- fixed lookup of members in structs defined in another scope

- preserve order of variable definitions in the Ast (and thus, the output)

.idea/dictionaries/irmen.xml

@@ -0,0 +1,3 @@
+<component name="ProjectDictionaryState">
+  <dictionary name="irmen" />
+</component>

.idea/inspectionProfiles/Project_Default.xml

@@ -0,0 +1,10 @@
+<component name="InspectionProjectProfileManager">
+  <profile version="1.0">
+    <option name="myName" value="Project Default" />
+    <inspection_tool class="SpellCheckingInspection" enabled="true" level="TYPO" enabled_by_default="true">
+      <option name="processCode" value="false" />
+      <option name="processLiterals" value="true" />
+      <option name="processComments" value="false" />
+    </inspection_tool>
+  </profile>
+</component>

README.md

@@ -21,6 +21,8 @@ which aims to provide many conveniences over raw assembly code (even when using
 - automatic variable allocations, automatic string variables and string sharing
 - constant folding in expressions (compile-time evaluation)
 - conditional branches
+- when statement to provide a 'jump table' alternative to if/elseif chains
+- structs to group together sets of variables and manipulate them at once
 - automatic type conversions
 - floating point operations  (uses the C64 Basic ROM routines for this)
 - abstracting away low level aspects such as ZeroPage handling, program startup, explicit memory addresses
@@ -33,7 +35,9 @@ Rapid edit-compile-run-debug cycle:
 - option to automatically run the program in the Vice emulator  
 - breakpoints, that let the Vice emulator drop into the monitor if execution hits them
 - source code labels automatically loaded in Vice emulator so it can show them in disassembly
-
+- the compiler includes a virtual machine that can execute compiled code directy on the
+  host system without having to actually convert it to assembly to run on a real 6502. 
+  This allows for very quick experimentation and debugging
 
 It is mainly targeted at the Commodore-64 machine at this time.
 Contributions to add support for other 8-bit (or other?!) machines are welcome.

compiler/build.gradle

@@ -1,21 +1,36 @@
-plugins {
-    id "org.jetbrains.kotlin.jvm" version "1.3.40"
-    id 'application'
-    id 'org.jetbrains.dokka' version "0.9.18"
+buildscript {
+    dependencies {
+        classpath "org.jetbrains.kotlin:kotlin-gradle-plugin:$kotlinVersion"
+    }
 }
 
+plugins {
+    // id "org.jetbrains.kotlin.jvm" version $kotlinVersion
+    id 'application'
+    id 'org.jetbrains.dokka' version "0.9.18"
+    id 'com.github.johnrengelman.shadow' version '5.1.0'
+    id 'java'
+}
+
+apply plugin: "kotlin"
+apply plugin: "java"
+
+
 repositories {
+    mavenLocal()
     mavenCentral()
     jcenter()
 }
 
-def kotlinVersion = '1.3.40'
+sourceCompatibility = 1.8
+
+def prog8version = rootProject.file('compiler/res/version.txt').text.trim()
 
 dependencies {
     implementation project(':parser')
     implementation "org.jetbrains.kotlin:kotlin-stdlib-jdk8:$kotlinVersion"
-    implementation "org.jetbrains.kotlin:kotlin-reflect:$kotlinVersion"
-    runtime "org.jetbrains.kotlin:kotlin-reflect:$kotlinVersion"
+    // implementation "org.jetbrains.kotlin:kotlin-reflect:$kotlinVersion"
+    // runtime "org.jetbrains.kotlin:kotlin-reflect:$kotlinVersion"
     runtime 'org.antlr:antlr4-runtime:4.7.2'
     runtime project(':parser')
 
@@ -29,6 +44,7 @@ dependencies {
 compileKotlin {
     kotlinOptions {
         jvmTarget = "1.8"
+        verbose = true
         // freeCompilerArgs += "-XXLanguage:+NewInference"
     }
 }
@@ -49,41 +65,27 @@ sourceSets {
     }
 }
 
-
+startScripts.enabled = true
 
 application {
     mainClassName = 'prog8.CompilerMainKt'
     applicationName = 'p8compile'
 }
 
-task p8vmScript(type: CreateStartScripts) {
-    mainClassName = "prog8.StackVmMainKt"
-    applicationName = "p8vm"
-    outputDir = new File(project.buildDir, 'scripts')
-    classpath = jar.outputs.files + project.configurations.runtime
+artifacts {
+    archives shadowJar
 }
 
-applicationDistribution.into("bin") {
-    from(p8vmScript)
-    fileMode = 0755
+
+// To create a fat-jar use the 'create_compiler_jar' script for now
+// @todo investigate https://imperceptiblethoughts.com/shadow/introduction/
+
+shadowJar {
+    baseName = 'prog8compiler'
+    version = prog8version
+    // minimize()
 }
 
-task fatJar(type: Jar) {
-    manifest {
-        attributes 'Main-Class': 'prog8.CompilerMainKt'
-    }
-    archiveBaseName = 'prog8compiler'
-    destinationDirectory = rootProject.projectDir
-    from {
-        project.configurations.runtime.collect { it.isDirectory() ? it : zipTree(it) }
-    }
-    with jar
-}
-// build.finalizedBy(fatJar)
-
-
-// Java target version
-sourceCompatibility = 1.8
 
 test {
     // Enable JUnit 5 (Gradle 4.6+).

compiler/compiler.iml

@@ -11,7 +11,6 @@
     <orderEntry type="jdk" jdkName="1.8" jdkType="JavaSDK" />
     <orderEntry type="sourceFolder" forTests="false" />
     <orderEntry type="library" name="KotlinJavaRuntime" level="project" />
-    <orderEntry type="library" name="KotlinJavaRuntime" level="project" />
     <orderEntry type="library" name="antlr-runtime-4.7.2" level="project" />
     <orderEntry type="module" module-name="parser" />
     <orderEntry type="library" name="unittest-libs" level="project" />

compiler/res/prog8lib/c64flt.p8

@@ -41,25 +41,25 @@
 ; note: for subtraction and division, the left operand is in fac2, the right operand in fac1.
 
 ; checked functions below:
-asmsub	MOVFM		(uword mflpt @ AY) -> clobbers(A,Y) -> ()	= $bba2		; load mflpt value from memory  in A/Y into fac1
-asmsub	FREADMEM	() -> clobbers(A,Y) -> ()			= $bba6		; load mflpt value from memory  in $22/$23 into fac1
-asmsub	CONUPK		(uword mflpt @ AY) -> clobbers(A,Y) -> ()	= $ba8c		; load mflpt value from memory  in A/Y into fac2
-asmsub	FAREADMEM	() -> clobbers(A,Y) -> ()			= $ba90		; load mflpt value from memory  in $22/$23 into fac2
-asmsub	MOVFA		() -> clobbers(A,X) -> ()			= $bbfc		; copy fac2 to fac1
-asmsub	MOVAF		() -> clobbers(A,X) -> ()			= $bc0c		; copy fac1 to fac2  (rounded)
-asmsub	MOVEF		() -> clobbers(A,X) -> ()			= $bc0f		; copy fac1 to fac2
-asmsub	MOVMF		(uword mflpt @ XY) -> clobbers(A,Y) -> ()	= $bbd4		; store fac1 to memory  X/Y as 5-byte mflpt
+asmsub	MOVFM		(uword mflpt @ AY) clobbers(A,Y)	= $bba2		; load mflpt value from memory  in A/Y into fac1
+asmsub	FREADMEM	() clobbers(A,Y)			= $bba6		; load mflpt value from memory  in $22/$23 into fac1
+asmsub	CONUPK		(uword mflpt @ AY) clobbers(A,Y)	= $ba8c		; load mflpt value from memory  in A/Y into fac2
+asmsub	FAREADMEM	() clobbers(A,Y)			= $ba90		; load mflpt value from memory  in $22/$23 into fac2
+asmsub	MOVFA		() clobbers(A,X)			= $bbfc		; copy fac2 to fac1
+asmsub	MOVAF		() clobbers(A,X)			= $bc0c		; copy fac1 to fac2  (rounded)
+asmsub	MOVEF		() clobbers(A,X)			= $bc0f		; copy fac1 to fac2
+asmsub	MOVMF		(uword mflpt @ XY) clobbers(A,Y)	= $bbd4		; store fac1 to memory  X/Y as 5-byte mflpt
 
 ; fac1-> signed word in Y/A (might throw ILLEGAL QUANTITY)
 ; (tip: use c64flt.FTOSWRDAY to get A/Y output; lo/hi switched to normal little endian order)
-asmsub	FTOSWORDYA	() -> clobbers(X) -> (ubyte @ Y, ubyte @ A)	= $b1aa
+asmsub	FTOSWORDYA	() clobbers(X) -> ubyte @ Y, ubyte @ A  = $b1aa
 
 ; fac1 -> unsigned word in Y/A (might throw ILLEGAL QUANTITY) (result also in $14/15)
 ; (tip: use c64flt.GETADRAY to get A/Y output; lo/hi switched to normal little endian order)
-asmsub	GETADR		() -> clobbers(X) -> (ubyte @ Y, ubyte @ A)	= $b7f7
+asmsub	GETADR		() clobbers(X) -> ubyte @ Y, ubyte @ A  = $b7f7
 
-asmsub	QINT		() -> clobbers(A,X,Y) -> ()			= $bc9b		; fac1 -> 4-byte signed integer in 98-101 ($62-$65), with the MSB FIRST.
-asmsub	AYINT		() -> clobbers(A,X,Y) -> ()			= $b1bf		; fac1-> signed word in 100-101 ($64-$65) MSB FIRST. (might throw ILLEGAL QUANTITY)
+asmsub	QINT		() clobbers(A,X,Y)			= $bc9b		; fac1 -> 4-byte signed integer in 98-101 ($62-$65), with the MSB FIRST.
+asmsub	AYINT		() clobbers(A,X,Y)			= $b1bf		; fac1-> signed word in 100-101 ($64-$65) MSB FIRST. (might throw ILLEGAL QUANTITY)
 
 ; GIVAYF: signed word in Y/A (note different lsb/msb order) -> float in fac1
 ; (tip: use c64flt.GIVAYFAY to use A/Y input; lo/hi switched to normal order)
@@ -67,50 +67,50 @@ asmsub	AYINT		() -> clobbers(A,X,Y) -> ()			= $b1bf		; fac1-> signed word in 100
 ; there is also c64flt.FREADS32  that reads from 98-101 ($62-$65) MSB FIRST
 ; there is also c64flt.FREADUS32  that reads from 98-101 ($62-$65) MSB FIRST
 ; there is also c64flt.FREADS24AXY  that reads signed int24 into fac1 from A/X/Y (lo/mid/hi bytes)
-asmsub	GIVAYF		(ubyte lo @ Y, ubyte hi @ A) -> clobbers(A,X,Y) -> ()	= $b391
+asmsub	GIVAYF		(ubyte lo @ Y, ubyte hi @ A) clobbers(A,X,Y)	= $b391
 
-asmsub	FREADUY		(ubyte value @ Y) -> clobbers(A,X,Y) -> ()	= $b3a2		; 8 bit unsigned Y -> float in fac1
-asmsub	FREADSA		(byte value @ A) -> clobbers(A,X,Y) -> ()	= $bc3c		; 8 bit signed A -> float in fac1
-asmsub	FREADSTR	(ubyte length @ A) -> clobbers(A,X,Y) -> ()	= $b7b5		; str -> fac1, $22/23 must point to string, A=string length
-asmsub	FPRINTLN	() -> clobbers(A,X,Y) -> ()			= $aabc		; print string of fac1, on one line (= with newline) destroys fac1.  (consider FOUT + STROUT as well)
-asmsub	FOUT		() -> clobbers(X) -> (uword @ AY)		= $bddd		; fac1 -> string, address returned in AY ($0100)
+asmsub	FREADUY		(ubyte value @ Y) clobbers(A,X,Y)	= $b3a2		; 8 bit unsigned Y -> float in fac1
+asmsub	FREADSA		(byte value @ A) clobbers(A,X,Y)	= $bc3c		; 8 bit signed A -> float in fac1
+asmsub	FREADSTR	(ubyte length @ A) clobbers(A,X,Y)	= $b7b5		; str -> fac1, $22/23 must point to string, A=string length
+asmsub	FPRINTLN	() clobbers(A,X,Y)			= $aabc		; print string of fac1, on one line (= with newline) destroys fac1.  (consider FOUT + STROUT as well)
+asmsub	FOUT		() clobbers(X) -> uword @ AY		= $bddd		; fac1 -> string, address returned in AY ($0100)
 
-asmsub	FADDH		() -> clobbers(A,X,Y) -> ()			= $b849		; fac1 += 0.5, for rounding- call this before INT
-asmsub	MUL10		() -> clobbers(A,X,Y) -> ()			= $bae2		; fac1 *= 10
-asmsub	DIV10		() -> clobbers(A,X,Y) -> ()			= $bafe		; fac1 /= 10 , CAUTION: result is always positive!
-asmsub	FCOMP		(uword mflpt @ AY) -> clobbers(X,Y) -> (ubyte @ A) = $bc5b		; A = compare fac1 to mflpt in A/Y, 0=equal 1=fac1 is greater, 255=fac1 is less than
+asmsub	FADDH		() clobbers(A,X,Y)			= $b849		; fac1 += 0.5, for rounding- call this before INT
+asmsub	MUL10		() clobbers(A,X,Y)			= $bae2		; fac1 *= 10
+asmsub	DIV10		() clobbers(A,X,Y)			= $bafe		; fac1 /= 10 , CAUTION: result is always positive!
+asmsub	FCOMP		(uword mflpt @ AY) clobbers(X,Y) -> ubyte @ A = $bc5b		; A = compare fac1 to mflpt in A/Y, 0=equal 1=fac1 is greater, 255=fac1 is less than
 
-asmsub	FADDT		() -> clobbers(A,X,Y) -> ()			= $b86a		; fac1 += fac2
-asmsub	FADD		(uword mflpt @ AY) -> clobbers(A,X,Y) -> ()	= $b867		; fac1 += mflpt value from A/Y
-asmsub	FSUBT		() -> clobbers(A,X,Y) -> ()			= $b853		; fac1 = fac2-fac1   mind the order of the operands
-asmsub	FSUB		(uword mflpt @ AY) -> clobbers(A,X,Y) -> ()	= $b850		; fac1 = mflpt from A/Y - fac1
-asmsub	FMULTT 		() -> clobbers(A,X,Y) -> ()			= $ba2b		; fac1 *= fac2
-asmsub	FMULT		(uword mflpt @ AY) -> clobbers(A,X,Y) -> ()	= $ba28		; fac1 *= mflpt value from A/Y
-asmsub	FDIVT 		() -> clobbers(A,X,Y) -> ()			= $bb12		; fac1 = fac2/fac1  (remainder in fac2)  mind the order of the operands
-asmsub	FDIV  		(uword mflpt @ AY) -> clobbers(A,X,Y) -> ()	= $bb0f		; fac1 = mflpt in A/Y / fac1  (remainder in fac2)
-asmsub	FPWRT		() -> clobbers(A,X,Y) -> ()			= $bf7b		; fac1 = fac2 ** fac1
-asmsub	FPWR		(uword mflpt @ AY) -> clobbers(A,X,Y) -> ()	= $bf78		; fac1 = fac2 ** mflpt from A/Y
+asmsub	FADDT		() clobbers(A,X,Y)			= $b86a		; fac1 += fac2
+asmsub	FADD		(uword mflpt @ AY) clobbers(A,X,Y)	= $b867		; fac1 += mflpt value from A/Y
+asmsub	FSUBT		() clobbers(A,X,Y)			= $b853		; fac1 = fac2-fac1   mind the order of the operands
+asmsub	FSUB		(uword mflpt @ AY) clobbers(A,X,Y)	= $b850		; fac1 = mflpt from A/Y - fac1
+asmsub	FMULTT 		() clobbers(A,X,Y)			= $ba2b		; fac1 *= fac2
+asmsub	FMULT		(uword mflpt @ AY) clobbers(A,X,Y)	= $ba28		; fac1 *= mflpt value from A/Y
+asmsub	FDIVT 		() clobbers(A,X,Y)			= $bb12		; fac1 = fac2/fac1  (remainder in fac2)  mind the order of the operands
+asmsub	FDIV  		(uword mflpt @ AY) clobbers(A,X,Y)	= $bb0f		; fac1 = mflpt in A/Y / fac1  (remainder in fac2)
+asmsub	FPWRT		() clobbers(A,X,Y)			= $bf7b		; fac1 = fac2 ** fac1
+asmsub	FPWR		(uword mflpt @ AY) clobbers(A,X,Y)	= $bf78		; fac1 = fac2 ** mflpt from A/Y
 
-asmsub	NOTOP		() -> clobbers(A,X,Y) -> ()			= $aed4		; fac1 = NOT(fac1)
-asmsub	INT		() -> clobbers(A,X,Y) -> ()			= $bccc		; INT() truncates, use FADDH first to round instead of trunc
-asmsub	LOG		() -> clobbers(A,X,Y) -> ()			= $b9ea		; fac1 = LN(fac1)  (natural log)
-asmsub	SGN		() -> clobbers(A,X,Y) -> ()			= $bc39		; fac1 = SGN(fac1), result of SIGN (-1, 0 or 1)
-asmsub	SIGN		() -> clobbers() -> (ubyte @ A)			= $bc2b		; SIGN(fac1) to A, $ff, $0, $1 for negative, zero, positive
-asmsub	ABS		() -> clobbers() -> ()				= $bc58		; fac1 = ABS(fac1)
-asmsub	SQR		() -> clobbers(A,X,Y) -> ()			= $bf71		; fac1 = SQRT(fac1)
-asmsub	SQRA		() -> clobbers(A,X,Y) -> ()			= $bf74		; fac1 = SQRT(fac2)
-asmsub	EXP		() -> clobbers(A,X,Y) -> ()			= $bfed		; fac1 = EXP(fac1)  (e ** fac1)
-asmsub	NEGOP		() -> clobbers(A) -> ()				= $bfb4		; switch the sign of fac1
-asmsub	RND		() -> clobbers(A,X,Y) -> ()			= $e097		; fac1 = RND(fac1) float random number generator
-asmsub	COS		() -> clobbers(A,X,Y) -> ()			= $e264		; fac1 = COS(fac1)
-asmsub	SIN		() -> clobbers(A,X,Y) -> ()			= $e26b		; fac1 = SIN(fac1)
-asmsub	TAN		() -> clobbers(A,X,Y) -> ()			= $e2b4		; fac1 = TAN(fac1)
-asmsub	ATN		() -> clobbers(A,X,Y) -> ()			= $e30e		; fac1 = ATN(fac1)
+asmsub	NOTOP		() clobbers(A,X,Y)			= $aed4		; fac1 = NOT(fac1)
+asmsub	INT		() clobbers(A,X,Y)			= $bccc		; INT() truncates, use FADDH first to round instead of trunc
+asmsub	LOG		() clobbers(A,X,Y)			= $b9ea		; fac1 = LN(fac1)  (natural log)
+asmsub	SGN		() clobbers(A,X,Y)			= $bc39		; fac1 = SGN(fac1), result of SIGN (-1, 0 or 1)
+asmsub	SIGN		() -> ubyte @ A				= $bc2b		; SIGN(fac1) to A, $ff, $0, $1 for negative, zero, positive
+asmsub	ABS		()					= $bc58		; fac1 = ABS(fac1)
+asmsub	SQR		() clobbers(A,X,Y)			= $bf71		; fac1 = SQRT(fac1)
+asmsub	SQRA		() clobbers(A,X,Y)			= $bf74		; fac1 = SQRT(fac2)
+asmsub	EXP		() clobbers(A,X,Y)			= $bfed		; fac1 = EXP(fac1)  (e ** fac1)
+asmsub	NEGOP		() clobbers(A)				= $bfb4		; switch the sign of fac1
+asmsub	RND		() clobbers(A,X,Y)			= $e097		; fac1 = RND(fac1) float random number generator
+asmsub	COS		() clobbers(A,X,Y)			= $e264		; fac1 = COS(fac1)
+asmsub	SIN		() clobbers(A,X,Y)			= $e26b		; fac1 = SIN(fac1)
+asmsub	TAN		() clobbers(A,X,Y)			= $e2b4		; fac1 = TAN(fac1)
+asmsub	ATN		() clobbers(A,X,Y)			= $e30e		; fac1 = ATN(fac1)
 
 
 
 
-asmsub  FREADS32  () -> clobbers(A,X,Y) -> ()  {
+asmsub  FREADS32  () clobbers(A,X,Y)  {
 	; ---- fac1 = signed int32 from $62-$65 big endian (MSB FIRST)
 	%asm {{
 		lda  $62
@@ -122,7 +122,7 @@ asmsub  FREADS32  () -> clobbers(A,X,Y) -> ()  {
 	}}
 }
 
-asmsub  FREADUS32  () -> clobbers(A,X,Y) -> ()  {
+asmsub  FREADUS32  () clobbers(A,X,Y)  {
 	; ---- fac1 = uint32 from $62-$65 big endian (MSB FIRST)
 	%asm {{
 		sec
@@ -132,7 +132,7 @@ asmsub  FREADUS32  () -> clobbers(A,X,Y) -> ()  {
 	}}
 }
 
-asmsub  FREADS24AXY  (ubyte lo @ A, ubyte mid @ X, ubyte hi @ Y) -> clobbers(A,X,Y) -> ()  {
+asmsub  FREADS24AXY  (ubyte lo @ A, ubyte mid @ X, ubyte hi @ Y) clobbers(A,X,Y)  {
 	; ---- fac1 = signed int24 (A/X/Y contain lo/mid/hi bytes)
 	;      note: there is no FREADU24AXY (unsigned), use FREADUS32 instead.
 	%asm {{
@@ -149,7 +149,7 @@ asmsub  FREADS24AXY  (ubyte lo @ A, ubyte mid @ X, ubyte hi @ Y) -> clobbers(A,X
 	}}
 }
 
-asmsub  GIVUAYFAY  (uword value @ AY) -> clobbers(A,X,Y) -> ()  {
+asmsub  GIVUAYFAY  (uword value @ AY) clobbers(A,X,Y)  {
 	; ---- unsigned 16 bit word in A/Y (lo/hi) to fac1
 	%asm {{
 		sty  $62
@@ -160,7 +160,7 @@ asmsub  GIVUAYFAY  (uword value @ AY) -> clobbers(A,X,Y) -> ()  {
 	}}
 }
 
-asmsub  GIVAYFAY  (uword value @ AY) -> clobbers(A,X,Y) -> ()  {
+asmsub  GIVAYFAY  (uword value @ AY) clobbers(A,X,Y)  {
 	; ---- signed 16 bit word in A/Y (lo/hi) to float in fac1
 	%asm {{
 		sta  c64.SCRATCH_ZPREG
@@ -170,7 +170,7 @@ asmsub  GIVAYFAY  (uword value @ AY) -> clobbers(A,X,Y) -> ()  {
 	}}
 }
 
-asmsub  FTOSWRDAY  () -> clobbers(X) -> (uword @ AY)  {
+asmsub  FTOSWRDAY  () clobbers(X) -> uword @ AY  {
 	; ---- fac1 to signed word in A/Y
 	%asm {{
 		jsr  FTOSWORDYA	; note the inverse Y/A order
@@ -181,7 +181,7 @@ asmsub  FTOSWRDAY  () -> clobbers(X) -> (uword @ AY)  {
 	}}
 }
 
-asmsub  GETADRAY  () -> clobbers(X) -> (uword @ AY)  {
+asmsub  GETADRAY  () clobbers(X) -> uword @ AY  {
 	; ---- fac1 to unsigned word in A/Y
 	%asm {{
 		jsr  GETADR		; this uses the inverse order, Y/A

compiler/res/prog8lib/c64lib.p8

@@ -63,8 +63,8 @@
 		&ubyte  SP6Y		= $d00d
 		&ubyte  SP7X		= $d00e
 		&ubyte  SP7Y		= $d00f
-		&ubyte[16]  SPXY		= $d000		; the 8 sprite X and Y registers as an array.
-		&uword[8]  SPXYW		= $d000		; the 8 sprite X and Y registers as a combined xy word array.
+		&ubyte[16]  SPXY	= $d000		; the 8 sprite X and Y registers as an array.
+		&uword[8]  SPXYW	= $d000		; the 8 sprite X and Y registers as a combined xy word array.
 
 		&ubyte  MSIGX		= $d010
 		&ubyte  SCROLY		= $d011
@@ -76,7 +76,7 @@
 		&ubyte  YXPAND		= $d017
 		&ubyte  VMCSB		= $d018
 		&ubyte  VICIRQ		= $d019
-		&ubyte  IREQMASK		= $d01a
+		&ubyte  IREQMASK	= $d01a
 		&ubyte  SPBGPR		= $d01b
 		&ubyte  SPMC		= $d01c
 		&ubyte  XXPAND		= $d01d
@@ -98,7 +98,7 @@
 		&ubyte  SP5COL		= $d02c
 		&ubyte  SP6COL		= $d02d
 		&ubyte  SP7COL		= $d02e
-		&ubyte[8]  SPCOL		= $d027
+		&ubyte[8]  SPCOL	= $d027
 
 
 ; ---- end of VIC-II registers ----
@@ -107,8 +107,8 @@
 
 		&ubyte  CIA1PRA		= $DC00		; CIA 1 DRA, keyboard column drive (and joystick control port #2)
 		&ubyte  CIA1PRB		= $DC01		; CIA 1 DRB, keyboard row port (and joystick control port #1)
-		&ubyte  CIA1DDRA		= $DC02		; CIA 1 DDRA, keyboard column
-		&ubyte  CIA1DDRB		= $DC03		; CIA 1 DDRB, keyboard row
+		&ubyte  CIA1DDRA	= $DC02		; CIA 1 DDRA, keyboard column
+		&ubyte  CIA1DDRB	= $DC03		; CIA 1 DDRB, keyboard row
 		&ubyte  CIA1TAL		= $DC04		; CIA 1 timer A low byte
 		&ubyte  CIA1TAH		= $DC05		; CIA 1 timer A high byte
 		&ubyte  CIA1TBL		= $DC06		; CIA 1 timer B low byte
@@ -124,8 +124,8 @@
 
 		&ubyte  CIA2PRA		= $DD00		; CIA 2 DRA, serial port and video address
 		&ubyte  CIA2PRB		= $DD01		; CIA 2 DRB, RS232 port / USERPORT
-		&ubyte  CIA2DDRA		= $DD02		; CIA 2 DDRA, serial port and video address
-		&ubyte  CIA2DDRB		= $DD03		; CIA 2 DDRB, RS232 port / USERPORT
+		&ubyte  CIA2DDRA	= $DD02		; CIA 2 DDRA, serial port and video address
+		&ubyte  CIA2DDRB	= $DD03		; CIA 2 DDRB, RS232 port / USERPORT
 		&ubyte  CIA2TAL		= $DD04		; CIA 2 timer A low byte
 		&ubyte  CIA2TAH		= $DD05		; CIA 2 timer A high byte
 		&ubyte  CIA2TBL		= $DD06		; CIA 2 timer B low byte
@@ -186,8 +186,8 @@
 
 ; ---- C64 basic routines ----
 
-asmsub	CLEARSCR	() -> clobbers(A,X,Y) -> ()		= $E544		; clear the screen
-asmsub	HOMECRSR	() -> clobbers(A,X,Y) -> ()		= $E566		; cursor to top left of screen
+asmsub	CLEARSCR	() clobbers(A,X,Y)		= $E544		; clear the screen
+asmsub	HOMECRSR	() clobbers(A,X,Y)		= $E566		; cursor to top left of screen
 
 
 ; ---- end of C64 basic routines ----
@@ -195,48 +195,48 @@ asmsub	HOMECRSR	() -> clobbers(A,X,Y) -> ()		= $E566		; cursor to top left of sc
 
 ; ---- C64 kernal routines ----
 
-asmsub	STROUT   (uword strptr @ AY) -> clobbers(A, X, Y) -> ()	= $AB1E		; print null-terminated string (use c64scr.print instead)
-asmsub	IRQDFRT  () -> clobbers(A,X,Y) -> ()			= $EA31		; default IRQ routine
-asmsub	IRQDFEND () -> clobbers(A,X,Y) -> ()			= $EA81		; default IRQ end/cleanup
-asmsub	CINT     () -> clobbers(A,X,Y) -> ()			= $FF81		; (alias: SCINIT) initialize screen editor and video chip
-asmsub	IOINIT   () -> clobbers(A, X) -> ()			= $FF84		; initialize I/O devices (CIA, SID, IRQ)
-asmsub	RAMTAS   () -> clobbers(A,X,Y) -> ()			= $FF87		; initialize RAM, tape buffer, screen
-asmsub	RESTOR   () -> clobbers(A,X,Y) -> ()			= $FF8A		; restore default I/O vectors
-asmsub	VECTOR   (ubyte dir @ Pc, uword userptr @ XY) -> clobbers(A,Y) -> ()	= $FF8D		; read/set I/O vector table
-asmsub	SETMSG   (ubyte value @ A) -> clobbers() -> ()		= $FF90		; set Kernal message control flag
-asmsub	SECOND   (ubyte address @ A) -> clobbers(A) -> ()	= $FF93		; (alias: LSTNSA) send secondary address after LISTEN
-asmsub	TKSA     (ubyte address @ A) -> clobbers(A) -> ()	= $FF96		; (alias: TALKSA) send secondary address after TALK
-asmsub	MEMTOP   (ubyte dir @ Pc, uword address @ XY) -> clobbers() -> (uword @ XY)	= $FF99		; read/set top of memory  pointer
-asmsub	MEMBOT   (ubyte dir @ Pc, uword address @ XY) -> clobbers() -> (uword @ XY)	= $FF9C		; read/set bottom of memory  pointer
-asmsub	SCNKEY   () -> clobbers(A,X,Y) -> ()			= $FF9F		; scan the keyboard
-asmsub	SETTMO   (ubyte timeout @ A) -> clobbers() -> ()	= $FFA2		; set time-out flag for IEEE bus
-asmsub	ACPTR    () -> clobbers() -> (ubyte @ A)			= $FFA5		; (alias: IECIN) input byte from serial bus
-asmsub	CIOUT    (ubyte databyte @ A) -> clobbers() -> ()	= $FFA8		; (alias: IECOUT) output byte to serial bus
-asmsub	UNTLK    () -> clobbers(A) -> ()			= $FFAB		; command serial bus device to UNTALK
-asmsub	UNLSN    () -> clobbers(A) -> ()			= $FFAE		; command serial bus device to UNLISTEN
-asmsub	LISTEN   (ubyte device @ A) -> clobbers(A) -> ()	= $FFB1		; command serial bus device to LISTEN
-asmsub	TALK     (ubyte device @ A) -> clobbers(A) -> ()	= $FFB4		; command serial bus device to TALK
-asmsub	READST   () -> clobbers() -> (ubyte @ A)			= $FFB7		; read I/O status word
-asmsub	SETLFS   (ubyte logical @ A, ubyte device @ X, ubyte address @ Y) -> clobbers() -> () = $FFBA	; set logical file parameters
-asmsub	SETNAM   (ubyte namelen @ A, str filename @ XY) -> clobbers() -> ()	= $FFBD		; set filename parameters
-asmsub	OPEN     () -> clobbers(A,X,Y) -> ()			= $FFC0		; (via 794 ($31A)) open a logical file
-asmsub	CLOSE    (ubyte logical @ A) -> clobbers(A,X,Y) -> ()	= $FFC3		; (via 796 ($31C)) close a logical file
-asmsub	CHKIN    (ubyte logical @ X) -> clobbers(A,X) -> ()	= $FFC6		; (via 798 ($31E)) define an input channel
-asmsub	CHKOUT   (ubyte logical @ X) -> clobbers(A,X) -> ()	= $FFC9		; (via 800 ($320)) define an output channel
-asmsub	CLRCHN   () -> clobbers(A,X) -> ()			= $FFCC		; (via 802 ($322)) restore default devices
-asmsub	CHRIN    () -> clobbers(Y) -> (ubyte @ A)		= $FFCF		; (via 804 ($324)) input a character (for keyboard, read a whole line from the screen) A=byte read.
-asmsub	CHROUT   (ubyte char @ A) -> clobbers() -> ()		= $FFD2		; (via 806 ($326)) output a character
-asmsub	LOAD     (ubyte verify @ A, uword address @ XY) -> clobbers() -> (ubyte @Pc, ubyte @ A, ubyte @ X, ubyte @ Y) = $FFD5	; (via 816 ($330)) load from device
-asmsub	SAVE     (ubyte zp_startaddr @ A, uword endaddr @ XY) -> clobbers() -> (ubyte @ Pc, ubyte @ A) = $FFD8	; (via 818 ($332)) save to a device
-asmsub	SETTIM   (ubyte low @ A, ubyte middle @ X, ubyte high @ Y) -> clobbers() -> ()	= $FFDB		; set the software clock
-asmsub	RDTIM    () -> clobbers() -> (ubyte @ A, ubyte @ X, ubyte @ Y) = $FFDE	; read the software clock
-asmsub	STOP     () -> clobbers(A,X) -> (ubyte @ Pz, ubyte @ Pc)	= $FFE1		; (via 808 ($328)) check the STOP key
-asmsub	GETIN    () -> clobbers(X,Y) -> (ubyte @ A)		= $FFE4		; (via 810 ($32A)) get a character
-asmsub	CLALL    () -> clobbers(A,X) -> ()			= $FFE7		; (via 812 ($32C)) close all files
-asmsub	UDTIM    () -> clobbers(A,X) -> ()			= $FFEA		; update the software clock
-asmsub	SCREEN   () -> clobbers() -> (ubyte @ X, ubyte @ Y)	= $FFED		; read number of screen rows and columns
-asmsub	PLOT     (ubyte dir @ Pc, ubyte col @ Y, ubyte row @ X) -> clobbers() -> (ubyte @ X, ubyte @ Y)	= $FFF0		; read/set position of cursor on screen.  Use c64scr.plot for a 'safe' wrapper that preserves X.
-asmsub	IOBASE   () -> clobbers() -> (uword @ XY)		= $FFF3		; read base address of I/O devices
+asmsub	STROUT   (uword strptr @ AY) clobbers(A, X, Y)	= $AB1E		; print null-terminated string (use c64scr.print instead)
+asmsub	IRQDFRT  () clobbers(A,X,Y)			= $EA31		; default IRQ routine
+asmsub	IRQDFEND () clobbers(A,X,Y)			= $EA81		; default IRQ end/cleanup
+asmsub	CINT     () clobbers(A,X,Y)			= $FF81		; (alias: SCINIT) initialize screen editor and video chip
+asmsub	IOINIT   () clobbers(A, X)			= $FF84		; initialize I/O devices (CIA, SID, IRQ)
+asmsub	RAMTAS   () clobbers(A,X,Y)			= $FF87		; initialize RAM, tape buffer, screen
+asmsub	RESTOR   () clobbers(A,X,Y)			= $FF8A		; restore default I/O vectors
+asmsub	VECTOR   (ubyte dir @ Pc, uword userptr @ XY) clobbers(A,Y)  = $FF8D		; read/set I/O vector table
+asmsub	SETMSG   (ubyte value @ A)			= $FF90		; set Kernal message control flag
+asmsub	SECOND   (ubyte address @ A) clobbers(A)	= $FF93		; (alias: LSTNSA) send secondary address after LISTEN
+asmsub	TKSA     (ubyte address @ A) clobbers(A)	= $FF96		; (alias: TALKSA) send secondary address after TALK
+asmsub	MEMTOP   (ubyte dir @ Pc, uword address @ XY) -> uword @ XY	= $FF99		; read/set top of memory  pointer
+asmsub	MEMBOT   (ubyte dir @ Pc, uword address @ XY) -> uword @ XY	= $FF9C		; read/set bottom of memory  pointer
+asmsub	SCNKEY   () clobbers(A,X,Y)			= $FF9F		; scan the keyboard
+asmsub	SETTMO   (ubyte timeout @ A)			= $FFA2		; set time-out flag for IEEE bus
+asmsub	ACPTR    () -> ubyte @ A			= $FFA5		; (alias: IECIN) input byte from serial bus
+asmsub	CIOUT    (ubyte databyte @ A)			= $FFA8		; (alias: IECOUT) output byte to serial bus
+asmsub	UNTLK    () clobbers(A)				= $FFAB		; command serial bus device to UNTALK
+asmsub	UNLSN    () clobbers(A)				= $FFAE		; command serial bus device to UNLISTEN
+asmsub	LISTEN   (ubyte device @ A) clobbers(A)		= $FFB1		; command serial bus device to LISTEN
+asmsub	TALK     (ubyte device @ A) clobbers(A)		= $FFB4		; command serial bus device to TALK
+asmsub	READST   () -> ubyte @ A			= $FFB7		; read I/O status word
+asmsub	SETLFS   (ubyte logical @ A, ubyte device @ X, ubyte address @ Y) = $FFBA	; set logical file parameters
+asmsub	SETNAM   (ubyte namelen @ A, str filename @ XY)	= $FFBD		; set filename parameters
+asmsub	OPEN     () clobbers(A,X,Y)			= $FFC0		; (via 794 ($31A)) open a logical file
+asmsub	CLOSE    (ubyte logical @ A) clobbers(A,X,Y)	= $FFC3		; (via 796 ($31C)) close a logical file
+asmsub	CHKIN    (ubyte logical @ X) clobbers(A,X)	= $FFC6		; (via 798 ($31E)) define an input channel
+asmsub	CHKOUT   (ubyte logical @ X) clobbers(A,X)	= $FFC9		; (via 800 ($320)) define an output channel
+asmsub	CLRCHN   () clobbers(A,X)			= $FFCC		; (via 802 ($322)) restore default devices
+asmsub	CHRIN    () clobbers(Y) -> ubyte @ A		= $FFCF		; (via 804 ($324)) input a character (for keyboard, read a whole line from the screen) A=byte read.
+asmsub	CHROUT   (ubyte char @ A)			= $FFD2		; (via 806 ($326)) output a character
+asmsub	LOAD     (ubyte verify @ A, uword address @ XY) -> ubyte @Pc, ubyte @ A, ubyte @ X, ubyte @ Y = $FFD5	; (via 816 ($330)) load from device
+asmsub	SAVE     (ubyte zp_startaddr @ A, uword endaddr @ XY) -> ubyte @ Pc, ubyte @ A = $FFD8	; (via 818 ($332)) save to a device
+asmsub	SETTIM   (ubyte low @ A, ubyte middle @ X, ubyte high @ Y)	= $FFDB		; set the software clock
+asmsub	RDTIM    () -> ubyte @ A, ubyte @ X, ubyte @ Y	= $FFDE	; read the software clock
+asmsub	STOP     () clobbers(A,X) -> ubyte @ Pz, ubyte @ Pc	= $FFE1		; (via 808 ($328)) check the STOP key
+asmsub	GETIN    () clobbers(X,Y) -> ubyte @ A		= $FFE4		; (via 810 ($32A)) get a character
+asmsub	CLALL    () clobbers(A,X)			= $FFE7		; (via 812 ($32C)) close all files
+asmsub	UDTIM    () clobbers(A,X)			= $FFEA		; update the software clock
+asmsub	SCREEN   () -> ubyte @ X, ubyte @ Y		= $FFED		; read number of screen rows and columns
+asmsub	PLOT     (ubyte dir @ Pc, ubyte col @ Y, ubyte row @ X) -> ubyte @ X, ubyte @ Y	= $FFF0		; read/set position of cursor on screen.  Use c64scr.plot for a 'safe' wrapper that preserves X.
+asmsub	IOBASE   () -> uword @ XY			= $FFF3		; read base address of I/O devices
 
 ; ---- end of C64 kernal routines ----
 

compiler/res/prog8lib/c64utils.p8

@@ -17,7 +17,7 @@
 
 ; ----- utility functions ----
 
-asmsub  ubyte2decimal  (ubyte value @ A) -> clobbers() -> (ubyte @ Y, ubyte @ X, ubyte @ A)  {
+asmsub  ubyte2decimal  (ubyte value @ A) -> ubyte @ Y, ubyte @ X, ubyte @ A  {
 	; ---- A to decimal string in Y/X/A  (100s in Y, 10s in X, 1s in A)
 	%asm {{
 		ldy  #$2f
@@ -34,7 +34,7 @@ asmsub  ubyte2decimal  (ubyte value @ A) -> clobbers() -> (ubyte @ Y, ubyte @ X,
 	}}
 }
 
-asmsub  byte2decimal  (ubyte value @ A) -> clobbers() -> (ubyte @ Y, ubyte @ X, ubyte @ A)  {
+asmsub  byte2decimal  (ubyte value @ A) -> ubyte @ Y, ubyte @ X, ubyte @ A  {
 	; ---- A (signed byte) to decimal string in Y/X/A  (100s in Y, 10s in X, 1s in A)
 	;      note: the '-' is not part of the conversion here if it's a negative number
 	%asm {{
@@ -47,7 +47,7 @@ asmsub  byte2decimal  (ubyte value @ A) -> clobbers() -> (ubyte @ Y, ubyte @ X,
 	}}
 }
 
-asmsub  ubyte2hex  (ubyte value @ A) -> clobbers() -> (ubyte @ A, ubyte @ Y)  {
+asmsub  ubyte2hex  (ubyte value @ A) -> ubyte @ A, ubyte @ Y  {
 	; ---- A to hex string in AY (first hex char in A, second hex char in Y)
 	%asm {{
 		stx  c64.SCRATCH_ZPREGX
@@ -70,7 +70,7 @@ _hex_digits	.text "0123456789abcdef"	; can probably be reused for other stuff as
 }
 
 
-asmsub  uword2hex  (uword value @ AY) -> clobbers(A,Y) -> ()  {
+asmsub  uword2hex  (uword value @ AY) clobbers(A,Y)  {
 	; ---- convert 16 bit uword in A/Y into 4-character hexadecimal string 'uword2hex.output' (0-terminated)
 	%asm {{
 		sta  c64.SCRATCH_ZPREG
@@ -87,7 +87,7 @@ output	.text  "0000", $00      ; 0-terminated output buffer (to make printing ea
 	}}
 }
 
-asmsub  uword2bcd  (uword value @ AY) -> clobbers(A,Y) -> ()  {
+asmsub  uword2bcd  (uword value @ AY) clobbers(A,Y)  {
 	; Convert an 16 bit binary value to BCD
 	;
 	; This function converts a 16 bit binary value in A/Y into a 24 bit BCD. It
@@ -134,7 +134,7 @@ bcdbuff  .byte  0,0,0
 }
 
 
-asmsub  uword2decimal  (uword value @ AY) -> clobbers(A) -> (ubyte @ Y)  {
+asmsub  uword2decimal  (uword value @ AY) clobbers(A) -> ubyte @ Y  {
 	; ---- convert 16 bit uword in A/Y into 0-terminated decimal string into memory  'uword2decimal.output'
 	;      returns length of resulting string in Y
 	%asm {{
@@ -173,7 +173,7 @@ output  .text  "00000", $00     ; 0 terminated
 }
 
 
-asmsub str2uword(str string @ AY) -> clobbers() -> (uword @ AY) {
+asmsub str2uword(str string @ AY) -> uword @ AY {
 	; -- returns the unsigned word value of the string number argument in AY
 	;    the number may NOT be preceded by a + sign and may NOT contain spaces
 	;    (any non-digit character will terminate the number string that is parsed)
@@ -228,7 +228,7 @@ _result_times_10     ; (W*4 + W)*2
 }
 
 
-asmsub str2word(str string @ AY) -> clobbers() -> (word @ AY) {
+asmsub str2word(str string @ AY) -> word @ AY {
 	; -- returns the signed word value of the string number argument in AY
 	;    the number may be preceded by a + or - sign but may NOT contain spaces
 	;    (any non-digit character will terminate the number string that is parsed)
@@ -284,7 +284,7 @@ _negative	.byte  0
 }
 
 
-asmsub  set_irqvec_excl() -> clobbers(A) -> ()  {
+asmsub  set_irqvec_excl() clobbers(A)  {
 	%asm {{
 		sei
 		lda  #<_irq_handler
@@ -303,7 +303,7 @@ _irq_handler	jsr  set_irqvec._irq_handler_init
 	}}
 }
 
-asmsub  set_irqvec() -> clobbers(A) -> ()  {
+asmsub  set_irqvec() clobbers(A)  {
 	%asm {{
 		sei
 		lda  #<_irq_handler
@@ -373,7 +373,7 @@ IRQ_SCRATCH_ZPWORD2	.word  0
 }
 
 
-asmsub  restore_irqvec() -> clobbers() -> () {
+asmsub  restore_irqvec() {
 	%asm {{
 		sei
 		lda  #<c64.IRQDFRT
@@ -390,7 +390,7 @@ asmsub  restore_irqvec() -> clobbers() -> () {
 }
 
 
-asmsub  set_rasterirq(uword rasterpos @ AY) -> clobbers(A) -> () {
+asmsub  set_rasterirq(uword rasterpos @ AY) clobbers(A) {
 	%asm {{
 		sei
 		jsr  _setup_raster_irq
@@ -431,7 +431,7 @@ _setup_raster_irq
 	}}
 }
 
-asmsub  set_rasterirq_excl(uword rasterpos @ AY) -> clobbers(A) -> () {
+asmsub  set_rasterirq_excl(uword rasterpos @ AY) clobbers(A) {
 	%asm {{
 		sei
 		jsr  set_rasterirq._setup_raster_irq
@@ -465,7 +465,7 @@ _raster_irq_handler
 	; ---- this block contains (character) Screen and text I/O related functions ----
 
 
-asmsub  clear_screen (ubyte char @ A, ubyte color @ Y) -> clobbers(A) -> ()  {
+asmsub  clear_screen (ubyte char @ A, ubyte color @ Y) clobbers(A)  {
 	; ---- clear the character screen with the given fill character and character color.
 	;      (assumes screen and color matrix are at their default addresses)
 
@@ -481,7 +481,7 @@ asmsub  clear_screen (ubyte char @ A, ubyte color @ Y) -> clobbers(A) -> ()  {
 }
 
 
-asmsub  clear_screenchars (ubyte char @ A) -> clobbers(Y) -> ()  {
+asmsub  clear_screenchars (ubyte char @ A) clobbers(Y)  {
 	; ---- clear the character screen with the given fill character (leaves colors)
 	;      (assumes screen matrix is at the default address)
 	%asm {{
@@ -501,7 +501,7 @@ _loop		sta  c64.Screen,y
         }}
 }
 
-asmsub  clear_screencolors (ubyte color @ A) -> clobbers(Y) -> ()  {
+asmsub  clear_screencolors (ubyte color @ A) clobbers(Y)  {
 	; ---- clear the character screen colors with the given color (leaves characters).
 	;      (assumes color matrix is at the default address)
 	%asm {{
@@ -522,7 +522,7 @@ _loop		sta  c64.Colors,y
 }
 
 
-asmsub  scroll_left_full  (ubyte alsocolors @ Pc) -> clobbers(A, Y) -> ()  {
+asmsub  scroll_left_full  (ubyte alsocolors @ Pc) clobbers(A, Y)  {
 	; ---- scroll the whole screen 1 character to the left
 	;      contents of the rightmost column are unchanged, you should clear/refill this yourself
 	;      Carry flag determines if screen color data must be scrolled too
@@ -583,7 +583,7 @@ _scroll_screen  ; scroll the screen memory
 }
 
 
-asmsub  scroll_right_full  (ubyte alsocolors @ Pc) -> clobbers(A) -> ()  {
+asmsub  scroll_right_full  (ubyte alsocolors @ Pc) clobbers(A)  {
 	; ---- scroll the whole screen 1 character to the right
 	;      contents of the leftmost column are unchanged, you should clear/refill this yourself
 	;      Carry flag determines if screen color data must be scrolled too
@@ -636,7 +636,7 @@ _scroll_screen  ; scroll the screen memory
 }
 
 
-asmsub  scroll_up_full  (ubyte alsocolors @ Pc) -> clobbers(A) -> ()  {
+asmsub  scroll_up_full  (ubyte alsocolors @ Pc) clobbers(A)  {
 	; ---- scroll the whole screen 1 character up
 	;      contents of the bottom row are unchanged, you should refill/clear this yourself
 	;      Carry flag determines if screen color data must be scrolled too
@@ -689,7 +689,7 @@ _scroll_screen  ; scroll the screen memory
 }
 
 
-asmsub  scroll_down_full  (ubyte alsocolors @ Pc) -> clobbers(A) -> ()  {
+asmsub  scroll_down_full  (ubyte alsocolors @ Pc) clobbers(A)  {
 	; ---- scroll the whole screen 1 character down
 	;      contents of the top row are unchanged, you should refill/clear this yourself
 	;      Carry flag determines if screen color data must be scrolled too
@@ -743,7 +743,7 @@ _scroll_screen  ; scroll the screen memory
 
 
 
-asmsub  print (str text @ AY) -> clobbers(A,Y) -> ()  {
+asmsub  print (str text @ AY) clobbers(A,Y)  {
 	; ---- print null terminated string from A/Y
 	; note: the compiler contains an optimization that will replace
 	;       a call to this subroutine with a string argument of just one char,
@@ -762,7 +762,7 @@ asmsub  print (str text @ AY) -> clobbers(A,Y) -> ()  {
 }
 
 
-asmsub  print_ub0  (ubyte value @ A) -> clobbers(A,Y) -> ()  {
+asmsub  print_ub0  (ubyte value @ A) clobbers(A,Y)  {
 	; ---- print the ubyte in A in decimal form, with left padding 0s (3 positions total)
 	%asm {{
 		stx  c64.SCRATCH_ZPREGX
@@ -780,7 +780,7 @@ asmsub  print_ub0  (ubyte value @ A) -> clobbers(A,Y) -> ()  {
 }
 
 
-asmsub  print_ub  (ubyte value @ A) -> clobbers(A,Y) -> ()  {
+asmsub  print_ub  (ubyte value @ A) clobbers(A,Y)  {
 	; ---- print the ubyte in A in decimal form, without left padding 0s
 	%asm {{
 		stx  c64.SCRATCH_ZPREGX
@@ -803,7 +803,7 @@ _end		pla
 	}}
 }
 
-asmsub  print_b  (byte value @ A) -> clobbers(A,Y) -> ()  {
+asmsub  print_b  (byte value @ A) clobbers(A,Y)  {
 	; ---- print the byte in A in decimal form, without left padding 0s
 	%asm {{
 		stx  c64.SCRATCH_ZPREGX
@@ -821,7 +821,7 @@ asmsub  print_b  (byte value @ A) -> clobbers(A,Y) -> ()  {
 }
 
 
-asmsub  print_ubhex  (ubyte prefix @ Pc, ubyte value @ A) -> clobbers(A,Y) -> ()  {
+asmsub  print_ubhex  (ubyte prefix @ Pc, ubyte value @ A) clobbers(A,Y)  {
 	; ---- print the ubyte in A in hex form (if Carry is set, a radix prefix '$' is printed as well)
 	%asm {{
 		stx  c64.SCRATCH_ZPREGX
@@ -840,7 +840,7 @@ asmsub  print_ubhex  (ubyte prefix @ Pc, ubyte value @ A) -> clobbers(A,Y) -> ()
 }
 
 
-asmsub  print_ubbin  (ubyte prefix @ Pc, ubyte value @ A) -> clobbers(A,Y) ->()  {
+asmsub  print_ubbin  (ubyte prefix @ Pc, ubyte value @ A) clobbers(A,Y)  {
 	; ---- print the ubyte in A in binary form (if Carry is set, a radix prefix '%' is printed as well)
 	%asm {{
 		stx  c64.SCRATCH_ZPREGX
@@ -862,7 +862,7 @@ asmsub  print_ubbin  (ubyte prefix @ Pc, ubyte value @ A) -> clobbers(A,Y) ->()
 }
 
 
-asmsub  print_uwbin  (ubyte prefix @ Pc, uword value @ AY) -> clobbers(A,Y) ->()  {
+asmsub  print_uwbin  (ubyte prefix @ Pc, uword value @ AY) clobbers(A,Y)  {
 	; ---- print the uword in A/Y in binary form (if Carry is set, a radix prefix '%' is printed as well)
 	%asm {{
 		pha
@@ -875,7 +875,7 @@ asmsub  print_uwbin  (ubyte prefix @ Pc, uword value @ AY) -> clobbers(A,Y) ->()
 }
 
 
-asmsub print_uwhex  (ubyte prefix @ Pc, uword value @ AY) -> clobbers(A,Y) -> ()  {
+asmsub print_uwhex  (ubyte prefix @ Pc, uword value @ AY) clobbers(A,Y)  {
 	; ---- print the uword in A/Y in hexadecimal form (4 digits)
 	;      (if Carry is set, a radix prefix '$' is printed as well)
 	%asm {{
@@ -889,7 +889,7 @@ asmsub print_uwhex  (ubyte prefix @ Pc, uword value @ AY) -> clobbers(A,Y) -> ()
 }
 
 
-asmsub  print_uw0  (uword value @ AY) -> clobbers(A,Y) -> ()  {
+asmsub  print_uw0  (uword value @ AY) clobbers(A,Y)  {
 	; ---- print the uword in A/Y in decimal form, with left padding 0s (5 positions total)
 	%asm {{
 		jsr  c64utils.uword2decimal
@@ -904,7 +904,7 @@ asmsub  print_uw0  (uword value @ AY) -> clobbers(A,Y) -> ()  {
 }
 
 
-asmsub  print_uw  (uword value @ AY) -> clobbers(A,Y) -> ()  {
+asmsub  print_uw  (uword value @ AY) clobbers(A,Y)  {
 	; ---- print the uword in A/Y in decimal form, without left padding 0s
 	%asm {{
 		jsr  c64utils.uword2decimal
@@ -936,7 +936,7 @@ _pr_decimal
 	}}
 }
 
-asmsub  print_w  (word value @ AY) -> clobbers(A,Y) -> ()  {
+asmsub  print_w  (word value @ AY) clobbers(A,Y)  {
 	; ---- print the (signed) word in A/Y in decimal form, without left padding 0's
 	%asm {{
 		cpy  #0
@@ -957,7 +957,7 @@ asmsub  print_w  (word value @ AY) -> clobbers(A,Y) -> ()  {
 	}}
 }
 
-asmsub  input_chars  (uword buffer @ AY) -> clobbers(A) -> (ubyte @ Y)  {
+asmsub  input_chars  (uword buffer @ AY) clobbers(A) -> ubyte @ Y  {
 	; ---- Input a string (max. 80 chars) from the keyboard. Returns length in Y. (string is terminated with a 0 byte as well)
 	;      It assumes the keyboard is selected as I/O channel!
 
@@ -978,7 +978,7 @@ asmsub  input_chars  (uword buffer @ AY) -> clobbers(A) -> (ubyte @ Y)  {
 	}}
 }
 
-asmsub  setchr  (ubyte col @Y, ubyte row @A) -> clobbers(A) -> ()  {
+asmsub  setchr  (ubyte col @Y, ubyte row @A) clobbers(A)  {
 	; ---- set the character in SCRATCH_ZPB1 on the screen matrix at the given position
 	%asm {{
 		sty  c64.SCRATCH_ZPREG
@@ -1000,7 +1000,7 @@ _screenrows	.word  $0400 + range(0, 1000, 40)
 	}}
 }
 
-asmsub  getchr  (ubyte col @Y, ubyte row @A) -> clobbers(Y) -> (ubyte @ A) {
+asmsub  getchr  (ubyte col @Y, ubyte row @A) clobbers(Y) -> ubyte @ A {
 	; ---- get the character in the screen matrix at the given location
 	%asm  {{
 		sty  c64.SCRATCH_ZPB1
@@ -1019,7 +1019,7 @@ _mod		lda  $ffff		; modified
 	}}
 }
 
-asmsub  setclr  (ubyte col @Y, ubyte row @A) -> clobbers(A) -> ()  {
+asmsub  setclr  (ubyte col @Y, ubyte row @A) clobbers(A)  {
 	; ---- set the color in SCRATCH_ZPB1 on the screen matrix at the given position
 	%asm {{
 		sty  c64.SCRATCH_ZPREG
@@ -1041,7 +1041,7 @@ _colorrows	.word  $d800 + range(0, 1000, 40)
 	}}
 }
 
-asmsub  getclr  (ubyte col @Y, ubyte row @A) -> clobbers(Y) -> (ubyte @ A) {
+asmsub  getclr  (ubyte col @Y, ubyte row @A) clobbers(Y) -> ubyte @ A {
 	; ---- get the color in the screen color matrix at the given location
 	%asm  {{
 		sty  c64.SCRATCH_ZPB1
@@ -1086,7 +1086,7 @@ _colormod	sta  $ffff		; modified
 	}}
 }
 
-asmsub  plot  (ubyte col @ Y, ubyte row @ A) -> clobbers(A) -> () {
+asmsub  plot  (ubyte col @ Y, ubyte row @ A) clobbers(A) {
 	; ---- safe wrapper around PLOT kernel routine, to save the X register.
 	%asm  {{
 		stx  c64.SCRATCH_ZPREGX

compiler/res/version.txt

@@ -1 +1 @@
-1.8
+1.11

compiler/src/prog8/CompilerMain.kt

@@ -1,23 +1,10 @@
 package prog8
 
-import prog8.ast.*
-import prog8.astvm.AstVm
+import prog8.vm.astvm.AstVm
+import prog8.vm.stackvm.stackVmMain
 import prog8.compiler.*
-import prog8.compiler.target.c64.AsmGen
-import prog8.compiler.target.c64.C64Zeropage
-import prog8.optimizing.constantFold
-import prog8.optimizing.optimizeStatements
-import prog8.optimizing.simplifyExpressions
-import prog8.parser.ParsingFailedError
-import prog8.parser.importLibraryModule
-import prog8.parser.importModule
-import prog8.parser.moduleName
-import java.io.File
-import java.io.PrintStream
-import java.lang.Exception
 import java.nio.file.Paths
 import kotlin.system.exitProcess
-import kotlin.system.measureTimeMillis
 
 
 fun main(args: Array<String>) {
@@ -75,115 +62,9 @@ private fun compileMain(args: Array<String>) {
         usage()
 
     val filepath = Paths.get(moduleFile).normalize()
-    var programname = "?"
-    lateinit var programAst: Program
 
-    try {
-        val totalTime = measureTimeMillis {
-            // import main module and everything it needs
-            println("Parsing...")
-            programAst = Program(moduleName(filepath.fileName), mutableListOf())
-            importModule(programAst, filepath)
-
-            val compilerOptions = determineCompilationOptions(programAst)
-            if (compilerOptions.launcher == LauncherType.BASIC && compilerOptions.output != OutputType.PRG)
-                throw ParsingFailedError("${programAst.modules.first().position} BASIC launcher requires output type PRG.")
-
-            // if we're producing a PRG or BASIC program, include the c64utils and c64lib libraries
-            if(compilerOptions.launcher==LauncherType.BASIC || compilerOptions.output==OutputType.PRG) {
-                importLibraryModule(programAst, "c64lib")
-                importLibraryModule(programAst, "c64utils")
-            }
-
-            // always import prog8lib and math
-            importLibraryModule(programAst, "math")
-            importLibraryModule(programAst, "prog8lib")
-
-
-            // perform initial syntax checks and constant folding
-            println("Syntax check...")
-            val time1= measureTimeMillis {
-                programAst.checkIdentifiers()
-            }
-            //println(" time1: $time1")
-            val time2 = measureTimeMillis {
-                programAst.constantFold()
-            }
-            //println(" time2: $time2")
-            val time3 = measureTimeMillis {
-                programAst.reorderStatements()     // reorder statements and add type casts, to please the compiler later
-            }
-            //println(" time3: $time3")
-            val time4 = measureTimeMillis {
-                programAst.checkValid(compilerOptions)          // check if tree is valid
-            }
-            //println(" time4: $time4")
-
-            programAst.checkIdentifiers()
-            if(optimize) {
-                // optimize the parse tree
-                println("Optimizing...")
-                while (true) {
-                    // keep optimizing expressions and statements until no more steps remain
-                    val optsDone1 = programAst.simplifyExpressions()
-                    val optsDone2 = programAst.optimizeStatements(optimizeInlining)
-                    if (optsDone1 + optsDone2 == 0)
-                        break
-                }
-            }
-
-            programAst.checkValid(compilerOptions)          // check if final tree is valid
-            programAst.checkRecursion()         // check if there are recursive subroutine calls
-
-            // namespace.debugPrint()
-
-            // compile the syntax tree into stackvmProg form, and optimize that
-            val compiler = Compiler(programAst)
-            val intermediate = compiler.compile(compilerOptions)
-            if(optimize)
-                intermediate.optimize()
-
-            if(writeVmCode) {
-                val stackVmFilename = intermediate.name + ".vm.txt"
-                val stackvmFile = PrintStream(File(stackVmFilename), "utf-8")
-                intermediate.writeCode(stackvmFile)
-                stackvmFile.close()
-                println("StackVM program code written to '$stackVmFilename'")
-            }
-
-            if(writeAssembly) {
-                val zeropage = C64Zeropage(compilerOptions)
-                intermediate.allocateZeropage(zeropage)
-                val assembly = AsmGen(compilerOptions, intermediate, programAst.heap, zeropage).compileToAssembly(optimize)
-                assembly.assemble(compilerOptions)
-                programname = assembly.name
-            }
-        }
-        println("\nTotal compilation+assemble time: ${totalTime / 1000.0} sec.")
-
-    } catch (px: ParsingFailedError) {
-        System.err.print("\u001b[91m")  // bright red
-        System.err.println(px.message)
-        System.err.print("\u001b[0m")  // reset
-        exitProcess(1)
-    } catch (ax: AstException) {
-        System.err.print("\u001b[91m")  // bright red
-        System.err.println(ax.toString())
-        System.err.print("\u001b[0m")  // reset
-        exitProcess(1)
-    } catch (x: Exception) {
-        print("\u001b[91m")  // bright red
-        println("\n* internal error *")
-        print("\u001b[0m")  // reset
-        System.out.flush()
-        throw x
-    } catch (x: NotImplementedError) {
-        print("\u001b[91m")  // bright red
-        println("\n* internal error: missing feature/code *")
-        print("\u001b[0m")  // reset
-        System.out.flush()
-        throw x
-    }
+    val (programAst, programName) = compileProgram(filepath, optimize, optimizeInlining,
+            !launchAstVm, writeVmCode, writeAssembly)
 
     if(launchAstVm) {
         println("\nLaunching AST-based vm...")
@@ -192,51 +73,19 @@ private fun compileMain(args: Array<String>) {
     }
 
     if(emulatorToStart.isNotEmpty()) {
-        println("\nStarting C-64 emulator $emulatorToStart...")
-        val cmdline = listOf(emulatorToStart, "-silent", "-moncommands", "$programname.vice-mon-list",
-                "-autostartprgmode", "1", "-autostart-warp", "-autostart", programname+".prg")
-        val process = ProcessBuilder(cmdline).inheritIO().start()
-        process.waitFor()
+        if(programName==null)
+            println("\nCan't start emulator because no program was assembled.")
+        else {
+            println("\nStarting C-64 emulator $emulatorToStart...")
+            val cmdline = listOf(emulatorToStart, "-silent", "-moncommands", "$programName.vice-mon-list",
+                    "-autostartprgmode", "1", "-autostart-warp", "-autostart", programName + ".prg")
+            val process = ProcessBuilder(cmdline).inheritIO().start()
+            process.waitFor()
+        }
     }
 }
 
 
-private fun determineCompilationOptions(program: Program): CompilationOptions {
-    val mainModule = program.modules.first()
-    val outputType = (mainModule.statements.singleOrNull { it is Directive && it.directive == "%output" }
-            as? Directive)?.args?.single()?.name?.toUpperCase()
-    val launcherType = (mainModule.statements.singleOrNull { it is Directive && it.directive == "%launcher" }
-            as? Directive)?.args?.single()?.name?.toUpperCase()
-    mainModule.loadAddress = (mainModule.statements.singleOrNull { it is Directive && it.directive == "%address" }
-            as? Directive)?.args?.single()?.int ?: 0
-    val zpoption: String? = (mainModule.statements.singleOrNull { it is Directive && it.directive == "%zeropage" }
-            as? Directive)?.args?.single()?.name?.toUpperCase()
-    val allOptions = program.modules.flatMap { it.statements }.filter { it is Directive && it.directive == "%option" }.flatMap { (it as Directive).args }.toSet()
-    val floatsEnabled = allOptions.any { it.name == "enable_floats" }
-    val zpType: ZeropageType =
-            if (zpoption == null)
-                if(floatsEnabled) ZeropageType.FLOATSAFE else ZeropageType.KERNALSAFE
-            else
-                try {
-                    ZeropageType.valueOf(zpoption)
-                } catch (x: IllegalArgumentException) {
-                    ZeropageType.KERNALSAFE
-                    // error will be printed by the astchecker
-                }
-    val zpReserved = mainModule.statements
-            .asSequence()
-            .filter { it is Directive && it.directive == "%zpreserved" }
-            .map { (it as Directive).args }
-            .map { it[0].int!!..it[1].int!! }
-            .toList()
-
-    return CompilationOptions(
-            if (outputType == null) OutputType.PRG else OutputType.valueOf(outputType),
-            if (launcherType == null) LauncherType.BASIC else LauncherType.valueOf(launcherType),
-            zpType, zpReserved, floatsEnabled
-    )
-}
-
 private fun usage() {
     System.err.println("Missing argument(s):")
     System.err.println("    [-emu]          auto-start the 'x64' C-64 emulator after successful compilation")

compiler/src/prog8/ast/AstRecursionChecker.kt

@@ -1,120 +0,0 @@
-package prog8.ast
-
-/**
- * Checks for the occurrence of recursive subroutine calls
- */
-
-internal fun Program.checkRecursion() {
-    val checker = AstRecursionChecker(namespace)
-    checker.process(this)
-    printErrors(checker.result(), name)
-}
-
-
-private class DirectedGraph<VT> {
-    private val graph = mutableMapOf<VT, MutableSet<VT>>()
-    private var uniqueVertices = mutableSetOf<VT>()
-    val numVertices : Int
-        get() = uniqueVertices.size
-
-    fun add(from: VT, to: VT) {
-        var targets = graph[from]
-        if(targets==null) {
-            targets = mutableSetOf()
-            graph[from] = targets
-        }
-        targets.add(to)
-        uniqueVertices.add(from)
-        uniqueVertices.add(to)
-    }
-
-    fun print() {
-        println("#vertices: $numVertices")
-        graph.forEach { (from, to) ->
-            println("$from   CALLS:")
-            to.forEach { println("   $it") }
-        }
-        val cycle = checkForCycle()
-        if(cycle.isNotEmpty()) {
-            println("CYCLIC!  $cycle")
-        }
-    }
-
-    fun checkForCycle(): MutableList<VT> {
-        val visited = uniqueVertices.associateWith { false }.toMutableMap()
-        val recStack = uniqueVertices.associateWith { false }.toMutableMap()
-        val cycle = mutableListOf<VT>()
-        for(node in uniqueVertices) {
-            if(isCyclicUntil(node, visited, recStack, cycle))
-                return cycle
-        }
-        return mutableListOf()
-    }
-
-    private fun isCyclicUntil(node: VT,
-                              visited: MutableMap<VT, Boolean>,
-                              recStack: MutableMap<VT, Boolean>,
-                              cycleNodes: MutableList<VT>): Boolean {
-
-        if(recStack[node]==true) return true
-        if(visited[node]==true) return false
-
-        // mark current node as visited and add to recursion stack
-        visited[node] = true
-        recStack[node] = true
-
-        // recurse for all neighbours
-        val neighbors = graph[node]
-        if(neighbors!=null) {
-            for (neighbour in neighbors) {
-                if (isCyclicUntil(neighbour, visited, recStack, cycleNodes)) {
-                    cycleNodes.add(node)
-                    return true
-                }
-            }
-        }
-
-        // pop node from recursion stack
-        recStack[node] = false
-        return false
-    }
-}
-
-
-private class AstRecursionChecker(private val namespace: INameScope) : IAstProcessor {
-    private val callGraph = DirectedGraph<INameScope>()
-
-    internal fun result(): List<AstException> {
-        val cycle = callGraph.checkForCycle()
-        if(cycle.isEmpty())
-            return emptyList()
-        val chain = cycle.joinToString(" <-- ") { "${it.name} at ${it.position}" }
-        return listOf(AstException("Program contains recursive subroutine calls, this is not supported. Recursive chain:\n (a subroutine call in) $chain"))
-    }
-
-    override fun process(functionCallStatement: FunctionCallStatement): IStatement {
-        val scope = functionCallStatement.definingScope()
-        val targetStatement = functionCallStatement.target.targetStatement(namespace)
-        if(targetStatement!=null) {
-            val targetScope = when (targetStatement) {
-                is Subroutine -> targetStatement
-                else -> targetStatement.definingScope()
-            }
-            callGraph.add(scope, targetScope)
-        }
-        return super.process(functionCallStatement)
-    }
-
-    override fun process(functionCall: FunctionCall): IExpression {
-        val scope = functionCall.definingScope()
-        val targetStatement = functionCall.target.targetStatement(namespace)
-        if(targetStatement!=null) {
-            val targetScope = when (targetStatement) {
-                is Subroutine -> targetStatement
-                else -> targetStatement.definingScope()
-            }
-            callGraph.add(scope, targetScope)
-        }
-        return super.process(functionCall)
-    }
-}

compiler/src/prog8/ast/AstToplevel.kt

@@ -0,0 +1,108 @@
+package prog8.ast
+
+import prog8.ast.base.*
+import prog8.ast.statements.Block
+import prog8.ast.statements.Label
+import prog8.ast.statements.Subroutine
+import prog8.ast.statements.VarDecl
+import prog8.compiler.HeapValues
+import prog8.functions.BuiltinFunctions
+import java.nio.file.Path
+
+
+/*********** Everything starts from here, the Program; zero or more modules *************/
+
+class Program(val name: String, val modules: MutableList<Module>) {
+    val namespace = GlobalNamespace(modules)
+    val heap = HeapValues()
+
+    val loadAddress: Int
+        get() = modules.first().loadAddress
+
+    fun entrypoint(): Subroutine? {
+        val mainBlocks = modules.flatMap { it.statements }.filter { b -> b is Block && b.name=="main" }.map { it as Block }
+        if(mainBlocks.size > 1)
+            throw FatalAstException("more than one 'main' block")
+        return if(mainBlocks.isEmpty()) {
+            null
+        } else {
+            mainBlocks[0].subScopes()["start"] as Subroutine?
+        }
+    }
+}
+
+class Module(override val name: String,
+             override var statements: MutableList<IStatement>,
+             override val position: Position,
+             val isLibraryModule: Boolean,
+             val source: Path) : Node, INameScope {
+    override lateinit var parent: Node
+    lateinit var program: Program
+    val importedBy = mutableListOf<Module>()
+    val imports = mutableSetOf<Module>()
+
+    var loadAddress: Int = 0        // can be set with the %address directive
+
+    override fun linkParents(parent: Node) {
+        this.parent = parent
+        statements.forEach {it.linkParents(this)}
+    }
+
+    override fun definingScope(): INameScope = program.namespace
+
+    override fun toString() = "Module(name=$name, pos=$position, lib=$isLibraryModule)"
+}
+
+class GlobalNamespace(val modules: List<Module>): Node, INameScope {
+    override val name = "<<<global>>>"
+    override val position = Position("<<<global>>>", 0, 0, 0)
+    override val statements = mutableListOf<IStatement>()
+    override var parent: Node = ParentSentinel
+
+    override fun linkParents(parent: Node) {
+        modules.forEach { it.linkParents(this) }
+    }
+
+    override fun lookup(scopedName: List<String>, localContext: Node): IStatement? {
+        if (scopedName.size == 1 && scopedName[0] in BuiltinFunctions) {
+            // builtin functions always exist, return a dummy localContext for them
+            val builtinPlaceholder = Label("builtin::${scopedName.last()}", localContext.position)
+            builtinPlaceholder.parent = ParentSentinel
+            return builtinPlaceholder
+        }
+
+        if(scopedName.size>1) {
+            // a scoped name can a) refer to a member of a struct, or b) refer to a name in another module.
+            // try the struct first.
+            val thing = lookup(scopedName.dropLast(1), localContext) as? VarDecl
+            val struct = thing?.struct
+            if (struct != null) {
+                if(struct.statements.any { (it as VarDecl).name == scopedName.last()}) {
+                    // return ref to the mangled name variable
+                    val mangled = mangledStructMemberName(thing.name, scopedName.last())
+                    val mangledVar = thing.definingScope().getLabelOrVariable(mangled)
+                    return mangledVar
+                }
+            }
+        }
+
+        val stmt = localContext.definingModule().lookup(scopedName, localContext)
+        return when (stmt) {
+            is Label, is VarDecl, is Block, is Subroutine -> stmt
+            null -> null
+            else -> throw NameError("wrong identifier target: $stmt", stmt.position)
+        }
+    }
+}
+
+object BuiltinFunctionScopePlaceholder : INameScope {
+    override val name = "<<builtin-functions-scope-placeholder>>"
+    override val position = Position("<<placeholder>>", 0, 0, 0)
+    override var statements = mutableListOf<IStatement>()
+    override var parent: Node = ParentSentinel
+    override fun linkParents(parent: Node) {}
+}
+
+
+// prefix for struct member variables
+internal fun mangledStructMemberName(varName: String, memberName: String) = "prog8struct_${varName}_$memberName"

compiler/src/prog8/ast/Interfaces.kt

@@ -0,0 +1,220 @@
+package prog8.ast
+
+import prog8.ast.base.*
+import prog8.ast.expressions.*
+import prog8.ast.processing.IAstModifyingVisitor
+import prog8.ast.processing.IAstVisitor
+import prog8.ast.statements.*
+
+interface Node {
+    val position: Position
+    var parent: Node             // will be linked correctly later (late init)
+    fun linkParents(parent: Node)
+
+    fun definingModule(): Module {
+        if(this is Module)
+            return this
+        return findParentNode<Module>(this)!!
+    }
+
+    fun definingSubroutine(): Subroutine?  = findParentNode<Subroutine>(this)
+
+    fun definingScope(): INameScope {
+        val scope = findParentNode<INameScope>(this)
+        if(scope!=null) {
+            return scope
+        }
+        if(this is Label && this.name.startsWith("builtin::")) {
+            return BuiltinFunctionScopePlaceholder
+        }
+        if(this is GlobalNamespace)
+            return this
+        throw FatalAstException("scope missing from $this")
+    }
+}
+
+interface IStatement : Node {
+    fun accept(visitor: IAstModifyingVisitor) : IStatement
+    fun accept(visitor: IAstVisitor)
+    fun makeScopedName(name: String): String {
+        // easy way out is to always return the full scoped name.
+        // it would be nicer to find only the minimal prefixed scoped name, but that's too much hassle for now.
+        // and like this, we can cache the name even,
+        // like in a lazy property on the statement object itself (label, subroutine, vardecl)
+        val scope = mutableListOf<String>()
+        var statementScope = this.parent
+        while(statementScope !is ParentSentinel && statementScope !is Module) {
+            if(statementScope is INameScope) {
+                scope.add(0, statementScope.name)
+            }
+            statementScope = statementScope.parent
+        }
+        if(name.isNotEmpty())
+            scope.add(name)
+        return scope.joinToString(".")
+    }
+
+    val expensiveToInline: Boolean
+
+    fun definingBlock(): Block {
+        if(this is Block)
+            return this
+        return findParentNode<Block>(this)!!
+    }
+}
+
+interface IFunctionCall {
+    var target: IdentifierReference
+    var arglist: MutableList<IExpression>
+}
+
+interface INameScope {
+    val name: String
+    val position: Position
+    val statements: MutableList<IStatement>
+    val parent: Node
+
+    fun linkParents(parent: Node)
+
+    fun subScopes(): Map<String, INameScope> {
+        val subscopes = mutableMapOf<String, INameScope>()
+        for(stmt in statements) {
+            when(stmt) {
+                // NOTE: if other nodes are introduced that are a scope, or contain subscopes, they must be added here!
+                is ForLoop -> subscopes[stmt.body.name] = stmt.body
+                is RepeatLoop -> subscopes[stmt.body.name] = stmt.body
+                is WhileLoop -> subscopes[stmt.body.name] = stmt.body
+                is BranchStatement -> {
+                    subscopes[stmt.truepart.name] = stmt.truepart
+                    if(stmt.elsepart.containsCodeOrVars())
+                        subscopes[stmt.elsepart.name] = stmt.elsepart
+                }
+                is IfStatement -> {
+                    subscopes[stmt.truepart.name] = stmt.truepart
+                    if(stmt.elsepart.containsCodeOrVars())
+                        subscopes[stmt.elsepart.name] = stmt.elsepart
+                }
+                is WhenStatement -> {
+                    stmt.choices.forEach { subscopes[it.statements.name] = it.statements }
+                }
+                is INameScope -> subscopes[stmt.name] = stmt
+            }
+        }
+        return subscopes
+    }
+
+    fun getLabelOrVariable(name: String): IStatement? {
+        // this is called A LOT and could perhaps be optimized a bit more,
+        // but adding a memoization cache didn't make much of a practical runtime difference
+        for (stmt in statements) {
+            if (stmt is VarDecl && stmt.name==name) return stmt
+            if (stmt is Label && stmt.name==name) return stmt
+            if (stmt is AnonymousScope) {
+                val sub = stmt.getLabelOrVariable(name)
+                if(sub!=null)
+                    return sub
+            }
+        }
+        return null
+    }
+
+    fun allDefinedSymbols(): List<Pair<String, IStatement>>  {
+        return statements.mapNotNull {
+            when (it) {
+                is Label -> it.name to it
+                is VarDecl -> it.name to it
+                is Subroutine -> it.name to it
+                is Block -> it.name to it
+                else -> null
+            }
+        }
+    }
+
+    fun lookup(scopedName: List<String>, localContext: Node) : IStatement? {
+        if(scopedName.size>1) {
+            // a scoped name can a) refer to a member of a struct, or b) refer to a name in another module.
+            // try the struct first.
+            val thing = lookup(scopedName.dropLast(1), localContext) as? VarDecl
+            val struct = thing?.struct
+            if (struct != null) {
+                if(struct.statements.any { (it as VarDecl).name == scopedName.last()}) {
+                    // return ref to the mangled name variable
+                    val mangled = mangledStructMemberName(thing.name, scopedName.last())
+                    val mangledVar = thing.definingScope().getLabelOrVariable(mangled)
+                    return mangledVar
+                }
+            }
+
+            // it's a qualified name, look it up from the root of the module's namespace (consider all modules in the program)
+            for(module in localContext.definingModule().program.modules) {
+                var scope: INameScope? = module
+                for(name in scopedName.dropLast(1)) {
+                    scope = scope?.subScopes()?.get(name)
+                    if(scope==null)
+                        break
+                }
+                if(scope!=null) {
+                    val result = scope.getLabelOrVariable(scopedName.last())
+                    if(result!=null)
+                        return result
+                    return scope.subScopes()[scopedName.last()] as IStatement?
+                }
+            }
+            return null
+        } else {
+            // unqualified name, find the scope the localContext is in, look in that first
+            var statementScope = localContext
+            while(statementScope !is ParentSentinel) {
+                val localScope = statementScope.definingScope()
+                val result = localScope.getLabelOrVariable(scopedName[0])
+                if (result != null)
+                    return result
+                val subscope = localScope.subScopes()[scopedName[0]] as IStatement?
+                if (subscope != null)
+                    return subscope
+                // not found in this scope, look one higher up
+                statementScope = statementScope.parent
+            }
+            return null
+        }
+    }
+
+    fun containsCodeOrVars() = statements.any { it !is Directive || it.directive == "%asminclude" || it.directive == "%asm"}
+    fun containsNoCodeNorVars() = !containsCodeOrVars()
+
+    fun remove(stmt: IStatement) {
+        if(!statements.remove(stmt))
+            throw FatalAstException("stmt to remove wasn't found in scope")
+    }
+}
+
+interface IExpression: Node {
+    fun constValue(program: Program): LiteralValue?
+    fun accept(visitor: IAstModifyingVisitor): IExpression
+    fun accept(visitor: IAstVisitor)
+    fun referencesIdentifiers(vararg name: String): Boolean
+    fun inferType(program: Program): DataType?
+
+    infix fun isSameAs(other: IExpression): Boolean {
+        if(this===other)
+            return true
+        when(this) {
+            is RegisterExpr ->
+                return (other is RegisterExpr && other.register==register)
+            is IdentifierReference ->
+                return (other is IdentifierReference && other.nameInSource==nameInSource)
+            is PrefixExpression ->
+                return (other is PrefixExpression && other.operator==operator && other.expression isSameAs expression)
+            is BinaryExpression ->
+                return (other is BinaryExpression && other.operator==operator
+                        && other.left isSameAs left
+                        && other.right isSameAs right)
+            is ArrayIndexedExpression -> {
+                return (other is ArrayIndexedExpression && other.identifier.nameInSource == identifier.nameInSource
+                        && other.arrayspec.index isSameAs arrayspec.index)
+            }
+            is LiteralValue -> return (other is LiteralValue && other==this)
+        }
+        return false
+    }
+}

compiler/src/prog8/ast/antlr/Antr2Kotlin.kt

@@ -0,0 +1,612 @@
+package prog8.ast.antlr
+
+import org.antlr.v4.runtime.IntStream
+import org.antlr.v4.runtime.ParserRuleContext
+import org.antlr.v4.runtime.tree.TerminalNode
+import prog8.ast.*
+import prog8.ast.base.*
+import prog8.ast.expressions.*
+import prog8.ast.statements.*
+import java.io.CharConversionException
+import java.io.File
+import java.nio.file.Path
+import prog8.compiler.target.c64.Petscii
+import prog8.parser.CustomLexer
+import prog8.parser.prog8Parser
+
+
+/***************** Antlr Extension methods to create AST ****************/
+
+private data class NumericLiteral(val number: Number, val datatype: DataType)
+
+
+fun prog8Parser.ModuleContext.toAst(name: String, isLibrary: Boolean, source: Path) : Module {
+    val nameWithoutSuffix = if(name.endsWith(".p8")) name.substringBeforeLast('.') else name
+    return Module(nameWithoutSuffix, modulestatement().asSequence().map { it.toAst(isLibrary) }.toMutableList(), toPosition(), isLibrary, source)
+}
+
+
+private fun ParserRuleContext.toPosition() : Position {
+    val customTokensource = this.start.tokenSource as? CustomLexer
+    val filename =
+            when {
+                customTokensource!=null -> customTokensource.modulePath.fileName.toString()
+                start.tokenSource.sourceName == IntStream.UNKNOWN_SOURCE_NAME -> "@internal@"
+                else -> File(start.inputStream.sourceName).name
+            }
+    // note: be ware of TAB characters in the source text, they count as 1 column...
+    return Position(filename, start.line, start.charPositionInLine, stop.charPositionInLine + stop.text.length)
+}
+
+
+private fun prog8Parser.ModulestatementContext.toAst(isInLibrary: Boolean) : IStatement {
+    val directive = directive()?.toAst()
+    if(directive!=null) return directive
+
+    val block = block()?.toAst(isInLibrary)
+    if(block!=null) return block
+
+    throw FatalAstException(text)
+}
+
+
+private fun prog8Parser.BlockContext.toAst(isInLibrary: Boolean) : IStatement =
+        Block(identifier().text, integerliteral()?.toAst()?.number?.toInt(), statement_block().toAst(), isInLibrary, toPosition())
+
+
+private fun prog8Parser.Statement_blockContext.toAst(): MutableList<IStatement> =
+        statement().asSequence().map { it.toAst() }.toMutableList()
+
+
+private fun prog8Parser.StatementContext.toAst() : IStatement {
+    vardecl()?.let { return it.toAst() }
+
+    varinitializer()?.let {
+        val vd = it.vardecl()
+        return VarDecl(
+                VarDeclType.VAR,
+                vd.datatype()?.toAst() ?: DataType.STRUCT,
+                if(vd.ZEROPAGE() != null) ZeropageWish.PREFER_ZEROPAGE else ZeropageWish.DONTCARE,
+                vd.arrayindex()?.toAst(),
+                vd.varname.text,
+                vd.structname?.text,
+                it.expression().toAst(),
+                vd.ARRAYSIG() != null || vd.arrayindex() != null,
+                false,
+                it.toPosition()
+        )
+    }
+
+    constdecl()?.let {
+        val cvarinit = it.varinitializer()
+        val vd = cvarinit.vardecl()
+        return VarDecl(
+                VarDeclType.CONST,
+                vd.datatype()?.toAst() ?: DataType.STRUCT,
+                if(vd.ZEROPAGE() != null) ZeropageWish.PREFER_ZEROPAGE else ZeropageWish.DONTCARE,
+                vd.arrayindex()?.toAst(),
+                vd.varname.text,
+                vd.structname?.text,
+                cvarinit.expression().toAst(),
+                vd.ARRAYSIG() != null || vd.arrayindex() != null,
+                false,
+                cvarinit.toPosition()
+        )
+    }
+
+    memoryvardecl()?.let {
+        val mvarinit = it.varinitializer()
+        val vd = mvarinit.vardecl()
+        return VarDecl(
+                VarDeclType.MEMORY,
+                vd.datatype()?.toAst() ?: DataType.STRUCT,
+                if(vd.ZEROPAGE() != null) ZeropageWish.PREFER_ZEROPAGE else ZeropageWish.DONTCARE,
+                vd.arrayindex()?.toAst(),
+                vd.varname.text,
+                vd.structname?.text,
+                mvarinit.expression().toAst(),
+                vd.ARRAYSIG() != null || vd.arrayindex() != null,
+                false,
+                mvarinit.toPosition()
+        )
+    }
+
+    assignment()?.let {
+        return Assignment(it.assign_target().toAst(), null, it.expression().toAst(), it.toPosition())
+    }
+
+    augassignment()?.let {
+        return Assignment(it.assign_target().toAst(),
+                it.operator.text,
+                it.expression().toAst(),
+                it.toPosition())
+    }
+
+    postincrdecr()?.let {
+        return PostIncrDecr(it.assign_target().toAst(), it.operator.text, it.toPosition())
+    }
+
+    val directive = directive()?.toAst()
+    if(directive!=null) return directive
+
+    val label = labeldef()?.toAst()
+    if(label!=null) return label
+
+    val jump = unconditionaljump()?.toAst()
+    if(jump!=null) return jump
+
+    val fcall = functioncall_stmt()?.toAst()
+    if(fcall!=null) return fcall
+
+    val ifstmt = if_stmt()?.toAst()
+    if(ifstmt!=null) return ifstmt
+
+    val returnstmt = returnstmt()?.toAst()
+    if(returnstmt!=null) return returnstmt
+
+    val sub = subroutine()?.toAst()
+    if(sub!=null) return sub
+
+    val asm = inlineasm()?.toAst()
+    if(asm!=null) return asm
+
+    val branchstmt = branch_stmt()?.toAst()
+    if(branchstmt!=null) return branchstmt
+
+    val forloop = forloop()?.toAst()
+    if(forloop!=null) return forloop
+
+    val repeatloop = repeatloop()?.toAst()
+    if(repeatloop!=null) return repeatloop
+
+    val whileloop = whileloop()?.toAst()
+    if(whileloop!=null) return whileloop
+
+    val breakstmt = breakstmt()?.toAst()
+    if(breakstmt!=null) return breakstmt
+
+    val continuestmt = continuestmt()?.toAst()
+    if(continuestmt!=null) return continuestmt
+
+    val asmsubstmt = asmsubroutine()?.toAst()
+    if(asmsubstmt!=null) return asmsubstmt
+
+    val whenstmt = whenstmt()?.toAst()
+    if(whenstmt!=null) return whenstmt
+
+    structdecl()?.let {
+        return StructDecl(it.identifier().text,
+                it.vardecl().map { vd->vd.toAst() }.toMutableList(),
+                toPosition())
+    }
+
+    throw FatalAstException("unprocessed source text (are we missing ast conversion rules for parser elements?): $text")
+}
+
+private fun prog8Parser.AsmsubroutineContext.toAst(): IStatement {
+    val name = identifier().text
+    val address = asmsub_address()?.address?.toAst()?.number?.toInt()
+    val params = asmsub_params()?.toAst() ?: emptyList()
+    val returns = asmsub_returns()?.toAst() ?: emptyList()
+    val normalParameters = params.map { SubroutineParameter(it.name, it.type, it.position) }
+    val normalReturnvalues = returns.map { it.type }
+    val paramRegisters = params.map { RegisterOrStatusflag(it.registerOrPair, it.statusflag, it.stack) }
+    val returnRegisters = returns.map { RegisterOrStatusflag(it.registerOrPair, it.statusflag, it.stack) }
+    val clobbers = asmsub_clobbers()?.clobber()?.toAst() ?: emptySet()
+    val statements = statement_block()?.toAst() ?: mutableListOf()
+    return Subroutine(name, normalParameters, normalReturnvalues,
+            paramRegisters, returnRegisters, clobbers, address, true, statements, toPosition())
+}
+
+private class AsmSubroutineParameter(name: String,
+                                     type: DataType,
+                                     val registerOrPair: RegisterOrPair?,
+                                     val statusflag: Statusflag?,
+                                     val stack: Boolean,
+                                     position: Position) : SubroutineParameter(name, type, position)
+
+private class AsmSubroutineReturn(val type: DataType,
+                                  val registerOrPair: RegisterOrPair?,
+                                  val statusflag: Statusflag?,
+                                  val stack: Boolean,
+                                  val position: Position)
+
+private fun prog8Parser.ClobberContext.toAst(): Set<Register>
+        = this.register().asSequence().map { it.toAst() }.toSet()
+
+
+private fun prog8Parser.Asmsub_returnsContext.toAst(): List<AsmSubroutineReturn>
+        = asmsub_return().map { AsmSubroutineReturn(it.datatype().toAst(), it.registerorpair()?.toAst(), it.statusregister()?.toAst(), !it.stack?.text.isNullOrEmpty(), toPosition()) }
+
+private fun prog8Parser.Asmsub_paramsContext.toAst(): List<AsmSubroutineParameter>
+        = asmsub_param().map {
+    val vardecl = it.vardecl()
+    val datatype = vardecl.datatype()?.toAst() ?: DataType.STRUCT
+    AsmSubroutineParameter(vardecl.varname.text, datatype,
+            it.registerorpair()?.toAst(),
+            it.statusregister()?.toAst(),
+            !it.stack?.text.isNullOrEmpty(), toPosition())
+}
+
+
+private fun prog8Parser.StatusregisterContext.toAst() = Statusflag.valueOf(text)
+
+
+private fun prog8Parser.Functioncall_stmtContext.toAst(): IStatement {
+    val location = scoped_identifier().toAst()
+    return if(expression_list() == null)
+        FunctionCallStatement(location, mutableListOf(), toPosition())
+    else
+        FunctionCallStatement(location, expression_list().toAst().toMutableList(), toPosition())
+}
+
+
+private fun prog8Parser.FunctioncallContext.toAst(): FunctionCall {
+    val location = scoped_identifier().toAst()
+    return if(expression_list() == null)
+        FunctionCall(location, mutableListOf(), toPosition())
+    else
+        FunctionCall(location, expression_list().toAst().toMutableList(), toPosition())
+}
+
+
+private fun prog8Parser.InlineasmContext.toAst() =
+        InlineAssembly(INLINEASMBLOCK().text, toPosition())
+
+
+private fun prog8Parser.ReturnstmtContext.toAst() : Return {
+    return Return(expression()?.toAst(), toPosition())
+}
+
+private fun prog8Parser.UnconditionaljumpContext.toAst(): Jump {
+    val address = integerliteral()?.toAst()?.number?.toInt()
+    val identifier = scoped_identifier()?.toAst()
+    return Jump(address, identifier, null, toPosition())
+}
+
+
+private fun prog8Parser.LabeldefContext.toAst(): IStatement =
+        Label(children[0].text, toPosition())
+
+
+private fun prog8Parser.SubroutineContext.toAst() : Subroutine {
+    return Subroutine(identifier().text,
+            sub_params()?.toAst() ?: emptyList(),
+            sub_return_part()?.toAst() ?: emptyList(),
+            emptyList(),
+            emptyList(),
+            emptySet(),
+            null,
+            false,
+            statement_block()?.toAst() ?: mutableListOf(),
+            toPosition())
+}
+
+private fun prog8Parser.Sub_return_partContext.toAst(): List<DataType> {
+    val returns = sub_returns() ?: return emptyList()
+    return returns.datatype().map { it.toAst() }
+}
+
+
+private fun prog8Parser.Sub_paramsContext.toAst(): List<SubroutineParameter> =
+        vardecl().map {
+            val datatype = it.datatype()?.toAst() ?: DataType.STRUCT
+            SubroutineParameter(it.varname.text, datatype, it.toPosition())
+        }
+
+
+private fun prog8Parser.Assign_targetContext.toAst() : AssignTarget {
+    val register = register()?.toAst()
+    val identifier = scoped_identifier()
+    return when {
+        register!=null -> AssignTarget(register, null, null, null, toPosition())
+        identifier!=null -> AssignTarget(null, identifier.toAst(), null, null, toPosition())
+        arrayindexed()!=null -> AssignTarget(null, null, arrayindexed().toAst(), null, toPosition())
+        directmemory()!=null -> AssignTarget(null, null, null, DirectMemoryWrite(directmemory().expression().toAst(), toPosition()), toPosition())
+        else -> AssignTarget(null, scoped_identifier()?.toAst(), null, null, toPosition())
+    }
+}
+
+private fun prog8Parser.RegisterContext.toAst() = Register.valueOf(text.toUpperCase())
+
+private fun prog8Parser.DatatypeContext.toAst() = DataType.valueOf(text.toUpperCase())
+
+private fun prog8Parser.RegisterorpairContext.toAst() = RegisterOrPair.valueOf(text.toUpperCase())
+
+
+private fun prog8Parser.ArrayindexContext.toAst() : ArrayIndex =
+        ArrayIndex(expression().toAst(), toPosition())
+
+
+private fun prog8Parser.DirectiveContext.toAst() : Directive =
+        Directive(directivename.text, directivearg().map { it.toAst() }, toPosition())
+
+
+private fun prog8Parser.DirectiveargContext.toAst() : DirectiveArg =
+        DirectiveArg(stringliteral()?.text, identifier()?.text, integerliteral()?.toAst()?.number?.toInt(), toPosition())
+
+
+private fun prog8Parser.IntegerliteralContext.toAst(): NumericLiteral {
+    fun makeLiteral(text: String, radix: Int, forceWord: Boolean): NumericLiteral {
+        val integer: Int
+        var datatype = DataType.UBYTE
+        when (radix) {
+            10 -> {
+                integer = try {
+                    text.toInt()
+                } catch(x: NumberFormatException) {
+                    throw AstException("${toPosition()} invalid decimal literal ${x.message}")
+                }
+                datatype = when(integer) {
+                    in 0..255 -> DataType.UBYTE
+                    in -128..127 -> DataType.BYTE
+                    in 0..65535 -> DataType.UWORD
+                    in -32768..32767 -> DataType.WORD
+                    else -> DataType.FLOAT
+                }
+            }
+            2 -> {
+                if(text.length>8)
+                    datatype = DataType.UWORD
+                try {
+                    integer = text.toInt(2)
+                } catch(x: NumberFormatException) {
+                    throw AstException("${toPosition()} invalid binary literal ${x.message}")
+                }
+            }
+            16 -> {
+                if(text.length>2)
+                    datatype = DataType.UWORD
+                try {
+                    integer = text.toInt(16)
+                } catch(x: NumberFormatException) {
+                    throw AstException("${toPosition()} invalid hexadecimal literal ${x.message}")
+                }
+            }
+            else -> throw FatalAstException("invalid radix")
+        }
+        return NumericLiteral(integer, if (forceWord) DataType.UWORD else datatype)
+    }
+    val terminal: TerminalNode = children[0] as TerminalNode
+    val integerPart = this.intpart.text
+    return when (terminal.symbol.type) {
+        prog8Parser.DEC_INTEGER -> makeLiteral(integerPart, 10, wordsuffix()!=null)
+        prog8Parser.HEX_INTEGER -> makeLiteral(integerPart.substring(1), 16, wordsuffix()!=null)
+        prog8Parser.BIN_INTEGER -> makeLiteral(integerPart.substring(1), 2, wordsuffix()!=null)
+        else -> throw FatalAstException(terminal.text)
+    }
+}
+
+
+private fun prog8Parser.ExpressionContext.toAst() : IExpression {
+
+    val litval = literalvalue()
+    if(litval!=null) {
+        val booleanlit = litval.booleanliteral()?.toAst()
+        return if(booleanlit!=null) {
+            LiteralValue.fromBoolean(booleanlit, litval.toPosition())
+        }
+        else {
+            val intLit = litval.integerliteral()?.toAst()
+            when {
+                intLit!=null -> when(intLit.datatype) {
+                    DataType.UBYTE -> LiteralValue(DataType.UBYTE, bytevalue = intLit.number.toShort(), position = litval.toPosition())
+                    DataType.BYTE -> LiteralValue(DataType.BYTE, bytevalue = intLit.number.toShort(), position = litval.toPosition())
+                    DataType.UWORD -> LiteralValue(DataType.UWORD, wordvalue = intLit.number.toInt(), position = litval.toPosition())
+                    DataType.WORD -> LiteralValue(DataType.WORD, wordvalue = intLit.number.toInt(), position = litval.toPosition())
+                    DataType.FLOAT -> LiteralValue(DataType.FLOAT, floatvalue = intLit.number.toDouble(), position = litval.toPosition())
+                    else -> throw FatalAstException("invalid datatype for numeric literal")
+                }
+                litval.floatliteral()!=null -> LiteralValue(DataType.FLOAT, floatvalue = litval.floatliteral().toAst(), position = litval.toPosition())
+                litval.stringliteral()!=null -> LiteralValue(DataType.STR, strvalue = unescape(litval.stringliteral().text, litval.toPosition()), position = litval.toPosition())
+                litval.charliteral()!=null -> {
+                    try {
+                        LiteralValue(DataType.UBYTE, bytevalue = Petscii.encodePetscii(unescape(litval.charliteral().text, litval.toPosition()), true)[0], position = litval.toPosition())
+                    } catch (ce: CharConversionException) {
+                        throw SyntaxError(ce.message ?: ce.toString(), litval.toPosition())
+                    }
+                }
+                litval.arrayliteral()!=null -> {
+                    val array = litval.arrayliteral()?.toAst()
+                    // the actual type of the arraysize can not yet be determined here (missing namespace & heap)
+                    // the ConstantFolder takes care of that and converts the type if needed.
+                    LiteralValue(DataType.ARRAY_UB, arrayvalue = array, position = litval.toPosition())
+                }
+                else -> throw FatalAstException("invalid parsed literal")
+            }
+        }
+    }
+
+    if(register()!=null)
+        return RegisterExpr(register().toAst(), register().toPosition())
+
+    if(scoped_identifier()!=null)
+        return scoped_identifier().toAst()
+
+    if(bop!=null)
+        return BinaryExpression(left.toAst(), bop.text, right.toAst(), toPosition())
+
+    if(prefix!=null)
+        return PrefixExpression(prefix.text, expression(0).toAst(), toPosition())
+
+    val funcall = functioncall()?.toAst()
+    if(funcall!=null) return funcall
+
+    if (rangefrom!=null && rangeto!=null) {
+        val step = rangestep?.toAst() ?: LiteralValue(DataType.UBYTE, 1, position = toPosition())
+        return RangeExpr(rangefrom.toAst(), rangeto.toAst(), step, toPosition())
+    }
+
+    if(childCount==3 && children[0].text=="(" && children[2].text==")")
+        return expression(0).toAst()        // expression within ( )
+
+    if(arrayindexed()!=null)
+        return arrayindexed().toAst()
+
+    if(typecast()!=null)
+        return TypecastExpression(expression(0).toAst(), typecast().datatype().toAst(), false, toPosition())
+
+    if(directmemory()!=null)
+        return DirectMemoryRead(directmemory().expression().toAst(), toPosition())
+
+    if(addressof()!=null)
+        return AddressOf(addressof().scoped_identifier().toAst(), toPosition())
+
+    throw FatalAstException(text)
+}
+
+
+private fun prog8Parser.ArrayindexedContext.toAst(): ArrayIndexedExpression {
+    return ArrayIndexedExpression(scoped_identifier().toAst(),
+            arrayindex().toAst(),
+            toPosition())
+}
+
+
+private fun prog8Parser.Expression_listContext.toAst() = expression().map{ it.toAst() }
+
+
+private fun prog8Parser.IdentifierContext.toAst() : IdentifierReference =
+        IdentifierReference(listOf(text), toPosition())
+
+
+private fun prog8Parser.Scoped_identifierContext.toAst() : IdentifierReference =
+        IdentifierReference(NAME().map { it.text }, toPosition())
+
+
+private fun prog8Parser.FloatliteralContext.toAst() = text.toDouble()
+
+
+private fun prog8Parser.BooleanliteralContext.toAst() = when(text) {
+    "true" -> true
+    "false" -> false
+    else -> throw FatalAstException(text)
+}
+
+
+private fun prog8Parser.ArrayliteralContext.toAst() : Array<IExpression> =
+        expression().map { it.toAst() }.toTypedArray()
+
+
+private fun prog8Parser.If_stmtContext.toAst(): IfStatement {
+    val condition = expression().toAst()
+    val trueStatements = statement_block()?.toAst() ?: mutableListOf(statement().toAst())
+    val elseStatements = else_part()?.toAst() ?: mutableListOf()
+    val trueScope = AnonymousScope(trueStatements, statement_block()?.toPosition()
+            ?: statement().toPosition())
+    val elseScope = AnonymousScope(elseStatements, else_part()?.toPosition() ?: toPosition())
+    return IfStatement(condition, trueScope, elseScope, toPosition())
+}
+
+private fun prog8Parser.Else_partContext.toAst(): MutableList<IStatement> {
+    return statement_block()?.toAst() ?: mutableListOf(statement().toAst())
+}
+
+
+private fun prog8Parser.Branch_stmtContext.toAst(): BranchStatement {
+    val branchcondition = branchcondition().toAst()
+    val trueStatements = statement_block()?.toAst() ?: mutableListOf(statement().toAst())
+    val elseStatements = else_part()?.toAst() ?: mutableListOf()
+    val trueScope = AnonymousScope(trueStatements, statement_block()?.toPosition()
+            ?: statement().toPosition())
+    val elseScope = AnonymousScope(elseStatements, else_part()?.toPosition() ?: toPosition())
+    return BranchStatement(branchcondition, trueScope, elseScope, toPosition())
+}
+
+private fun prog8Parser.BranchconditionContext.toAst() = BranchCondition.valueOf(text.substringAfter('_').toUpperCase())
+
+
+private fun prog8Parser.ForloopContext.toAst(): ForLoop {
+    val loopregister = register()?.toAst()
+    val datatype = datatype()?.toAst()
+    val zeropage = if(ZEROPAGE() != null) ZeropageWish.PREFER_ZEROPAGE else ZeropageWish.DONTCARE
+    val loopvar = identifier()?.toAst()
+    val iterable = expression()!!.toAst()
+    val scope =
+            if(statement()!=null)
+                AnonymousScope(mutableListOf(statement().toAst()), statement().toPosition())
+            else
+                AnonymousScope(statement_block().toAst(), statement_block().toPosition())
+    return ForLoop(loopregister, datatype, zeropage, loopvar, iterable, scope, toPosition())
+}
+
+
+private fun prog8Parser.ContinuestmtContext.toAst() = Continue(toPosition())
+
+private fun prog8Parser.BreakstmtContext.toAst() = Break(toPosition())
+
+
+private fun prog8Parser.WhileloopContext.toAst(): WhileLoop {
+    val condition = expression().toAst()
+    val statements = statement_block()?.toAst() ?: mutableListOf(statement().toAst())
+    val scope = AnonymousScope(statements, statement_block()?.toPosition()
+            ?: statement().toPosition())
+    return WhileLoop(condition, scope, toPosition())
+}
+
+
+private fun prog8Parser.RepeatloopContext.toAst(): RepeatLoop {
+    val untilCondition = expression().toAst()
+    val statements = statement_block()?.toAst() ?: mutableListOf(statement().toAst())
+    val scope = AnonymousScope(statements, statement_block()?.toPosition()
+            ?: statement().toPosition())
+    return RepeatLoop(scope, untilCondition, toPosition())
+}
+
+private fun prog8Parser.WhenstmtContext.toAst(): WhenStatement {
+    val condition = expression().toAst()
+    val choices = this.when_choice()?.map { it.toAst() }?.toMutableList() ?: mutableListOf()
+    return WhenStatement(condition, choices, toPosition())
+}
+
+private fun prog8Parser.When_choiceContext.toAst(): WhenChoice {
+    val values = expression_list()?.toAst()
+    val stmt = statement()?.toAst()
+    val stmt_block = statement_block()?.toAst()?.toMutableList() ?: mutableListOf()
+    if(stmt!=null)
+        stmt_block.add(stmt)
+    val scope = AnonymousScope(stmt_block, toPosition())
+    return WhenChoice(values, scope, toPosition())
+}
+
+private fun prog8Parser.VardeclContext.toAst(): VarDecl {
+    return VarDecl(
+            VarDeclType.VAR,
+            datatype()?.toAst() ?: DataType.STRUCT,
+            if(ZEROPAGE() != null) ZeropageWish.PREFER_ZEROPAGE else ZeropageWish.DONTCARE,
+            arrayindex()?.toAst(),
+            varname.text,
+            structname?.text,
+            null,
+            ARRAYSIG() != null || arrayindex() != null,
+            false,
+            toPosition()
+    )
+}
+
+internal fun escape(str: String) = str.replace("\t", "\\t").replace("\n", "\\n").replace("\r", "\\r")
+
+internal fun unescape(str: String, position: Position): String {
+    val result = mutableListOf<Char>()
+    val iter = str.iterator()
+    while(iter.hasNext()) {
+        val c = iter.nextChar()
+        if(c=='\\') {
+            val ec = iter.nextChar()
+            result.add(when(ec) {
+                '\\' -> '\\'
+                'n' -> '\n'
+                'r' -> '\r'
+                '"' -> '"'
+                'u' -> {
+                    "${iter.nextChar()}${iter.nextChar()}${iter.nextChar()}${iter.nextChar()}".toInt(16).toChar()
+                }
+                else -> throw SyntaxError("invalid escape char in string: \\$ec", position)
+            })
+        } else {
+            result.add(c)
+        }
+    }
+    return result.joinToString("")
+}
+

compiler/src/prog8/ast/base/Base.kt

@@ -0,0 +1,140 @@
+package prog8.ast.base
+
+import prog8.ast.Node
+
+/**************************** AST Data classes ****************************/
+
+enum class DataType {
+    UBYTE,              // pass by value
+    BYTE,               // pass by value
+    UWORD,              // pass by value
+    WORD,               // pass by value
+    FLOAT,              // pass by value
+    STR,                // pass by reference
+    STR_S,              // pass by reference
+    ARRAY_UB,           // pass by reference
+    ARRAY_B,            // pass by reference
+    ARRAY_UW,           // pass by reference
+    ARRAY_W,            // pass by reference
+    ARRAY_F,            // pass by reference
+    STRUCT;             // pass by reference
+
+    /**
+     * is the type assignable to the given other type?
+     */
+    infix fun isAssignableTo(targetType: DataType) =
+            // what types are assignable to others without loss of precision?
+            when(this) {
+                UBYTE -> targetType in setOf(UBYTE, UWORD, WORD, FLOAT)
+                BYTE -> targetType in setOf(BYTE, UBYTE, UWORD, WORD, FLOAT)
+                UWORD -> targetType in setOf(UWORD, FLOAT)
+                WORD -> targetType in setOf(WORD, UWORD, FLOAT)
+                FLOAT -> targetType == FLOAT
+                STR -> targetType == STR || targetType==STR_S
+                STR_S -> targetType == STR || targetType==STR_S
+                in ArrayDatatypes -> targetType == this
+                else -> false
+            }
+
+
+    infix fun isAssignableTo(targetTypes: Set<DataType>) = targetTypes.any { this isAssignableTo it }
+
+    infix fun largerThan(other: DataType) =
+            when(this) {
+                in ByteDatatypes -> false
+                in WordDatatypes -> other in ByteDatatypes
+                else -> true
+            }
+
+    infix fun equalsSize(other: DataType) =
+            when(this) {
+                in ByteDatatypes -> other in ByteDatatypes
+                in WordDatatypes -> other in WordDatatypes
+                else -> false
+            }
+}
+
+enum class Register {
+    A,
+    X,
+    Y
+}
+
+enum class RegisterOrPair {
+    A,
+    X,
+    Y,
+    AX,
+    AY,
+    XY
+}       // only used in parameter and return value specs in asm subroutines
+
+enum class Statusflag {
+    Pc,
+    Pz,
+    Pv,
+    Pn
+}
+
+enum class BranchCondition {
+    CS,
+    CC,
+    EQ,
+    Z,
+    NE,
+    NZ,
+    VS,
+    VC,
+    MI,
+    NEG,
+    PL,
+    POS
+}
+
+enum class VarDeclType {
+    VAR,
+    CONST,
+    MEMORY
+}
+
+val ByteDatatypes = setOf(DataType.UBYTE, DataType.BYTE)
+val WordDatatypes = setOf(DataType.UWORD, DataType.WORD)
+val IntegerDatatypes = setOf(DataType.UBYTE, DataType.BYTE, DataType.UWORD, DataType.WORD)
+val NumericDatatypes = setOf(DataType.UBYTE, DataType.BYTE, DataType.UWORD, DataType.WORD, DataType.FLOAT)
+val StringDatatypes = setOf(DataType.STR, DataType.STR_S)
+val ArrayDatatypes = setOf(DataType.ARRAY_UB, DataType.ARRAY_B, DataType.ARRAY_UW, DataType.ARRAY_W, DataType.ARRAY_F)
+val IterableDatatypes = setOf(
+        DataType.STR, DataType.STR_S,
+        DataType.ARRAY_UB, DataType.ARRAY_B,
+        DataType.ARRAY_UW, DataType.ARRAY_W,
+        DataType.ARRAY_F)
+val PassByValueDatatypes = NumericDatatypes
+val PassByReferenceDatatypes = IterableDatatypes.plus(DataType.STRUCT)
+val ArrayElementTypes = mapOf(
+        DataType.ARRAY_B to DataType.BYTE,
+        DataType.ARRAY_UB to DataType.UBYTE,
+        DataType.ARRAY_W to DataType.WORD,
+        DataType.ARRAY_UW to DataType.UWORD,
+        DataType.ARRAY_F to DataType.FLOAT)
+
+// find the parent node of a specific type or interface
+// (useful to figure out in what namespace/block something is defined, etc)
+inline fun <reified T> findParentNode(node: Node): T? {
+    var candidate = node.parent
+    while(candidate !is T && candidate !is ParentSentinel)
+        candidate = candidate.parent
+    return if(candidate is ParentSentinel)
+        null
+    else
+        candidate as T
+}
+
+object ParentSentinel : Node {
+    override val position = Position("<<sentinel>>", 0, 0, 0)
+    override var parent: Node = this
+    override fun linkParents(parent: Node) {}
+}
+
+data class Position(val file: String, val line: Int, val startCol: Int, val endCol: Int) {
+    override fun toString(): String = "[$file: line $line col ${startCol+1}-${endCol+1}]"
+}

compiler/src/prog8/ast/base/ErrorReporting.kt

@@ -0,0 +1,37 @@
+package prog8.ast.base
+
+import prog8.parser.ParsingFailedError
+
+
+fun printErrors(errors: List<Any>, moduleName: String) {
+    val reportedMessages = mutableSetOf<String>()
+    print("\u001b[91m")  // bright red
+    errors.forEach {
+        val msg = it.toString()
+        if(msg !in reportedMessages) {
+            System.err.println(msg)
+            reportedMessages.add(msg)
+        }
+    }
+    print("\u001b[0m")  // reset color
+    if(reportedMessages.isNotEmpty())
+        throw ParsingFailedError("There are ${reportedMessages.size} errors in module '$moduleName'.")
+}
+
+
+fun printWarning(msg: String, position: Position, detailInfo: String?=null) {
+    print("\u001b[93m")  // bright yellow
+    print("$position Warning: $msg")
+    if(detailInfo==null)
+        print("\n")
+    else
+        println(": $detailInfo\n")
+    print("\u001b[0m")  // normal
+}
+
+
+fun printWarning(msg: String) {
+    print("\u001b[93m")  // bright yellow
+    print("Warning: $msg")
+    print("\u001b[0m\n")  // normal
+}

compiler/src/prog8/ast/base/Errors.kt

@@ -0,0 +1,22 @@
+package prog8.ast.base
+
+import prog8.ast.expressions.IdentifierReference
+
+class FatalAstException (override var message: String) : Exception(message)
+
+open class AstException (override var message: String) : Exception(message)
+
+class SyntaxError(override var message: String, val position: Position) : AstException(message) {
+    override fun toString() = "$position Syntax error: $message"
+}
+
+class NameError(override var message: String, val position: Position) : AstException(message) {
+    override fun toString() = "$position Name error: $message"
+}
+
+open class ExpressionError(message: String, val position: Position) : AstException(message) {
+    override fun toString() = "$position Error: $message"
+}
+
+class UndefinedSymbolError(symbol: IdentifierReference)
+    : ExpressionError("undefined symbol: ${symbol.nameInSource.joinToString(".")}", symbol.position)

compiler/src/prog8/ast/base/Extensions.kt

@@ -0,0 +1,92 @@
+package prog8.ast.base
+
+import prog8.ast.*
+import prog8.ast.expressions.IdentifierReference
+import prog8.ast.processing.*
+import prog8.ast.statements.Assignment
+import prog8.ast.statements.ForLoop
+import prog8.compiler.CompilationOptions
+import prog8.optimizer.FlattenAnonymousScopesAndRemoveNops
+
+
+// the name of the subroutine that should be called for every block to initialize its variables
+internal const val initvarsSubName="prog8_init_vars"
+
+
+// prefix for literal values that are turned into a variable on the heap
+internal const val autoHeapValuePrefix = "auto_heap_value_"
+
+
+internal fun Program.removeNopsFlattenAnonScopes() {
+    val flattener = FlattenAnonymousScopesAndRemoveNops()
+    flattener.visit(this)
+}
+
+
+internal fun Program.checkValid(compilerOptions: CompilationOptions) {
+    val checker = AstChecker(this, compilerOptions)
+    checker.visit(this)
+    printErrors(checker.result(), name)
+}
+
+
+internal fun Program.reorderStatements() {
+    val initvalueCreator = VarInitValueAndAddressOfCreator(namespace)
+    initvalueCreator.visit(this)
+
+    val checker = StatementReorderer(this)
+    checker.visit(this)
+}
+
+internal fun Module.checkImportedValid() {
+    val checker = ImportedModuleDirectiveRemover()
+    checker.visit(this)
+    printErrors(checker.result(), name)
+}
+
+internal fun Program.checkRecursion() {
+    val checker = AstRecursionChecker(namespace)
+    checker.visit(this)
+    printErrors(checker.result(), name)
+}
+
+
+internal fun Program.checkIdentifiers() {
+    val checker = AstIdentifiersChecker(namespace)
+    checker.visit(this)
+
+    if(modules.map {it.name}.toSet().size != modules.size) {
+        throw FatalAstException("modules should all be unique")
+    }
+
+    // add any anonymous variables for heap values that are used,
+    // and replace an iterable literalvalue by identifierref to new local variable
+    // TODO: this is't doing anything anymore?
+    for (variable in checker.anonymousVariablesFromHeap.values) {
+        val scope = variable.first.definingScope()
+        scope.statements.add(variable.second)
+        val parent = variable.first.parent
+        when {
+            parent is Assignment && parent.value === variable.first -> {
+                val idref = IdentifierReference(listOf("$autoHeapValuePrefix${variable.first.heapId}"), variable.first.position)
+                idref.linkParents(parent)
+                parent.value = idref
+            }
+            parent is IFunctionCall -> {
+                val parameterPos = parent.arglist.indexOf(variable.first)
+                val idref = IdentifierReference(listOf("$autoHeapValuePrefix${variable.first.heapId}"), variable.first.position)
+                idref.linkParents(parent)
+                parent.arglist[parameterPos] = idref
+            }
+            parent is ForLoop -> {
+                val idref = IdentifierReference(listOf("$autoHeapValuePrefix${variable.first.heapId}"), variable.first.position)
+                idref.linkParents(parent)
+                parent.iterable = idref
+            }
+            else -> TODO("replace literalvalue by identifierref: $variable  (in $parent)")
+        }
+        variable.second.linkParents(scope as Node)
+    }
+
+    printErrors(checker.result(), name)
+}

compiler/src/prog8/ast/expressions/AstExpressions.kt

@@ -0,0 +1,785 @@
+package prog8.ast.expressions
+
+import prog8.ast.*
+import prog8.ast.antlr.escape
+import prog8.ast.base.*
+import prog8.ast.processing.IAstModifyingVisitor
+import prog8.ast.processing.IAstVisitor
+import prog8.ast.statements.*
+import prog8.compiler.HeapValues
+import prog8.compiler.IntegerOrAddressOf
+import prog8.compiler.target.c64.Petscii
+import prog8.functions.BuiltinFunctions
+import prog8.functions.NotConstArgumentException
+import prog8.functions.builtinFunctionReturnType
+import kotlin.math.abs
+
+
+val associativeOperators = setOf("+", "*", "&", "|", "^", "or", "and", "xor", "==", "!=")
+
+
+class PrefixExpression(val operator: String, var expression: IExpression, override val position: Position) : IExpression {
+    override lateinit var parent: Node
+
+    override fun linkParents(parent: Node) {
+        this.parent = parent
+        expression.linkParents(this)
+    }
+
+    override fun constValue(program: Program): LiteralValue? = null
+    override fun accept(visitor: IAstModifyingVisitor) = visitor.visit(this)
+    override fun accept(visitor: IAstVisitor) = visitor.visit(this)
+    override fun referencesIdentifiers(vararg name: String) = expression.referencesIdentifiers(*name)
+    override fun inferType(program: Program): DataType? = expression.inferType(program)
+
+    override fun toString(): String {
+        return "Prefix($operator $expression)"
+    }
+}
+
+class BinaryExpression(var left: IExpression, var operator: String, var right: IExpression, override val position: Position) : IExpression {
+    override lateinit var parent: Node
+
+    override fun linkParents(parent: Node) {
+        this.parent = parent
+        left.linkParents(this)
+        right.linkParents(this)
+    }
+
+    override fun toString(): String {
+        return "[$left $operator $right]"
+    }
+
+    // binary expression should actually have been optimized away into a single value, before const value was requested...
+    override fun constValue(program: Program): LiteralValue? = null
+
+    override fun accept(visitor: IAstModifyingVisitor) = visitor.visit(this)
+    override fun accept(visitor: IAstVisitor) = visitor.visit(this)
+    override fun referencesIdentifiers(vararg name: String) = left.referencesIdentifiers(*name) || right.referencesIdentifiers(*name)
+    override fun inferType(program: Program): DataType? {
+        val leftDt = left.inferType(program)
+        val rightDt = right.inferType(program)
+        return when (operator) {
+            "+", "-", "*", "**", "%" -> if (leftDt == null || rightDt == null) null else {
+                try {
+                    arithmeticOpDt(leftDt, rightDt)
+                } catch (x: FatalAstException) {
+                    null
+                }
+            }
+            "/" -> if (leftDt == null || rightDt == null) null else divisionOpDt(leftDt, rightDt)
+            "&" -> leftDt
+            "|" -> leftDt
+            "^" -> leftDt
+            "and", "or", "xor",
+            "<", ">",
+            "<=", ">=",
+            "==", "!=" -> DataType.UBYTE
+            "<<", ">>" -> leftDt
+            else -> throw FatalAstException("resulting datatype check for invalid operator $operator")
+        }
+    }
+
+    companion object {
+        fun divisionOpDt(leftDt: DataType, rightDt: DataType): DataType {
+            return when (leftDt) {
+                DataType.UBYTE -> when (rightDt) {
+                    DataType.UBYTE, DataType.UWORD -> DataType.UBYTE
+                    DataType.BYTE, DataType.WORD -> DataType.WORD
+                    DataType.FLOAT -> DataType.BYTE
+                    else -> throw FatalAstException("arithmetic operation on incompatible datatypes: $leftDt and $rightDt")
+                }
+                DataType.BYTE -> when (rightDt) {
+                    in NumericDatatypes -> DataType.BYTE
+                    else -> throw FatalAstException("arithmetic operation on incompatible datatypes: $leftDt and $rightDt")
+                }
+                DataType.UWORD -> when (rightDt) {
+                    DataType.UBYTE, DataType.UWORD -> DataType.UWORD
+                    DataType.BYTE, DataType.WORD -> DataType.WORD
+                    DataType.FLOAT -> DataType.FLOAT
+                    else -> throw FatalAstException("arithmetic operation on incompatible datatypes: $leftDt and $rightDt")
+                }
+                DataType.WORD -> when (rightDt) {
+                    in NumericDatatypes -> DataType.WORD
+                    else -> throw FatalAstException("arithmetic operation on incompatible datatypes: $leftDt and $rightDt")
+                }
+                DataType.FLOAT -> when (rightDt) {
+                    in NumericDatatypes -> DataType.FLOAT
+                    else -> throw FatalAstException("arithmetic operation on incompatible datatypes: $leftDt and $rightDt")
+                }
+                else -> throw FatalAstException("arithmetic operation on incompatible datatypes: $leftDt and $rightDt")
+            }
+        }
+
+        fun arithmeticOpDt(leftDt: DataType, rightDt: DataType): DataType {
+            return when (leftDt) {
+                DataType.UBYTE -> when (rightDt) {
+                    DataType.UBYTE -> DataType.UBYTE
+                    DataType.BYTE -> DataType.BYTE
+                    DataType.UWORD -> DataType.UWORD
+                    DataType.WORD -> DataType.WORD
+                    DataType.FLOAT -> DataType.FLOAT
+                    else -> throw FatalAstException("arithmetic operation on incompatible datatypes: $leftDt and $rightDt")
+                }
+                DataType.BYTE -> when (rightDt) {
+                    in ByteDatatypes -> DataType.BYTE
+                    in WordDatatypes -> DataType.WORD
+                    DataType.FLOAT -> DataType.FLOAT
+                    else -> throw FatalAstException("arithmetic operation on incompatible datatypes: $leftDt and $rightDt")
+                }
+                DataType.UWORD -> when (rightDt) {
+                    DataType.UBYTE, DataType.UWORD -> DataType.UWORD
+                    DataType.BYTE, DataType.WORD -> DataType.WORD
+                    DataType.FLOAT -> DataType.FLOAT
+                    else -> throw FatalAstException("arithmetic operation on incompatible datatypes: $leftDt and $rightDt")
+                }
+                DataType.WORD -> when (rightDt) {
+                    in IntegerDatatypes -> DataType.WORD
+                    DataType.FLOAT -> DataType.FLOAT
+                    else -> throw FatalAstException("arithmetic operation on incompatible datatypes: $leftDt and $rightDt")
+                }
+                DataType.FLOAT -> when (rightDt) {
+                    in NumericDatatypes -> DataType.FLOAT
+                    else -> throw FatalAstException("arithmetic operation on incompatible datatypes: $leftDt and $rightDt")
+                }
+                else -> throw FatalAstException("arithmetic operation on incompatible datatypes: $leftDt and $rightDt")
+            }
+        }
+    }
+
+    fun commonDatatype(leftDt: DataType, rightDt: DataType,
+                       left: IExpression, right: IExpression): Pair<DataType, IExpression?> {
+        // byte + byte -> byte
+        // byte + word -> word
+        // word + byte -> word
+        // word + word -> word
+        // a combination with a float will be float (but give a warning about this!)
+
+        if(this.operator=="/") {
+            // division is a bit weird, don't cast the operands
+            val commondt = divisionOpDt(leftDt, rightDt)
+            return Pair(commondt, null)
+        }
+
+        return when (leftDt) {
+            DataType.UBYTE -> {
+                when (rightDt) {
+                    DataType.UBYTE -> Pair(DataType.UBYTE, null)
+                    DataType.BYTE -> Pair(DataType.BYTE, left)
+                    DataType.UWORD -> Pair(DataType.UWORD, left)
+                    DataType.WORD -> Pair(DataType.WORD, left)
+                    DataType.FLOAT -> Pair(DataType.FLOAT, left)
+                    else -> throw FatalAstException("non-numeric datatype $rightDt")
+                }
+            }
+            DataType.BYTE -> {
+                when (rightDt) {
+                    DataType.UBYTE -> Pair(DataType.BYTE, right)
+                    DataType.BYTE -> Pair(DataType.BYTE, null)
+                    DataType.UWORD -> Pair(DataType.WORD, left)
+                    DataType.WORD -> Pair(DataType.WORD, left)
+                    DataType.FLOAT -> Pair(DataType.FLOAT, left)
+                    else -> throw FatalAstException("non-numeric datatype $rightDt")
+                }
+            }
+            DataType.UWORD -> {
+                when (rightDt) {
+                    DataType.UBYTE -> Pair(DataType.UWORD, right)
+                    DataType.BYTE -> Pair(DataType.UWORD, right)
+                    DataType.UWORD -> Pair(DataType.UWORD, null)
+                    DataType.WORD -> Pair(DataType.WORD, left)
+                    DataType.FLOAT -> Pair(DataType.FLOAT, left)
+                    else -> throw FatalAstException("non-numeric datatype $rightDt")
+                }
+            }
+            DataType.WORD -> {
+                when (rightDt) {
+                    DataType.UBYTE -> Pair(DataType.WORD, right)
+                    DataType.BYTE -> Pair(DataType.WORD, right)
+                    DataType.UWORD -> Pair(DataType.WORD, right)
+                    DataType.WORD -> Pair(DataType.WORD, null)
+                    DataType.FLOAT -> Pair(DataType.FLOAT, left)
+                    else -> throw FatalAstException("non-numeric datatype $rightDt")
+                }
+            }
+            DataType.FLOAT -> {
+                Pair(DataType.FLOAT, right)
+            }
+            else -> throw FatalAstException("non-numeric datatype $leftDt")
+        }
+    }
+}
+
+class ArrayIndexedExpression(val identifier: IdentifierReference,
+                             var arrayspec: ArrayIndex,
+                             override val position: Position) : IExpression {
+    override lateinit var parent: Node
+    override fun linkParents(parent: Node) {
+        this.parent = parent
+        identifier.linkParents(this)
+        arrayspec.linkParents(this)
+    }
+
+    override fun constValue(program: Program): LiteralValue? = null
+    override fun accept(visitor: IAstModifyingVisitor) = visitor.visit(this)
+    override fun accept(visitor: IAstVisitor) = visitor.visit(this)
+    override fun referencesIdentifiers(vararg name: String) = identifier.referencesIdentifiers(*name)
+
+    override fun inferType(program: Program): DataType? {
+        val target = identifier.targetStatement(program.namespace)
+        if (target is VarDecl) {
+            return when (target.datatype) {
+                in NumericDatatypes -> null
+                in StringDatatypes -> DataType.UBYTE
+                in ArrayDatatypes -> ArrayElementTypes[target.datatype]
+                else -> throw FatalAstException("invalid dt")
+            }
+        }
+        return null
+    }
+
+    override fun toString(): String {
+        return "ArrayIndexed(ident=$identifier, arraysize=$arrayspec; pos=$position)"
+    }
+}
+
+class TypecastExpression(var expression: IExpression, var type: DataType, val implicit: Boolean, override val position: Position) : IExpression {
+    override lateinit var parent: Node
+
+    override fun linkParents(parent: Node) {
+        this.parent = parent
+        expression.linkParents(this)
+    }
+
+    override fun accept(visitor: IAstModifyingVisitor) = visitor.visit(this)
+    override fun accept(visitor: IAstVisitor) = visitor.visit(this)
+    override fun referencesIdentifiers(vararg name: String) = expression.referencesIdentifiers(*name)
+    override fun inferType(program: Program): DataType? = type
+    override fun constValue(program: Program): LiteralValue? {
+        val cv = expression.constValue(program) ?: return null
+        return cv.cast(type)
+        // val value = RuntimeValue(cv.type, cv.asNumericValue!!).cast(type)
+        // return LiteralValue.fromNumber(value.numericValue(), value.type, position).cast(type)
+    }
+
+    override fun toString(): String {
+        return "Typecast($expression as $type)"
+    }
+}
+
+data class AddressOf(val identifier: IdentifierReference, override val position: Position) : IExpression {
+    override lateinit var parent: Node
+
+    override fun linkParents(parent: Node) {
+        this.parent = parent
+        identifier.parent=this
+    }
+
+    var scopedname: String? = null     // will be set in a later state by the compiler
+    override fun constValue(program: Program): LiteralValue? = null
+    override fun referencesIdentifiers(vararg name: String) = false
+    override fun inferType(program: Program) = DataType.UWORD
+    override fun accept(visitor: IAstModifyingVisitor) = visitor.visit(this)
+    override fun accept(visitor: IAstVisitor) = visitor.visit(this)
+}
+
+class DirectMemoryRead(var addressExpression: IExpression, override val position: Position) : IExpression {
+    override lateinit var parent: Node
+
+    override fun linkParents(parent: Node) {
+        this.parent = parent
+        this.addressExpression.linkParents(this)
+    }
+
+    override fun accept(visitor: IAstModifyingVisitor) = visitor.visit(this)
+    override fun accept(visitor: IAstVisitor) = visitor.visit(this)
+    override fun referencesIdentifiers(vararg name: String) = false
+    override fun inferType(program: Program): DataType? = DataType.UBYTE
+    override fun constValue(program: Program): LiteralValue? = null
+
+    override fun toString(): String {
+        return "DirectMemoryRead($addressExpression)"
+    }
+}
+
+open class LiteralValue(val type: DataType,
+                        val bytevalue: Short? = null,
+                        val wordvalue: Int? = null,
+                        val floatvalue: Double? = null,
+                        val strvalue: String? = null,
+                        val arrayvalue: Array<IExpression>? = null,
+                        initHeapId: Int? =null,
+                        override val position: Position) : IExpression {
+    override lateinit var parent: Node
+
+    override fun referencesIdentifiers(vararg name: String) = arrayvalue?.any { it.referencesIdentifiers(*name) } ?: false
+
+    val isString = type in StringDatatypes
+    val isNumeric = type in NumericDatatypes
+    val isArray = type in ArrayDatatypes
+    var heapId = initHeapId
+        private set
+
+    companion object {
+        fun fromBoolean(bool: Boolean, position: Position) =
+                LiteralValue(DataType.UBYTE, bytevalue = if (bool) 1 else 0, position = position)
+
+        fun fromNumber(value: Number, type: DataType, position: Position) : LiteralValue {
+            return when(type) {
+                in ByteDatatypes -> LiteralValue(type, bytevalue = value.toShort(), position = position)
+                in WordDatatypes -> LiteralValue(type, wordvalue = value.toInt(), position = position)
+                DataType.FLOAT -> LiteralValue(type, floatvalue = value.toDouble(), position = position)
+                else -> throw FatalAstException("non numeric datatype")
+            }
+        }
+
+        fun optimalNumeric(value: Number, position: Position): LiteralValue {
+            return if(value is Double) {
+                LiteralValue(DataType.FLOAT, floatvalue = value, position = position)
+            } else {
+                when (val intval = value.toInt()) {
+                    in 0..255 -> LiteralValue(DataType.UBYTE, bytevalue = intval.toShort(), position = position)
+                    in -128..127 -> LiteralValue(DataType.BYTE, bytevalue = intval.toShort(), position = position)
+                    in 0..65535 -> LiteralValue(DataType.UWORD, wordvalue = intval, position = position)
+                    in -32768..32767 -> LiteralValue(DataType.WORD, wordvalue = intval, position = position)
+                    else -> LiteralValue(DataType.FLOAT, floatvalue = intval.toDouble(), position = position)
+                }
+            }
+        }
+
+        fun optimalInteger(value: Number, position: Position): LiteralValue {
+            val intval = value.toInt()
+            if(intval.toDouble() != value.toDouble())
+                throw FatalAstException("value is not an integer: $value")
+            return when (intval) {
+                in 0..255 -> LiteralValue(DataType.UBYTE, bytevalue = value.toShort(), position = position)
+                in -128..127 -> LiteralValue(DataType.BYTE, bytevalue = value.toShort(), position = position)
+                in 0..65535 -> LiteralValue(DataType.UWORD, wordvalue = value.toInt(), position = position)
+                else -> throw FatalAstException("integer overflow: $value")
+            }
+        }
+    }
+
+    init {
+        when(type){
+            in ByteDatatypes -> if(bytevalue==null) throw FatalAstException("literal value missing bytevalue")
+            in WordDatatypes -> if(wordvalue==null) throw FatalAstException("literal value missing wordvalue")
+            DataType.FLOAT -> if(floatvalue==null) throw FatalAstException("literal value missing floatvalue")
+            in StringDatatypes ->
+                if(strvalue==null && heapId==null) throw FatalAstException("literal value missing strvalue/heapId")
+            in ArrayDatatypes ->
+                if(arrayvalue==null && heapId==null) throw FatalAstException("literal value missing arrayvalue/heapId")
+            else -> throw FatalAstException("invalid type $type")
+        }
+        if(bytevalue==null && wordvalue==null && floatvalue==null && arrayvalue==null && strvalue==null && heapId==null)
+            throw FatalAstException("literal value without actual value")
+    }
+
+    val asNumericValue: Number? = when {
+        bytevalue!=null -> bytevalue
+        wordvalue!=null -> wordvalue
+        floatvalue!=null -> floatvalue
+        else -> null
+    }
+
+    val asIntegerValue: Int? = when {
+        bytevalue!=null -> bytevalue.toInt()
+        wordvalue!=null -> wordvalue
+        // don't round a float value, otherwise code will not detect that it's not an integer
+        else -> null
+    }
+
+    val asBooleanValue: Boolean =
+            (floatvalue!=null && floatvalue != 0.0) ||
+            (bytevalue!=null && bytevalue != 0.toShort()) ||
+            (wordvalue!=null && wordvalue != 0) ||
+            (strvalue!=null && strvalue.isNotEmpty()) ||
+            (arrayvalue != null && arrayvalue.isNotEmpty())
+
+    override fun linkParents(parent: Node) {
+        this.parent = parent
+        arrayvalue?.forEach {it.linkParents(this)}
+    }
+
+    override fun constValue(program: Program): LiteralValue? {
+        if(arrayvalue!=null) {
+            for(v in arrayvalue) {
+                if(v.constValue(program)==null) return null
+            }
+        }
+        return this
+    }
+
+    override fun accept(visitor: IAstModifyingVisitor) = visitor.visit(this)
+    override fun accept(visitor: IAstVisitor) = visitor.visit(this)
+
+    override fun toString(): String {
+        val vstr = when(type) {
+            DataType.UBYTE -> "ubyte:$bytevalue"
+            DataType.BYTE -> "byte:$bytevalue"
+            DataType.UWORD -> "uword:$wordvalue"
+            DataType.WORD -> "word:$wordvalue"
+            DataType.FLOAT -> "float:$floatvalue"
+            in StringDatatypes -> "str:'${escape(strvalue?:"")}'"
+            in ArrayDatatypes -> "array:$arrayvalue"
+            else -> throw FatalAstException("weird datatype")
+        }
+        return "LiteralValue($vstr)"
+    }
+
+    override fun inferType(program: Program) = type
+
+    override fun hashCode(): Int {
+        val bh = bytevalue?.hashCode() ?: 0x10001234
+        val wh = wordvalue?.hashCode() ?: 0x01002345
+        val fh = floatvalue?.hashCode() ?: 0x00103456
+        val sh = strvalue?.hashCode() ?: 0x00014567
+        val ah = arrayvalue?.hashCode() ?: 0x11119876
+        var hash = bh * 31 xor wh
+        hash = hash*31 xor fh
+        hash = hash*31 xor sh
+        hash = hash*31 xor ah
+        hash = hash*31 xor type.hashCode()
+        return hash
+    }
+
+    override fun equals(other: Any?): Boolean {
+        if(other==null || other !is LiteralValue)
+            return false
+        if(isNumeric && other.isNumeric)
+            return asNumericValue?.toDouble()==other.asNumericValue?.toDouble()
+        if(isArray && other.isArray)
+            return arrayvalue!!.contentEquals(other.arrayvalue!!) && heapId==other.heapId
+        if(isString && other.isString)
+            return strvalue==other.strvalue && heapId==other.heapId
+
+        if(type!=other.type)
+            return false
+
+        return compareTo(other) == 0
+    }
+
+    operator fun compareTo(other: LiteralValue): Int {
+        val numLeft = asNumericValue?.toDouble()
+        val numRight = other.asNumericValue?.toDouble()
+        if(numLeft!=null && numRight!=null)
+            return numLeft.compareTo(numRight)
+
+        if(strvalue!=null && other.strvalue!=null)
+            return strvalue.compareTo(other.strvalue)
+
+        throw ExpressionError("cannot order compare type $type with ${other.type}", other.position)
+    }
+
+    fun cast(targettype: DataType): LiteralValue? {
+        if(type==targettype)
+            return this
+        when(type) {
+            DataType.UBYTE -> {
+                if(targettype== DataType.BYTE && bytevalue!! <= 127)
+                    return LiteralValue(targettype, bytevalue = bytevalue, position = position)
+                if(targettype== DataType.WORD || targettype== DataType.UWORD)
+                    return LiteralValue(targettype, wordvalue = bytevalue!!.toInt(), position = position)
+                if(targettype== DataType.FLOAT)
+                    return LiteralValue(targettype, floatvalue = bytevalue!!.toDouble(), position = position)
+            }
+            DataType.BYTE -> {
+                if(targettype== DataType.UBYTE && bytevalue!! >= 0)
+                    return LiteralValue(targettype, bytevalue = bytevalue, position = position)
+                if(targettype== DataType.UWORD && bytevalue!! >= 0)
+                    return LiteralValue(targettype, wordvalue = bytevalue.toInt(), position = position)
+                if(targettype== DataType.WORD)
+                    return LiteralValue(targettype, wordvalue = bytevalue!!.toInt(), position = position)
+                if(targettype== DataType.FLOAT)
+                    return LiteralValue(targettype, floatvalue = bytevalue!!.toDouble(), position = position)
+            }
+            DataType.UWORD -> {
+                if(targettype== DataType.BYTE && wordvalue!! <= 127)
+                    return LiteralValue(targettype, bytevalue = wordvalue.toShort(), position = position)
+                if(targettype== DataType.UBYTE && wordvalue!! <= 255)
+                    return LiteralValue(targettype, bytevalue = wordvalue.toShort(), position = position)
+                if(targettype== DataType.WORD && wordvalue!! <= 32767)
+                    return LiteralValue(targettype, wordvalue = wordvalue, position = position)
+                if(targettype== DataType.FLOAT)
+                    return LiteralValue(targettype, floatvalue = wordvalue!!.toDouble(), position = position)
+            }
+            DataType.WORD -> {
+                if(targettype== DataType.BYTE && wordvalue!! in -128..127)
+                    return LiteralValue(targettype, bytevalue = wordvalue.toShort(), position = position)
+                if(targettype== DataType.UBYTE && wordvalue!! in 0..255)
+                    return LiteralValue(targettype, bytevalue = wordvalue.toShort(), position = position)
+                if(targettype== DataType.UWORD && wordvalue!! >=0)
+                    return LiteralValue(targettype, wordvalue = wordvalue, position = position)
+                if(targettype== DataType.FLOAT)
+                    return LiteralValue(targettype, floatvalue = wordvalue!!.toDouble(), position = position)
+            }
+            DataType.FLOAT -> {
+                val value = floatvalue!!.toInt()
+                if (targettype == DataType.BYTE && value in -128..127)
+                    return LiteralValue(targettype, bytevalue = value.toShort(), position = position)
+                if (targettype == DataType.UBYTE && value in 0..255)
+                    return LiteralValue(targettype, bytevalue = value.toShort(), position = position)
+                if (targettype == DataType.WORD && value in -32768..32767)
+                    return LiteralValue(targettype, wordvalue = value, position = position)
+                if (targettype == DataType.UWORD && value in 0..65535)
+                    return LiteralValue(targettype, wordvalue = value, position = position)
+            }
+            in StringDatatypes -> {
+                if(targettype in StringDatatypes)
+                    return this
+            }
+            else -> {}
+        }
+        return null    // invalid type conversion from $this to $targettype
+    }
+
+    fun addToHeap(heap: HeapValues) {
+        if(heapId==null) {
+            if (strvalue != null) {
+                heapId = heap.addString(type, strvalue)
+            }
+            else if (arrayvalue!=null) {
+                if(arrayvalue.any {it is AddressOf }) {
+                    val intArrayWithAddressOfs = arrayvalue.map {
+                        when (it) {
+                            is AddressOf -> IntegerOrAddressOf(null, it)
+                            is LiteralValue -> IntegerOrAddressOf(it.asIntegerValue, null)
+                            else -> throw FatalAstException("invalid datatype in array")
+                        }
+                    }
+                    heapId = heap.addIntegerArray(type, intArrayWithAddressOfs.toTypedArray())
+                } else {
+                    val valuesInArray = arrayvalue.map { (it as LiteralValue).asNumericValue!! }
+                    heapId = if(type== DataType.ARRAY_F) {
+                        val doubleArray = valuesInArray.map { it.toDouble() }.toDoubleArray()
+                        heap.addDoublesArray(doubleArray)
+                    } else {
+                        val integerArray = valuesInArray.map { it.toInt() }
+                        heap.addIntegerArray(type, integerArray.map { IntegerOrAddressOf(it, null) }.toTypedArray())
+                    }
+                }
+            }
+        }
+    }
+}
+
+class RangeExpr(var from: IExpression,
+                var to: IExpression,
+                var step: IExpression,
+                override val position: Position) : IExpression {
+    override lateinit var parent: Node
+
+    override fun linkParents(parent: Node) {
+        this.parent = parent
+        from.linkParents(this)
+        to.linkParents(this)
+        step.linkParents(this)
+    }
+
+    override fun constValue(program: Program): LiteralValue? = null
+    override fun accept(visitor: IAstModifyingVisitor) = visitor.visit(this)
+    override fun accept(visitor: IAstVisitor) = visitor.visit(this)
+    override fun referencesIdentifiers(vararg name: String): Boolean  = from.referencesIdentifiers(*name) || to.referencesIdentifiers(*name)
+    override fun inferType(program: Program): DataType? {
+        val fromDt=from.inferType(program)
+        val toDt=to.inferType(program)
+        return when {
+            fromDt==null || toDt==null -> null
+            fromDt== DataType.UBYTE && toDt== DataType.UBYTE -> DataType.UBYTE
+            fromDt== DataType.UWORD && toDt== DataType.UWORD -> DataType.UWORD
+            fromDt== DataType.STR && toDt== DataType.STR -> DataType.STR
+            fromDt== DataType.STR_S && toDt== DataType.STR_S -> DataType.STR_S
+            fromDt== DataType.WORD || toDt== DataType.WORD -> DataType.WORD
+            fromDt== DataType.BYTE || toDt== DataType.BYTE -> DataType.BYTE
+            else -> DataType.UBYTE
+        }
+    }
+    override fun toString(): String {
+        return "RangeExpr(from $from, to $to, step $step, pos=$position)"
+    }
+
+    fun size(): Int? {
+        val fromLv = (from as? LiteralValue)
+        val toLv = (to as? LiteralValue)
+        if(fromLv==null || toLv==null)
+            return null
+        return toConstantIntegerRange()?.count()
+    }
+
+    fun toConstantIntegerRange(): IntProgression? {
+        val fromLv = from as? LiteralValue
+        val toLv = to as? LiteralValue
+        if(fromLv==null || toLv==null)
+            return null         // non-constant range
+        val fromVal: Int
+        val toVal: Int
+        if(fromLv.isString && toLv.isString) {
+            // string range -> int range over petscii values
+            fromVal = Petscii.encodePetscii(fromLv.strvalue!!, true)[0].toInt()
+            toVal = Petscii.encodePetscii(toLv.strvalue!!, true)[0].toInt()
+        } else {
+            // integer range
+            fromVal = (from as LiteralValue).asIntegerValue!!
+            toVal = (to as LiteralValue).asIntegerValue!!
+        }
+        val stepVal = (step as? LiteralValue)?.asIntegerValue ?: 1
+        return when {
+            fromVal <= toVal -> when {
+                stepVal <= 0 -> IntRange.EMPTY
+                stepVal == 1 -> fromVal..toVal
+                else -> fromVal..toVal step stepVal
+            }
+            else -> when {
+                stepVal >= 0 -> IntRange.EMPTY
+                stepVal == -1 -> fromVal downTo toVal
+                else -> fromVal downTo toVal step abs(stepVal)
+            }
+        }
+    }
+}
+
+class RegisterExpr(val register: Register, override val position: Position) : IExpression {
+    override lateinit var parent: Node
+
+    override fun linkParents(parent: Node) {
+        this.parent = parent
+    }
+
+    override fun constValue(program: Program): LiteralValue? = null
+    override fun accept(visitor: IAstModifyingVisitor) = visitor.visit(this)
+    override fun accept(visitor: IAstVisitor) = visitor.visit(this)
+    override fun referencesIdentifiers(vararg name: String): Boolean = register.name in name
+    override fun toString(): String {
+        return "RegisterExpr(register=$register, pos=$position)"
+    }
+
+    override fun inferType(program: Program) = DataType.UBYTE
+}
+
+data class IdentifierReference(val nameInSource: List<String>, override val position: Position) : IExpression {
+    override lateinit var parent: Node
+
+    fun targetStatement(namespace: INameScope) =
+        if(nameInSource.size==1 && nameInSource[0] in BuiltinFunctions)
+            BuiltinFunctionStatementPlaceholder(nameInSource[0], position)
+        else
+            namespace.lookup(nameInSource, this)
+
+    fun targetVarDecl(namespace: INameScope): VarDecl? = targetStatement(namespace) as? VarDecl
+    fun targetSubroutine(namespace: INameScope): Subroutine? = targetStatement(namespace) as? Subroutine
+
+    override fun linkParents(parent: Node) {
+        this.parent = parent
+    }
+
+    override fun constValue(program: Program): LiteralValue? {
+        val node = program.namespace.lookup(nameInSource, this)
+                ?: throw UndefinedSymbolError(this)
+        val vardecl = node as? VarDecl
+        if(vardecl==null) {
+            return null
+        } else if(vardecl.type!= VarDeclType.CONST) {
+            return null
+        }
+        return vardecl.value?.constValue(program)
+    }
+
+    override fun toString(): String {
+        return "IdentifierRef($nameInSource)"
+    }
+
+    override fun accept(visitor: IAstModifyingVisitor) = visitor.visit(this)
+    override fun accept(visitor: IAstVisitor) = visitor.visit(this)
+    override fun referencesIdentifiers(vararg name: String): Boolean = nameInSource.last() in name   // @todo is this correct all the time?
+
+    override fun inferType(program: Program): DataType? {
+        val targetStmt = targetStatement(program.namespace)
+        if(targetStmt is VarDecl) {
+            return targetStmt.datatype
+        } else {
+            throw FatalAstException("cannot get datatype from identifier reference ${this}, pos=$position")
+        }
+    }
+
+    fun heapId(namespace: INameScope): Int {
+        val node = namespace.lookup(nameInSource, this) ?: throw UndefinedSymbolError(this)
+        return ((node as? VarDecl)?.value as? LiteralValue)?.heapId ?: throw FatalAstException("identifier is not on the heap: $this")
+    }
+}
+
+class FunctionCall(override var target: IdentifierReference,
+                   override var arglist: MutableList<IExpression>,
+                   override val position: Position) : IExpression, IFunctionCall {
+    override lateinit var parent: Node
+
+    override fun linkParents(parent: Node) {
+        this.parent = parent
+        target.linkParents(this)
+        arglist.forEach { it.linkParents(this) }
+    }
+
+    override fun constValue(program: Program) = constValue(program, true)
+
+    private fun constValue(program: Program, withDatatypeCheck: Boolean): LiteralValue? {
+        // if the function is a built-in function and the args are consts, should try to const-evaluate!
+        // lenghts of arrays and strings are constants that are determined at compile time!
+        if(target.nameInSource.size>1) return null
+        try {
+            var resultValue: LiteralValue? = null
+            val func = BuiltinFunctions[target.nameInSource[0]]
+            if(func!=null) {
+                val exprfunc = func.constExpressionFunc
+                if(exprfunc!=null)
+                    resultValue = exprfunc(arglist, position, program)
+                else if(func.returntype==null)
+                    throw ExpressionError("builtin function ${target.nameInSource[0]} can't be used here because it doesn't return a value", position)
+            }
+
+            if(withDatatypeCheck) {
+                val resultDt = this.inferType(program)
+                if(resultValue==null || resultDt == resultValue.type)
+                    return resultValue
+                throw FatalAstException("evaluated const expression result value doesn't match expected datatype $resultDt, pos=$position")
+            } else {
+                return resultValue
+            }
+        }
+        catch(x: NotConstArgumentException) {
+            // const-evaluating the builtin function call failed.
+            return null
+        }
+    }
+
+    override fun toString(): String {
+        return "FunctionCall(target=$target, pos=$position)"
+    }
+
+    override fun accept(visitor: IAstModifyingVisitor) = visitor.visit(this)
+    override fun accept(visitor: IAstVisitor) = visitor.visit(this)
+    override fun referencesIdentifiers(vararg name: String): Boolean = target.referencesIdentifiers(*name) || arglist.any{it.referencesIdentifiers(*name)}
+
+    override fun inferType(program: Program): DataType? {
+        val constVal = constValue(program ,false)
+        if(constVal!=null)
+            return constVal.type
+        val stmt = target.targetStatement(program.namespace) ?: return null
+        when (stmt) {
+            is BuiltinFunctionStatementPlaceholder -> {
+                if(target.nameInSource[0] == "set_carry" || target.nameInSource[0]=="set_irqd" ||
+                        target.nameInSource[0] == "clear_carry" || target.nameInSource[0]=="clear_irqd") {
+                    return null // these have no return value
+                }
+                return builtinFunctionReturnType(target.nameInSource[0], this.arglist, program)
+            }
+            is Subroutine -> {
+                if(stmt.returntypes.isEmpty())
+                    return null     // no return value
+                if(stmt.returntypes.size==1)
+                    return stmt.returntypes[0]
+                return null     // has multiple return types... so not a single resulting datatype possible
+            }
+            is Label -> return null
+        }
+        return null     // calling something we don't recognise...
+    }
+}

compiler/src/prog8/ast/processing/AstChecker.kt

@@ -1,58 +1,19 @@
-package prog8.ast
+package prog8.ast.processing
 
+import prog8.ast.*
+import prog8.ast.base.*
+import prog8.ast.base.printWarning
+import prog8.ast.expressions.*
+import prog8.ast.statements.*
 import prog8.compiler.CompilationOptions
 import prog8.compiler.HeapValues
-import prog8.compiler.target.c64.FLOAT_MAX_NEGATIVE
-import prog8.compiler.target.c64.FLOAT_MAX_POSITIVE
+import prog8.compiler.target.c64.MachineDefinition.FLOAT_MAX_NEGATIVE
+import prog8.compiler.target.c64.MachineDefinition.FLOAT_MAX_POSITIVE
 import prog8.functions.BuiltinFunctions
-import prog8.parser.ParsingFailedError
 import java.io.File
 
-/**
- * General checks on the Ast
- */
-
-internal fun Program.checkValid(compilerOptions: CompilationOptions) {
-    val checker = AstChecker(this, compilerOptions)
-    checker.process(this)
-    printErrors(checker.result(), name)
-}
-
-
-fun printErrors(errors: List<Any>, moduleName: String) {
-    val reportedMessages = mutableSetOf<String>()
-    print("\u001b[91m")  // bright red
-    errors.forEach {
-        val msg = it.toString()
-        if(msg !in reportedMessages) {
-            System.err.println(msg)
-            reportedMessages.add(msg)
-        }
-    }
-    print("\u001b[0m")  // reset color
-    if(reportedMessages.isNotEmpty())
-        throw ParsingFailedError("There are ${reportedMessages.size} errors in module '$moduleName'.")
-}
-
-
-fun printWarning(msg: String, position: Position, detailInfo: String?=null) {
-    print("\u001b[93m")  // bright yellow
-    print("$position Warning: $msg")
-    if(detailInfo==null)
-        print("\n")
-    else
-        println(": $detailInfo\n")
-    print("\u001b[0m")  // normal
-}
-
-fun printWarning(msg: String) {
-    print("\u001b[93m")  // bright yellow
-    print("Warning: $msg")
-    print("\u001b[0m\n")  // normal
-}
-
-private class AstChecker(private val program: Program,
-                 private val compilerOptions: CompilationOptions) : IAstProcessor {
+internal class AstChecker(private val program: Program,
+                         private val compilerOptions: CompilationOptions) : IAstModifyingVisitor {
     private val checkResult: MutableList<AstException> = mutableListOf()
     private val heapStringSentinel: Int
     init {
@@ -64,7 +25,7 @@ private class AstChecker(private val program: Program,
         return checkResult
     }
 
-    override fun process(program: Program) {
+    override fun visit(program: Program) {
         assert(program === this.program)
         // there must be a single 'main' block with a 'start' subroutine for the program entry point.
         val mainBlocks = program.modules.flatMap { it.statements }.filter { b -> b is Block && b.name=="main" }.map { it as Block }
@@ -113,11 +74,11 @@ private class AstChecker(private val program: Program,
             }
         }
 
-        super.process(program)
+        super.visit(program)
     }
 
-    override fun process(module: Module) {
-        super.process(module)
+    override fun visit(module: Module) {
+        super.visit(module)
         val directives = module.statements.filterIsInstance<Directive>().groupBy { it.directive }
         directives.filter { it.value.size > 1 }.forEach{ entry ->
             when(entry.key) {
@@ -127,27 +88,27 @@ private class AstChecker(private val program: Program,
         }
     }
 
-    override fun process(returnStmt: Return): IStatement {
+    override fun visit(returnStmt: Return): IStatement {
         val expectedReturnValues = returnStmt.definingSubroutine()?.returntypes ?: emptyList()
-        if(expectedReturnValues.size != returnStmt.values.size) {
-            // if the return value is a function call, check the result of that call instead
-            if(returnStmt.values.size==1 && returnStmt.values[0] is FunctionCall) {
-                val dt = (returnStmt.values[0] as FunctionCall).inferType(program)
-                if(dt!=null && expectedReturnValues.isEmpty())
-                    checkResult.add(SyntaxError("invalid number of return values", returnStmt.position))
-            } else
-                checkResult.add(SyntaxError("invalid number of return values", returnStmt.position))
+        if(expectedReturnValues.size>1) {
+            throw AstException("cannot use a return with one value in a subroutine that has multiple return values: $returnStmt")
         }
 
-        for (rv in expectedReturnValues.withIndex().zip(returnStmt.values)) {
-            val valueDt=rv.second.inferType(program)
-            if(rv.first.value!=valueDt)
-                checkResult.add(ExpressionError("type $valueDt of return value #${rv.first.index+1} doesn't match subroutine return type ${rv.first.value}", rv.second.position))
+        if(expectedReturnValues.isEmpty() && returnStmt.value!=null) {
+            checkResult.add(SyntaxError("invalid number of return values", returnStmt.position))
         }
-        return super.process(returnStmt)
+        if(expectedReturnValues.isNotEmpty() && returnStmt.value==null) {
+            checkResult.add(SyntaxError("invalid number of return values", returnStmt.position))
+        }
+        if(expectedReturnValues.size==1 && returnStmt.value!=null) {
+            val valueDt = returnStmt.value!!.inferType(program)
+            if(expectedReturnValues[0]!=valueDt)
+                checkResult.add(ExpressionError("type $valueDt of return value doesn't match subroutine's return type", returnStmt.value!!.position))
+        }
+        return super.visit(returnStmt)
     }
 
-    override fun process(forLoop: ForLoop): IStatement {
+    override fun visit(forLoop: ForLoop): IStatement {
         if(forLoop.body.containsNoCodeNorVars())
             printWarning("for loop body is empty", forLoop.position)
 
@@ -156,38 +117,37 @@ private class AstChecker(private val program: Program,
             checkResult.add(ExpressionError("can only loop over an iterable type", forLoop.position))
         } else {
             if (forLoop.loopRegister != null) {
-                printWarning("using a register as loop variable is risky (it could get clobbered in the body)", forLoop.position)
+                printWarning("using a register as loop variable is risky (it could get clobbered)", forLoop.position)
                 // loop register
-                if (iterableDt != DataType.UBYTE && iterableDt!=DataType.ARRAY_UB && iterableDt !in StringDatatypes)
+                if (iterableDt != DataType.UBYTE && iterableDt!= DataType.ARRAY_UB && iterableDt !in StringDatatypes)
                     checkResult.add(ExpressionError("register can only loop over bytes", forLoop.position))
             } else {
                 // loop variable
                 val loopvar = forLoop.loopVar!!.targetVarDecl(program.namespace)
-                if(loopvar==null || loopvar.type==VarDeclType.CONST) {
+                if(loopvar==null || loopvar.type== VarDeclType.CONST) {
                     checkResult.add(SyntaxError("for loop requires a variable to loop with", forLoop.position))
-
                 } else {
                     when (loopvar.datatype) {
                         DataType.UBYTE -> {
-                            if(iterableDt!=DataType.UBYTE && iterableDt!=DataType.ARRAY_UB && iterableDt !in StringDatatypes)
+                            if(iterableDt!= DataType.UBYTE && iterableDt!= DataType.ARRAY_UB && iterableDt !in StringDatatypes)
                                 checkResult.add(ExpressionError("ubyte loop variable can only loop over unsigned bytes or strings", forLoop.position))
                         }
                         DataType.UWORD -> {
-                            if(iterableDt!=DataType.UBYTE && iterableDt!=DataType.UWORD && iterableDt !in StringDatatypes &&
-                                    iterableDt !=DataType.ARRAY_UB && iterableDt!=DataType.ARRAY_UW)
+                            if(iterableDt!= DataType.UBYTE && iterableDt!= DataType.UWORD && iterableDt !in StringDatatypes &&
+                                    iterableDt != DataType.ARRAY_UB && iterableDt!= DataType.ARRAY_UW)
                                 checkResult.add(ExpressionError("uword loop variable can only loop over unsigned bytes, words or strings", forLoop.position))
                         }
                         DataType.BYTE -> {
-                            if(iterableDt!=DataType.BYTE && iterableDt!=DataType.ARRAY_B)
+                            if(iterableDt!= DataType.BYTE && iterableDt!= DataType.ARRAY_B)
                                 checkResult.add(ExpressionError("byte loop variable can only loop over bytes", forLoop.position))
                         }
                         DataType.WORD -> {
-                            if(iterableDt!=DataType.BYTE && iterableDt!=DataType.WORD &&
-                                    iterableDt !=DataType.ARRAY_B && iterableDt!=DataType.ARRAY_W)
+                            if(iterableDt!= DataType.BYTE && iterableDt!= DataType.WORD &&
+                                    iterableDt != DataType.ARRAY_B && iterableDt!= DataType.ARRAY_W)
                                 checkResult.add(ExpressionError("word loop variable can only loop over bytes or words", forLoop.position))
                         }
                         DataType.FLOAT -> {
-                            if(iterableDt!=DataType.FLOAT && iterableDt != DataType.ARRAY_F)
+                            if(iterableDt!= DataType.FLOAT && iterableDt != DataType.ARRAY_F)
                                 checkResult.add(ExpressionError("float loop variable can only loop over floats", forLoop.position))
                         }
                         else -> checkResult.add(ExpressionError("loop variable must be numeric type", forLoop.position))
@@ -195,10 +155,10 @@ private class AstChecker(private val program: Program,
                 }
             }
         }
-        return super.process(forLoop)
+        return super.visit(forLoop)
     }
 
-    override fun process(jump: Jump): IStatement {
+    override fun visit(jump: Jump): IStatement {
         if(jump.identifier!=null) {
             val targetStatement = checkFunctionOrLabelExists(jump.identifier, jump)
             if(targetStatement!=null) {
@@ -209,29 +169,29 @@ private class AstChecker(private val program: Program,
 
         if(jump.address!=null && (jump.address < 0 || jump.address > 65535))
             checkResult.add(SyntaxError("jump address must be valid integer 0..\$ffff", jump.position))
-        return super.process(jump)
+        return super.visit(jump)
     }
 
-    override fun process(block: Block): IStatement {
+    override fun visit(block: Block): IStatement {
         if(block.address!=null && (block.address<0 || block.address>65535)) {
             checkResult.add(SyntaxError("block memory address must be valid integer 0..\$ffff", block.position))
         }
 
-        return super.process(block)
+        return super.visit(block)
     }
 
-    override fun process(label: Label): IStatement {
+    override fun visit(label: Label): IStatement {
         // scope check
         if(label.parent !is Block && label.parent !is Subroutine && label.parent !is AnonymousScope) {
             checkResult.add(SyntaxError("Labels can only be defined in the scope of a block, a loop body, or within another subroutine", label.position))
         }
-        return super.process(label)
+        return super.visit(label)
     }
 
     /**
      * Check subroutine definition
      */
-    override fun process(subroutine: Subroutine): IStatement {
+    override fun visit(subroutine: Subroutine): IStatement {
         fun err(msg: String) {
             checkResult.add(SyntaxError(msg, subroutine.position))
         }
@@ -243,7 +203,7 @@ private class AstChecker(private val program: Program,
         if(uniqueNames.size!=subroutine.parameters.size)
             err("parameter names must be unique")
 
-        super.process(subroutine)
+        super.visit(subroutine)
 
         // user-defined subroutines can only have zero or one return type
         // (multiple return values are only allowed for asm subs)
@@ -351,42 +311,59 @@ private class AstChecker(private val program: Program,
             // This is not easy to fix because strings and arrays are treated a bit simplistic (a "virtual" pointer to the value on the heap)
             // while passing them as subroutine parameters would require a "real" pointer OR copying the VALUE to the subroutine's parameter variable (which is very inefficient).
             // For now, don't pass strings and arrays as parameters and instead create the workaround as suggested in the error message below.
-            if(!subroutine.parameters.all{it.type in NumericDatatypes}) {
+            if(!subroutine.parameters.all{it.type in NumericDatatypes }) {
                 err("Non-asm subroutine can only take numerical parameters (no str/array types) for now. Workaround (for nested subroutine): access the variable from the outer scope directly.")
             }
         }
         return subroutine
     }
 
+    override fun visit(repeatLoop: RepeatLoop): IStatement {
+        if(repeatLoop.untilCondition.referencesIdentifiers("A", "X", "Y"))
+            printWarning("using a register in the loop condition is risky (it could get clobbered)", repeatLoop.untilCondition.position)
+        return super.visit(repeatLoop)
+    }
+
+    override fun visit(whileLoop: WhileLoop): IStatement {
+        if(whileLoop.condition.referencesIdentifiers("A", "X", "Y"))
+            printWarning("using a register in the loop condition is risky (it could get clobbered)", whileLoop.condition.position)
+        return super.visit(whileLoop)
+    }
+
     /**
      * Assignment target must be register, or a variable name
      * Also check data type compatibility and number of values
      */
-    override fun process(assignment: Assignment): IStatement {
+    override fun visit(assignment: Assignment): IStatement {
 
         // assigning from a functioncall COULD return multiple values (from an asm subroutine)
         if(assignment.value is FunctionCall) {
             val stmt = (assignment.value as FunctionCall).target.targetStatement(program.namespace)
-            if (stmt is Subroutine) {
-                if (stmt.isAsmSubroutine) {
-                    if (stmt.returntypes.size != assignment.targets.size)
-                        checkResult.add(ExpressionError("number of return values doesn't match number of assignment targets", assignment.value.position))
-                    else {
-                        for (thing in stmt.returntypes.zip(assignment.targets)) {
-                            if (thing.second.inferType(program, assignment) != thing.first)
-                                checkResult.add(ExpressionError("return type mismatch for target ${thing.second.shortString()}", assignment.value.position))
-                        }
+            if (stmt is Subroutine && stmt.isAsmSubroutine) {
+                if(stmt.returntypes.size>1)
+                    checkResult.add(ExpressionError("It's not possible to store the multipel results of this asmsub call; you should use a small block of custom inline assembly for this.", assignment.value.position))
+                else {
+                    if(stmt.returntypes.single()!=assignment.target.inferType(program, assignment)) {
+                         checkResult.add(ExpressionError("return type mismatch", assignment.value.position))
                     }
-                } else if(assignment.targets.size>1)
-                    checkResult.add(ExpressionError("only asmsub subroutines can return multiple values", assignment.value.position))
+                }
+            }
+        }
+
+        val sourceIdent = assignment.value as? IdentifierReference
+        val targetIdent = assignment.target.identifier
+        if(sourceIdent!=null && targetIdent!=null) {
+            val sourceVar = sourceIdent.targetVarDecl(program.namespace)
+            val targetVar = targetIdent.targetVarDecl(program.namespace)
+            if(sourceVar?.struct!=null && targetVar?.struct!=null) {
+                if(sourceVar.struct!==targetVar.struct)
+                    checkResult.add(ExpressionError("assignment of different struct types", assignment.position))
             }
         }
 
         var resultingAssignment = assignment
-        for (target in assignment.targets) {
-            resultingAssignment = processAssignmentTarget(resultingAssignment, target)
-        }
-        return super.process(resultingAssignment)
+        resultingAssignment = processAssignmentTarget(resultingAssignment, assignment.target)
+        return super.visit(resultingAssignment)
     }
 
     private fun processAssignmentTarget(assignment: Assignment, target: AssignTarget): Assignment {
@@ -431,7 +408,7 @@ private class AstChecker(private val program: Program,
 
             val expression = BinaryExpression(newTarget, assignment.aug_op.substringBeforeLast('='), assignment.value, assignment.position)
             expression.linkParents(assignment.parent)
-            val assignment2 = Assignment(listOf(target), null, expression, assignment.position)
+            val assignment2 = Assignment(target, null, expression, assignment.position)
             assignment2.linkParents(assignment.parent)
             return assignment2
         }
@@ -440,73 +417,74 @@ private class AstChecker(private val program: Program,
         if(targetDatatype!=null) {
             val constVal = assignment.value.constValue(program)
             if(constVal!=null) {
-                val arrayspec = if(target.identifier!=null) {
-                    val targetVar = program.namespace.lookup(target.identifier.nameInSource, assignment) as? VarDecl
-                    targetVar?.arraysize
-                } else null
-                checkValueTypeAndRange(targetDatatype,
+                val targetVar =
+                        if(target.identifier!=null)
+                            program.namespace.lookup(target.identifier.nameInSource, assignment) as? VarDecl
+                        else
+                            null
+                val arrayspec = if(target.identifier!=null) targetVar?.arraysize else null
+                checkValueTypeAndRange(targetDatatype, targetVar?.struct,
                         arrayspec ?: ArrayIndex(LiteralValue.optimalInteger(-1, assignment.position), assignment.position),
                         constVal, program.heap)
             } else {
                 val sourceDatatype: DataType? = assignment.value.inferType(program)
                 if(sourceDatatype==null) {
-                    if(assignment.targets.size<=1) {
-                        if (assignment.value is FunctionCall) {
-                            val targetStmt = (assignment.value as FunctionCall).target.targetStatement(program.namespace)
-                            if(targetStmt!=null)
-                                checkResult.add(ExpressionError("function call doesn't return a suitable value to use in assignment", assignment.value.position))
-                        }
-                        else
-                            checkResult.add(ExpressionError("assignment value is invalid or has no proper datatype", assignment.value.position))
+                    if (assignment.value is FunctionCall) {
+                        val targetStmt = (assignment.value as FunctionCall).target.targetStatement(program.namespace)
+                        if(targetStmt!=null)
+                            checkResult.add(ExpressionError("function call doesn't return a suitable value to use in assignment", assignment.value.position))
                     }
+                    else
+                        checkResult.add(ExpressionError("assignment value is invalid or has no proper datatype", assignment.value.position))
+                }
+                else {
+                    checkAssignmentCompatible(targetDatatype, target, sourceDatatype, assignment.value, assignment.position)
                 }
-                else
-                    checkAssignmentCompatible(targetDatatype, sourceDatatype, assignment.value, assignment.targets, assignment.position)
             }
         }
         return assignment
     }
 
-    override fun process(addressOf: AddressOf): IExpression {
+    override fun visit(addressOf: AddressOf): IExpression {
         val variable=addressOf.identifier.targetVarDecl(program.namespace)
         if(variable==null)
             checkResult.add(ExpressionError("pointer-of operand must be the name of a heap variable", addressOf.position))
         else {
-            if(variable.datatype !in ArrayDatatypes && variable.datatype !in StringDatatypes)
-                checkResult.add(ExpressionError("pointer-of operand must be the name of a string or array heap variable", addressOf.position))
+            if(variable.datatype !in ArrayDatatypes && variable.datatype !in StringDatatypes && variable.datatype!=DataType.STRUCT)
+                checkResult.add(ExpressionError("invalid pointer-of operand type", addressOf.position))
         }
         if(addressOf.scopedname==null)
             throw FatalAstException("the scopedname of AddressOf should have been set by now  $addressOf")
-        return super.process(addressOf)
+        return super.visit(addressOf)
     }
 
     /**
      * Check the variable declarations (values within range etc)
      */
-    override fun process(decl: VarDecl): IStatement {
+    override fun visit(decl: VarDecl): IStatement {
         fun err(msg: String, position: Position?=null) {
             checkResult.add(SyntaxError(msg, position ?: decl.position))
         }
 
         // the initializer value can't refer to the variable itself (recursive definition)
-        if(decl.value?.referencesIdentifier(decl.name) == true || decl.arraysize?.index?.referencesIdentifier(decl.name) == true) {
+        if(decl.value?.referencesIdentifiers(decl.name) == true || decl.arraysize?.index?.referencesIdentifiers(decl.name) == true) {
             err("recursive var declaration")
         }
 
         // CONST can only occur on simple types (byte, word, float)
-        if(decl.type==VarDeclType.CONST) {
+        if(decl.type== VarDeclType.CONST) {
             if (decl.datatype !in NumericDatatypes)
                 err("const modifier can only be used on numeric types (byte, word, float)")
         }
 
         // FLOATS
-        if(!compilerOptions.floats && decl.datatype in setOf(DataType.FLOAT, DataType.ARRAY_F) && decl.type!=VarDeclType.MEMORY) {
+        if(!compilerOptions.floats && decl.datatype in setOf(DataType.FLOAT, DataType.ARRAY_F) && decl.type!= VarDeclType.MEMORY) {
             checkResult.add(SyntaxError("floating point used, but that is not enabled via options", decl.position))
         }
 
         // ARRAY without size specifier MUST have an iterable initializer value
         if(decl.isArray && decl.arraysize==null) {
-            if(decl.type==VarDeclType.MEMORY)
+            if(decl.type== VarDeclType.MEMORY)
                 checkResult.add(SyntaxError("memory mapped array must have a size specification", decl.position))
             if(decl.value==null) {
                 checkResult.add(SyntaxError("array variable is missing a size specification or an initialization value", decl.position))
@@ -522,28 +500,41 @@ private class AstChecker(private val program: Program,
 
         when(decl.type) {
             VarDeclType.VAR, VarDeclType.CONST -> {
+                if(decl.datatype==DataType.STRUCT) {
+                    if(decl.struct==null)
+                        throw FatalAstException("struct vardecl should be linked to its struct $decl")
+                    if(decl.zeropage==ZeropageWish.PREFER_ZEROPAGE || decl.zeropage==ZeropageWish.REQUIRE_ZEROPAGE)
+                        err("struct can not be in zeropage")
+                }
+                if(decl.struct!=null) {
+                    if(decl.zeropage==ZeropageWish.PREFER_ZEROPAGE || decl.zeropage==ZeropageWish.REQUIRE_ZEROPAGE)
+                        err("struct can not be in zeropage")
+                }
                 if (decl.value == null) {
                     when {
                         decl.datatype in NumericDatatypes -> {
                             // initialize numeric var with value zero by default.
                             val litVal =
                                     when {
-                                        decl.datatype in ByteDatatypes -> LiteralValue(decl.datatype, bytevalue=0, position = decl.position)
-                                        decl.datatype in WordDatatypes -> LiteralValue(decl.datatype, wordvalue=0, position = decl.position)
-                                        else -> LiteralValue(decl.datatype, floatvalue=0.0, position = decl.position)
+                                        decl.datatype in ByteDatatypes -> LiteralValue(decl.datatype, bytevalue = 0, position = decl.position)
+                                        decl.datatype in WordDatatypes -> LiteralValue(decl.datatype, wordvalue = 0, position = decl.position)
+                                        else -> LiteralValue(decl.datatype, floatvalue = 0.0, position = decl.position)
                                     }
                             litVal.parent = decl
                             decl.value = litVal
                         }
-                        decl.type==VarDeclType.VAR -> {
-                            val litVal = LiteralValue(decl.datatype, initHeapId = heapStringSentinel, position=decl.position)    // point to the sentinel heap value instead
+                        decl.datatype == DataType.STRUCT -> {
+                            // TODO structs are not initialized with a literal value yet, should be an array of zeros!
+                        }
+                        decl.type== VarDeclType.VAR -> {
+                            val litVal = LiteralValue(decl.datatype, initHeapId = heapStringSentinel, position = decl.position)    // point to the sentinel heap value instead
                             litVal.parent=decl
                             decl.value = litVal
                         }
                         else -> err("var/const declaration needs a compile-time constant initializer value for type ${decl.datatype}")
                         // const fold should have provided it!
                     }
-                    return super.process(decl)
+                    return super.visit(decl)
                 }
                 when {
                     decl.value is RangeExpr -> {
@@ -557,11 +548,11 @@ private class AstChecker(private val program: Program,
                                 else
                                     ArrayIndex(LiteralValue.optimalInteger(-2, decl.position), decl.position)
                                 )
-                        checkValueTypeAndRange(decl.datatype, arraySpec, decl.value as LiteralValue, program.heap)
+                        checkValueTypeAndRange(decl.datatype, decl.struct, arraySpec, decl.value as LiteralValue, program.heap)
                     }
                     else -> {
-                        err("var/const declaration needs a compile-time constant initializer value, or range, instead found: ${decl.value!!::class.simpleName}")
-                        return super.process(decl)
+                        err("var/const declaration needs a compile-time constant initializer value, or range, instead found: ${decl.value!!.javaClass.simpleName}")
+                        return super.visit(decl)
                     }
                 }
             }
@@ -583,7 +574,7 @@ private class AstChecker(private val program: Program,
                 }
 
                 if(decl.value !is LiteralValue) {
-                    err("value of memory var decl is not a literal (it is a ${decl.value!!::class.simpleName}).", decl.value?.position)
+                    err("value of memory var decl is not a literal (it is a ${decl.value!!.javaClass.simpleName}).", decl.value?.position)
                 } else {
                     val value = decl.value as LiteralValue
                     if (value.asIntegerValue == null || value.asIntegerValue< 0 || value.asIntegerValue > 65535) {
@@ -593,13 +584,13 @@ private class AstChecker(private val program: Program,
             }
         }
 
-        return super.process(decl)
+        return super.visit(decl)
     }
 
     /**
      * check the arguments of the directive
      */
-    override fun process(directive: Directive): IStatement {
+    override fun visit(directive: Directive): IStatement {
         fun err(msg: String) {
             checkResult.add(SyntaxError(msg, directive.position))
         }
@@ -670,7 +661,7 @@ private class AstChecker(private val program: Program,
             }
             else -> throw SyntaxError("invalid directive ${directive.directive}", directive.position)
         }
-        return super.process(directive)
+        return super.visit(directive)
     }
 
     private fun checkFileExists(directive: Directive, filename: String) {
@@ -681,7 +672,7 @@ private class AstChecker(private val program: Program,
             checkResult.add(NameError("included file not found: $filename", directive.position))
     }
 
-    override fun process(literalValue: LiteralValue): LiteralValue {
+    override fun visit(literalValue: LiteralValue): LiteralValue {
         if(!compilerOptions.floats && literalValue.type in setOf(DataType.FLOAT, DataType.ARRAY_F)) {
             checkResult.add(SyntaxError("floating point used, but that is not enabled via options", literalValue.position))
         }
@@ -690,9 +681,9 @@ private class AstChecker(private val program: Program,
                     ArrayIndex.forArray(literalValue, program.heap)
                 else
                     ArrayIndex(LiteralValue.optimalInteger(-3, literalValue.position), literalValue.position)
-        checkValueTypeAndRange(literalValue.type, arrayspec, literalValue, program.heap)
+        checkValueTypeAndRange(literalValue.type, null, arrayspec, literalValue, program.heap)
 
-        val lv = super.process(literalValue)
+        val lv = super.visit(literalValue)
         when(lv.type) {
             in StringDatatypes -> {
                 if(lv.heapId==null)
@@ -707,17 +698,17 @@ private class AstChecker(private val program: Program,
         return lv
     }
 
-    override fun process(expr: PrefixExpression): IExpression {
+    override fun visit(expr: PrefixExpression): IExpression {
         if(expr.operator=="-") {
             val dt = expr.inferType(program)
             if (dt != DataType.BYTE && dt != DataType.WORD && dt != DataType.FLOAT) {
                 checkResult.add(ExpressionError("can only take negative of a signed number type", expr.position))
             }
         }
-        return super.process(expr)
+        return super.visit(expr)
     }
 
-    override fun process(expr: BinaryExpression): IExpression {
+    override fun visit(expr: BinaryExpression): IExpression {
         val leftDt = expr.left.inferType(program)
         val rightDt = expr.right.inferType(program)
 
@@ -728,7 +719,7 @@ private class AstChecker(private val program: Program,
                 if(divisor==0.0)
                     checkResult.add(ExpressionError("division by zero", expr.right.position))
                 if(expr.operator=="%") {
-                    if ((rightDt != DataType.UBYTE && rightDt != DataType.UWORD) || (leftDt!=DataType.UBYTE && leftDt!=DataType.UWORD))
+                    if ((rightDt != DataType.UBYTE && rightDt != DataType.UWORD) || (leftDt!= DataType.UBYTE && leftDt!= DataType.UWORD))
                         checkResult.add(ExpressionError("remainder can only be used on unsigned integer operands", expr.right.position))
                 }
             }
@@ -756,20 +747,20 @@ private class AstChecker(private val program: Program,
             checkResult.add(ExpressionError("left operand is not numeric", expr.left.position))
         if(rightDt!in NumericDatatypes)
             checkResult.add(ExpressionError("right operand is not numeric", expr.right.position))
-        return super.process(expr)
+        return super.visit(expr)
     }
 
-    override fun process(typecast: TypecastExpression): IExpression {
+    override fun visit(typecast: TypecastExpression): IExpression {
         if(typecast.type in IterableDatatypes)
             checkResult.add(ExpressionError("cannot type cast to string or array type", typecast.position))
-        return super.process(typecast)
+        return super.visit(typecast)
     }
 
-    override fun process(range: RangeExpr): IExpression {
+    override fun visit(range: RangeExpr): IExpression {
         fun err(msg: String) {
             checkResult.add(SyntaxError(msg, range.position))
         }
-        super.process(range)
+        super.visit(range)
         val from = range.from.constValue(program)
         val to = range.to.constValue(program)
         val stepLv = range.step.constValue(program) ?: LiteralValue(DataType.UBYTE, 1, position = range.position)
@@ -806,7 +797,7 @@ private class AstChecker(private val program: Program,
         return range
     }
 
-    override fun process(functionCall: FunctionCall): IExpression {
+    override fun visit(functionCall: FunctionCall): IExpression {
         // this function call is (part of) an expression, which should be in a statement somewhere.
         val stmtOfExpression = findParentNode<IStatement>(functionCall)
                 ?: throw FatalAstException("cannot determine statement scope of function call expression at ${functionCall.position}")
@@ -814,16 +805,20 @@ private class AstChecker(private val program: Program,
         val targetStatement = checkFunctionOrLabelExists(functionCall.target, stmtOfExpression)
         if(targetStatement!=null)
             checkFunctionCall(targetStatement, functionCall.arglist, functionCall.position)
-        return super.process(functionCall)
+        return super.visit(functionCall)
     }
 
-    override fun process(functionCallStatement: FunctionCallStatement): IStatement {
+    override fun visit(functionCallStatement: FunctionCallStatement): IStatement {
         val targetStatement = checkFunctionOrLabelExists(functionCallStatement.target, functionCallStatement)
         if(targetStatement!=null)
             checkFunctionCall(targetStatement, functionCallStatement.arglist, functionCallStatement.position)
-        if(targetStatement is Subroutine && targetStatement.returntypes.isNotEmpty())
-            printWarning("result value of subroutine call is discarded", functionCallStatement.position)
-        return super.process(functionCallStatement)
+        if(targetStatement is Subroutine && targetStatement.returntypes.isNotEmpty()) {
+            if(targetStatement.returntypes.size==1)
+                printWarning("result value of subroutine call is discarded", functionCallStatement.position)
+            else
+                printWarning("result values of subroutine call are discarded", functionCallStatement.position)
+        }
+        return super.visit(functionCallStatement)
     }
 
     private fun checkFunctionCall(target: IStatement, args: List<IExpression>, position: Position) {
@@ -863,8 +858,8 @@ private class AstChecker(private val program: Program,
                 for (arg in args.withIndex().zip(target.parameters)) {
                     val argDt = arg.first.value.inferType(program)
                     if(argDt!=null && !(argDt isAssignableTo arg.second.type)) {
-                        // for asm subroutines having STR param it's okay to provide a UWORD too (pointer value)
-                        if(!(target.isAsmSubroutine && arg.second.type in StringDatatypes && argDt==DataType.UWORD))
+                        // for asm subroutines having STR param it's okay to provide a UWORD (address value)
+                        if(!(target.isAsmSubroutine && arg.second.type in StringDatatypes && argDt == DataType.UWORD))
                             checkResult.add(ExpressionError("subroutine '${target.name}' argument ${arg.first.index + 1} has invalid type $argDt, expected ${arg.second.type}", position))
                     }
 
@@ -878,13 +873,13 @@ private class AstChecker(private val program: Program,
                         val asmParamReg = target.asmParameterRegisters[arg.first.index]
                         if(asmParamReg.statusflag!=null) {
                             if(argDt !in ByteDatatypes)
-                                checkResult.add(ExpressionError("subroutine '${target.name}' argument ${arg.first.index+1} must be byte type for statusflag", position))
+                                checkResult.add(ExpressionError("subroutine '${target.name}' argument ${arg.first.index + 1} must be byte type for statusflag", position))
                         } else if(asmParamReg.registerOrPair in setOf(RegisterOrPair.A, RegisterOrPair.X, RegisterOrPair.Y)) {
                             if(argDt !in ByteDatatypes)
-                                checkResult.add(ExpressionError("subroutine '${target.name}' argument ${arg.first.index+1} must be byte type for single register", position))
+                                checkResult.add(ExpressionError("subroutine '${target.name}' argument ${arg.first.index + 1} must be byte type for single register", position))
                         } else if(asmParamReg.registerOrPair in setOf(RegisterOrPair.AX, RegisterOrPair.AY, RegisterOrPair.XY)) {
-                            if(argDt !in WordDatatypes+ IterableDatatypes)
-                                checkResult.add(ExpressionError("subroutine '${target.name}' argument ${arg.first.index+1} must be word type for register pair", position))
+                            if(argDt !in WordDatatypes + IterableDatatypes)
+                                checkResult.add(ExpressionError("subroutine '${target.name}' argument ${arg.first.index + 1} must be word type for register pair", position))
                         }
                     }
                 }
@@ -892,14 +887,14 @@ private class AstChecker(private val program: Program,
         }
     }
 
-    override fun process(postIncrDecr: PostIncrDecr): IStatement {
+    override fun visit(postIncrDecr: PostIncrDecr): IStatement {
         if(postIncrDecr.target.identifier != null) {
             val targetName = postIncrDecr.target.identifier!!.nameInSource
             val target = program.namespace.lookup(targetName, postIncrDecr)
             if(target==null) {
                 checkResult.add(SyntaxError("undefined symbol: ${targetName.joinToString(".")}", postIncrDecr.position))
             } else {
-                if(target !is VarDecl || target.type==VarDeclType.CONST) {
+                if(target !is VarDecl || target.type== VarDeclType.CONST) {
                     checkResult.add(SyntaxError("can only increment or decrement a variable", postIncrDecr.position))
                 } else if(target.datatype !in NumericDatatypes) {
                     checkResult.add(SyntaxError("can only increment or decrement a byte/float/word variable", postIncrDecr.position))
@@ -918,10 +913,10 @@ private class AstChecker(private val program: Program,
         } else if(postIncrDecr.target.memoryAddress != null) {
             // a memory location can always be ++/--
         }
-        return super.process(postIncrDecr)
+        return super.visit(postIncrDecr)
     }
 
-    override fun process(arrayIndexedExpression: ArrayIndexedExpression): IExpression {
+    override fun visit(arrayIndexedExpression: ArrayIndexedExpression): IExpression {
         val target = arrayIndexedExpression.identifier.targetStatement(program.namespace)
         if(target is VarDecl) {
             if(target.datatype !in IterableDatatypes)
@@ -945,10 +940,42 @@ private class AstChecker(private val program: Program,
 
         // check index value 0..255
         val dtx = arrayIndexedExpression.arrayspec.index.inferType(program)
-        if(dtx!=DataType.UBYTE && dtx!=DataType.BYTE)
+        if(dtx!= DataType.UBYTE && dtx!= DataType.BYTE)
             checkResult.add(SyntaxError("array indexing is limited to byte size 0..255", arrayIndexedExpression.position))
 
-        return super.process(arrayIndexedExpression)
+        return super.visit(arrayIndexedExpression)
+    }
+
+    override fun visit(whenStatement: WhenStatement): IStatement {
+        val conditionType = whenStatement.condition.inferType(program)
+        if(conditionType !in IntegerDatatypes)
+            checkResult.add(SyntaxError("when condition must be an integer value", whenStatement.position))
+        val choiceValues = whenStatement.choiceValues(program)
+        val occurringValues = choiceValues.map {it.first}
+        val tally = choiceValues.associate { it.second to occurringValues.count { ov->it.first==ov} }
+        tally.filter { it.value>1 }.forEach {
+            checkResult.add(SyntaxError("choice value occurs multiple times", it.key.position))
+        }
+        return super.visit(whenStatement)
+    }
+
+    override fun visit(whenChoice: WhenChoice) {
+        val whenStmt = whenChoice.parent as WhenStatement
+        if(whenChoice.values!=null) {
+            val conditionType = whenStmt.condition.inferType(program)
+            val constvalues = whenChoice.values.map { it.constValue(program) }
+            for(constvalue in constvalues) {
+                when {
+                    constvalue == null -> checkResult.add(SyntaxError("choice value must be a constant", whenChoice.position))
+                    constvalue.type !in IntegerDatatypes -> checkResult.add(SyntaxError("choice value must be a byte or word", whenChoice.position))
+                    constvalue.type != conditionType -> checkResult.add(SyntaxError("choice value datatype differs from condition value", whenChoice.position))
+                }
+            }
+        } else {
+            if(whenChoice !== whenStmt.choices.last())
+                checkResult.add(SyntaxError("else choice must be the last one", whenChoice.position))
+        }
+        super.visit(whenChoice)
     }
 
     private fun checkFunctionOrLabelExists(target: IdentifierReference, statement: IStatement): IStatement? {
@@ -999,7 +1026,8 @@ private class AstChecker(private val program: Program,
         }
     }
 
-    private fun checkValueTypeAndRange(targetDt: DataType, arrayspec: ArrayIndex, value: LiteralValue, heap: HeapValues) : Boolean {
+    private fun checkValueTypeAndRange(targetDt: DataType, struct: StructDecl?,
+                                       arrayspec: ArrayIndex, value: LiteralValue, heap: HeapValues) : Boolean {
         fun err(msg: String) : Boolean {
             checkResult.add(ExpressionError(msg, value.position))
             return false
@@ -1121,12 +1149,28 @@ private class AstChecker(private val program: Program,
                         value.arrayvalue.map {it.constValue(program)?.asNumericValue!!.toDouble()}.toDoubleArray()
                     else
                         heap.get(value.heapId!!).doubleArray!!
-                    if(doubles.any { it < FLOAT_MAX_NEGATIVE || it> FLOAT_MAX_POSITIVE})
+                    if(doubles.any { it < FLOAT_MAX_NEGATIVE || it> FLOAT_MAX_POSITIVE })
                         return err("floating point value overflow")
                     return true
                 }
                 return err("invalid float array initialization value ${value.type}, expected $targetDt")
             }
+            DataType.STRUCT -> {
+                if(value.type in ArrayDatatypes) {
+                    if(value.arrayvalue!!.size != struct!!.numberOfElements)
+                        return err("number of values is not the same as the number of members in the struct")
+                    for(elt in value.arrayvalue.zip(struct.statements)) {
+                        val vardecl = elt.second as VarDecl
+                        val valuetype = elt.first.inferType(program)!!
+                        if (!(valuetype isAssignableTo vardecl.datatype)) {
+                            checkResult.add(ExpressionError("invalid struct member init value type $valuetype, expected ${vardecl.datatype}", elt.first.position))
+                            return false
+                        }
+                    }
+                    return true
+                }
+                return false
+            }
         }
         return true
     }
@@ -1181,39 +1225,79 @@ private class AstChecker(private val program: Program,
     }
 
     private fun checkAssignmentCompatible(targetDatatype: DataType,
+                                          target: AssignTarget,
                                           sourceDatatype: DataType,
                                           sourceValue: IExpression,
-                                          assignTargets: List<AssignTarget>,
                                           position: Position) : Boolean {
 
         if(sourceValue is RangeExpr)
-            checkResult.add(SyntaxError("can't assign a range value", position))
+            checkResult.add(SyntaxError("can't assign a range value to something else", position))
 
         val result =  when(targetDatatype) {
-            DataType.BYTE -> sourceDatatype==DataType.BYTE
-            DataType.UBYTE -> sourceDatatype==DataType.UBYTE
-            DataType.WORD -> sourceDatatype==DataType.BYTE || sourceDatatype==DataType.UBYTE || sourceDatatype==DataType.WORD
-            DataType.UWORD -> sourceDatatype==DataType.UBYTE || sourceDatatype==DataType.UWORD
+            DataType.BYTE -> sourceDatatype== DataType.BYTE
+            DataType.UBYTE -> sourceDatatype== DataType.UBYTE
+            DataType.WORD -> sourceDatatype== DataType.BYTE || sourceDatatype== DataType.UBYTE || sourceDatatype== DataType.WORD
+            DataType.UWORD -> sourceDatatype== DataType.UBYTE || sourceDatatype== DataType.UWORD
             DataType.FLOAT -> sourceDatatype in NumericDatatypes
-            DataType.STR -> sourceDatatype==DataType.STR
-            DataType.STR_S -> sourceDatatype==DataType.STR_S
+            DataType.STR -> sourceDatatype== DataType.STR
+            DataType.STR_S -> sourceDatatype== DataType.STR_S
+            DataType.STRUCT -> {
+                // for now we've decided you cannot assign struct by-value.
+                // but you can however assign an array to it of the correct size
+                if(sourceDatatype in ArrayDatatypes) {
+                    val identifier = sourceValue as IdentifierReference
+                    val sourceArraySize = identifier.targetVarDecl(program.namespace)!!.arraysize?.size()
+                    val targetstruct = target.identifier!!.targetVarDecl(program.namespace)!!.struct!!
+                    return targetstruct.numberOfElements == sourceArraySize
+                }
+//                if(sourceDatatype==DataType.STRUCT) {
+//                    val sourcename = (sourceValue as IdentifierReference).nameInSource
+//                    val vd1 = program.namespace.lookup(sourcename, target) as? VarDecl
+//                    val targetname = target.identifier!!.nameInSource
+//                    val vd2 = program.namespace.lookup(targetname, target) as? VarDecl
+//                    return vd1?.struct == vd2?.struct
+//                }
+                false
+            }
             else -> checkResult.add(SyntaxError("cannot assign new value to variable of type $targetDatatype", position))
         }
 
         if(result)
             return true
 
-        if((sourceDatatype==DataType.UWORD || sourceDatatype==DataType.WORD) && (targetDatatype==DataType.UBYTE || targetDatatype==DataType.BYTE)) {
-            if(assignTargets.size==2 && assignTargets[0].register!=null && assignTargets[1].register!=null)
-                return true // for asm subroutine calls that return a (U)WORD that's going to be stored into two BYTES (registers), we make an exception.
-            else
-                checkResult.add(ExpressionError("cannot assign word to byte, use msb() or lsb()?", position))
+        if((sourceDatatype== DataType.UWORD || sourceDatatype== DataType.WORD) && (targetDatatype== DataType.UBYTE || targetDatatype== DataType.BYTE)) {
+            checkResult.add(ExpressionError("cannot assign word to byte, use msb() or lsb()?", position))
         }
-        else if(sourceDatatype==DataType.FLOAT && targetDatatype in IntegerDatatypes)
+        else if(sourceDatatype== DataType.FLOAT && targetDatatype in IntegerDatatypes)
             checkResult.add(ExpressionError("cannot assign float to ${targetDatatype.name.toLowerCase()}; possible loss of precision. Suggestion: round the value or revert to integer arithmetic", position))
-        else
-            checkResult.add(ExpressionError("cannot assign ${sourceDatatype.name.toLowerCase()} to ${targetDatatype.name.toLowerCase()}", position))
+        else {
+            if(targetDatatype==DataType.UWORD && sourceDatatype in PassByReferenceDatatypes)
+                checkResult.add(ExpressionError("cannot assign ${sourceDatatype.name.toLowerCase()} to ${targetDatatype.name.toLowerCase()}, perhaps forgot '&' ?", position))
+            else
+                checkResult.add(ExpressionError("cannot assign ${sourceDatatype.name.toLowerCase()} to ${targetDatatype.name.toLowerCase()}", position))
+        }
+
 
         return false
     }
+
+    override fun visit(structDecl: StructDecl): IStatement {
+        // a struct can only contain 1 or more vardecls and can not be nested
+        if(structDecl.statements.isEmpty())
+            checkResult.add(SyntaxError("struct must contain at least one member", structDecl.position))
+
+        for(member in structDecl.statements){
+            val decl = member as? VarDecl
+            if(decl==null)
+                checkResult.add(SyntaxError("struct can only contain variable declarations", structDecl.position))
+            else {
+                if(decl.zeropage==ZeropageWish.REQUIRE_ZEROPAGE || decl.zeropage==ZeropageWish.PREFER_ZEROPAGE)
+                    checkResult.add(SyntaxError("struct can not contain zeropage members", decl.position))
+                if(decl.datatype !in NumericDatatypes)
+                    checkResult.add(SyntaxError("structs can only contain numerical types", decl.position))
+            }
+        }
+
+        return structDecl
+    }
 }

compiler/src/prog8/ast/processing/AstIdentifiersChecker.kt

@@ -1,57 +1,18 @@
-package prog8.ast
+package prog8.ast.processing
 
+import prog8.ast.*
+import prog8.ast.base.*
+import prog8.ast.base.autoHeapValuePrefix
+import prog8.ast.expressions.*
+import prog8.ast.statements.*
 import prog8.functions.BuiltinFunctions
 
-/**
- * Checks the validity of all identifiers (no conflicts)
- * Also makes sure that subroutine's parameters also become local variable decls in the subroutine's scope.
- * Finally, it also makes sure the datatype of all Var decls and sub Return values is set correctly.
- */
 
-internal fun Program.checkIdentifiers() {
-    val checker = AstIdentifiersChecker(namespace)
-    checker.process(this)
-
-    if(modules.map {it.name}.toSet().size != modules.size) {
-        throw FatalAstException("modules should all be unique")
-    }
-
-    // add any anonymous variables for heap values that are used,
-    // and replace an iterable literalvalue by identifierref to new local variable
-    for (variable in checker.anonymousVariablesFromHeap.values) {
-        val scope = variable.first.definingScope()
-        scope.statements.add(variable.second)
-        val parent = variable.first.parent
-        when {
-            parent is Assignment && parent.value === variable.first -> {
-                val idref = IdentifierReference(listOf("$autoHeapValuePrefix${variable.first.heapId}"), variable.first.position)
-                idref.linkParents(parent)
-                parent.value = idref
-            }
-            parent is IFunctionCall -> {
-                val parameterPos = parent.arglist.indexOf(variable.first)
-                val idref = IdentifierReference(listOf("$autoHeapValuePrefix${variable.first.heapId}"), variable.first.position)
-                idref.linkParents(parent)
-                parent.arglist[parameterPos] = idref
-            }
-            parent is ForLoop -> {
-                val idref = IdentifierReference(listOf("$autoHeapValuePrefix${variable.first.heapId}"), variable.first.position)
-                idref.linkParents(parent)
-                parent.iterable = idref
-            }
-            else -> TODO("replace literalvalue by identifierref: $variable  (in $parent)")
-        }
-        variable.second.linkParents(scope as Node)
-    }
-
-    printErrors(checker.result(), name)
-}
-
-
-private class AstIdentifiersChecker(private val namespace: INameScope) : IAstProcessor {
+internal class AstIdentifiersChecker(private val namespace: INameScope) : IAstModifyingVisitor {
     private val checkResult: MutableList<AstException> = mutableListOf()
 
-    private var blocks: MutableMap<String, Block> = mutableMapOf()
+    private var blocks = mutableMapOf<String, Block>()
+    internal val anonymousVariablesFromHeap = mutableMapOf<String, Pair<LiteralValue, VarDecl>>()
 
     internal fun result(): List<AstException> {
         return checkResult
@@ -61,32 +22,32 @@ private class AstIdentifiersChecker(private val namespace: INameScope) : IAstPro
         checkResult.add(NameError("name conflict '$name', also defined in ${existing.position.file} line ${existing.position.line}", position))
     }
 
-    override fun process(module: Module) {
+    override fun visit(module: Module) {
         blocks.clear()  // blocks may be redefined within a different module
-        super.process(module)
+        super.visit(module)
     }
 
-    override fun process(block: Block): IStatement {
+    override fun visit(block: Block): IStatement {
         val existing = blocks[block.name]
         if(existing!=null)
             nameError(block.name, block.position, existing)
         else
             blocks[block.name] = block
 
-        return super.process(block)
+        return super.visit(block)
     }
 
-    override fun process(functionCall: FunctionCall): IExpression {
+    override fun visit(functionCall: FunctionCall): IExpression {
         if(functionCall.target.nameInSource.size==1 && functionCall.target.nameInSource[0]=="lsb") {
             // lsb(...) is just an alias for type cast to ubyte, so replace with "... as ubyte"
             val typecast = TypecastExpression(functionCall.arglist.single(), DataType.UBYTE, false, functionCall.position)
             typecast.linkParents(functionCall.parent)
-            return super.process(typecast)
+            return super.visit(typecast)
         }
-        return super.process(functionCall)
+        return super.visit(functionCall)
     }
 
-    override fun process(decl: VarDecl): IStatement {
+    override fun visit(decl: VarDecl): IStatement {
         // first, check if there are datatype errors on the vardecl
         decl.datatypeErrors.forEach { checkResult.add(it) }
 
@@ -95,14 +56,30 @@ private class AstIdentifiersChecker(private val namespace: INameScope) : IAstPro
             // the builtin functions can't be redefined
             checkResult.add(NameError("builtin function cannot be redefined", decl.position))
 
+        // is it a struct variable? then define all its struct members as mangled names,
+        //    and include the original decl as well.
+        if(decl.datatype==DataType.STRUCT) {
+            if(decl.structHasBeenFlattened)
+                return decl    // don't do this multiple times
+
+            if(decl.struct!!.statements.any { (it as VarDecl).datatype !in NumericDatatypes})
+                return decl     // a non-numeric member, not supported. proper error is given by AstChecker later
+
+            val decls = decl.flattenStructMembers()
+            decls.add(decl)
+            val result = AnonymousScope(decls, decl.position)
+            result.linkParents(decl.parent)
+            return result
+        }
+
         val existing = namespace.lookup(listOf(decl.name), decl)
         if (existing != null && existing !== decl)
             nameError(decl.name, decl.position, existing)
 
-        return super.process(decl)
+        return super.visit(decl)
     }
 
-    override fun process(subroutine: Subroutine): IStatement {
+    override fun visit(subroutine: Subroutine): IStatement {
         if(subroutine.name in BuiltinFunctions) {
             // the builtin functions can't be redefined
             checkResult.add(NameError("builtin function cannot be redefined", subroutine.position))
@@ -138,18 +115,18 @@ private class AstIdentifiersChecker(private val namespace: INameScope) : IAstPro
                     subroutine.parameters
                             .filter { it.name !in namesInSub }
                             .forEach {
-                                val vardecl = VarDecl(VarDeclType.VAR, it.type, false, null, it.name, null,
-                                        isArray = false, autoGenerated = true, position = subroutine.position)
+                                val vardecl = VarDecl(VarDeclType.VAR, it.type, ZeropageWish.DONTCARE, null, it.name, null, null,
+                                        isArray = false, hiddenButDoNotRemove = true, position = subroutine.position)
                                 vardecl.linkParents(subroutine)
                                 subroutine.statements.add(0, vardecl)
                             }
                 }
             }
         }
-        return super.process(subroutine)
+        return super.visit(subroutine)
     }
 
-    override fun process(label: Label): IStatement {
+    override fun visit(label: Label): IStatement {
         if(label.name in BuiltinFunctions) {
             // the builtin functions can't be redefined
             checkResult.add(NameError("builtin function cannot be redefined", label.position))
@@ -158,10 +135,10 @@ private class AstIdentifiersChecker(private val namespace: INameScope) : IAstPro
             if (existing != null && existing !== label)
                 nameError(label.name, label.position, existing)
         }
-        return super.process(label)
+        return super.visit(label)
     }
 
-    override fun process(forLoop: ForLoop): IStatement {
+    override fun visit(forLoop: ForLoop): IStatement {
         // If the for loop has a decltype, it means to declare the loopvar inside the loop body
         // rather than reusing an already declared loopvar from an outer scope.
         // For loops that loop over an interable variable (instead of a range of numbers) get an
@@ -177,8 +154,8 @@ private class AstIdentifiersChecker(private val namespace: INameScope) : IAstPro
                 val existing = if(forLoop.body.containsNoCodeNorVars()) null else forLoop.body.lookup(forLoop.loopVar.nameInSource, forLoop.body.statements.first())
                 if(existing==null) {
                     // create the local scoped for loop variable itself
-                    val vardecl = VarDecl(VarDeclType.VAR, forLoop.decltype, forLoop.zeropage, null, varName, null,
-                            isArray = false, autoGenerated = true, position = forLoop.loopVar.position)
+                    val vardecl = VarDecl(VarDeclType.VAR, forLoop.decltype, forLoop.zeropage, null, varName, null, null,
+                            isArray = false, hiddenButDoNotRemove = true, position = forLoop.loopVar.position)
                     vardecl.linkParents(forLoop.body)
                     forLoop.body.statements.add(0, vardecl)
                     forLoop.loopVar.parent = forLoop.body   // loopvar 'is defined in the body'
@@ -190,69 +167,79 @@ private class AstIdentifiersChecker(private val namespace: INameScope) : IAstPro
                 val existing = if(forLoop.body.containsNoCodeNorVars()) null else forLoop.body.lookup(listOf(ForLoop.iteratorLoopcounterVarname), forLoop.body.statements.first())
                 if(existing==null) {
                     // create loop iteration counter variable (without value, to avoid an assignment)
-                    val vardecl = VarDecl(VarDeclType.VAR, DataType.UBYTE, true, null, ForLoop.iteratorLoopcounterVarname, null,
-                            isArray = false, autoGenerated = true, position = forLoop.loopVar.position)
+                    val vardecl = VarDecl(VarDeclType.VAR, DataType.UBYTE, ZeropageWish.PREFER_ZEROPAGE, null, ForLoop.iteratorLoopcounterVarname, null, null,
+                            isArray = false, hiddenButDoNotRemove = true, position = forLoop.loopVar.position)
                     vardecl.linkParents(forLoop.body)
                     forLoop.body.statements.add(0, vardecl)
                     forLoop.loopVar.parent = forLoop.body   // loopvar 'is defined in the body'
                 }
             }
         }
-        return super.process(forLoop)
+        return super.visit(forLoop)
     }
 
-    override fun process(assignTarget: AssignTarget): AssignTarget {
-        if(assignTarget.register==Register.X)
+    override fun visit(assignTarget: AssignTarget): AssignTarget {
+        if(assignTarget.register== Register.X)
             printWarning("writing to the X register is dangerous, because it's used as an internal pointer", assignTarget.position)
-        return super.process(assignTarget)
+        return super.visit(assignTarget)
     }
 
-    override fun process(returnStmt: Return): IStatement {
-        if(returnStmt.values.isNotEmpty()) {
+    override fun visit(returnStmt: Return): IStatement {
+        if(returnStmt.value!=null) {
             // possibly adjust any literal values returned, into the desired returning data type
             val subroutine = returnStmt.definingSubroutine()!!
-            if(subroutine.returntypes.size!=returnStmt.values.size)
+            if(subroutine.returntypes.size!=1)
                 return returnStmt  // mismatch in number of return values, error will be printed later.
-            val newValues = mutableListOf<IExpression>()
-            for(returnvalue in returnStmt.values.zip(subroutine.returntypes)) {
-                val lval = returnvalue.first as? LiteralValue
-                if(lval!=null) {
-                    val adjusted = lval.intoDatatype(returnvalue.second)
-                    if(adjusted!=null && adjusted !== lval)
-                        newValues.add(adjusted)
-                    else
-                        newValues.add(lval)
-                }
+            val newValue: IExpression
+            val lval = returnStmt.value as? LiteralValue
+            if(lval!=null) {
+                val adjusted = lval.cast(subroutine.returntypes.single())
+                if(adjusted!=null && adjusted !== lval)
+                    newValue = adjusted
                 else
-                    newValues.add(returnvalue.first)
-            }
-            returnStmt.values = newValues
+                    newValue = lval
+            } else
+                newValue = returnStmt.value!!
+
+            returnStmt.value = newValue
         }
-        return super.process(returnStmt)
+        return super.visit(returnStmt)
     }
 
-
-    internal val anonymousVariablesFromHeap = mutableMapOf<String, Pair<LiteralValue, VarDecl>>()
-
-
-    override fun process(literalValue: LiteralValue): LiteralValue {
+    override fun visit(literalValue: LiteralValue): LiteralValue {
         if(literalValue.heapId!=null && literalValue.parent !is VarDecl) {
             // a literal value that's not declared as a variable, which refers to something on the heap.
             // we need to introduce an auto-generated variable for this to be able to refer to the value!
-            val variable = VarDecl(VarDeclType.VAR, literalValue.type, false, null, "$autoHeapValuePrefix${literalValue.heapId}", literalValue,
-                    isArray = false, autoGenerated = false, position = literalValue.position)
+            // (note: ususally, this has been taken care of already when the var was created)
+            val declaredType = if(literalValue.isArray) ArrayElementTypes.getValue(literalValue.type) else literalValue.type
+            val variable = VarDecl(VarDeclType.VAR,
+                    declaredType,
+                    ZeropageWish.NOT_IN_ZEROPAGE,
+                    null,
+                    "$autoHeapValuePrefix${literalValue.heapId}",
+                    null,
+                    literalValue,
+                    isArray = literalValue.isArray, hiddenButDoNotRemove = true, position = literalValue.position)
             anonymousVariablesFromHeap[variable.name] = Pair(literalValue, variable)
         }
-        return super.process(literalValue)
+        return super.visit(literalValue)
     }
 
-    override fun process(addressOf: AddressOf): IExpression {
+    override fun visit(addressOf: AddressOf): IExpression {
         // register the scoped name of the referenced identifier
         val variable= addressOf.identifier.targetVarDecl(namespace) ?: return addressOf
         addressOf.scopedname = variable.scopedname
-        return super.process(addressOf)
+        return super.visit(addressOf)
+    }
+
+    override fun visit(structDecl: StructDecl): IStatement {
+        for(member in structDecl.statements){
+            val decl = member as? VarDecl
+            if(decl!=null && decl.datatype !in NumericDatatypes)
+                checkResult.add(SyntaxError("structs can only contain numerical types", decl.position))
+        }
+
+        return super.visit(structDecl)
     }
 
 }
-
-internal const val autoHeapValuePrefix = "auto_heap_value_"

compiler/src/prog8/ast/processing/AstRecursionChecker.kt

@@ -0,0 +1,117 @@
+package prog8.ast.processing
+
+import prog8.ast.*
+import prog8.ast.base.AstException
+import prog8.ast.expressions.FunctionCall
+import prog8.ast.statements.FunctionCallStatement
+import prog8.ast.statements.Subroutine
+
+
+internal class AstRecursionChecker(private val namespace: INameScope) : IAstVisitor {
+    private val callGraph = DirectedGraph<INameScope>()
+
+    internal fun result(): List<AstException> {
+        val cycle = callGraph.checkForCycle()
+        if(cycle.isEmpty())
+            return emptyList()
+        val chain = cycle.joinToString(" <-- ") { "${it.name} at ${it.position}" }
+        return listOf(AstException("Program contains recursive subroutine calls, this is not supported. Recursive chain:\n (a subroutine call in) $chain"))
+    }
+
+    override fun visit(functionCallStatement: FunctionCallStatement) {
+        val scope = functionCallStatement.definingScope()
+        val targetStatement = functionCallStatement.target.targetStatement(namespace)
+        if(targetStatement!=null) {
+            val targetScope = when (targetStatement) {
+                is Subroutine -> targetStatement
+                else -> targetStatement.definingScope()
+            }
+            callGraph.add(scope, targetScope)
+        }
+        super.visit(functionCallStatement)
+    }
+
+    override fun visit(functionCall: FunctionCall) {
+        val scope = functionCall.definingScope()
+        val targetStatement = functionCall.target.targetStatement(namespace)
+        if(targetStatement!=null) {
+            val targetScope = when (targetStatement) {
+                is Subroutine -> targetStatement
+                else -> targetStatement.definingScope()
+            }
+            callGraph.add(scope, targetScope)
+        }
+        super.visit(functionCall)
+    }
+
+
+    private class DirectedGraph<VT> {
+        private val graph = mutableMapOf<VT, MutableSet<VT>>()
+        private var uniqueVertices = mutableSetOf<VT>()
+        val numVertices : Int
+            get() = uniqueVertices.size
+
+        fun add(from: VT, to: VT) {
+            var targets = graph[from]
+            if(targets==null) {
+                targets = mutableSetOf()
+                graph[from] = targets
+            }
+            targets.add(to)
+            uniqueVertices.add(from)
+            uniqueVertices.add(to)
+        }
+
+        fun print() {
+            println("#vertices: $numVertices")
+            graph.forEach { (from, to) ->
+                println("$from   CALLS:")
+                to.forEach { println("   $it") }
+            }
+            val cycle = checkForCycle()
+            if(cycle.isNotEmpty()) {
+                println("CYCLIC!  $cycle")
+            }
+        }
+
+        fun checkForCycle(): MutableList<VT> {
+            val visited = uniqueVertices.associateWith { false }.toMutableMap()
+            val recStack = uniqueVertices.associateWith { false }.toMutableMap()
+            val cycle = mutableListOf<VT>()
+            for(node in uniqueVertices) {
+                if(isCyclicUntil(node, visited, recStack, cycle))
+                    return cycle
+            }
+            return mutableListOf()
+        }
+
+        private fun isCyclicUntil(node: VT,
+                                  visited: MutableMap<VT, Boolean>,
+                                  recStack: MutableMap<VT, Boolean>,
+                                  cycleNodes: MutableList<VT>): Boolean {
+
+            if(recStack[node]==true) return true
+            if(visited[node]==true) return false
+
+            // mark current node as visited and add to recursion stack
+            visited[node] = true
+            recStack[node] = true
+
+            // recurse for all neighbours
+            val neighbors = graph[node]
+            if(neighbors!=null) {
+                for (neighbour in neighbors) {
+                    if (isCyclicUntil(neighbour, visited, recStack, cycleNodes)) {
+                        cycleNodes.add(node)
+                        return true
+                    }
+                }
+            }
+
+            // pop node from recursion stack
+            recStack[node] = false
+            return false
+        }
+    }
+
+}

compiler/src/prog8/ast/processing/IAstModifyingVisitor.kt

@@ -0,0 +1,224 @@
+package prog8.ast.processing
+
+import prog8.ast.*
+import prog8.ast.expressions.*
+import prog8.ast.statements.*
+
+interface IAstModifyingVisitor {
+    fun visit(program: Program) {
+        program.modules.forEach { visit(it) }
+    }
+
+    fun visit(module: Module) {
+        module.statements = module.statements.asSequence().map { it.accept(this) }.toMutableList()
+    }
+
+    fun visit(expr: PrefixExpression): IExpression {
+        expr.expression = expr.expression.accept(this)
+        return expr
+    }
+
+    fun visit(expr: BinaryExpression): IExpression {
+        expr.left = expr.left.accept(this)
+        expr.right = expr.right.accept(this)
+        return expr
+    }
+
+    fun visit(directive: Directive): IStatement {
+        return directive
+    }
+
+    fun visit(block: Block): IStatement {
+        block.statements = block.statements.asSequence().map { it.accept(this) }.toMutableList()
+        return block
+    }
+
+    fun visit(decl: VarDecl): IStatement {
+        decl.value = decl.value?.accept(this)
+        decl.arraysize?.accept(this)
+        return decl
+    }
+
+    fun visit(subroutine: Subroutine): IStatement {
+        subroutine.statements = subroutine.statements.asSequence().map { it.accept(this) }.toMutableList()
+        return subroutine
+    }
+
+    fun visit(functionCall: FunctionCall): IExpression {
+        val newtarget = functionCall.target.accept(this)
+        if(newtarget is IdentifierReference)
+            functionCall.target = newtarget
+        functionCall.arglist = functionCall.arglist.map { it.accept(this) }.toMutableList()
+        return functionCall
+    }
+
+    fun visit(functionCallStatement: FunctionCallStatement): IStatement {
+        val newtarget = functionCallStatement.target.accept(this)
+        if(newtarget is IdentifierReference)
+            functionCallStatement.target = newtarget
+        functionCallStatement.arglist = functionCallStatement.arglist.map { it.accept(this) }.toMutableList()
+        return functionCallStatement
+    }
+
+    fun visit(identifier: IdentifierReference): IExpression {
+        // note: this is an identifier that is used in an expression.
+        // other identifiers are simply part of the other statements (such as jumps, subroutine defs etc)
+        return identifier
+    }
+
+    fun visit(jump: Jump): IStatement {
+        if(jump.identifier!=null) {
+            val ident = jump.identifier.accept(this)
+            if(ident is IdentifierReference && ident!==jump.identifier) {
+                return Jump(null, ident, null, jump.position)
+            }
+        }
+        return jump
+    }
+
+    fun visit(ifStatement: IfStatement): IStatement {
+        ifStatement.condition = ifStatement.condition.accept(this)
+        ifStatement.truepart = ifStatement.truepart.accept(this) as AnonymousScope
+        ifStatement.elsepart = ifStatement.elsepart.accept(this) as AnonymousScope
+        return ifStatement
+    }
+
+    fun visit(branchStatement: BranchStatement): IStatement {
+        branchStatement.truepart = branchStatement.truepart.accept(this) as AnonymousScope
+        branchStatement.elsepart = branchStatement.elsepart.accept(this) as AnonymousScope
+        return branchStatement
+    }
+
+    fun visit(range: RangeExpr): IExpression {
+        range.from = range.from.accept(this)
+        range.to = range.to.accept(this)
+        range.step = range.step.accept(this)
+        return range
+    }
+
+    fun visit(label: Label): IStatement {
+        return label
+    }
+
+    fun visit(literalValue: LiteralValue): LiteralValue {
+        if(literalValue.arrayvalue!=null) {
+            for(av in literalValue.arrayvalue.withIndex()) {
+                val newvalue = av.value.accept(this)
+                literalValue.arrayvalue[av.index] = newvalue
+            }
+        }
+        return literalValue
+    }
+
+    fun visit(assignment: Assignment): IStatement {
+        assignment.target = assignment.target.accept(this)
+        assignment.value = assignment.value.accept(this)
+        return assignment
+    }
+
+    fun visit(postIncrDecr: PostIncrDecr): IStatement {
+        postIncrDecr.target = postIncrDecr.target.accept(this)
+        return postIncrDecr
+    }
+
+    fun visit(contStmt: Continue): IStatement {
+        return contStmt
+    }
+
+    fun visit(breakStmt: Break): IStatement {
+        return breakStmt
+    }
+
+    fun visit(forLoop: ForLoop): IStatement {
+        forLoop.loopVar?.accept(this)
+        forLoop.iterable = forLoop.iterable.accept(this)
+        forLoop.body = forLoop.body.accept(this) as AnonymousScope
+        return forLoop
+    }
+
+    fun visit(whileLoop: WhileLoop): IStatement {
+        whileLoop.condition = whileLoop.condition.accept(this)
+        whileLoop.body = whileLoop.body.accept(this) as AnonymousScope
+        return whileLoop
+    }
+
+    fun visit(repeatLoop: RepeatLoop): IStatement {
+        repeatLoop.untilCondition = repeatLoop.untilCondition.accept(this)
+        repeatLoop.body = repeatLoop.body.accept(this) as AnonymousScope
+        return repeatLoop
+    }
+
+    fun visit(returnStmt: Return): IStatement {
+        returnStmt.value = returnStmt.value?.accept(this)
+        return returnStmt
+    }
+
+    fun visit(arrayIndexedExpression: ArrayIndexedExpression): IExpression {
+        arrayIndexedExpression.identifier.accept(this)
+        arrayIndexedExpression.arrayspec.accept(this)
+        return arrayIndexedExpression
+    }
+
+    fun visit(assignTarget: AssignTarget): AssignTarget {
+        assignTarget.arrayindexed?.accept(this)
+        assignTarget.identifier?.accept(this)
+        assignTarget.memoryAddress?.let { visit(it) }
+        return assignTarget
+    }
+
+    fun visit(scope: AnonymousScope): IStatement {
+        scope.statements = scope.statements.asSequence().map { it.accept(this) }.toMutableList()
+        return scope
+    }
+
+    fun visit(typecast: TypecastExpression): IExpression {
+        typecast.expression = typecast.expression.accept(this)
+        return typecast
+    }
+
+    fun visit(memread: DirectMemoryRead): IExpression {
+        memread.addressExpression = memread.addressExpression.accept(this)
+        return memread
+    }
+
+    fun visit(memwrite: DirectMemoryWrite) {
+        memwrite.addressExpression = memwrite.addressExpression.accept(this)
+    }
+
+    fun visit(addressOf: AddressOf): IExpression {
+        addressOf.identifier.accept(this)
+        return addressOf
+    }
+
+    fun visit(inlineAssembly: InlineAssembly): IStatement {
+        return inlineAssembly
+    }
+
+    fun visit(registerExpr: RegisterExpr): IExpression {
+        return registerExpr
+    }
+
+    fun visit(builtinFunctionStatementPlaceholder: BuiltinFunctionStatementPlaceholder): IStatement {
+        return builtinFunctionStatementPlaceholder
+    }
+
+    fun visit(nopStatement: NopStatement): IStatement {
+        return nopStatement
+    }
+
+    fun visit(whenStatement: WhenStatement): IStatement {
+        whenStatement.condition.accept(this)
+        whenStatement.choices.forEach { it.accept(this) }
+        return whenStatement
+    }
+
+    fun visit(whenChoice: WhenChoice) {
+        whenChoice.values?.forEach { it.accept(this) }
+        whenChoice.statements.accept(this)
+    }
+
+    fun visit(structDecl: StructDecl): IStatement {
+        structDecl.statements = structDecl.statements.map{ it.accept(this) }.toMutableList()
+        return structDecl
+    }
+}

compiler/src/prog8/ast/processing/IAstVisitor.kt

@@ -0,0 +1,173 @@
+package prog8.ast.processing
+
+import prog8.ast.*
+import prog8.ast.expressions.*
+import prog8.ast.statements.*
+
+interface IAstVisitor {
+    fun visit(program: Program) {
+        program.modules.forEach { visit(it) }
+    }
+
+    fun visit(module: Module) {
+        module.statements.forEach{ it.accept(this) }
+    }
+
+    fun visit(expr: PrefixExpression) {
+        expr.expression.accept(this)
+    }
+
+    fun visit(expr: BinaryExpression) {
+        expr.left.accept(this)
+        expr.right.accept(this)
+    }
+
+    fun visit(directive: Directive) {
+    }
+
+    fun visit(block: Block) {
+        block.statements.forEach { it.accept(this) }
+    }
+
+    fun visit(decl: VarDecl) {
+        decl.value?.accept(this)
+        decl.arraysize?.accept(this)
+    }
+
+    fun visit(subroutine: Subroutine) {
+        subroutine.statements.forEach { it.accept(this) }
+    }
+
+    fun visit(functionCall: FunctionCall) {
+        functionCall.target.accept(this)
+        functionCall.arglist.forEach { it.accept(this) }
+    }
+
+    fun visit(functionCallStatement: FunctionCallStatement) {
+        functionCallStatement.target.accept(this)
+        functionCallStatement.arglist.forEach { it.accept(this) }
+    }
+
+    fun visit(identifier: IdentifierReference) {
+    }
+
+    fun visit(jump: Jump) {
+        jump.identifier?.accept(this)
+    }
+
+    fun visit(ifStatement: IfStatement) {
+        ifStatement.condition.accept(this)
+        ifStatement.truepart.accept(this)
+        ifStatement.elsepart.accept(this)
+    }
+
+    fun visit(branchStatement: BranchStatement) {
+        branchStatement.truepart.accept(this)
+        branchStatement.elsepart.accept(this)
+    }
+
+    fun visit(range: RangeExpr) {
+        range.from.accept(this)
+        range.to.accept(this)
+        range.step.accept(this)
+    }
+
+    fun visit(label: Label) {
+    }
+
+    fun visit(literalValue: LiteralValue) {
+        literalValue.arrayvalue?.let { it.forEach { v->v.accept(this) }}
+    }
+
+    fun visit(assignment: Assignment) {
+        assignment.target.accept(this)
+        assignment.value.accept(this)
+    }
+
+    fun visit(postIncrDecr: PostIncrDecr) {
+        postIncrDecr.target.accept(this)
+    }
+
+    fun visit(contStmt: Continue) {
+    }
+
+    fun visit(breakStmt: Break) {
+    }
+
+    fun visit(forLoop: ForLoop) {
+        forLoop.loopVar?.accept(this)
+        forLoop.iterable.accept(this)
+        forLoop.body.accept(this)
+    }
+
+    fun visit(whileLoop: WhileLoop) {
+        whileLoop.condition.accept(this)
+        whileLoop.body.accept(this)
+    }
+
+    fun visit(repeatLoop: RepeatLoop) {
+        repeatLoop.untilCondition.accept(this)
+        repeatLoop.body.accept(this)
+    }
+
+    fun visit(returnStmt: Return) {
+        returnStmt.value?.accept(this)
+    }
+
+    fun visit(arrayIndexedExpression: ArrayIndexedExpression) {
+        arrayIndexedExpression.identifier.accept(this)
+        arrayIndexedExpression.arrayspec.accept(this)
+    }
+
+    fun visit(assignTarget: AssignTarget) {
+        assignTarget.arrayindexed?.accept(this)
+        assignTarget.identifier?.accept(this)
+        assignTarget.memoryAddress?.accept(this)
+    }
+
+    fun visit(scope: AnonymousScope) {
+        scope.statements.forEach { it.accept(this) }
+    }
+
+    fun visit(typecast: TypecastExpression) {
+        typecast.expression.accept(this)
+    }
+
+    fun visit(memread: DirectMemoryRead) {
+        memread.addressExpression.accept(this)
+    }
+
+    fun visit(memwrite: DirectMemoryWrite) {
+        memwrite.addressExpression.accept(this)
+    }
+
+    fun visit(addressOf: AddressOf) {
+        addressOf.identifier.accept(this)
+    }
+
+    fun visit(inlineAssembly: InlineAssembly) {
+    }
+
+    fun visit(registerExpr: RegisterExpr) {
+    }
+
+    fun visit(builtinFunctionStatementPlaceholder: BuiltinFunctionStatementPlaceholder) {
+    }
+
+    fun visit(nopStatement: NopStatement) {
+    }
+
+    fun visit(whenStatement: WhenStatement) {
+        whenStatement.condition.accept(this)
+        whenStatement.choices.forEach { it.accept(this) }
+    }
+
+    fun visit(whenChoice: WhenChoice) {
+        whenChoice.values?.forEach { it.accept(this) }
+        whenChoice.statements.accept(this)
+    }
+
+    fun visit(structDecl: StructDecl) {
+        structDecl.statements.forEach { it.accept(this) }
+    }
+}

compiler/src/prog8/ast/processing/ImportedModuleDirectiveRemover.kt

@@ -1,18 +1,11 @@
-package prog8.ast
+package prog8.ast.processing
 
+import prog8.ast.*
+import prog8.ast.base.SyntaxError
+import prog8.ast.base.printWarning
+import prog8.ast.statements.Directive
 
-/**
- * Checks that are specific for imported modules.
- */
-
-internal fun Module.checkImportedValid() {
-    val checker = ImportedAstChecker()
-    checker.process(this)
-    printErrors(checker.result(), name)
-}
-
-
-private class ImportedAstChecker : IAstProcessor {
+internal class ImportedModuleDirectiveRemover : IAstModifyingVisitor {
     private val checkResult: MutableList<SyntaxError> = mutableListOf()
 
     internal fun result(): List<SyntaxError> {
@@ -20,15 +13,15 @@ private class ImportedAstChecker : IAstProcessor {
     }
 
     /**
-     * Module check: most global directives don't apply for imported modules
+     * Most global directives don't apply for imported modules, so remove them
      */
-    override fun process(module: Module) {
-        super.process(module)
+    override fun visit(module: Module) {
+        super.visit(module)
         val newStatements : MutableList<IStatement> = mutableListOf()
 
         val moduleLevelDirectives = listOf("%output", "%launcher", "%zeropage", "%zpreserved", "%address")
         for (sourceStmt in module.statements) {
-            val stmt = sourceStmt.process(this)
+            val stmt = sourceStmt.accept(this)
             if(stmt is Directive && stmt.parent is Module) {
                 if(stmt.directive in moduleLevelDirectives) {
                     printWarning("ignoring module directive because it was imported", stmt.position, stmt.directive)

compiler/src/prog8/ast/processing/StatementReorderer.kt

@@ -1,19 +1,60 @@
-package prog8.ast
+package prog8.ast.processing
 
+import kotlin.comparisons.nullsLast
+import prog8.ast.*
+import prog8.ast.base.*
+import prog8.ast.base.initvarsSubName
+import prog8.ast.expressions.*
+import prog8.ast.statements.*
 import prog8.functions.BuiltinFunctions
 
-internal fun Program.reorderStatements() {
-    val initvalueCreator = VarInitValueAndAddressOfCreator(namespace)
-    initvalueCreator.process(this)
 
-    val checker = StatementReorderer(this)
-    checker.process(this)
+fun flattenStructAssignment(structAssignment: Assignment, program: Program): List<Assignment> {
+    val identifier = structAssignment.target.identifier!!
+    val identifierName = identifier.nameInSource.single()
+    val targetVar = identifier.targetVarDecl(program.namespace)!!
+    val struct = targetVar.struct!!
+    val sourceVar = (structAssignment.value as IdentifierReference).targetVarDecl(program.namespace)!!
+    if(!sourceVar.isArray && sourceVar.struct==null)
+        throw FatalAstException("can only assign arrays or structs to structs")
+    if(sourceVar.isArray) {
+        val sourceArray = (sourceVar.value as LiteralValue).arrayvalue!!
+        return struct.statements.zip(sourceArray).map { member ->
+            val decl = member.first as VarDecl
+            val mangled = mangledStructMemberName(identifierName, decl.name)
+            val idref = IdentifierReference(listOf(mangled), structAssignment.position)
+            val assign = Assignment(AssignTarget(null, idref, null, null, structAssignment.position),
+                    null, member.second, member.second.position)
+            assign.linkParents(structAssignment)
+            assign
+        }
+    }
+    else {
+        // struct memberwise copy
+        val sourceStruct = sourceVar.struct!!
+        if(sourceStruct!==targetVar.struct) {
+            // structs are not the same in assignment
+            return listOf()     // error will be printed elsewhere
+        }
+        return struct.statements.zip(sourceStruct.statements).map { member ->
+            val targetDecl = member.first as VarDecl
+            val sourceDecl = member.second as VarDecl
+            if(targetDecl.name != sourceDecl.name)
+                throw FatalAstException("struct member mismatch")
+            val mangled = mangledStructMemberName(identifierName, targetDecl.name)
+            val idref = IdentifierReference(listOf(mangled), structAssignment.position)
+            val sourcemangled = mangledStructMemberName(sourceVar.name, sourceDecl.name)
+            val sourceIdref = IdentifierReference(listOf(sourcemangled), structAssignment.position)
+            val assign = Assignment(AssignTarget(null, idref, null, null, structAssignment.position),
+                    null, sourceIdref, member.second.position)
+            assign.linkParents(structAssignment)
+            assign
+        }
+    }
 }
 
-internal const val initvarsSubName="prog8_init_vars"    // the name of the subroutine that should be called for every block to initialize its variables
 
-
-private class StatementReorderer(private val program: Program): IAstProcessor {
+internal class StatementReorderer(private val program: Program): IAstModifyingVisitor {
     // Reorders the statements in a way the compiler needs.
     // - 'main' block must be the very first statement UNLESS it has an address set.
     // - blocks are ordered by address, where blocks without address are put at the end.
@@ -24,14 +65,15 @@ private class StatementReorderer(private val program: Program): IAstProcessor {
     //
     // - the 'start' subroutine in the 'main' block will be moved to the top immediately following the directives.
     // - all other subroutines will be moved to the end of their block.
+    // - sorts the choices in when statement.
     //
     // Also, makes sure any value assignments get the proper type casts if needed to cast them into the target variable's type.
     // (this includes function call arguments)
 
     private val directivesToMove = setOf("%output", "%launcher", "%zeropage", "%zpreserved", "%address", "%option")
 
-    override fun process(module: Module) {
-        super.process(module)
+    override fun visit(module: Module) {
+        super.visit(module)
 
         val (blocks, other) = module.statements.partition { it is Block }
         module.statements = other.asSequence().plus(blocks.sortedBy { (it as Block).address ?: Int.MAX_VALUE }).toMutableList()
@@ -58,11 +100,9 @@ private class StatementReorderer(private val program: Program): IAstProcessor {
         val directives = module.statements.filter {it is Directive && it.directive in directivesToMove}
         module.statements.removeAll(directives)
         module.statements.addAll(0, directives)
-
-        sortConstantAssignments(module.statements)
     }
 
-    override fun process(block: Block): IStatement {
+    override fun visit(block: Block): IStatement {
 
         val subroutines = block.statements.filterIsInstance<Subroutine>()
         var numSubroutinesAtEnd = 0
@@ -93,7 +133,7 @@ private class StatementReorderer(private val program: Program): IAstProcessor {
                         && stmtBeforeFirstSub !is Jump
                         && stmtBeforeFirstSub !is Subroutine
                         && stmtBeforeFirstSub !is BuiltinFunctionStatementPlaceholder) {
-                    val ret = Return(emptyList(), stmtBeforeFirstSub.position)
+                    val ret = Return(null, stmtBeforeFirstSub.position)
                     ret.linkParents(block)
                     block.statements.add(block.statements.size - numSubroutinesAtEnd, ret)
                 }
@@ -108,8 +148,6 @@ private class StatementReorderer(private val program: Program): IAstProcessor {
         block.statements.addAll(0, directives)
         block.linkParents(block.parent)
 
-        sortConstantAssignments(block.statements)
-
         // create subroutine that initializes the block's variables (if any)
         val varInits = block.statements.withIndex().filter { it.value is VariableInitializationAssignment }
         if(varInits.isNotEmpty()) {
@@ -125,13 +163,11 @@ private class StatementReorderer(private val program: Program): IAstProcessor {
                 block.statements.removeAt(index)
         }
 
-        return super.process(block)
+        return super.visit(block)
     }
 
-    override fun process(subroutine: Subroutine): IStatement {
-        super.process(subroutine)
-
-        sortConstantAssignments(subroutine.statements)
+    override fun visit(subroutine: Subroutine): IStatement {
+        super.visit(subroutine)
 
         val varDecls = subroutine.statements.filterIsInstance<VarDecl>()
         subroutine.statements.removeAll(varDecls)
@@ -144,8 +180,8 @@ private class StatementReorderer(private val program: Program): IAstProcessor {
             // add the implicit return statement at the end (if it's not there yet), but only if it's not a kernel routine.
             // and if an assembly block doesn't contain a rts/rti
             if(subroutine.asmAddress==null && subroutine.amountOfRtsInAsm()==0) {
-                if (subroutine.statements.lastOrNull {it !is VarDecl} !is Return) {
-                    val returnStmt = Return(emptyList(), subroutine.position)
+                if (subroutine.statements.lastOrNull {it !is VarDecl } !is Return) {
+                    val returnStmt = Return(null, subroutine.position)
                     returnStmt.linkParents(subroutine)
                     subroutine.statements.add(returnStmt)
                 }
@@ -155,13 +191,7 @@ private class StatementReorderer(private val program: Program): IAstProcessor {
         return subroutine
     }
 
-    override fun process(scope: AnonymousScope): AnonymousScope {
-        scope.statements = scope.statements.map { it.process(this)}.toMutableList()
-        sortConstantAssignments(scope.statements)
-        return scope
-    }
-
-    override fun process(expr: BinaryExpression): IExpression {
+    override fun visit(expr: BinaryExpression): IExpression {
         val leftDt = expr.left.inferType(program)
         val rightDt = expr.right.inferType(program)
         if(leftDt!=null && rightDt!=null && leftDt!=rightDt) {
@@ -181,64 +211,53 @@ private class StatementReorderer(private val program: Program): IAstProcessor {
                 }
             }
         }
-        return super.process(expr)
+        return super.visit(expr)
     }
 
-    private fun sortConstantAssignments(statements: MutableList<IStatement>) {
-        // sort assignments by datatype and value, so multiple initializations with the isSameAs value can be optimized (to load the value just once)
-        val result = mutableListOf<IStatement>()
-        val stmtIter = statements.iterator()
-        for(stmt in stmtIter) {
-            if(stmt is Assignment && !stmt.targets.any { it.isMemoryMapped(program.namespace) }) {
-                val constval = stmt.value.constValue(program)
-                if(constval!=null) {
-                    val (sorted, trailing) = sortConstantAssignmentSequence(stmt, stmtIter)
-                    result.addAll(sorted)
-                    if(trailing!=null)
-                        result.add(trailing)
-                }
-                else
-                    result.add(stmt)
-            }
-            else
-                result.add(stmt)
-        }
-        statements.clear()
-        statements.addAll(result)
-    }
-
-    override fun process(assignment: Assignment): IStatement {
-        val target=assignment.singleTarget
-        if(target!=null) {
-            // see if a typecast is needed to convert the value's type into the proper target type
-            val valuetype = assignment.value.inferType(program)
-            val targettype = target.inferType(program, assignment)
-            if(targettype!=null && valuetype!=null && valuetype!=targettype) {
-                if(valuetype isAssignableTo targettype) {
+    override fun visit(assignment: Assignment): IStatement {
+        // see if a typecast is needed to convert the value's type into the proper target type
+        val valuetype = assignment.value.inferType(program)
+        val targettype = assignment.target.inferType(program, assignment)
+        if(targettype!=null && valuetype!=null) {
+            if(valuetype!=targettype) {
+                if (valuetype isAssignableTo targettype) {
                     assignment.value = TypecastExpression(assignment.value, targettype, true, assignment.value.position)
                     assignment.value.linkParents(assignment)
                 }
                 // if they're not assignable, we'll get a proper error later from the AstChecker
             }
-        } else TODO("multi-target assign")
+        }
 
-        return super.process(assignment)
+        // struct assignments will be flattened
+        if(valuetype==DataType.STRUCT && targettype==DataType.STRUCT) {
+            val assignments = flattenStructAssignment(assignment, program)
+            if(assignments.isEmpty()) {
+                // something went wrong (probably incompatible struct types)
+                // we'll get an error later from the AstChecker
+                return assignment
+            } else {
+                val scope = AnonymousScope(assignments.toMutableList(), assignment.position)
+                scope.linkParents(assignment.parent)
+                return scope
+            }
+        }
+
+        return super.visit(assignment)
     }
 
-    override fun process(functionCallStatement: FunctionCallStatement): IStatement {
+    override fun visit(functionCallStatement: FunctionCallStatement): IStatement {
         checkFunctionCallArguments(functionCallStatement, functionCallStatement.definingScope())
-        return super.process(functionCallStatement)
+        return super.visit(functionCallStatement)
     }
 
-    override fun process(functionCall: FunctionCall): IExpression {
+    override fun visit(functionCall: FunctionCall): IExpression {
         checkFunctionCallArguments(functionCall, functionCall.definingScope())
-        return super.process(functionCall)
+        return super.visit(functionCall)
     }
 
     private fun checkFunctionCallArguments(call: IFunctionCall, scope: INameScope) {
         // see if a typecast is needed to convert the arguments into the required parameter's type
-        val sub = call.target.targetStatement(scope)
-        when(sub) {
+        when(val sub = call.target.targetStatement(scope)) {
             is Subroutine -> {
                 for(arg in sub.parameters.zip(call.arglist.withIndex())) {
                     val argtype = arg.second.value.inferType(program)
@@ -300,131 +319,64 @@ private class StatementReorderer(private val program: Program): IAstProcessor {
                 break
             }
         }
-        val sorted = sequence.sortedWith(compareBy({it.value.inferType(program)}, {it.singleTarget?.shortString(true)}))
+        val sorted = sequence.sortedWith(compareBy({it.value.inferType(program)}, {it.target.shortString(true)}))
         return Pair(sorted, trailing)
     }
 
-    override fun process(typecast: TypecastExpression): IExpression {
+    override fun visit(typecast: TypecastExpression): IExpression {
         // warn about any implicit type casts to Float, because that may not be intended
         if(typecast.implicit && typecast.type in setOf(DataType.FLOAT, DataType.ARRAY_F)) {
             printWarning("byte or word value implicitly converted to float. Suggestion: use explicit cast as float, a float number, or revert to integer arithmetic", typecast.position)
         }
-        return super.process(typecast)
+        return super.visit(typecast)
     }
-}
 
-
-private class VarInitValueAndAddressOfCreator(private val namespace: INameScope): IAstProcessor {
-    // For VarDecls that declare an initialization value:
-    // Replace the vardecl with an assignment (to set the initial value),
-    // and add a new vardecl with the default constant value of that type (usually zero) to the scope.
-    // This makes sure the variables get reset to the intended value on a next run of the program.
-    // Variable decls without a value don't get this treatment, which means they retain the last
-    // value they had when restarting the program.
-    // This is done in a separate step because it interferes with the namespace lookup of symbols
-    // in other ast processors.
-
-    // Also takes care to insert AddressOf (&) expression where required (string params to a UWORD function param etc).
-
-    private val vardeclsToAdd = mutableMapOf<INameScope, MutableMap<String, VarDecl>>()
-
-    override fun process(module: Module) {
-        vardeclsToAdd.clear()
-        super.process(module)
-
-        // add any new vardecls to the various scopes
-        for(decl in vardeclsToAdd)
-            for(d in decl.value) {
-                d.value.linkParents(decl.key as Node)
-                decl.key.statements.add(0, d.value)
+    override fun visit(whenStatement: WhenStatement): IStatement {
+        // make sure all choices are just for one single value
+        val choices = whenStatement.choices.toList()
+        for(choice in choices) {
+            if(choice.values==null || choice.values.size==1)
+                continue
+            for(v in choice.values) {
+                val newchoice=WhenChoice(listOf(v), choice.statements, choice.position)
+                newchoice.parent = choice.parent
+                whenStatement.choices.add(newchoice)
             }
-    }
-
-    override fun process(decl: VarDecl): IStatement {
-        super.process(decl)
-        if(decl.type!=VarDeclType.VAR || decl.value==null)
-            return decl
-
-        if(decl.datatype in NumericDatatypes) {
-            val scope = decl.definingScope()
-            addVarDecl(scope, decl.asDefaultValueDecl(null))
-            val declvalue = decl.value!!
-            val value =
-                    if(declvalue is LiteralValue) {
-                        val converted = declvalue.intoDatatype(decl.datatype)
-                        converted ?: declvalue
-                    }
-                    else
-                        declvalue
-            val identifierName = listOf(decl.name)    //  // TODO this was: (scoped name) decl.scopedname.split(".")
-            return VariableInitializationAssignment(
-                    AssignTarget(null, IdentifierReference(identifierName, decl.position), null, null, decl.position),
-                    null,
-                    value,
-                    decl.position
-            )
+            whenStatement.choices.remove(choice)
         }
-        return decl
+
+        // sort the choices in low-to-high value order (nulls last)
+        whenStatement.choices
+                .sortWith(compareBy<WhenChoice, Int?>(nullsLast(), {it.values?.single()?.constValue(program)?.asIntegerValue}))
+        return super.visit(whenStatement)
     }
 
-    override fun process(functionCall: FunctionCall): IExpression {
-        val targetStatement = functionCall.target.targetSubroutine(namespace)
-        if(targetStatement!=null) {
-            var node: Node = functionCall
-            while(node !is IStatement)
-                node=node.parent
-            addAddressOfExprIfNeeded(targetStatement, functionCall.arglist, node)
-        }
-        return functionCall
-    }
-
-    override fun process(functionCallStatement: FunctionCallStatement): IStatement {
-        val targetStatement = functionCallStatement.target.targetSubroutine(namespace)
-        if(targetStatement!=null)
-            addAddressOfExprIfNeeded(targetStatement, functionCallStatement.arglist, functionCallStatement)
-        return functionCallStatement
-    }
-
-    private fun addAddressOfExprIfNeeded(subroutine: Subroutine, arglist: MutableList<IExpression>, parent: IStatement) {
-        // functions that accept UWORD and are given an array type, or string, will receive the AddressOf (memory location) of that value instead.
-        for(argparam in subroutine.parameters.withIndex().zip(arglist)) {
-            if(argparam.first.value.type==DataType.UWORD || argparam.first.value.type in StringDatatypes) {
-                if(argparam.second is AddressOf)
-                    continue
-                val idref = argparam.second as? IdentifierReference
-                val strvalue = argparam.second as? LiteralValue
-                if(idref!=null) {
-                    val variable = idref.targetVarDecl(namespace)
-                    if(variable!=null && (variable.datatype in StringDatatypes || variable.datatype in ArrayDatatypes)) {
-                        val pointerExpr = AddressOf(idref, idref.position)
-                        pointerExpr.scopedname = parent.makeScopedName(idref.nameInSource.single())
-                        pointerExpr.linkParents(arglist[argparam.first.index].parent)
-                        arglist[argparam.first.index] = pointerExpr
-                    }
-                }
-                else if(strvalue!=null) {
-                    if(strvalue.isString) {
-                        // replace the argument with &autovar
-                        val autoVarName = "$autoHeapValuePrefix${strvalue.heapId}"
-                        val autoHeapvarRef = IdentifierReference(listOf(autoVarName), strvalue.position)
-                        val pointerExpr = AddressOf(autoHeapvarRef, strvalue.position)
-                        pointerExpr.scopedname = parent.makeScopedName(autoVarName)
-                        pointerExpr.linkParents(arglist[argparam.first.index].parent)
-                        arglist[argparam.first.index] = pointerExpr
-                        // add a vardecl so that the autovar can be resolved in later lookups
-                        val variable = VarDecl(VarDeclType.VAR, strvalue.type, false, null, autoVarName, strvalue,
-                                isArray = false, autoGenerated = false, position=strvalue.position)
-                        addVarDecl(strvalue.definingScope(), variable)
-                    }
-                }
+    override fun visit(memread: DirectMemoryRead): IExpression {
+        // make sure the memory address is an uword
+        val dt = memread.addressExpression.inferType(program)
+        if(dt!=DataType.UWORD) {
+            val literaladdr = memread.addressExpression as? LiteralValue
+            if(literaladdr!=null) {
+                memread.addressExpression = literaladdr.cast(DataType.UWORD)!!
+            } else {
+                memread.addressExpression = TypecastExpression(memread.addressExpression, DataType.UWORD, true, memread.addressExpression.position)
+                memread.addressExpression.parent = memread
             }
         }
+        return super.visit(memread)
     }
 
-    private fun addVarDecl(scope: INameScope, variable: VarDecl) {
-        if(scope !in vardeclsToAdd)
-            vardeclsToAdd[scope] = mutableMapOf()
-        vardeclsToAdd.getValue(scope)[variable.name]=variable
+    override fun visit(memwrite: DirectMemoryWrite) {
+        val dt = memwrite.addressExpression.inferType(program)
+        if(dt!=DataType.UWORD) {
+            val literaladdr = memwrite.addressExpression as? LiteralValue
+            if(literaladdr!=null) {
+                memwrite.addressExpression = literaladdr.cast(DataType.UWORD)!!
+            } else {
+                memwrite.addressExpression = TypecastExpression(memwrite.addressExpression, DataType.UWORD, true, memwrite.addressExpression.position)
+                memwrite.addressExpression.parent = memwrite
+            }
+        }
+        super.visit(memwrite)
     }
-
 }

compiler/src/prog8/ast/processing/VarInitValueAndAddressOfCreator.kt

@@ -0,0 +1,128 @@
+package prog8.ast.processing
+
+import prog8.ast.*
+import prog8.ast.base.*
+import prog8.ast.base.autoHeapValuePrefix
+import prog8.ast.expressions.AddressOf
+import prog8.ast.expressions.FunctionCall
+import prog8.ast.expressions.IdentifierReference
+import prog8.ast.expressions.LiteralValue
+import prog8.ast.statements.*
+import prog8.compiler.CompilerException
+
+
+internal class VarInitValueAndAddressOfCreator(private val namespace: INameScope): IAstModifyingVisitor {
+    // For VarDecls that declare an initialization value:
+    // Replace the vardecl with an assignment (to set the initial value),
+    // and add a new vardecl with the default constant value of that type (usually zero) to the scope.
+    // This makes sure the variables get reset to the intended value on a next run of the program.
+    // Variable decls without a value don't get this treatment, which means they retain the last
+    // value they had when restarting the program.
+    // This is done in a separate step because it interferes with the namespace lookup of symbols
+    // in other ast processors.
+
+    // Also takes care to insert AddressOf (&) expression where required (string params to a UWORD function param etc).
+
+    private val vardeclsToAdd = mutableMapOf<INameScope, MutableList<VarDecl>>()
+
+    override fun visit(module: Module) {
+        vardeclsToAdd.clear()
+        super.visit(module)
+
+        // add any new vardecls to the various scopes
+        for((where, decls) in vardeclsToAdd) {
+            where.statements.addAll(0, decls)
+            decls.forEach { it.linkParents(where as Node) }
+        }
+    }
+
+    override fun visit(decl: VarDecl): IStatement {
+        super.visit(decl)
+        if(decl.type!= VarDeclType.VAR || decl.value==null)
+            return decl
+
+        if(decl.datatype in NumericDatatypes) {
+            val scope = decl.definingScope()
+            addVarDecl(scope, decl.asDefaultValueDecl(null))
+            val declvalue = decl.value!!
+            val value =
+                    if(declvalue is LiteralValue) {
+                        val converted = declvalue.cast(decl.datatype)
+                        converted ?: declvalue
+                    }
+                    else
+                        declvalue
+            val identifierName = listOf(decl.name)    //  // TODO this was: (scoped name) decl.scopedname.split(".")
+            return VariableInitializationAssignment(
+                    AssignTarget(null, IdentifierReference(identifierName, decl.position), null, null, decl.position),
+                    null,
+                    value,
+                    decl.position
+            )
+        }
+        return decl
+    }
+
+    override fun visit(functionCall: FunctionCall): IExpression {
+        val targetStatement = functionCall.target.targetSubroutine(namespace)
+        if(targetStatement!=null) {
+            var node: Node = functionCall
+            while(node !is IStatement)
+                node=node.parent
+            addAddressOfExprIfNeeded(targetStatement, functionCall.arglist, node)
+        }
+        return functionCall
+    }
+
+    override fun visit(functionCallStatement: FunctionCallStatement): IStatement {
+        val targetStatement = functionCallStatement.target.targetSubroutine(namespace)
+        if(targetStatement!=null)
+            addAddressOfExprIfNeeded(targetStatement, functionCallStatement.arglist, functionCallStatement)
+        return functionCallStatement
+    }
+
+    private fun addAddressOfExprIfNeeded(subroutine: Subroutine, arglist: MutableList<IExpression>, parent: IStatement) {
+        // functions that accept UWORD and are given an array type, or string, will receive the AddressOf (memory location) of that value instead.
+        for(argparam in subroutine.parameters.withIndex().zip(arglist)) {
+            if(argparam.first.value.type==DataType.UWORD || argparam.first.value.type in StringDatatypes) {
+                if(argparam.second is AddressOf)
+                    continue
+                val idref = argparam.second as? IdentifierReference
+                val strvalue = argparam.second as? LiteralValue
+                if(idref!=null) {
+                    val variable = idref.targetVarDecl(namespace)
+                    if(variable!=null && (variable.datatype in StringDatatypes || variable.datatype in ArrayDatatypes)) {
+                        val pointerExpr = AddressOf(idref, idref.position)
+                        pointerExpr.scopedname = parent.makeScopedName(idref.nameInSource.single())
+                        pointerExpr.linkParents(arglist[argparam.first.index].parent)
+                        arglist[argparam.first.index] = pointerExpr
+                    }
+                }
+                else if(strvalue!=null) {
+                    if(strvalue.isString) {
+                        // replace the argument with &autovar
+                        val autoVarName = "$autoHeapValuePrefix${strvalue.heapId}"
+                        val autoHeapvarRef = IdentifierReference(listOf(autoVarName), strvalue.position)
+                        val pointerExpr = AddressOf(autoHeapvarRef, strvalue.position)
+                        pointerExpr.scopedname = parent.makeScopedName(autoVarName)
+                        pointerExpr.linkParents(arglist[argparam.first.index].parent)
+                        arglist[argparam.first.index] = pointerExpr
+                        // add a vardecl so that the autovar can be resolved in later lookups
+                        val variable = VarDecl(VarDeclType.VAR, strvalue.type, ZeropageWish.NOT_IN_ZEROPAGE, null, autoVarName, null, strvalue,
+                                isArray = false, hiddenButDoNotRemove = false, position = strvalue.position)
+                        addVarDecl(strvalue.definingScope(), variable)
+                    }
+                }
+            }
+        }
+    }
+
+    private fun addVarDecl(scope: INameScope, variable: VarDecl) {
+        if(scope !in vardeclsToAdd)
+            vardeclsToAdd[scope] = mutableListOf()
+        val declList = vardeclsToAdd.getValue(scope)
+        if(declList.all{it.name!=variable.name})
+            declList.add(variable)
+    }
+
+}

compiler/src/prog8/ast/statements/AstStatements.kt

@@ -0,0 +1,810 @@
+package prog8.ast.statements
+
+import prog8.ast.*
+import prog8.ast.base.*
+import prog8.ast.expressions.*
+import prog8.ast.processing.IAstModifyingVisitor
+import prog8.ast.processing.IAstVisitor
+import prog8.compiler.HeapValues
+import prog8.compiler.target.c64.MachineDefinition
+
+
+class BuiltinFunctionStatementPlaceholder(val name: String, override val position: Position) : IStatement {
+    override var parent: Node = ParentSentinel
+    override fun linkParents(parent: Node) {}
+    override fun accept(visitor: IAstModifyingVisitor) = visitor.visit(this)
+    override fun accept(visitor: IAstVisitor) = visitor.visit(this)
+    override fun definingScope(): INameScope = BuiltinFunctionScopePlaceholder
+    override val expensiveToInline = false
+}
+
+
+data class RegisterOrStatusflag(val registerOrPair: RegisterOrPair?, val statusflag: Statusflag?, val stack: Boolean?)
+
+
+class Block(override val name: String,
+            val address: Int?,
+            override var statements: MutableList<IStatement>,
+            val isInLibrary: Boolean,
+            override val position: Position) : IStatement, INameScope {
+    override lateinit var parent: Node
+    override val expensiveToInline
+        get() = statements.any { it.expensiveToInline }
+
+    override fun linkParents(parent: Node) {
+        this.parent = parent
+        statements.forEach {it.linkParents(this)}
+    }
+
+    override fun accept(visitor: IAstModifyingVisitor) = visitor.visit(this)
+    override fun accept(visitor: IAstVisitor) = visitor.visit(this)
+
+    override fun toString(): String {
+        return "Block(name=$name, address=$address, ${statements.size} statements)"
+    }
+
+    fun options() = statements.filter { it is Directive && it.directive == "%option" }.flatMap { (it as Directive).args }.map {it.name!!}.toSet()
+}
+
+data class Directive(val directive: String, val args: List<DirectiveArg>, override val position: Position) : IStatement {
+    override lateinit var parent: Node
+    override val expensiveToInline = false
+
+    override fun linkParents(parent: Node) {
+        this.parent = parent
+        args.forEach{it.linkParents(this)}
+    }
+
+    override fun accept(visitor: IAstModifyingVisitor) = visitor.visit(this)
+    override fun accept(visitor: IAstVisitor) = visitor.visit(this)
+}
+
+data class DirectiveArg(val str: String?, val name: String?, val int: Int?, override val position: Position) : Node {
+    override lateinit var parent: Node
+
+    override fun linkParents(parent: Node) {
+        this.parent = parent
+    }
+}
+
+data class Label(val name: String, override val position: Position) : IStatement {
+    override lateinit var parent: Node
+    override val expensiveToInline = false
+
+    override fun linkParents(parent: Node) {
+        this.parent = parent
+    }
+
+    override fun accept(visitor: IAstModifyingVisitor) = visitor.visit(this)
+    override fun accept(visitor: IAstVisitor) = visitor.visit(this)
+
+    override fun toString(): String {
+        return "Label(name=$name, pos=$position)"
+    }
+
+    val scopedname: String by lazy { makeScopedName(name) }
+}
+
+open class Return(var value: IExpression?, override val position: Position) : IStatement {
+    override lateinit var parent: Node
+    override val expensiveToInline = value!=null && value !is LiteralValue
+
+    override fun linkParents(parent: Node) {
+        this.parent = parent
+        value?.linkParents(this)
+    }
+
+    override fun accept(visitor: IAstModifyingVisitor) = visitor.visit(this)
+    override fun accept(visitor: IAstVisitor) = visitor.visit(this)
+
+    override fun toString(): String {
+        return "Return($value, pos=$position)"
+    }
+}
+
+class ReturnFromIrq(override val position: Position) : Return(null, position) {
+    override fun accept(visitor: IAstModifyingVisitor) = visitor.visit(this)
+    override fun accept(visitor: IAstVisitor) = visitor.visit(this)
+
+    override fun toString(): String {
+        return "ReturnFromIrq(pos=$position)"
+    }
+}
+
+class Continue(override val position: Position) : IStatement {
+    override lateinit var parent: Node
+    override val expensiveToInline = false
+
+    override fun linkParents(parent: Node) {
+        this.parent=parent
+    }
+
+    override fun accept(visitor: IAstModifyingVisitor) = visitor.visit(this)
+    override fun accept(visitor: IAstVisitor) = visitor.visit(this)
+}
+
+class Break(override val position: Position) : IStatement {
+    override lateinit var parent: Node
+    override val expensiveToInline = false
+
+    override fun linkParents(parent: Node) {
+        this.parent=parent
+    }
+
+    override fun accept(visitor: IAstModifyingVisitor) = visitor.visit(this)
+    override fun accept(visitor: IAstVisitor) = visitor.visit(this)
+}
+
+
+enum class ZeropageWish {
+    REQUIRE_ZEROPAGE,
+    PREFER_ZEROPAGE,
+    DONTCARE,
+    NOT_IN_ZEROPAGE
+}
+
+class VarDecl(val type: VarDeclType,
+              private val declaredDatatype: DataType,
+              val zeropage: ZeropageWish,
+              var arraysize: ArrayIndex?,
+              val name: String,
+              private val structName: String?,
+              var value: IExpression?,
+              val isArray: Boolean,
+              val hiddenButDoNotRemove: Boolean,
+              override val position: Position) : IStatement {
+    override lateinit var parent: Node
+    var struct: StructDecl? = null        // set later (because at parse time, we only know the name)
+        private set
+    var structHasBeenFlattened = false      // set later
+        private set
+
+    override val expensiveToInline
+            get() = value!=null && value !is LiteralValue
+
+    val datatypeErrors = mutableListOf<SyntaxError>()       // don't crash at init time, report them in the AstChecker
+    val datatype =
+            if (!isArray) declaredDatatype
+            else when (declaredDatatype) {
+                DataType.UBYTE -> DataType.ARRAY_UB
+                DataType.BYTE -> DataType.ARRAY_B
+                DataType.UWORD -> DataType.ARRAY_UW
+                DataType.WORD -> DataType.ARRAY_W
+                DataType.FLOAT -> DataType.ARRAY_F
+                else -> {
+                    datatypeErrors.add(SyntaxError("array can only contain bytes/words/floats", position))
+                    DataType.ARRAY_UB
+                }
+            }
+
+    override fun linkParents(parent: Node) {
+        this.parent = parent
+        arraysize?.linkParents(this)
+        value?.linkParents(this)
+        if(structName!=null) {
+            struct = definingScope().lookup(listOf(structName), this) as StructDecl
+        }
+    }
+
+    override fun accept(visitor: IAstModifyingVisitor) = visitor.visit(this)
+    override fun accept(visitor: IAstVisitor) = visitor.visit(this)
+
+    val scopedname: String by lazy { makeScopedName(name) }
+
+    override fun toString(): String {
+        return "VarDecl(name=$name, vartype=$type, datatype=$datatype, struct=$structName, value=$value, pos=$position)"
+    }
+
+    fun asDefaultValueDecl(parent: Node?): VarDecl {
+        val constValue = when(declaredDatatype) {
+            DataType.UBYTE -> LiteralValue(DataType.UBYTE, 0, position = position)
+            DataType.BYTE -> LiteralValue(DataType.BYTE, 0, position = position)
+            DataType.UWORD -> LiteralValue(DataType.UWORD, wordvalue = 0, position = position)
+            DataType.WORD -> LiteralValue(DataType.WORD, wordvalue = 0, position = position)
+            DataType.FLOAT -> LiteralValue(DataType.FLOAT, floatvalue = 0.0, position = position)
+            else -> throw FatalAstException("can only set a default value for a numeric type")
+        }
+        val decl = VarDecl(type, declaredDatatype, zeropage, arraysize, name, structName, constValue, isArray, true, position)
+        if(parent!=null)
+            decl.linkParents(parent)
+        return decl
+    }
+
+    fun flattenStructMembers(): MutableList<IStatement> {
+        val result = struct!!.statements.withIndex().map {
+            val member = it.value as VarDecl
+            val initvalue = if(value!=null) (value as LiteralValue).arrayvalue!![it.index] else null
+            VarDecl(
+                    VarDeclType.VAR,
+                    member.datatype,
+                    ZeropageWish.NOT_IN_ZEROPAGE,
+                    member.arraysize,
+                    mangledStructMemberName(name, member.name),
+                    struct!!.name,
+                    initvalue,
+                    member.isArray,
+                    true,
+                    member.position
+            ) as IStatement
+        }.toMutableList()
+        structHasBeenFlattened = true
+        return result
+    }
+}
+
+class ArrayIndex(var index: IExpression, override val position: Position) : Node {
+    override lateinit var parent: Node
+
+    override fun linkParents(parent: Node) {
+        this.parent = parent
+        index.linkParents(this)
+    }
+
+    companion object {
+        fun forArray(v: LiteralValue, heap: HeapValues): ArrayIndex {
+            val arraySize = v.arrayvalue?.size ?: heap.get(v.heapId!!).arraysize
+            return ArrayIndex(LiteralValue.optimalNumeric(arraySize, v.position), v.position)
+        }
+    }
+
+    fun accept(visitor: IAstModifyingVisitor) {
+        index = index.accept(visitor)
+    }
+    fun accept(visitor: IAstVisitor) {
+        index.accept(visitor)
+    }
+
+    override fun toString(): String {
+        return("ArrayIndex($index, pos=$position)")
+    }
+
+    fun size() = (index as? LiteralValue)?.asIntegerValue
+}
+
+open class Assignment(var target: AssignTarget, val aug_op : String?, var value: IExpression, override val position: Position) : IStatement {
+    override lateinit var parent: Node
+    override val expensiveToInline
+            get() = value !is LiteralValue
+
+    override fun linkParents(parent: Node) {
+        this.parent = parent
+        this.target.linkParents(this)
+        value.linkParents(this)
+    }
+
+    override fun accept(visitor: IAstModifyingVisitor) = visitor.visit(this)
+    override fun accept(visitor: IAstVisitor) = visitor.visit(this)
+
+    override fun toString(): String {
+        return("Assignment(augop: $aug_op, target: $target, value: $value, pos=$position)")
+    }
+}
+
+// This is a special class so the compiler can see if the assignments are for initializing the vars in the scope,
+// or just a regular assignment. It may optimize the initialization step from this.
+class VariableInitializationAssignment(target: AssignTarget, aug_op: String?, value: IExpression, position: Position)
+    : Assignment(target, aug_op, value, position)
+
+data class AssignTarget(val register: Register?,
+                        val identifier: IdentifierReference?,
+                        val arrayindexed: ArrayIndexedExpression?,
+                        var memoryAddress: DirectMemoryWrite?,
+                        override val position: Position) : Node {
+    override lateinit var parent: Node
+
+    override fun linkParents(parent: Node) {
+        this.parent = parent
+        identifier?.linkParents(this)
+        arrayindexed?.linkParents(this)
+        memoryAddress?.linkParents(this)
+    }
+
+    fun accept(visitor: IAstModifyingVisitor) = visitor.visit(this)
+    fun accept(visitor: IAstVisitor) = visitor.visit(this)
+
+    companion object {
+        fun fromExpr(expr: IExpression): AssignTarget {
+            return when (expr) {
+                is RegisterExpr -> AssignTarget(expr.register, null, null, null, expr.position)
+                is IdentifierReference -> AssignTarget(null, expr, null, null, expr.position)
+                is ArrayIndexedExpression -> AssignTarget(null, null, expr, null, expr.position)
+                is DirectMemoryRead -> AssignTarget(null, null, null, DirectMemoryWrite(expr.addressExpression, expr.position), expr.position)
+                else -> throw FatalAstException("invalid expression object $expr")
+            }
+        }
+    }
+
+    fun inferType(program: Program, stmt: IStatement): DataType? {
+        if(register!=null)
+            return DataType.UBYTE
+
+        if(identifier!=null) {
+            val symbol = program.namespace.lookup(identifier.nameInSource, stmt) ?: return null
+            if (symbol is VarDecl) return symbol.datatype
+        }
+
+        if(arrayindexed!=null) {
+            val dt = arrayindexed.inferType(program)
+            if(dt!=null)
+                return dt
+        }
+
+        if(memoryAddress!=null)
+            return DataType.UBYTE
+
+        return null
+    }
+
+    fun shortString(withTypePrefix: Boolean=false): String {
+        if(register!=null)
+            return (if(withTypePrefix) "0register::" else "") + register.name
+        if(identifier!=null)
+            return (if(withTypePrefix) "3identifier::" else "") + identifier.nameInSource.last()
+        if(arrayindexed!=null)
+            return (if(withTypePrefix) "2arrayidx::" else "") + arrayindexed.identifier.nameInSource.last()
+        val address = memoryAddress?.addressExpression
+        if(address is LiteralValue)
+            return (if(withTypePrefix) "1address::" else "") +address.asIntegerValue.toString()
+        return if(withTypePrefix) "???::???" else "???"
+    }
+
+    fun isMemoryMapped(namespace: INameScope): Boolean =
+            memoryAddress!=null || (identifier?.targetVarDecl(namespace)?.type== VarDeclType.MEMORY)
+
+    infix fun isSameAs(value: IExpression): Boolean {
+        return when {
+            this.memoryAddress!=null -> false
+            this.register!=null -> value is RegisterExpr && value.register==register
+            this.identifier!=null -> value is IdentifierReference && value.nameInSource==identifier.nameInSource
+            this.arrayindexed!=null -> value is ArrayIndexedExpression &&
+                    value.identifier.nameInSource==arrayindexed.identifier.nameInSource &&
+                    value.arrayspec.size()!=null &&
+                    arrayindexed.arrayspec.size()!=null &&
+                    value.arrayspec.size()==arrayindexed.arrayspec.size()
+            else -> false
+        }
+    }
+
+    fun isSameAs(other: AssignTarget, program: Program): Boolean {
+        if(this===other)
+            return true
+        if(this.register!=null && other.register!=null)
+            return this.register==other.register
+        if(this.identifier!=null && other.identifier!=null)
+            return this.identifier.nameInSource==other.identifier.nameInSource
+        if(this.memoryAddress!=null && other.memoryAddress!=null) {
+            val addr1 = this.memoryAddress!!.addressExpression.constValue(program)
+            val addr2 = other.memoryAddress!!.addressExpression.constValue(program)
+            return addr1!=null && addr2!=null && addr1==addr2
+        }
+        if(this.arrayindexed!=null && other.arrayindexed!=null) {
+            if(this.arrayindexed.identifier.nameInSource == other.arrayindexed.identifier.nameInSource) {
+                val x1 = this.arrayindexed.arrayspec.index.constValue(program)
+                val x2 = other.arrayindexed.arrayspec.index.constValue(program)
+                return x1!=null && x2!=null && x1==x2
+            }
+        }
+        return false
+    }
+
+    fun isNotMemory(namespace: INameScope): Boolean {
+        if(this.register!=null)
+            return true
+        if(this.memoryAddress!=null)
+            return false
+        if(this.arrayindexed!=null) {
+            val targetStmt = this.arrayindexed.identifier.targetVarDecl(namespace)
+            if(targetStmt!=null)
+                return targetStmt.type!= VarDeclType.MEMORY
+        }
+        if(this.identifier!=null) {
+            val targetStmt = this.identifier.targetVarDecl(namespace)
+            if(targetStmt!=null)
+                return targetStmt.type!= VarDeclType.MEMORY
+        }
+        return false
+    }
+}
+
+class PostIncrDecr(var target: AssignTarget, val operator: String, override val position: Position) : IStatement {
+    override lateinit var parent: Node
+    override val expensiveToInline = false
+
+    override fun linkParents(parent: Node) {
+        this.parent = parent
+        target.linkParents(this)
+    }
+
+    override fun accept(visitor: IAstModifyingVisitor) = visitor.visit(this)
+    override fun accept(visitor: IAstVisitor) = visitor.visit(this)
+
+    override fun toString(): String {
+        return "PostIncrDecr(op: $operator, target: $target, pos=$position)"
+    }
+}
+
+class Jump(val address: Int?,
+           val identifier: IdentifierReference?,
+           val generatedLabel: String?,             // used in code generation scenarios
+           override val position: Position) : IStatement {
+    override lateinit var parent: Node
+    override val expensiveToInline = false
+
+    override fun linkParents(parent: Node) {
+        this.parent = parent
+        identifier?.linkParents(this)
+    }
+
+    override fun accept(visitor: IAstModifyingVisitor) = visitor.visit(this)
+    override fun accept(visitor: IAstVisitor) = visitor.visit(this)
+
+    override fun toString(): String {
+        return "Jump(addr: $address, identifier: $identifier, label: $generatedLabel;  pos=$position)"
+    }
+}
+
+class FunctionCallStatement(override var target: IdentifierReference,
+                            override var arglist: MutableList<IExpression>,
+                            override val position: Position) : IStatement, IFunctionCall {
+    override lateinit var parent: Node
+    override val expensiveToInline
+            get() = arglist.any { it !is LiteralValue }
+
+    override fun linkParents(parent: Node) {
+        this.parent = parent
+        target.linkParents(this)
+        arglist.forEach { it.linkParents(this) }
+    }
+
+    override fun accept(visitor: IAstModifyingVisitor) = visitor.visit(this)
+    override fun accept(visitor: IAstVisitor) = visitor.visit(this)
+
+    override fun toString(): String {
+        return "FunctionCallStatement(target=$target, pos=$position)"
+    }
+}
+
+class InlineAssembly(val assembly: String, override val position: Position) : IStatement {
+    override lateinit var parent: Node
+    override val expensiveToInline = true
+
+    override fun linkParents(parent: Node) {
+        this.parent = parent
+    }
+
+    override fun accept(visitor: IAstModifyingVisitor) = visitor.visit(this)
+    override fun accept(visitor: IAstVisitor) = visitor.visit(this)
+}
+
+class AnonymousScope(override var statements: MutableList<IStatement>,
+                     override val position: Position) : INameScope, IStatement {
+    override val name: String
+    override lateinit var parent: Node
+    override val expensiveToInline
+        get() = statements.any { it.expensiveToInline }
+
+    init {
+        name = "<anon-$sequenceNumber>"     // make sure it's an invalid soruce code identifier so user source code can never produce it
+        sequenceNumber++
+    }
+
+    companion object {
+        private var sequenceNumber = 1
+    }
+
+    override fun linkParents(parent: Node) {
+        this.parent = parent
+        statements.forEach { it.linkParents(this) }
+    }
+
+    override fun accept(visitor: IAstModifyingVisitor) = visitor.visit(this)
+    override fun accept(visitor: IAstVisitor) = visitor.visit(this)
+}
+
+class NopStatement(override val position: Position): IStatement {
+    override lateinit var parent: Node
+    override val expensiveToInline = false
+
+    override fun linkParents(parent: Node) {
+        this.parent = parent
+    }
+
+    override fun accept(visitor: IAstModifyingVisitor) = visitor.visit(this)
+    override fun accept(visitor: IAstVisitor) = visitor.visit(this)
+
+    companion object {
+        fun insteadOf(stmt: IStatement): NopStatement {
+            val nop = NopStatement(stmt.position)
+            nop.parent = stmt.parent
+            return nop
+        }
+    }
+}
+
+// the subroutine class covers both the normal user-defined subroutines,
+// and also the predefined/ROM/register-based subroutines.
+// (multiple return types can only occur for the latter type)
+class Subroutine(override val name: String,
+                 val parameters: List<SubroutineParameter>,
+                 val returntypes: List<DataType>,
+                 val asmParameterRegisters: List<RegisterOrStatusflag>,
+                 val asmReturnvaluesRegisters: List<RegisterOrStatusflag>,
+                 val asmClobbers: Set<Register>,
+                 val asmAddress: Int?,
+                 val isAsmSubroutine: Boolean,
+                 override var statements: MutableList<IStatement>,
+                 override val position: Position) : IStatement, INameScope {
+
+    var keepAlways: Boolean = false
+    override val expensiveToInline
+            get() = statements.any { it.expensiveToInline }
+
+    override lateinit var parent: Node
+    val calledBy = mutableListOf<Node>()
+    val calls = mutableSetOf<Subroutine>()
+
+    val scopedname: String by lazy { makeScopedName(name) }
+
+    override fun linkParents(parent: Node) {
+        this.parent = parent
+        parameters.forEach { it.linkParents(this) }
+        statements.forEach { it.linkParents(this) }
+    }
+
+    override fun accept(visitor: IAstModifyingVisitor) = visitor.visit(this)
+    override fun accept(visitor: IAstVisitor) = visitor.visit(this)
+
+    override fun toString(): String {
+        return "Subroutine(name=$name, parameters=$parameters, returntypes=$returntypes, ${statements.size} statements, address=$asmAddress)"
+    }
+
+    fun amountOfRtsInAsm(): Int = statements
+            .asSequence()
+            .filter { it is InlineAssembly }
+            .map { (it as InlineAssembly).assembly }
+            .count { " rti" in it || "\trti" in it || " rts" in it || "\trts" in it || " jmp" in it || "\tjmp" in it }
+
+    val canBeAsmSubroutine =false // TODO disabled for now, see below about problem with converting to asm subroutine
+//            !isAsmSubroutine
+//                    && ((parameters.size == 1 && parameters[0].type in setOf(DataType.BYTE, DataType.UBYTE, DataType.WORD, DataType.UWORD))
+//                    || (parameters.size == 2 && parameters.map { it.type }.all { it == DataType.BYTE || it == DataType.UBYTE }))
+
+    fun intoAsmSubroutine(): Subroutine {
+        // TODO turn subroutine into asm calling convention.   Requires rethinking of how parameters are handled (conflicts with local vardefs now, see AstIdentifierChecker...)
+        return this // TODO
+
+//        println("TO ASM   $this")  // TODO
+//        val paramregs = if (parameters.size == 1 && parameters[0].type in setOf(DataType.BYTE, DataType.UBYTE))
+//            listOf(RegisterOrStatusflag(RegisterOrPair.Y, null, null))
+//        else if (parameters.size == 1 && parameters[0].type in setOf(DataType.WORD, DataType.UWORD))
+//            listOf(RegisterOrStatusflag(RegisterOrPair.AY, null, null))
+//        else if (parameters.size == 2 && parameters.map { it.type }.all { it == DataType.BYTE || it == DataType.UBYTE })
+//            listOf(RegisterOrStatusflag(RegisterOrPair.A, null, null), RegisterOrStatusflag(RegisterOrPair.Y, null, null))
+//        else throw FatalAstException("cannot convert subroutine to asm parameters")
+//
+//        val asmsub=Subroutine(
+//                name,
+//                parameters,
+//                returntypes,
+//                paramregs,
+//                emptyList(),
+//                emptySet(),
+//                null,
+//                true,
+//                statements,
+//                position
+//        )
+//        asmsub.linkParents(parent)
+//        return asmsub
+    }
+}
+
+open class SubroutineParameter(val name: String,
+                               val type: DataType,
+                               override val position: Position) : Node {
+    override lateinit var parent: Node
+
+    override fun linkParents(parent: Node) {
+        this.parent = parent
+    }
+}
+
+class IfStatement(var condition: IExpression,
+                  var truepart: AnonymousScope,
+                  var elsepart: AnonymousScope,
+                  override val position: Position) : IStatement {
+    override lateinit var parent: Node
+    override val expensiveToInline: Boolean
+        get() = truepart.expensiveToInline || elsepart.expensiveToInline
+
+    override fun linkParents(parent: Node) {
+        this.parent = parent
+        condition.linkParents(this)
+        truepart.linkParents(this)
+        elsepart.linkParents(this)
+    }
+
+    override fun accept(visitor: IAstModifyingVisitor) = visitor.visit(this)
+    override fun accept(visitor: IAstVisitor) = visitor.visit(this)
+}
+
+class BranchStatement(var condition: BranchCondition,
+                      var truepart: AnonymousScope,
+                      var elsepart: AnonymousScope,
+                      override val position: Position) : IStatement {
+    override lateinit var parent: Node
+    override val expensiveToInline: Boolean
+        get() = truepart.expensiveToInline || elsepart.expensiveToInline
+
+    override fun linkParents(parent: Node) {
+        this.parent = parent
+        truepart.linkParents(this)
+        elsepart.linkParents(this)
+    }
+
+    override fun accept(visitor: IAstModifyingVisitor) = visitor.visit(this)
+    override fun accept(visitor: IAstVisitor) = visitor.visit(this)
+}
+
+class ForLoop(val loopRegister: Register?,
+              val decltype: DataType?,
+              val zeropage: ZeropageWish,
+              val loopVar: IdentifierReference?,
+              var iterable: IExpression,
+              var body: AnonymousScope,
+              override val position: Position) : IStatement {
+    override lateinit var parent: Node
+    override val expensiveToInline = true
+
+    override fun linkParents(parent: Node) {
+        this.parent=parent
+        loopVar?.linkParents(if(decltype==null) this else body)
+        iterable.linkParents(this)
+        body.linkParents(this)
+    }
+
+    override fun accept(visitor: IAstModifyingVisitor) = visitor.visit(this)
+    override fun accept(visitor: IAstVisitor) = visitor.visit(this)
+
+    override fun toString(): String {
+        return "ForLoop(loopVar: $loopVar, loopReg: $loopRegister, iterable: $iterable, pos=$position)"
+    }
+
+    companion object {
+        const val iteratorLoopcounterVarname = "prog8forloopcounter"
+    }
+}
+
+class WhileLoop(var condition: IExpression,
+                var body: AnonymousScope,
+                override val position: Position) : IStatement {
+    override lateinit var parent: Node
+    override val expensiveToInline = true
+
+    override fun linkParents(parent: Node) {
+        this.parent = parent
+        condition.linkParents(this)
+        body.linkParents(this)
+    }
+
+    override fun accept(visitor: IAstModifyingVisitor) = visitor.visit(this)
+    override fun accept(visitor: IAstVisitor) = visitor.visit(this)
+}
+
+class RepeatLoop(var body: AnonymousScope,
+                 var untilCondition: IExpression,
+                 override val position: Position) : IStatement {
+    override lateinit var parent: Node
+    override val expensiveToInline = true
+
+    override fun linkParents(parent: Node) {
+        this.parent = parent
+        untilCondition.linkParents(this)
+        body.linkParents(this)
+    }
+
+    override fun accept(visitor: IAstModifyingVisitor) = visitor.visit(this)
+    override fun accept(visitor: IAstVisitor) = visitor.visit(this)
+}
+
+class WhenStatement(val condition: IExpression,
+                    val choices: MutableList<WhenChoice>,
+                    override val position: Position): IStatement {
+    override lateinit var parent: Node
+    override val expensiveToInline: Boolean = true
+
+    override fun linkParents(parent: Node) {
+        this.parent = parent
+        condition.linkParents(this)
+        choices.forEach { it.linkParents(this) }
+    }
+
+    fun choiceValues(program: Program): List<Pair<List<Int>?, WhenChoice>> {
+        // only gives sensible results when the choices are all valid (constant integers)
+        val result = mutableListOf<Pair<List<Int>?, WhenChoice>>()
+        for(choice in choices) {
+            if(choice.values==null)
+                result.add(null to choice)
+            else {
+                val values = choice.values.map { it.constValue(program)?.asNumericValue?.toInt() }
+                if(values.contains(null))
+                    result.add(null to choice)
+                else
+                    result.add(values.filterNotNull() to choice)
+            }
+        }
+        return result
+    }
+
+    override fun accept(visitor: IAstVisitor) = visitor.visit(this)
+    override fun accept(visitor: IAstModifyingVisitor) = visitor.visit(this)
+}
+
+class WhenChoice(val values: List<IExpression>?,           // if null,  this is the 'else' part
+                 val statements: AnonymousScope,
+                 override val position: Position) : Node {
+    override lateinit var parent: Node
+
+    override fun linkParents(parent: Node) {
+        values?.forEach { it.linkParents(this) }
+        statements.linkParents(this)
+        this.parent = parent
+    }
+
+    override fun toString(): String {
+        return "Choice($values at $position)"
+    }
+
+    fun accept(visitor: IAstVisitor) = visitor.visit(this)
+    fun accept(visitor: IAstModifyingVisitor) = visitor.visit(this)
+}
+
+
+class StructDecl(override val name: String,
+                 override var statements: MutableList<IStatement>,      // actually, only vardecls here
+                 override val position: Position): IStatement, INameScope {
+
+    override lateinit var parent: Node
+    override val expensiveToInline: Boolean = true
+
+    override fun linkParents(parent: Node) {
+        this.parent = parent
+        this.statements.forEach { it.linkParents(this) }
+    }
+
+    val numberOfElements: Int
+        get() = this.statements.size
+    val memorySize: Int
+        get() = this.statements.map {
+            val decl = it as VarDecl
+            when {
+                decl.datatype in ByteDatatypes -> 8
+                decl.datatype in WordDatatypes -> 16
+                decl.datatype==DataType.FLOAT -> MachineDefinition.Mflpt5.MemorySize
+                decl.datatype in StringDatatypes -> TODO("stringvalue size")
+                decl.datatype in ArrayDatatypes -> decl.arraysize!!.size()!!
+                decl.datatype==DataType.STRUCT -> decl.struct!!.memorySize
+                else -> throw FatalAstException("can't get size for $decl")
+            }
+        }.sum()
+
+    override fun accept(visitor: IAstVisitor) = visitor.visit(this)
+    override fun accept(visitor: IAstModifyingVisitor) = visitor.visit(this)
+}
+
+class DirectMemoryWrite(var addressExpression: IExpression, override val position: Position) : Node {
+    override lateinit var parent: Node
+
+    override fun linkParents(parent: Node) {
+        this.parent = parent
+        this.addressExpression.linkParents(this)
+    }
+
+    override fun toString(): String {
+        return "DirectMemoryWrite($addressExpression)"
+    }
+
+    fun accept(visitor: IAstVisitor) = visitor.visit(this)
+    fun accept(visitor: IAstModifyingVisitor) = visitor.visit(this)
+}
+

compiler/src/prog8/astvm/AstVm.kt

@@ -1,563 +0,0 @@
-package prog8.astvm
-
-import prog8.ast.*
-import prog8.compiler.RuntimeValue
-import prog8.compiler.RuntimeValueRange
-import prog8.compiler.target.c64.Petscii
-import java.awt.EventQueue
-
-
-class VmExecutionException(msg: String?) : Exception(msg)
-
-class VmTerminationException(msg: String?) : Exception(msg)
-
-class VmBreakpointException : Exception("breakpoint")
-
-
-class StatusFlags {
-    var carry: Boolean = false
-    var zero: Boolean = true
-    var negative: Boolean = false
-    var irqd: Boolean = false
-
-    private fun setFlags(value: LiteralValue?) {
-        if (value != null) {
-            when (value.type) {
-                DataType.UBYTE -> {
-                    val v = value.bytevalue!!.toInt()
-                    negative = v > 127
-                    zero = v == 0
-                }
-                DataType.BYTE -> {
-                    val v = value.bytevalue!!.toInt()
-                    negative = v < 0
-                    zero = v == 0
-                }
-                DataType.UWORD -> {
-                    val v = value.wordvalue!!
-                    negative = v > 32767
-                    zero = v == 0
-                }
-                DataType.WORD -> {
-                    val v = value.wordvalue!!
-                    negative = v < 0
-                    zero = v == 0
-                }
-                DataType.FLOAT -> {
-                    val flt = value.floatvalue!!
-                    negative = flt < 0.0
-                    zero = flt == 0.0
-                }
-                else -> {
-                    // no flags for non-numeric type
-                }
-            }
-        }
-    }
-}
-
-
-class RuntimeVariables {
-    fun define(scope: INameScope, name: String, initialValue: RuntimeValue) {
-        val where = vars.getValue(scope)
-        where[name] = initialValue
-        vars[scope] = where
-    }
-
-    fun defineMemory(scope: INameScope, name: String, address: Int) {
-        val where = memvars.getValue(scope)
-        where[name] = address
-        memvars[scope] = where
-    }
-
-    fun set(scope: INameScope, name: String, value: RuntimeValue) {
-        val where = vars.getValue(scope)
-        val existing = where[name]
-        if(existing==null) {
-            if(memvars.getValue(scope)[name]!=null)
-                throw NoSuchElementException("this is a memory mapped var, not a normal var: ${scope.name}.$name")
-            throw NoSuchElementException("no such runtime variable: ${scope.name}.$name")
-        }
-        if(existing.type!=value.type)
-            throw VmExecutionException("new value is of different datatype ${value.type} expected ${existing.type} for $name")
-        where[name] = value
-        vars[scope] = where
-    }
-
-    fun get(scope: INameScope, name: String): RuntimeValue {
-        val where = vars.getValue(scope)
-        val value = where[name] ?: throw NoSuchElementException("no such runtime variable: ${scope.name}.$name")
-        return value
-    }
-
-    fun getMemoryAddress(scope: INameScope, name: String): Int {
-        val where = memvars.getValue(scope)
-        val address = where[name] ?: throw NoSuchElementException("no such runtime memory-variable: ${scope.name}.$name")
-        return address
-    }
-
-    fun swap(a1: VarDecl, a2: VarDecl) = swap(a1.definingScope(), a1.name, a2.definingScope(), a2.name)
-
-    fun swap(scope1: INameScope, name1: String, scope2: INameScope, name2: String) {
-        val v1 = get(scope1, name1)
-        val v2 = get(scope2, name2)
-        set(scope1, name1, v2)
-        set(scope2, name2, v1)
-    }
-
-    private val vars = mutableMapOf<INameScope, MutableMap<String, RuntimeValue>>().withDefault { mutableMapOf() }
-    private val memvars = mutableMapOf<INameScope, MutableMap<String, Int>>().withDefault { mutableMapOf() }
-}
-
-
-class AstVm(val program: Program) {
-    val mem = Memory()
-    val statusflags = StatusFlags()
-
-    private var dialog = ScreenDialog()
-    var instructionCounter = 0
-
-    init {
-        dialog.requestFocusInWindow()
-
-        EventQueue.invokeLater {
-            dialog.pack()
-            dialog.isVisible = true
-            dialog.start()
-        }
-    }
-
-    fun run() {
-        try {
-            val init = VariablesCreator(runtimeVariables, program.heap)
-            init.process(program)
-
-            // initialize all global variables
-            for (m in program.modules) {
-                for (b in m.statements.filterIsInstance<Block>()) {
-                    for (s in b.statements.filterIsInstance<Subroutine>()) {
-                        if (s.name == initvarsSubName) {
-                            try {
-                                executeSubroutine(s, emptyList(), null)
-                            } catch (x: LoopControlReturn) {
-                                // regular return
-                            }
-                        }
-                    }
-                }
-            }
-
-            var entrypoint: Subroutine? = program.entrypoint() ?: throw VmTerminationException("no valid entrypoint found")
-            var startlabel: Label? = null
-
-            while(entrypoint!=null) {
-                try {
-                    executeSubroutine(entrypoint, emptyList(), startlabel)
-                    entrypoint = null
-                } catch (rx: LoopControlReturn) {
-                    // regular return
-                } catch (jx: LoopControlJump) {
-                    if (jx.address != null)
-                        throw VmTerminationException("doesn't support jumping to machine address ${jx.address}")
-                    when {
-                        jx.generatedLabel != null -> {
-                            val label = entrypoint.getLabelOrVariable(jx.generatedLabel) as Label
-                            TODO("generatedlabel $label")
-                        }
-                        jx.identifier != null -> {
-                            when (val jumptarget = entrypoint.lookup(jx.identifier.nameInSource, jx.identifier.parent)) {
-                                is Label -> {
-                                    startlabel = jumptarget
-                                    entrypoint = jumptarget.definingSubroutine()
-                                }
-                                is Subroutine -> entrypoint = jumptarget
-                                else -> throw VmTerminationException("weird jump target $jumptarget")
-                            }
-                        }
-                        else -> throw VmTerminationException("unspecified jump target")
-                    }
-                }
-            }
-            println("PROGRAM EXITED!")
-            dialog.title = "PROGRAM EXITED"
-        } catch (tx: VmTerminationException) {
-            println("Execution halted: ${tx.message}")
-        } catch (xx: VmExecutionException) {
-            println("Execution error: ${xx.message}")
-            throw xx
-        }
-    }
-
-    private val runtimeVariables = RuntimeVariables()
-    private val functions = BuiltinFunctions()
-    private val evalCtx = EvalContext(program, mem, statusflags, runtimeVariables, functions, ::executeSubroutine)
-
-    class LoopControlBreak : Exception()
-    class LoopControlContinue : Exception()
-    class LoopControlReturn(val returnvalues: List<RuntimeValue>) : Exception()
-    class LoopControlJump(val identifier: IdentifierReference?, val address: Int?, val generatedLabel: String?) : Exception()
-
-
-    internal fun executeSubroutine(sub: Subroutine, arguments: List<RuntimeValue>, startlabel: Label?=null): List<RuntimeValue> {
-        assert(!sub.isAsmSubroutine)
-        if (sub.statements.isEmpty())
-            throw VmTerminationException("scope contains no statements: $sub")
-        if (arguments.size != sub.parameters.size)
-            throw VmTerminationException("number of args doesn't match number of required parameters")
-
-        for (arg in sub.parameters.zip(arguments)) {
-            val idref = IdentifierReference(listOf(arg.first.name), sub.position)
-            performAssignment(AssignTarget(null, idref, null, null, idref.position),
-                    arg.second, sub.statements.first(), evalCtx)
-        }
-
-        val statements = sub.statements.iterator()
-        if(startlabel!=null) {
-            do {
-                val stmt = statements.next()
-            } while(stmt!==startlabel)
-        }
-
-        try {
-            while(statements.hasNext()) {
-                val s = statements.next()
-                try {
-                    executeStatement(sub, s)
-                }
-                catch (b: VmBreakpointException) {
-                    print("BREAKPOINT HIT at ${s.position} - Press enter to continue:")
-                    readLine()
-                }
-            }
-        } catch (r: LoopControlReturn) {
-            return r.returnvalues
-        }
-        throw VmTerminationException("instruction pointer overflow, is a return missing? $sub")
-    }
-
-    internal fun executeAnonymousScope(scope: INameScope) {
-        for (s in scope.statements) {
-            executeStatement(scope, s)
-        }
-    }
-
-
-    private fun executeStatement(sub: INameScope, stmt: IStatement) {
-        instructionCounter++
-        if (instructionCounter % 100 == 0)
-            Thread.sleep(1)
-        when (stmt) {
-            is NopStatement, is Label, is Subroutine -> {
-                // do nothing, skip this instruction
-            }
-            is Directive -> {
-                if (stmt.directive == "%breakpoint")
-                    throw VmBreakpointException()
-                else if (stmt.directive == "%asm")
-                    throw VmExecutionException("can't execute assembly code")
-            }
-            is VarDecl -> {
-                // should have been defined already when the program started
-            }
-            is FunctionCallStatement -> {
-                val target = stmt.target.targetStatement(program.namespace)
-                when (target) {
-                    is Subroutine -> {
-                        val args = evaluate(stmt.arglist)
-                        if (target.isAsmSubroutine) {
-                            performSyscall(target, args)
-                        } else {
-                            executeSubroutine(target, args, null)
-                            // any return value(s) are discarded
-                        }
-                    }
-                    is BuiltinFunctionStatementPlaceholder -> {
-                        if(target.name=="swap") {
-                            // swap cannot be implemented as a function, so inline it here
-                            executeSwap(stmt)
-                        } else {
-                            val args = evaluate(stmt.arglist)
-                            functions.performBuiltinFunction(target.name, args, statusflags)
-                        }
-                    }
-                    else -> {
-                        TODO("weird call $target")
-                    }
-                }
-            }
-            is Return -> throw LoopControlReturn(stmt.values.map { evaluate(it, evalCtx) })
-            is Continue -> throw LoopControlContinue()
-            is Break -> throw LoopControlBreak()
-            is Assignment -> {
-                if (stmt.aug_op != null)
-                    throw VmExecutionException("augmented assignment should have been converted into regular one $stmt")
-                val target = stmt.singleTarget
-                if (target != null) {
-                    val value = evaluate(stmt.value, evalCtx)
-                    performAssignment(target, value, stmt, evalCtx)
-                } else TODO("assign multitarget $stmt")
-            }
-            is PostIncrDecr -> {
-                when {
-                    stmt.target.identifier != null -> {
-                        val ident = stmt.definingScope().lookup(stmt.target.identifier!!.nameInSource, stmt) as VarDecl
-                        val identScope = ident.definingScope()
-                        var value = runtimeVariables.get(identScope, ident.name)
-                        value = when {
-                            stmt.operator == "++" -> value.add(RuntimeValue(value.type, 1))
-                            stmt.operator == "--" -> value.sub(RuntimeValue(value.type, 1))
-                            else -> throw VmExecutionException("strange postincdec operator $stmt")
-                        }
-                        runtimeVariables.set(identScope, ident.name, value)
-                    }
-                    stmt.target.memoryAddress != null -> {
-                        TODO("postincrdecr memory $stmt")
-                    }
-                    stmt.target.arrayindexed != null -> {
-                        TODO("postincrdecr array $stmt")
-                    }
-                }
-            }
-            is Jump -> throw LoopControlJump(stmt.identifier, stmt.address, stmt.generatedLabel)
-            is InlineAssembly -> {
-                if (sub is Subroutine) {
-                    val args = sub.parameters.map { runtimeVariables.get(sub, it.name) }
-                    performSyscall(sub, args)
-                    throw LoopControlReturn(emptyList())
-                }
-                throw VmExecutionException("can't execute inline assembly in $sub")
-            }
-            is AnonymousScope -> executeAnonymousScope(stmt)
-            is IfStatement -> {
-                val condition = evaluate(stmt.condition, evalCtx)
-                if (condition.asBoolean)
-                    executeAnonymousScope(stmt.truepart)
-                else
-                    executeAnonymousScope(stmt.elsepart)
-            }
-            is BranchStatement -> {
-                when(stmt.condition) {
-                    BranchCondition.CS -> if(statusflags.carry) executeAnonymousScope(stmt.truepart) else executeAnonymousScope(stmt.elsepart)
-                    BranchCondition.CC -> if(!statusflags.carry) executeAnonymousScope(stmt.truepart) else executeAnonymousScope(stmt.elsepart)
-                    BranchCondition.EQ, BranchCondition.Z -> if(statusflags.zero) executeAnonymousScope(stmt.truepart) else executeAnonymousScope(stmt.elsepart)
-                    BranchCondition.NE, BranchCondition.NZ -> if(statusflags.zero) executeAnonymousScope(stmt.truepart) else executeAnonymousScope(stmt.elsepart)
-                    BranchCondition.MI, BranchCondition.NEG -> if(statusflags.negative) executeAnonymousScope(stmt.truepart) else executeAnonymousScope(stmt.elsepart)
-                    BranchCondition.PL, BranchCondition.POS -> if(statusflags.negative) executeAnonymousScope(stmt.truepart) else executeAnonymousScope(stmt.elsepart)
-                    BranchCondition.VS, BranchCondition.VC -> TODO("overflow status")
-                }
-            }
-            is ForLoop -> {
-                val iterable = evaluate(stmt.iterable, evalCtx)
-                if (iterable.type !in IterableDatatypes && iterable !is RuntimeValueRange)
-                    throw VmExecutionException("can only iterate over an iterable value:  $stmt")
-                val loopvarDt: DataType
-                val loopvar: IdentifierReference
-                if (stmt.loopRegister != null) {
-                    loopvarDt = DataType.UBYTE
-                    loopvar = IdentifierReference(listOf(stmt.loopRegister.name), stmt.position)
-                } else {
-                    loopvarDt = stmt.loopVar!!.inferType(program)!!
-                    loopvar = stmt.loopVar
-                }
-                val iterator = iterable.iterator()
-                for (loopvalue in iterator) {
-                    try {
-                        oneForCycle(stmt, loopvarDt, loopvalue, loopvar)
-                    } catch (b: LoopControlBreak) {
-                        break
-                    } catch (c: LoopControlContinue) {
-                        continue
-                    }
-                }
-            }
-            is WhileLoop -> {
-                var condition = evaluate(stmt.condition, evalCtx)
-                while (condition.asBoolean) {
-                    try {
-                        executeAnonymousScope(stmt.body)
-                        condition = evaluate(stmt.condition, evalCtx)
-                    } catch (b: LoopControlBreak) {
-                        break
-                    } catch (c: LoopControlContinue) {
-                        continue
-                    }
-                }
-            }
-            is RepeatLoop -> {
-                do {
-                    val condition = evaluate(stmt.untilCondition, evalCtx)
-                    try {
-                        executeAnonymousScope(stmt.body)
-                    } catch (b: LoopControlBreak) {
-                        break
-                    } catch (c: LoopControlContinue) {
-                        continue
-                    }
-                } while (!condition.asBoolean)
-            }
-            else -> {
-                TODO("implement $stmt")
-            }
-        }
-    }
-
-    private fun executeSwap(swap: FunctionCallStatement) {
-        val v1 = swap.arglist[0]
-        val v2 = swap.arglist[1]
-        val value1 = evaluate(v1, evalCtx)
-        val value2 = evaluate(v2, evalCtx)
-        val target1 = AssignTarget.fromExpr(v1)
-        val target2 = AssignTarget.fromExpr(v2)
-        performAssignment(target1, value2, swap, evalCtx)
-        performAssignment(target2, value1, swap, evalCtx)
-    }
-
-    fun performAssignment(target: AssignTarget, value: RuntimeValue, contextStmt: IStatement, evalCtx: EvalContext) {
-        when {
-            target.identifier != null -> {
-                val decl = contextStmt.definingScope().lookup(target.identifier.nameInSource, contextStmt) as? VarDecl
-                        ?: throw VmExecutionException("can't find assignment target ${target.identifier}")
-                if (decl.type == VarDeclType.MEMORY) {
-                    val address = runtimeVariables.getMemoryAddress(decl.definingScope(), decl.name)
-                    when (decl.datatype) {
-                        DataType.UBYTE -> mem.setUByte(address, value.byteval!!)
-                        DataType.BYTE -> mem.setSByte(address, value.byteval!!)
-                        DataType.UWORD -> mem.setUWord(address, value.wordval!!)
-                        DataType.WORD -> mem.setSWord(address, value.wordval!!)
-                        DataType.FLOAT -> mem.setFloat(address, value.floatval!!)
-                        DataType.STR -> mem.setString(address, value.str!!)
-                        DataType.STR_S -> mem.setScreencodeString(address, value.str!!)
-                        else -> TODO("set memvar $decl")
-                    }
-                } else
-                    runtimeVariables.set(decl.definingScope(), decl.name, value)
-            }
-            target.memoryAddress != null -> {
-                val address = evaluate(target.memoryAddress!!.addressExpression, evalCtx).wordval!!
-                evalCtx.mem.setUByte(address, value.byteval!!)
-            }
-            target.arrayindexed != null -> {
-                val array = evaluate(target.arrayindexed.identifier, evalCtx)
-                val index = evaluate(target.arrayindexed.arrayspec.index, evalCtx)
-                when (array.type) {
-                    DataType.ARRAY_UB -> {
-                        if (value.type != DataType.UBYTE)
-                            throw VmExecutionException("new value is of different datatype ${value.type} for $array")
-                    }
-                    DataType.ARRAY_B -> {
-                        if (value.type != DataType.BYTE)
-                            throw VmExecutionException("new value is of different datatype ${value.type} for $array")
-                    }
-                    DataType.ARRAY_UW -> {
-                        if (value.type != DataType.UWORD)
-                            throw VmExecutionException("new value is of different datatype ${value.type} for $array")
-                    }
-                    DataType.ARRAY_W -> {
-                        if (value.type != DataType.WORD)
-                            throw VmExecutionException("new value is of different datatype ${value.type} for $array")
-                    }
-                    DataType.ARRAY_F -> {
-                        if (value.type != DataType.FLOAT)
-                            throw VmExecutionException("new value is of different datatype ${value.type} for $array")
-                    }
-                    DataType.STR, DataType.STR_S -> {
-                        if (value.type !in ByteDatatypes)
-                            throw VmExecutionException("new value is of different datatype ${value.type} for $array")
-                    }
-                    else -> throw VmExecutionException("strange array type ${array.type}")
-                }
-                if (array.type in ArrayDatatypes)
-                    array.array!![index.integerValue()] = value.numericValue()
-                else if (array.type in StringDatatypes) {
-                    val indexInt = index.integerValue()
-                    val newchr = Petscii.decodePetscii(listOf(value.numericValue().toShort()), true)
-                    val newstr = array.str!!.replaceRange(indexInt, indexInt + 1, newchr)
-                    val ident = contextStmt.definingScope().lookup(target.arrayindexed.identifier.nameInSource, contextStmt) as? VarDecl
-                            ?: throw VmExecutionException("can't find assignment target ${target.identifier}")
-                    val identScope = ident.definingScope()
-                    program.heap.update(array.heapId!!, newstr)
-                    runtimeVariables.set(identScope, ident.name, RuntimeValue(array.type, str = newstr, heapId = array.heapId))
-                }
-            }
-            target.register != null -> {
-                runtimeVariables.set(program.namespace, target.register.name, value)
-            }
-            else -> TODO("assign $target")
-        }
-    }
-
-    private fun oneForCycle(stmt: ForLoop, loopvarDt: DataType, loopValue: Number, loopVar: IdentifierReference) {
-        // assign the new loop value to the loopvar, and run the code
-        performAssignment(AssignTarget(null, loopVar, null, null, loopVar.position),
-                RuntimeValue(loopvarDt, loopValue), stmt.body.statements.first(), evalCtx)
-        executeAnonymousScope(stmt.body)
-    }
-
-    private fun evaluate(args: List<IExpression>) = args.map { evaluate(it, evalCtx) }
-
-    private fun performSyscall(sub: Subroutine, args: List<RuntimeValue>) {
-        assert(sub.isAsmSubroutine)
-        when (sub.scopedname) {
-            "c64scr.print" -> {
-                // if the argument is an UWORD, consider it to be the "address" of the string (=heapId)
-                if (args[0].wordval != null) {
-                    val str = program.heap.get(args[0].wordval!!).str!!
-                    dialog.canvas.printText(str, 1, true)
-                } else
-                    dialog.canvas.printText(args[0].str!!, 1, true)
-            }
-            "c64scr.print_ub" -> {
-                dialog.canvas.printText(args[0].byteval!!.toString(), 1, true)
-            }
-            "c64scr.print_b" -> {
-                dialog.canvas.printText(args[0].byteval!!.toString(), 1, true)
-            }
-            "c64scr.print_uw" -> {
-                dialog.canvas.printText(args[0].wordval!!.toString(), 1, true)
-            }
-            "c64scr.print_w" -> {
-                dialog.canvas.printText(args[0].wordval!!.toString(), 1, true)
-            }
-            "c64scr.print_ubhex" -> {
-                val prefix = if (args[0].asBoolean) "$" else ""
-                val number = args[1].byteval!!
-                dialog.canvas.printText("$prefix${number.toString(16).padStart(2, '0')}", 1, true)
-            }
-            "c64scr.print_uwhex" -> {
-                val prefix = if (args[0].asBoolean) "$" else ""
-                val number = args[1].wordval!!
-                dialog.canvas.printText("$prefix${number.toString(16).padStart(4, '0')}", 1, true)
-            }
-            "c64scr.print_uwbin" -> {
-                val prefix = if (args[0].asBoolean) "%" else ""
-                val number = args[1].wordval!!
-                dialog.canvas.printText("$prefix${number.toString(2).padStart(16, '0')}", 1, true)
-            }
-            "c64scr.print_ubbin" -> {
-                val prefix = if (args[0].asBoolean) "%" else ""
-                val number = args[1].byteval!!
-                dialog.canvas.printText("$prefix${number.toString(2).padStart(8, '0')}", 1, true)
-            }
-            "c64scr.clear_screenchars" -> {
-                dialog.canvas.clearScreen(6)
-            }
-            "c64scr.clear_screen" -> {
-                dialog.canvas.clearScreen(args[0].integerValue().toShort())
-            }
-            "c64scr.setcc" -> {
-                dialog.canvas.setChar(args[0].integerValue(), args[1].integerValue(), args[2].integerValue().toShort(), args[3].integerValue().toShort())
-            }
-            "c64scr.plot" -> {
-                dialog.canvas.setCursorPos(args[0].integerValue(), args[1].integerValue())
-            }
-            "c64.CHROUT" -> {
-                dialog.canvas.printChar(args[0].byteval!!)
-            }
-            "c64flt.print_f" -> {
-                dialog.canvas.printText(args[0].floatval.toString(), 1, true)
-            }
-            else -> TODO("syscall  ${sub.scopedname} $sub")
-        }
-    }
-}
-

compiler/src/prog8/astvm/BuiltinFunctions.kt

@@ -1,204 +0,0 @@
-package prog8.astvm
-
-import prog8.ast.DataType
-import prog8.compiler.RuntimeValue
-import java.lang.Math.toDegrees
-import java.lang.Math.toRadians
-import java.util.*
-import kotlin.math.*
-import kotlin.random.Random
-
-
-class BuiltinFunctions {
-
-    private val rnd = Random(0)
-    private val statusFlagsSave = Stack<StatusFlags>()
-
-
-    fun performBuiltinFunction(name: String, args: List<RuntimeValue>, statusflags: StatusFlags): RuntimeValue? {
-        return when (name) {
-            "rnd" -> RuntimeValue(DataType.UBYTE, rnd.nextInt() and 255)
-            "rndw" -> RuntimeValue(DataType.UWORD, rnd.nextInt() and 65535)
-            "rndf" -> RuntimeValue(DataType.FLOAT, rnd.nextDouble())
-            "lsb" -> RuntimeValue(DataType.UBYTE, args[0].integerValue() and 255)
-            "msb" -> RuntimeValue(DataType.UBYTE, (args[0].integerValue() ushr 8) and 255)
-            "sin" -> RuntimeValue(DataType.FLOAT, sin(args[0].numericValue().toDouble()))
-            "sin8" -> {
-                val rad = args[0].numericValue().toDouble() / 256.0 * 2.0 * PI
-                RuntimeValue(DataType.BYTE, (127.0 * sin(rad)).toShort())
-            }
-            "sin8u" -> {
-                val rad = args[0].numericValue().toDouble() / 256.0 * 2.0 * PI
-                RuntimeValue(DataType.UBYTE, (128.0 + 127.5 * sin(rad)).toShort())
-            }
-            "sin16" -> {
-                val rad = args[0].numericValue().toDouble() / 256.0 * 2.0 * PI
-                RuntimeValue(DataType.BYTE, (32767.0 * sin(rad)).toShort())
-            }
-            "sin16u" -> {
-                val rad = args[0].numericValue().toDouble() / 256.0 * 2.0 * PI
-                RuntimeValue(DataType.UBYTE, (32768.0 + 32767.5 * sin(rad)).toShort())
-            }
-            "cos" -> RuntimeValue(DataType.FLOAT, cos(args[0].numericValue().toDouble()))
-            "cos8" -> {
-                val rad = args[0].numericValue().toDouble() / 256.0 * 2.0 * PI
-                RuntimeValue(DataType.BYTE, (127.0 * cos(rad)).toShort())
-            }
-            "cos8u" -> {
-                val rad = args[0].numericValue().toDouble() / 256.0 * 2.0 * PI
-                RuntimeValue(DataType.UBYTE, (128.0 + 127.5 * cos(rad)).toShort())
-            }
-            "cos16" -> {
-                val rad = args[0].numericValue().toDouble() / 256.0 * 2.0 * PI
-                RuntimeValue(DataType.BYTE, (32767.0 * cos(rad)).toShort())
-            }
-            "cos16u" -> {
-                val rad = args[0].numericValue().toDouble() / 256.0 * 2.0 * PI
-                RuntimeValue(DataType.UBYTE, (32768.0 + 32767.5 * cos(rad)).toShort())
-            }
-            "tan" -> RuntimeValue(DataType.FLOAT, tan(args[0].numericValue().toDouble()))
-            "atan" -> RuntimeValue(DataType.FLOAT, atan(args[0].numericValue().toDouble()))
-            "ln" -> RuntimeValue(DataType.FLOAT, ln(args[0].numericValue().toDouble()))
-            "log2" -> RuntimeValue(DataType.FLOAT, log2(args[0].numericValue().toDouble()))
-            "sqrt" -> RuntimeValue(DataType.FLOAT, sqrt(args[0].numericValue().toDouble()))
-            "sqrt16" -> RuntimeValue(DataType.UBYTE, sqrt(args[0].wordval!!.toDouble()).toInt())
-            "rad" -> RuntimeValue(DataType.FLOAT, toRadians(args[0].numericValue().toDouble()))
-            "deg" -> RuntimeValue(DataType.FLOAT, toDegrees(args[0].numericValue().toDouble()))
-            "round" -> RuntimeValue(DataType.FLOAT, round(args[0].numericValue().toDouble()))
-            "floor" -> RuntimeValue(DataType.FLOAT, floor(args[0].numericValue().toDouble()))
-            "ceil" -> RuntimeValue(DataType.FLOAT, ceil(args[0].numericValue().toDouble()))
-            "rol" -> {
-                val (result, newCarry) = args[0].rol(statusflags.carry)
-                statusflags.carry = newCarry
-                return result
-            }
-            "rol2" -> args[0].rol2()
-            "ror" -> {
-                val (result, newCarry) = args[0].ror(statusflags.carry)
-                statusflags.carry = newCarry
-                return result
-            }
-            "ror2" -> args[0].ror2()
-            "lsl" -> args[0].shl()
-            "lsr" -> args[0].shr()
-            "abs" -> {
-                when (args[0].type) {
-                    DataType.UBYTE -> args[0]
-                    DataType.BYTE -> RuntimeValue(DataType.UBYTE, abs(args[0].numericValue().toDouble()))
-                    DataType.UWORD -> args[0]
-                    DataType.WORD -> RuntimeValue(DataType.UWORD, abs(args[0].numericValue().toDouble()))
-                    DataType.FLOAT -> RuntimeValue(DataType.FLOAT, abs(args[0].numericValue().toDouble()))
-                    else -> TODO("strange abs type")
-                }
-            }
-            "max" -> {
-                val numbers = args.map { it.numericValue().toDouble() }
-                RuntimeValue(args[0].type, numbers.max())
-            }
-            "min" -> {
-                val numbers = args.map { it.numericValue().toDouble() }
-                RuntimeValue(args[0].type, numbers.min())
-            }
-            "avg" -> {
-                val numbers = args.map { it.numericValue().toDouble() }
-                RuntimeValue(DataType.FLOAT, numbers.average())
-            }
-            "sum" -> {
-                val sum = args.map { it.numericValue().toDouble() }.sum()
-                when (args[0].type) {
-                    DataType.UBYTE -> RuntimeValue(DataType.UWORD, sum)
-                    DataType.BYTE -> RuntimeValue(DataType.WORD, sum)
-                    DataType.UWORD -> RuntimeValue(DataType.UWORD, sum)
-                    DataType.WORD -> RuntimeValue(DataType.WORD, sum)
-                    DataType.FLOAT -> RuntimeValue(DataType.FLOAT, sum)
-                    else -> TODO("weird sum type")
-                }
-            }
-            "any" -> {
-                val numbers = args.map { it.numericValue().toDouble() }
-                RuntimeValue(DataType.UBYTE, if (numbers.any { it != 0.0 }) 1 else 0)
-            }
-            "all" -> {
-                val numbers = args.map { it.numericValue().toDouble() }
-                RuntimeValue(DataType.UBYTE, if (numbers.all { it != 0.0 }) 1 else 0)
-            }
-            "swap" ->
-                throw VmExecutionException("swap() cannot be implemented as a function")
-            "strlen" -> {
-                val zeroIndex = args[0].str!!.indexOf(0.toChar())
-                if (zeroIndex >= 0)
-                    RuntimeValue(DataType.UBYTE, zeroIndex)
-                else
-                    RuntimeValue(DataType.UBYTE, args[0].str!!.length)
-            }
-            "memset" -> {
-                val target = args[0].array!!
-                val amount = args[1].integerValue()
-                val value = args[2].integerValue()
-                for (i in 0 until amount) {
-                    target[i] = value
-                }
-                null
-            }
-            "memsetw" -> {
-                val target = args[0].array!!
-                val amount = args[1].integerValue()
-                val value = args[2].integerValue()
-                for (i in 0 until amount step 2) {
-                    target[i * 2] = value and 255
-                    target[i * 2 + 1] = value ushr 8
-                }
-                null
-            }
-            "memcopy" -> {
-                val source = args[0].array!!
-                val dest = args[1].array!!
-                val amount = args[2].integerValue()
-                for(i in 0 until amount) {
-                    dest[i] = source[i]
-                }
-                null
-            }
-            "mkword" -> {
-                val result = (args[0].integerValue() shl 8) or args[1].integerValue()
-                RuntimeValue(DataType.UWORD, result)
-            }
-            "set_carry" -> {
-                statusflags.carry=true
-                null
-            }
-            "clear_carry" -> {
-                statusflags.carry=false
-                null
-            }
-            "set_irqd" -> {
-                statusflags.irqd=true
-                null
-            }
-            "clear_irqd" -> {
-                statusflags.irqd=false
-                null
-            }
-            "read_flags" -> {
-                val carry = if(statusflags.carry) 1 else 0
-                val zero = if(statusflags.zero) 2 else 0
-                val irqd = if(statusflags.irqd) 4 else 0
-                val negative = if(statusflags.negative) 128 else 0
-                RuntimeValue(DataType.UBYTE, carry or zero or irqd or negative)
-            }
-            "rsave" -> {
-                statusFlagsSave.push(statusflags)
-                null
-            }
-            "rrestore" -> {
-                val flags = statusFlagsSave.pop()
-                statusflags.carry = flags.carry
-                statusflags.negative = flags.negative
-                statusflags.zero = flags.zero
-                statusflags.irqd = flags.irqd
-                null
-            }
-            else -> TODO("builtin function $name")
-        }
-    }
-}

compiler/src/prog8/astvm/VariablesCreator.kt

@@ -1,73 +0,0 @@
-package prog8.astvm
-
-import prog8.ast.*
-import prog8.compiler.HeapValues
-import prog8.compiler.RuntimeValue
-
-class VariablesCreator(private val runtimeVariables: RuntimeVariables, private val heap: HeapValues) : IAstProcessor {
-
-    override fun process(program: Program) {
-        // define the three registers as global variables
-        runtimeVariables.define(program.namespace, Register.A.name, RuntimeValue(DataType.UBYTE, 0))
-        runtimeVariables.define(program.namespace, Register.X.name, RuntimeValue(DataType.UBYTE, 255))
-        runtimeVariables.define(program.namespace, Register.Y.name, RuntimeValue(DataType.UBYTE, 0))
-
-        val globalpos = Position("<<global>>", 0, 0, 0)
-        val vdA = VarDecl(VarDeclType.VAR, DataType.UBYTE, false, null, Register.A.name, LiteralValue.optimalInteger(0, globalpos), isArray = false, autoGenerated = true, position = globalpos)
-        val vdX = VarDecl(VarDeclType.VAR, DataType.UBYTE, false, null, Register.X.name, LiteralValue.optimalInteger(255, globalpos), isArray = false, autoGenerated = true, position = globalpos)
-        val vdY = VarDecl(VarDeclType.VAR, DataType.UBYTE, false, null, Register.Y.name, LiteralValue.optimalInteger(0, globalpos), isArray = false, autoGenerated = true, position = globalpos)
-        vdA.linkParents(program.namespace)
-        vdX.linkParents(program.namespace)
-        vdY.linkParents(program.namespace)
-        program.namespace.statements.add(vdA)
-        program.namespace.statements.add(vdX)
-        program.namespace.statements.add(vdY)
-
-        super.process(program)
-    }
-
-    override fun process(decl: VarDecl): IStatement {
-        when(decl.type) {
-            VarDeclType.VAR -> {
-                val value = when (decl.datatype) {
-                    in NumericDatatypes -> {
-                        if(decl.value !is LiteralValue) {
-                            TODO("evaluate vardecl expression $decl")
-                            //RuntimeValue(decl.datatype, num = evaluate(decl.value!!, program, runtimeVariables, executeSubroutine).numericValue())
-                        } else {
-                            RuntimeValue.from(decl.value as LiteralValue, heap)
-                        }
-                    }
-                    in StringDatatypes -> {
-                        RuntimeValue.from(decl.value as LiteralValue, heap)
-                    }
-                    in ArrayDatatypes -> {
-                        RuntimeValue.from(decl.value as LiteralValue, heap)
-                    }
-                    else -> throw VmExecutionException("weird type ${decl.datatype}")
-                }
-                runtimeVariables.define(decl.definingScope(), decl.name, value)
-            }
-            VarDeclType.MEMORY -> {
-                if(decl.value !is LiteralValue) {
-                    TODO("evaluate vardecl expression $decl")
-                    //RuntimeValue(decl.datatype, num = evaluate(decl.value!!, program, runtimeVariables, executeSubroutine).numericValue())
-                } else {
-                    runtimeVariables.defineMemory(decl.definingScope(), decl.name, (decl.value as LiteralValue).asIntegerValue!!)
-                }
-            }
-            VarDeclType.CONST -> {
-                // consts should have been const-folded away
-            }
-        }
-        return super.process(decl)
-    }
-
-//    override fun process(assignment: Assignment): IStatement {
-//        if(assignment is VariableInitializationAssignment) {
-//            println("INIT VAR $assignment")
-//        }
-//        return super.process(assignment)
-//    }
-
-}

compiler/src/prog8/compiler/AstToSourceCode.kt

@@ -0,0 +1,435 @@
+package prog8.compiler
+
+import prog8.ast.antlr.escape
+import prog8.ast.IFunctionCall
+import prog8.ast.IStatement
+import prog8.ast.Module
+import prog8.ast.Program
+import prog8.ast.base.*
+import prog8.ast.expressions.*
+import prog8.ast.processing.IAstVisitor
+import prog8.ast.statements.*
+
+class AstToSourceCode(val output: (text: String) -> Unit): IAstVisitor {
+    var scopelevel = 0
+
+    fun indent(s: String) = "    ".repeat(scopelevel) + s
+    fun outputln(text: String) = output(text + "\n")
+    fun outputlni(s: Any) = outputln(indent(s.toString()))
+    fun outputi(s: Any) = output(indent(s.toString()))
+
+    override fun visit(program: Program) {
+        outputln("============= PROGRAM ${program.name} (FROM AST) ===============")
+        super.visit(program)
+        outputln("============= END PROGRAM ${program.name} (FROM AST) ===========")
+    }
+
+    override fun visit(module: Module) {
+        if(!module.isLibraryModule) {
+            outputln("; ----------- module: ${module.name} -----------")
+            super.visit(module)
+        }
+        else outputln("; library module skipped: ${module.name}")
+    }
+
+    override fun visit(block: Block) {
+        val addr = if(block.address!=null) block.address.toHex() else ""
+        outputln("~ ${block.name} $addr {")
+        scopelevel++
+        for(stmt in block.statements) {
+            outputi("")
+            stmt.accept(this)
+            output("\n")
+        }
+        scopelevel--
+        outputln("}\n")
+    }
+
+    override fun visit(expr: PrefixExpression) {
+        if(expr.operator.any { it.isLetter() })
+            output(" ${expr.operator} ")
+        else
+            output(expr.operator)
+        expr.expression.accept(this)
+    }
+
+    override fun visit(expr: BinaryExpression) {
+        expr.left.accept(this)
+        if(expr.operator.any { it.isLetter() })
+            output(" ${expr.operator} ")
+        else
+            output(expr.operator)
+        expr.right.accept(this)
+    }
+
+    override fun visit(directive: Directive) {
+        output("${directive.directive} ")
+        for(arg in directive.args) {
+            when {
+                arg.int!=null -> output(arg.int.toString())
+                arg.name!=null -> output(arg.name)
+                arg.str!=null -> output("\"${arg.str}\"")
+            }
+            if(arg!==directive.args.last())
+                output(",")
+        }
+        output("\n")
+    }
+
+    fun datatypeString(dt: DataType): String {
+        return when(dt) {
+            in NumericDatatypes -> dt.toString().toLowerCase()
+            in StringDatatypes -> dt.toString().toLowerCase()
+            DataType.ARRAY_UB -> "ubyte["
+            DataType.ARRAY_B -> "byte["
+            DataType.ARRAY_UW -> "uword["
+            DataType.ARRAY_W -> "word["
+            DataType.ARRAY_F -> "float["
+            DataType.STRUCT -> ""       // the name of the struct is enough
+            else -> "?????2"
+        }
+    }
+
+    override fun visit(structDecl: StructDecl) {
+        outputln("struct ${structDecl.name} {")
+        scopelevel++
+        for(decl in structDecl.statements) {
+            outputi("")
+            decl.accept(this)
+            output("\n")
+        }
+        scopelevel--
+        outputlni("}")
+    }
+
+    override fun visit(decl: VarDecl) {
+        when(decl.type) {
+            VarDeclType.VAR -> {}
+            VarDeclType.CONST -> output("const ")
+            VarDeclType.MEMORY -> output("&")
+        }
+        output(decl.struct?.name ?: "")
+        output(datatypeString(decl.datatype))
+        if(decl.arraysize!=null) {
+            decl.arraysize!!.index.accept(this)
+        }
+        if(decl.isArray)
+            output("]")
+
+        if(decl.zeropage == ZeropageWish.REQUIRE_ZEROPAGE || decl.zeropage==ZeropageWish.PREFER_ZEROPAGE)
+            output(" @zp")
+        output(" ${decl.name} ")
+        if(decl.value!=null) {
+            output("= ")
+            decl.value?.accept(this)
+        }
+    }
+
+    override fun visit(subroutine: Subroutine) {
+        output("\n")
+        if(subroutine.isAsmSubroutine) {
+            outputi("asmsub ${subroutine.name} (")
+            for(param in subroutine.parameters.zip(subroutine.asmParameterRegisters)) {
+                val reg =
+                        when {
+                            true==param.second.stack -> "stack"
+                            param.second.registerOrPair!=null -> param.second.registerOrPair.toString()
+                            param.second.statusflag!=null -> param.second.statusflag.toString()
+                            else -> "?????1"
+                        }
+                output("${datatypeString(param.first.type)} ${param.first.name} @$reg")
+                if(param.first!==subroutine.parameters.last())
+                    output(", ")
+            }
+        }
+        else {
+            outputi("sub ${subroutine.name} (")
+            for(param in subroutine.parameters) {
+                output("${datatypeString(param.type)} ${param.name}")
+                if(param!==subroutine.parameters.last())
+                    output(", ")
+            }
+        }
+        output(") ")
+        if(subroutine.asmClobbers.isNotEmpty()) {
+            output("-> clobbers (")
+            val regs = subroutine.asmClobbers.toList().sorted()
+            for(r in regs) {
+                output(r.toString())
+                if(r!==regs.last())
+                    output(",")
+            }
+            output(") ")
+        }
+        if(subroutine.returntypes.any()) {
+            val rt = subroutine.returntypes.single()
+            output("-> ${datatypeString(rt)} ")
+        }
+        if(subroutine.asmAddress!=null)
+            outputln("= ${subroutine.asmAddress.toHex()}")
+        else {
+            outputln("{ ")
+            scopelevel++
+            outputStatements(subroutine.statements)
+            scopelevel--
+            outputi("}")
+        }
+    }
+
+    private fun outputStatements(statements: List<IStatement>) {
+        for(stmt in statements) {
+            if(stmt is VarDecl && stmt.hiddenButDoNotRemove)
+                continue    // skip autogenerated decls (to avoid generating a newline)
+            outputi("")
+            stmt.accept(this)
+            output("\n")
+        }
+    }
+
+    override fun visit(functionCall: FunctionCall) {
+        printout(functionCall as IFunctionCall)
+    }
+
+    override fun visit(functionCallStatement: FunctionCallStatement) {
+        printout(functionCallStatement as IFunctionCall)
+    }
+
+    private fun printout(call: IFunctionCall) {
+        call.target.accept(this)
+        output("(")
+        for(arg in call.arglist) {
+            arg.accept(this)
+            if(arg!==call.arglist.last())
+                output(", ")
+        }
+        output(")")
+    }
+
+    override fun visit(identifier: IdentifierReference) {
+        output(identifier.nameInSource.joinToString("."))
+    }
+
+    override fun visit(jump: Jump) {
+        output("goto ")
+        when {
+            jump.address!=null -> output(jump.address.toHex())
+            jump.generatedLabel!=null -> output(jump.generatedLabel)
+            jump.identifier!=null -> jump.identifier.accept(this)
+        }
+    }
+
+    override fun visit(ifStatement: IfStatement) {
+        output("if ")
+        ifStatement.condition.accept(this)
+        output(" ")
+        ifStatement.truepart.accept(this)
+        if(ifStatement.elsepart.statements.isNotEmpty()) {
+            output(" else ")
+            ifStatement.elsepart.accept(this)
+        }
+    }
+
+    override fun visit(branchStatement: BranchStatement) {
+        output("if_${branchStatement.condition.toString().toLowerCase()} ")
+        branchStatement.truepart.accept(this)
+        if(branchStatement.elsepart.statements.isNotEmpty()) {
+            output(" else ")
+            branchStatement.elsepart.accept(this)
+        }
+    }
+
+    override fun visit(range: RangeExpr) {
+        range.from.accept(this)
+        output(" to ")
+        range.to.accept(this)
+        output(" step ")
+        range.step.accept(this)
+        output(" ")
+    }
+
+    override fun visit(label: Label) {
+        output("\n")
+        output("${label.name}:")
+    }
+
+    override fun visit(literalValue: LiteralValue) {
+        when {
+            literalValue.isNumeric -> output(literalValue.asNumericValue.toString())
+            literalValue.isString -> output("\"${escape(literalValue.strvalue!!)}\"")
+            literalValue.isArray -> {
+                if(literalValue.arrayvalue!=null) {
+                    var counter = 0
+                    output("[")
+                    scopelevel++
+                    for (v in literalValue.arrayvalue) {
+                        v.accept(this)
+                        if (v !== literalValue.arrayvalue.last())
+                            output(", ")
+                        counter++
+                        if(counter > 16) {
+                            outputln("")
+                            outputi("")
+                            counter=0
+                        }
+                    }
+                    scopelevel--
+                    output("]")
+                }
+            }
+        }
+    }
+
+    override fun visit(assignment: Assignment) {
+        assignment.target.accept(this)
+        if(assignment.aug_op!=null)
+            output(" ${assignment.aug_op} ")
+        else
+            output(" = ")
+        assignment.value.accept(this)
+    }
+
+    override fun visit(postIncrDecr: PostIncrDecr) {
+        postIncrDecr.target.accept(this)
+        output(postIncrDecr.operator)
+    }
+
+    override fun visit(contStmt: Continue) {
+        output("continue")
+    }
+
+    override fun visit(breakStmt: Break) {
+        output("break")
+    }
+
+    override fun visit(forLoop: ForLoop) {
+        output("for ")
+        if(forLoop.decltype!=null) {
+            output(datatypeString(forLoop.decltype))
+            if (forLoop.zeropage==ZeropageWish.REQUIRE_ZEROPAGE || forLoop.zeropage==ZeropageWish.PREFER_ZEROPAGE)
+                output(" @zp ")
+            else
+                output(" ")
+        }
+        if(forLoop.loopRegister!=null)
+            output(forLoop.loopRegister.toString())
+        else
+            forLoop.loopVar!!.accept(this)
+        output(" in ")
+        forLoop.iterable.accept(this)
+        output(" ")
+        forLoop.body.accept(this)
+    }
+
+    override fun visit(whileLoop: WhileLoop) {
+        output("while ")
+        whileLoop.condition.accept(this)
+        output(" ")
+        whileLoop.body.accept(this)
+    }
+
+    override fun visit(repeatLoop: RepeatLoop) {
+        outputln("repeat ")
+        repeatLoop.body.accept(this)
+        output(" until ")
+        repeatLoop.untilCondition.accept(this)
+    }
+
+    override fun visit(returnStmt: Return) {
+        output("return ")
+        returnStmt.value?.accept(this)
+    }
+
+    override fun visit(arrayIndexedExpression: ArrayIndexedExpression) {
+        arrayIndexedExpression.identifier.accept(this)
+        output("[")
+        arrayIndexedExpression.arrayspec.index.accept(this)
+        output("]")
+    }
+
+    override fun visit(assignTarget: AssignTarget) {
+        if(assignTarget.register!=null)
+            output(assignTarget.register.toString())
+        else {
+            assignTarget.memoryAddress?.accept(this)
+            assignTarget.identifier?.accept(this)
+        }
+        assignTarget.arrayindexed?.accept(this)
+    }
+
+    override fun visit(scope: AnonymousScope) {
+        outputln("{")
+        scopelevel++
+        outputStatements(scope.statements)
+        scopelevel--
+        outputi("}")
+    }
+
+    override fun visit(typecast: TypecastExpression) {
+        output("(")
+        typecast.expression.accept(this)
+        output(" as ${datatypeString(typecast.type)}) ")
+    }
+
+    override fun visit(memread: DirectMemoryRead) {
+        output("@(")
+        memread.addressExpression.accept(this)
+        output(")")
+    }
+
+    override fun visit(memwrite: DirectMemoryWrite) {
+        output("@(")
+        memwrite.addressExpression.accept(this)
+        output(")")
+    }
+
+    override fun visit(addressOf: AddressOf) {
+        output("&")
+        addressOf.identifier.accept(this)
+    }
+
+    override fun visit(inlineAssembly: InlineAssembly) {
+        outputlni("%asm {{")
+        outputln(inlineAssembly.assembly)
+        outputlni("}}")
+    }
+
+    override fun visit(registerExpr: RegisterExpr) {
+        output(registerExpr.register.toString())
+    }
+
+    override fun visit(builtinFunctionStatementPlaceholder: BuiltinFunctionStatementPlaceholder) {
+        output(builtinFunctionStatementPlaceholder.name)
+    }
+
+    override fun visit(whenStatement: WhenStatement) {
+        output("when ")
+        whenStatement.condition.accept(this)
+        outputln(" {")
+        scopelevel++
+        whenStatement.choices.forEach { it.accept(this) }
+        scopelevel--
+        outputlni("}")
+    }
+
+    override fun visit(whenChoice: WhenChoice) {
+        if(whenChoice.values==null)
+            outputi("else -> ")
+        else {
+            outputi("")
+            for(value in whenChoice.values) {
+                value.accept(this)
+                if(value !== whenChoice.values.last())
+                    output(",")
+            }
+            output(" -> ")
+        }
+        if(whenChoice.statements.statements.size==1)
+            whenChoice.statements.statements.single().accept(this)
+        else
+            whenChoice.statements.accept(this)
+        outputln("")
+    }
+    override fun visit(nopStatement: NopStatement) {
+        output("; NOP @ ${nopStatement.position}  $nopStatement")
+    }
+}

compiler/src/prog8/compiler/Compiler.kt

@@ -1,13 +1,18 @@
 package prog8.compiler
 
 import prog8.ast.*
-import prog8.ast.RegisterOrPair.*
+import prog8.ast.base.*
+import prog8.ast.base.RegisterOrPair.*
+import prog8.ast.expressions.*
+import prog8.ast.processing.flattenStructAssignment
+import prog8.ast.statements.*
 import prog8.compiler.intermediate.IntermediateProgram
 import prog8.compiler.intermediate.Opcode
 import prog8.compiler.intermediate.branchOpcodes
 import prog8.functions.BuiltinFunctions
 import prog8.parser.tryGetEmbeddedResource
-import prog8.stackvm.Syscall
+import prog8.vm.RuntimeValue
+import prog8.vm.stackvm.Syscall
 import java.io.File
 import java.nio.file.Path
 import java.util.*
@@ -143,7 +148,7 @@ data class CompilationOptions(val output: OutputType,
                               val floats: Boolean)
 
 
-internal class Compiler(private val program: Program): IAstProcessor {
+internal class Compiler(private val program: Program) {
 
     private val prog: IntermediateProgram = IntermediateProgram(program.name, program.loadAddress, program.heap, program.modules.first().source)
     private var generatedLabelSequenceNumber = 0
@@ -153,17 +158,19 @@ internal class Compiler(private val program: Program): IAstProcessor {
     fun compile(options: CompilationOptions) : IntermediateProgram {
         println("Creating stackVM code...")
         program.modules.forEach {
-            process(it)
+            it.statements.forEach { stmt->
+                if(stmt is Block)
+                    processBlock(stmt)
+            }
         }
         return prog
     }
 
-    override fun process(block: Block): IStatement {
+    private fun processBlock(block: Block) {
         prog.newBlock(block.name, block.address, block.options())
         processVariables(block)
         prog.line(block.position)
         translate(block.statements)
-        return super.process(block)
     }
 
     private fun processVariables(scope: INameScope) {
@@ -173,27 +180,6 @@ internal class Compiler(private val program: Program): IAstProcessor {
             processVariables(subscope.value)
     }
 
-    override fun process(subroutine: Subroutine): IStatement {
-        if(subroutine.asmAddress==null) {
-            prog.label(subroutine.scopedname, true)
-            prog.instr(Opcode.START_PROCDEF)
-            prog.line(subroutine.position)
-            // note: the caller has already written the arguments into the subroutine's parameter variables.
-            // note2: don't separate normal and VariableInitializationAssignment here, because the order strictly matters
-            translate(subroutine.statements)
-            val r= super.process(subroutine)
-            prog.instr(Opcode.END_PROCDEF)
-            return r
-        } else {
-            // asmsub
-            if(subroutine.containsCodeOrVars())
-                throw CompilerException("kernel subroutines (with memory address) can't have a body: $subroutine")
-
-            prog.memoryPointer(subroutine.scopedname, subroutine.asmAddress, DataType.UBYTE)        // the datatype is a bit of a dummy in this case
-            return super.process(subroutine)
-        }
-    }
-
     private fun translate(statements: List<IStatement>) {
         for (stmt: IStatement in statements) {
             generatedLabelSequenceNumber++
@@ -223,14 +209,34 @@ internal class Compiler(private val program: Program): IAstProcessor {
                         }
                     }
                 }
-                is VarDecl, is Subroutine -> {}   // skip this, already processed these.
+                is VarDecl -> {}   // skip this, already processed these.
+                is Subroutine -> translate(stmt)
                 is NopStatement -> {}
                 is InlineAssembly -> translate(stmt)
+                is WhenStatement -> translate(stmt)
+                is StructDecl -> {}
                 else -> TODO("translate statement $stmt to stackvm")
             }
         }
     }
 
+    private fun translate(subroutine: Subroutine) {
+        if(subroutine.asmAddress==null) {
+            prog.label(subroutine.scopedname, true)
+            prog.instr(Opcode.START_PROCDEF)
+            prog.line(subroutine.position)
+            // note: the caller has already written the arguments into the subroutine's parameter variables.
+            // note2: don't separate normal and VariableInitializationAssignment here, because the order strictly matters
+            translate(subroutine.statements)
+            prog.instr(Opcode.END_PROCDEF)
+        } else {
+            // asmsub
+            if(subroutine.containsCodeOrVars())
+                throw CompilerException("kernel subroutines (with memory address) can't have a body: $subroutine")
+
+            prog.memoryPointer(subroutine.scopedname, subroutine.asmAddress, DataType.UBYTE)        // the datatype is a bit of a dummy in this case
+        }
+    }
     private fun opcodePush(dt: DataType): Opcode {
         return when (dt) {
             in ByteDatatypes -> Opcode.PUSH_BYTE
@@ -383,7 +389,7 @@ internal class Compiler(private val program: Program): IAstProcessor {
         // The compiler could then convert it to a special system call
         val sub = stmt.parent as? Subroutine
         val scopename =
-                if(sub!=null && sub.statements.filter{it !is VarDecl}.size==1)
+                if(sub!=null && sub.statements.filter{it !is VarDecl }.size==1)
                     sub.scopedname
                 else
                     null
@@ -586,7 +592,6 @@ internal class Compiler(private val program: Program): IAstProcessor {
             is RangeExpr -> throw CompilerException("it's not possible to just have a range expression that has to be translated")
             is TypecastExpression -> translate(expr)
             is DirectMemoryRead -> translate(expr)
-            is DirectMemoryWrite -> translate(expr)
             is AddressOf -> translate(expr)
             else -> {
                 val lv = expr.constValue(program) ?: throw CompilerException("constant expression required, not $expr")
@@ -979,7 +984,7 @@ internal class Compiler(private val program: Program): IAstProcessor {
             } else {
                 when (arg.second.registerOrPair!!) {
                     A -> {
-                        val assign = Assignment(listOf(AssignTarget(Register.A, null, null, null, callPosition)), null, arg.first, callPosition)
+                        val assign = Assignment(AssignTarget(Register.A, null, null, null, callPosition), null, arg.first, callPosition)
                         assign.linkParents(arguments[0].parent)
                         translate(assign)
                     }
@@ -988,12 +993,12 @@ internal class Compiler(private val program: Program): IAstProcessor {
                             prog.instr(Opcode.RSAVEX)
                             restoreX = true
                         }
-                        val assign = Assignment(listOf(AssignTarget(Register.X, null, null, null, callPosition)), null, arg.first, callPosition)
+                        val assign = Assignment(AssignTarget(Register.X, null, null, null, callPosition), null, arg.first, callPosition)
                         assign.linkParents(arguments[0].parent)
                         translate(assign)
                     }
                     Y -> {
-                        val assign = Assignment(listOf(AssignTarget(Register.Y, null, null, null, callPosition)), null, arg.first, callPosition)
+                        val assign = Assignment(AssignTarget(Register.Y, null, null, null, callPosition), null, arg.first, callPosition)
                         assign.linkParents(arguments[0].parent)
                         translate(assign)
                     }
@@ -1009,8 +1014,8 @@ internal class Compiler(private val program: Program): IAstProcessor {
                             DataType.UBYTE -> {
                                 valueA = arg.first
                                 valueX = LiteralValue.optimalInteger(0, callPosition)
-                                val assignA = Assignment(listOf(AssignTarget(Register.A, null, null, null, callPosition)), null, valueA, callPosition)
-                                val assignX = Assignment(listOf(AssignTarget(Register.X, null, null, null, callPosition)), null, valueX, callPosition)
+                                val assignA = Assignment(AssignTarget(Register.A, null, null, null, callPosition), null, valueA, callPosition)
+                                val assignX = Assignment(AssignTarget(Register.X, null, null, null, callPosition), null, valueX, callPosition)
                                 assignA.linkParents(arguments[0].parent)
                                 assignX.linkParents(arguments[0].parent)
                                 translate(assignA)
@@ -1032,8 +1037,8 @@ internal class Compiler(private val program: Program): IAstProcessor {
                             DataType.UBYTE -> {
                                 valueA = arg.first
                                 valueY = LiteralValue.optimalInteger(0, callPosition)
-                                val assignA = Assignment(listOf(AssignTarget(Register.A, null, null, null, callPosition)), null, valueA, callPosition)
-                                val assignY = Assignment(listOf(AssignTarget(Register.Y, null, null, null, callPosition)), null, valueY, callPosition)
+                                val assignA = Assignment(AssignTarget(Register.A, null, null, null, callPosition), null, valueA, callPosition)
+                                val assignY = Assignment(AssignTarget(Register.Y, null, null, null, callPosition), null, valueY, callPosition)
                                 assignA.linkParents(arguments[0].parent)
                                 assignY.linkParents(arguments[0].parent)
                                 translate(assignA)
@@ -1059,8 +1064,8 @@ internal class Compiler(private val program: Program): IAstProcessor {
                             DataType.UBYTE -> {
                                 valueX = arg.first
                                 valueY = LiteralValue.optimalInteger(0, callPosition)
-                                val assignX = Assignment(listOf(AssignTarget(Register.X, null, null, null, callPosition)), null, valueX, callPosition)
-                                val assignY = Assignment(listOf(AssignTarget(Register.Y, null, null, null, callPosition)), null, valueY, callPosition)
+                                val assignX = Assignment(AssignTarget(Register.X, null, null, null, callPosition), null, valueX, callPosition)
+                                val assignY = Assignment(AssignTarget(Register.Y, null, null, null, callPosition), null, valueY, callPosition)
                                 assignX.linkParents(arguments[0].parent)
                                 assignY.linkParents(arguments[0].parent)
                                 translate(assignX)
@@ -1399,21 +1404,14 @@ internal class Compiler(private val program: Program): IAstProcessor {
         prog.line(stmt.position)
         translate(stmt.value)
 
-        val assignTarget= stmt.singleTarget
-        if(assignTarget==null) {
-            // we're dealing with multiple return values
-            translateMultiReturnAssignment(stmt)
-            return
-        }
-
         val valueDt = stmt.value.inferType(program)
-        val targetDt = assignTarget.inferType(program, stmt)
+        val targetDt = stmt.target.inferType(program, stmt)
         if(valueDt!=targetDt) {
             // convert value to target datatype if possible
             // @todo use convertType()????
             when(targetDt) {
                 in ByteDatatypes ->
-                    if(valueDt!=DataType.BYTE && valueDt!=DataType.UBYTE)
+                    if(valueDt!= DataType.BYTE && valueDt!= DataType.UBYTE)
                         throw CompilerException("incompatible data types valueDt=$valueDt  targetDt=$targetDt  at $stmt")
                 DataType.WORD -> {
                     when (valueDt) {
@@ -1448,6 +1446,11 @@ internal class Compiler(private val program: Program): IAstProcessor {
                         else -> throw CompilerException("incompatible data types valueDt=$valueDt  targetDt=$targetDt  at $stmt")
                     }
                 }
+                DataType.STRUCT -> {
+                    // Assume the value is an array. Flatten the struct assignment into memberwise assignments.
+                    flattenStructAssignment(stmt, program).forEach { translate(it) }
+                    return
+                }
                 in StringDatatypes -> throw CompilerException("incompatible data types valueDt=$valueDt  targetDt=$targetDt  at $stmt")
                 in ArrayDatatypes -> throw CompilerException("incompatible data types valueDt=$valueDt  targetDt=$targetDt  at $stmt")
                 else -> throw CompilerException("weird/unknown targetdt")
@@ -1458,8 +1461,8 @@ internal class Compiler(private val program: Program): IAstProcessor {
             throw CompilerException("augmented assignment should have been converted to regular assignment already")
 
         // pop the result value back into the assignment target
-        val datatype = assignTarget.inferType(program, stmt)!!
-        popValueIntoTarget(assignTarget, datatype)
+        val datatype = stmt.target.inferType(program, stmt)!!
+        popValueIntoTarget(stmt.target, datatype)
     }
 
     private fun pushHeapVarAddress(value: IExpression, removeLastOpcode: Boolean) {
@@ -1485,18 +1488,20 @@ internal class Compiler(private val program: Program): IAstProcessor {
         }
     }
 
-    private fun translateMultiReturnAssignment(stmt: Assignment) {
-        val targetStmt = (stmt.value as? FunctionCall)?.target?.targetStatement(program.namespace)
-        if(targetStmt is Subroutine && targetStmt.isAsmSubroutine) {
-            // this is the only case where multiple assignment targets are allowed: a call to an asmsub with multiple return values
-            // the return values are already on the stack (the subroutine call puts them there)
-            if(stmt.targets.size!=targetStmt.asmReturnvaluesRegisters.size)
-                throw CompilerException("asmsub number of return values doesn't match number of assignment targets ${stmt.position}")
-            for(target in stmt.targets) {
-                val dt = target.inferType(program, stmt)
-                popValueIntoTarget(target, dt!!)
+    private fun pushStructAddress(value: IExpression) {
+        when (value) {
+            is LiteralValue -> throw CompilerException("can only push address of struct that is a variable on the heap")
+            is IdentifierReference -> {
+                // notice that the mangled name of the first struct member is the start address of this struct var
+                val vardecl = value.targetVarDecl(program.namespace)!!
+                val firstStructMember = (vardecl.struct!!.statements.first() as VarDecl).name
+                val firstVarName = listOf(vardecl.name, firstStructMember)
+                // find the flattened var that belongs to this first struct member
+                val firstVar = value.definingScope().lookup(firstVarName, value) as VarDecl
+                prog.instr(Opcode.PUSH_ADDR_HEAPVAR, callLabel = firstVar.scopedname)    // TODO
             }
-        } else throw CompilerException("can only use multiple assignment targets on an asmsub call")
+            else -> throw CompilerException("can only take address of a the float as constant literal or variable")
+        }
     }
 
     private fun popValueIntoTarget(assignTarget: AssignTarget, datatype: DataType) {
@@ -1534,10 +1539,9 @@ internal class Compiler(private val program: Program): IAstProcessor {
     }
 
     private fun translate(stmt: Return) {
-        // put the return values on the stack, in reversed order. The caller will process them.
-        for(value in stmt.values.reversed()) {
-            translate(value)
-        }
+        // put the return values on the stack, in reversed order. The caller will accept them.
+        if(stmt.value!=null)
+            translate(stmt.value!!)
         prog.line(stmt.position)
         prog.instr(Opcode.RETURN)
     }
@@ -1549,17 +1553,19 @@ internal class Compiler(private val program: Program): IAstProcessor {
     private fun translate(loop: ForLoop) {
         if(loop.body.containsNoCodeNorVars()) return
         prog.line(loop.position)
-        val loopVarName: String
-        val loopVarDt: DataType
+        val loopVarName: String?
+        val loopRegister: Register?
+        val loopvalueDt: DataType
 
         if(loop.loopRegister!=null) {
-            val reg = loop.loopRegister
-            loopVarName = reg.name
-            loopVarDt = DataType.UBYTE
+            loopVarName = null
+            loopRegister = loop.loopRegister
+            loopvalueDt = DataType.UBYTE
         } else {
             val loopvar = loop.loopVar!!.targetVarDecl(program.namespace)!!
             loopVarName = loopvar.scopedname
-            loopVarDt = loopvar.datatype
+            loopvalueDt = loopvar.datatype
+            loopRegister = null
         }
 
         if(loop.iterable is RangeExpr) {
@@ -1572,7 +1578,7 @@ internal class Compiler(private val program: Program): IAstProcessor {
                     throw CompilerException("loop over just 1 value should have been optimized away")
                 if((range.last-range.first) % range.step != 0)
                     throw CompilerException("range first and last must be exactly inclusive")
-                when (loopVarDt) {
+                when (loopvalueDt) {
                     DataType.UBYTE -> {
                         if (range.first < 0 || range.first > 255 || range.last < 0 || range.last > 255)
                             throw CompilerException("range out of bounds for ubyte")
@@ -1591,7 +1597,7 @@ internal class Compiler(private val program: Program): IAstProcessor {
                     }
                     else -> throw CompilerException("range must be byte or word")
                 }
-                translateForOverConstantRange(loopVarName, loopVarDt, range, loop.body)
+                translateForOverConstantRange(loopVarName, loopRegister, loopvalueDt, range, loop.body)
             } else {
                 // loop over a range where one or more of the start, last or step values is not a constant
                 if(loop.loopRegister!=null) {
@@ -1610,7 +1616,7 @@ internal class Compiler(private val program: Program): IAstProcessor {
                     val iterableValue = vardecl.value as LiteralValue
                     if(iterableValue.type !in IterableDatatypes)
                         throw CompilerException("loop over something that isn't iterable ${loop.iterable}")
-                    translateForOverIterableVar(loop, loopVarDt, iterableValue)
+                    translateForOverIterableVar(loop, loopvalueDt, iterableValue)
                 }
                 loop.iterable is LiteralValue -> throw CompilerException("literal value in loop must have been moved to heap already $loop")
                 else -> throw CompilerException("loopvar is something strange ${loop.iterable}")
@@ -1619,11 +1625,11 @@ internal class Compiler(private val program: Program): IAstProcessor {
     }
 
     private fun translateForOverIterableVar(loop: ForLoop, loopvarDt: DataType, iterableValue: LiteralValue) {
-        if(loopvarDt==DataType.UBYTE && iterableValue.type !in setOf(DataType.STR, DataType.STR_S, DataType.ARRAY_UB))
+        if(loopvarDt== DataType.UBYTE && iterableValue.type !in setOf(DataType.STR, DataType.STR_S, DataType.ARRAY_UB))
             throw CompilerException("loop variable type doesn't match iterableValue type")
-        else if(loopvarDt==DataType.UWORD && iterableValue.type != DataType.ARRAY_UW)
+        else if(loopvarDt== DataType.UWORD && iterableValue.type != DataType.ARRAY_UW)
             throw CompilerException("loop variable type doesn't match iterableValue type")
-        else if(loopvarDt==DataType.FLOAT && iterableValue.type != DataType.ARRAY_F)
+        else if(loopvarDt== DataType.FLOAT && iterableValue.type != DataType.ARRAY_F)
             throw CompilerException("loop variable type doesn't match iterableValue type")
 
         val numElements: Int
@@ -1645,7 +1651,7 @@ internal class Compiler(private val program: Program): IAstProcessor {
             else -> throw CompilerException("weird datatype")
         }
 
-        if(loop.loopRegister!=null && loop.loopRegister==Register.X)
+        if(loop.loopRegister!=null && loop.loopRegister== Register.X)
             throw CompilerException("loopVar cannot use X register because that is used as internal stack pointer")
 
         /**
@@ -1683,7 +1689,7 @@ internal class Compiler(private val program: Program): IAstProcessor {
             AssignTarget(null, loop.loopVar!!.copy(), null, null, loop.position)
         val arrayspec = ArrayIndex(IdentifierReference(listOf(ForLoop.iteratorLoopcounterVarname), loop.position), loop.position)
         val assignLv = Assignment(
-                listOf(assignTarget), null,
+                assignTarget, null,
                 ArrayIndexedExpression((loop.iterable as IdentifierReference).copy(), arrayspec, loop.position),
                 loop.position)
         assignLv.linkParents(loop.body)
@@ -1703,7 +1709,7 @@ internal class Compiler(private val program: Program): IAstProcessor {
         continueStmtLabelStack.pop()
     }
 
-    private fun translateForOverConstantRange(varname: String, varDt: DataType, range: IntProgression, body: AnonymousScope) {
+    private fun translateForOverConstantRange(varname: String?, loopregister: Register?, varDt: DataType, range: IntProgression, body: AnonymousScope) {
         /**
          * for LV in start..last { body }
          * (and we already know that the range is not empty, and first and last are exactly inclusive.)
@@ -1731,7 +1737,9 @@ internal class Compiler(private val program: Program): IAstProcessor {
         breakStmtLabelStack.push(breakLabel)
 
         prog.instr(opcodePush(varDt), RuntimeValue(varDt, range.first))
-        prog.instr(opcodePopvar(varDt), callLabel = varname)
+        val variableLabel = varname ?: loopregister?.name
+
+        prog.instr(opcodePopvar(varDt), callLabel = variableLabel)
         prog.label(loopLabel)
         translate(body)
         prog.label(continueLabel)
@@ -1739,25 +1747,25 @@ internal class Compiler(private val program: Program): IAstProcessor {
         when {
             range.step in 1..numberOfIncDecsForOptimize -> {
                 repeat(range.step) {
-                    prog.instr(opcodeIncvar(varDt), callLabel = varname)
+                    prog.instr(opcodeIncvar(varDt), callLabel = variableLabel)
                 }
             }
             range.step in -1 downTo -numberOfIncDecsForOptimize -> {
                 repeat(abs(range.step)) {
-                    prog.instr(opcodeDecvar(varDt), callLabel = varname)
+                    prog.instr(opcodeDecvar(varDt), callLabel = variableLabel)
                 }
             }
             range.step>numberOfIncDecsForOptimize -> {
-                prog.instr(opcodePushvar(varDt), callLabel = varname)
+                prog.instr(opcodePushvar(varDt), callLabel = variableLabel)
                 prog.instr(opcodePush(varDt), RuntimeValue(varDt, range.step))
                 prog.instr(opcodeAdd(varDt))
-                prog.instr(opcodePopvar(varDt), callLabel = varname)
+                prog.instr(opcodePopvar(varDt), callLabel = variableLabel)
             }
             range.step<numberOfIncDecsForOptimize -> {
-                prog.instr(opcodePushvar(varDt), callLabel = varname)
+                prog.instr(opcodePushvar(varDt), callLabel = variableLabel)
                 prog.instr(opcodePush(varDt), RuntimeValue(varDt, abs(range.step)))
                 prog.instr(opcodeSub(varDt))
-                prog.instr(opcodePopvar(varDt), callLabel = varname)
+                prog.instr(opcodePopvar(varDt), callLabel = variableLabel)
             }
         }
 
@@ -1765,7 +1773,7 @@ internal class Compiler(private val program: Program): IAstProcessor {
             // optimize for the for loop that counts to 0
             prog.instr(if(range.first>0) Opcode.BPOS else Opcode.BNEG, callLabel = loopLabel)
         } else {
-            prog.instr(opcodePushvar(varDt), callLabel = varname)
+            prog.instr(opcodePushvar(varDt), callLabel = variableLabel)
             val checkValue =
                     when (varDt) {
                         DataType.UBYTE -> (range.last + range.step) and 255
@@ -1824,7 +1832,7 @@ internal class Compiler(private val program: Program): IAstProcessor {
                 AssignTarget(register, null, null, null, range.position)
         }
 
-        val startAssignment = Assignment(listOf(makeAssignmentTarget()), null, range.from, range.position)
+        val startAssignment = Assignment(makeAssignmentTarget(), null, range.from, range.position)
         startAssignment.linkParents(body)
         translate(startAssignment)
 
@@ -1848,10 +1856,10 @@ internal class Compiler(private val program: Program): IAstProcessor {
             val condition =
                     if(literalStepValue > 0) {
                         // if LV > last  goto break
-                        BinaryExpression(loopVar,">", range.to, range.position)
+                        BinaryExpression(loopVar, ">", range.to, range.position)
                     } else {
                         // if LV < last  goto break
-                        BinaryExpression(loopVar,"<", range.to, range.position)
+                        BinaryExpression(loopVar, "<", range.to, range.position)
                     }
             val ifstmt = IfStatement(condition,
                     AnonymousScope(mutableListOf(Jump(null, null, breakLabel, range.position)), range.position),
@@ -1881,7 +1889,7 @@ internal class Compiler(private val program: Program): IAstProcessor {
                 TODO("can't generate code for step other than 1 or -1 right now")
 
             // LV++ / LV--
-            val postIncr = PostIncrDecr(lvTarget, if(step==1) "++" else "--", range.position)
+            val postIncr = PostIncrDecr(lvTarget, if (step == 1) "++" else "--", range.position)
             postIncr.linkParents(body)
             translate(postIncr)
             if(lvTarget.register!=null)
@@ -2002,7 +2010,7 @@ internal class Compiler(private val program: Program): IAstProcessor {
             DataType.UBYTE -> when(sourceDt) {
                 DataType.UBYTE -> {}
                 DataType.BYTE -> prog.instr(Opcode.CAST_B_TO_UB)
-                DataType.UWORD-> prog.instr(Opcode.CAST_UW_TO_UB)
+                DataType.UWORD -> prog.instr(Opcode.CAST_UW_TO_UB)
                 DataType.WORD-> prog.instr(Opcode.CAST_W_TO_UB)
                 DataType.FLOAT -> prog.instr(Opcode.CAST_F_TO_UB)
                 else -> throw CompilerException("invalid cast $sourceDt to ${expr.type} -- should be an Ast check")
@@ -2056,6 +2064,7 @@ internal class Compiler(private val program: Program): IAstProcessor {
 
     private fun translate(memwrite: DirectMemoryWrite) {
         // for now, only a single memory location (ubyte) is written at a time.
+        // TODO inline this function (it's only used once)
         val address = memwrite.addressExpression.constValue(program)?.asIntegerValue
         if(address!=null) {
             prog.instr(Opcode.POP_MEM_BYTE, arg = RuntimeValue(DataType.UWORD, address))
@@ -2067,16 +2076,68 @@ internal class Compiler(private val program: Program): IAstProcessor {
 
     private fun translate(addrof: AddressOf) {
         val target = addrof.identifier.targetVarDecl(program.namespace)!!
-        if(target.datatype in ArrayDatatypes || target.datatype in StringDatatypes|| target.datatype==DataType.FLOAT) {
+        if(target.datatype in ArrayDatatypes || target.datatype in StringDatatypes || target.datatype== DataType.FLOAT) {
             pushHeapVarAddress(addrof.identifier, false)
         }
-        else if(target.datatype==DataType.FLOAT) {
+        else if(target.datatype== DataType.FLOAT) {
             pushFloatAddress(addrof.identifier)
         }
+        else if(target.datatype == DataType.STRUCT) {
+            pushStructAddress(addrof.identifier)
+        }
         else
             throw CompilerException("cannot take memory pointer $addrof")
     }
 
+    private fun translate(whenstmt: WhenStatement) {
+        val conditionDt = whenstmt.condition.inferType(program)
+        if(conditionDt !in IntegerDatatypes)
+            throw CompilerException("when condition must be integer")
+        translate(whenstmt.condition)
+        if(whenstmt.choices.isEmpty()) {
+            if (conditionDt in ByteDatatypes) prog.instr(Opcode.DISCARD_BYTE)
+            else prog.instr(Opcode.DISCARD_WORD)
+            return
+        }
+
+        val endOfWhenLabel = makeLabel(whenstmt, "when_end")
+
+        val choiceLabels = mutableListOf<String>()
+        for(choice in whenstmt.choiceValues(program)) {
+            if(choice.first==null) {
+                // the else clause
+                translate(choice.second.statements)
+            } else {
+                val choiceVal = choice.first!!.single()
+                val rval = RuntimeValue(conditionDt!!, choiceVal)
+                if (conditionDt in ByteDatatypes) {
+                    prog.instr(Opcode.DUP_B)
+                    prog.instr(opcodeCompare(conditionDt), rval)
+                }
+                else {
+                    prog.instr(Opcode.DUP_W)
+                    prog.instr(opcodeCompare(conditionDt), rval)
+                }
+                val choiceLabel = makeLabel(whenstmt, "choice_$choiceVal")
+                choiceLabels.add(choiceLabel)
+                prog.instr(Opcode.BZ, callLabel = choiceLabel)
+            }
+        }
+        prog.instr(Opcode.JUMP, callLabel = endOfWhenLabel)
+
+        for(choice in whenstmt.choices.zip(choiceLabels)) {
+            prog.label(choice.second)
+            translate(choice.first.statements)
+            prog.instr(Opcode.JUMP, callLabel = endOfWhenLabel)
+        }
+
+        prog.removeLastInstruction()    // remove the last jump, that can fall through to here
+        prog.label(endOfWhenLabel)
+
+        if (conditionDt in ByteDatatypes) prog.instr(Opcode.DISCARD_BYTE)
+        else prog.instr(Opcode.DISCARD_WORD)
+    }
+
     private fun translateAsmInclude(args: List<DirectiveArg>, source: Path) {
         val scopeprefix = if(args[1].str!!.isNotBlank()) "${args[1].str}\t.proc\n" else ""
         val scopeprefixEnd = if(args[1].str!!.isNotBlank()) "\t.pend\n" else ""

compiler/src/prog8/compiler/Main.kt

@@ -0,0 +1,189 @@
+package prog8.compiler
+
+import prog8.ast.Program
+import prog8.ast.base.*
+import prog8.ast.base.checkIdentifiers
+import prog8.ast.base.checkValid
+import prog8.ast.base.reorderStatements
+import prog8.ast.statements.Directive
+import prog8.compiler.target.c64.AsmGen
+import prog8.compiler.target.c64.MachineDefinition
+import prog8.optimizer.constantFold
+import prog8.optimizer.optimizeStatements
+import prog8.optimizer.simplifyExpressions
+import prog8.parser.ParsingFailedError
+import prog8.parser.importLibraryModule
+import prog8.parser.importModule
+import prog8.parser.moduleName
+import java.io.File
+import java.io.PrintStream
+import java.lang.Exception
+import java.nio.file.Path
+import kotlin.system.exitProcess
+import kotlin.system.measureTimeMillis
+
+fun compileProgram(filepath: Path,
+                   optimize: Boolean, optimizeInlining: Boolean,
+                   generateVmCode: Boolean, writeVmCode: Boolean,
+                   writeAssembly: Boolean): Pair<Program, String?> {
+    lateinit var programAst: Program
+    var programName: String? = null
+
+    try {
+        val totalTime = measureTimeMillis {
+            // import main module and everything it needs
+            println("Parsing...")
+            programAst = Program(moduleName(filepath.fileName), mutableListOf())
+            importModule(programAst, filepath)
+
+            val compilerOptions = determineCompilationOptions(programAst)
+            if (compilerOptions.launcher == LauncherType.BASIC && compilerOptions.output != OutputType.PRG)
+                throw ParsingFailedError("${programAst.modules.first().position} BASIC launcher requires output type PRG.")
+
+            // if we're producing a PRG or BASIC program, include the c64utils and c64lib libraries
+            if (compilerOptions.launcher == LauncherType.BASIC || compilerOptions.output == OutputType.PRG) {
+                importLibraryModule(programAst, "c64lib")
+                importLibraryModule(programAst, "c64utils")
+            }
+
+            // always import prog8lib and math
+            importLibraryModule(programAst, "math")
+            importLibraryModule(programAst, "prog8lib")
+
+
+            // perform initial syntax checks and constant folding
+            println("Syntax check...")
+            val time1 = measureTimeMillis {
+                programAst.checkIdentifiers()
+            }
+
+            //println(" time1: $time1")
+            val time2 = measureTimeMillis {
+                programAst.constantFold()
+            }
+            //println(" time2: $time2")
+            val time3 = measureTimeMillis {
+                programAst.removeNopsFlattenAnonScopes()
+                programAst.reorderStatements()     // reorder statements and add type casts, to please the compiler later
+            }
+            //println(" time3: $time3")
+            val time4 = measureTimeMillis {
+                programAst.checkValid(compilerOptions)          // check if tree is valid
+            }
+            //println(" time4: $time4")
+
+            programAst.checkIdentifiers()
+            if (optimize) {
+                // optimize the parse tree
+                println("Optimizing...")
+                while (true) {
+                    // keep optimizing expressions and statements until no more steps remain
+                    val optsDone1 = programAst.simplifyExpressions()
+                    val optsDone2 = programAst.optimizeStatements(optimizeInlining)
+                    if (optsDone1 + optsDone2 == 0)
+                        break
+                }
+            }
+
+            programAst.removeNopsFlattenAnonScopes()
+            programAst.checkValid(compilerOptions)          // check if final tree is valid
+            programAst.checkRecursion()         // check if there are recursive subroutine calls
+
+            // printAst(programAst)
+            // namespace.debugPrint()
+
+            if(generateVmCode) {
+                // compile the syntax tree into stackvmProg form, and optimize that
+                val compiler = Compiler(programAst)
+                val intermediate = compiler.compile(compilerOptions)
+                if (optimize)
+                    intermediate.optimize()
+
+                if (writeVmCode) {
+                    val stackVmFilename = intermediate.name + ".vm.txt"
+                    val stackvmFile = PrintStream(File(stackVmFilename), "utf-8")
+                    intermediate.writeCode(stackvmFile)
+                    stackvmFile.close()
+                    println("StackVM program code written to '$stackVmFilename'")
+                }
+
+                if (writeAssembly) {
+                    val zeropage = MachineDefinition.C64Zeropage(compilerOptions)
+                    intermediate.allocateZeropage(zeropage)
+                    val assembly = AsmGen(compilerOptions, intermediate, programAst.heap, zeropage).compileToAssembly(optimize)
+                    assembly.assemble(compilerOptions)
+                    programName = assembly.name
+                }
+            }
+        }
+        println("\nTotal compilation+assemble time: ${totalTime / 1000.0} sec.")
+
+    } catch (px: ParsingFailedError) {
+        System.err.print("\u001b[91m")  // bright red
+        System.err.println(px.message)
+        System.err.print("\u001b[0m")  // reset
+        exitProcess(1)
+    } catch (ax: AstException) {
+        System.err.print("\u001b[91m")  // bright red
+        System.err.println(ax.toString())
+        System.err.print("\u001b[0m")  // reset
+        exitProcess(1)
+    } catch (x: Exception) {
+        print("\u001b[91m")  // bright red
+        println("\n* internal error *")
+        print("\u001b[0m")  // reset
+        System.out.flush()
+        throw x
+    } catch (x: NotImplementedError) {
+        print("\u001b[91m")  // bright red
+        println("\n* internal error: missing feature/code *")
+        print("\u001b[0m")  // reset
+        System.out.flush()
+        throw x
+    }
+    return Pair(programAst, programName)
+}
+
+fun printAst(programAst: Program) {
+    println()
+    val printer = AstToSourceCode(::print)
+    printer.visit(programAst)
+    println()
+}
+
+
+private fun determineCompilationOptions(program: Program): CompilationOptions {
+    val mainModule = program.modules.first()
+    val outputType = (mainModule.statements.singleOrNull { it is Directive && it.directive == "%output" }
+            as? Directive)?.args?.single()?.name?.toUpperCase()
+    val launcherType = (mainModule.statements.singleOrNull { it is Directive && it.directive == "%launcher" }
+            as? Directive)?.args?.single()?.name?.toUpperCase()
+    mainModule.loadAddress = (mainModule.statements.singleOrNull { it is Directive && it.directive == "%address" }
+            as? Directive)?.args?.single()?.int ?: 0
+    val zpoption: String? = (mainModule.statements.singleOrNull { it is Directive && it.directive == "%zeropage" }
+            as? Directive)?.args?.single()?.name?.toUpperCase()
+    val allOptions = program.modules.flatMap { it.statements }.filter { it is Directive && it.directive == "%option" }.flatMap { (it as Directive).args }.toSet()
+    val floatsEnabled = allOptions.any { it.name == "enable_floats" }
+    val zpType: ZeropageType =
+            if (zpoption == null)
+                if(floatsEnabled) ZeropageType.FLOATSAFE else ZeropageType.KERNALSAFE
+            else
+                try {
+                    ZeropageType.valueOf(zpoption)
+                } catch (x: IllegalArgumentException) {
+                    ZeropageType.KERNALSAFE
+                    // error will be printed by the astchecker
+                }
+    val zpReserved = mainModule.statements
+            .asSequence()
+            .filter { it is Directive && it.directive == "%zpreserved" }
+            .map { (it as Directive).args }
+            .map { it[0].int!!..it[1].int!! }
+            .toList()
+
+    return CompilationOptions(
+            if (outputType == null) OutputType.PRG else OutputType.valueOf(outputType),
+            if (launcherType == null) LauncherType.BASIC else LauncherType.valueOf(launcherType),
+            zpType, zpReserved, floatsEnabled
+    )
+}

compiler/src/prog8/compiler/Zeropage.kt

@@ -1,6 +1,7 @@
 package prog8.compiler
 
-import prog8.ast.*
+import prog8.ast.base.*
+import prog8.ast.base.printWarning
 
 
 class ZeropageDepletedError(message: String) : Exception(message)

compiler/src/prog8/compiler/intermediate/Instruction.kt

@@ -1,7 +1,7 @@
 package prog8.compiler.intermediate
 
-import prog8.compiler.RuntimeValue
-import prog8.stackvm.Syscall
+import prog8.vm.RuntimeValue
+import prog8.vm.stackvm.Syscall
 
 open class Instruction(val opcode: Opcode,
                        val arg: RuntimeValue? = null,

compiler/src/prog8/compiler/intermediate/IntermediateProgram.kt

@@ -1,7 +1,13 @@
 package prog8.compiler.intermediate
 
-import prog8.ast.*
-import prog8.compiler.RuntimeValue
+import prog8.ast.antlr.escape
+import prog8.ast.base.*
+import prog8.ast.base.printWarning
+import prog8.ast.expressions.LiteralValue
+import prog8.ast.statements.StructDecl
+import prog8.ast.statements.VarDecl
+import prog8.ast.statements.ZeropageWish
+import prog8.vm.RuntimeValue
 import prog8.compiler.CompilerException
 import prog8.compiler.HeapValues
 import prog8.compiler.Zeropage
@@ -12,10 +18,12 @@ import java.nio.file.Path
 
 class IntermediateProgram(val name: String, var loadAddress: Int, val heap: HeapValues, val source: Path) {
 
+    data class VariableParameters (val zp: ZeropageWish, val memberOfStruct: StructDecl?)
+
     class ProgramBlock(val name: String,
                        var address: Int?,
                        val instructions: MutableList<Instruction> = mutableListOf(),
-                       val variables: MutableMap<String, RuntimeValue> = mutableMapOf(),           // names are fully scoped
+                       val variables: MutableList<Triple<String, RuntimeValue, VariableParameters>> = mutableListOf(),           // names are fully scoped
                        val memoryPointers: MutableMap<String, Pair<Int, DataType>> = mutableMapOf(),
                        val labels: MutableMap<String, Instruction> = mutableMapOf(),        // names are fully scoped
                        val force_output: Boolean)
@@ -24,7 +32,7 @@ class IntermediateProgram(val name: String, var loadAddress: Int, val heap: Heap
             get() { return variables.size }
         val numInstructions: Int
             get() { return instructions.filter { it.opcode!= Opcode.LINE }.size }
-        val variablesMarkedForZeropage: MutableSet<String> = mutableSetOf()
+        val variablesMarkedForZeropage: MutableSet<String> = mutableSetOf()     // TODO maybe this can be removed now we have ValueParameters
     }
 
     val allocatedZeropageVariables = mutableMapOf<String, Pair<Int, DataType>>()
@@ -41,14 +49,16 @@ class IntermediateProgram(val name: String, var loadAddress: Int, val heap: Heap
         // allocates all @zp marked variables on the zeropage (for all blocks, as long as there is space in the ZP)
         var notAllocated = 0
         for(block in blocks) {
-            val zpVariables = block.variables.filter { it.key in block.variablesMarkedForZeropage }
+            val zpVariables = block.variables.filter { it.first in block.variablesMarkedForZeropage }
             if (zpVariables.isNotEmpty()) {
-                for (variable in zpVariables) {
+                for ((varname, value, varparams) in zpVariables) {
+                    if(varparams.zp==ZeropageWish.NOT_IN_ZEROPAGE || varparams.memberOfStruct!=null)
+                        throw CompilerException("zp conflict")
                     try {
-                        val address = zeropage.allocate(variable.key, variable.value.type, null)
-                        allocatedZeropageVariables[variable.key] = Pair(address, variable.value.type)
+                        val address = zeropage.allocate(varname, value.type, null)
+                        allocatedZeropageVariables[varname] = Pair(address, value.type)
                     } catch (x: ZeropageDepletedError) {
-                        printWarning(x.toString() + " variable ${variable.key} type ${variable.value.type}")
+                        printWarning(x.toString() + " variable $varname type ${value.type}")
                         notAllocated++
                     }
                 }
@@ -389,8 +399,16 @@ class IntermediateProgram(val name: String, var loadAddress: Int, val heap: Heap
     fun variable(scopedname: String, decl: VarDecl) {
         when(decl.type) {
             VarDeclType.VAR -> {
+                // var decls that are defined inside of a StructDecl are skipped in the output
+                //   because every occurrence of the members will have a separate mangled vardecl for that occurrence
+                if(decl.parent is StructDecl)
+                    return
+
+                val valueparams = VariableParameters(decl.zeropage, decl.struct)
                 val value = when(decl.datatype) {
-                    in NumericDatatypes -> RuntimeValue(decl.datatype, (decl.value as LiteralValue).asNumericValue!!)
+                    in NumericDatatypes -> {
+                        RuntimeValue(decl.datatype, (decl.value as LiteralValue).asNumericValue!!)
+                    }
                     in StringDatatypes -> {
                         val litval = (decl.value as LiteralValue)
                         if(litval.heapId==null)
@@ -403,16 +421,22 @@ class IntermediateProgram(val name: String, var loadAddress: Int, val heap: Heap
                             throw CompilerException("array should already be in the heap")
                         RuntimeValue(decl.datatype, heapId = litval.heapId)
                     }
+                    DataType.STRUCT -> {
+                        // struct variables have been flattened already
+                        return
+                    }
                     else -> throw CompilerException("weird datatype")
                 }
-                currentBlock.variables[scopedname] = value
-                if(decl.zeropage)
+                currentBlock.variables.add(Triple(scopedname, value, valueparams))
+                if(decl.zeropage==ZeropageWish.PREFER_ZEROPAGE)
                     currentBlock.variablesMarkedForZeropage.add(scopedname)
+                else if(decl.zeropage==ZeropageWish.REQUIRE_ZEROPAGE)
+                    TODO("REQUIRE_ZEROPAGE not yet implemented")
             }
             VarDeclType.MEMORY -> {
                 // note that constants are all folded away, but assembly code may still refer to them
                 val lv = decl.value as LiteralValue
-                if(lv.type!=DataType.UWORD && lv.type!=DataType.UBYTE)
+                if(lv.type!= DataType.UWORD && lv.type!= DataType.UBYTE)
                     throw CompilerException("expected integer memory address $lv")
                 currentBlock.memoryPointers[scopedname] = Pair(lv.asIntegerValue!!, decl.datatype)
             }
@@ -455,10 +479,14 @@ class IntermediateProgram(val name: String, var loadAddress: Int, val heap: Heap
 
     fun writeCode(out: PrintStream, embeddedLabels: Boolean=true) {
         out.println("; stackVM program code for '$name'")
-        out.println("%memory")
-        if(memory.isNotEmpty())
-            TODO("add support for writing/reading initial memory values")
-        out.println("%end_memory")
+        writeMemory(out)
+        writeHeap(out)
+        for(blk in blocks) {
+            writeBlock(out, blk, embeddedLabels)
+        }
+    }
+
+    private fun writeHeap(out: PrintStream) {
         out.println("%heap")
         heap.allEntries().forEach {
             out.print("${it.key}  ${it.value.type.name.toLowerCase()}  ")
@@ -487,34 +515,45 @@ class IntermediateProgram(val name: String, var loadAddress: Int, val heap: Heap
             }
         }
         out.println("%end_heap")
-        for(blk in blocks) {
-            out.println("\n%block ${blk.name} ${blk.address?.toString(16) ?: ""}")
+    }
 
-            out.println("%variables")
-            for(variable in blk.variables) {
-                val valuestr = variable.value.toString()
-                out.println("${variable.key}  ${variable.value.type.name.toLowerCase()}  $valuestr")
-            }
-            out.println("%end_variables")
-            out.println("%memorypointers")
-            for(iconst in blk.memoryPointers) {
-                out.println("${iconst.key}  ${iconst.value.second.name.toLowerCase()}  uw:${iconst.value.first.toString(16)}")
-            }
-            out.println("%end_memorypointers")
-            out.println("%instructions")
-            val labels = blk.labels.entries.associateBy({it.value}) {it.key}
-            for(instr in blk.instructions) {
-                if(!embeddedLabels) {
-                    val label = labels[instr]
-                    if (label != null)
-                        out.println("$label:")
-                } else {
-                    out.println(instr)
-                }
-            }
-            out.println("%end_instructions")
+    private fun writeBlock(out: PrintStream, blk: ProgramBlock, embeddedLabels: Boolean) {
+        out.println("\n%block ${blk.name} ${blk.address?.toString(16) ?: ""}")
 
-            out.println("%end_block")
+        out.println("%variables")
+        for ((vname, value, parameters) in blk.variables) {
+            if(parameters.zp==ZeropageWish.REQUIRE_ZEROPAGE)
+                throw CompilerException("zp conflict")
+            val valuestr = value.toString()
+            val struct =  if(parameters.memberOfStruct==null) "" else "struct=${parameters.memberOfStruct.name}"
+            out.println("$vname  ${value.type.name.toLowerCase()}  $valuestr  zp=${parameters.zp} $struct")
         }
+        out.println("%end_variables")
+        out.println("%memorypointers")
+        for (iconst in blk.memoryPointers) {
+            out.println("${iconst.key}  ${iconst.value.second.name.toLowerCase()}  uw:${iconst.value.first.toString(16)}")
+        }
+        out.println("%end_memorypointers")
+        out.println("%instructions")
+        val labels = blk.labels.entries.associateBy({ it.value }) { it.key }
+        for (instr in blk.instructions) {
+            if (!embeddedLabels) {
+                val label = labels[instr]
+                if (label != null)
+                    out.println("$label:")
+            } else {
+                out.println(instr)
+            }
+        }
+        out.println("%end_instructions")
+
+        out.println("%end_block")
+    }
+
+    private fun writeMemory(out: PrintStream) {
+        out.println("%memory")
+        if (memory.isNotEmpty())
+            TODO("add support for writing/reading initial memory values")
+        out.println("%end_memory")
     }
 }

compiler/src/prog8/compiler/intermediate/Opcode.kt

@@ -19,6 +19,8 @@ enum class Opcode {
     PUSH_REGAY_WORD, // push registers A/Y as a 16-bit word
     PUSH_REGXY_WORD, // push registers X/Y as a 16-bit word
     PUSH_ADDR_HEAPVAR,  // push the address of the variable that's on the heap (string or array)
+    DUP_B,          // duplicate the top byte on the stack
+    DUP_W,          // duplicate the top word on the stack
 
     // popping values off the (evaluation) stack, possibly storing them in another location
     DISCARD_BYTE,    // discard top byte value

compiler/src/prog8/compiler/target/c64/AsmOptimizer.kt

@@ -1,6 +1,11 @@
 package prog8.compiler.target.c64
 
-import prog8.compiler.toHex
+import prog8.compiler.target.c64.MachineDefinition.ESTACK_LO_HEX
+import prog8.compiler.target.c64.MachineDefinition.ESTACK_LO_PLUS1_HEX
+
+
+// note: see https://wiki.nesdev.com/w/index.php/6502_assembly_optimisations
+
 
 fun optimizeAssembly(lines: MutableList<String>): Int {
 
@@ -24,10 +29,19 @@ fun optimizeAssembly(lines: MutableList<String>): Int {
         numberOfOptimizations++
     }
 
+    removeLines = optimizeCmpSequence(linesByFour)
+    if(removeLines.isNotEmpty()) {
+        for (i in removeLines.reversed())
+            lines.removeAt(i)
+        linesByFour = getLinesBy(lines, 4)
+        numberOfOptimizations++
+    }
+
     removeLines = optimizeStoreLoadSame(linesByFour)
     if(removeLines.isNotEmpty()) {
         for (i in removeLines.reversed())
             lines.removeAt(i)
+        linesByFour = getLinesBy(lines, 4)
         numberOfOptimizations++
     }
 
@@ -36,6 +50,7 @@ fun optimizeAssembly(lines: MutableList<String>): Int {
     if(removeLines.isNotEmpty()) {
         for (i in removeLines.reversed())
             lines.removeAt(i)
+        linesByFourteen = getLinesBy(lines, 14)
         numberOfOptimizations++
     }
 
@@ -44,15 +59,36 @@ fun optimizeAssembly(lines: MutableList<String>): Int {
     return numberOfOptimizations
 }
 
+fun optimizeCmpSequence(linesByFour: List<List<IndexedValue<String>>>): List<Int> {
+    // the when statement (on bytes) generates a sequence of:
+    //	 lda $ce01,x
+    //	 cmp #$20
+    //	 beq  check_prog8_s72choice_32
+    //	 lda $ce01,x
+    //	 cmp #$21
+    //	 beq  check_prog8_s73choice_33
+    // the repeated lda can be removed
+    val removeLines = mutableListOf<Int>()
+    for(lines in linesByFour) {
+        if(lines[0].value.trim()=="lda  $ESTACK_LO_PLUS1_HEX,x" &&
+                lines[1].value.trim().startsWith("cmp ") &&
+                lines[2].value.trim().startsWith("beq ") &&
+                lines[3].value.trim()=="lda  $ESTACK_LO_PLUS1_HEX,x") {
+            removeLines.add(lines[3].index) // remove the second lda
+        }
+    }
+    return removeLines
+}
+
 fun optimizeUselessStackByteWrites(linesByFour: List<List<IndexedValue<String>>>): List<Int> {
     // sta on stack, dex, inx, lda from stack -> eliminate this useless stack byte write
     // this is a lot harder for word values because the instruction sequence varies.
     val removeLines = mutableListOf<Int>()
     for(lines in linesByFour) {
-        if(lines[0].value.trim()=="sta  ${ESTACK_LO.toHex()},x" &&
+        if(lines[0].value.trim()=="sta  $ESTACK_LO_HEX,x" &&
                 lines[1].value.trim()=="dex" &&
                 lines[2].value.trim()=="inx" &&
-                lines[3].value.trim()=="lda  ${ESTACK_LO.toHex()},x") {
+                lines[3].value.trim()=="lda  $ESTACK_LO_HEX,x") {
             removeLines.add(lines[0].index)
             removeLines.add(lines[1].index)
             removeLines.add(lines[2].index)
@@ -128,7 +164,7 @@ fun optimizeSameAssignments(linesByFourteen: List<List<IndexedValue<String>>>):
 }
 
 private fun getLinesBy(lines: MutableList<String>, windowSize: Int) =
-// all lines (that aren't empty or comments) in sliding pairs of 2
+// all lines (that aren't empty or comments) in sliding windows of certain size
         lines.withIndex().filter { it.value.isNotBlank() && !it.value.trimStart().startsWith(';') }.windowed(windowSize, partialWindows = false)
 
 private fun optimizeStoreLoadSame(linesByFour: List<List<IndexedValue<String>>>): List<Int> {

compiler/src/prog8/compiler/target/c64/Commodore64.kt

@@ -1,242 +0,0 @@
-package prog8.compiler.target.c64
-
-import prog8.compiler.CompilationOptions
-import prog8.compiler.CompilerException
-import prog8.compiler.Zeropage
-import prog8.compiler.ZeropageType
-import java.awt.Color
-import java.awt.image.BufferedImage
-import javax.imageio.ImageIO
-import kotlin.math.absoluteValue
-import kotlin.math.pow
-
-
-// 5-byte cbm MFLPT format limitations:
-const val FLOAT_MAX_POSITIVE = 1.7014118345e+38         // bytes: 255,127,255,255,255
-const val FLOAT_MAX_NEGATIVE = -1.7014118345e+38        // bytes: 255,255,255,255,255
-
-const val BASIC_LOAD_ADDRESS = 0x0801
-const val RAW_LOAD_ADDRESS = 0xc000
-
-// the 2*256 byte evaluation stack (on which bytes, words, and even floats are stored during calculations)
-const val ESTACK_LO = 0xce00        //  $ce00-$ceff inclusive
-const val ESTACK_HI = 0xcf00        //  $cf00-$cfff inclusive
-
-
-class C64Zeropage(options: CompilationOptions) : Zeropage(options) {
-
-    companion object {
-        const val SCRATCH_B1 = 0x02
-        const val SCRATCH_REG = 0x03    // temp storage for a register
-        const val SCRATCH_REG_X = 0xfa    // temp storage for register X (the evaluation stack pointer)
-        const val SCRATCH_W1 = 0xfb     // $fb+$fc
-        const val SCRATCH_W2 = 0xfd     // $fd+$fe
-    }
-
-    override val exitProgramStrategy: ExitProgramStrategy = when(options.zeropage) {
-        ZeropageType.BASICSAFE -> ExitProgramStrategy.CLEAN_EXIT
-        ZeropageType.FLOATSAFE, ZeropageType.KERNALSAFE, ZeropageType.FULL -> ExitProgramStrategy.SYSTEM_RESET
-    }
-
-
-    init {
-        if(options.floats && options.zeropage!=ZeropageType.FLOATSAFE && options.zeropage!=ZeropageType.BASICSAFE)
-            throw CompilerException("when floats are enabled, zero page type should be 'floatsafe' or 'basicsafe'")
-
-        if(options.zeropage == ZeropageType.FULL) {
-            free.addAll(0x04 .. 0xf9)
-            free.add(0xff)
-            free.removeAll(listOf(SCRATCH_B1, SCRATCH_REG, SCRATCH_REG_X, SCRATCH_W1, SCRATCH_W1+1, SCRATCH_W2, SCRATCH_W2+1))
-            free.removeAll(listOf(0xa0, 0xa1, 0xa2, 0x91, 0xc0, 0xc5, 0xcb, 0xf5, 0xf6))        // these are updated by IRQ
-        } else {
-            if(options.zeropage == ZeropageType.KERNALSAFE || options.zeropage == ZeropageType.FLOATSAFE) {
-                free.addAll(listOf(0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f, 0x10, 0x11,
-                        0x14, 0x15, 0x16, 0x17, 0x18, 0x19, 0x1a, 0x1b, 0x1c, 0x1d, 0x1e, 0x1f, 0x20, 0x21,
-                        0x22, 0x23, 0x24, 0x25,
-                        0x39, 0x3a, 0x3b, 0x3c, 0x3d, 0x3e, 0x3f, 0x40, 0x41, 0x42, 0x43, 0x44, 0x45, 0x46,
-                        0x47, 0x48, 0x4b, 0x4c, 0x4d, 0x4e, 0x4f, 0x51, 0x52, 0x53,
-                        0x57, 0x58, 0x59, 0x5a, 0x5b, 0x5c, 0x5d, 0x5e, 0x5f, 0x60,
-                        0x61, 0x62, 0x63, 0x64, 0x65, 0x66, 0x67, 0x68,
-                        0x69, 0x6a, 0x6b, 0x6c, 0x6d, 0x6e, 0x6f, 0x70, 0x71, 0x72,
-                        0x73, 0x74, 0x75, 0x76, 0x77, 0x78, 0x79, 0x7a, 0x7b, 0x7c,
-                        0x7d, 0x7e, 0x7f, 0x80, 0x81, 0x82, 0x83, 0x84, 0x85, 0x86, 0x87, 0x88, 0x89, 0x8a,
-                        0x8b, 0x8c, 0x8d, 0x8e, 0x8f, 0xff
-                        // 0x90-0xfa is 'kernel work storage area'
-                ))
-            }
-
-            if(options.zeropage == ZeropageType.FLOATSAFE) {
-                // remove the zero page locations used for floating point operations from the free list
-                free.removeAll(listOf(
-                        0x12, 0x26, 0x27, 0x28, 0x29, 0x2a,
-                        0x57, 0x58, 0x59, 0x5a, 0x5b, 0x5c, 0x5d, 0x5e, 0x5f, 0x60,
-                        0x61, 0x62, 0x63, 0x64, 0x65, 0x66, 0x67, 0x68,
-                        0x69, 0x6a, 0x6b, 0x6c, 0x6d, 0x6e, 0x6f, 0x70, 0x71, 0x72,
-                        0x8b, 0x8c, 0x8d, 0x8e, 0x8f, 0xf
-                ))
-            }
-
-            // add the other free Zp addresses,
-            // these are valid for the C-64 (when no RS232 I/O is performed) but to keep BASIC running fully:
-            free.addAll(listOf(0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0a, 0x0d, 0x0e,
-                    0x94, 0x95, 0xa7, 0xa8, 0xa9, 0xaa,
-                    0xb5, 0xb6, 0xf7, 0xf8, 0xf9))
-        }
-        assert(SCRATCH_B1 !in free)
-        assert(SCRATCH_REG !in free)
-        assert(SCRATCH_REG_X !in free)
-        assert(SCRATCH_W1 !in free)
-        assert(SCRATCH_W2 !in free)
-
-        for(reserved in options.zpReserved)
-            reserve(reserved)
-    }
-}
-
-
-data class Mflpt5(val b0: Short, val b1: Short, val b2: Short, val b3: Short, val b4: Short) {
-
-    companion object {
-        const val MemorySize = 5
-
-        val zero = Mflpt5(0, 0,0,0,0)
-        fun fromNumber(num: Number): Mflpt5 {
-            // see https://en.wikipedia.org/wiki/Microsoft_Binary_Format
-            // and https://sourceforge.net/p/acme-crossass/code-0/62/tree/trunk/ACME_Lib/cbm/mflpt.a
-            // and https://en.wikipedia.org/wiki/IEEE_754-1985
-
-            val flt = num.toDouble()
-            if(flt < FLOAT_MAX_NEGATIVE || flt > FLOAT_MAX_POSITIVE)
-                throw CompilerException("floating point number out of 5-byte mflpt range: $this")
-            if(flt==0.0)
-                return zero
-
-            val sign = if(flt<0.0) 0x80L else 0x00L
-            var exponent = 128 + 32	// 128 is cbm's bias, 32 is this algo's bias
-            var mantissa = flt.absoluteValue
-
-            // if mantissa is too large, shift right and adjust exponent
-            while(mantissa >= 0x100000000) {
-                mantissa /= 2.0
-                exponent ++
-            }
-            // if mantissa is too small, shift left and adjust exponent
-            while(mantissa < 0x80000000) {
-                mantissa *= 2.0
-                exponent --
-            }
-
-            return when {
-                exponent<0 -> zero  // underflow, use zero instead
-                exponent>255 -> throw CompilerException("floating point overflow: $this")
-                exponent==0 -> zero
-                else -> {
-                    val mantLong = mantissa.toLong()
-                    Mflpt5(
-                            exponent.toShort(),
-                            (mantLong.and(0x7f000000L) ushr 24).or(sign).toShort(),
-                            (mantLong.and(0x00ff0000L) ushr 16).toShort(),
-                            (mantLong.and(0x0000ff00L) ushr 8).toShort(),
-                            (mantLong.and(0x000000ffL)).toShort())
-                }
-            }
-        }
-    }
-
-    fun toDouble(): Double {
-        if(this == zero) return 0.0
-        val exp = b0 - 128
-        val sign = (b1.toInt() and 0x80) > 0
-        val number = 0x80000000L.or(b1.toLong() shl 24).or(b2.toLong() shl 16).or(b3.toLong() shl 8).or(b4.toLong())
-        val result = number.toDouble() * (2.0).pow(exp) / 0x100000000
-        return if(sign) -result else result
-    }
-}
-
-object Charset {
-    private val normalImg = ImageIO.read(javaClass.getResource("/charset/c64/charset-normal.png"))
-    private val shiftedImg = ImageIO.read(javaClass.getResource("/charset/c64/charset-shifted.png"))
-
-    private fun scanChars(img: BufferedImage): Array<BufferedImage> {
-
-        val transparent = BufferedImage(img.width, img.height, BufferedImage.TYPE_INT_ARGB)
-        transparent.createGraphics().drawImage(img, 0, 0, null)
-
-        val black = Color(0,0,0).rgb
-        val nopixel = Color(0,0,0,0).rgb
-        for(y in 0 until transparent.height) {
-            for(x in 0 until transparent.width) {
-                val col = transparent.getRGB(x, y)
-                if(col==black)
-                    transparent.setRGB(x, y, nopixel)
-            }
-        }
-
-        val numColumns = transparent.width / 8
-        val charImages = (0..255).map {
-            val charX = it % numColumns
-            val charY = it/ numColumns
-            transparent.getSubimage(charX*8, charY*8, 8, 8)
-        }
-        return charImages.toTypedArray()
-    }
-
-    val normalChars = scanChars(normalImg)
-    val shiftedChars = scanChars(shiftedImg)
-
-    private val coloredNormalChars = mutableMapOf<Short, Array<BufferedImage>>()
-
-    fun getColoredChar(screenCode: Short, color: Short): BufferedImage {
-        val colorIdx = (color % Colors.palette.size).toShort()
-        val chars = coloredNormalChars[colorIdx]
-        if(chars!=null)
-            return chars[screenCode.toInt()]
-
-        val coloredChars = mutableListOf<BufferedImage>()
-        val transparent = Color(0,0,0,0).rgb
-        val rgb = Colors.palette[colorIdx.toInt()].rgb
-        for(c in normalChars) {
-            val colored = c.copy()
-            for(y in 0 until colored.height)
-                for(x in 0 until colored.width) {
-                    if(colored.getRGB(x, y)!=transparent) {
-                        colored.setRGB(x, y, rgb)
-                    }
-                }
-            coloredChars.add(colored)
-        }
-        coloredNormalChars[colorIdx] = coloredChars.toTypedArray()
-        return coloredNormalChars.getValue(colorIdx)[screenCode.toInt()]
-    }
-
-}
-
-private fun BufferedImage.copy(): BufferedImage {
-    val bcopy = BufferedImage(this.width, this.height, this.type)
-    val g = bcopy.graphics
-    g.drawImage(this, 0, 0, null)
-    g.dispose()
-    return bcopy
-}
-
-
-object Colors {
-    val palette = listOf(         // this is Pepto's Commodore-64 palette  http://www.pepto.de/projects/colorvic/
-            Color(0x000000),  // 0 = black
-            Color(0xFFFFFF),  // 1 = white
-            Color(0x813338),  // 2 = red
-            Color(0x75cec8),  // 3 = cyan
-            Color(0x8e3c97),  // 4 = purple
-            Color(0x56ac4d),  // 5 = green
-            Color(0x2e2c9b),  // 6 = blue
-            Color(0xedf171),  // 7 = yellow
-            Color(0x8e5029),  // 8 = orange
-            Color(0x553800),  // 9 = brown
-            Color(0xc46c71),  // 10 = light red
-            Color(0x4a4a4a),  // 11 = dark grey
-            Color(0x7b7b7b),  // 12 = medium grey
-            Color(0xa9ff9f),  // 13 = light green
-            Color(0x706deb),  // 14 = light blue
-            Color(0xb2b2b2)   // 15 = light grey
-    )
-}

compiler/src/prog8/compiler/target/c64/MachineDefinition.kt

@@ -0,0 +1,247 @@
+package prog8.compiler.target.c64
+
+import prog8.compiler.*
+import java.awt.Color
+import java.awt.image.BufferedImage
+import javax.imageio.ImageIO
+import kotlin.math.absoluteValue
+import kotlin.math.pow
+
+object MachineDefinition {
+
+    // 5-byte cbm MFLPT format limitations:
+    const val FLOAT_MAX_POSITIVE = 1.7014118345e+38         // bytes: 255,127,255,255,255
+    const val FLOAT_MAX_NEGATIVE = -1.7014118345e+38        // bytes: 255,255,255,255,255
+
+    const val BASIC_LOAD_ADDRESS = 0x0801
+    const val RAW_LOAD_ADDRESS = 0xc000
+
+    // the 2*256 byte evaluation stack (on which bytes, words, and even floats are stored during calculations)
+    // and some heavily used string constants derived from the two values above
+    const val ESTACK_LO_VALUE       = 0xce00        //  $ce00-$ceff inclusive
+    const val ESTACK_HI_VALUE       = 0xcf00        //  $cf00-$cfff inclusive
+    const val ESTACK_LO_HEX         = "\$ce00"
+    const val ESTACK_LO_PLUS1_HEX   = "\$ce01"
+    const val ESTACK_LO_PLUS2_HEX   = "\$ce02"
+    const val ESTACK_HI_HEX         = "\$cf00"
+    const val ESTACK_HI_PLUS1_HEX   = "\$cf01"
+    const val ESTACK_HI_PLUS2_HEX   = "\$cf02"
+
+
+    class C64Zeropage(options: CompilationOptions) : Zeropage(options) {
+
+        companion object {
+            const val SCRATCH_B1 = 0x02
+            const val SCRATCH_REG = 0x03    // temp storage for a register
+            const val SCRATCH_REG_X = 0xfa    // temp storage for register X (the evaluation stack pointer)
+            const val SCRATCH_W1 = 0xfb     // $fb+$fc
+            const val SCRATCH_W2 = 0xfd     // $fd+$fe
+        }
+
+        override val exitProgramStrategy: ExitProgramStrategy = when (options.zeropage) {
+            ZeropageType.BASICSAFE -> ExitProgramStrategy.CLEAN_EXIT
+            ZeropageType.FLOATSAFE, ZeropageType.KERNALSAFE, ZeropageType.FULL -> ExitProgramStrategy.SYSTEM_RESET
+        }
+
+
+        init {
+            if (options.floats && options.zeropage != ZeropageType.FLOATSAFE && options.zeropage != ZeropageType.BASICSAFE)
+                throw CompilerException("when floats are enabled, zero page type should be 'floatsafe' or 'basicsafe'")
+
+            if (options.zeropage == ZeropageType.FULL) {
+                free.addAll(0x04..0xf9)
+                free.add(0xff)
+                free.removeAll(listOf(SCRATCH_B1, SCRATCH_REG, SCRATCH_REG_X, SCRATCH_W1, SCRATCH_W1 + 1, SCRATCH_W2, SCRATCH_W2 + 1))
+                free.removeAll(listOf(0xa0, 0xa1, 0xa2, 0x91, 0xc0, 0xc5, 0xcb, 0xf5, 0xf6))        // these are updated by IRQ
+            } else {
+                if (options.zeropage == ZeropageType.KERNALSAFE || options.zeropage == ZeropageType.FLOATSAFE) {
+                    free.addAll(listOf(0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f, 0x10, 0x11,
+                            0x14, 0x15, 0x16, 0x17, 0x18, 0x19, 0x1a, 0x1b, 0x1c, 0x1d, 0x1e, 0x1f, 0x20, 0x21,
+                            0x22, 0x23, 0x24, 0x25,
+                            0x39, 0x3a, 0x3b, 0x3c, 0x3d, 0x3e, 0x3f, 0x40, 0x41, 0x42, 0x43, 0x44, 0x45, 0x46,
+                            0x47, 0x48, 0x4b, 0x4c, 0x4d, 0x4e, 0x4f, 0x51, 0x52, 0x53,
+                            0x57, 0x58, 0x59, 0x5a, 0x5b, 0x5c, 0x5d, 0x5e, 0x5f, 0x60,
+                            0x61, 0x62, 0x63, 0x64, 0x65, 0x66, 0x67, 0x68,
+                            0x69, 0x6a, 0x6b, 0x6c, 0x6d, 0x6e, 0x6f, 0x70, 0x71, 0x72,
+                            0x73, 0x74, 0x75, 0x76, 0x77, 0x78, 0x79, 0x7a, 0x7b, 0x7c,
+                            0x7d, 0x7e, 0x7f, 0x80, 0x81, 0x82, 0x83, 0x84, 0x85, 0x86, 0x87, 0x88, 0x89, 0x8a,
+                            0x8b, 0x8c, 0x8d, 0x8e, 0x8f, 0xff
+                            // 0x90-0xfa is 'kernel work storage area'
+                    ))
+                }
+
+                if (options.zeropage == ZeropageType.FLOATSAFE) {
+                    // remove the zero page locations used for floating point operations from the free list
+                    free.removeAll(listOf(
+                            0x12, 0x26, 0x27, 0x28, 0x29, 0x2a,
+                            0x57, 0x58, 0x59, 0x5a, 0x5b, 0x5c, 0x5d, 0x5e, 0x5f, 0x60,
+                            0x61, 0x62, 0x63, 0x64, 0x65, 0x66, 0x67, 0x68,
+                            0x69, 0x6a, 0x6b, 0x6c, 0x6d, 0x6e, 0x6f, 0x70, 0x71, 0x72,
+                            0x8b, 0x8c, 0x8d, 0x8e, 0x8f, 0xf
+                    ))
+                }
+
+                // add the other free Zp addresses,
+                // these are valid for the C-64 (when no RS232 I/O is performed) but to keep BASIC running fully:
+                free.addAll(listOf(0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0a, 0x0d, 0x0e,
+                        0x94, 0x95, 0xa7, 0xa8, 0xa9, 0xaa,
+                        0xb5, 0xb6, 0xf7, 0xf8, 0xf9))
+            }
+            assert(SCRATCH_B1 !in free)
+            assert(SCRATCH_REG !in free)
+            assert(SCRATCH_REG_X !in free)
+            assert(SCRATCH_W1 !in free)
+            assert(SCRATCH_W2 !in free)
+
+            for (reserved in options.zpReserved)
+                reserve(reserved)
+        }
+    }
+
+
+    data class Mflpt5(val b0: Short, val b1: Short, val b2: Short, val b3: Short, val b4: Short) {
+
+        companion object {
+            const val MemorySize = 5
+
+            val zero = Mflpt5(0, 0, 0, 0, 0)
+            fun fromNumber(num: Number): Mflpt5 {
+                // see https://en.wikipedia.org/wiki/Microsoft_Binary_Format
+                // and https://sourceforge.net/p/acme-crossass/code-0/62/tree/trunk/ACME_Lib/cbm/mflpt.a
+                // and https://en.wikipedia.org/wiki/IEEE_754-1985
+
+                val flt = num.toDouble()
+                if (flt < FLOAT_MAX_NEGATIVE || flt > FLOAT_MAX_POSITIVE)
+                    throw CompilerException("floating point number out of 5-byte mflpt range: $this")
+                if (flt == 0.0)
+                    return zero
+
+                val sign = if (flt < 0.0) 0x80L else 0x00L
+                var exponent = 128 + 32    // 128 is cbm's bias, 32 is this algo's bias
+                var mantissa = flt.absoluteValue
+
+                // if mantissa is too large, shift right and adjust exponent
+                while (mantissa >= 0x100000000) {
+                    mantissa /= 2.0
+                    exponent++
+                }
+                // if mantissa is too small, shift left and adjust exponent
+                while (mantissa < 0x80000000) {
+                    mantissa *= 2.0
+                    exponent--
+                }
+
+                return when {
+                    exponent < 0 -> zero  // underflow, use zero instead
+                    exponent > 255 -> throw CompilerException("floating point overflow: $this")
+                    exponent == 0 -> zero
+                    else -> {
+                        val mantLong = mantissa.toLong()
+                        Mflpt5(
+                                exponent.toShort(),
+                                (mantLong.and(0x7f000000L) ushr 24).or(sign).toShort(),
+                                (mantLong.and(0x00ff0000L) ushr 16).toShort(),
+                                (mantLong.and(0x0000ff00L) ushr 8).toShort(),
+                                (mantLong.and(0x000000ffL)).toShort())
+                    }
+                }
+            }
+        }
+
+        fun toDouble(): Double {
+            if (this == zero) return 0.0
+            val exp = b0 - 128
+            val sign = (b1.toInt() and 0x80) > 0
+            val number = 0x80000000L.or(b1.toLong() shl 24).or(b2.toLong() shl 16).or(b3.toLong() shl 8).or(b4.toLong())
+            val result = number.toDouble() * (2.0).pow(exp) / 0x100000000
+            return if (sign) -result else result
+        }
+    }
+
+    object Charset {
+        private val normalImg = ImageIO.read(javaClass.getResource("/charset/c64/charset-normal.png"))
+        private val shiftedImg = ImageIO.read(javaClass.getResource("/charset/c64/charset-shifted.png"))
+
+        private fun scanChars(img: BufferedImage): Array<BufferedImage> {
+
+            val transparent = BufferedImage(img.width, img.height, BufferedImage.TYPE_INT_ARGB)
+            transparent.createGraphics().drawImage(img, 0, 0, null)
+
+            val black = Color(0, 0, 0).rgb
+            val nopixel = Color(0, 0, 0, 0).rgb
+            for (y in 0 until transparent.height) {
+                for (x in 0 until transparent.width) {
+                    val col = transparent.getRGB(x, y)
+                    if (col == black)
+                        transparent.setRGB(x, y, nopixel)
+                }
+            }
+
+            val numColumns = transparent.width / 8
+            val charImages = (0..255).map {
+                val charX = it % numColumns
+                val charY = it / numColumns
+                transparent.getSubimage(charX * 8, charY * 8, 8, 8)
+            }
+            return charImages.toTypedArray()
+        }
+
+        val normalChars = scanChars(normalImg)
+        val shiftedChars = scanChars(shiftedImg)
+
+        private val coloredNormalChars = mutableMapOf<Short, Array<BufferedImage>>()
+
+        fun getColoredChar(screenCode: Short, color: Short): BufferedImage {
+            val colorIdx = (color % colorPalette.size).toShort()
+            val chars = coloredNormalChars[colorIdx]
+            if (chars != null)
+                return chars[screenCode.toInt()]
+
+            val coloredChars = mutableListOf<BufferedImage>()
+            val transparent = Color(0, 0, 0, 0).rgb
+            val rgb = colorPalette[colorIdx.toInt()].rgb
+            for (c in normalChars) {
+                val colored = c.copy()
+                for (y in 0 until colored.height)
+                    for (x in 0 until colored.width) {
+                        if (colored.getRGB(x, y) != transparent) {
+                            colored.setRGB(x, y, rgb)
+                        }
+                    }
+                coloredChars.add(colored)
+            }
+            coloredNormalChars[colorIdx] = coloredChars.toTypedArray()
+            return coloredNormalChars.getValue(colorIdx)[screenCode.toInt()]
+        }
+
+    }
+
+    private fun BufferedImage.copy(): BufferedImage {
+        val bcopy = BufferedImage(this.width, this.height, this.type)
+        val g = bcopy.graphics
+        g.drawImage(this, 0, 0, null)
+        g.dispose()
+        return bcopy
+    }
+
+
+    val colorPalette = listOf(         // this is Pepto's Commodore-64 palette  http://www.pepto.de/projects/colorvic/
+            Color(0x000000),  // 0 = black
+            Color(0xFFFFFF),  // 1 = white
+            Color(0x813338),  // 2 = red
+            Color(0x75cec8),  // 3 = cyan
+            Color(0x8e3c97),  // 4 = purple
+            Color(0x56ac4d),  // 5 = green
+            Color(0x2e2c9b),  // 6 = blue
+            Color(0xedf171),  // 7 = yellow
+            Color(0x8e5029),  // 8 = orange
+            Color(0x553800),  // 9 = brown
+            Color(0xc46c71),  // 10 = light red
+            Color(0x4a4a4a),  // 11 = dark grey
+            Color(0x7b7b7b),  // 12 = medium grey
+            Color(0xa9ff9f),  // 13 = light green
+            Color(0x706deb),  // 14 = light blue
+            Color(0xb2b2b2)   // 15 = light grey
+    )
+
+}

compiler/src/prog8/compiler/target/c64/Petscii.kt

@@ -1086,5 +1086,38 @@ class Petscii {
             val decodeTable = if(lowercase) decodingScreencodeLowercase else decodingScreencodeUppercase
             return screencode.map { decodeTable[it.toInt()] }.joinToString("")
         }
+
+        fun petscii2scr(petscii_code: Short, inverseVideo: Boolean): Short {
+            val code = when {
+                petscii_code <= 0x1f -> petscii_code + 128
+                petscii_code <= 0x3f -> petscii_code.toInt()
+                petscii_code <= 0x5f -> petscii_code - 64
+                petscii_code <= 0x7f -> petscii_code - 32
+                petscii_code <= 0x9f -> petscii_code + 64
+                petscii_code <= 0xbf -> petscii_code - 64
+                petscii_code <= 0xfe -> petscii_code - 128
+                petscii_code == 255.toShort() -> 95
+                else -> throw CharConversionException("petscii code out of range")
+            }
+            if(inverseVideo)
+                return (code or 0x80).toShort()
+            return code.toShort()
+        }
+
+        fun scr2petscii(screencode: Short): Short {
+            val petscii = when {
+                screencode <= 0x1f -> screencode + 64
+                screencode <= 0x3f -> screencode.toInt()
+                screencode <= 0x5d -> screencode +123
+                screencode == 0x5e.toShort() -> 255
+                screencode == 0x5f.toShort() -> 223
+                screencode <= 0x7f -> screencode + 64
+                screencode <= 0xbf -> screencode - 128
+                screencode <= 0xfe -> screencode - 64
+                screencode == 255.toShort() -> 191
+                else -> throw CharConversionException("screencode out of range")
+            }
+            return petscii.toShort()
+        }
     }
 }

compiler/src/prog8/compiler/target/c64/SimpleAsm.kt

@@ -0,0 +1,560 @@
+package prog8.compiler.target.c64
+
+import prog8.compiler.CompilerException
+import prog8.compiler.intermediate.Instruction
+import prog8.compiler.intermediate.IntermediateProgram
+import prog8.compiler.intermediate.LabelInstr
+import prog8.compiler.intermediate.Opcode
+import prog8.compiler.toHex
+import prog8.vm.stackvm.Syscall
+import prog8.vm.stackvm.syscallsForStackVm
+import prog8.compiler.target.c64.MachineDefinition.C64Zeropage
+import prog8.compiler.target.c64.MachineDefinition.ESTACK_HI_HEX
+import prog8.compiler.target.c64.MachineDefinition.ESTACK_LO_HEX
+import prog8.compiler.target.c64.MachineDefinition.ESTACK_LO_PLUS1_HEX
+import prog8.compiler.target.c64.MachineDefinition.ESTACK_LO_PLUS2_HEX
+import prog8.compiler.target.c64.MachineDefinition.ESTACK_HI_PLUS1_HEX
+import prog8.compiler.target.c64.MachineDefinition.ESTACK_HI_PLUS2_HEX
+
+
+// note: see https://wiki.nesdev.com/w/index.php/6502_assembly_optimisations
+
+
+private var breakpointCounter = 0
+
+internal fun simpleInstr2Asm(ins: Instruction, block: IntermediateProgram.ProgramBlock): String? {
+    // a label 'instruction' is simply translated into a asm label
+    if(ins is LabelInstr) {
+        val labelresult =
+                if(ins.name.startsWith("${block.name}."))
+                    ins.name.substring(block.name.length+1)
+                else
+                    ins.name
+        return if(ins.asmProc) labelresult+"\t\t.proc" else labelresult
+    }
+
+    // simple opcodes that are translated directly into one or a few asm instructions
+    return when(ins.opcode) {
+        Opcode.LINE -> " ;\tsrc line: ${ins.callLabel}"
+        Opcode.NOP -> " nop"      // shouldn't be present anymore though
+        Opcode.START_PROCDEF -> ""  // is done as part of a label
+        Opcode.END_PROCDEF -> " .pend"
+        Opcode.TERMINATE -> " brk"
+        Opcode.SEC -> " sec"
+        Opcode.CLC -> " clc"
+        Opcode.SEI -> " sei"
+        Opcode.CLI -> " cli"
+        Opcode.CARRY_TO_A -> " lda  #0 |  adc  #0"
+        Opcode.JUMP -> {
+            if(ins.callLabel!=null)
+                " jmp  ${ins.callLabel}"
+            else
+                " jmp  ${hexVal(ins)}"
+        }
+        Opcode.CALL -> {
+            if(ins.callLabel!=null)
+                " jsr  ${ins.callLabel}"
+            else
+                " jsr  ${hexVal(ins)}"
+        }
+        Opcode.RETURN -> " rts"
+        Opcode.RSAVE -> {
+            // save cpu status flag and all registers A, X, Y.
+            // see http://6502.org/tutorials/register_preservation.html
+            " php |  sta  ${C64Zeropage.SCRATCH_REG} | pha  | txa  | pha  | tya  | pha  | lda  ${C64Zeropage.SCRATCH_REG}"
+        }
+        Opcode.RRESTORE -> {
+            // restore all registers and cpu status flag
+            " pla |  tay |  pla |  tax |  pla |  plp"
+        }
+        Opcode.RSAVEX -> " sta  ${C64Zeropage.SCRATCH_REG} |  txa |  pha |  lda  ${C64Zeropage.SCRATCH_REG}"
+        Opcode.RRESTOREX -> " sta  ${C64Zeropage.SCRATCH_REG} |  pla |  tax |  lda  ${C64Zeropage.SCRATCH_REG}"
+        Opcode.DISCARD_BYTE -> " inx"
+        Opcode.DISCARD_WORD -> " inx"
+        Opcode.DISCARD_FLOAT -> " inx |  inx |  inx"
+        Opcode.DUP_B -> {
+            " lda $ESTACK_LO_PLUS1_HEX,x | sta $ESTACK_LO_HEX,x | dex | ;DUP_B "
+        }
+        Opcode.DUP_W -> {
+            " lda $ESTACK_LO_PLUS1_HEX,x | sta $ESTACK_LO_HEX,x | lda $ESTACK_HI_PLUS1_HEX,x | sta $ESTACK_HI_HEX,x | dex "
+        }
+
+        Opcode.CMP_B, Opcode.CMP_UB -> {
+            " inx | lda $ESTACK_LO_HEX,x | cmp #${ins.arg!!.integerValue().toHex()} | ;CMP_B "
+        }
+
+        Opcode.CMP_W, Opcode.CMP_UW -> {
+            """
+            inx
+            lda   $ESTACK_HI_HEX,x
+            cmp   #>${ins.arg!!.integerValue().toHex()}
+            bne   +
+            lda   $ESTACK_LO_HEX,x
+            cmp   #<${ins.arg.integerValue().toHex()}
+            ; bne   +    not necessary?
+            ; lda   #0   not necessary?
++                           
+            """
+        }
+
+        Opcode.INLINE_ASSEMBLY ->  "@inline@" + (ins.callLabel2 ?: "")      // All of the inline assembly is stored in the calllabel2 property. the '@inline@' is a special marker to accept it.
+        Opcode.INCLUDE_FILE -> {
+            val offset = if(ins.arg==null) "" else ", ${ins.arg.integerValue()}"
+            val length = if(ins.arg2==null) "" else ", ${ins.arg2.integerValue()}"
+            " .binary  \"${ins.callLabel}\" $offset $length"
+        }
+        Opcode.SYSCALL -> {
+            if (ins.arg!!.numericValue() in syscallsForStackVm.map { it.callNr })
+                throw CompilerException("cannot translate vm syscalls to real assembly calls - use *real* subroutine calls instead. Syscall ${ins.arg.numericValue()}")
+            val call = Syscall.values().find { it.callNr==ins.arg.numericValue() }
+            when(call) {
+                Syscall.FUNC_SIN,
+                Syscall.FUNC_COS,
+                Syscall.FUNC_ABS,
+                Syscall.FUNC_TAN,
+                Syscall.FUNC_ATAN,
+                Syscall.FUNC_LN,
+                Syscall.FUNC_LOG2,
+                Syscall.FUNC_SQRT,
+                Syscall.FUNC_RAD,
+                Syscall.FUNC_DEG,
+                Syscall.FUNC_ROUND,
+                Syscall.FUNC_FLOOR,
+                Syscall.FUNC_CEIL,
+                Syscall.FUNC_RNDF,
+                Syscall.FUNC_ANY_F,
+                Syscall.FUNC_ALL_F,
+                Syscall.FUNC_MAX_F,
+                Syscall.FUNC_MIN_F,
+                Syscall.FUNC_SUM_F -> " jsr  c64flt.${call.name.toLowerCase()}"
+                null -> ""
+                else -> " jsr  prog8_lib.${call.name.toLowerCase()}"
+            }
+        }
+        Opcode.BREAKPOINT -> {
+            breakpointCounter++
+            "_prog8_breakpoint_$breakpointCounter\tnop"
+        }
+
+        Opcode.PUSH_BYTE -> {
+            " lda  #${hexVal(ins)} |  sta  $ESTACK_LO_HEX,x |  dex"
+        }
+        Opcode.PUSH_WORD -> {
+            val value = hexVal(ins)
+            " lda  #<$value |  sta  $ESTACK_LO_HEX,x |  lda  #>$value |  sta  $ESTACK_HI_HEX,x |  dex"
+        }
+        Opcode.PUSH_FLOAT -> {
+            val floatConst = getFloatConst(ins.arg!!)
+            " lda  #<$floatConst |  ldy  #>$floatConst |  jsr  c64flt.push_float"
+        }
+        Opcode.PUSH_VAR_BYTE -> {
+            when(ins.callLabel) {
+                "X" -> throw CompilerException("makes no sense to push X, it's used as a stack pointer itself. You should probably not use the X register (or only in trivial assignments)")
+                "A" -> " sta  $ESTACK_LO_HEX,x |  dex"
+                "Y" -> " tya |  sta  $ESTACK_LO_HEX,x |  dex"
+                else -> " lda  ${ins.callLabel} |  sta  $ESTACK_LO_HEX,x |  dex"
+            }
+        }
+        Opcode.PUSH_VAR_WORD -> {
+            " lda  ${ins.callLabel} |  sta  $ESTACK_LO_HEX,x |  lda  ${ins.callLabel}+1 |    sta  $ESTACK_HI_HEX,x |  dex"
+        }
+        Opcode.PUSH_VAR_FLOAT -> " lda  #<${ins.callLabel} |  ldy  #>${ins.callLabel}|  jsr  c64flt.push_float"
+        Opcode.PUSH_MEM_B, Opcode.PUSH_MEM_UB -> {
+            """
+                lda  ${hexVal(ins)}
+                sta  $ESTACK_LO_HEX,x
+                dex
+                """
+        }
+        Opcode.PUSH_MEM_W, Opcode.PUSH_MEM_UW -> {
+            """
+                lda  ${hexVal(ins)}
+                sta  $ESTACK_LO_HEX,x
+                lda  ${hexValPlusOne(ins)}
+                sta  $ESTACK_HI_HEX,x
+                dex
+                """
+        }
+        Opcode.PUSH_MEM_FLOAT -> {
+            " lda  #<${hexVal(ins)} |  ldy  #>${hexVal(ins)}|  jsr  c64flt.push_float"
+        }
+        Opcode.PUSH_MEMREAD -> {
+            """
+                lda  $ESTACK_LO_PLUS1_HEX,x
+                sta  (+) +1
+                lda  $ESTACK_HI_PLUS1_HEX,x
+                sta  (+) +2
++               lda  65535    ; modified
+                sta  $ESTACK_LO_PLUS1_HEX,x
+                """
+        }
+
+        Opcode.PUSH_REGAY_WORD -> {
+            " sta  $ESTACK_LO_HEX,x |  tya |  sta  $ESTACK_HI_HEX,x |  dex "
+        }
+        Opcode.PUSH_ADDR_HEAPVAR -> {
+            " lda  #<${ins.callLabel} |  sta  $ESTACK_LO_HEX,x |  lda  #>${ins.callLabel}  |  sta  $ESTACK_HI_HEX,x |  dex"
+        }
+        Opcode.POP_REGAX_WORD -> throw AssemblyError("cannot load X register from stack because it's used as the stack pointer itself")
+        Opcode.POP_REGXY_WORD -> throw AssemblyError("cannot load X register from stack because it's used as the stack pointer itself")
+        Opcode.POP_REGAY_WORD -> {
+            " inx |  lda  $ESTACK_LO_HEX,x |  ldy  $ESTACK_HI_HEX,x "
+        }
+
+        Opcode.READ_INDEXED_VAR_BYTE -> {
+            """
+                ldy  $ESTACK_LO_PLUS1_HEX,x
+                lda  ${ins.callLabel},y
+                sta  $ESTACK_LO_PLUS1_HEX,x
+                """
+        }
+        Opcode.READ_INDEXED_VAR_WORD -> {
+            """
+                lda  $ESTACK_LO_PLUS1_HEX,x
+                asl  a
+                tay
+                lda  ${ins.callLabel},y
+                sta  $ESTACK_LO_PLUS1_HEX,x
+                lda  ${ins.callLabel}+1,y
+                sta  $ESTACK_HI_PLUS1_HEX,x
+                """
+        }
+        Opcode.READ_INDEXED_VAR_FLOAT -> {
+            """
+                lda  #<${ins.callLabel}
+                ldy  #>${ins.callLabel}
+                jsr  c64flt.push_float_from_indexed_var
+                """
+        }
+        Opcode.WRITE_INDEXED_VAR_BYTE -> {
+            """
+                inx
+                ldy  $ESTACK_LO_HEX,x
+                inx
+                lda  $ESTACK_LO_HEX,x
+                sta  ${ins.callLabel},y
+                """
+        }
+        Opcode.WRITE_INDEXED_VAR_WORD -> {
+            """
+                inx
+                lda  $ESTACK_LO_HEX,x
+                asl  a
+                tay
+                inx
+                lda  $ESTACK_LO_HEX,x
+                sta  ${ins.callLabel},y
+                lda  $ESTACK_HI_HEX,x
+                sta  ${ins.callLabel}+1,y
+                """
+        }
+        Opcode.WRITE_INDEXED_VAR_FLOAT -> {
+            """
+                lda  #<${ins.callLabel}
+                ldy  #>${ins.callLabel}
+                jsr  c64flt.pop_float_to_indexed_var
+                """
+        }
+        Opcode.POP_MEM_BYTE -> {
+            """
+                inx
+                lda  $ESTACK_LO_HEX,x
+                sta  ${hexVal(ins)}
+                """
+        }
+        Opcode.POP_MEM_WORD -> {
+            """
+                inx
+                lda  $ESTACK_LO_HEX,x
+                sta  ${hexVal(ins)}
+                lda  $ESTACK_HI_HEX,x
+                sta  ${hexValPlusOne(ins)}
+                """
+        }
+        Opcode.POP_MEM_FLOAT -> {
+            " lda  ${hexVal(ins)} |  ldy  ${hexValPlusOne(ins)} |  jsr  c64flt.pop_float"
+        }
+        Opcode.POP_MEMWRITE -> {
+            """
+                inx
+                lda  $ESTACK_LO_HEX,x
+                sta  (+) +1
+                lda  $ESTACK_HI_HEX,x
+                sta  (+) +2
+                inx
+                lda  $ESTACK_LO_HEX,x
++               sta  65535       ; modified
+                """
+        }
+
+        Opcode.POP_VAR_BYTE -> {
+            when (ins.callLabel) {
+                "X" -> throw CompilerException("makes no sense to pop X, it's used as a stack pointer itself")
+                "A" -> " inx |  lda  $ESTACK_LO_HEX,x"
+                "Y" -> " inx |  ldy  $ESTACK_LO_HEX,x"
+                else -> " inx |  lda  $ESTACK_LO_HEX,x |  sta  ${ins.callLabel}"
+            }
+        }
+        Opcode.POP_VAR_WORD -> {
+            " inx |  lda  $ESTACK_LO_HEX,x |  ldy  $ESTACK_HI_HEX,x |  sta  ${ins.callLabel} |  sty  ${ins.callLabel}+1"
+        }
+        Opcode.POP_VAR_FLOAT -> {
+            " lda  #<${ins.callLabel} |  ldy  #>${ins.callLabel} |  jsr  c64flt.pop_float"
+        }
+
+        Opcode.INC_VAR_UB, Opcode.INC_VAR_B -> {
+            when (ins.callLabel) {
+                "A" -> " clc |  adc  #1"
+                "X" -> " inx"
+                "Y" -> " iny"
+                else -> " inc  ${ins.callLabel}"
+            }
+        }
+        Opcode.INC_VAR_UW, Opcode.INC_VAR_W -> {
+            " inc  ${ins.callLabel} |  bne  + |  inc  ${ins.callLabel}+1 |+"
+        }
+        Opcode.INC_VAR_F -> {
+            """
+                lda  #<${ins.callLabel}
+                ldy  #>${ins.callLabel}
+                jsr  c64flt.inc_var_f
+                """
+        }
+        Opcode.POP_INC_MEMORY -> {
+            """
+                inx
+                lda  $ESTACK_LO_HEX,x
+                sta  (+) +1
+                lda  $ESTACK_HI_HEX,x
+                sta  (+) +2
++               inc  65535     ; modified
+                """
+        }
+        Opcode.POP_DEC_MEMORY -> {
+            """
+                inx
+                lda  $ESTACK_LO_HEX,x
+                sta  (+) +1
+                lda  $ESTACK_HI_HEX,x
+                sta  (+) +2
++               dec  65535     ; modified
+                """
+        }
+        Opcode.DEC_VAR_UB, Opcode.DEC_VAR_B -> {
+            when (ins.callLabel) {
+                "A" -> " sec |  sbc  #1"
+                "X" -> " dex"
+                "Y" -> " dey"
+                else -> " dec  ${ins.callLabel}"
+            }
+        }
+        Opcode.DEC_VAR_UW, Opcode.DEC_VAR_W -> {
+            " lda  ${ins.callLabel} |  bne  + |  dec  ${ins.callLabel}+1 |+ |  dec  ${ins.callLabel}"
+        }
+        Opcode.DEC_VAR_F -> {
+            """
+                lda  #<${ins.callLabel}
+                ldy  #>${ins.callLabel}
+                jsr  c64flt.dec_var_f
+                """
+        }
+        Opcode.INC_MEMORY -> " inc  ${hexVal(ins)}"
+        Opcode.DEC_MEMORY -> " dec  ${hexVal(ins)}"
+        Opcode.INC_INDEXED_VAR_B, Opcode.INC_INDEXED_VAR_UB -> " inx |  txa |  pha |  lda  $ESTACK_LO_HEX,x |  tax |  inc  ${ins.callLabel},x |  pla |  tax"
+        Opcode.DEC_INDEXED_VAR_B, Opcode.DEC_INDEXED_VAR_UB -> " inx |  txa |  pha |  lda  $ESTACK_LO_HEX,x |  tax |  dec  ${ins.callLabel},x |  pla |  tax"
+
+        Opcode.NEG_B -> " jsr  prog8_lib.neg_b"
+        Opcode.NEG_W -> " jsr  prog8_lib.neg_w"
+        Opcode.NEG_F -> " jsr  c64flt.neg_f"
+        Opcode.ABS_B -> " jsr  prog8_lib.abs_b"
+        Opcode.ABS_W -> " jsr  prog8_lib.abs_w"
+        Opcode.ABS_F -> " jsr  c64flt.abs_f"
+        Opcode.POW_F -> " jsr  c64flt.pow_f"
+        Opcode.INV_BYTE -> {
+            """
+                lda  $ESTACK_LO_PLUS1_HEX,x
+                eor  #255
+                sta  $ESTACK_LO_PLUS1_HEX,x
+                """
+        }
+        Opcode.INV_WORD -> " jsr  prog8_lib.inv_word"
+        Opcode.NOT_BYTE -> " jsr  prog8_lib.not_byte"
+        Opcode.NOT_WORD -> " jsr  prog8_lib.not_word"
+        Opcode.BCS -> {
+            val label = ins.callLabel ?: hexVal(ins)
+            " bcs  $label"
+        }
+        Opcode.BCC -> {
+            val label = ins.callLabel ?: hexVal(ins)
+            " bcc  $label"
+        }
+        Opcode.BNEG -> {
+            val label = ins.callLabel ?: hexVal(ins)
+            " bmi  $label"
+        }
+        Opcode.BPOS -> {
+            val label = ins.callLabel ?: hexVal(ins)
+            " bpl  $label"
+        }
+        Opcode.BVC -> {
+            val label = ins.callLabel ?: hexVal(ins)
+            " bvc  $label"
+        }
+        Opcode.BVS -> {
+            val label = ins.callLabel ?: hexVal(ins)
+            " bvs  $label"
+        }
+        Opcode.BZ -> {
+            val label = ins.callLabel ?: hexVal(ins)
+            " beq  $label"
+        }
+        Opcode.BNZ -> {
+            val label = ins.callLabel ?: hexVal(ins)
+            " bne  $label"
+        }
+        Opcode.JZ -> {
+            val label = ins.callLabel ?: hexVal(ins)
+            """
+                inx
+                lda  $ESTACK_LO_HEX,x
+                beq  $label
+                """
+        }
+        Opcode.JZW -> {
+            val label = ins.callLabel ?: hexVal(ins)
+            """
+                inx
+                lda  $ESTACK_LO_HEX,x
+                beq  $label
+                lda  $ESTACK_HI_HEX,x
+                beq  $label
+                """
+        }
+        Opcode.JNZ -> {
+            val label = ins.callLabel ?: hexVal(ins)
+            """
+                inx
+                lda  $ESTACK_LO_HEX,x
+                bne  $label
+                """
+        }
+        Opcode.JNZW -> {
+            val label = ins.callLabel ?: hexVal(ins)
+            """
+                inx
+                lda  $ESTACK_LO_HEX,x
+                bne  $label
+                lda  $ESTACK_HI_HEX,x
+                bne  $label
+                """
+        }
+        Opcode.CAST_B_TO_UB -> ""  // is a no-op, just carry on with the byte as-is
+        Opcode.CAST_UB_TO_B -> ""  // is a no-op, just carry on with the byte as-is
+        Opcode.CAST_W_TO_UW -> ""  // is a no-op, just carry on with the word as-is
+        Opcode.CAST_UW_TO_W -> ""  // is a no-op, just carry on with the word as-is
+        Opcode.CAST_W_TO_UB -> ""  // is a no-op, just carry on with the lsb of the word as-is
+        Opcode.CAST_W_TO_B -> ""  // is a no-op, just carry on with the lsb of the word as-is
+        Opcode.CAST_UW_TO_UB -> ""  // is a no-op, just carry on with the lsb of the uword as-is
+        Opcode.CAST_UW_TO_B -> ""  // is a no-op, just carry on with the lsb of the uword as-is
+        Opcode.CAST_UB_TO_F -> " jsr  c64flt.stack_ub2float"
+        Opcode.CAST_B_TO_F -> " jsr  c64flt.stack_b2float"
+        Opcode.CAST_UW_TO_F -> " jsr  c64flt.stack_uw2float"
+        Opcode.CAST_W_TO_F -> " jsr  c64flt.stack_w2float"
+        Opcode.CAST_F_TO_UB -> " jsr  c64flt.stack_float2uw"
+        Opcode.CAST_F_TO_B -> " jsr  c64flt.stack_float2w"
+        Opcode.CAST_F_TO_UW -> " jsr  c64flt.stack_float2uw"
+        Opcode.CAST_F_TO_W -> " jsr  c64flt.stack_float2w"
+        Opcode.CAST_UB_TO_UW, Opcode.CAST_UB_TO_W -> " lda  #0 |  sta  $ESTACK_HI_PLUS1_HEX,x"     // clear the msb
+        Opcode.CAST_B_TO_UW, Opcode.CAST_B_TO_W -> " lda  $ESTACK_LO_PLUS1_HEX,x |  ${signExtendA("$ESTACK_HI_PLUS1_HEX,x")}"     // sign extend the lsb
+        Opcode.MSB -> " lda  $ESTACK_HI_PLUS1_HEX,x |  sta  $ESTACK_LO_PLUS1_HEX,x"
+        Opcode.MKWORD -> " inx |  lda  $ESTACK_LO_HEX,x |  sta  $ESTACK_HI_PLUS1_HEX,x "
+
+        Opcode.ADD_UB, Opcode.ADD_B -> {        // TODO inline better (pattern with more opcodes)
+            """
+                lda  $ESTACK_LO_PLUS2_HEX,x
+                clc
+                adc  $ESTACK_LO_PLUS1_HEX,x
+                inx
+                sta  $ESTACK_LO_PLUS1_HEX,x
+                """
+        }
+        Opcode.SUB_UB, Opcode.SUB_B -> {        // TODO inline better (pattern with more opcodes)
+            """
+                lda  $ESTACK_LO_PLUS2_HEX,x
+                sec
+                sbc  $ESTACK_LO_PLUS1_HEX,x
+                inx
+                sta  $ESTACK_LO_PLUS1_HEX,x
+                """
+        }
+        Opcode.ADD_W, Opcode.ADD_UW -> "  jsr  prog8_lib.add_w"
+        Opcode.SUB_W, Opcode.SUB_UW -> "  jsr  prog8_lib.sub_w"
+        Opcode.MUL_B, Opcode.MUL_UB -> "  jsr  prog8_lib.mul_byte"
+        Opcode.MUL_W, Opcode.MUL_UW -> "  jsr  prog8_lib.mul_word"
+        Opcode.MUL_F -> "  jsr  c64flt.mul_f"
+        Opcode.ADD_F -> "  jsr  c64flt.add_f"
+        Opcode.SUB_F -> "  jsr  c64flt.sub_f"
+        Opcode.DIV_F -> "  jsr  c64flt.div_f"
+        Opcode.IDIV_UB -> "  jsr  prog8_lib.idiv_ub"
+        Opcode.IDIV_B -> "  jsr  prog8_lib.idiv_b"
+        Opcode.IDIV_W -> "  jsr  prog8_lib.idiv_w"
+        Opcode.IDIV_UW -> "  jsr  prog8_lib.idiv_uw"
+
+        Opcode.AND_BYTE -> "  jsr  prog8_lib.and_b"
+        Opcode.OR_BYTE -> "  jsr  prog8_lib.or_b"
+        Opcode.XOR_BYTE -> "  jsr  prog8_lib.xor_b"
+        Opcode.AND_WORD -> "  jsr  prog8_lib.and_w"
+        Opcode.OR_WORD -> "  jsr  prog8_lib.or_w"
+        Opcode.XOR_WORD -> "  jsr  prog8_lib.xor_w"
+
+        Opcode.BITAND_BYTE -> "  jsr  prog8_lib.bitand_b"
+        Opcode.BITOR_BYTE -> "  jsr  prog8_lib.bitor_b"
+        Opcode.BITXOR_BYTE -> "  jsr  prog8_lib.bitxor_b"
+        Opcode.BITAND_WORD -> "  jsr  prog8_lib.bitand_w"
+        Opcode.BITOR_WORD -> "  jsr  prog8_lib.bitor_w"
+        Opcode.BITXOR_WORD -> "  jsr  prog8_lib.bitxor_w"
+
+        Opcode.REMAINDER_UB -> "  jsr prog8_lib.remainder_ub"
+        Opcode.REMAINDER_UW -> "  jsr prog8_lib.remainder_uw"
+
+        Opcode.GREATER_B -> "  jsr prog8_lib.greater_b"
+        Opcode.GREATER_UB -> "  jsr prog8_lib.greater_ub"
+        Opcode.GREATER_W -> "  jsr prog8_lib.greater_w"
+        Opcode.GREATER_UW -> "  jsr prog8_lib.greater_uw"
+        Opcode.GREATER_F -> "  jsr c64flt.greater_f"
+
+        Opcode.GREATEREQ_B -> "  jsr prog8_lib.greatereq_b"
+        Opcode.GREATEREQ_UB -> "  jsr prog8_lib.greatereq_ub"
+        Opcode.GREATEREQ_W -> "  jsr prog8_lib.greatereq_w"
+        Opcode.GREATEREQ_UW -> "  jsr prog8_lib.greatereq_uw"
+        Opcode.GREATEREQ_F -> "  jsr c64flt.greatereq_f"
+
+        Opcode.EQUAL_BYTE -> "  jsr prog8_lib.equal_b"
+        Opcode.EQUAL_WORD -> "  jsr prog8_lib.equal_w"
+        Opcode.EQUAL_F -> "  jsr c64flt.equal_f"
+        Opcode.NOTEQUAL_BYTE -> "  jsr prog8_lib.notequal_b"
+        Opcode.NOTEQUAL_WORD -> "  jsr prog8_lib.notequal_w"
+        Opcode.NOTEQUAL_F -> "  jsr c64flt.notequal_f"
+
+        Opcode.LESS_UB -> "  jsr  prog8_lib.less_ub"
+        Opcode.LESS_B -> "  jsr  prog8_lib.less_b"
+        Opcode.LESS_UW -> "  jsr  prog8_lib.less_uw"
+        Opcode.LESS_W -> "  jsr  prog8_lib.less_w"
+        Opcode.LESS_F -> "  jsr  c64flt.less_f"
+
+        Opcode.LESSEQ_UB -> "  jsr  prog8_lib.lesseq_ub"
+        Opcode.LESSEQ_B -> "  jsr  prog8_lib.lesseq_b"
+        Opcode.LESSEQ_UW -> "  jsr  prog8_lib.lesseq_uw"
+        Opcode.LESSEQ_W -> "  jsr  prog8_lib.lesseq_w"
+        Opcode.LESSEQ_F -> "  jsr  c64flt.lesseq_f"
+
+        Opcode.SHIFTEDL_BYTE -> "  asl  $ESTACK_LO_PLUS1_HEX,x"
+        Opcode.SHIFTEDL_WORD -> "  asl  $ESTACK_LO_PLUS1_HEX,x |  rol  $ESTACK_HI_PLUS1_HEX,x"
+        Opcode.SHIFTEDR_SBYTE -> "  lda  $ESTACK_LO_PLUS1_HEX,x |  asl  a |  ror  $ESTACK_LO_PLUS1_HEX,x"
+        Opcode.SHIFTEDR_UBYTE -> "  lsr  $ESTACK_LO_PLUS1_HEX,x"
+        Opcode.SHIFTEDR_SWORD -> "  lda  $ESTACK_HI_PLUS1_HEX,x |  asl a  |  ror  $ESTACK_HI_PLUS1_HEX,x |  ror  $ESTACK_LO_PLUS1_HEX,x"
+        Opcode.SHIFTEDR_UWORD -> "  lsr  $ESTACK_HI_PLUS1_HEX,x |  ror  $ESTACK_LO_PLUS1_HEX,x"
+
+        else -> null
+    }
+}

compiler/src/prog8/functions/BuiltinFunctions.kt

@@ -1,16 +1,25 @@
 package prog8.functions
 
 import prog8.ast.*
+import prog8.ast.base.*
+import prog8.ast.expressions.DirectMemoryRead
+import prog8.ast.expressions.IdentifierReference
+import prog8.ast.expressions.LiteralValue
+import prog8.ast.statements.VarDecl
 import prog8.compiler.CompilerException
 import kotlin.math.*
 
 
 class BuiltinFunctionParam(val name: String, val possibleDatatypes: Set<DataType>)
 
+
+typealias ConstExpressionCaller = (args: List<IExpression>, position: Position, program: Program) -> LiteralValue
+
+
 class FunctionSignature(val pure: Boolean,      // does it have side effects?
                         val parameters: List<BuiltinFunctionParam>,
                         val returntype: DataType?,
-                        val constExpressionFunc: ((args: List<IExpression>, position: Position, program: Program) -> LiteralValue)? = null)
+                        val constExpressionFunc: ConstExpressionCaller? = null)
 
 
 val BuiltinFunctions = mapOf(
@@ -111,19 +120,18 @@ fun builtinFunctionReturnType(function: String, args: List<IExpression>, program
 
     fun datatypeFromIterableArg(arglist: IExpression): DataType {
         if(arglist is LiteralValue) {
-            if(arglist.type==DataType.ARRAY_UB || arglist.type==DataType.ARRAY_UW || arglist.type==DataType.ARRAY_F) {
+            if(arglist.type== DataType.ARRAY_UB || arglist.type== DataType.ARRAY_UW || arglist.type== DataType.ARRAY_F) {
                 val dt = arglist.arrayvalue!!.map {it.inferType(program)}
-                if(dt.any { it!=DataType.UBYTE && it!=DataType.UWORD && it!=DataType.FLOAT}) {
+                if(dt.any { it!= DataType.UBYTE && it!= DataType.UWORD && it!= DataType.FLOAT}) {
                     throw FatalAstException("fuction $function only accepts arraysize of numeric values")
                 }
-                if(dt.any { it==DataType.FLOAT }) return DataType.FLOAT
-                if(dt.any { it==DataType.UWORD }) return DataType.UWORD
+                if(dt.any { it== DataType.FLOAT }) return DataType.FLOAT
+                if(dt.any { it== DataType.UWORD }) return DataType.UWORD
                 return DataType.UBYTE
             }
         }
         if(arglist is IdentifierReference) {
-            val dt = arglist.inferType(program)
-            return when(dt) {
+            return when(val dt = arglist.inferType(program)) {
                 in NumericDatatypes -> dt!!
                 in StringDatatypes -> dt!!
                 in ArrayDatatypes -> ArrayElementTypes.getValue(dt!!)
@@ -140,8 +148,7 @@ fun builtinFunctionReturnType(function: String, args: List<IExpression>, program
 
     return when (function) {
         "abs" -> {
-            val dt = args.single().inferType(program)
-            when(dt) {
+            when(val dt = args.single().inferType(program)) {
                 in ByteDatatypes -> DataType.UBYTE
                 in WordDatatypes -> DataType.UWORD
                 DataType.FLOAT -> DataType.FLOAT
@@ -149,8 +156,7 @@ fun builtinFunctionReturnType(function: String, args: List<IExpression>, program
             }
         }
         "max", "min" -> {
-            val dt = datatypeFromIterableArg(args.single())
-            when(dt) {
+            when(val dt = datatypeFromIterableArg(args.single())) {
                 in NumericDatatypes -> dt
                 in StringDatatypes -> DataType.UBYTE
                 in ArrayDatatypes -> ArrayElementTypes.getValue(dt)
@@ -186,27 +192,28 @@ private fun oneDoubleArg(args: List<IExpression>, position: Position, program: P
     if(args.size!=1)
         throw SyntaxError("built-in function requires one floating point argument", position)
     val constval = args[0].constValue(program) ?: throw NotConstArgumentException()
-    if(constval.type!=DataType.FLOAT)
-        throw SyntaxError("built-in function requires one floating point argument", position)
-
-    val float = constval.asNumericValue?.toDouble()!!
+    val float = getFloatArg(constval, args[0].position)
     return numericLiteral(function(float), args[0].position)
 }
 
+private fun getFloatArg(v: LiteralValue, position: Position): Double {
+    val nv = v.asNumericValue ?: throw SyntaxError("numerical argument required", position)
+    return nv.toDouble()
+}
+
 private fun oneDoubleArgOutputWord(args: List<IExpression>, position: Position, program: Program, function: (arg: Double)->Number): LiteralValue {
     if(args.size!=1)
         throw SyntaxError("built-in function requires one floating point argument", position)
     val constval = args[0].constValue(program) ?: throw NotConstArgumentException()
-    if(constval.type!=DataType.FLOAT)
-        throw SyntaxError("built-in function requires one floating point argument", position)
-    return LiteralValue(DataType.WORD, wordvalue=function(constval.asNumericValue!!.toDouble()).toInt(), position=args[0].position)
+    val float = getFloatArg(constval, args[0].position)
+    return LiteralValue(DataType.WORD, wordvalue = function(float).toInt(), position = args[0].position)
 }
 
 private fun oneIntArgOutputInt(args: List<IExpression>, position: Position, program: Program, function: (arg: Int)->Number): LiteralValue {
     if(args.size!=1)
         throw SyntaxError("built-in function requires one integer argument", position)
     val constval = args[0].constValue(program) ?: throw NotConstArgumentException()
-    if(constval.type!=DataType.UBYTE && constval.type!=DataType.UWORD)
+    if(constval.type!= DataType.UBYTE && constval.type!= DataType.UWORD)
         throw SyntaxError("built-in function requires one integer argument", position)
 
     val integer = constval.asNumericValue?.toInt()!!
@@ -273,8 +280,7 @@ private fun builtinAbs(args: List<IExpression>, position: Position, program: Pro
         throw SyntaxError("abs requires one numeric argument", position)
 
     val constval = args[0].constValue(program) ?: throw NotConstArgumentException()
-    val number = constval.asNumericValue
-    return when (number) {
+    return when (val number = constval.asNumericValue) {
         is Int, is Byte, is Short -> numericLiteral(abs(number.toInt()), args[0].position)
         is Double -> numericLiteral(abs(number.toDouble()), args[0].position)
         else -> throw SyntaxError("abs requires one numeric argument", position)
@@ -378,7 +384,7 @@ private fun builtinSin8(args: List<IExpression>, position: Position, program: Pr
         throw SyntaxError("sin8 requires one argument", position)
     val constval = args[0].constValue(program) ?: throw NotConstArgumentException()
     val rad = constval.asNumericValue!!.toDouble() /256.0 * 2.0 * PI
-    return LiteralValue(DataType.BYTE, bytevalue = (127.0* sin(rad)).toShort(), position = position)
+    return LiteralValue(DataType.BYTE, bytevalue = (127.0 * sin(rad)).toShort(), position = position)
 }
 
 private fun builtinSin8u(args: List<IExpression>, position: Position, program: Program): LiteralValue {
@@ -386,7 +392,7 @@ private fun builtinSin8u(args: List<IExpression>, position: Position, program: P
         throw SyntaxError("sin8u requires one argument", position)
     val constval = args[0].constValue(program) ?: throw NotConstArgumentException()
     val rad = constval.asNumericValue!!.toDouble() /256.0 * 2.0 * PI
-    return LiteralValue(DataType.UBYTE, bytevalue = (128.0+127.5*sin(rad)).toShort(), position = position)
+    return LiteralValue(DataType.UBYTE, bytevalue = (128.0 + 127.5 * sin(rad)).toShort(), position = position)
 }
 
 private fun builtinCos8(args: List<IExpression>, position: Position, program: Program): LiteralValue {
@@ -394,7 +400,7 @@ private fun builtinCos8(args: List<IExpression>, position: Position, program: Pr
         throw SyntaxError("cos8 requires one argument", position)
     val constval = args[0].constValue(program) ?: throw NotConstArgumentException()
     val rad = constval.asNumericValue!!.toDouble() /256.0 * 2.0 * PI
-    return LiteralValue(DataType.BYTE, bytevalue = (127.0* cos(rad)).toShort(), position = position)
+    return LiteralValue(DataType.BYTE, bytevalue = (127.0 * cos(rad)).toShort(), position = position)
 }
 
 private fun builtinCos8u(args: List<IExpression>, position: Position, program: Program): LiteralValue {
@@ -402,7 +408,7 @@ private fun builtinCos8u(args: List<IExpression>, position: Position, program: P
         throw SyntaxError("cos8u requires one argument", position)
     val constval = args[0].constValue(program) ?: throw NotConstArgumentException()
     val rad = constval.asNumericValue!!.toDouble() /256.0 * 2.0 * PI
-    return LiteralValue(DataType.UBYTE, bytevalue = (128.0 + 127.5*cos(rad)).toShort(), position = position)
+    return LiteralValue(DataType.UBYTE, bytevalue = (128.0 + 127.5 * cos(rad)).toShort(), position = position)
 }
 
 private fun builtinSin16(args: List<IExpression>, position: Position, program: Program): LiteralValue {
@@ -410,7 +416,7 @@ private fun builtinSin16(args: List<IExpression>, position: Position, program: P
         throw SyntaxError("sin16 requires one argument", position)
     val constval = args[0].constValue(program) ?: throw NotConstArgumentException()
     val rad = constval.asNumericValue!!.toDouble() /256.0 * 2.0 * PI
-    return LiteralValue(DataType.WORD, wordvalue = (32767.0* sin(rad)).toInt(), position = position)
+    return LiteralValue(DataType.WORD, wordvalue = (32767.0 * sin(rad)).toInt(), position = position)
 }
 
 private fun builtinSin16u(args: List<IExpression>, position: Position, program: Program): LiteralValue {
@@ -418,7 +424,7 @@ private fun builtinSin16u(args: List<IExpression>, position: Position, program:
         throw SyntaxError("sin16u requires one argument", position)
     val constval = args[0].constValue(program) ?: throw NotConstArgumentException()
     val rad = constval.asNumericValue!!.toDouble() /256.0 * 2.0 * PI
-    return LiteralValue(DataType.UWORD, wordvalue = (32768.0+32767.5*sin(rad)).toInt(), position = position)
+    return LiteralValue(DataType.UWORD, wordvalue = (32768.0 + 32767.5 * sin(rad)).toInt(), position = position)
 }
 
 private fun builtinCos16(args: List<IExpression>, position: Position, program: Program): LiteralValue {
@@ -426,7 +432,7 @@ private fun builtinCos16(args: List<IExpression>, position: Position, program: P
         throw SyntaxError("cos16 requires one argument", position)
     val constval = args[0].constValue(program) ?: throw NotConstArgumentException()
     val rad = constval.asNumericValue!!.toDouble() /256.0 * 2.0 * PI
-    return LiteralValue(DataType.WORD, wordvalue = (32767.0* cos(rad)).toInt(), position = position)
+    return LiteralValue(DataType.WORD, wordvalue = (32767.0 * cos(rad)).toInt(), position = position)
 }
 
 private fun builtinCos16u(args: List<IExpression>, position: Position, program: Program): LiteralValue {
@@ -434,7 +440,7 @@ private fun builtinCos16u(args: List<IExpression>, position: Position, program:
         throw SyntaxError("cos16u requires one argument", position)
     val constval = args[0].constValue(program) ?: throw NotConstArgumentException()
     val rad = constval.asNumericValue!!.toDouble() /256.0 * 2.0 * PI
-    return LiteralValue(DataType.UWORD, wordvalue = (32768.0+32767.5* cos(rad)).toInt(), position = position)
+    return LiteralValue(DataType.UWORD, wordvalue = (32768.0 + 32767.5 * cos(rad)).toInt(), position = position)
 }
 
 private fun numericLiteral(value: Number, position: Position): LiteralValue {

compiler/src/prog8/optimizer/CallGraph.kt

@@ -1,10 +1,18 @@
-package prog8.optimizing
+package prog8.optimizer
 
 import prog8.ast.*
+import prog8.ast.base.DataType
+import prog8.ast.base.ParentSentinel
+import prog8.ast.base.VarDeclType
+import prog8.ast.base.initvarsSubName
+import prog8.ast.expressions.FunctionCall
+import prog8.ast.expressions.IdentifierReference
+import prog8.ast.processing.IAstVisitor
+import prog8.ast.statements.*
 import prog8.compiler.loadAsmIncludeFile
 
 
-class CallGraph(private val program: Program): IAstProcessor {
+class CallGraph(private val program: Program): IAstVisitor {
 
     val modulesImporting = mutableMapOf<Module, List<Module>>().withDefault { mutableListOf() }
     val modulesImportedBy = mutableMapOf<Module, List<Module>>().withDefault { mutableListOf() }
@@ -13,7 +21,7 @@ class CallGraph(private val program: Program): IAstProcessor {
     val usedSymbols = mutableSetOf<IStatement>()
 
     init {
-        process(program)
+        visit(program)
     }
 
     fun forAllSubroutines(scope: INameScope, sub: (s: Subroutine) -> Unit) {
@@ -28,8 +36,8 @@ class CallGraph(private val program: Program): IAstProcessor {
         findSubs(scope)
     }
 
-    override fun process(program: Program) {
-        super.process(program)
+    override fun visit(program: Program) {
+        super.visit(program)
 
         program.modules.forEach {
             it.importedBy.clear()
@@ -52,16 +60,16 @@ class CallGraph(private val program: Program): IAstProcessor {
         rootmodule.importedBy.add(rootmodule)       // don't discard root module
     }
 
-    override fun process(block: Block): IStatement {
+    override fun visit(block: Block) {
         if(block.definingModule().isLibraryModule) {
             // make sure the block is not removed
             addNodeAndParentScopes(block)
         }
 
-        return super.process(block)
+        super.visit(block)
     }
 
-    override fun process(directive: Directive): IStatement {
+    override fun visit(directive: Directive) {
         val thisModule = directive.definingModule()
         if(directive.directive=="%import") {
             val importedModule: Module = program.modules.single { it.name==directive.args[0].name }
@@ -73,16 +81,16 @@ class CallGraph(private val program: Program): IAstProcessor {
             scanAssemblyCode(asm, directive, scope)
         }
 
-        return super.process(directive)
+        super.visit(directive)
     }
 
-    override fun process(identifier: IdentifierReference): IExpression {
+    override fun visit(identifier: IdentifierReference) {
         // track symbol usage
         val target = identifier.targetStatement(this.program.namespace)
         if(target!=null) {
             addNodeAndParentScopes(target)
         }
-        return super.process(identifier)
+        super.visit(identifier)
     }
 
     private fun addNodeAndParentScopes(stmt: IStatement) {
@@ -96,24 +104,33 @@ class CallGraph(private val program: Program): IAstProcessor {
         } while (node !is Module && node !is ParentSentinel)
     }
 
-    override fun process(subroutine: Subroutine): IStatement {
-        if((subroutine.name=="start" && subroutine.definingScope().name=="main")
-                || subroutine.name==initvarsSubName || subroutine.definingModule().isLibraryModule) {
+    override fun visit(subroutine: Subroutine) {
+        val alwaysKeepSubroutines = setOf(
+                Pair("main", "start"),
+                Pair("irq", "irq")
+        )
+
+        if(Pair(subroutine.definingScope().name, subroutine.name) in alwaysKeepSubroutines
+                || subroutine.name== initvarsSubName || subroutine.definingModule().isLibraryModule) {
             // make sure the entrypoint is mentioned in the used symbols
             addNodeAndParentScopes(subroutine)
         }
-        return super.process(subroutine)
+        super.visit(subroutine)
     }
 
-    override fun process(decl: VarDecl): IStatement {
-        if(decl.autoGenerated || (decl.definingModule().isLibraryModule && decl.type!=VarDeclType.VAR)) {
+    override fun visit(decl: VarDecl) {
+        if(decl.hiddenButDoNotRemove || (decl.definingModule().isLibraryModule && decl.type!=VarDeclType.VAR)) {
             // make sure autogenerated vardecls are in the used symbols
             addNodeAndParentScopes(decl)
         }
-        return super.process(decl)
+
+        if(decl.datatype==DataType.STRUCT)
+            addNodeAndParentScopes(decl)
+
+        super.visit(decl)
     }
 
-    override fun process(functionCall: FunctionCall): IExpression {
+    override fun visit(functionCall: FunctionCall) {
         val otherSub = functionCall.target.targetSubroutine(program.namespace)
         if(otherSub!=null) {
             functionCall.definingSubroutine()?.let { thisSub ->
@@ -121,10 +138,10 @@ class CallGraph(private val program: Program): IAstProcessor {
                 subroutinesCalledBy[otherSub] = subroutinesCalledBy.getValue(otherSub).plus(functionCall)
             }
         }
-        return super.process(functionCall)
+        super.visit(functionCall)
     }
 
-    override fun process(functionCallStatement: FunctionCallStatement): IStatement {
+    override fun visit(functionCallStatement: FunctionCallStatement) {
         val otherSub = functionCallStatement.target.targetSubroutine(program.namespace)
         if(otherSub!=null) {
             functionCallStatement.definingSubroutine()?.let { thisSub ->
@@ -132,10 +149,10 @@ class CallGraph(private val program: Program): IAstProcessor {
                 subroutinesCalledBy[otherSub] = subroutinesCalledBy.getValue(otherSub).plus(functionCallStatement)
             }
         }
-        return super.process(functionCallStatement)
+        super.visit(functionCallStatement)
     }
 
-    override fun process(jump: Jump): IStatement {
+    override fun visit(jump: Jump) {
         val otherSub = jump.identifier?.targetSubroutine(program.namespace)
         if(otherSub!=null) {
             jump.definingSubroutine()?.let { thisSub ->
@@ -143,14 +160,19 @@ class CallGraph(private val program: Program): IAstProcessor {
                 subroutinesCalledBy[otherSub] = subroutinesCalledBy.getValue(otherSub).plus(jump)
             }
         }
-        return super.process(jump)
+        super.visit(jump)
     }
 
-    override fun process(inlineAssembly: InlineAssembly): IStatement {
+    override fun visit(structDecl: StructDecl) {
+        usedSymbols.add(structDecl)
+        usedSymbols.addAll(structDecl.statements)
+    }
+
+    override fun visit(inlineAssembly: InlineAssembly) {
         // parse inline asm for subroutine calls (jmp, jsr)
         val scope = inlineAssembly.definingScope()
         scanAssemblyCode(inlineAssembly.assembly, inlineAssembly, scope)
-        return super.process(inlineAssembly)
+        super.visit(inlineAssembly)
     }
 
     private fun scanAssemblyCode(asm: String, context: IStatement, scope: INameScope) {
@@ -179,10 +201,12 @@ class CallGraph(private val program: Program): IAstProcessor {
                 if (matches2 != null) {
                     val target= matches2.groups[2]?.value
                     if (target != null && (target[0].isLetter() || target[0] == '_')) {
-                        val node = program.namespace.lookup(listOf(target.substringBefore('.')), context)
-                        if (node is Subroutine) {
-                            subroutinesCalling[scope] = subroutinesCalling.getValue(scope).plus(node)
-                            subroutinesCalledBy[node] = subroutinesCalledBy.getValue(node).plus(context)
+                        if(target.contains('.')) {
+                            val node = program.namespace.lookup(listOf(target.substringBefore('.')), context)
+                            if (node is Subroutine) {
+                                subroutinesCalling[scope] = subroutinesCalling.getValue(scope).plus(node)
+                                subroutinesCalledBy[node] = subroutinesCalledBy.getValue(node).plus(context)
+                            }
                         }
                     }
                 }

compiler/src/prog8/optimizer/ConstExprEvaluator.kt

@@ -1,13 +1,14 @@
-package prog8.optimizing
+package prog8.optimizer
 
 import prog8.ast.*
-import prog8.compiler.HeapValues
+import prog8.ast.base.DataType
+import prog8.ast.base.ExpressionError
+import prog8.ast.base.FatalAstException
+import prog8.ast.base.Position
+import prog8.ast.expressions.LiteralValue
 import kotlin.math.pow
 
 
-val associativeOperators = setOf("+", "*", "&", "|", "^", "or", "and", "xor", "==", "!=")
-
-
 class ConstExprEvaluator {
 
     fun evaluate(left: LiteralValue, operator: String, right: LiteralValue): IExpression {
@@ -40,7 +41,7 @@ class ConstExprEvaluator {
         if(left.asIntegerValue==null || amount.asIntegerValue==null)
             throw ExpressionError("cannot compute $left >> $amount", left.position)
         val result =
-                if(left.type==DataType.UBYTE || left.type==DataType.UWORD)
+                if(left.type== DataType.UBYTE || left.type== DataType.UWORD)
                     left.asIntegerValue.ushr(amount.asIntegerValue)
                 else
                     left.asIntegerValue.shr(amount.asIntegerValue)

compiler/src/prog8/optimizer/ConstantFolding.kt

@@ -1,15 +1,18 @@
-package prog8.optimizing
+package prog8.optimizer
 
 import prog8.ast.*
-import prog8.compiler.CompilerException
+import prog8.ast.base.*
+import prog8.ast.expressions.*
+import prog8.ast.processing.IAstModifyingVisitor
+import prog8.ast.statements.*
 import prog8.compiler.HeapValues
 import prog8.compiler.IntegerOrAddressOf
-import prog8.compiler.target.c64.FLOAT_MAX_NEGATIVE
-import prog8.compiler.target.c64.FLOAT_MAX_POSITIVE
+import prog8.compiler.target.c64.MachineDefinition.FLOAT_MAX_NEGATIVE
+import prog8.compiler.target.c64.MachineDefinition.FLOAT_MAX_POSITIVE
 import kotlin.math.floor
 
 
-class ConstantFolding(private val program: Program) : IAstProcessor {
+class ConstantFolding(private val program: Program) : IAstModifyingVisitor {
     var optimizationsDone: Int = 0
     var errors : MutableList<AstException> = mutableListOf()
 
@@ -23,9 +26,9 @@ class ConstantFolding(private val program: Program) : IAstProcessor {
         }
     }
 
-    override fun process(decl: VarDecl): IStatement {
+    override fun visit(decl: VarDecl): IStatement {
         // the initializer value can't refer to the variable itself (recursive definition)
-        if(decl.value?.referencesIdentifier(decl.name) == true || decl.arraysize?.index?.referencesIdentifier(decl.name) == true) {
+        if(decl.value?.referencesIdentifiers(decl.name) == true || decl.arraysize?.index?.referencesIdentifiers(decl.name) == true) {
             errors.add(ExpressionError("recursive var declaration", decl.position))
             return decl
         }
@@ -45,7 +48,7 @@ class ConstantFolding(private val program: Program) : IAstProcessor {
                     }
                 }
                 else if(decl.arraysize?.size()==null) {
-                    val size = decl.arraysize!!.index.process(this)
+                    val size = decl.arraysize!!.index.accept(this)
                     if(size is LiteralValue) {
                         decl.arraysize = ArrayIndex(size, decl.position)
                         optimizationsDone++
@@ -75,19 +78,19 @@ class ConstantFolding(private val program: Program) : IAstProcessor {
                             val eltType = rangeExpr.inferType(program)!!
                             if(eltType in ByteDatatypes) {
                                 decl.value = LiteralValue(decl.datatype,
-                                        arrayvalue = constRange.map { LiteralValue(eltType, bytevalue=it.toShort(), position = decl.value!!.position ) }
-                                                .toTypedArray(), position=decl.value!!.position)
+                                        arrayvalue = constRange.map { LiteralValue(eltType, bytevalue = it.toShort(), position = decl.value!!.position) }
+                                                .toTypedArray(), position = decl.value!!.position)
                             } else {
                                 decl.value = LiteralValue(decl.datatype,
-                                        arrayvalue = constRange.map { LiteralValue(eltType, wordvalue= it, position = decl.value!!.position ) }
-                                                .toTypedArray(), position=decl.value!!.position)
+                                        arrayvalue = constRange.map { LiteralValue(eltType, wordvalue = it, position = decl.value!!.position) }
+                                                .toTypedArray(), position = decl.value!!.position)
                             }
                             decl.value!!.linkParents(decl)
                             optimizationsDone++
                             return decl
                         }
                     }
-                    if(litval?.type==DataType.FLOAT)
+                    if(litval?.type== DataType.FLOAT)
                         errors.add(ExpressionError("arraysize requires only integers here", litval.position))
                     val size = decl.arraysize?.size() ?: return decl
                     if ((litval==null || !litval.isArray) && rangeExpr==null) {
@@ -96,24 +99,29 @@ class ConstantFolding(private val program: Program) : IAstProcessor {
                         when(decl.datatype){
                             DataType.ARRAY_UB -> {
                                 if(fillvalue !in 0..255)
-                                    errors.add(ExpressionError("ubyte value overflow", litval?.position ?: decl.position))
+                                    errors.add(ExpressionError("ubyte value overflow", litval?.position
+                                            ?: decl.position))
                             }
                             DataType.ARRAY_B -> {
                                 if(fillvalue !in -128..127)
-                                    errors.add(ExpressionError("byte value overflow", litval?.position ?: decl.position))
+                                    errors.add(ExpressionError("byte value overflow", litval?.position
+                                            ?: decl.position))
                             }
                             DataType.ARRAY_UW -> {
                                 if(fillvalue !in 0..65535)
-                                    errors.add(ExpressionError("uword value overflow", litval?.position ?: decl.position))
+                                    errors.add(ExpressionError("uword value overflow", litval?.position
+                                            ?: decl.position))
                             }
                             DataType.ARRAY_W -> {
                                 if(fillvalue !in -32768..32767)
-                                    errors.add(ExpressionError("word value overflow", litval?.position ?: decl.position))
+                                    errors.add(ExpressionError("word value overflow", litval?.position
+                                            ?: decl.position))
                             }
                             else -> {}
                         }
                         val heapId = program.heap.addIntegerArray(decl.datatype, Array(size) { IntegerOrAddressOf(fillvalue, null) })
-                        decl.value = LiteralValue(decl.datatype, initHeapId = heapId, position = litval?.position ?: decl.position)
+                        decl.value = LiteralValue(decl.datatype, initHeapId = heapId, position = litval?.position
+                                ?: decl.position)
                         optimizationsDone++
                         return decl
                     }
@@ -124,10 +132,12 @@ class ConstantFolding(private val program: Program) : IAstProcessor {
                         // arraysize initializer is empty or a single int, and we know the size; create the arraysize.
                         val fillvalue = if (litval == null) 0.0 else litval.asNumericValue?.toDouble() ?: 0.0
                         if(fillvalue< FLOAT_MAX_NEGATIVE || fillvalue> FLOAT_MAX_POSITIVE)
-                            errors.add(ExpressionError("float value overflow", litval?.position ?: decl.position))
+                            errors.add(ExpressionError("float value overflow", litval?.position
+                                    ?: decl.position))
                         else {
                             val heapId = program.heap.addDoublesArray(DoubleArray(size) { fillvalue })
-                            decl.value = LiteralValue(DataType.ARRAY_F, initHeapId = heapId, position = litval?.position ?: decl.position)
+                            decl.value = LiteralValue(DataType.ARRAY_F, initHeapId = heapId, position = litval?.position
+                                    ?: decl.position)
                             optimizationsDone++
                             return decl
                         }
@@ -139,7 +149,7 @@ class ConstantFolding(private val program: Program) : IAstProcessor {
             }
         }
 
-        return super.process(decl)
+        return super.visit(decl)
     }
 
     private fun fixupArrayTypeOnHeap(decl: VarDecl, litval: LiteralValue) {
@@ -154,7 +164,7 @@ class ConstantFolding(private val program: Program) : IAstProcessor {
             DataType.ARRAY_UB, DataType.ARRAY_B, DataType.ARRAY_UW, DataType.ARRAY_W -> {
                 if(array.array!=null) {
                     program.heap.update(heapId, HeapValues.HeapValue(decl.datatype, null, array.array, null))
-                    decl.value = LiteralValue(decl.datatype, initHeapId=heapId, position = litval.position)
+                    decl.value = LiteralValue(decl.datatype, initHeapId = heapId, position = litval.position)
                 }
             }
             DataType.ARRAY_F -> {
@@ -165,6 +175,9 @@ class ConstantFolding(private val program: Program) : IAstProcessor {
                     decl.value = LiteralValue(decl.datatype, initHeapId = heapId, position = litval.position)
                 }
             }
+            DataType.STRUCT -> {
+                // leave it alone for structs.
+            }
             else -> throw FatalAstException("invalid array vardecl type ${decl.datatype}")
         }
     }
@@ -172,7 +185,7 @@ class ConstantFolding(private val program: Program) : IAstProcessor {
     /**
      * replace identifiers that refer to const value, with the value itself (if it's a simple type)
      */
-    override fun process(identifier: IdentifierReference): IExpression {
+    override fun visit(identifier: IdentifierReference): IExpression {
         return try {
             val cval = identifier.constValue(program) ?: return identifier
             return if(cval.isNumeric) {
@@ -187,9 +200,9 @@ class ConstantFolding(private val program: Program) : IAstProcessor {
         }
     }
 
-    override fun process(functionCall: FunctionCall): IExpression {
+    override fun visit(functionCall: FunctionCall): IExpression {
         return try {
-            super.process(functionCall)
+            super.visit(functionCall)
             typeCastConstArguments(functionCall)
             functionCall.constValue(program) ?: functionCall
         } catch (ax: AstException) {
@@ -198,8 +211,8 @@ class ConstantFolding(private val program: Program) : IAstProcessor {
         }
     }
 
-    override fun process(functionCallStatement: FunctionCallStatement): IStatement {
-        super.process(functionCallStatement)
+    override fun visit(functionCallStatement: FunctionCallStatement): IStatement {
+        super.visit(functionCallStatement)
         typeCastConstArguments(functionCallStatement)
         return functionCallStatement
     }
@@ -212,7 +225,7 @@ class ConstantFolding(private val program: Program) : IAstProcessor {
                 val expectedDt = arg.second.type
                 val argConst = arg.first.value.constValue(program)
                 if(argConst!=null && argConst.type!=expectedDt) {
-                    val convertedValue = argConst.intoDatatype(expectedDt)
+                    val convertedValue = argConst.cast(expectedDt)
                     if(convertedValue!=null) {
                         functionCall.arglist[arg.first.index] = convertedValue
                         optimizationsDone++
@@ -222,34 +235,26 @@ class ConstantFolding(private val program: Program) : IAstProcessor {
         }
     }
 
-    override fun process(memread: DirectMemoryRead): IExpression {
+    override fun visit(memread: DirectMemoryRead): IExpression {
         // @( &thing )  -->  thing
         val addrOf = memread.addressExpression as? AddressOf
         if(addrOf!=null)
-            return super.process(addrOf.identifier)
-        return super.process(memread)
-    }
-
-    override fun process(memwrite: DirectMemoryWrite): IExpression {
-        // @( &thing )  -->  thing
-        val addrOf = memwrite.addressExpression as? AddressOf
-        if(addrOf!=null)
-            return super.process(addrOf.identifier)
-        return super.process(memwrite)
+            return super.visit(addrOf.identifier)
+        return super.visit(memread)
     }
 
     /**
-     * Try to process a unary prefix expression.
+     * Try to accept a unary prefix expression.
      * Compile-time constant sub expressions will be evaluated on the spot.
      * For instance, the expression for "- 4.5" will be optimized into the float literal -4.5
      */
-    override fun process(expr: PrefixExpression): IExpression {
+    override fun visit(expr: PrefixExpression): IExpression {
         return try {
-            super.process(expr)
+            super.visit(expr)
 
             val subexpr = expr.expression
             if (subexpr is LiteralValue) {
-                // process prefixed literal values (such as -3, not true)
+                // accept prefixed literal values (such as -3, not true)
                 return when {
                     expr.operator == "+" -> subexpr
                     expr.operator == "-" -> when {
@@ -292,7 +297,7 @@ class ConstantFolding(private val program: Program) : IAstProcessor {
     }
 
     /**
-     * Try to process a binary expression.
+     * Try to accept a binary expression.
      * Compile-time constant sub expressions will be evaluated on the spot.
      * For instance, "9 * (4 + 2)" will be optimized into the integer literal 54.
      *
@@ -308,9 +313,9 @@ class ConstantFolding(private val program: Program) : IAstProcessor {
      *        (X / c1) * c2  ->  X / (c2/c1)
      *        (X + c1) - c2  ->  X + (c1-c2)
      */
-    override fun process(expr: BinaryExpression): IExpression {
+    override fun visit(expr: BinaryExpression): IExpression {
         return try {
-            super.process(expr)
+            super.visit(expr)
             val leftconst = expr.left.constValue(program)
             val rightconst = expr.right.constValue(program)
 
@@ -385,7 +390,7 @@ class ConstantFolding(private val program: Program) : IAstProcessor {
                         expr
                     } else
                         BinaryExpression(
-                                BinaryExpression(expr.left, if(expr.operator=="-") "+" else "*", subExpr.right, subExpr.position),
+                                BinaryExpression(expr.left, if (expr.operator == "-") "+" else "*", subExpr.right, subExpr.position),
                                 expr.operator, subExpr.left, expr.position)
                 } else {
                     return if(subleftIsConst) {
@@ -394,7 +399,7 @@ class ConstantFolding(private val program: Program) : IAstProcessor {
                     } else
                         BinaryExpression(
                                 subExpr.left, expr.operator,
-                                BinaryExpression(expr.right, if(expr.operator=="-") "+" else "*", subExpr.right, subExpr.position),
+                                BinaryExpression(expr.right, if (expr.operator == "-") "+" else "*", subExpr.right, subExpr.position),
                                 expr.position)
                 }
             }
@@ -537,21 +542,21 @@ class ConstantFolding(private val program: Program) : IAstProcessor {
         }
     }
 
-    override fun process(forLoop: ForLoop): IStatement {
+    override fun visit(forLoop: ForLoop): IStatement {
 
         fun adjustRangeDt(rangeFrom: LiteralValue, targetDt: DataType, rangeTo: LiteralValue, stepLiteral: LiteralValue?, range: RangeExpr): RangeExpr {
-            val newFrom = rangeFrom.intoDatatype(targetDt)
-            val newTo = rangeTo.intoDatatype(targetDt)
+            val newFrom = rangeFrom.cast(targetDt)
+            val newTo = rangeTo.cast(targetDt)
             if (newFrom != null && newTo != null) {
                 val newStep: IExpression =
-                        if (stepLiteral != null) (stepLiteral.intoDatatype(targetDt) ?: stepLiteral) else range.step
+                        if (stepLiteral != null) (stepLiteral.cast(targetDt) ?: stepLiteral) else range.step
                 return RangeExpr(newFrom, newTo, newStep, range.position)
             }
             return range
         }
 
         // adjust the datatype of a range expression in for loops to the loop variable.
-        val resultStmt = super.process(forLoop) as ForLoop
+        val resultStmt = super.visit(forLoop) as ForLoop
         val iterableRange = resultStmt.iterable as? RangeExpr ?: return resultStmt
         val rangeFrom = iterableRange.from as? LiteralValue
         val rangeTo = iterableRange.to as? LiteralValue
@@ -562,25 +567,25 @@ class ConstantFolding(private val program: Program) : IAstProcessor {
             val stepLiteral = iterableRange.step as? LiteralValue
             when(loopvar.datatype) {
                 DataType.UBYTE -> {
-                    if(rangeFrom.type!=DataType.UBYTE) {
+                    if(rangeFrom.type!= DataType.UBYTE) {
                         // attempt to translate the iterable into ubyte values
                         resultStmt.iterable = adjustRangeDt(rangeFrom, loopvar.datatype, rangeTo, stepLiteral, iterableRange)
                     }
                 }
                 DataType.BYTE -> {
-                    if(rangeFrom.type!=DataType.BYTE) {
+                    if(rangeFrom.type!= DataType.BYTE) {
                         // attempt to translate the iterable into byte values
                         resultStmt.iterable = adjustRangeDt(rangeFrom, loopvar.datatype, rangeTo, stepLiteral, iterableRange)
                     }
                 }
                 DataType.UWORD -> {
-                    if(rangeFrom.type!=DataType.UWORD) {
+                    if(rangeFrom.type!= DataType.UWORD) {
                         // attempt to translate the iterable into uword values
                         resultStmt.iterable = adjustRangeDt(rangeFrom, loopvar.datatype, rangeTo, stepLiteral, iterableRange)
                     }
                 }
                 DataType.WORD -> {
-                    if(rangeFrom.type!=DataType.WORD) {
+                    if(rangeFrom.type!= DataType.WORD) {
                         // attempt to translate the iterable into word values
                         resultStmt.iterable = adjustRangeDt(rangeFrom, loopvar.datatype, rangeTo, stepLiteral, iterableRange)
                     }
@@ -591,8 +596,8 @@ class ConstantFolding(private val program: Program) : IAstProcessor {
         return resultStmt
     }
 
-    override fun process(literalValue: LiteralValue): LiteralValue {
-        val litval = super.process(literalValue)
+    override fun visit(literalValue: LiteralValue): LiteralValue {
+        val litval = super.visit(literalValue)
         if(litval.isString) {
             // intern the string; move it into the heap
             if(litval.strvalue!!.length !in 1..255)
@@ -614,7 +619,7 @@ class ConstantFolding(private val program: Program) : IAstProcessor {
         val typesInArray = array.mapNotNull { it.inferType(program) }.toSet()
         val arrayDt =
                 when {
-                    array.any { it is AddressOf} -> DataType.ARRAY_UW
+                    array.any { it is AddressOf } -> DataType.ARRAY_UW
                     DataType.FLOAT in typesInArray -> DataType.ARRAY_F
                     DataType.WORD in typesInArray -> DataType.ARRAY_W
                     else -> {
@@ -649,65 +654,65 @@ class ConstantFolding(private val program: Program) : IAstProcessor {
         return litval
     }
 
-    override fun process(assignment: Assignment): IStatement {
-        super.process(assignment)
+    override fun visit(assignment: Assignment): IStatement {
+        super.visit(assignment)
         val lv = assignment.value as? LiteralValue
         if(lv!=null) {
             // see if we can promote/convert a literal value to the required datatype
-            when(assignment.singleTarget?.inferType(program, assignment)) {
+            when(assignment.target.inferType(program, assignment)) {
                 DataType.UWORD -> {
                     // we can convert to UWORD: any UBYTE, BYTE/WORD that are >=0, FLOAT that's an integer 0..65535,
-                    if(lv.type==DataType.UBYTE)
-                        assignment.value = LiteralValue(DataType.UWORD, wordvalue = lv.asIntegerValue, position=lv.position)
-                    else if(lv.type==DataType.BYTE && lv.bytevalue!!>=0)
-                        assignment.value = LiteralValue(DataType.UWORD, wordvalue = lv.asIntegerValue, position=lv.position)
-                    else if(lv.type==DataType.WORD && lv.wordvalue!!>=0)
-                        assignment.value = LiteralValue(DataType.UWORD, wordvalue = lv.asIntegerValue, position=lv.position)
-                    else if(lv.type==DataType.FLOAT) {
+                    if(lv.type== DataType.UBYTE)
+                        assignment.value = LiteralValue(DataType.UWORD, wordvalue = lv.asIntegerValue, position = lv.position)
+                    else if(lv.type== DataType.BYTE && lv.bytevalue!!>=0)
+                        assignment.value = LiteralValue(DataType.UWORD, wordvalue = lv.asIntegerValue, position = lv.position)
+                    else if(lv.type== DataType.WORD && lv.wordvalue!!>=0)
+                        assignment.value = LiteralValue(DataType.UWORD, wordvalue = lv.asIntegerValue, position = lv.position)
+                    else if(lv.type== DataType.FLOAT) {
                         val d = lv.floatvalue!!
                         if(floor(d)==d && d>=0 && d<=65535)
-                            assignment.value = LiteralValue(DataType.UWORD, wordvalue=floor(d).toInt(), position=lv.position)
+                            assignment.value = LiteralValue(DataType.UWORD, wordvalue = floor(d).toInt(), position = lv.position)
                     }
                 }
                 DataType.UBYTE -> {
                     // we can convert to UBYTE: UWORD <=255, BYTE >=0, FLOAT that's an integer 0..255,
-                    if(lv.type==DataType.UWORD && lv.wordvalue!! <= 255)
-                        assignment.value = LiteralValue(DataType.UBYTE, lv.wordvalue.toShort(), position=lv.position)
-                    else if(lv.type==DataType.BYTE && lv.bytevalue!! >=0)
-                        assignment.value = LiteralValue(DataType.UBYTE, lv.bytevalue.toShort(), position=lv.position)
-                    else if(lv.type==DataType.FLOAT) {
+                    if(lv.type== DataType.UWORD && lv.wordvalue!! <= 255)
+                        assignment.value = LiteralValue(DataType.UBYTE, lv.wordvalue.toShort(), position = lv.position)
+                    else if(lv.type== DataType.BYTE && lv.bytevalue!! >=0)
+                        assignment.value = LiteralValue(DataType.UBYTE, lv.bytevalue.toShort(), position = lv.position)
+                    else if(lv.type== DataType.FLOAT) {
                         val d = lv.floatvalue!!
                         if(floor(d)==d && d >=0 && d<=255)
-                            assignment.value = LiteralValue(DataType.UBYTE, floor(d).toShort(), position=lv.position)
+                            assignment.value = LiteralValue(DataType.UBYTE, floor(d).toShort(), position = lv.position)
                     }
                 }
                 DataType.BYTE -> {
                     // we can convert to BYTE: UWORD/UBYTE <= 127, FLOAT that's an integer 0..127
-                    if(lv.type==DataType.UWORD && lv.wordvalue!! <= 127)
-                        assignment.value = LiteralValue(DataType.BYTE, lv.wordvalue.toShort(), position=lv.position)
-                    else if(lv.type==DataType.UBYTE && lv.bytevalue!! <= 127)
-                        assignment.value = LiteralValue(DataType.BYTE, lv.bytevalue, position=lv.position)
-                    else if(lv.type==DataType.FLOAT) {
+                    if(lv.type== DataType.UWORD && lv.wordvalue!! <= 127)
+                        assignment.value = LiteralValue(DataType.BYTE, lv.wordvalue.toShort(), position = lv.position)
+                    else if(lv.type== DataType.UBYTE && lv.bytevalue!! <= 127)
+                        assignment.value = LiteralValue(DataType.BYTE, lv.bytevalue, position = lv.position)
+                    else if(lv.type== DataType.FLOAT) {
                         val d = lv.floatvalue!!
                         if(floor(d)==d && d>=0 && d<=127)
-                            assignment.value = LiteralValue(DataType.BYTE, floor(d).toShort(), position=lv.position)
+                            assignment.value = LiteralValue(DataType.BYTE, floor(d).toShort(), position = lv.position)
                     }
                 }
                 DataType.WORD -> {
                     // we can convert to WORD: any UBYTE/BYTE, UWORD <= 32767, FLOAT that's an integer -32768..32767,
-                    if(lv.type==DataType.UBYTE || lv.type==DataType.BYTE)
-                        assignment.value = LiteralValue(DataType.WORD, wordvalue=lv.bytevalue!!.toInt(), position=lv.position)
-                    else if(lv.type==DataType.UWORD && lv.wordvalue!! <= 32767)
-                        assignment.value = LiteralValue(DataType.WORD, wordvalue=lv.wordvalue, position=lv.position)
-                    else if(lv.type==DataType.FLOAT) {
+                    if(lv.type== DataType.UBYTE || lv.type== DataType.BYTE)
+                        assignment.value = LiteralValue(DataType.WORD, wordvalue = lv.bytevalue!!.toInt(), position = lv.position)
+                    else if(lv.type== DataType.UWORD && lv.wordvalue!! <= 32767)
+                        assignment.value = LiteralValue(DataType.WORD, wordvalue = lv.wordvalue, position = lv.position)
+                    else if(lv.type== DataType.FLOAT) {
                         val d = lv.floatvalue!!
                         if(floor(d)==d && d>=-32768 && d<=32767)
-                            assignment.value = LiteralValue(DataType.BYTE, floor(d).toShort(), position=lv.position)
+                            assignment.value = LiteralValue(DataType.BYTE, floor(d).toShort(), position = lv.position)
                     }
                 }
                 DataType.FLOAT -> {
                     if(lv.isNumeric)
-                        assignment.value = LiteralValue(DataType.FLOAT, floatvalue= lv.asNumericValue?.toDouble(), position=lv.position)
+                        assignment.value = LiteralValue(DataType.FLOAT, floatvalue = lv.asNumericValue?.toDouble(), position = lv.position)
                 }
                 else -> {}
             }

compiler/src/prog8/optimizer/Extensions.kt

@@ -1,20 +1,22 @@
-package prog8.optimizing
+package prog8.optimizer
 
 import prog8.ast.*
+import prog8.ast.base.AstException
+import prog8.ast.statements.NopStatement
 import prog8.parser.ParsingFailedError
 
 
 internal fun Program.constantFold() {
     val optimizer = ConstantFolding(this)
     try {
-        optimizer.process(this)
+        optimizer.visit(this)
     } catch (ax: AstException) {
         optimizer.addError(ax)
     }
 
     while(optimizer.errors.isEmpty() && optimizer.optimizationsDone>0) {
         optimizer.optimizationsDone = 0
-        optimizer.process(this)
+        optimizer.visit(this)
     }
 
     if(optimizer.errors.isNotEmpty()) {
@@ -28,15 +30,7 @@ internal fun Program.constantFold() {
 
 internal fun Program.optimizeStatements(optimizeInlining: Boolean): Int {
     val optimizer = StatementOptimizer(this, optimizeInlining)
-    optimizer.process(this)
-    for(scope in optimizer.scopesToFlatten.reversed()) {
-        val namescope = scope.parent as INameScope
-        val idx = namescope.statements.indexOf(scope as IStatement)
-        if(idx>=0) {
-            namescope.statements[idx] = NopStatement(scope.position)
-            namescope.statements.addAll(idx, scope.statements)
-        }
-    }
+    optimizer.visit(this)
     modules.forEach { it.linkParents(this.namespace) }   // re-link in final configuration
 
     return optimizer.optimizationsDone
@@ -44,6 +38,6 @@ internal fun Program.optimizeStatements(optimizeInlining: Boolean): Int {
 
 internal fun Program.simplifyExpressions() : Int {
     val optimizer = SimplifyExpressions(this)
-    optimizer.process(this)
+    optimizer.visit(this)
     return optimizer.optimizationsDone
 }

compiler/src/prog8/optimizer/SimplifyExpressions.kt

@@ -1,6 +1,13 @@
-package prog8.optimizing
+package prog8.optimizer
 
 import prog8.ast.*
+import prog8.ast.base.AstException
+import prog8.ast.base.DataType
+import prog8.ast.base.IntegerDatatypes
+import prog8.ast.base.NumericDatatypes
+import prog8.ast.expressions.*
+import prog8.ast.processing.IAstModifyingVisitor
+import prog8.ast.statements.Assignment
 import kotlin.math.abs
 import kotlin.math.log2
 
@@ -11,57 +18,74 @@ import kotlin.math.log2
 
  */
 
-internal class SimplifyExpressions(private val program: Program) : IAstProcessor {
+internal class SimplifyExpressions(private val program: Program) : IAstModifyingVisitor {
     var optimizationsDone: Int = 0
 
-    override fun process(assignment: Assignment): IStatement {
+    override fun visit(assignment: Assignment): IStatement {
         if (assignment.aug_op != null)
             throw AstException("augmented assignments should have been converted to normal assignments before this optimizer")
-        return super.process(assignment)
+        return super.visit(assignment)
     }
 
-    override fun process(memread: DirectMemoryRead): IExpression {
+    override fun visit(memread: DirectMemoryRead): IExpression {
         // @( &thing )  -->  thing
         val addrOf = memread.addressExpression as? AddressOf
         if(addrOf!=null)
-            return super.process(addrOf.identifier)
-        return super.process(memread)
+            return super.visit(addrOf.identifier)
+        return super.visit(memread)
     }
 
-    override fun process(memwrite: DirectMemoryWrite): IExpression {
-        // @( &thing )  -->  thing
-        val addrOf = memwrite.addressExpression as? AddressOf
-        if(addrOf!=null)
-            return super.process(addrOf.identifier)
-        return super.process(memwrite)
-    }
-
-    override fun process(typecast: TypecastExpression): IExpression {
-        // remove redundant typecasts
+    override fun visit(typecast: TypecastExpression): IExpression {
         var tc = typecast
+
+        // try to statically convert a literal value into one of the desired type
+        val literal = tc.expression as? LiteralValue
+        if(literal!=null) {
+            val newLiteral = literal.cast(tc.type)
+            if(newLiteral!=null && newLiteral!==literal) {
+                optimizationsDone++
+                return newLiteral
+            }
+        }
+
+        // remove redundant typecasts
         while(true) {
             val expr = tc.expression
             if(expr !is TypecastExpression || expr.type!=tc.type) {
                 val assignment = typecast.parent as? Assignment
                 if(assignment!=null) {
-                    val targetDt = assignment.singleTarget?.inferType(program, assignment)
+                    val targetDt = assignment.target.inferType(program, assignment)
                     if(tc.expression.inferType(program)==targetDt) {
                         optimizationsDone++
                         return tc.expression
                     }
                 }
-                return super.process(tc)
+
+                val subTc = tc.expression as? TypecastExpression
+                if(subTc!=null) {
+                    // if the previous typecast was casting to a 'bigger' type, just ignore that one
+                    // if the previous typecast was casting to a similar type, ignore that one
+                    if(subTc.type largerThan tc.type || subTc.type equalsSize tc.type) {
+                        subTc.type = tc.type
+                        subTc.parent = tc.parent
+                        optimizationsDone++
+                        return subTc
+                    }
+                }
+
+                return super.visit(tc)
             }
+
             optimizationsDone++
             tc = expr
         }
     }
 
-    override fun process(expr: PrefixExpression): IExpression {
+    override fun visit(expr: PrefixExpression): IExpression {
         if (expr.operator == "+") {
             // +X --> X
             optimizationsDone++
-            return expr.expression.process(this)
+            return expr.expression.accept(this)
         } else if (expr.operator == "not") {
             (expr.expression as? BinaryExpression)?.let {
                 // NOT (...)  ->   invert  ...
@@ -101,11 +125,11 @@ internal class SimplifyExpressions(private val program: Program) : IAstProcessor
                 }
             }
         }
-        return super.process(expr)
+        return super.visit(expr)
     }
 
-    override fun process(expr: BinaryExpression): IExpression {
-        super.process(expr)
+    override fun visit(expr: BinaryExpression): IExpression {
+        super.visit(expr)
         val leftVal = expr.left.constValue(program)
         val rightVal = expr.right.constValue(program)
         val constTrue = LiteralValue.fromBoolean(true, expr.position)
@@ -336,48 +360,48 @@ internal class SimplifyExpressions(private val program: Program) : IAstProcessor
                 DataType.UBYTE -> {
                     if (targetDt == DataType.BYTE) {
                         if(value.bytevalue!! < 127)
-                            return Pair(true, LiteralValue(targetDt, value.bytevalue, position=value.position))
+                            return Pair(true, LiteralValue(targetDt, value.bytevalue, position = value.position))
                     }
                     else if (targetDt == DataType.UWORD || targetDt == DataType.WORD)
-                        return Pair(true, LiteralValue(targetDt, wordvalue = value.bytevalue!!.toInt(), position=value.position))
+                        return Pair(true, LiteralValue(targetDt, wordvalue = value.bytevalue!!.toInt(), position = value.position))
                 }
                 DataType.BYTE -> {
                     if (targetDt == DataType.UBYTE) {
                         if(value.bytevalue!! >= 0)
-                            return Pair(true, LiteralValue(targetDt, value.bytevalue, position=value.position))
+                            return Pair(true, LiteralValue(targetDt, value.bytevalue, position = value.position))
                     }
                     else if (targetDt == DataType.UWORD) {
                         if(value.bytevalue!! >= 0)
-                            return Pair(true, LiteralValue(targetDt, wordvalue=value.bytevalue.toInt(), position=value.position))
+                            return Pair(true, LiteralValue(targetDt, wordvalue = value.bytevalue.toInt(), position = value.position))
                     }
-                    else if (targetDt == DataType.WORD) return Pair(true, LiteralValue(targetDt, wordvalue=value.bytevalue!!.toInt(), position=value.position))
+                    else if (targetDt == DataType.WORD) return Pair(true, LiteralValue(targetDt, wordvalue = value.bytevalue!!.toInt(), position = value.position))
                 }
                 DataType.UWORD -> {
                     if (targetDt == DataType.UBYTE) {
                         if(value.wordvalue!! <= 255)
-                            return Pair(true, LiteralValue(targetDt, value.wordvalue.toShort(), position=value.position))
+                            return Pair(true, LiteralValue(targetDt, value.wordvalue.toShort(), position = value.position))
                     }
                     else if (targetDt == DataType.BYTE) {
                         if(value.wordvalue!! <= 127)
-                            return Pair(true, LiteralValue(targetDt, value.wordvalue.toShort(), position=value.position))
+                            return Pair(true, LiteralValue(targetDt, value.wordvalue.toShort(), position = value.position))
                     }
                     else if (targetDt == DataType.WORD) {
                         if(value.wordvalue!! <= 32767)
-                            return Pair(true, LiteralValue(targetDt, wordvalue=value.wordvalue, position=value.position))
+                            return Pair(true, LiteralValue(targetDt, wordvalue = value.wordvalue, position = value.position))
                     }
                 }
                 DataType.WORD -> {
                     if (targetDt == DataType.UBYTE) {
                         if(value.wordvalue!! in 0..255)
-                            return Pair(true, LiteralValue(targetDt, value.wordvalue.toShort(), position=value.position))
+                            return Pair(true, LiteralValue(targetDt, value.wordvalue.toShort(), position = value.position))
                     }
                     else if (targetDt == DataType.BYTE) {
                         if(value.wordvalue!! in -128..127)
-                            return Pair(true, LiteralValue(targetDt, value.wordvalue.toShort(), position=value.position))
+                            return Pair(true, LiteralValue(targetDt, value.wordvalue.toShort(), position = value.position))
                     }
                     else if (targetDt == DataType.UWORD) {
                         if(value.wordvalue!! >= 0)
-                            return Pair(true, LiteralValue(targetDt, value.wordvalue.toShort(), position=value.position))
+                            return Pair(true, LiteralValue(targetDt, value.wordvalue.toShort(), position = value.position))
                     }
                 }
                 else -> {}
@@ -386,7 +410,7 @@ internal class SimplifyExpressions(private val program: Program) : IAstProcessor
         }
 
         if(leftConstVal==null && rightConstVal!=null) {
-            if(leftDt biggerThan rightDt) {
+            if(leftDt largerThan rightDt) {
                 val (adjusted, newValue) = adjust(rightConstVal, leftDt)
                 if (adjusted) {
                     expr.right = newValue
@@ -396,7 +420,7 @@ internal class SimplifyExpressions(private val program: Program) : IAstProcessor
             }
             return false
         } else if(leftConstVal!=null && rightConstVal==null) {
-            if(rightDt biggerThan leftDt) {
+            if(rightDt largerThan leftDt) {
                 val (adjusted, newValue) = adjust(leftConstVal, rightDt)
                 if (adjusted) {
                     expr.left = newValue

compiler/src/prog8/optimizer/StatementOptimizer.kt

@@ -1,6 +1,11 @@
-package prog8.optimizing
+package prog8.optimizer
 
 import prog8.ast.*
+import prog8.ast.base.*
+import prog8.ast.expressions.*
+import prog8.ast.processing.IAstModifyingVisitor
+import prog8.ast.processing.IAstVisitor
+import prog8.ast.statements.*
 import prog8.compiler.target.c64.Petscii
 import prog8.functions.BuiltinFunctions
 import kotlin.math.floor
@@ -11,10 +16,10 @@ import kotlin.math.floor
     todo analyse for unreachable code and remove that (f.i. code after goto or return that has no label so can never be jumped to) + print warning about this
 */
 
-internal class StatementOptimizer(private val program: Program, private val optimizeInlining: Boolean) : IAstProcessor {
+
+internal class StatementOptimizer(private val program: Program, private val optimizeInlining: Boolean) : IAstModifyingVisitor {
     var optimizationsDone: Int = 0
         private set
-    var scopesToFlatten = mutableListOf<INameScope>()
 
     private val pureBuiltinFunctions = BuiltinFunctions.filter { it.value.pure }
     private val callgraph = CallGraph(program)
@@ -23,12 +28,12 @@ internal class StatementOptimizer(private val program: Program, private val opti
         private var generatedLabelSequenceNumber = 0
     }
 
-    override fun process(program: Program) {
+    override fun visit(program: Program) {
         removeUnusedCode(callgraph)
         if(optimizeInlining) {
             inlineSubroutines(callgraph)
         }
-        super.process(program)
+        super.visit(program)
     }
 
     private fun inlineSubroutines(callgraph: CallGraph) {
@@ -63,18 +68,22 @@ internal class StatementOptimizer(private val program: Program, private val opti
             val inlined = AnonymousScope(sub.statements.toMutableList(), caller.position)
             parent.statements[parent.statements.indexOf(caller)] = inlined
             // replace return statements in the inlined sub by a jump to the end of it
+            var haveNewEndLabel = false
+            var endLabelUsed = false
             var endlabel = inlined.statements.last() as? Label
             if(endlabel==null) {
                 endlabel = makeLabel("_prog8_auto_sub_end", inlined.statements.last().position)
-                inlined.statements.add(endlabel)
                 endlabel.parent = inlined
+                haveNewEndLabel = true
             }
             val returns = inlined.statements.withIndex().filter { iv -> iv.value is Return }.map { iv -> Pair(iv.index, iv.value as Return)}
             for(returnIdx in returns) {
-                assert(returnIdx.second.values.isEmpty())
                 val jump = Jump(null, IdentifierReference(listOf(endlabel.name), returnIdx.second.position), null, returnIdx.second.position)
                 inlined.statements[returnIdx.first] = jump
+                endLabelUsed = true
             }
+            if(endLabelUsed && haveNewEndLabel)
+                inlined.statements.add(endlabel)
             inlined.linkParents(caller.parent)
             sub.calledBy.remove(caller)     // if there are no callers left, the sub will be removed automatically later
             optimizationsDone++
@@ -127,32 +136,32 @@ internal class StatementOptimizer(private val program: Program, private val opti
         }
     }
 
-    override fun process(block: Block): IStatement {
+    override fun visit(block: Block): IStatement {
         if("force_output" !in block.options()) {
             if (block.containsNoCodeNorVars()) {
                 optimizationsDone++
                 printWarning("removing empty block '${block.name}'", block.position)
-                return NopStatement(block.position)
+                return NopStatement.insteadOf(block)
             }
 
             if (block !in callgraph.usedSymbols) {
                 optimizationsDone++
                 printWarning("removing unused block '${block.name}'", block.position)
-                return NopStatement(block.position)  // remove unused block
+                return NopStatement.insteadOf(block)  // remove unused block
             }
         }
 
-        return super.process(block)
+        return super.visit(block)
     }
 
-    override fun process(subroutine: Subroutine): IStatement {
-        super.process(subroutine)
+    override fun visit(subroutine: Subroutine): IStatement {
+        super.visit(subroutine)
         val forceOutput = "force_output" in subroutine.definingBlock().options()
         if(subroutine.asmAddress==null && !forceOutput) {
             if(subroutine.containsNoCodeNorVars()) {
                 printWarning("removing empty subroutine '${subroutine.name}'", subroutine.position)
                 optimizationsDone++
-                return NopStatement(subroutine.position)
+                return NopStatement.insteadOf(subroutine)
             }
         }
 
@@ -176,22 +185,22 @@ internal class StatementOptimizer(private val program: Program, private val opti
         if(subroutine !in callgraph.usedSymbols && !forceOutput) {
             printWarning("removing unused subroutine '${subroutine.name}'", subroutine.position)
             optimizationsDone++
-            return NopStatement(subroutine.position)        // remove unused subroutine
+            return NopStatement.insteadOf(subroutine)
         }
 
         return subroutine
     }
 
-    override fun process(decl: VarDecl): IStatement {
+    override fun visit(decl: VarDecl): IStatement {
         val forceOutput = "force_output" in decl.definingBlock().options()
         if(decl !in callgraph.usedSymbols && !forceOutput) {
-            if(decl.type!=VarDeclType.CONST)
-                printWarning("removing unused variable '${decl.name}'", decl.position)
+            if(decl.type == VarDeclType.VAR)
+                printWarning("removing unused variable ${decl.type} '${decl.name}'", decl.position)
             optimizationsDone++
-            return NopStatement(decl.position)        // remove unused variable
+            return NopStatement.insteadOf(decl)
         }
 
-        return super.process(decl)
+        return super.visit(decl)
     }
 
     private fun deduplicateAssignments(statements: List<IStatement>): MutableList<Int> {
@@ -206,9 +215,9 @@ internal class StatementOptimizer(private val program: Program, private val opti
                     continue
                 } else {
                     val prev = statements[previousAssignmentLine] as Assignment
-                    if (prev.targets.size == 1 && stmt.targets.size == 1 && prev.targets[0].isSameAs(stmt.targets[0], program)) {
+                    if (prev.target.isSameAs(stmt.target, program)) {
                         // get rid of the previous assignment, if the target is not MEMORY
-                        if (prev.targets[0].isNotMemory(program.namespace))
+                        if (prev.target.isNotMemory(program.namespace))
                             linesToRemove.add(previousAssignmentLine)
                     }
                     previousAssignmentLine = i
@@ -219,13 +228,13 @@ internal class StatementOptimizer(private val program: Program, private val opti
         return linesToRemove
     }
 
-    override fun process(functionCallStatement: FunctionCallStatement): IStatement {
+    override fun visit(functionCallStatement: FunctionCallStatement): IStatement {
         if(functionCallStatement.target.nameInSource.size==1 && functionCallStatement.target.nameInSource[0] in BuiltinFunctions) {
             val functionName = functionCallStatement.target.nameInSource[0]
             if (functionName in pureBuiltinFunctions) {
                 printWarning("statement has no effect (function return value is discarded)", functionCallStatement.position)
                 optimizationsDone++
-                return NopStatement(functionCallStatement.position)
+                return NopStatement.insteadOf(functionCallStatement)
             }
         }
 
@@ -270,14 +279,14 @@ internal class StatementOptimizer(private val program: Program, private val opti
             }
             if(first is ReturnFromIrq || first is Return) {
                 optimizationsDone++
-                return NopStatement(functionCallStatement.position)
+                return NopStatement.insteadOf(functionCallStatement)
             }
         }
 
-        return super.process(functionCallStatement)
+        return super.visit(functionCallStatement)
     }
 
-    override fun process(functionCall: FunctionCall): IExpression {
+    override fun visit(functionCall: FunctionCall): IExpression {
         // if it calls a subroutine,
         // and the first instruction in the subroutine is a jump, call that jump target instead
         // if the first instruction in the subroutine is a return statement with constant value, replace with the constant value
@@ -288,21 +297,21 @@ internal class StatementOptimizer(private val program: Program, private val opti
                 optimizationsDone++
                 return FunctionCall(first.identifier, functionCall.arglist, functionCall.position)
             }
-            if(first is Return && first.values.size==1) {
-                val constval = first.values[0].constValue(program)
+            if(first is Return && first.value!=null) {
+                val constval = first.value?.constValue(program)
                 if(constval!=null)
                     return constval
             }
         }
-        return super.process(functionCall)
+        return super.visit(functionCall)
     }
 
-    override fun process(ifStatement: IfStatement): IStatement {
-        super.process(ifStatement)
+    override fun visit(ifStatement: IfStatement): IStatement {
+        super.visit(ifStatement)
 
         if(ifStatement.truepart.containsNoCodeNorVars() && ifStatement.elsepart.containsNoCodeNorVars()) {
             optimizationsDone++
-            return NopStatement(ifStatement.position)
+            return NopStatement.insteadOf(ifStatement)
         }
 
         if(ifStatement.truepart.containsNoCodeNorVars() && ifStatement.elsepart.containsCodeOrVars()) {
@@ -331,18 +340,18 @@ internal class StatementOptimizer(private val program: Program, private val opti
         return ifStatement
     }
 
-    override fun process(forLoop: ForLoop): IStatement {
-        super.process(forLoop)
+    override fun visit(forLoop: ForLoop): IStatement {
+        super.visit(forLoop)
         if(forLoop.body.containsNoCodeNorVars()) {
             // remove empty for loop
             optimizationsDone++
-            return NopStatement(forLoop.position)
+            return NopStatement.insteadOf(forLoop)
         } else if(forLoop.body.statements.size==1) {
             val loopvar = forLoop.body.statements[0] as? VarDecl
             if(loopvar!=null && loopvar.name==forLoop.loopVar?.nameInSource?.singleOrNull()) {
                 // remove empty for loop
                 optimizationsDone++
-                return NopStatement(forLoop.position)
+                return NopStatement.insteadOf(forLoop)
             }
         }
 
@@ -352,7 +361,7 @@ internal class StatementOptimizer(private val program: Program, private val opti
             if(range.size()==1) {
                 // for loop over a (constant) range of just a single value-- optimize the loop away
                 // loopvar/reg = range value , follow by block
-                val assignment = Assignment(listOf(AssignTarget(forLoop.loopRegister, forLoop.loopVar, null, null, forLoop.position)), null, range.from, forLoop.position)
+                val assignment = Assignment(AssignTarget(forLoop.loopRegister, forLoop.loopVar, null, null, forLoop.position), null, range.from, forLoop.position)
                 forLoop.body.statements.add(0, assignment)
                 optimizationsDone++
                 return forLoop.body
@@ -361,8 +370,8 @@ internal class StatementOptimizer(private val program: Program, private val opti
         return forLoop
     }
 
-    override fun process(whileLoop: WhileLoop): IStatement {
-        super.process(whileLoop)
+    override fun visit(whileLoop: WhileLoop): IStatement {
+        super.visit(whileLoop)
         val constvalue = whileLoop.condition.constValue(program)
         if(constvalue!=null) {
             return if(constvalue.asBooleanValue){
@@ -381,14 +390,14 @@ internal class StatementOptimizer(private val program: Program, private val opti
                 // always false -> ditch whole statement
                 printWarning("condition is always false", whileLoop.position)
                 optimizationsDone++
-                NopStatement(whileLoop.position)
+                NopStatement.insteadOf(whileLoop)
             }
         }
         return whileLoop
     }
 
-    override fun process(repeatLoop: RepeatLoop): IStatement {
-        super.process(repeatLoop)
+    override fun visit(repeatLoop: RepeatLoop): IStatement {
+        super.visit(repeatLoop)
         val constvalue = repeatLoop.untilCondition.constValue(program)
         if(constvalue!=null) {
             return if(constvalue.asBooleanValue){
@@ -417,32 +426,41 @@ internal class StatementOptimizer(private val program: Program, private val opti
         return repeatLoop
     }
 
+    override fun visit(whenStatement: WhenStatement): IStatement {
+        val choices = whenStatement.choices.toList()
+        for(choice in choices) {
+            if(choice.statements.containsNoCodeNorVars())
+                whenStatement.choices.remove(choice)
+        }
+        return super.visit(whenStatement)
+    }
+
     private fun hasContinueOrBreak(scope: INameScope): Boolean {
 
-        class Searcher:IAstProcessor
+        class Searcher: IAstModifyingVisitor
         {
             var count=0
 
-            override fun process(breakStmt: Break): IStatement {
+            override fun visit(breakStmt: Break): IStatement {
                 count++
-                return super.process(breakStmt)
+                return super.visit(breakStmt)
             }
 
-            override fun process(contStmt: Continue): IStatement {
+            override fun visit(contStmt: Continue): IStatement {
                 count++
-                return super.process(contStmt)
+                return super.visit(contStmt)
             }
         }
         val s=Searcher()
         for(stmt in scope.statements) {
-            stmt.process(s)
+            stmt.accept(s)
             if(s.count>0)
                 return true
         }
         return s.count > 0
     }
 
-    override fun process(jump: Jump): IStatement {
+    override fun visit(jump: Jump): IStatement {
         val subroutine = jump.identifier?.targetSubroutine(program.namespace)
         if(subroutine!=null) {
             // if the first instruction in the subroutine is another jump, shortcut this one
@@ -459,136 +477,133 @@ internal class StatementOptimizer(private val program: Program, private val opti
         if(label!=null) {
             if(scope.statements.indexOf(label) == scope.statements.indexOf(jump)+1) {
                 optimizationsDone++
-                return NopStatement(jump.position)
+                return NopStatement.insteadOf(jump)
             }
         }
 
         return jump
     }
 
-    override fun process(assignment: Assignment): IStatement {
+    override fun visit(assignment: Assignment): IStatement {
         if(assignment.aug_op!=null)
             throw AstException("augmented assignments should have been converted to normal assignments before this optimizer")
 
-        if(assignment.targets.size==1) {
-            val target=assignment.targets[0]
-            if(target isSameAs assignment.value) {
-                optimizationsDone++
-                return NopStatement(assignment.position)
-            }
-            val targetDt = target.inferType(program, assignment)
-            val bexpr=assignment.value as? BinaryExpression
-            if(bexpr!=null) {
-                val cv = bexpr.right.constValue(program)?.asNumericValue?.toDouble()
-                if(cv==null) {
-                    if(bexpr.operator=="+" && targetDt!=DataType.FLOAT) {
-                        if (bexpr.left isSameAs bexpr.right && target isSameAs bexpr.left) {
-                            bexpr.operator = "*"
-                            bexpr.right = LiteralValue.optimalInteger(2, assignment.value.position)
-                            optimizationsDone++
-                            return assignment
-                        }
+        if(assignment.target isSameAs assignment.value) {
+            optimizationsDone++
+            return NopStatement.insteadOf(assignment)
+        }
+        val targetDt = assignment.target.inferType(program, assignment)
+        val bexpr=assignment.value as? BinaryExpression
+        if(bexpr!=null) {
+            val cv = bexpr.right.constValue(program)?.asNumericValue?.toDouble()
+            if (cv == null) {
+                if (bexpr.operator == "+" && targetDt != DataType.FLOAT) {
+                    if (bexpr.left isSameAs bexpr.right && assignment.target isSameAs bexpr.left) {
+                        bexpr.operator = "*"
+                        bexpr.right = LiteralValue.optimalInteger(2, assignment.value.position)
+                        optimizationsDone++
+                        return assignment
                     }
-                } else {
-                    if (target isSameAs bexpr.left) {
-                        // remove assignments that have no effect  X=X , X+=0, X-=0, X*=1, X/=1, X//=1, A |= 0, A ^= 0, A<<=0, etc etc
-                        // A = A <operator> B
-                        val vardeclDt = (target.identifier?.targetVarDecl(program.namespace))?.type
+                }
+            } else {
+                if (assignment.target isSameAs bexpr.left) {
+                    // remove assignments that have no effect  X=X , X+=0, X-=0, X*=1, X/=1, X//=1, A |= 0, A ^= 0, A<<=0, etc etc
+                    // A = A <operator> B
+                    val vardeclDt = (assignment.target.identifier?.targetVarDecl(program.namespace))?.type
 
-                        when (bexpr.operator) {
-                            "+" -> {
-                                if (cv == 0.0) {
-                                    optimizationsDone++
-                                    return NopStatement(assignment.position)
-                                } else if (targetDt in IntegerDatatypes && floor(cv) == cv) {
-                                    if((vardeclDt == VarDeclType.MEMORY && cv in 1.0..3.0) || (vardeclDt!=VarDeclType.MEMORY && cv in 1.0..8.0)) {
-                                        // replace by several INCs (a bit less when dealing with memory targets)
-                                        val decs = AnonymousScope(mutableListOf(), assignment.position)
-                                        repeat(cv.toInt()) {
-                                            decs.statements.add(PostIncrDecr(target, "++", assignment.position))
-                                        }
-                                        return decs
+                    when (bexpr.operator) {
+                        "+" -> {
+                            if (cv == 0.0) {
+                                optimizationsDone++
+                                return NopStatement.insteadOf(assignment)
+                            } else if (targetDt in IntegerDatatypes && floor(cv) == cv) {
+                                if ((vardeclDt == VarDeclType.MEMORY && cv in 1.0..3.0) || (vardeclDt != VarDeclType.MEMORY && cv in 1.0..8.0)) {
+                                    // replace by several INCs (a bit less when dealing with memory targets)
+                                    val decs = AnonymousScope(mutableListOf(), assignment.position)
+                                    repeat(cv.toInt()) {
+                                        decs.statements.add(PostIncrDecr(assignment.target, "++", assignment.position))
                                     }
+                                    return decs
                                 }
                             }
-                            "-" -> {
-                                if (cv == 0.0) {
-                                    optimizationsDone++
-                                    return NopStatement(assignment.position)
-                                } else if (targetDt in IntegerDatatypes && floor(cv) == cv) {
-                                    if((vardeclDt == VarDeclType.MEMORY && cv in 1.0..3.0) || (vardeclDt!=VarDeclType.MEMORY && cv in 1.0..8.0)) {
-                                        // replace by several DECs (a bit less when dealing with memory targets)
-                                        val decs = AnonymousScope(mutableListOf(), assignment.position)
-                                        repeat(cv.toInt()) {
-                                            decs.statements.add(PostIncrDecr(target, "--", assignment.position))
-                                        }
-                                        return decs
+                        }
+                        "-" -> {
+                            if (cv == 0.0) {
+                                optimizationsDone++
+                                return NopStatement.insteadOf(assignment)
+                            } else if (targetDt in IntegerDatatypes && floor(cv) == cv) {
+                                if ((vardeclDt == VarDeclType.MEMORY && cv in 1.0..3.0) || (vardeclDt != VarDeclType.MEMORY && cv in 1.0..8.0)) {
+                                    // replace by several DECs (a bit less when dealing with memory targets)
+                                    val decs = AnonymousScope(mutableListOf(), assignment.position)
+                                    repeat(cv.toInt()) {
+                                        decs.statements.add(PostIncrDecr(assignment.target, "--", assignment.position))
                                     }
+                                    return decs
                                 }
                             }
-                            "*" -> if (cv == 1.0) {
+                        }
+                        "*" -> if (cv == 1.0) {
+                            optimizationsDone++
+                            return NopStatement.insteadOf(assignment)
+                        }
+                        "/" -> if (cv == 1.0) {
+                            optimizationsDone++
+                            return NopStatement.insteadOf(assignment)
+                        }
+                        "**" -> if (cv == 1.0) {
+                            optimizationsDone++
+                            return NopStatement.insteadOf(assignment)
+                        }
+                        "|" -> if (cv == 0.0) {
+                            optimizationsDone++
+                            return NopStatement.insteadOf(assignment)
+                        }
+                        "^" -> if (cv == 0.0) {
+                            optimizationsDone++
+                            return NopStatement.insteadOf(assignment)
+                        }
+                        "<<" -> {
+                            if (cv == 0.0) {
                                 optimizationsDone++
-                                return NopStatement(assignment.position)
+                                return NopStatement.insteadOf(assignment)
                             }
-                            "/" -> if (cv == 1.0) {
+                            if (((targetDt == DataType.UWORD || targetDt == DataType.WORD) && cv > 15.0) ||
+                                    ((targetDt == DataType.UBYTE || targetDt == DataType.BYTE) && cv > 7.0)) {
+                                assignment.value = LiteralValue.optimalInteger(0, assignment.value.position)
+                                assignment.value.linkParents(assignment)
                                 optimizationsDone++
-                                return NopStatement(assignment.position)
-                            }
-                            "**" -> if (cv == 1.0) {
-                                optimizationsDone++
-                                return NopStatement(assignment.position)
-                            }
-                            "|" -> if (cv == 0.0) {
-                                optimizationsDone++
-                                return NopStatement(assignment.position)
-                            }
-                            "^" -> if (cv == 0.0) {
-                                optimizationsDone++
-                                return NopStatement(assignment.position)
-                            }
-                            "<<" -> {
-                                if (cv == 0.0) {
-                                    optimizationsDone++
-                                    return NopStatement(assignment.position)
-                                }
-                                if (((targetDt == DataType.UWORD || targetDt == DataType.WORD) && cv > 15.0) ||
-                                        ((targetDt == DataType.UBYTE || targetDt == DataType.BYTE) && cv > 7.0)) {
-                                    assignment.value = LiteralValue.optimalInteger(0, assignment.value.position)
-                                    assignment.value.linkParents(assignment)
-                                    optimizationsDone++
-                                } else {
-                                    // replace by in-place lsl(...) call
-                                    val scope = AnonymousScope(mutableListOf(), assignment.position)
-                                    var numshifts = cv.toInt()
-                                    while (numshifts > 0) {
-                                        scope.statements.add(FunctionCallStatement(IdentifierReference(listOf("lsl"), assignment.position), mutableListOf(bexpr.left), assignment.position))
-                                        numshifts--
-                                    }
-                                    optimizationsDone++
-                                    return scope
+                            } else {
+                                // replace by in-place lsl(...) call
+                                val scope = AnonymousScope(mutableListOf(), assignment.position)
+                                var numshifts = cv.toInt()
+                                while (numshifts > 0) {
+                                    scope.statements.add(FunctionCallStatement(IdentifierReference(listOf("lsl"), assignment.position), mutableListOf(bexpr.left), assignment.position))
+                                    numshifts--
                                 }
+                                optimizationsDone++
+                                return scope
                             }
-                            ">>" -> {
-                                if (cv == 0.0) {
-                                    optimizationsDone++
-                                    return NopStatement(assignment.position)
-                                }
-                                if (((targetDt == DataType.UWORD || targetDt == DataType.WORD) && cv > 15.0) ||
-                                        ((targetDt == DataType.UBYTE || targetDt == DataType.BYTE) && cv > 7.0)) {
-                                    assignment.value = LiteralValue.optimalInteger(0, assignment.value.position)
-                                    assignment.value.linkParents(assignment)
-                                    optimizationsDone++
-                                } else {
-                                    // replace by in-place lsr(...) call
-                                    val scope = AnonymousScope(mutableListOf(), assignment.position)
-                                    var numshifts = cv.toInt()
-                                    while (numshifts > 0) {
-                                        scope.statements.add(FunctionCallStatement(IdentifierReference(listOf("lsr"), assignment.position), mutableListOf(bexpr.left), assignment.position))
-                                        numshifts--
-                                    }
-                                    optimizationsDone++
-                                    return scope
+                        }
+                        ">>" -> {
+                            if (cv == 0.0) {
+                                optimizationsDone++
+                                return NopStatement.insteadOf(assignment)
+                            }
+                            if (((targetDt == DataType.UWORD || targetDt == DataType.WORD) && cv > 15.0) ||
+                                    ((targetDt == DataType.UBYTE || targetDt == DataType.BYTE) && cv > 7.0)) {
+                                assignment.value = LiteralValue.optimalInteger(0, assignment.value.position)
+                                assignment.value.linkParents(assignment)
+                                optimizationsDone++
+                            } else {
+                                // replace by in-place lsr(...) call
+                                val scope = AnonymousScope(mutableListOf(), assignment.position)
+                                var numshifts = cv.toInt()
+                                while (numshifts > 0) {
+                                    scope.statements.add(FunctionCallStatement(IdentifierReference(listOf("lsr"), assignment.position), mutableListOf(bexpr.left), assignment.position))
+                                    numshifts--
                                 }
+                                optimizationsDone++
+                                return scope
                             }
                         }
                     }
@@ -596,32 +611,64 @@ internal class StatementOptimizer(private val program: Program, private val opti
             }
         }
 
-        return super.process(assignment)
+
+        return super.visit(assignment)
     }
 
-    override fun process(scope: AnonymousScope): IStatement {
+    override fun visit(scope: AnonymousScope): IStatement {
         val linesToRemove = deduplicateAssignments(scope.statements)
         if(linesToRemove.isNotEmpty()) {
             linesToRemove.reversed().forEach{scope.statements.removeAt(it)}
         }
-
-        if(scope.parent is INameScope) {
-            scopesToFlatten.add(scope)  // get rid of the anonymous scope
-        }
-
-        return super.process(scope)
+        return super.visit(scope)
     }
 
-    override fun process(label: Label): IStatement {
+    override fun visit(label: Label): IStatement {
         // remove duplicate labels
         val stmts = label.definingScope().statements
         val startIdx = stmts.indexOf(label)
         if(startIdx<(stmts.size-1) && stmts[startIdx+1] == label)
-            return NopStatement(label.position)
+            return NopStatement.insteadOf(label)
 
-        return super.process(label)
+        return super.visit(label)
     }
 }
 
 
 
+internal class FlattenAnonymousScopesAndRemoveNops: IAstVisitor {
+    private var scopesToFlatten = mutableListOf<INameScope>()
+    private val nopStatements = mutableListOf<NopStatement>()
+
+    override fun visit(program: Program) {
+        super.visit(program)
+        for(scope in scopesToFlatten.reversed()) {
+            val namescope = scope.parent as INameScope
+            val idx = namescope.statements.indexOf(scope as IStatement)
+            if(idx>=0) {
+                val nop = NopStatement.insteadOf(namescope.statements[idx])
+                nop.parent = namescope as Node
+                namescope.statements[idx] = nop
+                namescope.statements.addAll(idx, scope.statements)
+                scope.statements.forEach { it.parent = namescope }
+                visit(nop)
+            }
+        }
+
+        this.nopStatements.forEach {
+            it.definingScope().remove(it)
+        }
+    }
+
+    override fun visit(scope: AnonymousScope) {
+        if(scope.parent is INameScope) {
+            scopesToFlatten.add(scope)  // get rid of the anonymous scope
+        }
+
+        return super.visit(scope)
+    }
+
+    override fun visit(nopStatement: NopStatement) {
+        nopStatements.add(nopStatement)
+    }
+}

compiler/src/prog8/parser/ModuleParsing.kt

@@ -2,6 +2,12 @@ package prog8.parser
 
 import org.antlr.v4.runtime.*
 import prog8.ast.*
+import prog8.ast.antlr.toAst
+import prog8.ast.base.Position
+import prog8.ast.base.SyntaxError
+import prog8.ast.base.checkImportedValid
+import prog8.ast.statements.Directive
+import prog8.ast.statements.DirectiveArg
 import java.io.InputStream
 import java.nio.file.Files
 import java.nio.file.Path
@@ -40,13 +46,13 @@ internal fun importModule(program: Program, filePath: Path): Module {
         throw ParsingFailedError("No such file: $filePath")
 
     val input = CharStreams.fromPath(filePath)
-    return importModule(program, input, filePath, filePath.parent==null)
+    return importModule(program, input, filePath, false)
 }
 
 internal fun importLibraryModule(program: Program, name: String): Module? {
     val import = Directive("%import", listOf(
-            DirectiveArg("", name, 42, position = Position("<<<implicit-import>>>", 0, 0 ,0))
-    ), Position("<<<implicit-import>>>", 0, 0 ,0))
+            DirectiveArg("", name, 42, position = Position("<<<implicit-import>>>", 0, 0, 0))
+    ), Position("<<<implicit-import>>>", 0, 0, 0))
     return executeImportDirective(program, import, Paths.get(""))
 }
 
@@ -71,7 +77,7 @@ internal fun importModule(program: Program, stream: CharStream, modulePath: Path
     moduleAst.linkParents(program.namespace)
     program.modules.add(moduleAst)
 
-    // process additional imports
+    // accept additional imports
     val lines = moduleAst.statements.toMutableList()
     lines.asSequence()
          .mapIndexed { i, it -> Pair(i, it) }

compiler/src/prog8/stackvm/Memory.kt

@@ -1,102 +0,0 @@
-package prog8.stackvm
-
-import prog8.compiler.target.c64.Mflpt5
-import prog8.compiler.target.c64.Petscii
-import kotlin.math.abs
-
-class Memory {
-    private val mem = ShortArray(65536)         // shorts because byte is signed and we store values 0..255
-
-    fun getUByte(address: Int): Short {
-        return mem[address]
-    }
-
-    fun getSByte(address: Int): Short {
-        val ubyte = getUByte(address)
-        if(ubyte <= 127)
-            return ubyte
-        return (-((ubyte.toInt() xor 255)+1)).toShort()   // 2's complement
-    }
-
-    fun setUByte(address: Int, value: Short) {
-        if(value !in 0..255)
-            throw VmExecutionException("ubyte value out of range")
-        mem[address] = value
-    }
-
-    fun setSByte(address: Int, value: Short) {
-        if(value !in -128..127) throw VmExecutionException("byte value out of range")
-        if(value>=0)
-            mem[address] = value
-        else
-            mem[address] = ((abs(value.toInt()) xor 255)+1).toShort()        // 2's complement
-    }
-
-    fun getUWord(address: Int): Int {
-        return mem[address] + 256*mem[address+1]
-    }
-
-    fun getSWord(address: Int): Int {
-        val uword = getUWord(address)
-        if(uword <= 32767)
-            return uword
-        return -((uword xor 65535)+1)   // 2's complement
-    }
-
-    fun setUWord(address: Int, value: Int) {
-        if(value !in 0..65535)
-            throw VmExecutionException("uword value out of range")
-        mem[address] = value.and(255).toShort()
-        mem[address+1] = (value / 256).toShort()
-    }
-
-    fun setSWord(address: Int, value: Int) {
-        if(value !in -32768..32767) throw VmExecutionException("word value out of range")
-        if(value>=0)
-            setUWord(address, value)
-        else
-            setUWord(address, (abs(value) xor 65535)+1)        // 2's complement
-    }
-
-    fun setFloat(address: Int, value: Double) {
-        val mflpt5 = Mflpt5.fromNumber(value)
-        mem[address] = mflpt5.b0
-        mem[address+1] = mflpt5.b1
-        mem[address+2] = mflpt5.b2
-        mem[address+3] = mflpt5.b3
-        mem[address+4] = mflpt5.b4
-    }
-
-    fun getFloat(address: Int): Double {
-        return Mflpt5(mem[address], mem[address + 1], mem[address + 2], mem[address + 3], mem[address + 4]).toDouble()
-    }
-
-    fun setString(address: Int, str: String) {
-        // lowercase PETSCII
-        val petscii = Petscii.encodePetscii(str, true)
-        var addr = address
-        for (c in petscii) mem[addr++] = c
-        mem[addr] = 0
-    }
-
-    fun getString(strAddress: Int): String {
-        // lowercase PETSCII
-        val petscii = mutableListOf<Short>()
-        var addr = strAddress
-        while(true) {
-            val byte = mem[addr++]
-            if(byte==0.toShort()) break
-            petscii.add(byte)
-        }
-        return Petscii.decodePetscii(petscii, true)
-    }
-
-    fun clear() {
-        for(i in 0..65535) mem[i]=0
-    }
-
-    fun copy(from: Int, to: Int, numbytes: Int) {
-        for(i in 0 until numbytes)
-            mem[to+i] = mem[from+i]
-    }
-}

compiler/src/prog8/stackvm/ScreenDialog.kt

@@ -1,188 +0,0 @@
-package prog8.stackvm
-
-import prog8.compiler.target.c64.Charset
-import prog8.compiler.target.c64.Colors
-import prog8.compiler.target.c64.Petscii
-import java.awt.*
-import java.awt.event.KeyEvent
-import java.awt.event.KeyListener
-import java.awt.image.BufferedImage
-import javax.swing.JFrame
-import javax.swing.JPanel
-import javax.swing.Timer
-
-
-class BitmapScreenPanel : KeyListener, JPanel() {
-
-    private val image = BufferedImage(SCREENWIDTH, SCREENHEIGHT, BufferedImage.TYPE_INT_ARGB)
-    private val g2d = image.graphics as Graphics2D
-    private var cursorX: Int=0
-    private var cursorY: Int=0
-
-    init {
-        val size = Dimension(image.width * SCALING, image.height * SCALING)
-        minimumSize = size
-        maximumSize = size
-        preferredSize = size
-        clearScreen(6)
-        isFocusable = true
-        requestFocusInWindow()
-        addKeyListener(this)
-    }
-
-    override fun keyTyped(p0: KeyEvent?) {}
-
-    override fun keyPressed(p0: KeyEvent?) {
-        println("pressed: $p0.k")
-    }
-
-    override fun keyReleased(p0: KeyEvent?) {
-        println("released: $p0")
-    }
-
-    override fun paint(graphics: Graphics?) {
-        val g2d = graphics as Graphics2D?
-        g2d!!.setRenderingHint(RenderingHints.KEY_ANTIALIASING, RenderingHints.VALUE_ANTIALIAS_OFF)
-        g2d.setRenderingHint(RenderingHints.KEY_DITHERING, RenderingHints.VALUE_DITHER_DISABLE)
-        g2d.setRenderingHint(RenderingHints.KEY_INTERPOLATION, RenderingHints.VALUE_INTERPOLATION_NEAREST_NEIGHBOR)
-        g2d.drawImage(image, 0, 0, image.width * 3, image.height * 3, null)
-    }
-
-    fun clearScreen(color: Short) {
-        g2d.background = Colors.palette[color % Colors.palette.size]
-        g2d.clearRect(0, 0, SCREENWIDTH, SCREENHEIGHT)
-        cursorX = 0
-        cursorY = 0
-    }
-    fun setPixel(x: Int, y: Int, color: Short) {
-        image.setRGB(x, y, Colors.palette[color % Colors.palette.size].rgb)
-    }
-    fun drawLine(x1: Int, y1: Int, x2: Int, y2: Int, color: Short) {
-        g2d.color = Colors.palette[color % Colors.palette.size]
-        g2d.drawLine(x1, y1, x2, y2)
-    }
-    fun printText(text: String, color: Short, lowercase: Boolean) {
-        val lines = text.split('\n')
-        for(line in lines.withIndex()) {
-            printTextSingleLine(line.value, color, lowercase)
-            if(line.index<lines.size-1) {
-                cursorX=0
-                cursorY++
-            }
-        }
-    }
-    private fun printTextSingleLine(text: String, color: Short, lowercase: Boolean) {
-        for(clearx in cursorX until cursorX+text.length) {
-            g2d.clearRect(8*clearx, 8*y, 8, 8)
-        }
-        for(sc in Petscii.encodeScreencode(text, lowercase)) {
-            setChar(cursorX, cursorY, sc, color)
-            cursorX++
-            if(cursorX>=(SCREENWIDTH/8)) {
-                cursorY++
-                cursorX=0
-            }
-        }
-    }
-
-    fun printChar(char: Short) {
-        if(char==13.toShort() || char==141.toShort()) {
-            cursorX=0
-            cursorY++
-        } else {
-            setChar(cursorX, cursorY, char, 1)
-            cursorX++
-            if (cursorX >= (SCREENWIDTH / 8)) {
-                cursorY++
-                cursorX = 0
-            }
-        }
-    }
-
-    fun setChar(x: Int, y: Int, screenCode: Short, color: Short) {
-        g2d.clearRect(8*x, 8*y, 8, 8)
-        val colorIdx = (color % Colors.palette.size).toShort()
-        val coloredImage = Charset.getColoredChar(screenCode, colorIdx)
-        g2d.drawImage(coloredImage, 8*x, 8*y , null)
-    }
-
-    fun setCursorPos(x: Int, y: Int) {
-        cursorX = x
-        cursorY = y
-    }
-
-    fun getCursorPos(): Pair<Int, Int> {
-        return Pair(cursorX, cursorY)
-    }
-
-    fun writeText(x: Int, y: Int, text: String, color: Short, lowercase: Boolean) {
-        var xx=x
-        for(clearx in xx until xx+text.length) {
-            g2d.clearRect(8*clearx, 8*y, 8, 8)
-        }
-        for(sc in Petscii.encodeScreencode(text, lowercase)) {
-            setChar(xx++, y, sc, color)
-        }
-    }
-
-
-    companion object {
-        const val SCREENWIDTH = 320
-        const val SCREENHEIGHT = 200
-        const val SCALING = 3
-    }
-}
-
-
-class ScreenDialog : JFrame() {
-    val canvas = BitmapScreenPanel()
-
-    init {
-        val borderWidth = 16
-        title = "StackVm graphics. Text I/O goes to console."
-        layout = GridBagLayout()
-        defaultCloseOperation = JFrame.EXIT_ON_CLOSE
-        isResizable = false
-
-        // the borders (top, left, right, bottom)
-        val borderTop = JPanel().apply {
-            preferredSize = Dimension(BitmapScreenPanel.SCALING * (BitmapScreenPanel.SCREENWIDTH+2*borderWidth), BitmapScreenPanel.SCALING * borderWidth)
-            background = Colors.palette[14]
-        }
-        val borderBottom = JPanel().apply {
-            preferredSize =Dimension(BitmapScreenPanel.SCALING * (BitmapScreenPanel.SCREENWIDTH+2*borderWidth), BitmapScreenPanel.SCALING * borderWidth)
-            background = Colors.palette[14]
-        }
-        val borderLeft = JPanel().apply {
-            preferredSize =Dimension(BitmapScreenPanel.SCALING * borderWidth, BitmapScreenPanel.SCALING * BitmapScreenPanel.SCREENHEIGHT)
-            background = Colors.palette[14]
-        }
-        val borderRight = JPanel().apply {
-            preferredSize =Dimension(BitmapScreenPanel.SCALING * borderWidth, BitmapScreenPanel.SCALING * BitmapScreenPanel.SCREENHEIGHT)
-            background = Colors.palette[14]
-        }
-        var c = GridBagConstraints()
-        c.gridx=0; c.gridy=1; c.gridwidth=3
-        add(borderTop, c)
-        c = GridBagConstraints()
-        c.gridx=0; c.gridy=2
-        add(borderLeft, c)
-        c = GridBagConstraints()
-        c.gridx=2; c.gridy=2
-        add(borderRight, c)
-        c = GridBagConstraints()
-        c.gridx=0; c.gridy=3; c.gridwidth=3
-        add(borderBottom, c)
-        // the screen canvas(bitmap)
-        c = GridBagConstraints()
-        c.gridx = 1; c.gridy = 2
-        add(canvas, c)
-
-        canvas.requestFocusInWindow()
-    }
-
-    fun start() {
-        val repaintTimer = Timer(1000 / 60) { repaint() }
-        repaintTimer.start()
-    }
-}

compiler/src/prog8/vm/RuntimeValue.kt

@@ -1,6 +1,10 @@
-package prog8.compiler
+package prog8.vm
 
-import prog8.ast.*
+import prog8.ast.base.*
+import prog8.ast.expressions.LiteralValue
+import prog8.ast.statements.StructDecl
+import prog8.ast.statements.ZeropageWish
+import prog8.compiler.HeapValues
 import prog8.compiler.target.c64.Petscii
 import kotlin.math.abs
 import kotlin.math.pow
@@ -11,7 +15,8 @@ import kotlin.math.pow
  * this runtime value can be used to *execute* the parsed Ast (or another intermediary form)
  * It contains a value of a variable during run time of the program and provides arithmetic operations on the value.
  */
-open class RuntimeValue(val type: DataType, num: Number?=null, val str: String?=null, val array: Array<Number>?=null, val heapId: Int?=null) {
+open class RuntimeValue(val type: DataType, num: Number?=null, val str: String?=null,
+                        val array: Array<Number>?=null, val heapId: Int?=null) {
 
     val byteval: Short?
     val wordval: Int?
@@ -24,7 +29,7 @@ open class RuntimeValue(val type: DataType, num: Number?=null, val str: String?=
                 in NumericDatatypes -> RuntimeValue(literalValue.type, num = literalValue.asNumericValue!!)
                 in StringDatatypes -> from(literalValue.heapId!!, heap)
                 in ArrayDatatypes -> from(literalValue.heapId!!, heap)
-                else -> TODO("type")
+                else -> throw IllegalArgumentException("weird source value $literalValue")
             }
         }
 
@@ -38,11 +43,18 @@ open class RuntimeValue(val type: DataType, num: Number?=null, val str: String?=
                         RuntimeValue(value.type, array = value.doubleArray!!.toList().toTypedArray(), heapId = heapId)
                     } else {
                         val array = value.array!!
-                        if (array.any { it.addressOf != null })
-                            TODO("addressof values")
-                        RuntimeValue(value.type, array = array.map { it.integer!! }.toTypedArray(), heapId = heapId)
+                        val resultArray = mutableListOf<Number>()
+                        for(elt in array.withIndex()){
+                            if(elt.value.integer!=null)
+                                resultArray.add(elt.value.integer!!)
+                            else {
+                                TODO("ADDRESSOF ${elt.value}")
+                            }
+                        }
+                        RuntimeValue(value.type, array = resultArray.toTypedArray(), heapId = heapId)
+                        //RuntimeValue(value.type, array = array.map { it.integer!! }.toTypedArray(), heapId = heapId)
                     }
-                else -> TODO("weird type on heap")
+                else -> throw IllegalArgumentException("weird value type on heap $value")
             }
         }
 
@@ -51,27 +63,37 @@ open class RuntimeValue(val type: DataType, num: Number?=null, val str: String?=
     init {
         when(type) {
             DataType.UBYTE -> {
-                byteval = (num!!.toInt() and 255).toShort()
+                val inum = num!!.toInt()
+                if(inum !in 0 .. 255)
+                    throw IllegalArgumentException("invalid value for ubyte: $inum")
+                byteval = inum.toShort()
                 wordval = null
                 floatval = null
                 asBoolean = byteval != 0.toShort()
             }
             DataType.BYTE -> {
-                val v = num!!.toInt() and 255
-                byteval = (if(v<128) v else v-256).toShort()
+                val inum = num!!.toInt()
+                if(inum !in -128 .. 127)
+                    throw IllegalArgumentException("invalid value for byte: $inum")
+                byteval = inum.toShort()
                 wordval = null
                 floatval = null
                 asBoolean = byteval != 0.toShort()
             }
             DataType.UWORD -> {
-                wordval = num!!.toInt() and 65535
+                val inum = num!!.toInt()
+                if(inum !in 0 .. 65535)
+                    throw IllegalArgumentException("invalid value for uword: $inum")
+                wordval = inum
                 byteval = null
                 floatval = null
                 asBoolean = wordval != 0
             }
             DataType.WORD -> {
-                val v = num!!.toInt() and 65535
-                wordval = if(v<32768) v else v - 65536
+                val inum = num!!.toInt()
+                if(inum !in -32768 .. 32767)
+                    throw IllegalArgumentException("invalid value for word: $inum")
+                wordval = inum
                 byteval = null
                 floatval = null
                 asBoolean = wordval != 0
@@ -102,7 +124,7 @@ open class RuntimeValue(val type: DataType, num: Number?=null, val str: String?=
             in ArrayDatatypes -> LiteralValue(type,
                     arrayvalue = array?.map { LiteralValue.optimalNumeric(it, Position("", 0, 0, 0)) }?.toTypedArray(),
                     position = Position("", 0, 0, 0))
-            else -> TODO("strange type")
+            else -> throw IllegalArgumentException("weird source value $this")
         }
     }
 
@@ -174,23 +196,47 @@ open class RuntimeValue(val type: DataType, num: Number?=null, val str: String?=
                 DataType.UBYTE, DataType.UWORD -> {
                     // storing a negative number in an unsigned one is done by storing the 2's complement instead
                     val number = abs(result.toDouble().toInt())
-                    if(leftDt==DataType.UBYTE)
+                    if(leftDt== DataType.UBYTE)
                         RuntimeValue(DataType.UBYTE, (number xor 255) + 1)
                     else
-                        RuntimeValue(DataType.UBYTE, (number xor 65535) + 1)
+                        RuntimeValue(DataType.UWORD, (number xor 65535) + 1)
+                }
+                DataType.BYTE -> {
+                    val v=result.toInt() and 255
+                    if(v<128)
+                        RuntimeValue(DataType.BYTE, v)
+                    else
+                        RuntimeValue(DataType.BYTE, v-256)
+                }
+                DataType.WORD -> {
+                    val v=result.toInt() and 65535
+                    if(v<32768)
+                        RuntimeValue(DataType.WORD, v)
+                    else
+                        RuntimeValue(DataType.WORD, v-65536)
                 }
-                DataType.BYTE -> RuntimeValue(DataType.BYTE, result.toInt())
-                DataType.WORD -> RuntimeValue(DataType.WORD, result.toInt())
                 DataType.FLOAT -> RuntimeValue(DataType.FLOAT, result)
                 else -> throw ArithmeticException("$op on non-numeric type")
             }
         }
 
         return when(leftDt) {
-            DataType.UBYTE -> RuntimeValue(DataType.UBYTE, result.toInt())
-            DataType.BYTE -> RuntimeValue(DataType.BYTE, result.toInt())
-            DataType.UWORD -> RuntimeValue(DataType.UWORD, result.toInt())
-            DataType.WORD -> RuntimeValue(DataType.WORD, result.toInt())
+            DataType.UBYTE -> RuntimeValue(DataType.UBYTE, result.toInt() and 255)
+            DataType.BYTE -> {
+                val v = result.toInt() and 255
+                if(v<128)
+                    RuntimeValue(DataType.BYTE, v)
+                else
+                    RuntimeValue(DataType.BYTE, v-256)
+            }
+            DataType.UWORD -> RuntimeValue(DataType.UWORD, result.toInt() and 65535)
+            DataType.WORD -> {
+                val v = result.toInt() and 65535
+                if(v<32768)
+                    RuntimeValue(DataType.WORD, v)
+                else
+                    RuntimeValue(DataType.WORD, v-65536)
+            }
             DataType.FLOAT -> RuntimeValue(DataType.FLOAT, result)
             else -> throw ArithmeticException("$op on non-numeric type")
         }
@@ -266,10 +312,22 @@ open class RuntimeValue(val type: DataType, num: Number?=null, val str: String?=
     fun shl(): RuntimeValue {
         val v = integerValue()
         return when (type) {
-            DataType.UBYTE,
-            DataType.BYTE,
-            DataType.UWORD,
-            DataType.WORD -> RuntimeValue(type, v shl 1)
+            DataType.UBYTE -> RuntimeValue(type, (v shl 1) and 255)
+            DataType.UWORD -> RuntimeValue(type, (v shl 1) and 65535)
+            DataType.BYTE -> {
+                val value = v shl 1
+                if(value<128)
+                    RuntimeValue(type, value)
+                else
+                    RuntimeValue(type, value-256)
+            }
+            DataType.WORD -> {
+                val value = v shl 1
+                if(value<32768)
+                    RuntimeValue(type, value)
+                else
+                    RuntimeValue(type, value-65536)
+            }
             else -> throw ArithmeticException("invalid type for shl: $type")
         }
     }
@@ -407,16 +465,32 @@ open class RuntimeValue(val type: DataType, num: Number?=null, val str: String?=
 
     fun inv(): RuntimeValue {
         return when(type) {
-            in ByteDatatypes -> RuntimeValue(type, byteval!!.toInt().inv())
-            in WordDatatypes -> RuntimeValue(type, wordval!!.inv())
+            DataType.UBYTE -> RuntimeValue(type, byteval!!.toInt().inv() and 255)
+            DataType.UWORD -> RuntimeValue(type, wordval!!.inv() and 65535)
+            DataType.BYTE -> RuntimeValue(type, byteval!!.toInt().inv())
+            DataType.WORD -> RuntimeValue(type, wordval!!.inv())
             else -> throw ArithmeticException("inv can only work on byte/word")
         }
     }
 
     fun inc(): RuntimeValue {
         return when(type) {
-            in ByteDatatypes -> RuntimeValue(type, byteval!! + 1)
-            in WordDatatypes -> RuntimeValue(type, wordval!! + 1)
+            DataType.UBYTE -> RuntimeValue(type, (byteval!! + 1) and 255)
+            DataType.UWORD -> RuntimeValue(type, (wordval!! + 1) and 65535)
+            DataType.BYTE -> {
+                val newval = byteval!! + 1
+                if(newval == 128)
+                    RuntimeValue(type, -128)
+                else
+                    RuntimeValue(type, newval)
+            }
+            DataType.WORD -> {
+                val newval = wordval!! + 1
+                if(newval == 32768)
+                    RuntimeValue(type, -32768)
+                else
+                    RuntimeValue(type, newval)
+            }
             DataType.FLOAT -> RuntimeValue(DataType.FLOAT, floatval!! + 1)
             else -> throw ArithmeticException("inc can only work on numeric types")
         }
@@ -424,8 +498,22 @@ open class RuntimeValue(val type: DataType, num: Number?=null, val str: String?=
 
     fun dec(): RuntimeValue {
         return when(type) {
-            in ByteDatatypes -> RuntimeValue(type, byteval!! - 1)
-            in WordDatatypes -> RuntimeValue(type, wordval!! - 1)
+            DataType.UBYTE -> RuntimeValue(type, (byteval!! - 1) and 255)
+            DataType.UWORD -> RuntimeValue(type, (wordval!! - 1) and 65535)
+            DataType.BYTE -> {
+                val newval = byteval!! - 1
+                if(newval == -129)
+                    RuntimeValue(type, 127)
+                else
+                    RuntimeValue(type, newval)
+            }
+            DataType.WORD -> {
+                val newval = wordval!! - 1
+                if(newval == -32769)
+                    RuntimeValue(type, 32767)
+                else
+                    RuntimeValue(type, newval)
+            }
             DataType.FLOAT -> RuntimeValue(DataType.FLOAT, floatval!! - 1)
             else -> throw ArithmeticException("dec can only work on numeric types")
         }
@@ -444,9 +532,21 @@ open class RuntimeValue(val type: DataType, num: Number?=null, val str: String?=
             DataType.UBYTE -> {
                 when (targetType) {
                     DataType.UBYTE -> this
-                    DataType.BYTE -> RuntimeValue(DataType.BYTE, byteval)
+                    DataType.BYTE -> {
+                        val nval=byteval!!.toInt()
+                        if(nval<128)
+                            RuntimeValue(DataType.BYTE, nval)
+                        else
+                            RuntimeValue(DataType.BYTE, nval-256)
+                    }
                     DataType.UWORD -> RuntimeValue(DataType.UWORD, numericValue())
-                    DataType.WORD -> RuntimeValue(DataType.WORD, numericValue())
+                    DataType.WORD -> {
+                        val nval = numericValue().toInt()
+                        if(nval<32768)
+                            RuntimeValue(DataType.WORD, nval)
+                        else
+                            RuntimeValue(DataType.WORD, nval-65536)
+                    }
                     DataType.FLOAT -> RuntimeValue(DataType.FLOAT, numericValue())
                     else -> throw ArithmeticException("invalid type cast from $type to $targetType")
                 }
@@ -454,8 +554,8 @@ open class RuntimeValue(val type: DataType, num: Number?=null, val str: String?=
             DataType.BYTE -> {
                 when (targetType) {
                     DataType.BYTE -> this
-                    DataType.UBYTE -> RuntimeValue(DataType.UBYTE, integerValue())
-                    DataType.UWORD -> RuntimeValue(DataType.UWORD, integerValue())
+                    DataType.UBYTE -> RuntimeValue(DataType.UBYTE, integerValue() and 255)
+                    DataType.UWORD -> RuntimeValue(DataType.UWORD, integerValue() and 65535)
                     DataType.WORD -> RuntimeValue(DataType.WORD, integerValue())
                     DataType.FLOAT -> RuntimeValue(DataType.FLOAT, numericValue())
                     else -> throw ArithmeticException("invalid type cast from $type to $targetType")
@@ -463,18 +563,36 @@ open class RuntimeValue(val type: DataType, num: Number?=null, val str: String?=
             }
             DataType.UWORD -> {
                 when (targetType) {
-                    DataType.BYTE -> RuntimeValue(DataType.BYTE, integerValue())
-                    DataType.UBYTE -> RuntimeValue(DataType.UBYTE, integerValue())
+                    DataType.BYTE -> {
+                        val v=integerValue()
+                        if(v<128)
+                            RuntimeValue(DataType.BYTE, v)
+                        else
+                            RuntimeValue(DataType.BYTE, v-256)
+                    }
+                    DataType.UBYTE -> RuntimeValue(DataType.UBYTE, integerValue() and 255)
                     DataType.UWORD -> this
-                    DataType.WORD -> RuntimeValue(DataType.WORD, integerValue())
+                    DataType.WORD -> {
+                        val v=integerValue()
+                        if(v<32768)
+                            RuntimeValue(DataType.WORD, v)
+                        else
+                            RuntimeValue(DataType.WORD, v-65536)
+                    }
                     DataType.FLOAT -> RuntimeValue(DataType.FLOAT, numericValue())
                     else -> throw ArithmeticException("invalid type cast from $type to $targetType")
                 }
             }
             DataType.WORD -> {
                 when (targetType) {
-                    DataType.BYTE -> RuntimeValue(DataType.BYTE, integerValue())
-                    DataType.UBYTE -> RuntimeValue(DataType.UBYTE, integerValue())
+                    DataType.BYTE -> {
+                        val v = integerValue() and 255
+                        if(v<128)
+                            RuntimeValue(DataType.BYTE, v)
+                        else
+                            RuntimeValue(DataType.BYTE, v-256)
+                    }
+                    DataType.UBYTE -> RuntimeValue(DataType.UBYTE, integerValue() and 65535)
                     DataType.UWORD -> RuntimeValue(DataType.UWORD, integerValue())
                     DataType.WORD -> this
                     DataType.FLOAT -> RuntimeValue(DataType.FLOAT, numericValue())

compiler/src/prog8/vm/astvm/AstVm.kt

@@ -0,0 +1,954 @@
+package prog8.vm.astvm
+
+import prog8.ast.*
+import prog8.ast.base.*
+import prog8.ast.base.initvarsSubName
+import prog8.ast.expressions.IdentifierReference
+import prog8.ast.expressions.LiteralValue
+import prog8.ast.statements.*
+import prog8.compiler.target.c64.MachineDefinition
+import prog8.vm.RuntimeValue
+import prog8.vm.RuntimeValueRange
+import prog8.compiler.target.c64.Petscii
+import java.awt.EventQueue
+import java.io.CharConversionException
+import java.util.*
+import kotlin.NoSuchElementException
+import kotlin.concurrent.fixedRateTimer
+import kotlin.math.*
+import kotlin.random.Random
+
+
+class VmExecutionException(msg: String?) : Exception(msg)
+
+class VmTerminationException(msg: String?) : Exception(msg)
+
+class VmBreakpointException : Exception("breakpoint")
+
+
+class StatusFlags {
+    var carry: Boolean = false
+    var zero: Boolean = true
+    var negative: Boolean = false
+    var irqd: Boolean = false
+
+    private fun setFlags(value: LiteralValue?) {
+        if (value != null) {
+            when (value.type) {
+                DataType.UBYTE -> {
+                    val v = value.bytevalue!!.toInt()
+                    negative = v > 127
+                    zero = v == 0
+                }
+                DataType.BYTE -> {
+                    val v = value.bytevalue!!.toInt()
+                    negative = v < 0
+                    zero = v == 0
+                }
+                DataType.UWORD -> {
+                    val v = value.wordvalue!!
+                    negative = v > 32767
+                    zero = v == 0
+                }
+                DataType.WORD -> {
+                    val v = value.wordvalue!!
+                    negative = v < 0
+                    zero = v == 0
+                }
+                DataType.FLOAT -> {
+                    val flt = value.floatvalue!!
+                    negative = flt < 0.0
+                    zero = flt == 0.0
+                }
+                else -> {
+                    // no flags for non-numeric type
+                }
+            }
+        }
+    }
+}
+
+
+class RuntimeVariables {
+    fun define(scope: INameScope, name: String, initialValue: RuntimeValue) {
+        val where = vars.getValue(scope)
+        where[name] = initialValue
+        vars[scope] = where
+    }
+
+    fun defineMemory(scope: INameScope, name: String, address: Int) {
+        val where = memvars.getValue(scope)
+        where[name] = address
+        memvars[scope] = where
+    }
+
+    fun set(scope: INameScope, name: String, value: RuntimeValue) {
+        val where = vars.getValue(scope)
+        val existing = where[name]
+        if(existing==null) {
+            if(memvars.getValue(scope)[name]!=null)
+                throw NoSuchElementException("this is a memory mapped var, not a normal var: ${scope.name}.$name")
+            throw NoSuchElementException("no such runtime variable: ${scope.name}.$name")
+        }
+        if(existing.type!=value.type)
+            throw VmExecutionException("new value is of different datatype ${value.type} expected ${existing.type} for $name")
+        where[name] = value
+        vars[scope] = where
+    }
+
+    fun get(scope: INameScope, name: String): RuntimeValue {
+        val where = vars.getValue(scope)
+        return where[name] ?: throw NoSuchElementException("no such runtime variable: ${scope.name}.$name")
+    }
+
+    fun getMemoryAddress(scope: INameScope, name: String): Int {
+        val where = memvars.getValue(scope)
+        return where[name] ?: throw NoSuchElementException("no such runtime memory-variable: ${scope.name}.$name")
+    }
+
+    fun swap(a1: VarDecl, a2: VarDecl) = swap(a1.definingScope(), a1.name, a2.definingScope(), a2.name)
+
+    fun swap(scope1: INameScope, name1: String, scope2: INameScope, name2: String) {
+        val v1 = get(scope1, name1)
+        val v2 = get(scope2, name2)
+        set(scope1, name1, v2)
+        set(scope2, name2, v1)
+    }
+
+    private val vars = mutableMapOf<INameScope, MutableMap<String, RuntimeValue>>().withDefault { mutableMapOf() }
+    private val memvars = mutableMapOf<INameScope, MutableMap<String, Int>>().withDefault { mutableMapOf() }
+}
+
+
+class AstVm(val program: Program) {
+
+    val mem = Memory(::memread, ::memwrite)
+    val statusflags = StatusFlags()
+
+    private var dialog = ScreenDialog("AstVM")
+    var instructionCounter = 0
+    val bootTime = System.currentTimeMillis()
+    var rtcOffset = bootTime
+
+    private val rnd = Random(0)
+    private val statusFlagsSave = Stack<StatusFlags>()
+    private val registerXsave = Stack<RuntimeValue>()
+    private val registerYsave = Stack<RuntimeValue>()
+    private val registerAsave = Stack<RuntimeValue>()
+
+
+    init {
+        // observe the jiffyclock and screen matrix
+        mem.observe(0xa0, 0xa1, 0xa2)
+        for(i in 1024..2023)
+            mem.observe(i)
+
+        dialog.requestFocusInWindow()
+
+        EventQueue.invokeLater {
+            dialog.pack()
+            dialog.isVisible = true
+            dialog.start()
+        }
+
+        fixedRateTimer("60hz-irq", true, period=1000/60) {
+            irq(this.scheduledExecutionTime())
+        }
+    }
+
+    fun memread(address: Int, value: Short): Short {
+        // println("MEM READ  $address  -> $value")
+        return value
+    }
+
+    fun memwrite(address: Int, value: Short): Short {
+        if(address==0xa0 || address==0xa1 || address==0xa2) {
+            // a write to the jiffy clock, update the clock offset for the irq
+            val time_hi = if(address==0xa0) value else mem.getUByte_DMA(0xa0)
+            val time_mid = if(address==0xa1) value else mem.getUByte_DMA(0xa1)
+            val time_lo = if(address==0xa2) value else mem.getUByte_DMA(0xa2)
+            val jiffies = (time_hi.toInt() shl 16) + (time_mid.toInt() shl 8) + time_lo
+            rtcOffset = bootTime - (jiffies*1000/60)
+        }
+        if(address in 1024..2023) {
+            // write to the screen matrix
+            val scraddr = address-1024
+            dialog.canvas.setChar(scraddr % 40, scraddr / 40, value, 1)
+        }
+        return value
+    }
+
+    fun run() {
+        try {
+            val init = VariablesCreator(runtimeVariables, program.heap)
+            init.visit(program)
+
+            // initialize all global variables
+            for (m in program.modules) {
+                for (b in m.statements.filterIsInstance<Block>()) {
+                    for (s in b.statements.filterIsInstance<Subroutine>()) {
+                        if (s.name == initvarsSubName) {
+                            try {
+                                executeSubroutine(s, emptyList(), null)
+                            } catch (x: LoopControlReturn) {
+                                // regular return
+                            }
+                        }
+                    }
+                }
+            }
+
+            var entrypoint: Subroutine? = program.entrypoint() ?: throw VmTerminationException("no valid entrypoint found")
+            var startlabel: Label? = null
+
+            while(entrypoint!=null) {
+                try {
+                    executeSubroutine(entrypoint, emptyList(), startlabel)
+                    entrypoint = null
+                } catch (rx: LoopControlReturn) {
+                    // regular return
+                } catch (jx: LoopControlJump) {
+                    if (jx.address != null)
+                        throw VmTerminationException("doesn't support jumping to machine address ${jx.address}")
+                    when {
+                        jx.generatedLabel != null -> {
+                            val label = entrypoint.getLabelOrVariable(jx.generatedLabel) as Label
+                            TODO("generatedlabel $label")
+                        }
+                        jx.identifier != null -> {
+                            when (val jumptarget = entrypoint.lookup(jx.identifier.nameInSource, jx.identifier.parent)) {
+                                is Label -> {
+                                    startlabel = jumptarget
+                                    entrypoint = jumptarget.definingSubroutine()
+                                }
+                                is Subroutine -> entrypoint = jumptarget
+                                else -> throw VmTerminationException("weird jump target $jumptarget")
+                            }
+                        }
+                        else -> throw VmTerminationException("unspecified jump target")
+                    }
+                }
+            }
+            dialog.canvas.printText("\n<program ended>", true)
+            println("PROGRAM EXITED!")
+            dialog.title = "PROGRAM EXITED"
+        } catch (tx: VmTerminationException) {
+            println("Execution halted: ${tx.message}")
+        } catch (xx: VmExecutionException) {
+            println("Execution error: ${xx.message}")
+            throw xx
+        }
+    }
+
+    private fun irq(timeStamp: Long) {
+        // 60hz IRQ handling
+        if(statusflags.irqd)
+            return      // interrupt is disabled
+
+        var jiffies = (timeStamp-rtcOffset)*60/1000
+        if(jiffies>24*3600*60-1) {
+            jiffies = 0
+            rtcOffset = timeStamp
+        }
+        // update the C-64 60hz jiffy clock in the ZP addresses:
+        mem.setUByte_DMA(0x00a0, (jiffies ushr 16).toShort())
+        mem.setUByte_DMA(0x00a1, (jiffies ushr 8 and 255).toShort())
+        mem.setUByte_DMA(0x00a2, (jiffies and 255).toShort())
+    }
+
+    private val runtimeVariables = RuntimeVariables()
+    private val evalCtx = EvalContext(program, mem, statusflags, runtimeVariables, ::performBuiltinFunction, ::executeSubroutine)
+
+    class LoopControlBreak : Exception()
+    class LoopControlContinue : Exception()
+    class LoopControlReturn(val returnvalue: RuntimeValue?) : Exception()
+    class LoopControlJump(val identifier: IdentifierReference?, val address: Int?, val generatedLabel: String?) : Exception()
+
+
+    internal fun executeSubroutine(sub: Subroutine, arguments: List<RuntimeValue>, startAtLabel: Label?=null): RuntimeValue? {
+        if(sub.isAsmSubroutine) {
+            return performSyscall(sub, arguments)
+        }
+
+        if (sub.statements.isEmpty())
+            throw VmTerminationException("scope contains no statements: $sub")
+        if (arguments.size != sub.parameters.size)
+            throw VmTerminationException("number of args doesn't match number of required parameters")
+
+        for (arg in sub.parameters.zip(arguments)) {
+            val idref = IdentifierReference(listOf(arg.first.name), sub.position)
+            performAssignment(AssignTarget(null, idref, null, null, idref.position),
+                    arg.second, sub.statements.first(), evalCtx)
+        }
+
+        val statements = sub.statements.iterator()
+        if(startAtLabel!=null) {
+            do {
+                val stmt = statements.next()
+            } while(stmt!==startAtLabel)
+        }
+
+        try {
+            while(statements.hasNext()) {
+                val s = statements.next()
+                try {
+                    executeStatement(sub, s)
+                }
+                catch (b: VmBreakpointException) {
+                    print("BREAKPOINT HIT at ${s.position} - Press enter to continue:")
+                    readLine()
+                }
+            }
+        } catch (r: LoopControlReturn) {
+            return r.returnvalue
+        }
+        throw VmTerminationException("instruction pointer overflow, is a return missing? $sub")
+    }
+
+    internal fun executeAnonymousScope(scope: INameScope) {
+        for (s in scope.statements) {
+            executeStatement(scope, s)
+        }
+    }
+
+
+    private fun executeStatement(sub: INameScope, stmt: IStatement) {
+        instructionCounter++
+        if (instructionCounter % 200 == 0)
+            Thread.sleep(1)
+        when (stmt) {
+            is NopStatement, is Label, is Subroutine -> {
+                // do nothing, skip this instruction
+            }
+            is Directive -> {
+                if (stmt.directive == "%breakpoint")
+                    throw VmBreakpointException()
+                else if (stmt.directive == "%asm")
+                    throw VmExecutionException("can't execute assembly code")
+            }
+            is VarDecl -> {
+                // should have been defined already when the program started
+            }
+            is FunctionCallStatement -> {
+                val target = stmt.target.targetStatement(program.namespace)
+                when (target) {
+                    is Subroutine -> {
+                        val args = evaluate(stmt.arglist)
+                        if (target.isAsmSubroutine) {
+                            performSyscall(target, args)
+                        } else {
+                            executeSubroutine(target, args, null)
+                            // any return value(s) are discarded
+                        }
+                    }
+                    is BuiltinFunctionStatementPlaceholder -> {
+                        if(target.name=="swap") {
+                            // swap cannot be implemented as a function, so inline it here
+                            executeSwap(stmt)
+                        } else {
+                            val args = evaluate(stmt.arglist)
+                            performBuiltinFunction(target.name, args, statusflags)
+                        }
+                    }
+                    else -> {
+                        TODO("weird call $target")
+                    }
+                }
+            }
+            is Return -> {
+                val value =
+                        if(stmt.value==null)
+                            null
+                        else
+                            evaluate(stmt.value!!, evalCtx)
+                throw LoopControlReturn(value)
+            }
+            is Continue -> throw LoopControlContinue()
+            is Break -> throw LoopControlBreak()
+            is Assignment -> {
+                if (stmt.aug_op != null)
+                    throw VmExecutionException("augmented assignment should have been converted into regular one $stmt")
+                val value = evaluate(stmt.value, evalCtx)
+                performAssignment(stmt.target, value, stmt, evalCtx)
+            }
+            is PostIncrDecr -> {
+                when {
+                    stmt.target.identifier != null -> {
+                        val ident = stmt.definingScope().lookup(stmt.target.identifier!!.nameInSource, stmt) as VarDecl
+                        val identScope = ident.definingScope()
+                        when(ident.type){
+                            VarDeclType.VAR -> {
+                                var value = runtimeVariables.get(identScope, ident.name)
+                                value = when {
+                                    stmt.operator == "++" -> value.add(RuntimeValue(value.type, 1))
+                                    stmt.operator == "--" -> value.sub(RuntimeValue(value.type, 1))
+                                    else -> throw VmExecutionException("strange postincdec operator $stmt")
+                                }
+                                runtimeVariables.set(identScope, ident.name, value)
+                            }
+                            VarDeclType.MEMORY -> {
+                                val addr=ident.value!!.constValue(program)!!.asIntegerValue!!
+                                val newval = when {
+                                    stmt.operator == "++" -> mem.getUByte(addr)+1 and 255
+                                    stmt.operator == "--" -> mem.getUByte(addr)-1 and 255
+                                    else -> throw VmExecutionException("strange postincdec operator $stmt")
+                                }
+                                mem.setUByte(addr,newval.toShort())
+                            }
+                            VarDeclType.CONST -> throw VmExecutionException("can't be const")
+                        }
+                    }
+                    stmt.target.memoryAddress != null -> {
+                        val addr = evaluate(stmt.target.memoryAddress!!.addressExpression, evalCtx).integerValue()
+                        val newval = when {
+                            stmt.operator == "++" -> mem.getUByte(addr)+1 and 255
+                            stmt.operator == "--" -> mem.getUByte(addr)-1 and 255
+                            else -> throw VmExecutionException("strange postincdec operator $stmt")
+                        }
+                        mem.setUByte(addr,newval.toShort())
+                    }
+                    stmt.target.arrayindexed != null -> {
+                        val arrayvar = stmt.target.arrayindexed!!.identifier.targetVarDecl(program.namespace)!!
+                        val arrayvalue = runtimeVariables.get(arrayvar.definingScope(), arrayvar.name)
+                        val elementType = stmt.target.arrayindexed!!.inferType(program)!!
+                        val index = evaluate(stmt.target.arrayindexed!!.arrayspec.index, evalCtx).integerValue()
+                        var value = RuntimeValue(elementType, arrayvalue.array!![index].toInt())
+                        when {
+                            stmt.operator == "++" -> value=value.inc()
+                            stmt.operator == "--" -> value=value.dec()
+                            else -> throw VmExecutionException("strange postincdec operator $stmt")
+                        }
+                        arrayvalue.array[index] = value.numericValue()
+                    }
+                    stmt.target.register != null -> {
+                        var value = runtimeVariables.get(program.namespace, stmt.target.register!!.name)
+                        value = when {
+                            stmt.operator == "++" -> value.add(RuntimeValue(value.type, 1))
+                            stmt.operator == "--" -> value.sub(RuntimeValue(value.type, 1))
+                            else -> throw VmExecutionException("strange postincdec operator $stmt")
+                        }
+                        runtimeVariables.set(program.namespace, stmt.target.register!!.name, value)
+                    }
+                    else -> throw VmExecutionException("empty postincrdecr? $stmt")
+                }
+            }
+            is Jump -> throw LoopControlJump(stmt.identifier, stmt.address, stmt.generatedLabel)
+            is InlineAssembly -> {
+                if (sub is Subroutine) {
+                    val args = sub.parameters.map { runtimeVariables.get(sub, it.name) }
+                    performSyscall(sub, args)
+                    throw LoopControlReturn(null)
+                }
+                throw VmExecutionException("can't execute inline assembly in $sub")
+            }
+            is AnonymousScope -> executeAnonymousScope(stmt)
+            is IfStatement -> {
+                val condition = evaluate(stmt.condition, evalCtx)
+                if (condition.asBoolean)
+                    executeAnonymousScope(stmt.truepart)
+                else
+                    executeAnonymousScope(stmt.elsepart)
+            }
+            is BranchStatement -> {
+                when(stmt.condition) {
+                    BranchCondition.CS -> if(statusflags.carry) executeAnonymousScope(stmt.truepart) else executeAnonymousScope(stmt.elsepart)
+                    BranchCondition.CC -> if(!statusflags.carry) executeAnonymousScope(stmt.truepart) else executeAnonymousScope(stmt.elsepart)
+                    BranchCondition.EQ, BranchCondition.Z -> if(statusflags.zero) executeAnonymousScope(stmt.truepart) else executeAnonymousScope(stmt.elsepart)
+                    BranchCondition.NE, BranchCondition.NZ -> if(statusflags.zero) executeAnonymousScope(stmt.truepart) else executeAnonymousScope(stmt.elsepart)
+                    BranchCondition.MI, BranchCondition.NEG -> if(statusflags.negative) executeAnonymousScope(stmt.truepart) else executeAnonymousScope(stmt.elsepart)
+                    BranchCondition.PL, BranchCondition.POS -> if(statusflags.negative) executeAnonymousScope(stmt.truepart) else executeAnonymousScope(stmt.elsepart)
+                    BranchCondition.VS, BranchCondition.VC -> TODO("overflow status")
+                }
+            }
+            is ForLoop -> {
+                val iterable = evaluate(stmt.iterable, evalCtx)
+                if (iterable.type !in IterableDatatypes && iterable !is RuntimeValueRange)
+                    throw VmExecutionException("can only iterate over an iterable value:  $stmt")
+                val loopvarDt: DataType
+                val loopvar: IdentifierReference
+                if (stmt.loopRegister != null) {
+                    loopvarDt = DataType.UBYTE
+                    loopvar = IdentifierReference(listOf(stmt.loopRegister.name), stmt.position)
+                } else {
+                    loopvarDt = stmt.loopVar!!.inferType(program)!!
+                    loopvar = stmt.loopVar
+                }
+                val iterator = iterable.iterator()
+                for (loopvalue in iterator) {
+                    try {
+                        oneForCycle(stmt, loopvarDt, loopvalue, loopvar)
+                    } catch (b: LoopControlBreak) {
+                        break
+                    } catch (c: LoopControlContinue) {
+                        continue
+                    }
+                }
+            }
+            is WhileLoop -> {
+                var condition = evaluate(stmt.condition, evalCtx)
+                while (condition.asBoolean) {
+                    try {
+                        executeAnonymousScope(stmt.body)
+                        condition = evaluate(stmt.condition, evalCtx)
+                    } catch (b: LoopControlBreak) {
+                        break
+                    } catch (c: LoopControlContinue) {
+                        continue
+                    }
+                }
+            }
+            is RepeatLoop -> {
+                do {
+                    val condition = evaluate(stmt.untilCondition, evalCtx)
+                    try {
+                        executeAnonymousScope(stmt.body)
+                    } catch (b: LoopControlBreak) {
+                        break
+                    } catch (c: LoopControlContinue) {
+                        continue
+                    }
+                } while (!condition.asBoolean)
+            }
+            is WhenStatement -> {
+                val condition=evaluate(stmt.condition, evalCtx)
+                for(choice in stmt.choices) {
+                    if(choice.values==null) {
+                        // the 'else' choice
+                        executeAnonymousScope(choice.statements)
+                        break
+                    } else {
+                        val value = choice.values.single().constValue(evalCtx.program) ?: throw VmExecutionException("can only use const values in when choices ${choice.position}")
+                        val rtval = RuntimeValue.from(value, evalCtx.program.heap)
+                        if(condition==rtval) {
+                            executeAnonymousScope(choice.statements)
+                            break
+                        }
+                    }
+                }
+            }
+            else -> {
+                TODO("implement $stmt")
+            }
+        }
+    }
+
+    private fun executeSwap(swap: FunctionCallStatement) {
+        val v1 = swap.arglist[0]
+        val v2 = swap.arglist[1]
+        val value1 = evaluate(v1, evalCtx)
+        val value2 = evaluate(v2, evalCtx)
+        val target1 = AssignTarget.fromExpr(v1)
+        val target2 = AssignTarget.fromExpr(v2)
+        performAssignment(target1, value2, swap, evalCtx)
+        performAssignment(target2, value1, swap, evalCtx)
+    }
+
+    fun performAssignment(target: AssignTarget, value: RuntimeValue, contextStmt: IStatement, evalCtx: EvalContext) {
+        when {
+            target.identifier != null -> {
+                val decl = contextStmt.definingScope().lookup(target.identifier.nameInSource, contextStmt) as? VarDecl
+                        ?: throw VmExecutionException("can't find assignment target ${target.identifier}")
+                if (decl.type == VarDeclType.MEMORY) {
+                    val address = runtimeVariables.getMemoryAddress(decl.definingScope(), decl.name)
+                    when (decl.datatype) {
+                        DataType.UBYTE -> mem.setUByte(address, value.byteval!!)
+                        DataType.BYTE -> mem.setSByte(address, value.byteval!!)
+                        DataType.UWORD -> mem.setUWord(address, value.wordval!!)
+                        DataType.WORD -> mem.setSWord(address, value.wordval!!)
+                        DataType.FLOAT -> mem.setFloat(address, value.floatval!!)
+                        DataType.STR -> mem.setString(address, value.str!!)
+                        DataType.STR_S -> mem.setScreencodeString(address, value.str!!)
+                        else -> throw VmExecutionException("weird memaddress type $decl")
+                    }
+                } else
+                    runtimeVariables.set(decl.definingScope(), decl.name, value)
+            }
+            target.memoryAddress != null -> {
+                val address = evaluate(target.memoryAddress!!.addressExpression, evalCtx).wordval!!
+                evalCtx.mem.setUByte(address, value.byteval!!)
+            }
+            target.arrayindexed != null -> {
+                val vardecl = target.arrayindexed.identifier.targetVarDecl(program.namespace)!!
+                if(vardecl.type==VarDeclType.VAR) {
+                    val array = evaluate(target.arrayindexed.identifier, evalCtx)
+                    val index = evaluate(target.arrayindexed.arrayspec.index, evalCtx)
+                    when (array.type) {
+                        DataType.ARRAY_UB -> {
+                            if (value.type != DataType.UBYTE)
+                                throw VmExecutionException("new value is of different datatype ${value.type} for $array")
+                        }
+                        DataType.ARRAY_B -> {
+                            if (value.type != DataType.BYTE)
+                                throw VmExecutionException("new value is of different datatype ${value.type} for $array")
+                        }
+                        DataType.ARRAY_UW -> {
+                            if (value.type != DataType.UWORD)
+                                throw VmExecutionException("new value is of different datatype ${value.type} for $array")
+                        }
+                        DataType.ARRAY_W -> {
+                            if (value.type != DataType.WORD)
+                                throw VmExecutionException("new value is of different datatype ${value.type} for $array")
+                        }
+                        DataType.ARRAY_F -> {
+                            if (value.type != DataType.FLOAT)
+                                throw VmExecutionException("new value is of different datatype ${value.type} for $array")
+                        }
+                        DataType.STR, DataType.STR_S -> {
+                            if (value.type !in ByteDatatypes)
+                                throw VmExecutionException("new value is of different datatype ${value.type} for $array")
+                        }
+                        else -> throw VmExecutionException("strange array type ${array.type}")
+                    }
+                    if (array.type in ArrayDatatypes)
+                        array.array!![index.integerValue()] = value.numericValue()
+                    else if (array.type in StringDatatypes) {
+                        val indexInt = index.integerValue()
+                        val newchr = Petscii.decodePetscii(listOf(value.numericValue().toShort()), true)
+                        val newstr = array.str!!.replaceRange(indexInt, indexInt + 1, newchr)
+                        val ident = contextStmt.definingScope().lookup(target.arrayindexed.identifier.nameInSource, contextStmt) as? VarDecl
+                                ?: throw VmExecutionException("can't find assignment target ${target.identifier}")
+                        val identScope = ident.definingScope()
+                        program.heap.update(array.heapId!!, newstr)
+                        runtimeVariables.set(identScope, ident.name, RuntimeValue(array.type, str = newstr, heapId = array.heapId))
+                    }
+                }
+                else {
+                    val address = (vardecl.value as LiteralValue).asIntegerValue!!
+                    val index = evaluate(target.arrayindexed.arrayspec.index, evalCtx).integerValue()
+                    val elementType = target.arrayindexed.inferType(program)!!
+                    when(elementType) {
+                        DataType.UBYTE -> mem.setUByte(address+index, value.byteval!!)
+                        DataType.BYTE -> mem.setSByte(address+index, value.byteval!!)
+                        DataType.UWORD -> mem.setUWord(address+index*2, value.wordval!!)
+                        DataType.WORD -> mem.setSWord(address+index*2, value.wordval!!)
+                        DataType.FLOAT -> mem.setFloat(address+index* MachineDefinition.Mflpt5.MemorySize, value.floatval!!)
+                        else -> throw VmExecutionException("strange array elt type $elementType")
+                    }
+                }
+            }
+            target.register != null -> {
+                runtimeVariables.set(program.namespace, target.register.name, value)
+            }
+            else -> TODO("assign $target")
+        }
+    }
+
+    private fun oneForCycle(stmt: ForLoop, loopvarDt: DataType, loopValue: Number, loopVar: IdentifierReference) {
+        // assign the new loop value to the loopvar, and run the code
+        performAssignment(AssignTarget(null, loopVar, null, null, loopVar.position),
+                RuntimeValue(loopvarDt, loopValue), stmt.body.statements.first(), evalCtx)
+        executeAnonymousScope(stmt.body)
+    }
+
+    private fun evaluate(args: List<IExpression>) = args.map { evaluate(it, evalCtx) }
+
+    private fun performSyscall(sub: Subroutine, args: List<RuntimeValue>): RuntimeValue? {
+        var result: RuntimeValue? = null
+        when (sub.scopedname) {
+            "c64scr.print" -> {
+                // if the argument is an UWORD, consider it to be the "address" of the string (=heapId)
+                if (args[0].wordval != null) {
+                    val str = program.heap.get(args[0].wordval!!).str!!
+                    dialog.canvas.printText(str, true)
+                } else
+                    dialog.canvas.printText(args[0].str!!, true)
+            }
+            "c64scr.print_ub" -> {
+                dialog.canvas.printText(args[0].byteval!!.toString(), true)
+            }
+            "c64scr.print_ub0" -> {
+                dialog.canvas.printText("%03d".format(args[0].byteval!!), true)
+            }
+            "c64scr.print_b" -> {
+                dialog.canvas.printText(args[0].byteval!!.toString(), true)
+            }
+            "c64scr.print_uw" -> {
+                dialog.canvas.printText(args[0].wordval!!.toString(), true)
+            }
+            "c64scr.print_uw0" -> {
+                dialog.canvas.printText("%05d".format(args[0].wordval!!), true)
+            }
+            "c64scr.print_w" -> {
+                dialog.canvas.printText(args[0].wordval!!.toString(), true)
+            }
+            "c64scr.print_ubhex" -> {
+                val prefix = if (args[0].asBoolean) "$" else ""
+                val number = args[1].byteval!!
+                dialog.canvas.printText("$prefix${number.toString(16).padStart(2, '0')}", true)
+            }
+            "c64scr.print_uwhex" -> {
+                val prefix = if (args[0].asBoolean) "$" else ""
+                val number = args[1].wordval!!
+                dialog.canvas.printText("$prefix${number.toString(16).padStart(4, '0')}", true)
+            }
+            "c64scr.print_uwbin" -> {
+                val prefix = if (args[0].asBoolean) "%" else ""
+                val number = args[1].wordval!!
+                dialog.canvas.printText("$prefix${number.toString(2).padStart(16, '0')}", true)
+            }
+            "c64scr.print_ubbin" -> {
+                val prefix = if (args[0].asBoolean) "%" else ""
+                val number = args[1].byteval!!
+                dialog.canvas.printText("$prefix${number.toString(2).padStart(8, '0')}", true)
+            }
+            "c64scr.clear_screenchars" -> {
+                dialog.canvas.clearScreen(6)
+            }
+            "c64scr.clear_screen" -> {
+                dialog.canvas.clearScreen(args[0].integerValue().toShort())
+            }
+            "c64scr.setcc" -> {
+                dialog.canvas.setChar(args[0].integerValue(), args[1].integerValue(), args[2].integerValue().toShort(), args[3].integerValue().toShort())
+            }
+            "c64scr.plot" -> {
+                dialog.canvas.setCursorPos(args[0].integerValue(), args[1].integerValue())
+            }
+            "c64scr.input_chars" -> {
+                val input=mutableListOf<Char>()
+                for(i in 0 until 80) {
+                    while(dialog.keyboardBuffer.isEmpty()) {
+                        Thread.sleep(10)
+                    }
+                    val char=dialog.keyboardBuffer.pop()
+                    if(char=='\n')
+                        break
+                    else {
+                        input.add(char)
+                        val printChar = try {
+                            Petscii.encodePetscii("" + char, true).first()
+                        } catch (cv: CharConversionException) {
+                            0x3f.toShort()
+                        }
+                        dialog.canvas.printPetscii(printChar)
+                    }
+                }
+                val inputStr = input.joinToString("")
+                val heapId = args[0].wordval!!
+                val origStr = program.heap.get(heapId).str!!
+                val paddedStr=inputStr.padEnd(origStr.length+1, '\u0000').substring(0, origStr.length)
+                program.heap.update(heapId, paddedStr)
+                result = RuntimeValue(DataType.UBYTE, paddedStr.indexOf('\u0000'))
+            }
+            "c64flt.print_f" -> {
+                dialog.canvas.printText(args[0].floatval.toString(), true)
+            }
+            "c64.CHROUT" -> {
+                dialog.canvas.printPetscii(args[0].byteval!!)
+            }
+            "c64.CLEARSCR" -> {
+                dialog.canvas.clearScreen(6)
+            }
+            "c64.CHRIN" -> {
+                while(dialog.keyboardBuffer.isEmpty()) {
+                    Thread.sleep(10)
+                }
+                val char=dialog.keyboardBuffer.pop()
+                result = RuntimeValue(DataType.UBYTE, char.toShort())
+            }
+            "c64utils.str2uword" -> {
+                val heapId = args[0].wordval!!
+                val argString = program.heap.get(heapId).str!!
+                val numericpart = argString.takeWhile { it.isDigit() }
+                result = RuntimeValue(DataType.UWORD, numericpart.toInt() and 65535)
+            }
+            else -> TODO("syscall  ${sub.scopedname} $sub")
+        }
+
+        return result
+    }
+
+    private fun performBuiltinFunction(name: String, args: List<RuntimeValue>, statusflags: StatusFlags): RuntimeValue? {
+        return when (name) {
+            "rnd" -> RuntimeValue(DataType.UBYTE, rnd.nextInt() and 255)
+            "rndw" -> RuntimeValue(DataType.UWORD, rnd.nextInt() and 65535)
+            "rndf" -> RuntimeValue(DataType.FLOAT, rnd.nextDouble())
+            "lsb" -> RuntimeValue(DataType.UBYTE, args[0].integerValue() and 255)
+            "msb" -> RuntimeValue(DataType.UBYTE, (args[0].integerValue() ushr 8) and 255)
+            "sin" -> RuntimeValue(DataType.FLOAT, sin(args[0].numericValue().toDouble()))
+            "sin8" -> {
+                val rad = args[0].numericValue().toDouble() / 256.0 * 2.0 * PI
+                RuntimeValue(DataType.BYTE, (127.0 * sin(rad)).toShort())
+            }
+            "sin8u" -> {
+                val rad = args[0].numericValue().toDouble() / 256.0 * 2.0 * PI
+                RuntimeValue(DataType.UBYTE, (128.0 + 127.5 * sin(rad)).toShort())
+            }
+            "sin16" -> {
+                val rad = args[0].numericValue().toDouble() / 256.0 * 2.0 * PI
+                RuntimeValue(DataType.BYTE, (32767.0 * sin(rad)).toShort())
+            }
+            "sin16u" -> {
+                val rad = args[0].numericValue().toDouble() / 256.0 * 2.0 * PI
+                RuntimeValue(DataType.UBYTE, (32768.0 + 32767.5 * sin(rad)).toShort())
+            }
+            "cos" -> RuntimeValue(DataType.FLOAT, cos(args[0].numericValue().toDouble()))
+            "cos8" -> {
+                val rad = args[0].numericValue().toDouble() / 256.0 * 2.0 * PI
+                RuntimeValue(DataType.BYTE, (127.0 * cos(rad)).toShort())
+            }
+            "cos8u" -> {
+                val rad = args[0].numericValue().toDouble() / 256.0 * 2.0 * PI
+                RuntimeValue(DataType.UBYTE, (128.0 + 127.5 * cos(rad)).toShort())
+            }
+            "cos16" -> {
+                val rad = args[0].numericValue().toDouble() / 256.0 * 2.0 * PI
+                RuntimeValue(DataType.BYTE, (32767.0 * cos(rad)).toShort())
+            }
+            "cos16u" -> {
+                val rad = args[0].numericValue().toDouble() / 256.0 * 2.0 * PI
+                RuntimeValue(DataType.UBYTE, (32768.0 + 32767.5 * cos(rad)).toShort())
+            }
+            "tan" -> RuntimeValue(DataType.FLOAT, tan(args[0].numericValue().toDouble()))
+            "atan" -> RuntimeValue(DataType.FLOAT, atan(args[0].numericValue().toDouble()))
+            "ln" -> RuntimeValue(DataType.FLOAT, ln(args[0].numericValue().toDouble()))
+            "log2" -> RuntimeValue(DataType.FLOAT, log2(args[0].numericValue().toDouble()))
+            "sqrt" -> RuntimeValue(DataType.FLOAT, sqrt(args[0].numericValue().toDouble()))
+            "sqrt16" -> RuntimeValue(DataType.UBYTE, sqrt(args[0].wordval!!.toDouble()).toInt())
+            "rad" -> RuntimeValue(DataType.FLOAT, Math.toRadians(args[0].numericValue().toDouble()))
+            "deg" -> RuntimeValue(DataType.FLOAT, Math.toDegrees(args[0].numericValue().toDouble()))
+            "round" -> RuntimeValue(DataType.FLOAT, round(args[0].numericValue().toDouble()))
+            "floor" -> RuntimeValue(DataType.FLOAT, floor(args[0].numericValue().toDouble()))
+            "ceil" -> RuntimeValue(DataType.FLOAT, ceil(args[0].numericValue().toDouble()))
+            "rol" -> {
+                val (result, newCarry) = args[0].rol(statusflags.carry)
+                statusflags.carry = newCarry
+                return result
+            }
+            "rol2" -> args[0].rol2()
+            "ror" -> {
+                val (result, newCarry) = args[0].ror(statusflags.carry)
+                statusflags.carry = newCarry
+                return result
+            }
+            "ror2" -> args[0].ror2()
+            "lsl" -> args[0].shl()
+            "lsr" -> args[0].shr()
+            "abs" -> {
+                when (args[0].type) {
+                    DataType.UBYTE -> args[0]
+                    DataType.BYTE -> RuntimeValue(DataType.UBYTE, abs(args[0].numericValue().toDouble()))
+                    DataType.UWORD -> args[0]
+                    DataType.WORD -> RuntimeValue(DataType.UWORD, abs(args[0].numericValue().toDouble()))
+                    DataType.FLOAT -> RuntimeValue(DataType.FLOAT, abs(args[0].numericValue().toDouble()))
+                    else -> throw VmExecutionException("strange abs type ${args[0]}")
+                }
+            }
+            "max" -> {
+                val numbers = args.map { it.numericValue().toDouble() }
+                RuntimeValue(args[0].type, numbers.max())
+            }
+            "min" -> {
+                val numbers = args.map { it.numericValue().toDouble() }
+                RuntimeValue(args[0].type, numbers.min())
+            }
+            "avg" -> {
+                val numbers = args.map { it.numericValue().toDouble() }
+                RuntimeValue(DataType.FLOAT, numbers.average())
+            }
+            "sum" -> {
+                val sum = args.map { it.numericValue().toDouble() }.sum()
+                when (args[0].type) {
+                    DataType.UBYTE -> RuntimeValue(DataType.UWORD, sum)
+                    DataType.BYTE -> RuntimeValue(DataType.WORD, sum)
+                    DataType.UWORD -> RuntimeValue(DataType.UWORD, sum)
+                    DataType.WORD -> RuntimeValue(DataType.WORD, sum)
+                    DataType.FLOAT -> RuntimeValue(DataType.FLOAT, sum)
+                    else -> throw VmExecutionException("weird sum type ${args[0]}")
+                }
+            }
+            "any" -> {
+                val numbers = args.map { it.numericValue().toDouble() }
+                RuntimeValue(DataType.UBYTE, if (numbers.any { it != 0.0 }) 1 else 0)
+            }
+            "all" -> {
+                val numbers = args.map { it.numericValue().toDouble() }
+                RuntimeValue(DataType.UBYTE, if (numbers.all { it != 0.0 }) 1 else 0)
+            }
+            "swap" ->
+                throw VmExecutionException("swap() cannot be implemented as a function")
+            "strlen" -> {
+                val zeroIndex = args[0].str!!.indexOf(0.toChar())
+                if (zeroIndex >= 0)
+                    RuntimeValue(DataType.UBYTE, zeroIndex)
+                else
+                    RuntimeValue(DataType.UBYTE, args[0].str!!.length)
+            }
+            "memset" -> {
+                val target = args[0].array!!
+                val amount = args[1].integerValue()
+                val value = args[2].integerValue()
+                for (i in 0 until amount) {
+                    target[i] = value
+                }
+                null
+            }
+            "memsetw" -> {
+                val target = args[0].array!!
+                val amount = args[1].integerValue()
+                val value = args[2].integerValue()
+                for (i in 0 until amount step 2) {
+                    target[i * 2] = value and 255
+                    target[i * 2 + 1] = value ushr 8
+                }
+                null
+            }
+            "memcopy" -> {
+                val source = args[0].array!!
+                val dest = args[1].array!!
+                val amount = args[2].integerValue()
+                for(i in 0 until amount) {
+                    dest[i] = source[i]
+                }
+                null
+            }
+            "mkword" -> {
+                val result = (args[1].integerValue() shl 8) or args[0].integerValue()
+                RuntimeValue(DataType.UWORD, result)
+            }
+            "set_carry" -> {
+                statusflags.carry=true
+                null
+            }
+            "clear_carry" -> {
+                statusflags.carry=false
+                null
+            }
+            "set_irqd" -> {
+                statusflags.irqd=true
+                null
+            }
+            "clear_irqd" -> {
+                statusflags.irqd=false
+                null
+            }
+            "read_flags" -> {
+                val carry = if(statusflags.carry) 1 else 0
+                val zero = if(statusflags.zero) 2 else 0
+                val irqd = if(statusflags.irqd) 4 else 0
+                val negative = if(statusflags.negative) 128 else 0
+                RuntimeValue(DataType.UBYTE, carry or zero or irqd or negative)
+            }
+            "rsave" -> {
+                statusFlagsSave.push(statusflags)
+                registerAsave.push(runtimeVariables.get(program.namespace, Register.A.name))
+                registerXsave.push(runtimeVariables.get(program.namespace, Register.X.name))
+                registerYsave.push(runtimeVariables.get(program.namespace, Register.Y.name))
+                null
+            }
+            "rrestore" -> {
+                val flags = statusFlagsSave.pop()
+                statusflags.carry = flags.carry
+                statusflags.negative = flags.negative
+                statusflags.zero = flags.zero
+                statusflags.irqd = flags.irqd
+                runtimeVariables.set(program.namespace, Register.A.name, registerAsave.pop())
+                runtimeVariables.set(program.namespace, Register.X.name, registerXsave.pop())
+                runtimeVariables.set(program.namespace, Register.Y.name, registerYsave.pop())
+                null
+            }
+            else -> TODO("builtin function $name")
+        }
+    }
+
+}
+

compiler/src/prog8/vm/astvm/CallStack.kt

@@ -1,4 +1,4 @@
-package prog8.astvm
+package prog8.vm.astvm
 
 import prog8.ast.INameScope
 import java.util.*

compiler/src/prog8/vm/astvm/Expressions.kt

@@ -1,13 +1,28 @@
-package prog8.astvm
+package prog8.vm.astvm
 
 import prog8.ast.*
-import prog8.compiler.RuntimeValue
-import prog8.compiler.RuntimeValueRange
+import prog8.ast.base.ArrayElementTypes
+import prog8.ast.base.DataType
+import prog8.ast.base.FatalAstException
+import prog8.ast.base.VarDeclType
+import prog8.ast.expressions.*
+import prog8.ast.statements.BuiltinFunctionStatementPlaceholder
+import prog8.ast.statements.Label
+import prog8.ast.statements.Subroutine
+import prog8.ast.statements.VarDecl
+import prog8.vm.RuntimeValue
+import prog8.vm.RuntimeValueRange
 import kotlin.math.abs
 
+
+typealias BuiltinfunctionCaller =  (name: String, args: List<RuntimeValue>, flags: StatusFlags) -> RuntimeValue?
+typealias SubroutineCaller =  (sub: Subroutine, args: List<RuntimeValue>, startAtLabel: Label?) -> RuntimeValue?
+
+
 class EvalContext(val program: Program, val mem: Memory, val statusflags: StatusFlags,
-                  val runtimeVars: RuntimeVariables, val functions: BuiltinFunctions,
-                  val executeSubroutine: (sub: Subroutine, args: List<RuntimeValue>, startlabel: Label?) -> List<RuntimeValue>)
+                  val runtimeVars: RuntimeVariables,
+                  val performBuiltinFunction: BuiltinfunctionCaller,
+                  val executeSubroutine: SubroutineCaller)
 
 fun evaluate(expr: IExpression, ctx: EvalContext): RuntimeValue {
     val constval = expr.constValue(ctx.program)
@@ -24,7 +39,7 @@ fun evaluate(expr: IExpression, ctx: EvalContext): RuntimeValue {
                 "~" -> evaluate(expr.expression, ctx).inv()
                 "not" -> evaluate(expr.expression, ctx).not()
                 // unary '+' should have been optimized away
-                else -> TODO("prefixexpr ${expr.operator}")
+                else -> throw VmExecutionException("unsupported prefix operator "+expr.operator)
             }
         }
         is BinaryExpression -> {
@@ -59,7 +74,7 @@ fun evaluate(expr: IExpression, ctx: EvalContext): RuntimeValue {
                 "and" -> left.and(right)
                 "or" -> left.or(right)
                 "xor" -> left.xor(right)
-                else -> TODO("binexpression operator ${expr.operator}")
+                else -> throw VmExecutionException("unsupported operator "+expr.operator)
             }
         }
         is ArrayIndexedExpression -> {
@@ -73,56 +88,60 @@ fun evaluate(expr: IExpression, ctx: EvalContext): RuntimeValue {
         }
         is AddressOf -> {
             // we support: address of heap var -> the heap id
-            val heapId = expr.identifier.heapId(ctx.program.namespace)
-            return RuntimeValue(DataType.UWORD, heapId)
+            return try {
+                val heapId = expr.identifier.heapId(ctx.program.namespace)
+                RuntimeValue(DataType.UWORD, heapId)
+            } catch( f: FatalAstException) {
+                // fallback: use the hash of the name, so we have at least *a* value...
+                val address = expr.identifier.hashCode() and 65535
+                RuntimeValue(DataType.UWORD, address)
+            }
         }
         is DirectMemoryRead -> {
             val address = evaluate(expr.addressExpression, ctx).wordval!!
             return RuntimeValue(DataType.UBYTE, ctx.mem.getUByte(address))
         }
-        is DirectMemoryWrite -> {
-            TODO("memorywrite $expr")
-        }
         is RegisterExpr -> return ctx.runtimeVars.get(ctx.program.namespace, expr.register.name)
         is IdentifierReference -> {
             val scope = expr.definingScope()
             val variable = scope.lookup(expr.nameInSource, expr)
             if(variable is VarDecl) {
-                if(variable.type==VarDeclType.VAR)
-                    return ctx.runtimeVars.get(variable.definingScope(), variable.name)
-                else {
-                    val address = ctx.runtimeVars.getMemoryAddress(variable.definingScope(), variable.name)
-                    return when(variable.datatype) {
-                        DataType.UBYTE -> RuntimeValue(DataType.UBYTE, ctx.mem.getUByte(address))
-                        DataType.BYTE -> RuntimeValue(DataType.BYTE, ctx.mem.getSByte(address))
-                        DataType.UWORD -> RuntimeValue(DataType.UWORD, ctx.mem.getUWord(address))
-                        DataType.WORD -> RuntimeValue(DataType.WORD, ctx.mem.getSWord(address))
-                        DataType.FLOAT -> RuntimeValue(DataType.FLOAT, ctx.mem.getFloat(address))
-                        DataType.STR -> RuntimeValue(DataType.STR, str=ctx.mem.getString(address))
-                        DataType.STR_S -> RuntimeValue(DataType.STR_S, str=ctx.mem.getScreencodeString(address))
-                        else -> TODO("memvar $variable")
+                when {
+                    variable.type==VarDeclType.VAR -> return ctx.runtimeVars.get(variable.definingScope(), variable.name)
+                    variable.datatype==DataType.STRUCT -> throw VmExecutionException("cannot process structs by-value.  at ${expr.position}")
+                    else -> {
+                        val address = ctx.runtimeVars.getMemoryAddress(variable.definingScope(), variable.name)
+                        return when(variable.datatype) {
+                            DataType.UBYTE -> RuntimeValue(DataType.UBYTE, ctx.mem.getUByte(address))
+                            DataType.BYTE -> RuntimeValue(DataType.BYTE, ctx.mem.getSByte(address))
+                            DataType.UWORD -> RuntimeValue(DataType.UWORD, ctx.mem.getUWord(address))
+                            DataType.WORD -> RuntimeValue(DataType.WORD, ctx.mem.getSWord(address))
+                            DataType.FLOAT -> RuntimeValue(DataType.FLOAT, ctx.mem.getFloat(address))
+                            DataType.STR -> RuntimeValue(DataType.STR, str = ctx.mem.getString(address))
+                            DataType.STR_S -> RuntimeValue(DataType.STR_S, str = ctx.mem.getScreencodeString(address))
+                            else -> throw VmExecutionException("unexpected datatype $variable")
+                        }
                     }
                 }
             } else
-                TODO("weird ref $variable")
+                throw VmExecutionException("weird identifier reference $variable")
         }
         is FunctionCall -> {
             val sub = expr.target.targetStatement(ctx.program.namespace)
             val args = expr.arglist.map { evaluate(it, ctx) }
             return when(sub) {
                 is Subroutine -> {
-                    val results = ctx.executeSubroutine(sub, args, null)
-                    if(results.size!=1)
-                        throw VmExecutionException("expected 1 result from functioncall $expr")
-                    results[0]
+                    val result = ctx.executeSubroutine(sub, args, null)
+                            ?: throw VmExecutionException("expected a result from functioncall $expr")
+                    result
                 }
                 is BuiltinFunctionStatementPlaceholder -> {
-                    val result = ctx.functions.performBuiltinFunction(sub.name, args, ctx.statusflags)
+                    val result = ctx.performBuiltinFunction(sub.name, args, ctx.statusflags)
                             ?: throw VmExecutionException("expected 1 result from functioncall $expr")
                     result
                 }
                 else -> {
-                    TODO("call expr function ${expr.target}")
+                    throw VmExecutionException("unimplemented function call target $sub")
                 }
             }
         }
@@ -148,7 +167,7 @@ fun evaluate(expr: IExpression, ctx: EvalContext): RuntimeValue {
             return RuntimeValueRange(expr.inferType(ctx.program)!!, range)
         }
         else -> {
-            TODO("implement eval $expr")
+            throw VmExecutionException("unimplemented expression node $expr")
         }
     }
 }

compiler/src/prog8/vm/astvm/Memory.kt

@@ -1,39 +1,60 @@
-package prog8.astvm
+package prog8.vm.astvm
 
-import prog8.compiler.target.c64.Mflpt5
+import prog8.compiler.target.c64.MachineDefinition
 import prog8.compiler.target.c64.Petscii
 import kotlin.math.abs
 
-class Memory {
+class Memory(private val readObserver: (address: Int, value: Short) -> Short,
+             private val writeObserver: (address: Int, value: Short) -> Short)
+{
+
     private val mem = ShortArray(65536)         // shorts because byte is signed and we store values 0..255
+    private val observed = BooleanArray(65536)     // what addresses are observed
+
+
+    fun observe(vararg address: Int) {
+        address.forEach { observed[it]=true }
+    }
 
     fun getUByte(address: Int): Short {
+        return if(observed[address]) readObserver(address, mem[address])
+        else mem[address]
+    }
+
+    fun getUByte_DMA(address: Int): Short {
         return mem[address]
     }
 
     fun getSByte(address: Int): Short {
         val ubyte = getUByte(address)
-        if(ubyte <= 127)
-            return ubyte
-        return (-((ubyte.toInt() xor 255)+1)).toShort()   // 2's complement
+        return if(ubyte <= 127) ubyte
+        else (-((ubyte.toInt() xor 255)+1)).toShort()   // 2's complement
     }
 
     fun setUByte(address: Int, value: Short) {
         if(value !in 0..255)
-            throw VmExecutionException("ubyte value out of range")
+            throw VmExecutionException("ubyte value out of range $value")
+        mem[address] =
+                if(observed[address]) writeObserver(address, value)
+                else value
+    }
+
+    fun setUByte_DMA(address: Int, value: Short) {
+        if(value !in 0..255)
+            throw VmExecutionException("ubyte value out of range $value")
         mem[address] = value
     }
 
     fun setSByte(address: Int, value: Short) {
-        if(value !in -128..127) throw VmExecutionException("byte value out of range")
-        if(value>=0)
-            mem[address] = value
-        else
-            mem[address] = ((abs(value.toInt()) xor 255)+1).toShort()        // 2's complement
+        if(value !in -128..127) throw VmExecutionException("byte value out of range $value")
+        val ubyte =
+                if(value>=0) value
+                else ((abs(value.toInt()) xor 255)+1).toShort()        // 2's complement
+        setUByte(address, ubyte)
     }
 
     fun getUWord(address: Int): Int {
-        return mem[address] + 256*mem[address+1]
+        return getUByte(address) + 256*getUByte(address+1)
     }
 
     fun getSWord(address: Int): Int {
@@ -45,13 +66,13 @@ class Memory {
 
     fun setUWord(address: Int, value: Int) {
         if(value !in 0..65535)
-            throw VmExecutionException("uword value out of range")
-        mem[address] = value.and(255).toShort()
-        mem[address+1] = (value / 256).toShort()
+            throw VmExecutionException("uword value out of range $value")
+        setUByte(address, value.and(255).toShort())
+        setUByte(address+1, (value / 256).toShort())
     }
 
     fun setSWord(address: Int, value: Int) {
-        if(value !in -32768..32767) throw VmExecutionException("word value out of range")
+        if(value !in -32768..32767) throw VmExecutionException("word value out of range $value")
         if(value>=0)
             setUWord(address, value)
         else
@@ -59,24 +80,25 @@ class Memory {
     }
 
     fun setFloat(address: Int, value: Double) {
-        val mflpt5 = Mflpt5.fromNumber(value)
-        mem[address] = mflpt5.b0
-        mem[address+1] = mflpt5.b1
-        mem[address+2] = mflpt5.b2
-        mem[address+3] = mflpt5.b3
-        mem[address+4] = mflpt5.b4
+        val mflpt5 = MachineDefinition.Mflpt5.fromNumber(value)
+        setUByte(address, mflpt5.b0)
+        setUByte(address+1, mflpt5.b1)
+        setUByte(address+2, mflpt5.b2)
+        setUByte(address+3, mflpt5.b3)
+        setUByte(address+4, mflpt5.b4)
     }
 
     fun getFloat(address: Int): Double {
-        return Mflpt5(mem[address], mem[address + 1], mem[address + 2], mem[address + 3], mem[address + 4]).toDouble()
+        return MachineDefinition.Mflpt5(getUByte(address), getUByte(address + 1), getUByte(address + 2),
+                getUByte(address + 3), getUByte(address + 4)).toDouble()
     }
 
     fun setString(address: Int, str: String) {
         // lowercase PETSCII
         val petscii = Petscii.encodePetscii(str, true)
         var addr = address
-        for (c in petscii) mem[addr++] = c
-        mem[addr] = 0
+        for (c in petscii) setUByte(addr++, c)
+        setUByte(addr, 0)
     }
 
     fun getString(strAddress: Int): String {
@@ -84,7 +106,7 @@ class Memory {
         val petscii = mutableListOf<Short>()
         var addr = strAddress
         while(true) {
-            val byte = mem[addr++]
+            val byte = getUByte(addr++)
             if(byte==0.toShort()) break
             petscii.add(byte)
         }
@@ -92,12 +114,12 @@ class Memory {
     }
 
     fun clear() {
-        for(i in 0..65535) mem[i]=0
+        for(i in 0..65535) setUByte(i, 0)
     }
 
     fun copy(from: Int, to: Int, numbytes: Int) {
         for(i in 0 until numbytes)
-            mem[to+i] = mem[from+i]
+            setUByte(to+i, getUByte(from+i))
     }
 
     fun getScreencodeString(strAddress: Int): String? {
@@ -105,7 +127,7 @@ class Memory {
         val screencodes = mutableListOf<Short>()
         var addr = strAddress
         while(true) {
-            val byte = mem[addr++]
+            val byte = getUByte(addr++)
             if(byte==0.toShort()) break
             screencodes.add(byte)
         }
@@ -116,7 +138,7 @@ class Memory {
         // lowercase screencodes
         val screencodes = Petscii.encodeScreencode(str, true)
         var addr = address
-        for (c in screencodes) mem[addr++] = c
-        mem[addr] = 0
+        for (c in screencodes) setUByte(addr++, c)
+        setUByte(addr, 0)
     }
 }

compiler/src/prog8/vm/astvm/ScreenDialog.kt

@@ -1,12 +1,12 @@
-package prog8.astvm
+package prog8.vm.astvm
 
-import prog8.compiler.target.c64.Charset
-import prog8.compiler.target.c64.Colors
+import prog8.compiler.target.c64.MachineDefinition
 import prog8.compiler.target.c64.Petscii
 import java.awt.*
 import java.awt.event.KeyEvent
 import java.awt.event.KeyListener
 import java.awt.image.BufferedImage
+import java.util.*
 import javax.swing.JFrame
 import javax.swing.JPanel
 import javax.swing.Timer
@@ -18,6 +18,7 @@ class BitmapScreenPanel : KeyListener, JPanel() {
     private val g2d = image.graphics as Graphics2D
     private var cursorX: Int=0
     private var cursorY: Int=0
+    val keyboardBuffer: Deque<Char> = LinkedList<Char>()
 
     init {
         val size = Dimension(image.width * SCALING, image.height * SCALING)
@@ -30,14 +31,14 @@ class BitmapScreenPanel : KeyListener, JPanel() {
         addKeyListener(this)
     }
 
-    override fun keyTyped(p0: KeyEvent?) {}
+    override fun keyTyped(p0: KeyEvent) {
+        keyboardBuffer.add(p0.keyChar)
+    }
 
-    override fun keyPressed(p0: KeyEvent?) {
-        println("pressed: $p0.k")
+    override fun keyPressed(p0: KeyEvent) {
     }
 
     override fun keyReleased(p0: KeyEvent?) {
-        println("released: $p0")
     }
 
     override fun paint(graphics: Graphics?) {
@@ -49,61 +50,82 @@ class BitmapScreenPanel : KeyListener, JPanel() {
     }
 
     fun clearScreen(color: Short) {
-        g2d.background = Colors.palette[color % Colors.palette.size]
+        g2d.background = MachineDefinition.colorPalette[color % MachineDefinition.colorPalette.size]
         g2d.clearRect(0, 0, SCREENWIDTH, SCREENHEIGHT)
         cursorX = 0
         cursorY = 0
     }
     fun setPixel(x: Int, y: Int, color: Short) {
-        image.setRGB(x, y, Colors.palette[color % Colors.palette.size].rgb)
+        image.setRGB(x, y, MachineDefinition.colorPalette[color % MachineDefinition.colorPalette.size].rgb)
     }
     fun drawLine(x1: Int, y1: Int, x2: Int, y2: Int, color: Short) {
-        g2d.color = Colors.palette[color % Colors.palette.size]
+        g2d.color = MachineDefinition.colorPalette[color % MachineDefinition.colorPalette.size]
         g2d.drawLine(x1, y1, x2, y2)
     }
-    fun printText(text: String, color: Short, lowercase: Boolean) {
+
+    fun printText(text: String, lowercase: Boolean, inverseVideo: Boolean=false) {
         val t2 = text.substringBefore(0.toChar())
         val lines = t2.split('\n')
         for(line in lines.withIndex()) {
-            printTextSingleLine(line.value, color, lowercase)
+            val petscii = Petscii.encodePetscii(line.value, lowercase)
+            petscii.forEach { printPetscii(it, inverseVideo) }
             if(line.index<lines.size-1) {
-                cursorX=0
-                cursorY++
-            }
-        }
-    }
-    private fun printTextSingleLine(text: String, color: Short, lowercase: Boolean) {
-        for(clearx in cursorX until cursorX+text.length) {
-            g2d.clearRect(8*clearx, 8*y, 8, 8)
-        }
-        for(sc in Petscii.encodeScreencode(text, lowercase)) {
-            setChar(cursorX, cursorY, sc, color)
-            cursorX++
-            if(cursorX>=(SCREENWIDTH/8)) {
-                cursorY++
-                cursorX=0
+                printPetscii(13)    // newline
             }
         }
     }
 
-    fun printChar(char: Short) {
+    fun printPetscii(char: Short, inverseVideo: Boolean=false) {
         if(char==13.toShort() || char==141.toShort()) {
             cursorX=0
             cursorY++
         } else {
-            setChar(cursorX, cursorY, char, 1)
+            setPetscii(cursorX, cursorY, char, 1, inverseVideo)
             cursorX++
             if (cursorX >= (SCREENWIDTH / 8)) {
                 cursorY++
                 cursorX = 0
             }
         }
+        while(cursorY>=(SCREENHEIGHT/8)) {
+            // scroll the screen up because the cursor went past the last line
+            Thread.sleep(10)
+            val screen = image.copy()
+            val graphics = image.graphics as Graphics2D
+            graphics.drawImage(screen, 0, -8, null)
+            val color = graphics.color
+            graphics.color = MachineDefinition.colorPalette[6]
+            graphics.fillRect(0, 24*8, SCREENWIDTH, 25*8)
+            graphics.color=color
+            cursorY--
+        }
     }
 
-    fun setChar(x: Int, y: Int, screenCode: Short, color: Short) {
+    fun writeTextAt(x: Int, y: Int, text: String, color: Short, lowercase: Boolean, inverseVideo: Boolean=false) {
+        val colorIdx = (color % MachineDefinition.colorPalette.size).toShort()
+        var xx=x
+        for(clearx in xx until xx+text.length) {
+            g2d.clearRect(8*clearx, 8*y, 8, 8)
+        }
+        for(sc in Petscii.encodePetscii(text, lowercase)) {
+            if(sc==0.toShort())
+                break
+            setPetscii(xx++, y, sc, colorIdx, inverseVideo)
+        }
+    }
+
+    fun setPetscii(x: Int, y: Int, petscii: Short, color: Short, inverseVideo: Boolean) {
         g2d.clearRect(8*x, 8*y, 8, 8)
-        val colorIdx = (color % Colors.palette.size).toShort()
-        val coloredImage = Charset.getColoredChar(screenCode, colorIdx)
+        val colorIdx = (color % MachineDefinition.colorPalette.size).toShort()
+        val screencode = Petscii.petscii2scr(petscii, inverseVideo)
+        val coloredImage = MachineDefinition.Charset.getColoredChar(screencode, colorIdx)
+        g2d.drawImage(coloredImage, 8*x, 8*y , null)
+    }
+
+    fun setChar(x: Int, y: Int, screencode: Short, color: Short) {
+        g2d.clearRect(8*x, 8*y, 8, 8)
+        val colorIdx = (color % MachineDefinition.colorPalette.size).toShort()
+        val coloredImage = MachineDefinition.Charset.getColoredChar(screencode, colorIdx)
         g2d.drawImage(coloredImage, 8*x, 8*y , null)
     }
 
@@ -116,20 +138,6 @@ class BitmapScreenPanel : KeyListener, JPanel() {
         return Pair(cursorX, cursorY)
     }
 
-    fun writeText(x: Int, y: Int, text: String, color: Short, lowercase: Boolean) {
-        val colorIdx = (color % Colors.palette.size).toShort()
-        var xx=x
-        for(clearx in xx until xx+text.length) {
-            g2d.clearRect(8*clearx, 8*y, 8, 8)
-        }
-        for(sc in Petscii.encodeScreencode(text, lowercase)) {
-            if(sc==0.toShort())
-                break
-            setChar(xx++, y, sc, colorIdx)
-        }
-    }
-
-
     companion object {
         const val SCREENWIDTH = 320
         const val SCREENHEIGHT = 200
@@ -138,32 +146,32 @@ class BitmapScreenPanel : KeyListener, JPanel() {
 }
 
 
-class ScreenDialog : JFrame() {
+class ScreenDialog(title: String) : JFrame(title) {
     val canvas = BitmapScreenPanel()
+    val keyboardBuffer = canvas.keyboardBuffer
 
     init {
         val borderWidth = 16
-        title = "AstVm graphics. Text I/O goes to console."
         layout = GridBagLayout()
-        defaultCloseOperation = JFrame.EXIT_ON_CLOSE
+        defaultCloseOperation = EXIT_ON_CLOSE
         isResizable = false
 
         // the borders (top, left, right, bottom)
         val borderTop = JPanel().apply {
-            preferredSize = Dimension(BitmapScreenPanel.SCALING * (BitmapScreenPanel.SCREENWIDTH+2*borderWidth), BitmapScreenPanel.SCALING * borderWidth)
-            background = Colors.palette[14]
+            preferredSize = Dimension(BitmapScreenPanel.SCALING * (BitmapScreenPanel.SCREENWIDTH +2*borderWidth), BitmapScreenPanel.SCALING * borderWidth)
+            background = MachineDefinition.colorPalette[14]
         }
         val borderBottom = JPanel().apply {
-            preferredSize =Dimension(BitmapScreenPanel.SCALING * (BitmapScreenPanel.SCREENWIDTH+2*borderWidth), BitmapScreenPanel.SCALING * borderWidth)
-            background = Colors.palette[14]
+            preferredSize =Dimension(BitmapScreenPanel.SCALING * (BitmapScreenPanel.SCREENWIDTH +2*borderWidth), BitmapScreenPanel.SCALING * borderWidth)
+            background = MachineDefinition.colorPalette[14]
         }
         val borderLeft = JPanel().apply {
             preferredSize =Dimension(BitmapScreenPanel.SCALING * borderWidth, BitmapScreenPanel.SCALING * BitmapScreenPanel.SCREENHEIGHT)
-            background = Colors.palette[14]
+            background = MachineDefinition.colorPalette[14]
         }
         val borderRight = JPanel().apply {
             preferredSize =Dimension(BitmapScreenPanel.SCALING * borderWidth, BitmapScreenPanel.SCALING * BitmapScreenPanel.SCREENHEIGHT)
-            background = Colors.palette[14]
+            background = MachineDefinition.colorPalette[14]
         }
         var c = GridBagConstraints()
         c.gridx=0; c.gridy=1; c.gridwidth=3
@@ -190,3 +198,12 @@ class ScreenDialog : JFrame() {
         repaintTimer.start()
     }
 }
+
+
+private fun BufferedImage.copy(): BufferedImage {
+    val bcopy = BufferedImage(this.width, this.height, this.type)
+    val g = bcopy.graphics
+    g.drawImage(this, 0, 0, null)
+    g.dispose()
+    return bcopy
+}

compiler/src/prog8/vm/astvm/VariablesCreator.kt

@@ -0,0 +1,67 @@
+package prog8.vm.astvm
+
+import prog8.ast.*
+import prog8.ast.base.*
+import prog8.ast.expressions.LiteralValue
+import prog8.ast.processing.IAstModifyingVisitor
+import prog8.ast.statements.StructDecl
+import prog8.ast.statements.VarDecl
+import prog8.ast.statements.ZeropageWish
+import prog8.compiler.HeapValues
+import prog8.vm.RuntimeValue
+
+class VariablesCreator(private val runtimeVariables: RuntimeVariables, private val heap: HeapValues) : IAstModifyingVisitor {
+
+    override fun visit(program: Program) {
+        // define the three registers as global variables
+        runtimeVariables.define(program.namespace, Register.A.name, RuntimeValue(DataType.UBYTE, 0))
+        runtimeVariables.define(program.namespace, Register.X.name, RuntimeValue(DataType.UBYTE, 255))
+        runtimeVariables.define(program.namespace, Register.Y.name, RuntimeValue(DataType.UBYTE, 0))
+
+        val globalpos = Position("<<global>>", 0, 0, 0)
+        val vdA = VarDecl(VarDeclType.VAR, DataType.UBYTE, ZeropageWish.DONTCARE, null, Register.A.name, null,
+                LiteralValue.optimalInteger(0, globalpos), isArray = false, hiddenButDoNotRemove = true, position = globalpos)
+        val vdX = VarDecl(VarDeclType.VAR, DataType.UBYTE, ZeropageWish.DONTCARE, null, Register.X.name, null,
+                LiteralValue.optimalInteger(255, globalpos), isArray = false, hiddenButDoNotRemove = true, position = globalpos)
+        val vdY = VarDecl(VarDeclType.VAR, DataType.UBYTE, ZeropageWish.DONTCARE, null, Register.Y.name, null,
+                LiteralValue.optimalInteger(0, globalpos), isArray = false, hiddenButDoNotRemove = true, position = globalpos)
+        vdA.linkParents(program.namespace)
+        vdX.linkParents(program.namespace)
+        vdY.linkParents(program.namespace)
+        program.namespace.statements.add(vdA)
+        program.namespace.statements.add(vdX)
+        program.namespace.statements.add(vdY)
+
+        super.visit(program)
+    }
+
+    override fun visit(decl: VarDecl): IStatement {
+        // if the decl is part of a struct, just skip it
+        if(decl.parent !is StructDecl) {
+            when (decl.type) {
+                // we can assume the value in the vardecl already has been converted into a constant LiteralValue here.
+                VarDeclType.VAR -> {
+                    if(decl.datatype!=DataType.STRUCT) {
+                        val value = RuntimeValue.from(decl.value as LiteralValue, heap)
+                        runtimeVariables.define(decl.definingScope(), decl.name, value)
+                    }
+                }
+                VarDeclType.MEMORY -> {
+                    runtimeVariables.defineMemory(decl.definingScope(), decl.name, (decl.value as LiteralValue).asIntegerValue!!)
+                }
+                VarDeclType.CONST -> {
+                    // consts should have been const-folded away
+                }
+            }
+        }
+        return super.visit(decl)
+    }
+
+//    override fun accept(assignment: Assignment): IStatement {
+//        if(assignment is VariableInitializationAssignment) {
+//            println("INIT VAR $assignment")
+//        }
+//        return super.accept(assignment)
+//    }
+
+}

compiler/src/prog8/vm/stackvm/Main.kt

@@ -1,6 +1,7 @@
-package prog8
+package prog8.vm.stackvm
 
-import prog8.stackvm.*
+import prog8.printSoftwareHeader
+import prog8.vm.astvm.ScreenDialog
 import java.awt.EventQueue
 import javax.swing.Timer
 import kotlin.system.exitProcess
@@ -19,7 +20,7 @@ fun stackVmMain(args: Array<String>) {
 
     val program = Program.load(args.first())
     val vm = StackVm(traceOutputFile = null)
-    val dialog = ScreenDialog()
+    val dialog = ScreenDialog("StackVM")
     vm.load(program, dialog.canvas)
     EventQueue.invokeLater {
         dialog.pack()

compiler/src/prog8/vm/stackvm/Program.kt

@@ -1,7 +1,10 @@
-package prog8.stackvm
+package prog8.vm.stackvm
 
-import prog8.ast.*
-import prog8.compiler.RuntimeValue
+import prog8.ast.antlr.unescape
+import prog8.ast.base.*
+import prog8.ast.expressions.AddressOf
+import prog8.ast.expressions.IdentifierReference
+import prog8.vm.RuntimeValue
 import prog8.compiler.HeapValues
 import prog8.compiler.IntegerOrAddressOf
 import prog8.compiler.intermediate.*
@@ -89,7 +92,7 @@ class Program (val name: String,
             }
             heapvalues.sortedBy { it.first }.forEach {
                 when(it.second) {
-                    DataType.STR, DataType.STR_S -> heap.addString(it.second, unescape(it.third.substring(1, it.third.length-1), Position("<stackvmsource>", 0, 0, 0)))
+                    DataType.STR, DataType.STR_S -> heap.addString(it.second, unescape(it.third.substring(1, it.third.length - 1), Position("<stackvmsource>", 0, 0, 0)))
                     DataType.ARRAY_UB, DataType.ARRAY_B,
                     DataType.ARRAY_UW, DataType.ARRAY_W -> {
                         val numbers = it.third.substring(1, it.third.length-1).split(',')
@@ -98,8 +101,8 @@ class Program (val name: String,
                             if(num.startsWith("&")) {
                                 // it's AddressOf
                                 val scopedname = num.substring(1)
-                                val iref = IdentifierReference(scopedname.split('.'), Position("<intermediate>", 0,0,0))
-                                val addrOf = AddressOf(iref, Position("<intermediate>", 0,0,0))
+                                val iref = IdentifierReference(scopedname.split('.'), Position("<intermediate>", 0, 0, 0))
+                                val addrOf = AddressOf(iref, Position("<intermediate>", 0, 0, 0))
                                 addrOf.scopedname=scopedname
                                 IntegerOrAddressOf(null, addrOf)
                             } else {

compiler/src/prog8/vm/stackvm/StackVm.kt

@@ -1,7 +1,13 @@
-package prog8.stackvm
+package prog8.vm.stackvm
 
-import prog8.ast.*
-import prog8.compiler.RuntimeValue
+import prog8.ast.base.DataType
+import prog8.ast.base.IterableDatatypes
+import prog8.ast.base.NumericDatatypes
+import prog8.ast.base.Register
+import prog8.ast.base.initvarsSubName
+import prog8.vm.astvm.BitmapScreenPanel
+import prog8.vm.astvm.Memory
+import prog8.vm.RuntimeValue
 import prog8.compiler.HeapValues
 import prog8.compiler.IntegerOrAddressOf
 import prog8.compiler.intermediate.Instruction
@@ -14,7 +20,7 @@ import java.util.*
 import kotlin.math.*
 
 
-enum class Syscall(val callNr: Short) {
+internal enum class Syscall(val callNr: Short) {
     VM_WRITE_MEMCHR(10),           // print a single char from the memory address popped from stack
     VM_WRITE_MEMSTR(11),           // print a 0-terminated petscii string from the memory address popped from stack
     VM_WRITE_NUM(12),              // pop from the evaluation stack and print it as a number
@@ -85,7 +91,7 @@ enum class Syscall(val callNr: Short) {
 
     // vm intercepts of system routines:
     SYSCALLSTUB(200),
-    SYSASM_c64scr_PLOT(201),
+    SYSASM_c64scr_plot(201),
     SYSASM_c64scr_print(202),
     SYSASM_c64scr_print_ub0(203),
     SYSASM_c64scr_print_ub(204),
@@ -101,10 +107,9 @@ enum class Syscall(val callNr: Short) {
     SYSASM_c64flt_print_f(214),
 }
 
+internal val syscallNames = enumValues<Syscall>().map { it.name }.toSet()
 
-val syscallNames = enumValues<Syscall>().map { it.name }.toSet()
-
-val syscallsForStackVm = setOf(
+internal val syscallsForStackVm = setOf(
         Syscall.VM_WRITE_MEMCHR,
         Syscall.VM_WRITE_MEMSTR,
         Syscall.VM_WRITE_NUM,
@@ -117,13 +122,13 @@ val syscallsForStackVm = setOf(
         Syscall.VM_GFX_LINE
 )
 
-class VmExecutionException(msg: String?) : Exception(msg)
+internal class VmExecutionException(msg: String?) : Exception(msg)
 
-class VmTerminationException(msg: String?) : Exception(msg)
+internal class VmTerminationException(msg: String?) : Exception(msg)
 
-class VmBreakpointException : Exception("breakpoint")
+internal class VmBreakpointException : Exception("breakpoint")
 
-class MyStack<T> : Stack<T>() {
+internal class MyStack<T> : Stack<T>() {
     fun peek(amount: Int) : List<T> {
         return this.toList().subList(max(0, size-amount), size)
     }
@@ -135,9 +140,8 @@ class MyStack<T> : Stack<T>() {
     }
 }
 
-
 class StackVm(private var traceOutputFile: String?) {
-    val mem = Memory()
+    val mem = Memory(::memread, ::memwrite)
     var P_carry: Boolean = false
         private set
     var P_zero: Boolean = true
@@ -150,9 +154,9 @@ class StackVm(private var traceOutputFile: String?) {
         private set
     var memoryPointers = mutableMapOf<String, Pair<Int, DataType>>()        // all named pointers
         private set
-    var evalstack = MyStack<RuntimeValue>()
+    internal var evalstack = MyStack<RuntimeValue>()
         private set
-    var callstack = MyStack<Int>()
+    internal var callstack = MyStack<Int>()
         private set
     private var program = listOf<Instruction>()
     private var labels = emptyMap<String, Int>()
@@ -161,12 +165,29 @@ class StackVm(private var traceOutputFile: String?) {
     private var canvas: BitmapScreenPanel? = null
     private val rnd = Random()
     private val bootTime = System.currentTimeMillis()
+    private var rtcOffset = bootTime
     private var currentInstructionPtr: Int = -1
     private var irqStartInstructionPtr: Int = -1
     private var registerSaveX: RuntimeValue = RuntimeValue(DataType.UBYTE, 0)
     var sourceLine: String = ""
         private set
 
+    fun memread(address: Int, value: Short): Short {
+        //println("MEM READ  $address  -> $value")
+        return value
+    }
+
+    fun memwrite(address: Int, value: Short): Short {
+        if(address==0xa0 || address==0xa1 || address==0xa2) {
+            // a write to the jiffy clock, update the clock offset for the irq
+            val time_hi = if(address==0xa0) value else mem.getUByte_DMA(0xa0)
+            val time_mid = if(address==0xa1) value else mem.getUByte_DMA(0xa1)
+            val time_lo = if(address==0xa2) value else mem.getUByte_DMA(0xa2)
+            val jiffies = (time_hi.toInt() shl 16) + (time_mid.toInt() shl 8) + time_lo
+            rtcOffset = bootTime - (jiffies*1000/60)
+        }
+        return value
+    }
 
     fun load(program: Program, canvas: BitmapScreenPanel?) {
         this.program = program.program + Instruction(Opcode.RETURN)  // append a RETURN for use in the IRQ handler
@@ -181,7 +202,7 @@ class StackVm(private var traceOutputFile: String?) {
             throw VmExecutionException("program contains variable(s) for the reserved registers A/X/Y")
         // define the 'registers'
         variables["A"] = RuntimeValue(DataType.UBYTE, 0)
-        variables["X"] = RuntimeValue(DataType.UBYTE, 0)
+        variables["X"] = RuntimeValue(DataType.UBYTE, 255)
         variables["Y"] = RuntimeValue(DataType.UBYTE, 0)
 
         initMemory(program.memory)
@@ -241,6 +262,7 @@ class StackVm(private var traceOutputFile: String?) {
 
     private fun initMemory(memory: Map<Int, List<RuntimeValue>>) {
         mem.clear()
+
         for (meminit in memory) {
             var address = meminit.key
             for (value in meminit.value) {
@@ -274,6 +296,9 @@ class StackVm(private var traceOutputFile: String?) {
                 }
             }
         }
+
+        // observe the jiffyclock
+        mem.observe(0xa0, 0xa1, 0xa2)
     }
 
     private fun checkDt(value: RuntimeValue?, vararg expected: DataType) {
@@ -349,11 +374,21 @@ class StackVm(private var traceOutputFile: String?) {
                 val value = evalstack.pop()
                 checkDt(value, DataType.FLOAT)
             }
+            Opcode.DUP_B -> {
+                val value = evalstack.peek()
+                checkDt(value, DataType.BYTE, DataType.UBYTE)
+                evalstack.push(value)
+            }
+            Opcode.DUP_W -> {
+                val value = evalstack.peek()
+                checkDt(value, DataType.WORD, DataType.UWORD)
+                evalstack.push(value)
+            }
             Opcode.POP_MEM_BYTE -> {
                 val value = evalstack.pop()
                 checkDt(value, DataType.BYTE, DataType.UBYTE)
                 val address = ins.arg!!.integerValue()
-                if(value.type==DataType.BYTE)
+                if(value.type== DataType.BYTE)
                     mem.setSByte(address, value.integerValue().toShort())
                 else
                     mem.setUByte(address, value.integerValue().toShort())
@@ -363,7 +398,7 @@ class StackVm(private var traceOutputFile: String?) {
                 val value = evalstack.pop()
                 checkDt(value, DataType.WORD, DataType.UWORD)
                 val address = ins.arg!!.integerValue()
-                if(value.type==DataType.WORD)
+                if(value.type== DataType.WORD)
                     mem.setSWord(address, value.integerValue())
                 else
                     mem.setUWord(address, value.integerValue())
@@ -1650,7 +1685,7 @@ class StackVm(private var traceOutputFile: String?) {
                         } else {
                             // normal variable
                             val variable = getVar(ins.callLabel!!)
-                            if(variable.type==DataType.UWORD) {
+                            if(variable.type== DataType.UWORD) {
                                 // assume the variable is a pointer (address) and get the word value from that memory location
                                 RuntimeValue(DataType.UWORD, mem.getUWord(variable.integerValue()))
                             } else {
@@ -1685,7 +1720,7 @@ class StackVm(private var traceOutputFile: String?) {
                         if(ins.callLabel in memoryPointers) {
                             val variable = memoryPointers.getValue(ins.callLabel!!)
                             val address = variable.first + index*5
-                            if(variable.second==DataType.ARRAY_F)
+                            if(variable.second== DataType.ARRAY_F)
                                 RuntimeValue(DataType.FLOAT, mem.getFloat(address))
                             else
                                 throw VmExecutionException("not a proper arraysize var with float elements")
@@ -1714,13 +1749,13 @@ class StackVm(private var traceOutputFile: String?) {
                 val memloc = memoryPointers[varname]
                 if(memloc!=null) {
                     // variable is the name of a pointer, write the byte value to that memory location
-                    if(value.type==DataType.UBYTE) {
-                        if(memloc.second!=DataType.ARRAY_UB)
+                    if(value.type== DataType.UBYTE) {
+                        if(memloc.second!= DataType.ARRAY_UB)
                             throw VmExecutionException("invalid memory pointer type $memloc")
                         mem.setUByte(memloc.first, value.integerValue().toShort())
                     }
                     else {
-                        if(memloc.second!=DataType.ARRAY_B)
+                        if(memloc.second!= DataType.ARRAY_B)
                             throw VmExecutionException("invalid memory pointer type $memloc")
                         mem.setSByte(memloc.first, value.integerValue().toShort())
                     }
@@ -1728,7 +1763,7 @@ class StackVm(private var traceOutputFile: String?) {
                     val variable = getVar(varname)
                     if (variable.type == DataType.UWORD) {
                         // assume the variable is a pointer (address) and write the byte value to that memory location
-                        if(value.type==DataType.UBYTE)
+                        if(value.type== DataType.UBYTE)
                             mem.setUByte(variable.integerValue(), value.integerValue().toShort())
                         else
                             mem.setSByte(variable.integerValue(), value.integerValue().toShort())
@@ -1762,13 +1797,13 @@ class StackVm(private var traceOutputFile: String?) {
                 val memloc = memoryPointers[varname]
                 if(memloc!=null) {
                     // variable is the name of a pointer, write the word value to that memory location
-                    if(value.type==DataType.UWORD) {
-                        if(memloc.second!=DataType.ARRAY_UW)
+                    if(value.type== DataType.UWORD) {
+                        if(memloc.second!= DataType.ARRAY_UW)
                             throw VmExecutionException("invalid memory pointer type $memloc")
                         mem.setUWord(memloc.first+index*2, value.integerValue())
                     }
                     else {
-                        if(memloc.second!=DataType.ARRAY_W)
+                        if(memloc.second!= DataType.ARRAY_W)
                             throw VmExecutionException("invalid memory pointer type $memloc")
                         mem.setSWord(memloc.first+index*2, value.integerValue())
                     }
@@ -1776,7 +1811,7 @@ class StackVm(private var traceOutputFile: String?) {
                     val variable = getVar(varname)
                     if (variable.type == DataType.UWORD) {
                         // assume the variable is a pointer (address) and write the word value to that memory location
-                        if(value.type==DataType.UWORD)
+                        if(value.type== DataType.UWORD)
                             mem.setUWord(variable.integerValue()+index*2, value.integerValue())
                         else
                             mem.setSWord(variable.integerValue()+index*2, value.integerValue())
@@ -1801,7 +1836,7 @@ class StackVm(private var traceOutputFile: String?) {
                 val memloc = memoryPointers[varname]
                 if(memloc!=null) {
                     // variable is the name of a pointer, write the float value to that memory location
-                    if(memloc.second!=DataType.ARRAY_F)
+                    if(memloc.second!= DataType.ARRAY_F)
                         throw VmExecutionException("invalid memory pointer type $memloc")
                     mem.setFloat(memloc.first+index*5, value.numericValue().toDouble())
                 } else {
@@ -1828,8 +1863,8 @@ class StackVm(private var traceOutputFile: String?) {
             }
             Opcode.RRESTORE -> {
                 variables["A"] = evalstack.pop()
-                variables["X"] = evalstack.pop()
                 variables["Y"] = evalstack.pop()
+                variables["X"] = evalstack.pop()
                 P_carry = evalstack.pop().asBoolean
                 P_irqd = evalstack.pop().asBoolean
             }
@@ -1838,10 +1873,17 @@ class StackVm(private var traceOutputFile: String?) {
             Opcode.INLINE_ASSEMBLY -> throw VmExecutionException("stackVm doesn't support executing inline assembly code $ins")
             Opcode.INCLUDE_FILE -> throw VmExecutionException("stackVm doesn't support including a file $ins")
             Opcode.PUSH_ADDR_HEAPVAR -> {
-                val heapId = variables.getValue(ins.callLabel!!).heapId!!
-                if(heapId<0)
-                    throw VmExecutionException("expected variable on heap")
-                evalstack.push(RuntimeValue(DataType.UWORD, heapId))       // push the "address" of the string or array variable (this is taken care of properly in the assembly code generator)
+                val variable = variables.getValue(ins.callLabel!!)
+                if(variable.heapId!=null) {
+                    val heapId = variable.heapId
+                    if (heapId < 0)
+                        throw VmExecutionException("expected variable on heap")
+                    evalstack.push(RuntimeValue(DataType.UWORD, heapId))       // push the "address" of the string or array variable (this is taken care of properly in the assembly code generator)
+                } else {
+                    // hack: return hash of the name, so we have at least *a* value...
+                    val addr = ins.callLabel.hashCode() and 65535
+                    evalstack.push(RuntimeValue(DataType.UWORD, addr))
+                }
             }
             Opcode.CAST_UB_TO_B -> typecast(DataType.UBYTE, DataType.BYTE)
             Opcode.CAST_W_TO_B -> typecast(DataType.WORD, DataType.BYTE)
@@ -1891,7 +1933,7 @@ class StackVm(private var traceOutputFile: String?) {
                 }
                 "c64.CHROUT" -> {
                     val sc=variables.getValue("A").integerValue()
-                    canvas?.printChar(sc.toShort())
+                    canvas?.printPetscii(sc.toShort())
                     callstack.pop()
                 }
                 "c64.GETIN" -> {
@@ -1992,7 +2034,7 @@ class StackVm(private var traceOutputFile: String?) {
                 val color = evalstack.pop()
                 val (cy, cx) = evalstack.pop2()
                 val text = heap.get(textPtr)
-                canvas?.writeText(cx.integerValue(), cy.integerValue(), text.str!!, color.integerValue().toShort(), true)
+                canvas?.writeTextAt(cx.integerValue(), cy.integerValue(), text.str!!, color.integerValue().toShort(), true)
             }
             Syscall.FUNC_RND -> evalstack.push(RuntimeValue(DataType.UBYTE, rnd.nextInt() and 255))
             Syscall.FUNC_RNDW -> evalstack.push(RuntimeValue(DataType.UWORD, rnd.nextInt() and 65535))
@@ -2106,7 +2148,7 @@ class StackVm(private var traceOutputFile: String?) {
                 if(length!=value.array!!.size)
                     throw VmExecutionException("iterable length mismatch")
                 if(value.array.any {it.addressOf!=null})
-                    throw VmExecutionException("stackvm cannot process raw memory pointers")
+                    throw VmExecutionException("stackvm cannot accept raw memory pointers")
                 evalstack.push(RuntimeValue(DataType.UWORD, value.array.map { it.integer!! }.max() ?: 0))
             }
             Syscall.FUNC_MAX_W -> {
@@ -2148,7 +2190,7 @@ class StackVm(private var traceOutputFile: String?) {
                 if(length!=value.array!!.size)
                     throw VmExecutionException("iterable length mismatch")
                 if(value.array.any {it.addressOf!=null})
-                    throw VmExecutionException("stackvm cannot process raw memory pointers")
+                    throw VmExecutionException("stackvm cannot accept raw memory pointers")
                 evalstack.push(RuntimeValue(DataType.UWORD, value.array.map { it.integer!! }.min() ?: 0))
             }
             Syscall.FUNC_MIN_W -> {
@@ -2182,7 +2224,7 @@ class StackVm(private var traceOutputFile: String?) {
                 if(length!=value.array!!.size)
                     throw VmExecutionException("iterable length mismatch")
                 if(value.array.any {it.addressOf!=null})
-                    throw VmExecutionException("stackvm cannot process raw memory pointers")
+                    throw VmExecutionException("stackvm cannot accept raw memory pointers")
                 evalstack.push(RuntimeValue(DataType.UWORD, value.array.map { it.integer!! }.sum()))
             }
             Syscall.FUNC_SUM_UB -> {
@@ -2245,9 +2287,9 @@ class StackVm(private var traceOutputFile: String?) {
                 val numbytes = evalstack.pop().integerValue()
                 val bytevalue = value.integerValue().toShort()
                 when {
-                    value.type==DataType.UBYTE -> for(addr in address until address+numbytes)
+                    value.type== DataType.UBYTE -> for(addr in address until address+numbytes)
                         mem.setUByte(addr, bytevalue)
-                    value.type==DataType.BYTE -> for(addr in address until address+numbytes)
+                    value.type== DataType.BYTE -> for(addr in address until address+numbytes)
                         mem.setSByte(addr, bytevalue)
                     else -> throw VmExecutionException("(u)byte value expected")
                 }
@@ -2258,15 +2300,15 @@ class StackVm(private var traceOutputFile: String?) {
                 val numwords = evalstack.pop().integerValue()
                 val wordvalue = value.integerValue()
                 when {
-                    value.type==DataType.UWORD -> for(addr in address until address+numwords*2 step 2)
+                    value.type== DataType.UWORD -> for(addr in address until address+numwords*2 step 2)
                         mem.setUWord(addr, wordvalue)
-                    value.type==DataType.WORD -> for(addr in address until address+numwords*2 step 2)
+                    value.type== DataType.WORD -> for(addr in address until address+numwords*2 step 2)
                         mem.setSWord(addr, wordvalue)
                     else -> throw VmExecutionException("(u)word value expected")
                 }
             }
             Syscall.SYSCALLSTUB -> throw VmExecutionException("unimplemented sysasm called: ${ins.callLabel}  Create a Syscall enum for this and implement the vm intercept for it.")
-            Syscall.SYSASM_c64scr_PLOT -> {
+            Syscall.SYSASM_c64scr_plot -> {
                 val x = variables.getValue("Y").integerValue()
                 val y = variables.getValue("A").integerValue()
                 canvas?.setCursorPos(x, y)
@@ -2274,44 +2316,54 @@ class StackVm(private var traceOutputFile: String?) {
             Syscall.SYSASM_c64scr_print -> {
                 val straddr = variables.getValue("A").integerValue() + 256*variables.getValue("Y").integerValue()
                 val str = heap.get(straddr).str!!
-                canvas?.printText(str, 1, true)
+                canvas?.printText(str, true)
             }
             Syscall.SYSASM_c64scr_print_ub -> {
                 val num = variables.getValue("A").integerValue()
-                canvas?.printText(num.toString(), 1, true)
+                canvas?.printText(num.toString(), true)
+            }
+            Syscall.SYSASM_c64scr_print_ub0 -> {
+                val num = variables.getValue("A").integerValue()
+                canvas?.printText("%03d".format(num), true)
             }
             Syscall.SYSASM_c64scr_print_b -> {
                 val num = variables.getValue("A").integerValue()
                 if(num<=127)
-                    canvas?.printText(num.toString(), 1, true)
+                    canvas?.printText(num.toString(), true)
                 else
-                    canvas?.printText("-${256-num}", 1, true)
+                    canvas?.printText("-${256-num}", true)
             }
             Syscall.SYSASM_c64scr_print_uw -> {
                 val lo = variables.getValue("A").integerValue()
                 val hi = variables.getValue("Y").integerValue()
                 val number = lo+256*hi
-                canvas?.printText(number.toString(), 1, true)
+                canvas?.printText(number.toString(), true)
+            }
+            Syscall.SYSASM_c64scr_print_uw0 -> {
+                val lo = variables.getValue("A").integerValue()
+                val hi = variables.getValue("Y").integerValue()
+                val number = lo+256*hi
+                canvas?.printText("%05d".format(number), true)
             }
             Syscall.SYSASM_c64scr_print_uwhex -> {
                 val prefix = if(this.P_carry) "$" else ""
                 val lo = variables.getValue("A").integerValue()
                 val hi = variables.getValue("Y").integerValue()
                 val number = lo+256*hi
-                canvas?.printText("$prefix${number.toString(16).padStart(4, '0')}", 1, true)
+                canvas?.printText("$prefix${number.toString(16).padStart(4, '0')}", true)
             }
             Syscall.SYSASM_c64scr_print_w -> {
                 val lo = variables.getValue("A").integerValue()
                 val hi = variables.getValue("Y").integerValue()
                 val number = lo+256*hi
                 if(number<=32767)
-                    canvas?.printText(number.toString(), 1, true)
+                    canvas?.printText(number.toString(), true)
                 else
-                    canvas?.printText("-${65536-number}", 1, true)
+                    canvas?.printText("-${65536-number}", true)
             }
             Syscall.SYSASM_c64flt_print_f -> {
                 val number = variables.getValue("c64flt.print_f.value").numericValue()
-                canvas?.printText(number.toString(), 1, true)
+                canvas?.printText(number.toString(), true)
             }
             Syscall.SYSASM_c64scr_setcc -> {
                 val x = variables.getValue("c64scr.setcc.column").integerValue()
@@ -2332,11 +2384,11 @@ class StackVm(private var traceOutputFile: String?) {
         P_irqd=true
         swapIrqExecutionContexts(true)
 
-        val jiffies = min((timestamp-bootTime)*60/1000, 24*3600*60-1)
+        val jiffies = min((timestamp-rtcOffset)*60/1000, 24*3600*60-1)
         // update the C-64 60hz jiffy clock in the ZP addresses:
-        mem.setUByte(0x00a0, (jiffies ushr 16).toShort())
-        mem.setUByte(0x00a1, (jiffies ushr 8 and 255).toShort())
-        mem.setUByte(0x00a2, (jiffies and 255).toShort())
+        mem.setUByte_DMA(0x00a0, (jiffies ushr 16).toShort())
+        mem.setUByte_DMA(0x00a1, (jiffies ushr 8 and 255).toShort())
+        mem.setUByte_DMA(0x00a2, (jiffies and 255).toShort())
 
         if(irqStartInstructionPtr>=0) {
             try {
@@ -2365,12 +2417,12 @@ class StackVm(private var traceOutputFile: String?) {
             irqStoredCarry = P_carry
             irqStoredTraceOutputFile = traceOutputFile
 
-            if(irqStartInstructionPtr>=0)
-                currentInstructionPtr = irqStartInstructionPtr
+            currentInstructionPtr = if(irqStartInstructionPtr>=0)
+                irqStartInstructionPtr
             else {
                 if(program.last().opcode!=Opcode.RETURN)
                     throw VmExecutionException("last instruction in program should be RETURN for irq handler")
-                currentInstructionPtr = program.size-1
+                program.size-1
             }
             callstack = MyStack()
             evalstack = MyStack()

compiler/test/LiteralValueTests.kt

@@ -2,9 +2,9 @@ package prog8tests
 
 import org.junit.jupiter.api.Test
 import org.junit.jupiter.api.TestInstance
-import prog8.ast.DataType
-import prog8.ast.LiteralValue
-import prog8.ast.Position
+import prog8.ast.base.DataType
+import prog8.ast.expressions.LiteralValue
+import prog8.ast.base.Position
 import kotlin.test.*
 
 
@@ -16,7 +16,7 @@ private fun sameValueAndType(lv1: LiteralValue, lv2: LiteralValue): Boolean {
 @TestInstance(TestInstance.Lifecycle.PER_CLASS)
 class TestParserLiteralValue {
 
-    private val dummyPos = Position("test", 0,0,0)
+    private val dummyPos = Position("test", 0, 0, 0)
 
     @Test
     fun testIdentity() {
@@ -33,99 +33,99 @@ class TestParserLiteralValue {
 
     @Test
     fun testEqualsAndNotEquals() {
-        assertEquals(LiteralValue(DataType.UBYTE, 100, position=dummyPos), LiteralValue(DataType.UBYTE, 100, position=dummyPos))
-        assertEquals(LiteralValue(DataType.UBYTE, 100, position=dummyPos), LiteralValue(DataType.UWORD, wordvalue=100, position=dummyPos))
-        assertEquals(LiteralValue(DataType.UBYTE, 100, position=dummyPos), LiteralValue(DataType.FLOAT, floatvalue=100.0, position=dummyPos))
-        assertEquals(LiteralValue(DataType.UWORD, wordvalue=254, position=dummyPos), LiteralValue(DataType.UBYTE, 254, position=dummyPos))
-        assertEquals(LiteralValue(DataType.UWORD, wordvalue=12345, position=dummyPos), LiteralValue(DataType.UWORD, wordvalue=12345, position=dummyPos))
-        assertEquals(LiteralValue(DataType.UWORD, wordvalue=12345, position=dummyPos), LiteralValue(DataType.FLOAT, floatvalue=12345.0, position=dummyPos))
-        assertEquals(LiteralValue(DataType.FLOAT, floatvalue=100.0, position=dummyPos), LiteralValue(DataType.UBYTE, 100, position=dummyPos))
-        assertEquals(LiteralValue(DataType.FLOAT, floatvalue=22239.0, position=dummyPos), LiteralValue(DataType.UWORD,wordvalue=22239, position=dummyPos))
-        assertEquals(LiteralValue(DataType.FLOAT, floatvalue=9.99, position=dummyPos), LiteralValue(DataType.FLOAT, floatvalue=9.99, position=dummyPos))
+        assertEquals(LiteralValue(DataType.UBYTE, 100, position = dummyPos), LiteralValue(DataType.UBYTE, 100, position = dummyPos))
+        assertEquals(LiteralValue(DataType.UBYTE, 100, position = dummyPos), LiteralValue(DataType.UWORD, wordvalue = 100, position = dummyPos))
+        assertEquals(LiteralValue(DataType.UBYTE, 100, position = dummyPos), LiteralValue(DataType.FLOAT, floatvalue = 100.0, position = dummyPos))
+        assertEquals(LiteralValue(DataType.UWORD, wordvalue = 254, position = dummyPos), LiteralValue(DataType.UBYTE, 254, position = dummyPos))
+        assertEquals(LiteralValue(DataType.UWORD, wordvalue = 12345, position = dummyPos), LiteralValue(DataType.UWORD, wordvalue = 12345, position = dummyPos))
+        assertEquals(LiteralValue(DataType.UWORD, wordvalue = 12345, position = dummyPos), LiteralValue(DataType.FLOAT, floatvalue = 12345.0, position = dummyPos))
+        assertEquals(LiteralValue(DataType.FLOAT, floatvalue = 100.0, position = dummyPos), LiteralValue(DataType.UBYTE, 100, position = dummyPos))
+        assertEquals(LiteralValue(DataType.FLOAT, floatvalue = 22239.0, position = dummyPos), LiteralValue(DataType.UWORD, wordvalue = 22239, position = dummyPos))
+        assertEquals(LiteralValue(DataType.FLOAT, floatvalue = 9.99, position = dummyPos), LiteralValue(DataType.FLOAT, floatvalue = 9.99, position = dummyPos))
 
-        assertTrue(sameValueAndType(LiteralValue(DataType.UBYTE, 100, position=dummyPos), LiteralValue(DataType.UBYTE, 100, position=dummyPos)))
-        assertFalse(sameValueAndType(LiteralValue(DataType.UBYTE, 100, position=dummyPos), LiteralValue(DataType.UWORD, wordvalue=100, position=dummyPos)))
-        assertFalse(sameValueAndType(LiteralValue(DataType.UBYTE, 100, position=dummyPos), LiteralValue(DataType.FLOAT, floatvalue=100.0, position=dummyPos)))
-        assertFalse(sameValueAndType(LiteralValue(DataType.UWORD, wordvalue=254, position=dummyPos), LiteralValue(DataType.UBYTE, 254, position=dummyPos)))
-        assertTrue(sameValueAndType(LiteralValue(DataType.UWORD, wordvalue=12345, position=dummyPos), LiteralValue(DataType.UWORD, wordvalue=12345, position=dummyPos)))
-        assertFalse(sameValueAndType(LiteralValue(DataType.UWORD, wordvalue=12345, position=dummyPos), LiteralValue(DataType.FLOAT, floatvalue=12345.0, position=dummyPos)))
-        assertFalse(sameValueAndType(LiteralValue(DataType.FLOAT, floatvalue=100.0, position=dummyPos), LiteralValue(DataType.UBYTE, 100, position=dummyPos)))
-        assertFalse(sameValueAndType(LiteralValue(DataType.FLOAT, floatvalue=22239.0, position=dummyPos), LiteralValue(DataType.UWORD,wordvalue=22239, position=dummyPos)))
-        assertTrue(sameValueAndType(LiteralValue(DataType.FLOAT, floatvalue=9.99, position=dummyPos), LiteralValue(DataType.FLOAT, floatvalue=9.99, position=dummyPos)))
+        assertTrue(sameValueAndType(LiteralValue(DataType.UBYTE, 100, position = dummyPos), LiteralValue(DataType.UBYTE, 100, position = dummyPos)))
+        assertFalse(sameValueAndType(LiteralValue(DataType.UBYTE, 100, position = dummyPos), LiteralValue(DataType.UWORD, wordvalue = 100, position = dummyPos)))
+        assertFalse(sameValueAndType(LiteralValue(DataType.UBYTE, 100, position = dummyPos), LiteralValue(DataType.FLOAT, floatvalue = 100.0, position = dummyPos)))
+        assertFalse(sameValueAndType(LiteralValue(DataType.UWORD, wordvalue = 254, position = dummyPos), LiteralValue(DataType.UBYTE, 254, position = dummyPos)))
+        assertTrue(sameValueAndType(LiteralValue(DataType.UWORD, wordvalue = 12345, position = dummyPos), LiteralValue(DataType.UWORD, wordvalue = 12345, position = dummyPos)))
+        assertFalse(sameValueAndType(LiteralValue(DataType.UWORD, wordvalue = 12345, position = dummyPos), LiteralValue(DataType.FLOAT, floatvalue = 12345.0, position = dummyPos)))
+        assertFalse(sameValueAndType(LiteralValue(DataType.FLOAT, floatvalue = 100.0, position = dummyPos), LiteralValue(DataType.UBYTE, 100, position = dummyPos)))
+        assertFalse(sameValueAndType(LiteralValue(DataType.FLOAT, floatvalue = 22239.0, position = dummyPos), LiteralValue(DataType.UWORD, wordvalue = 22239, position = dummyPos)))
+        assertTrue(sameValueAndType(LiteralValue(DataType.FLOAT, floatvalue = 9.99, position = dummyPos), LiteralValue(DataType.FLOAT, floatvalue = 9.99, position = dummyPos)))
 
-        assertNotEquals(LiteralValue(DataType.UBYTE, 100, position=dummyPos), LiteralValue(DataType.UBYTE, 101, position=dummyPos))
-        assertNotEquals(LiteralValue(DataType.UBYTE, 100, position=dummyPos), LiteralValue(DataType.UWORD, wordvalue=101, position=dummyPos))
-        assertNotEquals(LiteralValue(DataType.UBYTE, 100, position=dummyPos), LiteralValue(DataType.FLOAT, floatvalue=101.0, position=dummyPos))
-        assertNotEquals(LiteralValue(DataType.UWORD, wordvalue=245, position=dummyPos), LiteralValue(DataType.UBYTE, 246, position=dummyPos))
-        assertNotEquals(LiteralValue(DataType.UWORD, wordvalue=12345, position=dummyPos), LiteralValue(DataType.UWORD, wordvalue=12346, position=dummyPos))
-        assertNotEquals(LiteralValue(DataType.UWORD, wordvalue=12345, position=dummyPos), LiteralValue(DataType.FLOAT, floatvalue=12346.0, position=dummyPos))
-        assertNotEquals(LiteralValue(DataType.FLOAT, floatvalue=9.99, position=dummyPos), LiteralValue(DataType.UBYTE, 9, position=dummyPos))
-        assertNotEquals(LiteralValue(DataType.FLOAT, floatvalue=9.99, position=dummyPos), LiteralValue(DataType.UWORD, wordvalue=9, position=dummyPos))
-        assertNotEquals(LiteralValue(DataType.FLOAT, floatvalue=9.99, position=dummyPos), LiteralValue(DataType.FLOAT, floatvalue=9.0, position=dummyPos))
+        assertNotEquals(LiteralValue(DataType.UBYTE, 100, position = dummyPos), LiteralValue(DataType.UBYTE, 101, position = dummyPos))
+        assertNotEquals(LiteralValue(DataType.UBYTE, 100, position = dummyPos), LiteralValue(DataType.UWORD, wordvalue = 101, position = dummyPos))
+        assertNotEquals(LiteralValue(DataType.UBYTE, 100, position = dummyPos), LiteralValue(DataType.FLOAT, floatvalue = 101.0, position = dummyPos))
+        assertNotEquals(LiteralValue(DataType.UWORD, wordvalue = 245, position = dummyPos), LiteralValue(DataType.UBYTE, 246, position = dummyPos))
+        assertNotEquals(LiteralValue(DataType.UWORD, wordvalue = 12345, position = dummyPos), LiteralValue(DataType.UWORD, wordvalue = 12346, position = dummyPos))
+        assertNotEquals(LiteralValue(DataType.UWORD, wordvalue = 12345, position = dummyPos), LiteralValue(DataType.FLOAT, floatvalue = 12346.0, position = dummyPos))
+        assertNotEquals(LiteralValue(DataType.FLOAT, floatvalue = 9.99, position = dummyPos), LiteralValue(DataType.UBYTE, 9, position = dummyPos))
+        assertNotEquals(LiteralValue(DataType.FLOAT, floatvalue = 9.99, position = dummyPos), LiteralValue(DataType.UWORD, wordvalue = 9, position = dummyPos))
+        assertNotEquals(LiteralValue(DataType.FLOAT, floatvalue = 9.99, position = dummyPos), LiteralValue(DataType.FLOAT, floatvalue = 9.0, position = dummyPos))
 
-        assertFalse(sameValueAndType(LiteralValue(DataType.UBYTE, 100, position=dummyPos), LiteralValue(DataType.UBYTE, 101, position=dummyPos)))
-        assertFalse(sameValueAndType(LiteralValue(DataType.UBYTE, 100, position=dummyPos), LiteralValue(DataType.UWORD, wordvalue=101, position=dummyPos)))
-        assertFalse(sameValueAndType(LiteralValue(DataType.UBYTE, 100, position=dummyPos), LiteralValue(DataType.FLOAT, floatvalue=101.0, position=dummyPos)))
-        assertFalse(sameValueAndType(LiteralValue(DataType.UWORD, wordvalue=245, position=dummyPos), LiteralValue(DataType.UBYTE, 246, position=dummyPos)))
-        assertFalse(sameValueAndType(LiteralValue(DataType.UWORD, wordvalue=12345, position=dummyPos), LiteralValue(DataType.UWORD, wordvalue=12346, position=dummyPos)))
-        assertFalse(sameValueAndType(LiteralValue(DataType.UWORD, wordvalue=12345, position=dummyPos), LiteralValue(DataType.FLOAT, floatvalue=12346.0, position=dummyPos)))
-        assertFalse(sameValueAndType(LiteralValue(DataType.FLOAT, floatvalue=9.99, position=dummyPos), LiteralValue(DataType.UBYTE, 9, position=dummyPos)))
-        assertFalse(sameValueAndType(LiteralValue(DataType.FLOAT, floatvalue=9.99, position=dummyPos), LiteralValue(DataType.UWORD, wordvalue=9, position=dummyPos)))
-        assertFalse(sameValueAndType(LiteralValue(DataType.FLOAT, floatvalue=9.99, position=dummyPos), LiteralValue(DataType.FLOAT, floatvalue=9.0, position=dummyPos)))
+        assertFalse(sameValueAndType(LiteralValue(DataType.UBYTE, 100, position = dummyPos), LiteralValue(DataType.UBYTE, 101, position = dummyPos)))
+        assertFalse(sameValueAndType(LiteralValue(DataType.UBYTE, 100, position = dummyPos), LiteralValue(DataType.UWORD, wordvalue = 101, position = dummyPos)))
+        assertFalse(sameValueAndType(LiteralValue(DataType.UBYTE, 100, position = dummyPos), LiteralValue(DataType.FLOAT, floatvalue = 101.0, position = dummyPos)))
+        assertFalse(sameValueAndType(LiteralValue(DataType.UWORD, wordvalue = 245, position = dummyPos), LiteralValue(DataType.UBYTE, 246, position = dummyPos)))
+        assertFalse(sameValueAndType(LiteralValue(DataType.UWORD, wordvalue = 12345, position = dummyPos), LiteralValue(DataType.UWORD, wordvalue = 12346, position = dummyPos)))
+        assertFalse(sameValueAndType(LiteralValue(DataType.UWORD, wordvalue = 12345, position = dummyPos), LiteralValue(DataType.FLOAT, floatvalue = 12346.0, position = dummyPos)))
+        assertFalse(sameValueAndType(LiteralValue(DataType.FLOAT, floatvalue = 9.99, position = dummyPos), LiteralValue(DataType.UBYTE, 9, position = dummyPos)))
+        assertFalse(sameValueAndType(LiteralValue(DataType.FLOAT, floatvalue = 9.99, position = dummyPos), LiteralValue(DataType.UWORD, wordvalue = 9, position = dummyPos)))
+        assertFalse(sameValueAndType(LiteralValue(DataType.FLOAT, floatvalue = 9.99, position = dummyPos), LiteralValue(DataType.FLOAT, floatvalue = 9.0, position = dummyPos)))
 
-        assertTrue(sameValueAndType(LiteralValue(DataType.STR, strvalue = "hello", position=dummyPos), LiteralValue(DataType.STR, strvalue="hello", position=dummyPos)))
-        assertFalse(sameValueAndType(LiteralValue(DataType.STR, strvalue = "hello", position=dummyPos), LiteralValue(DataType.STR, strvalue="bye", position=dummyPos)))
+        assertTrue(sameValueAndType(LiteralValue(DataType.STR, strvalue = "hello", position = dummyPos), LiteralValue(DataType.STR, strvalue = "hello", position = dummyPos)))
+        assertFalse(sameValueAndType(LiteralValue(DataType.STR, strvalue = "hello", position = dummyPos), LiteralValue(DataType.STR, strvalue = "bye", position = dummyPos)))
 
-        val lvOne = LiteralValue(DataType.UBYTE, 1, position=dummyPos)
-        val lvTwo = LiteralValue(DataType.UBYTE, 2, position=dummyPos)
-        val lvThree = LiteralValue(DataType.UBYTE, 3, position=dummyPos)
-        val lvOneR = LiteralValue(DataType.UBYTE, 1, position=dummyPos)
-        val lvTwoR = LiteralValue(DataType.UBYTE, 2, position=dummyPos)
-        val lvThreeR = LiteralValue(DataType.UBYTE, 3, position=dummyPos)
-        val lvFour= LiteralValue(DataType.UBYTE, 4, position=dummyPos)
-        val lv1 = LiteralValue(DataType.ARRAY_UB, arrayvalue = arrayOf(lvOne, lvTwo, lvThree), position=dummyPos)
-        val lv2 = LiteralValue(DataType.ARRAY_UB, arrayvalue = arrayOf(lvOneR, lvTwoR, lvThreeR), position=dummyPos)
-        val lv3 = LiteralValue(DataType.ARRAY_UB, arrayvalue = arrayOf(lvOneR, lvTwoR, lvFour), position=dummyPos)
+        val lvOne = LiteralValue(DataType.UBYTE, 1, position = dummyPos)
+        val lvTwo = LiteralValue(DataType.UBYTE, 2, position = dummyPos)
+        val lvThree = LiteralValue(DataType.UBYTE, 3, position = dummyPos)
+        val lvOneR = LiteralValue(DataType.UBYTE, 1, position = dummyPos)
+        val lvTwoR = LiteralValue(DataType.UBYTE, 2, position = dummyPos)
+        val lvThreeR = LiteralValue(DataType.UBYTE, 3, position = dummyPos)
+        val lvFour= LiteralValue(DataType.UBYTE, 4, position = dummyPos)
+        val lv1 = LiteralValue(DataType.ARRAY_UB, arrayvalue = arrayOf(lvOne, lvTwo, lvThree), position = dummyPos)
+        val lv2 = LiteralValue(DataType.ARRAY_UB, arrayvalue = arrayOf(lvOneR, lvTwoR, lvThreeR), position = dummyPos)
+        val lv3 = LiteralValue(DataType.ARRAY_UB, arrayvalue = arrayOf(lvOneR, lvTwoR, lvFour), position = dummyPos)
         assertEquals(lv1, lv2)
         assertNotEquals(lv1, lv3)
     }
 
     @Test
     fun testGreaterThan(){
-        assertTrue(LiteralValue(DataType.UBYTE, 100, position=dummyPos) > LiteralValue(DataType.UBYTE, 99, position=dummyPos))
-        assertTrue(LiteralValue(DataType.UWORD, wordvalue=254, position=dummyPos) > LiteralValue(DataType.UWORD, wordvalue=253, position=dummyPos))
-        assertTrue(LiteralValue(DataType.FLOAT, floatvalue=100.0, position=dummyPos) > LiteralValue(DataType.FLOAT, floatvalue=99.9, position=dummyPos))
+        assertTrue(LiteralValue(DataType.UBYTE, 100, position = dummyPos) > LiteralValue(DataType.UBYTE, 99, position = dummyPos))
+        assertTrue(LiteralValue(DataType.UWORD, wordvalue = 254, position = dummyPos) > LiteralValue(DataType.UWORD, wordvalue = 253, position = dummyPos))
+        assertTrue(LiteralValue(DataType.FLOAT, floatvalue = 100.0, position = dummyPos) > LiteralValue(DataType.FLOAT, floatvalue = 99.9, position = dummyPos))
 
-        assertTrue(LiteralValue(DataType.UBYTE, 100, position=dummyPos) >= LiteralValue(DataType.UBYTE, 100, position=dummyPos))
-        assertTrue(LiteralValue(DataType.UWORD, wordvalue=254, position=dummyPos) >= LiteralValue(DataType.UWORD,wordvalue= 254, position=dummyPos))
-        assertTrue(LiteralValue(DataType.FLOAT, floatvalue=100.0, position=dummyPos) >= LiteralValue(DataType.FLOAT, floatvalue=100.0, position=dummyPos))
+        assertTrue(LiteralValue(DataType.UBYTE, 100, position = dummyPos) >= LiteralValue(DataType.UBYTE, 100, position = dummyPos))
+        assertTrue(LiteralValue(DataType.UWORD, wordvalue = 254, position = dummyPos) >= LiteralValue(DataType.UWORD, wordvalue = 254, position = dummyPos))
+        assertTrue(LiteralValue(DataType.FLOAT, floatvalue = 100.0, position = dummyPos) >= LiteralValue(DataType.FLOAT, floatvalue = 100.0, position = dummyPos))
 
-        assertFalse(LiteralValue(DataType.UBYTE, 100, position=dummyPos) > LiteralValue(DataType.UBYTE, 100, position=dummyPos))
-        assertFalse(LiteralValue(DataType.UWORD, wordvalue=254, position=dummyPos) > LiteralValue(DataType.UWORD, wordvalue=254, position=dummyPos))
-        assertFalse(LiteralValue(DataType.FLOAT, floatvalue=100.0, position=dummyPos) > LiteralValue(DataType.FLOAT, floatvalue=100.0, position=dummyPos))
+        assertFalse(LiteralValue(DataType.UBYTE, 100, position = dummyPos) > LiteralValue(DataType.UBYTE, 100, position = dummyPos))
+        assertFalse(LiteralValue(DataType.UWORD, wordvalue = 254, position = dummyPos) > LiteralValue(DataType.UWORD, wordvalue = 254, position = dummyPos))
+        assertFalse(LiteralValue(DataType.FLOAT, floatvalue = 100.0, position = dummyPos) > LiteralValue(DataType.FLOAT, floatvalue = 100.0, position = dummyPos))
 
-        assertFalse(LiteralValue(DataType.UBYTE, 100, position=dummyPos) >= LiteralValue(DataType.UBYTE, 101, position=dummyPos))
-        assertFalse(LiteralValue(DataType.UWORD, wordvalue=254, position=dummyPos) >= LiteralValue(DataType.UWORD,wordvalue= 255, position=dummyPos))
-        assertFalse(LiteralValue(DataType.FLOAT, floatvalue=100.0, position=dummyPos) >= LiteralValue(DataType.FLOAT, floatvalue=100.1, position=dummyPos))
+        assertFalse(LiteralValue(DataType.UBYTE, 100, position = dummyPos) >= LiteralValue(DataType.UBYTE, 101, position = dummyPos))
+        assertFalse(LiteralValue(DataType.UWORD, wordvalue = 254, position = dummyPos) >= LiteralValue(DataType.UWORD, wordvalue = 255, position = dummyPos))
+        assertFalse(LiteralValue(DataType.FLOAT, floatvalue = 100.0, position = dummyPos) >= LiteralValue(DataType.FLOAT, floatvalue = 100.1, position = dummyPos))
     }
 
     @Test
     fun testLessThan() {
-        assertTrue(LiteralValue(DataType.UBYTE, 100, position=dummyPos) < LiteralValue(DataType.UBYTE, 101, position=dummyPos))
-        assertTrue(LiteralValue(DataType.UWORD, wordvalue=254, position=dummyPos) < LiteralValue(DataType.UWORD, wordvalue=255, position=dummyPos))
-        assertTrue(LiteralValue(DataType.FLOAT, floatvalue=100.0, position=dummyPos) < LiteralValue(DataType.FLOAT, floatvalue=100.1, position=dummyPos))
+        assertTrue(LiteralValue(DataType.UBYTE, 100, position = dummyPos) < LiteralValue(DataType.UBYTE, 101, position = dummyPos))
+        assertTrue(LiteralValue(DataType.UWORD, wordvalue = 254, position = dummyPos) < LiteralValue(DataType.UWORD, wordvalue = 255, position = dummyPos))
+        assertTrue(LiteralValue(DataType.FLOAT, floatvalue = 100.0, position = dummyPos) < LiteralValue(DataType.FLOAT, floatvalue = 100.1, position = dummyPos))
 
-        assertTrue(LiteralValue(DataType.UBYTE, 100, position=dummyPos) <= LiteralValue(DataType.UBYTE, 100, position=dummyPos))
-        assertTrue(LiteralValue(DataType.UWORD, wordvalue=254, position=dummyPos) <= LiteralValue(DataType.UWORD,wordvalue= 254, position=dummyPos))
-        assertTrue(LiteralValue(DataType.FLOAT, floatvalue=100.0, position=dummyPos) <= LiteralValue(DataType.FLOAT, floatvalue=100.0, position=dummyPos))
+        assertTrue(LiteralValue(DataType.UBYTE, 100, position = dummyPos) <= LiteralValue(DataType.UBYTE, 100, position = dummyPos))
+        assertTrue(LiteralValue(DataType.UWORD, wordvalue = 254, position = dummyPos) <= LiteralValue(DataType.UWORD, wordvalue = 254, position = dummyPos))
+        assertTrue(LiteralValue(DataType.FLOAT, floatvalue = 100.0, position = dummyPos) <= LiteralValue(DataType.FLOAT, floatvalue = 100.0, position = dummyPos))
 
-        assertFalse(LiteralValue(DataType.UBYTE, 100, position=dummyPos) < LiteralValue(DataType.UBYTE, 100, position=dummyPos))
-        assertFalse(LiteralValue(DataType.UWORD, wordvalue=254, position=dummyPos) < LiteralValue(DataType.UWORD, wordvalue=254, position=dummyPos))
-        assertFalse(LiteralValue(DataType.FLOAT, floatvalue=100.0, position=dummyPos) < LiteralValue(DataType.FLOAT, floatvalue=100.0, position=dummyPos))
+        assertFalse(LiteralValue(DataType.UBYTE, 100, position = dummyPos) < LiteralValue(DataType.UBYTE, 100, position = dummyPos))
+        assertFalse(LiteralValue(DataType.UWORD, wordvalue = 254, position = dummyPos) < LiteralValue(DataType.UWORD, wordvalue = 254, position = dummyPos))
+        assertFalse(LiteralValue(DataType.FLOAT, floatvalue = 100.0, position = dummyPos) < LiteralValue(DataType.FLOAT, floatvalue = 100.0, position = dummyPos))
 
-        assertFalse(LiteralValue(DataType.UBYTE, 100, position=dummyPos) <= LiteralValue(DataType.UBYTE, 99, position=dummyPos))
-        assertFalse(LiteralValue(DataType.UWORD,wordvalue= 254, position=dummyPos) <= LiteralValue(DataType.UWORD,wordvalue= 253, position=dummyPos))
-        assertFalse(LiteralValue(DataType.FLOAT,floatvalue= 100.0, position=dummyPos) <= LiteralValue(DataType.FLOAT, floatvalue=99.9, position=dummyPos))
+        assertFalse(LiteralValue(DataType.UBYTE, 100, position = dummyPos) <= LiteralValue(DataType.UBYTE, 99, position = dummyPos))
+        assertFalse(LiteralValue(DataType.UWORD, wordvalue = 254, position = dummyPos) <= LiteralValue(DataType.UWORD, wordvalue = 253, position = dummyPos))
+        assertFalse(LiteralValue(DataType.FLOAT, floatvalue = 100.0, position = dummyPos) <= LiteralValue(DataType.FLOAT, floatvalue = 99.9, position = dummyPos))
     }
 
 }

compiler/test/RuntimeValueTests.kt

@@ -2,8 +2,8 @@ package prog8tests
 
 import org.junit.jupiter.api.Test
 import org.junit.jupiter.api.TestInstance
-import prog8.ast.DataType
-import prog8.compiler.RuntimeValue
+import prog8.ast.base.DataType
+import prog8.vm.RuntimeValue
 import kotlin.test.*
 
 
@@ -17,39 +17,27 @@ class TestRuntimeValue {
 
     @Test
     fun testValueRanges() {
-        assertEquals(100, RuntimeValue(DataType.UBYTE, 100).integerValue())
-        assertEquals(100, RuntimeValue(DataType.BYTE, 100).integerValue())
-        assertEquals(10000, RuntimeValue(DataType.UWORD, 10000).integerValue())
-        assertEquals(10000, RuntimeValue(DataType.WORD, 10000).integerValue())
-        assertEquals(100.11, RuntimeValue(DataType.FLOAT, 100.11).numericValue())
+        assertEquals(0, RuntimeValue(DataType.UBYTE, 0).integerValue())
+        assertEquals(255, RuntimeValue(DataType.UBYTE, 255).integerValue())
+        assertFailsWith<IllegalArgumentException> { RuntimeValue(DataType.UBYTE, -1)}
+        assertFailsWith<IllegalArgumentException> { RuntimeValue(DataType.UBYTE, 256)}
 
-        assertEquals(200, RuntimeValue(DataType.UBYTE, 200).integerValue())
-        assertEquals(-56, RuntimeValue(DataType.BYTE, 200).integerValue())
-        assertEquals(50000, RuntimeValue(DataType.UWORD, 50000).integerValue())
-        assertEquals(-15536, RuntimeValue(DataType.WORD, 50000).integerValue())
+        assertEquals(0, RuntimeValue(DataType.BYTE, 0).integerValue())
+        assertEquals(-128, RuntimeValue(DataType.BYTE, -128).integerValue())
+        assertEquals(127, RuntimeValue(DataType.BYTE, 127).integerValue())
+        assertFailsWith<IllegalArgumentException> { RuntimeValue(DataType.BYTE, -129)}
+        assertFailsWith<IllegalArgumentException> { RuntimeValue(DataType.BYTE, 128)}
 
-        assertEquals(44, RuntimeValue(DataType.UBYTE, 300).integerValue())
-        assertEquals(44, RuntimeValue(DataType.BYTE, 300).integerValue())
-        assertEquals(144, RuntimeValue(DataType.UBYTE, 400).integerValue())
-        assertEquals(-112, RuntimeValue(DataType.BYTE, 400).integerValue())
-        assertEquals(34463, RuntimeValue(DataType.UWORD, 99999).integerValue())
-        assertEquals(-31073, RuntimeValue(DataType.WORD, 99999).integerValue())
+        assertEquals(0, RuntimeValue(DataType.UWORD, 0).integerValue())
+        assertEquals(65535, RuntimeValue(DataType.UWORD, 65535).integerValue())
+        assertFailsWith<IllegalArgumentException> { RuntimeValue(DataType.UWORD, -1)}
+        assertFailsWith<IllegalArgumentException> { RuntimeValue(DataType.UWORD, 65536)}
 
-        assertEquals(156, RuntimeValue(DataType.UBYTE, -100).integerValue())
-        assertEquals(-100, RuntimeValue(DataType.BYTE, -100).integerValue())
-        assertEquals(55536, RuntimeValue(DataType.UWORD, -10000).integerValue())
-        assertEquals(-10000, RuntimeValue(DataType.WORD, -10000).integerValue())
-        assertEquals(-100.11, RuntimeValue(DataType.FLOAT, -100.11).numericValue())
-
-        assertEquals(56, RuntimeValue(DataType.UBYTE, -200).integerValue())
-        assertEquals(56, RuntimeValue(DataType.BYTE, -200).integerValue())
-        assertEquals(45536, RuntimeValue(DataType.UWORD, -20000).integerValue())
-        assertEquals(-20000, RuntimeValue(DataType.WORD, -20000).integerValue())
-
-        assertEquals(212, RuntimeValue(DataType.UBYTE, -300).integerValue())
-        assertEquals(-44, RuntimeValue(DataType.BYTE, -300).integerValue())
-        assertEquals(42184, RuntimeValue(DataType.UWORD, -88888).integerValue())
-        assertEquals(-23352, RuntimeValue(DataType.WORD, -88888).integerValue())
+        assertEquals(0, RuntimeValue(DataType.WORD, 0).integerValue())
+        assertEquals(-32768, RuntimeValue(DataType.WORD, -32768).integerValue())
+        assertEquals(32767, RuntimeValue(DataType.WORD, 32767).integerValue())
+        assertFailsWith<IllegalArgumentException> { RuntimeValue(DataType.WORD, -32769)}
+        assertFailsWith<IllegalArgumentException> { RuntimeValue(DataType.WORD, 32768)}
     }
 
     @Test
@@ -60,10 +48,6 @@ class TestRuntimeValue {
         assertFalse(RuntimeValue(DataType.WORD, 0).asBoolean)
         assertFalse(RuntimeValue(DataType.UWORD, 0).asBoolean)
         assertFalse(RuntimeValue(DataType.FLOAT, 0.0).asBoolean)
-        assertFalse(RuntimeValue(DataType.BYTE, 256).asBoolean)
-        assertFalse(RuntimeValue(DataType.UBYTE, 256).asBoolean)
-        assertFalse(RuntimeValue(DataType.WORD, 65536).asBoolean)
-        assertFalse(RuntimeValue(DataType.UWORD, 65536).asBoolean)
 
         assertTrue(RuntimeValue(DataType.BYTE, 42).asBoolean)
         assertTrue(RuntimeValue(DataType.UBYTE, 42).asBoolean)
@@ -71,9 +55,7 @@ class TestRuntimeValue {
         assertTrue(RuntimeValue(DataType.UWORD, 42).asBoolean)
         assertTrue(RuntimeValue(DataType.FLOAT, 42.0).asBoolean)
         assertTrue(RuntimeValue(DataType.BYTE, -42).asBoolean)
-        assertTrue(RuntimeValue(DataType.UBYTE, -42).asBoolean)
         assertTrue(RuntimeValue(DataType.WORD, -42).asBoolean)
-        assertTrue(RuntimeValue(DataType.UWORD, -42).asBoolean)
         assertTrue(RuntimeValue(DataType.FLOAT, -42.0).asBoolean)
     }
 
@@ -245,4 +227,155 @@ class TestRuntimeValue {
         }
         val result = RuntimeValue(DataType.FLOAT, 233.333).add(RuntimeValue(DataType.FLOAT, 1.234))
     }
+
+    @Test
+    fun arithmetictestUbyte() {
+        assertEquals(255, RuntimeValue(DataType.UBYTE, 200).add(RuntimeValue(DataType.UBYTE, 55)).integerValue())
+        assertEquals(0, RuntimeValue(DataType.UBYTE, 200).add(RuntimeValue(DataType.UBYTE, 56)).integerValue())
+        assertEquals(1, RuntimeValue(DataType.UBYTE, 200).add(RuntimeValue(DataType.UBYTE, 57)).integerValue())
+
+        assertEquals(1, RuntimeValue(DataType.UBYTE, 2).sub(RuntimeValue(DataType.UBYTE, 1)).integerValue())
+        assertEquals(0, RuntimeValue(DataType.UBYTE, 2).sub(RuntimeValue(DataType.UBYTE, 2)).integerValue())
+        assertEquals(255, RuntimeValue(DataType.UBYTE, 2).sub(RuntimeValue(DataType.UBYTE, 3)).integerValue())
+
+        assertEquals(255, RuntimeValue(DataType.UBYTE, 254).inc().integerValue())
+        assertEquals(0, RuntimeValue(DataType.UBYTE, 255).inc().integerValue())
+        assertEquals(0, RuntimeValue(DataType.UBYTE, 1).dec().integerValue())
+        assertEquals(255, RuntimeValue(DataType.UBYTE, 0).dec().integerValue())
+
+        assertEquals(255, RuntimeValue(DataType.UBYTE, 0).inv().integerValue())
+        assertEquals(0b00110011, RuntimeValue(DataType.UBYTE, 0b11001100).inv().integerValue())
+//        assertEquals(0, RuntimeValue(DataType.UBYTE, 0).neg().integerValue())
+//        assertEquals(0, RuntimeValue(DataType.UBYTE, 0).neg().integerValue())
+        assertEquals(1, RuntimeValue(DataType.UBYTE, 0).not().integerValue())
+        assertEquals(0, RuntimeValue(DataType.UBYTE, 1).not().integerValue())
+        assertEquals(0, RuntimeValue(DataType.UBYTE, 111).not().integerValue())
+        assertEquals(0, RuntimeValue(DataType.UBYTE, 255).not().integerValue())
+
+        assertEquals(200, RuntimeValue(DataType.UBYTE, 20).mul(RuntimeValue(DataType.UBYTE, 10)).integerValue())
+        assertEquals(144, RuntimeValue(DataType.UBYTE, 20).mul(RuntimeValue(DataType.UBYTE, 20)).integerValue())
+
+        assertEquals(25, RuntimeValue(DataType.UBYTE, 5).pow(RuntimeValue(DataType.UBYTE, 2)).integerValue())
+        assertEquals(125, RuntimeValue(DataType.UBYTE, 5).pow(RuntimeValue(DataType.UBYTE, 3)).integerValue())
+        assertEquals(113, RuntimeValue(DataType.UBYTE, 5).pow(RuntimeValue(DataType.UBYTE, 4)).integerValue())
+
+        assertEquals(100, RuntimeValue(DataType.UBYTE, 50).shl().integerValue())
+        assertEquals(200, RuntimeValue(DataType.UBYTE, 100).shl().integerValue())
+        assertEquals(144, RuntimeValue(DataType.UBYTE, 200).shl().integerValue())
+    }
+
+    @Test
+    fun arithmetictestUWord() {
+        assertEquals(65535, RuntimeValue(DataType.UWORD, 60000).add(RuntimeValue(DataType.UWORD, 5535)).integerValue())
+        assertEquals(0, RuntimeValue(DataType.UWORD, 60000).add(RuntimeValue(DataType.UWORD, 5536)).integerValue())
+        assertEquals(1, RuntimeValue(DataType.UWORD, 60000).add(RuntimeValue(DataType.UWORD, 5537)).integerValue())
+
+        assertEquals(1, RuntimeValue(DataType.UWORD, 2).sub(RuntimeValue(DataType.UWORD, 1)).integerValue())
+        assertEquals(0, RuntimeValue(DataType.UWORD, 2).sub(RuntimeValue(DataType.UWORD, 2)).integerValue())
+        assertEquals(65535, RuntimeValue(DataType.UWORD, 2).sub(RuntimeValue(DataType.UWORD, 3)).integerValue())
+
+        assertEquals(65535, RuntimeValue(DataType.UWORD, 65534).inc().integerValue())
+        assertEquals(0, RuntimeValue(DataType.UWORD, 65535).inc().integerValue())
+        assertEquals(0, RuntimeValue(DataType.UWORD, 1).dec().integerValue())
+        assertEquals(65535, RuntimeValue(DataType.UWORD, 0).dec().integerValue())
+
+        assertEquals(65535, RuntimeValue(DataType.UWORD, 0).inv().integerValue())
+        assertEquals(0b0011001101010101, RuntimeValue(DataType.UWORD, 0b1100110010101010).inv().integerValue())
+//        assertEquals(0, RuntimeValue(DataType.UWORD, 0).neg().integerValue())
+//        assertEquals(0, RuntimeValue(DataType.UWORD, 0).neg().integerValue())
+        assertEquals(1, RuntimeValue(DataType.UWORD, 0).not().integerValue())
+        assertEquals(0, RuntimeValue(DataType.UWORD, 1).not().integerValue())
+        assertEquals(0, RuntimeValue(DataType.UWORD, 11111).not().integerValue())
+        assertEquals(0, RuntimeValue(DataType.UWORD, 65535).not().integerValue())
+
+        assertEquals(2000, RuntimeValue(DataType.UWORD, 200).mul(RuntimeValue(DataType.UWORD, 10)).integerValue())
+        assertEquals(40000, RuntimeValue(DataType.UWORD, 200).mul(RuntimeValue(DataType.UWORD, 200)).integerValue())
+        assertEquals(14464, RuntimeValue(DataType.UWORD, 200).mul(RuntimeValue(DataType.UWORD, 400)).integerValue())
+
+        assertEquals(15625, RuntimeValue(DataType.UWORD, 5).pow(RuntimeValue(DataType.UWORD, 6)).integerValue())
+        assertEquals(12589, RuntimeValue(DataType.UWORD, 5).pow(RuntimeValue(DataType.UWORD, 7)).integerValue())
+
+        assertEquals(10000, RuntimeValue(DataType.UWORD, 5000).shl().integerValue())
+        assertEquals(60000, RuntimeValue(DataType.UWORD, 30000).shl().integerValue())
+        assertEquals(14464, RuntimeValue(DataType.UWORD, 40000).shl().integerValue())
+    }
+
+    @Test
+    fun arithmetictestByte() {
+        assertEquals(127, RuntimeValue(DataType.BYTE, 100).add(RuntimeValue(DataType.BYTE, 27)).integerValue())
+        assertEquals(-128, RuntimeValue(DataType.BYTE, 100).add(RuntimeValue(DataType.BYTE, 28)).integerValue())
+        assertEquals(-127, RuntimeValue(DataType.BYTE, 100).add(RuntimeValue(DataType.BYTE, 29)).integerValue())
+
+        assertEquals(1, RuntimeValue(DataType.BYTE, 2).sub(RuntimeValue(DataType.BYTE, 1)).integerValue())
+        assertEquals(0, RuntimeValue(DataType.BYTE, 2).sub(RuntimeValue(DataType.BYTE, 2)).integerValue())
+        assertEquals(-1, RuntimeValue(DataType.BYTE, 2).sub(RuntimeValue(DataType.BYTE, 3)).integerValue())
+        assertEquals(-128, RuntimeValue(DataType.BYTE, -100).sub(RuntimeValue(DataType.BYTE, 28)).integerValue())
+        assertEquals(127, RuntimeValue(DataType.BYTE, -100).sub(RuntimeValue(DataType.BYTE, 29)).integerValue())
+
+        assertEquals(127, RuntimeValue(DataType.BYTE, 126).inc().integerValue())
+        assertEquals(-128, RuntimeValue(DataType.BYTE, 127).inc().integerValue())
+        assertEquals(0, RuntimeValue(DataType.BYTE, 1).dec().integerValue())
+        assertEquals(-1, RuntimeValue(DataType.BYTE, 0).dec().integerValue())
+        assertEquals(-128, RuntimeValue(DataType.BYTE, -127).dec().integerValue())
+        assertEquals(127, RuntimeValue(DataType.BYTE, -128).dec().integerValue())
+
+        assertEquals(-1, RuntimeValue(DataType.BYTE, 0).inv().integerValue())
+        assertEquals(-103, RuntimeValue(DataType.BYTE, 0b01100110).inv().integerValue())
+        assertEquals(0, RuntimeValue(DataType.BYTE, 0).neg().integerValue())
+        assertEquals(-2, RuntimeValue(DataType.BYTE, 2).neg().integerValue())
+        assertEquals(1, RuntimeValue(DataType.BYTE, 0).not().integerValue())
+        assertEquals(0, RuntimeValue(DataType.BYTE, 1).not().integerValue())
+        assertEquals(0, RuntimeValue(DataType.BYTE, 111).not().integerValue())
+        assertEquals(0, RuntimeValue(DataType.BYTE, -33).not().integerValue())
+
+        assertEquals(100, RuntimeValue(DataType.BYTE, 10).mul(RuntimeValue(DataType.BYTE, 10)).integerValue())
+        assertEquals(-56, RuntimeValue(DataType.BYTE, 20).mul(RuntimeValue(DataType.BYTE, 10)).integerValue())
+
+        assertEquals(25, RuntimeValue(DataType.BYTE, 5).pow(RuntimeValue(DataType.BYTE, 2)).integerValue())
+        assertEquals(125, RuntimeValue(DataType.BYTE, 5).pow(RuntimeValue(DataType.BYTE, 3)).integerValue())
+        assertEquals(113, RuntimeValue(DataType.BYTE, 5).pow(RuntimeValue(DataType.BYTE, 4)).integerValue())
+
+        assertEquals(100, RuntimeValue(DataType.BYTE, 50).shl().integerValue())
+        assertEquals(-56, RuntimeValue(DataType.BYTE, 100).shl().integerValue())
+        assertEquals(-2, RuntimeValue(DataType.BYTE, -1).shl().integerValue())
+    }
+
+    @Test
+    fun arithmetictestWorrd() {
+        assertEquals(32767, RuntimeValue(DataType.WORD, 32700).add(RuntimeValue(DataType.WORD, 67)).integerValue())
+        assertEquals(-32768, RuntimeValue(DataType.WORD, 32700).add(RuntimeValue(DataType.WORD, 68)).integerValue())
+        assertEquals(-32767, RuntimeValue(DataType.WORD, 32700).add(RuntimeValue(DataType.WORD, 69)).integerValue())
+
+        assertEquals(1, RuntimeValue(DataType.WORD, 2).sub(RuntimeValue(DataType.WORD, 1)).integerValue())
+        assertEquals(0, RuntimeValue(DataType.WORD, 2).sub(RuntimeValue(DataType.WORD, 2)).integerValue())
+        assertEquals(-1, RuntimeValue(DataType.WORD, 2).sub(RuntimeValue(DataType.WORD, 3)).integerValue())
+        assertEquals(-32768, RuntimeValue(DataType.WORD, -32700).sub(RuntimeValue(DataType.WORD, 68)).integerValue())
+        assertEquals(32767, RuntimeValue(DataType.WORD, -32700).sub(RuntimeValue(DataType.WORD, 69)).integerValue())
+
+        assertEquals(32767, RuntimeValue(DataType.WORD, 32766).inc().integerValue())
+        assertEquals(-32768, RuntimeValue(DataType.WORD, 32767).inc().integerValue())
+        assertEquals(0, RuntimeValue(DataType.WORD, 1).dec().integerValue())
+        assertEquals(-1, RuntimeValue(DataType.WORD, 0).dec().integerValue())
+        assertEquals(-32768, RuntimeValue(DataType.WORD, -32767).dec().integerValue())
+        assertEquals(32767, RuntimeValue(DataType.WORD, -32768).dec().integerValue())
+
+        assertEquals(-1, RuntimeValue(DataType.WORD, 0).inv().integerValue())
+        assertEquals(-103, RuntimeValue(DataType.WORD, 0b01100110).inv().integerValue())
+        assertEquals(0, RuntimeValue(DataType.WORD, 0).neg().integerValue())
+        assertEquals(-2, RuntimeValue(DataType.WORD, 2).neg().integerValue())
+        assertEquals(1, RuntimeValue(DataType.WORD, 0).not().integerValue())
+        assertEquals(0, RuntimeValue(DataType.WORD, 1).not().integerValue())
+        assertEquals(0, RuntimeValue(DataType.WORD, 111).not().integerValue())
+        assertEquals(0, RuntimeValue(DataType.WORD, -33).not().integerValue())
+
+        assertEquals(10000, RuntimeValue(DataType.WORD, 100).mul(RuntimeValue(DataType.WORD, 100)).integerValue())
+        assertEquals(-25536, RuntimeValue(DataType.WORD, 200).mul(RuntimeValue(DataType.WORD, 200)).integerValue())
+
+        assertEquals(15625, RuntimeValue(DataType.WORD, 5).pow(RuntimeValue(DataType.WORD, 6)).integerValue())
+        assertEquals(-6487, RuntimeValue(DataType.WORD, 9).pow(RuntimeValue(DataType.WORD, 5)).integerValue())
+
+        assertEquals(18000, RuntimeValue(DataType.WORD, 9000).shl().integerValue())
+        assertEquals(-25536, RuntimeValue(DataType.WORD, 20000).shl().integerValue())
+        assertEquals(-2, RuntimeValue(DataType.WORD, -1).shl().integerValue())
+    }
 }

compiler/test/StackVMOpcodeTests.kt

@@ -4,15 +4,15 @@ import org.hamcrest.MatcherAssert.assertThat
 import org.hamcrest.Matchers.empty
 import org.junit.jupiter.api.Test
 import org.junit.jupiter.api.TestInstance
-import prog8.ast.ByteDatatypes
-import prog8.ast.DataType
-import prog8.ast.IterableDatatypes
-import prog8.ast.WordDatatypes
-import prog8.compiler.RuntimeValue
+import prog8.ast.base.ByteDatatypes
+import prog8.ast.base.DataType
+import prog8.ast.base.IterableDatatypes
+import prog8.ast.base.WordDatatypes
+import prog8.vm.RuntimeValue
 import prog8.compiler.HeapValues
 import prog8.compiler.intermediate.Instruction
 import prog8.compiler.intermediate.Opcode
-import prog8.stackvm.*
+import prog8.vm.stackvm.*
 import kotlin.test.*
 
 
@@ -60,7 +60,8 @@ class TestStackVmOpcodes {
                          labels: Map<String, Int>?=null,
                          mem: Map<Int, List<RuntimeValue>>?=null) : Program {
         val heap = HeapValues()
-        return Program("test", ins, vars ?: mapOf(), memoryPointers ?: mapOf(), labels ?: mapOf(), mem ?: mapOf(), heap)
+        return Program("test", ins, vars ?: mapOf(), memoryPointers ?: mapOf(), labels ?: mapOf(), mem
+                ?: mapOf(), heap)
     }
 
     @Test
@@ -412,10 +413,10 @@ class TestStackVmOpcodes {
         testUnaryOperator(RuntimeValue(DataType.UBYTE, 123), Opcode.INV_BYTE, RuntimeValue(DataType.UBYTE, 0x84))
         testUnaryOperator(RuntimeValue(DataType.UWORD, 4044), Opcode.INV_WORD, RuntimeValue(DataType.UWORD, 0xf033))
         assertFailsWith<VmExecutionException> {
-            testUnaryOperator(RuntimeValue(DataType.BYTE, 123), Opcode.INV_BYTE, RuntimeValue(DataType.BYTE, 0x84))
+            testUnaryOperator(RuntimeValue(DataType.BYTE, 123), Opcode.INV_BYTE, RuntimeValue(DataType.BYTE, -124))
         }
         assertFailsWith<VmExecutionException> {
-            testUnaryOperator(RuntimeValue(DataType.WORD, 4044), Opcode.INV_WORD, RuntimeValue(DataType.WORD, 0xf033))
+            testUnaryOperator(RuntimeValue(DataType.WORD, 4044), Opcode.INV_WORD, RuntimeValue(DataType.WORD, -4043))
         }
     }
 

compiler/test/UnitTests.kt

@@ -5,10 +5,16 @@ import org.hamcrest.Matchers.closeTo
 import org.hamcrest.Matchers.equalTo
 import org.junit.jupiter.api.Test
 import org.junit.jupiter.api.TestInstance
-import prog8.ast.*
-import prog8.compiler.RuntimeValue
+import prog8.ast.base.DataType
+import prog8.ast.base.Position
+import prog8.ast.expressions.LiteralValue
+import prog8.vm.RuntimeValue
 import prog8.compiler.*
-import prog8.compiler.target.c64.*
+import prog8.compiler.target.c64.MachineDefinition.Mflpt5
+import prog8.compiler.target.c64.MachineDefinition.FLOAT_MAX_NEGATIVE
+import prog8.compiler.target.c64.MachineDefinition.FLOAT_MAX_POSITIVE
+import prog8.compiler.target.c64.MachineDefinition.C64Zeropage
+import prog8.compiler.target.c64.Petscii
 import java.io.CharConversionException
 import kotlin.test.*
 
@@ -334,8 +340,8 @@ class TestPetscii {
 
     @Test
     fun testLiteralValueComparisons() {
-        val ten = LiteralValue(DataType.UWORD, wordvalue=10, position=Position("", 0 ,0 ,0))
-        val nine = LiteralValue(DataType.UBYTE, bytevalue=9, position=Position("", 0 ,0 ,0))
+        val ten = LiteralValue(DataType.UWORD, wordvalue = 10, position = Position("", 0, 0, 0))
+        val nine = LiteralValue(DataType.UBYTE, bytevalue = 9, position = Position("", 0, 0, 0))
         assertEquals(ten, ten)
         assertNotEquals(ten, nine)
         assertFalse(ten != ten)
@@ -351,8 +357,8 @@ class TestPetscii {
         assertTrue(ten <= ten)
         assertFalse(ten < ten)
 
-        val abc = LiteralValue(DataType.STR, strvalue = "abc", position=Position("", 0 ,0 ,0))
-        val abd = LiteralValue(DataType.STR, strvalue = "abd", position=Position("", 0 ,0 ,0))
+        val abc = LiteralValue(DataType.STR, strvalue = "abc", position = Position("", 0, 0, 0))
+        val abd = LiteralValue(DataType.STR, strvalue = "abd", position = Position("", 0, 0, 0))
         assertEquals(abc, abc)
         assertTrue(abc!=abd)
         assertFalse(abc!=abc)

docs/docs.iml

@@ -2,7 +2,9 @@
 <module type="PYTHON_MODULE" version="4">
   <component name="NewModuleRootManager" inherit-compiler-output="true">
     <exclude-output />
-    <content url="file://$MODULE_DIR$" />
+    <content url="file://$MODULE_DIR$">
+      <excludeFolder url="file://$MODULE_DIR$/build" />
+    </content>
     <orderEntry type="jdk" jdkName="Python 3.7 (py3)" jdkType="Python SDK" />
     <orderEntry type="sourceFolder" forTests="false" />
   </component>

docs/source/building.rst

@@ -2,29 +2,50 @@
 Writing and building a program
 ==============================
 
+.. _building_compiler:
+
 First, getting a working compiler
 ---------------------------------
 
-Before you can compile Prog8 programs, you'll have to build the compiler itself.
+Before you can compile Prog8 programs, you'll have to download or build the compiler itself.
 First make sure you have installed the :ref:`requirements`.
-Then you can choose a few ways to create the compiler:
+Then you can choose a few ways to get a compiler:
 
-**Using the shell script:**
+**Download a precompiled version from github:**
 
-#. run the "build_the_compiler.sh" shell script
-#. it will create a "prog8compiler.jar" file which contains everything.
-#. run the compiler with "java -jar prog8compiler.jar" to see how you can use it.
+#. download a recent "fat-jar" (called something like "prog8compiler-all.jar") from `the releases on Github <https://github.com/irmen/prog8/releases>`_
+#. run the compiler with "java -jar prog8compiler-all.jar" to see how you can use it.
 
-**using the Gradle build system:**
+**using the Gradle build system to make it yourself:**
 
-#. run the command "./gradlew installDist"
-#. it will create the commands and required libraries in the "./compiler/build/install/p8compile/" directory
-#. run the compiler with the "./compiler/build/install/p8compile/bin/p8compile" command to see how you can use it.
+The Gradle build system is used to build the compiler.
+The most interesting gradle commands to run are probably:
 
-**download a precompiled version from github:**
+    ``./gradlew check``
+        Builds the compiler code and runs all available checks and unit-tests.
+    ``./gradlew installDist``
+        Builds the compiler and installs it with scripts to run it, in the directory
+        ``./compiler/build/install/p8compile``
+    ``./gradlew installShadowDist``
+        Creates a 'fat-jar' that contains the compiler and all dependencies, in a single
+        executable .jar file, and includes few start scripts to run it.
+        The output can be found in ``.compiler/build/install/compiler-shadow/``
+    ``./gradlew shadowDistZip``
+        Creates a zipfile with the above in it, for easy distribution.
+        This file can be found in ``./compiler/build/distributions/``
+
+For normal use, the ``installDist`` target should suffice and ater succesful completion
+of that build task, you can start the compiler with:
+
+    ``./compiler/build/install/p8compile/bin/p8compile <options> <sourcefile>``
+
+(You should probably make an alias...)
+
+.. note::
+    Development and testing is done on Linux, but the compiler should run on most
+    operating systems. If you do have trouble building or running
+    the compiler on another operating system, please let me know!
 
-#. download a recent "prog8compiler.jar" from `the releases on Github <https://github.com/irmen/prog8/releases>`_
-#. run the compiler with "java -jar prog8compiler.jar" to see how you can use it.
 
 
 What is a Prog8 "Program" anyway?
@@ -53,14 +74,10 @@ The compiler will link everything together into one output program at the end.
 If you start the compiler without arguments, it will print a short usage text.
 For normal use the compiler is invoked with the command:
 
-    ``$ java -jar prog8compiler.jar sourcefile.p8``   if you're using the packaged release version, or
+    ``$ java -jar prog8compiler.jar sourcefile.p8``
 
-    ``$ ./p8compile.sh sourcefile.p8``   if you're running an unpackaged development version.
-
-If you tell it to save the intermediate code for the prog8 virtual machine, you can
-actually run this code with the command:
-
-    ``$ ./p8vm.sh sourcefile.vm.txt``
+    Other options are also available, see the introduction page about how
+    to build and run the compiler.
 
 
 By default, assembly code is generated and written to ``sourcefile.asm``.
@@ -130,3 +147,24 @@ or::
 
     $ ./p8compile.sh -emu examples/rasterbars.p8
 
+
+
+Virtual Machine
+---------------
+
+You may have noticed the ``-avm`` and ``-vm`` command line options for the compiler:
+
+-avm
+    Launches the "AST virtual machine" that directly executes the parsed program.
+    No compilation steps will be performed.
+    Allows for very fast testing and debugging before actually compiling programs
+    to machine code.
+    It simulates a bare minimum of features from the target platform, so most stuff
+    that calls ROM routines or writes into hardware registers won't work. But basic
+    system routines are emulated.
+
+-vm   <vm bytecode file>
+    Launches the "intermediate code VM"
+    it interprets the intermediate code that the compiler can write when using the ``-writevm``
+    option. This is the code that will be fed to the assembly code generator,
+    so you'll skip that last step.

docs/source/index.rst

@@ -136,34 +136,21 @@ For other platforms it is very easy to compile it yourself (make ; make install)
 
 A **Java runtime (jre or jdk), version 8 or newer**  is required to run the packaged compiler.
 If you're scared of Oracle's licensing terms, most Linux distributions ship OpenJDK instead
-and for Windows it's possible to get that as well: for instance,
-`Azul's Zulu <https://www.azul.com/downloads/zulu/>`_ is a certified OpenJDK
-implementation available for various platforms.
+and for Windows it's possible to get that as well. Check out `AdoptOpenJDK <https://adoptopenjdk.net/>`_ for
+downloads.
 
 Finally: a **C-64 emulator** (or a real C-64 ofcourse) to run the programs on. The compiler assumes the presence
 of the `Vice emulator <http://vice-emu.sourceforge.net/>`_.
 
-.. hint::
-    The compiler is almost completely written in Kotlin, but the packaged release version
-    only requires a Java runtime. All other needed libraries and files are embedded in the
-    packaged jar file.
+.. important::
+    **Building the compiler itself:** (*Only needed if you have not downloaded a pre-built 'fat-jar'*)
 
-.. note::
-    Building the compiler itself:
-
-    (re)building the compiler itself requires a Kotlin SDK version 1.3.
+    (re)building the compiler itself requires a recent Kotlin SDK.
     The compiler is developed using the `IntelliJ IDEA <https://www.jetbrains.com/idea/>`_
     IDE from Jetbrains, with the Kotlin plugin (free community edition of this IDE is available).
     But a bare Kotlin SDK installation should work just as well.
-    A shell script (``build_the_compiler.sh``) is provided to build and package the compiler from the command line.
-    You can also use the Gradle build system to build the compiler (it will take care of
-    downloading all required libraries for you) by typing ``gradle installDist`` for instance.
-    The output of this gradle build will appear in the "./compiler/build/install/p8compile/" directory.
 
-.. note::
-    Development and testing is done on Linux, but the compiler should run on most
-    operating systems. If you do have trouble building or running
-    the compiler on another operating system, please let me know!
+    Instructions on how to obtain a working compiler are in :ref:`building_compiler`.
 
 
 .. toctree::

docs/source/programming.rst

@@ -54,7 +54,7 @@ Code
 
 	- value assignment
 	- looping  (for, while, repeat, unconditional jumps)
-	- conditional execution (if - then - else, and conditional jumps)
+	- conditional execution (if - then - else, when, and conditional jumps)
 	- subroutine calls
 	- label definition
 
@@ -273,6 +273,39 @@ you have to use the ``str_s`` variants of the string type identifier.
     The same is true for arrays by the way.
 
 
+Structs
+^^^^^^^
+
+A struct is a group of one or more other variables.
+This allows you to reuse the definition and manipulate it as a whole.
+Individual variables in the struct are accessed as you would expect, just
+use a scoped name to refer to them: ``structvariable.membername``.
+
+Structs are a bit limited in Prog8: you can only use numerical variables
+as member of a struct, so strings and arrays and other structs can not be part of a struct.
+Also, it is not possible to use a struct itself inside an array.
+Structs are mainly syntactic sugar for repeated groups of vardecls
+and assignments that belong together. However, *they are layed out
+in sequence in memory as the members are defined* which may be useful
+if you want to pass pointers around
+
+To create a variable of a struct type you need to define the struct itself,
+and then create a variable with it::
+
+    struct Color {
+        ubyte red
+        ubyte green
+        ubyte blue
+    }
+
+    Color rgb = [255,122,0]
+    Color another               ; the init value is optional, like arrays
+
+    another = rgb           ; assign all of the values of rgb to another
+    another.blue = 255      ; set a single member
+
+
+
 Special types: const and memory-mapped
 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
@@ -364,6 +397,9 @@ You can also create loops by using the ``goto`` statement, but this should usual
 Conditional Execution
 ---------------------
 
+if statements
+^^^^^^^^^^^^^
+
 Conditional execution means that the flow of execution changes based on certiain conditions,
 rather than having fixed gotos or subroutine calls::
 
@@ -413,6 +449,27 @@ So ``if_cc goto target`` will directly translate into the single CPU instruction
     Maybe in the future this will be a separate nested scope, but for now, that is
     only possible when defining a subroutine.
 
+when statement ('jump table')
+^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+Instead of writing a bunch of sequential if-elseif statements, it is more readable to
+use a ``when`` statement. (It will also result in greatly improved assembly code generation)
+Use a ``when`` statement if you have a set of fixed choices that each should result in a certain
+action. It is possible to combine several choices to result in the same action::
+
+    when value {
+        4 -> c64scr.print("four")
+        5 -> c64scr.print("five")
+        10,20,30 -> {
+            c64scr.print("ten or twenty or thirty")
+        }
+        else -> c64scr.print("don't know")
+    }
+
+The when-*value* can be any expression but the choice values have to evaluate to
+compile-time constant integers (bytes or words). They also have to be the same
+datatype as the when-value, otherwise no efficient comparison can be done.
+
 
 Assignments
 -----------

docs/source/syntaxreference.rst

@@ -234,7 +234,7 @@ Various examples::
     byte[5]     values  = 255           ; initialize with five 255 bytes
 
     word  @zp   zpword = 9999           ; prioritize this when selecting vars for zeropage storage
-
+    Color       rgb    = [1,255,0]      ; a struct variable
 
 
 Data types
@@ -358,6 +358,22 @@ Syntax is familiar with brackets:  ``arrayvar[x]`` ::
     string[4]       ; the fifth character (=byte) in the string
 
 
+Struct
+^^^^^^
+
+A *struct* has to be defined to specify what its member variables are.
+There are one or more members::
+
+    struct  <structname> {
+        <vardecl>
+        [ <vardecl> ...]
+    }
+
+You can only use numerical variables as member of a struct, so strings and arrays
+and other structs can not be part of a struct. Vice versa, a struct can not occur in an array.
+
+After defining a struct you can use the name of the struct as a data type to declare variables with.
+
 
 Operators
 ---------
@@ -444,11 +460,12 @@ Normal subroutines can only return zero or one return values.
 However, the special ``asmsub`` routines (implemented in assembly code or referencing
 a routine in kernel ROM) can return more than one return values, for instance a status
 in the carry bit and a number in A, or a 16-bit value in A/Y registers.
-Only for these kind of subroutines it is possible to write a multi value assignment to
-store the resulting values::
-
-        var1, var2, var3 = asmsubroutine()
-
+It is not possible to process the results of a call to these kind of routines
+directly from the language, because only single value assignments are possible.
+You can still call the subroutine and not store the results.
+But if you want to do something with the values it returns, you'll have to write
+a small block of custom inline assembly that does the call and stores the values
+appropriately. Don't forget to save/restore the registers if required.
 
 
 Subroutine definitions
@@ -609,3 +626,29 @@ where <statements> can be just a single statement for instance just a ``goto``,
 The XX corresponds to one of the eigth branching instructions so the possibilities are:
 ``if_cs``, ``if_cc``, ``if_eq``, ``if_ne``, ``if_pl``, ``if_mi``, ``if_vs`` and ``if_vc``.
 It can also be one of the four aliases that are easier to read: ``if_z``, ``if_nz``, ``if_pos`` and ``if_neg``.
+
+when statement ('jump table')
+^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+The structure of a when statement is like this::
+
+    when <expression> {
+        <value(s)> -> <statement(s)>
+        <value(s)> -> <statement(s)>
+        ...
+        [ else -> <statement(s)> ]
+    }
+
+The when-*value* can be any expression but the choice values have to evaluate to
+compile-time constant integers (bytes or words).
+The else part is optional.
+Choices can result in a single statement or a block of  multiple statements in which
+case you have to use { } to enclose them::
+
+    when value {
+        4 -> c64scr.print("four")
+        5 -> c64scr.print("five")
+        10,20,30 -> {
+            c64scr.print("ten or twenty or thirty")
+        }
+        else -> c64scr.print("don't know")
+    }

docs/source/todo.rst

@@ -52,25 +52,6 @@ Allocate a fixed word in ZP that is the TOS so we can operate on TOS directly
 without having to to index into the stack?
 
 
-structs?
-^^^^^^^^
-
-A user defined struct type would be nice to group a bunch
-of values together (and use it multiple times). Something like::
-
-    struct Point {
-        ubyte   color
-        word[] vec = [0,0,0]
-    }
-
-    Point p1
-    Point p2
-    Point p3
-
-    p1.color = 3
-    p1.vec[2] = 2
-
-
 Misc
 ^^^^
 

examples/mandelbrot.p8

@@ -39,9 +39,9 @@
             }
         }
 
-        float duration = floor(((c64.TIME_LO as float)
+        float duration = ((c64.TIME_LO as float)
                                 + 256.0*(c64.TIME_MID as float)
-                                + 65536.0*(c64.TIME_HI as float))/60.0)
+                                + 65536.0*(c64.TIME_HI as float))/60.0
         c64scr.plot(0, 21)
         c64scr.print("finished in ")
         c64flt.print_f(duration)

examples/numbergame.p8

@@ -32,7 +32,8 @@
             ubyte guess = lsb(c64utils.str2uword(input))
 
             if guess==secretnumber {
-                return ending(true)
+                ending(true)
+                return
             } else {
                 c64scr.print("\n\nThat is too ")
                 if guess<secretnumber
@@ -42,7 +43,8 @@
             }
         }
 
-        return ending(false)
+        ending(false)
+        return
 
 
         sub ending(ubyte success) {

examples/primes.p8

@@ -43,8 +43,6 @@
         while multiple < len(sieve) {
             sieve[lsb(multiple)] = true
             multiple += candidate_prime
-            ; c64scr.print_uw(multiple)       ; TODO
-            ; c4.CHROUT('\n')        ; TODO
         }
         return candidate_prime
     }

examples/rasterbars.p8

@@ -5,10 +5,11 @@
 ~ main {
 
     sub start() {
-        c64.SCROLY &= %11101111           ; blank the screen
-        c64utils.set_rasterirq_excl(40)
+        c64.SCROLY &= %11101111             ; blank the screen
+        c64utils.set_rasterirq_excl(40)     ; register exclusive raster irq handler
 
         while(true) {
+            ; enjoy the moving bars :)
         }
 
     }
@@ -20,22 +21,20 @@
     const ubyte barheight = 4
     ubyte[] colors = [6,2,4,5,15,7,1,13,3,12,8,11,9]
     ubyte color = 0
-    ubyte ypos = 0
+    ubyte yanim = 0
 
     sub irq() {
-        Y++     ; slight timing delay to avoid rasterline transition issues
-        ubyte rasterpos = c64.RASTER
-
         if color!=len(colors) {
             c64.EXTCOL = colors[color]
+            c64.RASTER += barheight         ; next raster Irq for next color
             color++
-            c64.RASTER = rasterpos+barheight
         }
         else {
-            ypos += 2
             c64.EXTCOL = 0
             color = 0
-            c64.RASTER = sin8u(ypos)/2+40
+            yanim += 2
+            c64.RASTER = sin8u(yanim)/2+30  ; new start of raster Irq
         }
+        c64.SCROLY &= $7f    ; set high bit of the raster pos to zero
     }
 }

examples/swirl.p8

@@ -5,20 +5,24 @@
     const uword width = 40
     const uword height = 25
 
-    sub start()  {
-
+    struct Ball {
         uword anglex
         uword angley
         ubyte color
+    }
+
+    sub start()  {
+
+        Ball ball
 
         while true {
-            ubyte x = msb(sin8u(msb(anglex)) as uword * width)
-            ubyte y = msb(cos8u(msb(angley)) as uword * height)
-            c64scr.setcc(x, y, 81, color)
+            ubyte x = msb(sin8u(msb(ball.anglex)) as uword * width)
+            ubyte y = msb(cos8u(msb(ball.angley)) as uword * height)
+            c64scr.setcc(x, y, 81, ball.color)
 
-            anglex+=800
-            angley+=947
-            color++
+            ball.anglex+=800
+            ball.angley+=947
+            ball.color++
         }
     }
 }

examples/tehtriz.p8

@@ -75,105 +75,112 @@ waitkey:
 
     }
 
+    sub move_left() {
+        drawBlock(xpos, ypos, 32)
+        if blocklogic.noCollision(xpos-1, ypos) {
+            xpos--
+        }
+        drawBlock(xpos, ypos, 160)
+    }
+
+    sub move_right() {
+        drawBlock(xpos, ypos, 32)
+        if blocklogic.noCollision(xpos+1, ypos) {
+            xpos++
+        }
+        drawBlock(xpos, ypos, 160)
+    }
+
+    sub move_down_faster() {
+        drawBlock(xpos, ypos, 32)
+        if blocklogic.noCollision(xpos, ypos+1) {
+            ypos++
+        }
+        drawBlock(xpos, ypos, 160)
+    }
+
+    sub drop_down_immediately() {
+        drawBlock(xpos, ypos, 32)
+        ubyte dropypos
+        for dropypos in ypos+1 to boardOffsetY+boardHeight-1 {
+            if not blocklogic.noCollision(xpos, dropypos) {
+                dropypos--   ; the furthest down that still fits
+                break
+            }
+        }
+        if dropypos>ypos {
+            ypos = dropypos
+            sound.blockdrop()
+            drawBlock(xpos, ypos, 160)
+            checkForLines()
+            spawnNextBlock()
+            score++
+            drawScore()
+        }
+    }
+
     sub keypress(ubyte key) {
-        if key==157 or key==',' {
-            ; move left
-            drawBlock(xpos, ypos, 32)
-            if blocklogic.noCollision(xpos-1, ypos) {
-                xpos--
-            }
-            drawBlock(xpos, ypos, 160)
-        }
-        else if key==29 or key=='/' {
-            ; move right
-            drawBlock(xpos, ypos, 32)
-            if blocklogic.noCollision(xpos+1, ypos) {
-                xpos++
-            }
-            drawBlock(xpos, ypos, 160)
-        }
-        else if key==17 or key=='.' {
-            ; move down faster
-            drawBlock(xpos, ypos, 32)
-            if blocklogic.noCollision(xpos, ypos+1) {
-                ypos++
-            }
-            drawBlock(xpos, ypos, 160)
-        }
-        else if key==145 or key==' ' {
-            ; drop down immediately
-            drawBlock(xpos, ypos, 32)
-            ubyte dropypos
-            for dropypos in ypos+1 to boardOffsetY+boardHeight-1 {
-                if not blocklogic.noCollision(xpos, dropypos) {
-                    dropypos--   ; the furthest down that still fits
-                    break
+        when key {
+            157, ',' -> move_left()
+            29, '/'  -> move_right()
+            17, '.'  -> move_down_faster()
+            145, ' ' -> drop_down_immediately()
+            'z' -> {
+                ; no joystick equivalent (there is only 1 fire button)
+                ; rotate counter clockwise
+                drawBlock(xpos, ypos, 32)
+                if blocklogic.canRotateCCW(xpos, ypos) {
+                    blocklogic.rotateCCW()
+                    sound.blockrotate()
+                }
+                else if blocklogic.canRotateCCW(xpos-1, ypos) {
+                    xpos--
+                    blocklogic.rotateCCW()
+                    sound.blockrotate()
+                }
+                else if blocklogic.canRotateCCW(xpos+1, ypos) {
+                    xpos++
+                    blocklogic.rotateCCW()
+                    sound.blockrotate()
                 }
-            }
-            if dropypos>ypos {
-                ypos = dropypos
-                sound.blockdrop()
                 drawBlock(xpos, ypos, 160)
-                checkForLines()
-                spawnNextBlock()
-                score++
-                drawScore()
             }
-        }
-        else if key=='z' {      ; no joystick equivalent (there is only 1 fire button)
-            ; rotate counter clockwise
-            drawBlock(xpos, ypos, 32)
-            if blocklogic.canRotateCCW(xpos, ypos) {
-                blocklogic.rotateCCW()
-                sound.blockrotate()
-            }
-            else if blocklogic.canRotateCCW(xpos-1, ypos) {
-                xpos--
-                blocklogic.rotateCCW()
-                sound.blockrotate()
-            }
-            else if blocklogic.canRotateCCW(xpos+1, ypos) {
-                xpos++
-                blocklogic.rotateCCW()
-                sound.blockrotate()
-            }
-            drawBlock(xpos, ypos, 160)
-        }
-        else if key=='x' {
-            ; rotate clockwise
-            drawBlock(xpos, ypos, 32)
-            if blocklogic.canRotateCW(xpos, ypos) {
-                blocklogic.rotateCW()
-                sound.blockrotate()
-            }
-            else if blocklogic.canRotateCW(xpos-1, ypos) {
-                xpos--
-                blocklogic.rotateCW()
-                sound.blockrotate()
-            }
-            else if blocklogic.canRotateCW(xpos+1, ypos) {
-                xpos++
-                blocklogic.rotateCW()
-                sound.blockrotate()
-            }
-            drawBlock(xpos, ypos, 160)
-        }
-        else if key=='c' {
-            ; hold
-            if holdingAllowed {
-                sound.swapping()
-                if holding<7 {
-                    drawBlock(xpos, ypos, 32)
-                    ubyte newholding = blocklogic.currentBlockNum
-                    swapBlock(holding)
-                    holding = newholding
-                    holdingAllowed = false
-                } else {
-                    holding = blocklogic.currentBlockNum
-                    drawBlock(xpos, ypos, 32)
-                    spawnNextBlock()
+            'x' -> {
+                ; rotate clockwise
+                drawBlock(xpos, ypos, 32)
+                if blocklogic.canRotateCW(xpos, ypos) {
+                    blocklogic.rotateCW()
+                    sound.blockrotate()
+                }
+                else if blocklogic.canRotateCW(xpos-1, ypos) {
+                    xpos--
+                    blocklogic.rotateCW()
+                    sound.blockrotate()
+                }
+                else if blocklogic.canRotateCW(xpos+1, ypos) {
+                    xpos++
+                    blocklogic.rotateCW()
+                    sound.blockrotate()
+                }
+                drawBlock(xpos, ypos, 160)
+            }
+            'c' -> {
+                ; hold
+                if holdingAllowed {
+                    sound.swapping()
+                    if holding<7 {
+                        drawBlock(xpos, ypos, 32)
+                        ubyte newholding = blocklogic.currentBlockNum
+                        swapBlock(holding)
+                        holding = newholding
+                        holdingAllowed = false
+                    } else {
+                        holding = blocklogic.currentBlockNum
+                        drawBlock(xpos, ypos, 32)
+                        spawnNextBlock()
+                    }
+                    drawHoldBlock()
                 }
-                drawHoldBlock()
             }
         }
     }

examples/test.p8

@@ -1,57 +1,44 @@
 %import c64utils
 %zeropage basicsafe
 
-
 ~ main {
 
+    struct Color {
+        uword red
+        ubyte green
+        ubyte blue
+    }
+
+    str naam = "irmen"
+    word[] array = [1,2,3,4]
+    uword uw = $ab12
+    Color rgb = [255,128,0]
+    Color rgb2 = [111,222,33]
+
+    ubyte @zp zpvar=99
+
     sub start() {
 
-        ubyte x = 99
+        uword fake_address
+
+        fake_address = &naam
+        c64scr.print_uwhex(1, fake_address)
+        c64scr.print(", ")
+
+        fake_address = &array
+        c64scr.print_uwhex(1, fake_address)
+        c64scr.print(", ")
+
+        fake_address = &rgb
+        c64scr.print_uwhex(1, fake_address)
+        c64scr.print("\n")
+
+        ; @todo only works once reference types are actually references:
+        ;str name2 = naam              ; @todo name2 points to same str as naam
+        ;str name2 = fake_address      ; @todo fake_address hopefully points to a str
+        ;Color colz = fake_address     ; @todo fake_address hopefully points to a Color
 
         return
-
-        startqqq:
-
-        sub startzzz() {
-            if_cc goto startqqq
-            c64.EXTCOL++
-        }
     }
 
-
-;        for ubyte y in 0 to 3 {
-;            for ubyte x in 0 to 10 {
-;                ubyte product = x*y
-;                c64scr.setcc(x, y, 160, product)
-;            }
-;        }
-;        c64.CHROUT('\n')
-;        c64.CHROUT('\n')
-;
-;        for ubyte y in 12 to 15 {
-;            for ubyte x in 0 to 10 {
-;                ubyte sumv = x+y
-;                c64scr.setcc(x, y, 160, sumv)
-;            }
-;        }
-
-        ;ubyte bb = len(xcoor)
-
-        ; storage for rotated coordinates
-;        ubyte[len(xcoor)] xx = 2
-;        float[len(xcoor)] rotatedx=0.0
-;
-;        ubyte[4] x = 23
-;        float[4] yy = 4.4
-
-;        c64flt.print_f(xcoor[1])
-;        c64.CHROUT(',')
-;        c64flt.print_f(xcoor[2])
-;        c64.CHROUT('\n')
-;        swap(xcoor[1], xcoor[2])
-;        c64flt.print_f(xcoor[1])
-;        c64.CHROUT(',')
-;        c64flt.print_f(xcoor[2])
-;        c64.CHROUT('\n')
-
 }

gradle.properties

@@ -1,2 +1,7 @@
 org.gradle.caching=true
+org.gradle.console=rich
+org.gradle.parallel=true
+org.gradle.jvmargs=-Xmx2048M
+org.gradle.daemon=true
 
+kotlinVersion=1.3.41

old_scripts/build_the_compiler.sh

@@ -1,33 +0,0 @@
-#!/usr/bin/env bash
-
-# compile using regular Kotlin sdk command line tool
-
-echo "Compiling the parser..."
-java -jar ./parser/antlr/lib/antlr-4.7.2-complete.jar -o ./parser/src/prog8/parser -Xexact-output-dir -no-listener -no-visitor ./parser/antlr/prog8.g4
-
-
-PARSER_CLASSES=./out/production/parser
-COMPILER_JAR=prog8compiler.jar
-ANTLR_RUNTIME=./parser/antlr/lib/antlr-runtime-4.7.2.jar
-
-mkdir -p ${PARSER_CLASSES}
-javac  -d ${PARSER_CLASSES} -cp ${ANTLR_RUNTIME} ./parser/src/prog8/parser/prog8Lexer.java  ./parser/src/prog8/parser/prog8Parser.java
-
-echo "Compiling the compiler itself..."
-JAVA_OPTS="-Xmx3G -Xms300M" kotlinc -verbose -include-runtime -d ${COMPILER_JAR} -jvm-target 1.8 -cp ${ANTLR_RUNTIME}:${PARSER_CLASSES} ./compiler/src/prog8
-
-echo "Finalizing the compiler jar file..."
-# add the antlr parser classes
-jar ufe ${COMPILER_JAR} prog8.CompilerMainKt -C ${PARSER_CLASSES} prog8
-
-# add the resources
-jar uf ${COMPILER_JAR} -C ./compiler/res .
-
-# add the antlr runtime classes
-rm -rf antlr_runtime_extraction
-mkdir antlr_runtime_extraction
-(cd antlr_runtime_extraction; jar xf ../${ANTLR_RUNTIME})
-jar uf ${COMPILER_JAR} -C antlr_runtime_extraction org
-rm -rf antlr_runtime_extraction
-
-echo "Done!"

p8compile.cmd

@@ -1,9 +0,0 @@
-@echo off
-
-set PROG8CLASSPATH=./compiler/build/classes/kotlin/main;./compiler/build/resources/main;./parser/build/classes/java/main
-set KOTLINPATH=%USERPROFILE%/.IdeaIC2019.1/config/plugins/Kotlin
-set LIBJARS=%KOTLINPATH%/lib/kotlin-stdlib.jar;%KOTLINPATH%/lib/kotlin-reflect.jar;./parser/antlr/lib/antlr-runtime-4.7.2.jar
-
-java -cp %PROG8CLASSPATH%;%LIBJARS% prog8.CompilerMainKt %*
-
-@REM   if you have created a .jar file using the 'create_compiler_jar' script, you can simply do:  java -jar prog8compiler.jar

p8compile.sh

@@ -1,9 +0,0 @@
-#!/usr/bin/env sh
-
-PROG8CLASSPATH=./compiler/build/classes/kotlin/main:./compiler/build/resources/main:./parser/build/classes/java/main
-KOTLINPATH=${HOME}/.IntelliJIdea2019.1/config/plugins/Kotlin
-LIBJARS=${KOTLINPATH}/lib/kotlin-stdlib.jar:${KOTLINPATH}/lib/kotlin-reflect.jar:./parser/antlr/lib/antlr-runtime-4.7.2.jar
-
-java -cp ${PROG8CLASSPATH}:${LIBJARS} prog8.CompilerMainKt $*
-
-# if you have created a .jar file using the 'create_compiler_jar' script, you can simply do:  java -jar prog8compiler.jar

p8vm.cmd

@@ -1,9 +0,0 @@
-@echo off
-
-set PROG8CLASSPATH=./compiler/build/classes/kotlin/main;./compiler/build/resources/main
-set KOTLINPATH=%USERPROFILE%/.IdeaIC2019.1/config/plugins/Kotlin
-set LIBJARS=%KOTLINPATH%/lib/kotlin-stdlib.jar;%KOTLINPATH%/lib/kotlin-reflect.jar
-
-java -cp %PROG8CLASSPATH%;%LIBJARS% prog8.StackVmMainKt %*
-
-@REM  if you have created a .jar file using the 'create_compiler_jar' script, you can simply do:  java -jar prog8compiler.jar -vm

p8vm.sh

@@ -1,9 +0,0 @@
-#!/usr/bin/env sh
-
-PROG8CLASSPATH=./compiler/build/classes/kotlin/main:./compiler/build/resources/main
-KOTLINPATH=${HOME}/.IntelliJIdea2019.1/config/plugins/Kotlin
-LIBJARS=${KOTLINPATH}/lib/kotlin-stdlib.jar:${KOTLINPATH}/lib/kotlin-reflect.jar
-
-java -cp ${PROG8CLASSPATH}:${LIBJARS} prog8.StackVmMainKt $*
-
-#  if you have created a .jar file using the 'create_compiler_jar' script, you can simply do:  java -jar prog8compiler.jar -vm

parser/antlr/prog8.g4

@@ -76,6 +76,7 @@ statement :
 	| vardecl
 	| constdecl
 	| memoryvardecl
+	| structdecl
 	| assignment
 	| augassignment
 	| unconditionaljump
@@ -90,6 +91,7 @@ statement :
 	| forloop
 	| whileloop
 	| repeatloop
+	| whenstmt
 	| breakstmt
 	| continuestmt
 	| labeldef
@@ -108,7 +110,7 @@ directive :
 
 directivearg : stringliteral | identifier | integerliteral ;
 
-vardecl: datatype ZEROPAGE? (arrayindex | ARRAYSIG) ? identifier ;
+vardecl: (datatype | structname=identifier) ZEROPAGE? (arrayindex | ARRAYSIG) ? varname=identifier ;
 
 varinitializer : vardecl '=' expression ;
 
@@ -116,13 +118,13 @@ constdecl: 'const' varinitializer ;
 
 memoryvardecl: ADDRESS_OF varinitializer;
 
+structdecl: 'struct' identifier '{' EOL vardecl ( EOL vardecl)* EOL? '}' EOL;
+
 datatype:  'ubyte' | 'byte' | 'uword' | 'word' | 'float' | 'str' | 'str_s' ;
 
 arrayindex:  '[' expression ']' ;
 
-assignment :  assign_targets '=' expression ;
-
-assign_targets : assign_target (',' assign_target)* ;
+assignment :  assign_target '=' expression ;
 
 augassignment :
 	assign_target operator=('+=' | '-=' | '/=' | '*=' | '**=' | '&=' | '|=' | '^=' | '%=' | '<<=' | '>>=' ) expression
@@ -184,7 +186,7 @@ expression_list :
 	expression (',' EOL? expression)*           // you can split the expression list over several lines
 	;
 
-returnstmt : 'return' expression_list? ;
+returnstmt : 'return' expression? ;
 
 breakstmt : 'break';
 
@@ -196,7 +198,7 @@ scoped_identifier :  NAME ('.' NAME)* ;
 
 register :  'A' | 'X' | 'Y' ;
 
-registerorpair :  'A' | 'X' | 'Y' | 'AX' | 'AY' | 'XY' ;          // only used in subroutine params and returnvalues
+registerorpair :  'A' | 'X' | 'Y' | 'AX' | 'AY' | 'XY' ;        // pairs can only be used in subroutine params and returnvalues
 
 statusregister :  'Pc' | 'Pz' | 'Pn' | 'Pv' ;
 
@@ -244,19 +246,21 @@ sub_params :  vardecl (',' EOL? vardecl)* ;
 sub_returns :  datatype (',' EOL? datatype)*  ;
 
 asmsubroutine :
-    'asmsub' identifier '(' asmsub_params? ')'
-    '->' 'clobbers' '(' clobber? ')' '->' '(' asmsub_returns? ')' (asmsub_address  | statement_block )
+    'asmsub' identifier '(' asmsub_params? ')'  EOL?
+    asmsub_clobbers? asmsub_returns?  (asmsub_address  | statement_block )
     ;
 
 asmsub_address :  '=' address=integerliteral  ;
 
 asmsub_params :  asmsub_param (',' EOL? asmsub_param)* ;
 
-asmsub_param :  vardecl '@' (registerorpair | statusregister | stack='stack');
+asmsub_param :  vardecl '@' (registerorpair | statusregister | stack='stack') ;
+
+asmsub_clobbers : 'clobbers' '(' clobber? ')' ;
 
 clobber :  register (',' register)* ;
 
-asmsub_returns :  asmsub_return (',' EOL? asmsub_return)* ;
+asmsub_returns :  '->' asmsub_return (',' EOL? asmsub_return)* ;
 
 asmsub_return :  datatype '@' (registerorpair | statusregister | stack='stack') ;
 
@@ -276,3 +280,8 @@ forloop :  'for' datatype? ZEROPAGE? (register | identifier) 'in' expression EOL
 whileloop:  'while' expression EOL? (statement | statement_block) ;
 
 repeatloop:  'repeat' (statement | statement_block) EOL? 'until' expression ;
+
+whenstmt: 'when' expression '{' EOL (when_choice | EOL) * '}' EOL? ;
+
+when_choice:  (expression_list | 'else' ) '->' (statement | statement_block ) ;
+

parser/build.gradle

@@ -7,12 +7,23 @@ repositories {
     mavenCentral()
 }
 
-dependencies {
-    antlr('org.antlr:antlr4:4.7.2') {
-        exclude group: 'com.ibm.icu', module: 'icu4j'
+configurations {
+    // strange antlr plugin issue, see https://github.com/gradle/gradle/issues/820
+    // this avoids linking in the complete antlr binary jar
+    compile {
+        extendsFrom = extendsFrom.findAll { it != configurations.antlr }
     }
 }
 
+dependencies {
+    antlr 'org.antlr:antlr4:4.7.2'
+    compile 'org.antlr:antlr4-runtime:4.7.2'
+
+//    antlr('org.antlr:antlr4:4.7.2') {
+//        exclude group: 'com.ibm.icu', module: 'icu4j'
+//    }
+}
+
 compileJava {
     dependsOn tasks.withType(AntlrTask)
 }

parser/src/prog8/parser/prog8Lexer.java

@@ -1,508 +0,0 @@
-// Generated from prog8.g4 by ANTLR 4.7.2
-
-package prog8.parser;
-
-import org.antlr.v4.runtime.Lexer;
-import org.antlr.v4.runtime.CharStream;
-import org.antlr.v4.runtime.Token;
-import org.antlr.v4.runtime.TokenStream;
-import org.antlr.v4.runtime.*;
-import org.antlr.v4.runtime.atn.*;
-import org.antlr.v4.runtime.dfa.DFA;
-import org.antlr.v4.runtime.misc.*;
-
-@SuppressWarnings({"all", "warnings", "unchecked", "unused", "cast"})
-public class prog8Lexer extends Lexer {
-	static { RuntimeMetaData.checkVersion("4.7.2", RuntimeMetaData.VERSION); }
-
-	protected static final DFA[] _decisionToDFA;
-	protected static final PredictionContextCache _sharedContextCache =
-		new PredictionContextCache();
-	public static final int
-		T__0=1, T__1=2, T__2=3, T__3=4, T__4=5, T__5=6, T__6=7, T__7=8, T__8=9, 
-		T__9=10, T__10=11, T__11=12, T__12=13, T__13=14, T__14=15, T__15=16, T__16=17, 
-		T__17=18, T__18=19, T__19=20, T__20=21, T__21=22, T__22=23, T__23=24, 
-		T__24=25, T__25=26, T__26=27, T__27=28, T__28=29, T__29=30, T__30=31, 
-		T__31=32, T__32=33, T__33=34, T__34=35, T__35=36, T__36=37, T__37=38, 
-		T__38=39, T__39=40, T__40=41, T__41=42, T__42=43, T__43=44, T__44=45, 
-		T__45=46, T__46=47, T__47=48, T__48=49, T__49=50, T__50=51, T__51=52, 
-		T__52=53, T__53=54, T__54=55, T__55=56, T__56=57, T__57=58, T__58=59, 
-		T__59=60, T__60=61, T__61=62, T__62=63, T__63=64, T__64=65, T__65=66, 
-		T__66=67, T__67=68, T__68=69, T__69=70, T__70=71, T__71=72, T__72=73, 
-		T__73=74, T__74=75, T__75=76, T__76=77, T__77=78, T__78=79, T__79=80, 
-		T__80=81, T__81=82, T__82=83, T__83=84, T__84=85, T__85=86, T__86=87, 
-		T__87=88, T__88=89, T__89=90, T__90=91, T__91=92, T__92=93, T__93=94, 
-		T__94=95, T__95=96, T__96=97, T__97=98, T__98=99, T__99=100, T__100=101, 
-		T__101=102, T__102=103, T__103=104, T__104=105, T__105=106, T__106=107, 
-		T__107=108, LINECOMMENT=109, COMMENT=110, WS=111, EOL=112, NAME=113, DEC_INTEGER=114, 
-		HEX_INTEGER=115, BIN_INTEGER=116, ADDRESS_OF=117, FLOAT_NUMBER=118, STRING=119, 
-		INLINEASMBLOCK=120, SINGLECHAR=121, ZEROPAGE=122, ARRAYSIG=123;
-	public static String[] channelNames = {
-		"DEFAULT_TOKEN_CHANNEL", "HIDDEN"
-	};
-
-	public static String[] modeNames = {
-		"DEFAULT_MODE"
-	};
-
-	private static String[] makeRuleNames() {
-		return new String[] {
-			"T__0", "T__1", "T__2", "T__3", "T__4", "T__5", "T__6", "T__7", "T__8", 
-			"T__9", "T__10", "T__11", "T__12", "T__13", "T__14", "T__15", "T__16", 
-			"T__17", "T__18", "T__19", "T__20", "T__21", "T__22", "T__23", "T__24", 
-			"T__25", "T__26", "T__27", "T__28", "T__29", "T__30", "T__31", "T__32", 
-			"T__33", "T__34", "T__35", "T__36", "T__37", "T__38", "T__39", "T__40", 
-			"T__41", "T__42", "T__43", "T__44", "T__45", "T__46", "T__47", "T__48", 
-			"T__49", "T__50", "T__51", "T__52", "T__53", "T__54", "T__55", "T__56", 
-			"T__57", "T__58", "T__59", "T__60", "T__61", "T__62", "T__63", "T__64", 
-			"T__65", "T__66", "T__67", "T__68", "T__69", "T__70", "T__71", "T__72", 
-			"T__73", "T__74", "T__75", "T__76", "T__77", "T__78", "T__79", "T__80", 
-			"T__81", "T__82", "T__83", "T__84", "T__85", "T__86", "T__87", "T__88", 
-			"T__89", "T__90", "T__91", "T__92", "T__93", "T__94", "T__95", "T__96", 
-			"T__97", "T__98", "T__99", "T__100", "T__101", "T__102", "T__103", "T__104", 
-			"T__105", "T__106", "T__107", "LINECOMMENT", "COMMENT", "WS", "EOL", 
-			"NAME", "DEC_INTEGER", "HEX_INTEGER", "BIN_INTEGER", "ADDRESS_OF", "FLOAT_NUMBER", 
-			"FNUMBER", "STRING_ESCAPE_SEQ", "STRING", "INLINEASMBLOCK", "SINGLECHAR", 
-			"ZEROPAGE", "ARRAYSIG"
-		};
-	}
-	public static final String[] ruleNames = makeRuleNames();
-
-	private static String[] makeLiteralNames() {
-		return new String[] {
-			null, "'~'", "':'", "'goto'", "'%output'", "'%launcher'", "'%zeropage'", 
-			"'%zpreserved'", "'%address'", "'%import'", "'%breakpoint'", "'%asminclude'", 
-			"'%asmbinary'", "'%option'", "','", "'='", "'const'", "'ubyte'", "'byte'", 
-			"'uword'", "'word'", "'float'", "'str'", "'str_s'", "'['", "']'", "'+='", 
-			"'-='", "'/='", "'*='", "'**='", "'&='", "'|='", "'^='", "'%='", "'<<='", 
-			"'>>='", "'++'", "'--'", "'+'", "'-'", "'**'", "'*'", "'/'", "'%'", "'<<'", 
-			"'>>'", "'<'", "'>'", "'<='", "'>='", "'=='", "'!='", "'^'", "'|'", "'to'", 
-			"'step'", "'and'", "'or'", "'xor'", "'not'", "'('", "')'", "'as'", "'@'", 
-			"'return'", "'break'", "'continue'", "'.'", "'A'", "'X'", "'Y'", "'AX'", 
-			"'AY'", "'XY'", "'Pc'", "'Pz'", "'Pn'", "'Pv'", "'.w'", "'true'", "'false'", 
-			"'%asm'", "'sub'", "'->'", "'{'", "'}'", "'asmsub'", "'clobbers'", "'stack'", 
-			"'if'", "'else'", "'if_cs'", "'if_cc'", "'if_eq'", "'if_z'", "'if_ne'", 
-			"'if_nz'", "'if_pl'", "'if_pos'", "'if_mi'", "'if_neg'", "'if_vs'", "'if_vc'", 
-			"'for'", "'in'", "'while'", "'repeat'", "'until'", null, null, null, 
-			null, null, null, null, null, "'&'", null, null, null, null, "'@zp'", 
-			"'[]'"
-		};
-	}
-	private static final String[] _LITERAL_NAMES = makeLiteralNames();
-	private static String[] makeSymbolicNames() {
-		return new String[] {
-			null, null, null, null, null, null, null, null, null, null, null, null, 
-			null, null, null, null, null, null, null, null, null, null, null, null, 
-			null, null, null, null, null, null, null, null, null, null, null, null, 
-			null, null, null, null, null, null, null, null, null, null, null, null, 
-			null, null, null, null, null, null, null, null, null, null, null, null, 
-			null, null, null, null, null, null, null, null, null, null, null, null, 
-			null, null, null, null, null, null, null, null, null, null, null, null, 
-			null, null, null, null, null, null, null, null, null, null, null, null, 
-			null, null, null, null, null, null, null, null, null, null, null, null, 
-			null, "LINECOMMENT", "COMMENT", "WS", "EOL", "NAME", "DEC_INTEGER", "HEX_INTEGER", 
-			"BIN_INTEGER", "ADDRESS_OF", "FLOAT_NUMBER", "STRING", "INLINEASMBLOCK", 
-			"SINGLECHAR", "ZEROPAGE", "ARRAYSIG"
-		};
-	}
-	private static final String[] _SYMBOLIC_NAMES = makeSymbolicNames();
-	public static final Vocabulary VOCABULARY = new VocabularyImpl(_LITERAL_NAMES, _SYMBOLIC_NAMES);
-
-	/**
-	 * @deprecated Use {@link #VOCABULARY} instead.
-	 */
-	@Deprecated
-	public static final String[] tokenNames;
-	static {
-		tokenNames = new String[_SYMBOLIC_NAMES.length];
-		for (int i = 0; i < tokenNames.length; i++) {
-			tokenNames[i] = VOCABULARY.getLiteralName(i);
-			if (tokenNames[i] == null) {
-				tokenNames[i] = VOCABULARY.getSymbolicName(i);
-			}
-
-			if (tokenNames[i] == null) {
-				tokenNames[i] = "<INVALID>";
-			}
-		}
-	}
-
-	@Override
-	@Deprecated
-	public String[] getTokenNames() {
-		return tokenNames;
-	}
-
-	@Override
-
-	public Vocabulary getVocabulary() {
-		return VOCABULARY;
-	}
-
-
-	public prog8Lexer(CharStream input) {
-		super(input);
-		_interp = new LexerATNSimulator(this,_ATN,_decisionToDFA,_sharedContextCache);
-	}
-
-	@Override
-	public String getGrammarFileName() { return "prog8.g4"; }
-
-	@Override
-	public String[] getRuleNames() { return ruleNames; }
-
-	@Override
-	public String getSerializedATN() { return _serializedATN; }
-
-	@Override
-	public String[] getChannelNames() { return channelNames; }
-
-	@Override
-	public String[] getModeNames() { return modeNames; }
-
-	@Override
-	public ATN getATN() { return _ATN; }
-
-	@Override
-	public void action(RuleContext _localctx, int ruleIndex, int actionIndex) {
-		switch (ruleIndex) {
-		case 120:
-			STRING_action((RuleContext)_localctx, actionIndex);
-			break;
-		case 121:
-			INLINEASMBLOCK_action((RuleContext)_localctx, actionIndex);
-			break;
-		case 122:
-			SINGLECHAR_action((RuleContext)_localctx, actionIndex);
-			break;
-		}
-	}
-	private void STRING_action(RuleContext _localctx, int actionIndex) {
-		switch (actionIndex) {
-		case 0:
-
-					// get rid of the enclosing quotes
-					String s = getText();
-					setText(s.substring(1, s.length() - 1));
-				
-			break;
-		}
-	}
-	private void INLINEASMBLOCK_action(RuleContext _localctx, int actionIndex) {
-		switch (actionIndex) {
-		case 1:
-
-					// get rid of the enclosing double braces
-					String s = getText();
-					setText(s.substring(2, s.length() - 2));
-				
-			break;
-		}
-	}
-	private void SINGLECHAR_action(RuleContext _localctx, int actionIndex) {
-		switch (actionIndex) {
-		case 2:
-
-					// get rid of the enclosing quotes
-					String s = getText();
-					setText(s.substring(1, s.length() - 1));
-				
-			break;
-		}
-	}
-
-	public static final String _serializedATN =
-		"\3\u608b\ua72a\u8133\ub9ed\u417c\u3be7\u7786\u5964\2}\u035e\b\1\4\2\t"+
-		"\2\4\3\t\3\4\4\t\4\4\5\t\5\4\6\t\6\4\7\t\7\4\b\t\b\4\t\t\t\4\n\t\n\4\13"+
-		"\t\13\4\f\t\f\4\r\t\r\4\16\t\16\4\17\t\17\4\20\t\20\4\21\t\21\4\22\t\22"+
-		"\4\23\t\23\4\24\t\24\4\25\t\25\4\26\t\26\4\27\t\27\4\30\t\30\4\31\t\31"+
-		"\4\32\t\32\4\33\t\33\4\34\t\34\4\35\t\35\4\36\t\36\4\37\t\37\4 \t \4!"+
-		"\t!\4\"\t\"\4#\t#\4$\t$\4%\t%\4&\t&\4\'\t\'\4(\t(\4)\t)\4*\t*\4+\t+\4"+
-		",\t,\4-\t-\4.\t.\4/\t/\4\60\t\60\4\61\t\61\4\62\t\62\4\63\t\63\4\64\t"+
-		"\64\4\65\t\65\4\66\t\66\4\67\t\67\48\t8\49\t9\4:\t:\4;\t;\4<\t<\4=\t="+
-		"\4>\t>\4?\t?\4@\t@\4A\tA\4B\tB\4C\tC\4D\tD\4E\tE\4F\tF\4G\tG\4H\tH\4I"+
-		"\tI\4J\tJ\4K\tK\4L\tL\4M\tM\4N\tN\4O\tO\4P\tP\4Q\tQ\4R\tR\4S\tS\4T\tT"+
-		"\4U\tU\4V\tV\4W\tW\4X\tX\4Y\tY\4Z\tZ\4[\t[\4\\\t\\\4]\t]\4^\t^\4_\t_\4"+
-		"`\t`\4a\ta\4b\tb\4c\tc\4d\td\4e\te\4f\tf\4g\tg\4h\th\4i\ti\4j\tj\4k\t"+
-		"k\4l\tl\4m\tm\4n\tn\4o\to\4p\tp\4q\tq\4r\tr\4s\ts\4t\tt\4u\tu\4v\tv\4"+
-		"w\tw\4x\tx\4y\ty\4z\tz\4{\t{\4|\t|\4}\t}\4~\t~\3\2\3\2\3\3\3\3\3\4\3\4"+
-		"\3\4\3\4\3\4\3\5\3\5\3\5\3\5\3\5\3\5\3\5\3\5\3\6\3\6\3\6\3\6\3\6\3\6\3"+
-		"\6\3\6\3\6\3\6\3\7\3\7\3\7\3\7\3\7\3\7\3\7\3\7\3\7\3\7\3\b\3\b\3\b\3\b"+
-		"\3\b\3\b\3\b\3\b\3\b\3\b\3\b\3\b\3\t\3\t\3\t\3\t\3\t\3\t\3\t\3\t\3\t\3"+
-		"\n\3\n\3\n\3\n\3\n\3\n\3\n\3\n\3\13\3\13\3\13\3\13\3\13\3\13\3\13\3\13"+
-		"\3\13\3\13\3\13\3\13\3\f\3\f\3\f\3\f\3\f\3\f\3\f\3\f\3\f\3\f\3\f\3\f\3"+
-		"\r\3\r\3\r\3\r\3\r\3\r\3\r\3\r\3\r\3\r\3\r\3\16\3\16\3\16\3\16\3\16\3"+
-		"\16\3\16\3\16\3\17\3\17\3\20\3\20\3\21\3\21\3\21\3\21\3\21\3\21\3\22\3"+
-		"\22\3\22\3\22\3\22\3\22\3\23\3\23\3\23\3\23\3\23\3\24\3\24\3\24\3\24\3"+
-		"\24\3\24\3\25\3\25\3\25\3\25\3\25\3\26\3\26\3\26\3\26\3\26\3\26\3\27\3"+
-		"\27\3\27\3\27\3\30\3\30\3\30\3\30\3\30\3\30\3\31\3\31\3\32\3\32\3\33\3"+
-		"\33\3\33\3\34\3\34\3\34\3\35\3\35\3\35\3\36\3\36\3\36\3\37\3\37\3\37\3"+
-		"\37\3 \3 \3 \3!\3!\3!\3\"\3\"\3\"\3#\3#\3#\3$\3$\3$\3$\3%\3%\3%\3%\3&"+
-		"\3&\3&\3\'\3\'\3\'\3(\3(\3)\3)\3*\3*\3*\3+\3+\3,\3,\3-\3-\3.\3.\3.\3/"+
-		"\3/\3/\3\60\3\60\3\61\3\61\3\62\3\62\3\62\3\63\3\63\3\63\3\64\3\64\3\64"+
-		"\3\65\3\65\3\65\3\66\3\66\3\67\3\67\38\38\38\39\39\39\39\39\3:\3:\3:\3"+
-		":\3;\3;\3;\3<\3<\3<\3<\3=\3=\3=\3=\3>\3>\3?\3?\3@\3@\3@\3A\3A\3B\3B\3"+
-		"B\3B\3B\3B\3B\3C\3C\3C\3C\3C\3C\3D\3D\3D\3D\3D\3D\3D\3D\3D\3E\3E\3F\3"+
-		"F\3G\3G\3H\3H\3I\3I\3I\3J\3J\3J\3K\3K\3K\3L\3L\3L\3M\3M\3M\3N\3N\3N\3"+
-		"O\3O\3O\3P\3P\3P\3Q\3Q\3Q\3Q\3Q\3R\3R\3R\3R\3R\3R\3S\3S\3S\3S\3S\3T\3"+
-		"T\3T\3T\3U\3U\3U\3V\3V\3W\3W\3X\3X\3X\3X\3X\3X\3X\3Y\3Y\3Y\3Y\3Y\3Y\3"+
-		"Y\3Y\3Y\3Z\3Z\3Z\3Z\3Z\3Z\3[\3[\3[\3\\\3\\\3\\\3\\\3\\\3]\3]\3]\3]\3]"+
-		"\3]\3^\3^\3^\3^\3^\3^\3_\3_\3_\3_\3_\3_\3`\3`\3`\3`\3`\3a\3a\3a\3a\3a"+
-		"\3a\3b\3b\3b\3b\3b\3b\3c\3c\3c\3c\3c\3c\3d\3d\3d\3d\3d\3d\3d\3e\3e\3e"+
-		"\3e\3e\3e\3f\3f\3f\3f\3f\3f\3f\3g\3g\3g\3g\3g\3g\3h\3h\3h\3h\3h\3h\3i"+
-		"\3i\3i\3i\3j\3j\3j\3k\3k\3k\3k\3k\3k\3l\3l\3l\3l\3l\3l\3l\3m\3m\3m\3m"+
-		"\3m\3m\3n\3n\7n\u02e4\nn\fn\16n\u02e7\13n\3n\3n\3n\3n\3o\3o\7o\u02ef\n"+
-		"o\fo\16o\u02f2\13o\3o\3o\3p\3p\3p\3p\3q\6q\u02fb\nq\rq\16q\u02fc\3r\3"+
-		"r\7r\u0301\nr\fr\16r\u0304\13r\3s\3s\3s\6s\u0309\ns\rs\16s\u030a\5s\u030d"+
-		"\ns\3t\3t\6t\u0311\nt\rt\16t\u0312\3u\3u\6u\u0317\nu\ru\16u\u0318\3v\3"+
-		"v\3w\3w\3w\5w\u0320\nw\3w\5w\u0323\nw\3x\6x\u0326\nx\rx\16x\u0327\3x\3"+
-		"x\6x\u032c\nx\rx\16x\u032d\5x\u0330\nx\3y\3y\3y\3y\5y\u0336\ny\3z\3z\3"+
-		"z\7z\u033b\nz\fz\16z\u033e\13z\3z\3z\3z\3{\3{\3{\3{\6{\u0347\n{\r{\16"+
-		"{\u0348\3{\3{\3{\3{\3{\3|\3|\3|\5|\u0353\n|\3|\3|\3|\3}\3}\3}\3}\3~\3"+
-		"~\3~\3\u0348\2\177\3\3\5\4\7\5\t\6\13\7\r\b\17\t\21\n\23\13\25\f\27\r"+
-		"\31\16\33\17\35\20\37\21!\22#\23%\24\'\25)\26+\27-\30/\31\61\32\63\33"+
-		"\65\34\67\359\36;\37= ?!A\"C#E$G%I&K\'M(O)Q*S+U,W-Y.[/]\60_\61a\62c\63"+
-		"e\64g\65i\66k\67m8o9q:s;u<w=y>{?}@\177A\u0081B\u0083C\u0085D\u0087E\u0089"+
-		"F\u008bG\u008dH\u008fI\u0091J\u0093K\u0095L\u0097M\u0099N\u009bO\u009d"+
-		"P\u009fQ\u00a1R\u00a3S\u00a5T\u00a7U\u00a9V\u00abW\u00adX\u00afY\u00b1"+
-		"Z\u00b3[\u00b5\\\u00b7]\u00b9^\u00bb_\u00bd`\u00bfa\u00c1b\u00c3c\u00c5"+
-		"d\u00c7e\u00c9f\u00cbg\u00cdh\u00cfi\u00d1j\u00d3k\u00d5l\u00d7m\u00d9"+
-		"n\u00dbo\u00ddp\u00dfq\u00e1r\u00e3s\u00e5t\u00e7u\u00e9v\u00ebw\u00ed"+
-		"x\u00ef\2\u00f1\2\u00f3y\u00f5z\u00f7{\u00f9|\u00fb}\3\2\n\4\2\f\f\17"+
-		"\17\4\2\13\13\"\"\5\2C\\aac|\6\2\62;C\\aac|\5\2\62;CHch\4\2GGgg\4\2--"+
-		"//\6\2\f\f\16\17$$^^\2\u036d\2\3\3\2\2\2\2\5\3\2\2\2\2\7\3\2\2\2\2\t\3"+
-		"\2\2\2\2\13\3\2\2\2\2\r\3\2\2\2\2\17\3\2\2\2\2\21\3\2\2\2\2\23\3\2\2\2"+
-		"\2\25\3\2\2\2\2\27\3\2\2\2\2\31\3\2\2\2\2\33\3\2\2\2\2\35\3\2\2\2\2\37"+
-		"\3\2\2\2\2!\3\2\2\2\2#\3\2\2\2\2%\3\2\2\2\2\'\3\2\2\2\2)\3\2\2\2\2+\3"+
-		"\2\2\2\2-\3\2\2\2\2/\3\2\2\2\2\61\3\2\2\2\2\63\3\2\2\2\2\65\3\2\2\2\2"+
-		"\67\3\2\2\2\29\3\2\2\2\2;\3\2\2\2\2=\3\2\2\2\2?\3\2\2\2\2A\3\2\2\2\2C"+
-		"\3\2\2\2\2E\3\2\2\2\2G\3\2\2\2\2I\3\2\2\2\2K\3\2\2\2\2M\3\2\2\2\2O\3\2"+
-		"\2\2\2Q\3\2\2\2\2S\3\2\2\2\2U\3\2\2\2\2W\3\2\2\2\2Y\3\2\2\2\2[\3\2\2\2"+
-		"\2]\3\2\2\2\2_\3\2\2\2\2a\3\2\2\2\2c\3\2\2\2\2e\3\2\2\2\2g\3\2\2\2\2i"+
-		"\3\2\2\2\2k\3\2\2\2\2m\3\2\2\2\2o\3\2\2\2\2q\3\2\2\2\2s\3\2\2\2\2u\3\2"+
-		"\2\2\2w\3\2\2\2\2y\3\2\2\2\2{\3\2\2\2\2}\3\2\2\2\2\177\3\2\2\2\2\u0081"+
-		"\3\2\2\2\2\u0083\3\2\2\2\2\u0085\3\2\2\2\2\u0087\3\2\2\2\2\u0089\3\2\2"+
-		"\2\2\u008b\3\2\2\2\2\u008d\3\2\2\2\2\u008f\3\2\2\2\2\u0091\3\2\2\2\2\u0093"+
-		"\3\2\2\2\2\u0095\3\2\2\2\2\u0097\3\2\2\2\2\u0099\3\2\2\2\2\u009b\3\2\2"+
-		"\2\2\u009d\3\2\2\2\2\u009f\3\2\2\2\2\u00a1\3\2\2\2\2\u00a3\3\2\2\2\2\u00a5"+
-		"\3\2\2\2\2\u00a7\3\2\2\2\2\u00a9\3\2\2\2\2\u00ab\3\2\2\2\2\u00ad\3\2\2"+
-		"\2\2\u00af\3\2\2\2\2\u00b1\3\2\2\2\2\u00b3\3\2\2\2\2\u00b5\3\2\2\2\2\u00b7"+
-		"\3\2\2\2\2\u00b9\3\2\2\2\2\u00bb\3\2\2\2\2\u00bd\3\2\2\2\2\u00bf\3\2\2"+
-		"\2\2\u00c1\3\2\2\2\2\u00c3\3\2\2\2\2\u00c5\3\2\2\2\2\u00c7\3\2\2\2\2\u00c9"+
-		"\3\2\2\2\2\u00cb\3\2\2\2\2\u00cd\3\2\2\2\2\u00cf\3\2\2\2\2\u00d1\3\2\2"+
-		"\2\2\u00d3\3\2\2\2\2\u00d5\3\2\2\2\2\u00d7\3\2\2\2\2\u00d9\3\2\2\2\2\u00db"+
-		"\3\2\2\2\2\u00dd\3\2\2\2\2\u00df\3\2\2\2\2\u00e1\3\2\2\2\2\u00e3\3\2\2"+
-		"\2\2\u00e5\3\2\2\2\2\u00e7\3\2\2\2\2\u00e9\3\2\2\2\2\u00eb\3\2\2\2\2\u00ed"+
-		"\3\2\2\2\2\u00f3\3\2\2\2\2\u00f5\3\2\2\2\2\u00f7\3\2\2\2\2\u00f9\3\2\2"+
-		"\2\2\u00fb\3\2\2\2\3\u00fd\3\2\2\2\5\u00ff\3\2\2\2\7\u0101\3\2\2\2\t\u0106"+
-		"\3\2\2\2\13\u010e\3\2\2\2\r\u0118\3\2\2\2\17\u0122\3\2\2\2\21\u012e\3"+
-		"\2\2\2\23\u0137\3\2\2\2\25\u013f\3\2\2\2\27\u014b\3\2\2\2\31\u0157\3\2"+
-		"\2\2\33\u0162\3\2\2\2\35\u016a\3\2\2\2\37\u016c\3\2\2\2!\u016e\3\2\2\2"+
-		"#\u0174\3\2\2\2%\u017a\3\2\2\2\'\u017f\3\2\2\2)\u0185\3\2\2\2+\u018a\3"+
-		"\2\2\2-\u0190\3\2\2\2/\u0194\3\2\2\2\61\u019a\3\2\2\2\63\u019c\3\2\2\2"+
-		"\65\u019e\3\2\2\2\67\u01a1\3\2\2\29\u01a4\3\2\2\2;\u01a7\3\2\2\2=\u01aa"+
-		"\3\2\2\2?\u01ae\3\2\2\2A\u01b1\3\2\2\2C\u01b4\3\2\2\2E\u01b7\3\2\2\2G"+
-		"\u01ba\3\2\2\2I\u01be\3\2\2\2K\u01c2\3\2\2\2M\u01c5\3\2\2\2O\u01c8\3\2"+
-		"\2\2Q\u01ca\3\2\2\2S\u01cc\3\2\2\2U\u01cf\3\2\2\2W\u01d1\3\2\2\2Y\u01d3"+
-		"\3\2\2\2[\u01d5\3\2\2\2]\u01d8\3\2\2\2_\u01db\3\2\2\2a\u01dd\3\2\2\2c"+
-		"\u01df\3\2\2\2e\u01e2\3\2\2\2g\u01e5\3\2\2\2i\u01e8\3\2\2\2k\u01eb\3\2"+
-		"\2\2m\u01ed\3\2\2\2o\u01ef\3\2\2\2q\u01f2\3\2\2\2s\u01f7\3\2\2\2u\u01fb"+
-		"\3\2\2\2w\u01fe\3\2\2\2y\u0202\3\2\2\2{\u0206\3\2\2\2}\u0208\3\2\2\2\177"+
-		"\u020a\3\2\2\2\u0081\u020d\3\2\2\2\u0083\u020f\3\2\2\2\u0085\u0216\3\2"+
-		"\2\2\u0087\u021c\3\2\2\2\u0089\u0225\3\2\2\2\u008b\u0227\3\2\2\2\u008d"+
-		"\u0229\3\2\2\2\u008f\u022b\3\2\2\2\u0091\u022d\3\2\2\2\u0093\u0230\3\2"+
-		"\2\2\u0095\u0233\3\2\2\2\u0097\u0236\3\2\2\2\u0099\u0239\3\2\2\2\u009b"+
-		"\u023c\3\2\2\2\u009d\u023f\3\2\2\2\u009f\u0242\3\2\2\2\u00a1\u0245\3\2"+
-		"\2\2\u00a3\u024a\3\2\2\2\u00a5\u0250\3\2\2\2\u00a7\u0255\3\2\2\2\u00a9"+
-		"\u0259\3\2\2\2\u00ab\u025c\3\2\2\2\u00ad\u025e\3\2\2\2\u00af\u0260\3\2"+
-		"\2\2\u00b1\u0267\3\2\2\2\u00b3\u0270\3\2\2\2\u00b5\u0276\3\2\2\2\u00b7"+
-		"\u0279\3\2\2\2\u00b9\u027e\3\2\2\2\u00bb\u0284\3\2\2\2\u00bd\u028a\3\2"+
-		"\2\2\u00bf\u0290\3\2\2\2\u00c1\u0295\3\2\2\2\u00c3\u029b\3\2\2\2\u00c5"+
-		"\u02a1\3\2\2\2\u00c7\u02a7\3\2\2\2\u00c9\u02ae\3\2\2\2\u00cb\u02b4\3\2"+
-		"\2\2\u00cd\u02bb\3\2\2\2\u00cf\u02c1\3\2\2\2\u00d1\u02c7\3\2\2\2\u00d3"+
-		"\u02cb\3\2\2\2\u00d5\u02ce\3\2\2\2\u00d7\u02d4\3\2\2\2\u00d9\u02db\3\2"+
-		"\2\2\u00db\u02e1\3\2\2\2\u00dd\u02ec\3\2\2\2\u00df\u02f5\3\2\2\2\u00e1"+
-		"\u02fa\3\2\2\2\u00e3\u02fe\3\2\2\2\u00e5\u030c\3\2\2\2\u00e7\u030e\3\2"+
-		"\2\2\u00e9\u0314\3\2\2\2\u00eb\u031a\3\2\2\2\u00ed\u031c\3\2\2\2\u00ef"+
-		"\u0325\3\2\2\2\u00f1\u0335\3\2\2\2\u00f3\u0337\3\2\2\2\u00f5\u0342\3\2"+
-		"\2\2\u00f7\u034f\3\2\2\2\u00f9\u0357\3\2\2\2\u00fb\u035b\3\2\2\2\u00fd"+
-		"\u00fe\7\u0080\2\2\u00fe\4\3\2\2\2\u00ff\u0100\7<\2\2\u0100\6\3\2\2\2"+
-		"\u0101\u0102\7i\2\2\u0102\u0103\7q\2\2\u0103\u0104\7v\2\2\u0104\u0105"+
-		"\7q\2\2\u0105\b\3\2\2\2\u0106\u0107\7\'\2\2\u0107\u0108\7q\2\2\u0108\u0109"+
-		"\7w\2\2\u0109\u010a\7v\2\2\u010a\u010b\7r\2\2\u010b\u010c\7w\2\2\u010c"+
-		"\u010d\7v\2\2\u010d\n\3\2\2\2\u010e\u010f\7\'\2\2\u010f\u0110\7n\2\2\u0110"+
-		"\u0111\7c\2\2\u0111\u0112\7w\2\2\u0112\u0113\7p\2\2\u0113\u0114\7e\2\2"+
-		"\u0114\u0115\7j\2\2\u0115\u0116\7g\2\2\u0116\u0117\7t\2\2\u0117\f\3\2"+
-		"\2\2\u0118\u0119\7\'\2\2\u0119\u011a\7|\2\2\u011a\u011b\7g\2\2\u011b\u011c"+
-		"\7t\2\2\u011c\u011d\7q\2\2\u011d\u011e\7r\2\2\u011e\u011f\7c\2\2\u011f"+
-		"\u0120\7i\2\2\u0120\u0121\7g\2\2\u0121\16\3\2\2\2\u0122\u0123\7\'\2\2"+
-		"\u0123\u0124\7|\2\2\u0124\u0125\7r\2\2\u0125\u0126\7t\2\2\u0126\u0127"+
-		"\7g\2\2\u0127\u0128\7u\2\2\u0128\u0129\7g\2\2\u0129\u012a\7t\2\2\u012a"+
-		"\u012b\7x\2\2\u012b\u012c\7g\2\2\u012c\u012d\7f\2\2\u012d\20\3\2\2\2\u012e"+
-		"\u012f\7\'\2\2\u012f\u0130\7c\2\2\u0130\u0131\7f\2\2\u0131\u0132\7f\2"+
-		"\2\u0132\u0133\7t\2\2\u0133\u0134\7g\2\2\u0134\u0135\7u\2\2\u0135\u0136"+
-		"\7u\2\2\u0136\22\3\2\2\2\u0137\u0138\7\'\2\2\u0138\u0139\7k\2\2\u0139"+
-		"\u013a\7o\2\2\u013a\u013b\7r\2\2\u013b\u013c\7q\2\2\u013c\u013d\7t\2\2"+
-		"\u013d\u013e\7v\2\2\u013e\24\3\2\2\2\u013f\u0140\7\'\2\2\u0140\u0141\7"+
-		"d\2\2\u0141\u0142\7t\2\2\u0142\u0143\7g\2\2\u0143\u0144\7c\2\2\u0144\u0145"+
-		"\7m\2\2\u0145\u0146\7r\2\2\u0146\u0147\7q\2\2\u0147\u0148\7k\2\2\u0148"+
-		"\u0149\7p\2\2\u0149\u014a\7v\2\2\u014a\26\3\2\2\2\u014b\u014c\7\'\2\2"+
-		"\u014c\u014d\7c\2\2\u014d\u014e\7u\2\2\u014e\u014f\7o\2\2\u014f\u0150"+
-		"\7k\2\2\u0150\u0151\7p\2\2\u0151\u0152\7e\2\2\u0152\u0153\7n\2\2\u0153"+
-		"\u0154\7w\2\2\u0154\u0155\7f\2\2\u0155\u0156\7g\2\2\u0156\30\3\2\2\2\u0157"+
-		"\u0158\7\'\2\2\u0158\u0159\7c\2\2\u0159\u015a\7u\2\2\u015a\u015b\7o\2"+
-		"\2\u015b\u015c\7d\2\2\u015c\u015d\7k\2\2\u015d\u015e\7p\2\2\u015e\u015f"+
-		"\7c\2\2\u015f\u0160\7t\2\2\u0160\u0161\7{\2\2\u0161\32\3\2\2\2\u0162\u0163"+
-		"\7\'\2\2\u0163\u0164\7q\2\2\u0164\u0165\7r\2\2\u0165\u0166\7v\2\2\u0166"+
-		"\u0167\7k\2\2\u0167\u0168\7q\2\2\u0168\u0169\7p\2\2\u0169\34\3\2\2\2\u016a"+
-		"\u016b\7.\2\2\u016b\36\3\2\2\2\u016c\u016d\7?\2\2\u016d \3\2\2\2\u016e"+
-		"\u016f\7e\2\2\u016f\u0170\7q\2\2\u0170\u0171\7p\2\2\u0171\u0172\7u\2\2"+
-		"\u0172\u0173\7v\2\2\u0173\"\3\2\2\2\u0174\u0175\7w\2\2\u0175\u0176\7d"+
-		"\2\2\u0176\u0177\7{\2\2\u0177\u0178\7v\2\2\u0178\u0179\7g\2\2\u0179$\3"+
-		"\2\2\2\u017a\u017b\7d\2\2\u017b\u017c\7{\2\2\u017c\u017d\7v\2\2\u017d"+
-		"\u017e\7g\2\2\u017e&\3\2\2\2\u017f\u0180\7w\2\2\u0180\u0181\7y\2\2\u0181"+
-		"\u0182\7q\2\2\u0182\u0183\7t\2\2\u0183\u0184\7f\2\2\u0184(\3\2\2\2\u0185"+
-		"\u0186\7y\2\2\u0186\u0187\7q\2\2\u0187\u0188\7t\2\2\u0188\u0189\7f\2\2"+
-		"\u0189*\3\2\2\2\u018a\u018b\7h\2\2\u018b\u018c\7n\2\2\u018c\u018d\7q\2"+
-		"\2\u018d\u018e\7c\2\2\u018e\u018f\7v\2\2\u018f,\3\2\2\2\u0190\u0191\7"+
-		"u\2\2\u0191\u0192\7v\2\2\u0192\u0193\7t\2\2\u0193.\3\2\2\2\u0194\u0195"+
-		"\7u\2\2\u0195\u0196\7v\2\2\u0196\u0197\7t\2\2\u0197\u0198\7a\2\2\u0198"+
-		"\u0199\7u\2\2\u0199\60\3\2\2\2\u019a\u019b\7]\2\2\u019b\62\3\2\2\2\u019c"+
-		"\u019d\7_\2\2\u019d\64\3\2\2\2\u019e\u019f\7-\2\2\u019f\u01a0\7?\2\2\u01a0"+
-		"\66\3\2\2\2\u01a1\u01a2\7/\2\2\u01a2\u01a3\7?\2\2\u01a38\3\2\2\2\u01a4"+
-		"\u01a5\7\61\2\2\u01a5\u01a6\7?\2\2\u01a6:\3\2\2\2\u01a7\u01a8\7,\2\2\u01a8"+
-		"\u01a9\7?\2\2\u01a9<\3\2\2\2\u01aa\u01ab\7,\2\2\u01ab\u01ac\7,\2\2\u01ac"+
-		"\u01ad\7?\2\2\u01ad>\3\2\2\2\u01ae\u01af\7(\2\2\u01af\u01b0\7?\2\2\u01b0"+
-		"@\3\2\2\2\u01b1\u01b2\7~\2\2\u01b2\u01b3\7?\2\2\u01b3B\3\2\2\2\u01b4\u01b5"+
-		"\7`\2\2\u01b5\u01b6\7?\2\2\u01b6D\3\2\2\2\u01b7\u01b8\7\'\2\2\u01b8\u01b9"+
-		"\7?\2\2\u01b9F\3\2\2\2\u01ba\u01bb\7>\2\2\u01bb\u01bc\7>\2\2\u01bc\u01bd"+
-		"\7?\2\2\u01bdH\3\2\2\2\u01be\u01bf\7@\2\2\u01bf\u01c0\7@\2\2\u01c0\u01c1"+
-		"\7?\2\2\u01c1J\3\2\2\2\u01c2\u01c3\7-\2\2\u01c3\u01c4\7-\2\2\u01c4L\3"+
-		"\2\2\2\u01c5\u01c6\7/\2\2\u01c6\u01c7\7/\2\2\u01c7N\3\2\2\2\u01c8\u01c9"+
-		"\7-\2\2\u01c9P\3\2\2\2\u01ca\u01cb\7/\2\2\u01cbR\3\2\2\2\u01cc\u01cd\7"+
-		",\2\2\u01cd\u01ce\7,\2\2\u01ceT\3\2\2\2\u01cf\u01d0\7,\2\2\u01d0V\3\2"+
-		"\2\2\u01d1\u01d2\7\61\2\2\u01d2X\3\2\2\2\u01d3\u01d4\7\'\2\2\u01d4Z\3"+
-		"\2\2\2\u01d5\u01d6\7>\2\2\u01d6\u01d7\7>\2\2\u01d7\\\3\2\2\2\u01d8\u01d9"+
-		"\7@\2\2\u01d9\u01da\7@\2\2\u01da^\3\2\2\2\u01db\u01dc\7>\2\2\u01dc`\3"+
-		"\2\2\2\u01dd\u01de\7@\2\2\u01deb\3\2\2\2\u01df\u01e0\7>\2\2\u01e0\u01e1"+
-		"\7?\2\2\u01e1d\3\2\2\2\u01e2\u01e3\7@\2\2\u01e3\u01e4\7?\2\2\u01e4f\3"+
-		"\2\2\2\u01e5\u01e6\7?\2\2\u01e6\u01e7\7?\2\2\u01e7h\3\2\2\2\u01e8\u01e9"+
-		"\7#\2\2\u01e9\u01ea\7?\2\2\u01eaj\3\2\2\2\u01eb\u01ec\7`\2\2\u01ecl\3"+
-		"\2\2\2\u01ed\u01ee\7~\2\2\u01een\3\2\2\2\u01ef\u01f0\7v\2\2\u01f0\u01f1"+
-		"\7q\2\2\u01f1p\3\2\2\2\u01f2\u01f3\7u\2\2\u01f3\u01f4\7v\2\2\u01f4\u01f5"+
-		"\7g\2\2\u01f5\u01f6\7r\2\2\u01f6r\3\2\2\2\u01f7\u01f8\7c\2\2\u01f8\u01f9"+
-		"\7p\2\2\u01f9\u01fa\7f\2\2\u01fat\3\2\2\2\u01fb\u01fc\7q\2\2\u01fc\u01fd"+
-		"\7t\2\2\u01fdv\3\2\2\2\u01fe\u01ff\7z\2\2\u01ff\u0200\7q\2\2\u0200\u0201"+
-		"\7t\2\2\u0201x\3\2\2\2\u0202\u0203\7p\2\2\u0203\u0204\7q\2\2\u0204\u0205"+
-		"\7v\2\2\u0205z\3\2\2\2\u0206\u0207\7*\2\2\u0207|\3\2\2\2\u0208\u0209\7"+
-		"+\2\2\u0209~\3\2\2\2\u020a\u020b\7c\2\2\u020b\u020c\7u\2\2\u020c\u0080"+
-		"\3\2\2\2\u020d\u020e\7B\2\2\u020e\u0082\3\2\2\2\u020f\u0210\7t\2\2\u0210"+
-		"\u0211\7g\2\2\u0211\u0212\7v\2\2\u0212\u0213\7w\2\2\u0213\u0214\7t\2\2"+
-		"\u0214\u0215\7p\2\2\u0215\u0084\3\2\2\2\u0216\u0217\7d\2\2\u0217\u0218"+
-		"\7t\2\2\u0218\u0219\7g\2\2\u0219\u021a\7c\2\2\u021a\u021b\7m\2\2\u021b"+
-		"\u0086\3\2\2\2\u021c\u021d\7e\2\2\u021d\u021e\7q\2\2\u021e\u021f\7p\2"+
-		"\2\u021f\u0220\7v\2\2\u0220\u0221\7k\2\2\u0221\u0222\7p\2\2\u0222\u0223"+
-		"\7w\2\2\u0223\u0224\7g\2\2\u0224\u0088\3\2\2\2\u0225\u0226\7\60\2\2\u0226"+
-		"\u008a\3\2\2\2\u0227\u0228\7C\2\2\u0228\u008c\3\2\2\2\u0229\u022a\7Z\2"+
-		"\2\u022a\u008e\3\2\2\2\u022b\u022c\7[\2\2\u022c\u0090\3\2\2\2\u022d\u022e"+
-		"\7C\2\2\u022e\u022f\7Z\2\2\u022f\u0092\3\2\2\2\u0230\u0231\7C\2\2\u0231"+
-		"\u0232\7[\2\2\u0232\u0094\3\2\2\2\u0233\u0234\7Z\2\2\u0234\u0235\7[\2"+
-		"\2\u0235\u0096\3\2\2\2\u0236\u0237\7R\2\2\u0237\u0238\7e\2\2\u0238\u0098"+
-		"\3\2\2\2\u0239\u023a\7R\2\2\u023a\u023b\7|\2\2\u023b\u009a\3\2\2\2\u023c"+
-		"\u023d\7R\2\2\u023d\u023e\7p\2\2\u023e\u009c\3\2\2\2\u023f\u0240\7R\2"+
-		"\2\u0240\u0241\7x\2\2\u0241\u009e\3\2\2\2\u0242\u0243\7\60\2\2\u0243\u0244"+
-		"\7y\2\2\u0244\u00a0\3\2\2\2\u0245\u0246\7v\2\2\u0246\u0247\7t\2\2\u0247"+
-		"\u0248\7w\2\2\u0248\u0249\7g\2\2\u0249\u00a2\3\2\2\2\u024a\u024b\7h\2"+
-		"\2\u024b\u024c\7c\2\2\u024c\u024d\7n\2\2\u024d\u024e\7u\2\2\u024e\u024f"+
-		"\7g\2\2\u024f\u00a4\3\2\2\2\u0250\u0251\7\'\2\2\u0251\u0252\7c\2\2\u0252"+
-		"\u0253\7u\2\2\u0253\u0254\7o\2\2\u0254\u00a6\3\2\2\2\u0255\u0256\7u\2"+
-		"\2\u0256\u0257\7w\2\2\u0257\u0258\7d\2\2\u0258\u00a8\3\2\2\2\u0259\u025a"+
-		"\7/\2\2\u025a\u025b\7@\2\2\u025b\u00aa\3\2\2\2\u025c\u025d\7}\2\2\u025d"+
-		"\u00ac\3\2\2\2\u025e\u025f\7\177\2\2\u025f\u00ae\3\2\2\2\u0260\u0261\7"+
-		"c\2\2\u0261\u0262\7u\2\2\u0262\u0263\7o\2\2\u0263\u0264\7u\2\2\u0264\u0265"+
-		"\7w\2\2\u0265\u0266\7d\2\2\u0266\u00b0\3\2\2\2\u0267\u0268\7e\2\2\u0268"+
-		"\u0269\7n\2\2\u0269\u026a\7q\2\2\u026a\u026b\7d\2\2\u026b\u026c\7d\2\2"+
-		"\u026c\u026d\7g\2\2\u026d\u026e\7t\2\2\u026e\u026f\7u\2\2\u026f\u00b2"+
-		"\3\2\2\2\u0270\u0271\7u\2\2\u0271\u0272\7v\2\2\u0272\u0273\7c\2\2\u0273"+
-		"\u0274\7e\2\2\u0274\u0275\7m\2\2\u0275\u00b4\3\2\2\2\u0276\u0277\7k\2"+
-		"\2\u0277\u0278\7h\2\2\u0278\u00b6\3\2\2\2\u0279\u027a\7g\2\2\u027a\u027b"+
-		"\7n\2\2\u027b\u027c\7u\2\2\u027c\u027d\7g\2\2\u027d\u00b8\3\2\2\2\u027e"+
-		"\u027f\7k\2\2\u027f\u0280\7h\2\2\u0280\u0281\7a\2\2\u0281\u0282\7e\2\2"+
-		"\u0282\u0283\7u\2\2\u0283\u00ba\3\2\2\2\u0284\u0285\7k\2\2\u0285\u0286"+
-		"\7h\2\2\u0286\u0287\7a\2\2\u0287\u0288\7e\2\2\u0288\u0289\7e\2\2\u0289"+
-		"\u00bc\3\2\2\2\u028a\u028b\7k\2\2\u028b\u028c\7h\2\2\u028c\u028d\7a\2"+
-		"\2\u028d\u028e\7g\2\2\u028e\u028f\7s\2\2\u028f\u00be\3\2\2\2\u0290\u0291"+
-		"\7k\2\2\u0291\u0292\7h\2\2\u0292\u0293\7a\2\2\u0293\u0294\7|\2\2\u0294"+
-		"\u00c0\3\2\2\2\u0295\u0296\7k\2\2\u0296\u0297\7h\2\2\u0297\u0298\7a\2"+
-		"\2\u0298\u0299\7p\2\2\u0299\u029a\7g\2\2\u029a\u00c2\3\2\2\2\u029b\u029c"+
-		"\7k\2\2\u029c\u029d\7h\2\2\u029d\u029e\7a\2\2\u029e\u029f\7p\2\2\u029f"+
-		"\u02a0\7|\2\2\u02a0\u00c4\3\2\2\2\u02a1\u02a2\7k\2\2\u02a2\u02a3\7h\2"+
-		"\2\u02a3\u02a4\7a\2\2\u02a4\u02a5\7r\2\2\u02a5\u02a6\7n\2\2\u02a6\u00c6"+
-		"\3\2\2\2\u02a7\u02a8\7k\2\2\u02a8\u02a9\7h\2\2\u02a9\u02aa\7a\2\2\u02aa"+
-		"\u02ab\7r\2\2\u02ab\u02ac\7q\2\2\u02ac\u02ad\7u\2\2\u02ad\u00c8\3\2\2"+
-		"\2\u02ae\u02af\7k\2\2\u02af\u02b0\7h\2\2\u02b0\u02b1\7a\2\2\u02b1\u02b2"+
-		"\7o\2\2\u02b2\u02b3\7k\2\2\u02b3\u00ca\3\2\2\2\u02b4\u02b5\7k\2\2\u02b5"+
-		"\u02b6\7h\2\2\u02b6\u02b7\7a\2\2\u02b7\u02b8\7p\2\2\u02b8\u02b9\7g\2\2"+
-		"\u02b9\u02ba\7i\2\2\u02ba\u00cc\3\2\2\2\u02bb\u02bc\7k\2\2\u02bc\u02bd"+
-		"\7h\2\2\u02bd\u02be\7a\2\2\u02be\u02bf\7x\2\2\u02bf\u02c0\7u\2\2\u02c0"+
-		"\u00ce\3\2\2\2\u02c1\u02c2\7k\2\2\u02c2\u02c3\7h\2\2\u02c3\u02c4\7a\2"+
-		"\2\u02c4\u02c5\7x\2\2\u02c5\u02c6\7e\2\2\u02c6\u00d0\3\2\2\2\u02c7\u02c8"+
-		"\7h\2\2\u02c8\u02c9\7q\2\2\u02c9\u02ca\7t\2\2\u02ca\u00d2\3\2\2\2\u02cb"+
-		"\u02cc\7k\2\2\u02cc\u02cd\7p\2\2\u02cd\u00d4\3\2\2\2\u02ce\u02cf\7y\2"+
-		"\2\u02cf\u02d0\7j\2\2\u02d0\u02d1\7k\2\2\u02d1\u02d2\7n\2\2\u02d2\u02d3"+
-		"\7g\2\2\u02d3\u00d6\3\2\2\2\u02d4\u02d5\7t\2\2\u02d5\u02d6\7g\2\2\u02d6"+
-		"\u02d7\7r\2\2\u02d7\u02d8\7g\2\2\u02d8\u02d9\7c\2\2\u02d9\u02da\7v\2\2"+
-		"\u02da\u00d8\3\2\2\2\u02db\u02dc\7w\2\2\u02dc\u02dd\7p\2\2\u02dd\u02de"+
-		"\7v\2\2\u02de\u02df\7k\2\2\u02df\u02e0\7n\2\2\u02e0\u00da\3\2\2\2\u02e1"+
-		"\u02e5\t\2\2\2\u02e2\u02e4\t\3\2\2\u02e3\u02e2\3\2\2\2\u02e4\u02e7\3\2"+
-		"\2\2\u02e5\u02e3\3\2\2\2\u02e5\u02e6\3\2\2\2\u02e6\u02e8\3\2\2\2\u02e7"+
-		"\u02e5\3\2\2\2\u02e8\u02e9\5\u00ddo\2\u02e9\u02ea\3\2\2\2\u02ea\u02eb"+
-		"\bn\2\2\u02eb\u00dc\3\2\2\2\u02ec\u02f0\7=\2\2\u02ed\u02ef\n\2\2\2\u02ee"+
-		"\u02ed\3\2\2\2\u02ef\u02f2\3\2\2\2\u02f0\u02ee\3\2\2\2\u02f0\u02f1\3\2"+
-		"\2\2\u02f1\u02f3\3\2\2\2\u02f2\u02f0\3\2\2\2\u02f3\u02f4\bo\2\2\u02f4"+
-		"\u00de\3\2\2\2\u02f5\u02f6\t\3\2\2\u02f6\u02f7\3\2\2\2\u02f7\u02f8\bp"+
-		"\3\2\u02f8\u00e0\3\2\2\2\u02f9\u02fb\t\2\2\2\u02fa\u02f9\3\2\2\2\u02fb"+
-		"\u02fc\3\2\2\2\u02fc\u02fa\3\2\2\2\u02fc\u02fd\3\2\2\2\u02fd\u00e2\3\2"+
-		"\2\2\u02fe\u0302\t\4\2\2\u02ff\u0301\t\5\2\2\u0300\u02ff\3\2\2\2\u0301"+
-		"\u0304\3\2\2\2\u0302\u0300\3\2\2\2\u0302\u0303\3\2\2\2\u0303\u00e4\3\2"+
-		"\2\2\u0304\u0302\3\2\2\2\u0305\u030d\4\62;\2\u0306\u0308\4\63;\2\u0307"+
-		"\u0309\4\62;\2\u0308\u0307\3\2\2\2\u0309\u030a\3\2\2\2\u030a\u0308\3\2"+
-		"\2\2\u030a\u030b\3\2\2\2\u030b\u030d\3\2\2\2\u030c\u0305\3\2\2\2\u030c"+
-		"\u0306\3\2\2\2\u030d\u00e6\3\2\2\2\u030e\u0310\7&\2\2\u030f\u0311\t\6"+
-		"\2\2\u0310\u030f\3\2\2\2\u0311\u0312\3\2\2\2\u0312\u0310\3\2\2\2\u0312"+
-		"\u0313\3\2\2\2\u0313\u00e8\3\2\2\2\u0314\u0316\7\'\2\2\u0315\u0317\4\62"+
-		"\63\2\u0316\u0315\3\2\2\2\u0317\u0318\3\2\2\2\u0318\u0316\3\2\2\2\u0318"+
-		"\u0319\3\2\2\2\u0319\u00ea\3\2\2\2\u031a\u031b\7(\2\2\u031b\u00ec\3\2"+
-		"\2\2\u031c\u0322\5\u00efx\2\u031d\u031f\t\7\2\2\u031e\u0320\t\b\2\2\u031f"+
-		"\u031e\3\2\2\2\u031f\u0320\3\2\2\2\u0320\u0321\3\2\2\2\u0321\u0323\5\u00ef"+
-		"x\2\u0322\u031d\3\2\2\2\u0322\u0323\3\2\2\2\u0323\u00ee\3\2\2\2\u0324"+
-		"\u0326\4\62;\2\u0325\u0324\3\2\2\2\u0326\u0327\3\2\2\2\u0327\u0325\3\2"+
-		"\2\2\u0327\u0328\3\2\2\2\u0328\u032f\3\2\2\2\u0329\u032b\7\60\2\2\u032a"+
-		"\u032c\4\62;\2\u032b\u032a\3\2\2\2\u032c\u032d\3\2\2\2\u032d\u032b\3\2"+
-		"\2\2\u032d\u032e\3\2\2\2\u032e\u0330\3\2\2\2\u032f\u0329\3\2\2\2\u032f"+
-		"\u0330\3\2\2\2\u0330\u00f0\3\2\2\2\u0331\u0332\7^\2\2\u0332\u0336\13\2"+
-		"\2\2\u0333\u0334\7^\2\2\u0334\u0336\5\u00e1q\2\u0335\u0331\3\2\2\2\u0335"+
-		"\u0333\3\2\2\2\u0336\u00f2\3\2\2\2\u0337\u033c\7$\2\2\u0338\u033b\5\u00f1"+
-		"y\2\u0339\u033b\n\t\2\2\u033a\u0338\3\2\2\2\u033a\u0339\3\2\2\2\u033b"+
-		"\u033e\3\2\2\2\u033c\u033a\3\2\2\2\u033c\u033d\3\2\2\2\u033d\u033f\3\2"+
-		"\2\2\u033e\u033c\3\2\2\2\u033f\u0340\7$\2\2\u0340\u0341\bz\4\2\u0341\u00f4"+
-		"\3\2\2\2\u0342\u0343\7}\2\2\u0343\u0344\7}\2\2\u0344\u0346\3\2\2\2\u0345"+
-		"\u0347\13\2\2\2\u0346\u0345\3\2\2\2\u0347\u0348\3\2\2\2\u0348\u0349\3"+
-		"\2\2\2\u0348\u0346\3\2\2\2\u0349\u034a\3\2\2\2\u034a\u034b\7\177\2\2\u034b"+
-		"\u034c\7\177\2\2\u034c\u034d\3\2\2\2\u034d\u034e\b{\5\2\u034e\u00f6\3"+
-		"\2\2\2\u034f\u0352\7)\2\2\u0350\u0353\5\u00f1y\2\u0351\u0353\n\t\2\2\u0352"+
-		"\u0350\3\2\2\2\u0352\u0351\3\2\2\2\u0353\u0354\3\2\2\2\u0354\u0355\7)"+
-		"\2\2\u0355\u0356\b|\6\2\u0356\u00f8\3\2\2\2\u0357\u0358\7B\2\2\u0358\u0359"+
-		"\7|\2\2\u0359\u035a\7r\2\2\u035a\u00fa\3\2\2\2\u035b\u035c\7]\2\2\u035c"+
-		"\u035d\7_\2\2\u035d\u00fc\3\2\2\2\26\2\u02e5\u02f0\u02fc\u0302\u030a\u030c"+
-		"\u0310\u0312\u0318\u031f\u0322\u0327\u032d\u032f\u0335\u033a\u033c\u0348"+
-		"\u0352\7\2\3\2\b\2\2\3z\2\3{\3\3|\4";
-	public static final ATN _ATN =
-		new ATNDeserializer().deserialize(_serializedATN.toCharArray());
-	static {
-		_decisionToDFA = new DFA[_ATN.getNumberOfDecisions()];
-		for (int i = 0; i < _ATN.getNumberOfDecisions(); i++) {
-			_decisionToDFA[i] = new DFA(_ATN.getDecisionState(i), i);
-		}
-	}
-}

scripts/clean.sh

@@ -1,5 +1,5 @@
 #!/usr/bin/env sh
 
 rm *.jar *.asm *.prg *.vm.txt *.vice-mon-list
-rm -r build
+rm -rf build out