updated tehtriz screenshot

possible solution for antlr4-runtime in the fatjar

.gitignore

@@ -29,3 +29,6 @@ compiler/src/prog8_kotlin.jar
 compiler/src/compiled_java
 .attach_pid*
 
+.gradle
+build/
+/prog8compiler.jar

README.md

@@ -109,3 +109,6 @@ Another example (cube3d-sprites.p8) draws the vertices of a rotating 3d cube:
 
 ![cube3d screen](docs/source/_static/cube3d.png)
 
+If you want to play a video game, a fully working Tetris clone is included in the examples:
+
+![tehtriz_screen](docs/source/_static/tehtriz.png)

build_the_compiler.sh

@@ -1,7 +1,7 @@
 #!/usr/bin/env bash
 
 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 -package prog8.parser ./parser/antlr/prog8.g4
+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/build.gradle

@@ -0,0 +1,73 @@
+plugins {
+    id "org.jetbrains.kotlin.jvm" version "1.3.21"
+    id 'application'
+}
+
+repositories {
+    mavenCentral()
+    jcenter()
+}
+
+def kotlinVersion = '1.3.21'
+
+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"
+    runtime 'org.antlr:antlr4-runtime:4.7.2'
+    runtime project(':parser')
+
+	testImplementation "org.jetbrains.kotlin:kotlin-test-junit5:$kotlinVersion"
+    testImplementation 'org.junit.jupiter:junit-jupiter-api:5.3.2'
+    testImplementation 'org.hamcrest:hamcrest-junit:2.0.0.0'
+}
+
+
+sourceSets {
+    main {
+        java {
+            srcDirs = ["${project.projectDir}/src"]
+        }
+        resources {
+            srcDirs = ["${project.projectDir}/res"]
+        }
+    }
+    test {
+        java {
+            srcDirs = ["${project.projectDir}/test"]
+        }
+    }
+}
+
+
+
+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
+}
+
+applicationDistribution.into("bin") {
+            from(p8vmScript)
+            fileMode = 0755
+}
+
+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)

compiler/res/prog8lib/c64lib.p8

@@ -43,7 +43,7 @@
 		memory  ubyte  SPRPTR6		= 2046
 		memory  ubyte  SPRPTR7		= 2047
 		memory  ubyte[8]  SPRPTR	= 2040		; the 8 sprite pointers as an array.
- 
+
 
 ; ---- VIC-II 6567/6569/856x registers ----
 
@@ -99,14 +99,14 @@
 		memory  ubyte  SP6COL		= $d02d
 		memory  ubyte  SP7COL		= $d02e
 		memory  ubyte[8]  SPCOL		= $d027
-		
+
 
 ; ---- end of VIC-II registers ----
 
 ; ---- CIA 6526 1 & 2 registers ----
 
-		memory  ubyte  CIA1PRA		= $DC00		; CIA 1 DRA, keyboard column drive
-		memory  ubyte  CIA1PRB		= $DC01		; CIA 1 DRB, keyboard row port
+		memory  ubyte  CIA1PRA		= $DC00		; CIA 1 DRA, keyboard column drive (and joystick control port #2)
+		memory  ubyte  CIA1PRB		= $DC01		; CIA 1 DRB, keyboard row port (and joystick control port #1)
 		memory  ubyte  CIA1DDRA		= $DC02		; CIA 1 DDRA, keyboard column
 		memory  ubyte  CIA1DDRB		= $DC03		; CIA 1 DDRB, keyboard row
 		memory  ubyte  CIA1TAL		= $DC04		; CIA 1 timer A low byte

compiler/res/prog8lib/c64utils.p8

@@ -99,6 +99,10 @@ asmsub  uword2bcd  (uword value @ AY) -> clobbers(A,Y) -> ()  {
 	%asm {{
 		sta  c64.SCRATCH_ZPB1
 		sty  c64.SCRATCH_ZPREG
+		php
+		pla             ; read status register
+		and  #%00000100
+		sta  _had_irqd
 		sei				; disable interrupts because of bcd math
 		sed				; switch to decimal mode
 		lda  #0				; ensure the result is clear
@@ -121,8 +125,11 @@ asmsub  uword2bcd  (uword value @ AY) -> clobbers(A,Y) -> ()  {
 		dey				; and repeat for next bit
 		bne  -
 		cld				; back to binary
-		cli				; enable interrupts again      @todo don't re-enable if it wasn't enabled before
-		rts
+		lda  _had_irqd
+		bne  +
+		cli				; enable interrupts again (only if they were enabled before)
++		rts
+_had_irqd  .byte  0
 	}}
 }
 
@@ -713,27 +720,6 @@ asmsub  print (str text @ AY) -> clobbers(A,Y) -> ()  {
 }
 
 
-asmsub  print_p  (str_p text @ AY) -> clobbers(A) -> (ubyte @ Y)  {
-	; ---- print pstring (length as first byte) from A/Y, returns str len in Y
-	%asm {{
-		sta  c64.SCRATCH_ZPB1
-		sty  c64.SCRATCH_ZPREG
-		stx  c64.SCRATCH_ZPREGX
-		ldy  #0
-		lda  (c64.SCRATCH_ZPB1),y
-		beq  +
-		tax
--		iny
-		lda  (c64.SCRATCH_ZPB1),y
-		jsr  c64.CHROUT
-		dex
-		bne  -
-+		ldx  c64.SCRATCH_ZPREGX
-		rts 		; output string length is in 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 {{
@@ -763,13 +749,12 @@ _print_byte_digits
 		bne  _print_hundreds
 		cpx  #'0'
 		bne  _print_tens
-		pla
-		jmp  c64.CHROUT
+		jmp  _end
 _print_hundreds	tya
 		jsr  c64.CHROUT
 _print_tens	txa
 		jsr  c64.CHROUT
-		pla
+_end		pla
 		jsr  c64.CHROUT
 		ldx  c64.SCRATCH_ZPREGX
 		rts
@@ -973,6 +958,25 @@ _screenrows	.word  $0400 + range(0, 1000, 40)
 	}}
 }
 
+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
+		asl  a
+		tay
+		lda  setchr._screenrows+1,y
+		sta  _mod+2
+		lda  setchr._screenrows,y
+		clc
+		adc  c64.SCRATCH_ZPB1
+		sta  _mod+1
+		bcc  _mod
+		inc  _mod+2
+_mod		lda  $ffff		; modified
+		rts
+	}}
+}
+
 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 {{
@@ -995,6 +999,24 @@ _colorrows	.word  $d800 + range(0, 1000, 40)
 	}}
 }
 
+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
+		asl  a
+		tay
+		lda  setclr._colorrows+1,y
+		sta  _mod+2
+		lda  setclr._colorrows,y
+		clc
+		adc  c64.SCRATCH_ZPB1
+		sta  _mod+1
+		bcc  _mod
+		inc  _mod+2
+_mod		lda  $ffff		; modified
+		rts
+	}}
+}
 
 sub  setcc  (ubyte column, ubyte row, ubyte char, ubyte color)  {
 	; ---- set char+color at the given position on the screen

compiler/res/prog8lib/math.asm

@@ -241,26 +241,24 @@ mul_byte_3	.proc
 		.pend
 		
 mul_word_3	.proc
-		; W + W*2
-		lda  c64.ESTACK_LO+1,x
-		sta  c64.SCRATCH_ZPWORD1
+		; W*2 + W
 		lda  c64.ESTACK_HI+1,x
-		sta  c64.SCRATCH_ZPWORD1+1
-		asl  c64.SCRATCH_ZPWORD1
-		rol  c64.SCRATCH_ZPWORD1+1
+		sta  c64.SCRATCH_ZPREG
+		lda  c64.ESTACK_LO+1,x
+		asl  a
+		rol  c64.SCRATCH_ZPREG
 		clc
-		lda  c64.ESTACK_LO+1,x
-		adc  c64.SCRATCH_ZPWORD1
+		adc  c64.ESTACK_LO+1,x
 		sta  c64.ESTACK_LO+1,x
-		lda  c64.ESTACK_HI+1,x
-		adc  c64.SCRATCH_ZPWORD1+1
+		lda  c64.SCRATCH_ZPREG
+		adc  c64.ESTACK_HI+1,x
 		sta  c64.ESTACK_HI+1,x
 		rts
 		.pend
 		
 
 mul_byte_5	.proc
-		; X + X*4
+		; X*4 + X
 		lda  c64.ESTACK_LO+1,x
 		asl  a
 		asl  a
@@ -271,58 +269,49 @@ mul_byte_5	.proc
 		.pend
 
 mul_word_5	.proc
-		; W + W*4
-		lda  c64.ESTACK_LO+1,x
-		sta  c64.SCRATCH_ZPWORD1
+		; W*4 + W
 		lda  c64.ESTACK_HI+1,x
-		sta  c64.SCRATCH_ZPWORD1+1
-		asl  c64.SCRATCH_ZPWORD1
-		rol  c64.SCRATCH_ZPWORD1+1
-		asl  c64.SCRATCH_ZPWORD1
-		rol  c64.SCRATCH_ZPWORD1+1
+		sta  c64.SCRATCH_ZPREG
+		lda  c64.ESTACK_LO+1,x
+		asl  a
+		rol  c64.SCRATCH_ZPREG
+		asl  a
+		rol  c64.SCRATCH_ZPREG
 		clc
-		lda  c64.ESTACK_LO+1,x
-		adc  c64.SCRATCH_ZPWORD1
+		adc  c64.ESTACK_LO+1,x
 		sta  c64.ESTACK_LO+1,x
-		lda  c64.ESTACK_HI+1,x
-		adc  c64.SCRATCH_ZPWORD1+1
+		lda  c64.SCRATCH_ZPREG
+		adc  c64.ESTACK_HI+1,x
 		sta  c64.ESTACK_HI+1,x
 		rts
 		.pend
 
 		
 mul_byte_6	.proc
-		; X*2 + X*4
+		; (X*2 + X)*2
 		lda  c64.ESTACK_LO+1,x
 		asl  a
-		sta  c64.SCRATCH_ZPREG
+                clc
+		adc  c64.ESTACK_LO+1,x
 		asl  a
-		clc
-		adc  c64.SCRATCH_ZPREG
 		sta  c64.ESTACK_LO+1,x
 		rts
 		.pend
 
 mul_word_6	.proc
-		; W*2 + W*4
-		lda  c64.ESTACK_LO+1,x
-		sta  c64.SCRATCH_ZPWORD1
+		; (W*2 + W)*2
 		lda  c64.ESTACK_HI+1,x
-		sta  c64.SCRATCH_ZPWORD1+1
-		asl  c64.SCRATCH_ZPWORD1
-		rol  c64.SCRATCH_ZPWORD1+1
-		lda  c64.SCRATCH_ZPWORD1
-		sta  c64.SCRATCH_ZPWORD2
-		lda  c64.SCRATCH_ZPWORD1+1
-		sta  c64.SCRATCH_ZPWORD2+1
-		asl  c64.SCRATCH_ZPWORD2
-		rol  c64.SCRATCH_ZPWORD2+1
+		sta  c64.SCRATCH_ZPREG
+		lda  c64.ESTACK_LO+1,x
+		asl  a
+		rol  c64.SCRATCH_ZPREG
 		clc
-		lda  c64.SCRATCH_ZPWORD1
-		adc  c64.SCRATCH_ZPWORD2
+		adc  c64.ESTACK_LO+1,x
 		sta  c64.ESTACK_LO+1,x
-		lda  c64.SCRATCH_ZPWORD1+1
-		adc  c64.SCRATCH_ZPWORD2+1
+		lda  c64.SCRATCH_ZPREG
+		adc  c64.ESTACK_HI+1,x
+		asl  c64.ESTACK_LO+1,x
+                rol  a
 		sta  c64.ESTACK_HI+1,x
 		rts
 		.pend
@@ -341,29 +330,26 @@ mul_byte_7	.proc
 		
 mul_word_7	.proc
 		; W*8 - W
-		lda  c64.ESTACK_LO+1,x
-		sta  c64.SCRATCH_ZPWORD1
 		lda  c64.ESTACK_HI+1,x
-		sta  c64.SCRATCH_ZPWORD1+1
-		asl  c64.SCRATCH_ZPWORD1
-		rol  c64.SCRATCH_ZPWORD1+1
-		asl  c64.SCRATCH_ZPWORD1
-		rol  c64.SCRATCH_ZPWORD1+1
-		asl  c64.SCRATCH_ZPWORD1
-		rol  c64.SCRATCH_ZPWORD1+1
-		lda  c64.SCRATCH_ZPWORD1
+		sta  c64.SCRATCH_ZPREG
+		lda  c64.ESTACK_LO+1,x
+		asl  a
+		rol  c64.SCRATCH_ZPREG
+		asl  a
+		rol  c64.SCRATCH_ZPREG
+		asl  a
+		rol  c64.SCRATCH_ZPREG
 		sec
-		lda  c64.SCRATCH_ZPWORD1
 		sbc  c64.ESTACK_LO+1,x
 		sta  c64.ESTACK_LO+1,x
-		lda  c64.SCRATCH_ZPWORD1+1
+		lda  c64.SCRATCH_ZPREG
 		sbc  c64.ESTACK_HI+1,x
 		sta  c64.ESTACK_HI+1,x
 		rts
 		.pend
 
 mul_byte_9	.proc
-		; X + X*8
+		; X*8 + X
 		lda  c64.ESTACK_LO+1,x
 		asl  a
 		asl  a
@@ -375,80 +361,67 @@ mul_byte_9	.proc
 		.pend
 
 mul_word_9	.proc
-		; W + W*8
-		lda  c64.ESTACK_LO+1,x
-		sta  c64.SCRATCH_ZPWORD1
+		; W*8 + W
 		lda  c64.ESTACK_HI+1,x
-		sta  c64.SCRATCH_ZPWORD1+1
-		asl  c64.SCRATCH_ZPWORD1
-		rol  c64.SCRATCH_ZPWORD1+1
-		asl  c64.SCRATCH_ZPWORD1
-		rol  c64.SCRATCH_ZPWORD1+1
-		asl  c64.SCRATCH_ZPWORD1
-		rol  c64.SCRATCH_ZPWORD1+1
+		sta  c64.SCRATCH_ZPREG
+		lda  c64.ESTACK_LO+1,x
+		asl  a
+		rol  c64.SCRATCH_ZPREG
+		asl  a
+		rol  c64.SCRATCH_ZPREG
+		asl  a
+		rol  c64.SCRATCH_ZPREG
 		clc
-		lda  c64.ESTACK_LO+1,x
-		adc  c64.SCRATCH_ZPWORD1
+		adc  c64.ESTACK_LO+1,x
 		sta  c64.ESTACK_LO+1,x
-		lda  c64.ESTACK_HI+1,x
-		adc  c64.SCRATCH_ZPWORD1+1
+		lda  c64.SCRATCH_ZPREG
+		adc  c64.ESTACK_HI+1,x
 		sta  c64.ESTACK_HI+1,x
 		rts
 		.pend
 
 mul_byte_10	.proc
-		; X + X + X*8
+		; (X*4 + X)*2
 		lda  c64.ESTACK_LO+1,x
 		asl  a
 		asl  a
+		clc
+		adc  c64.ESTACK_LO+1,x
 		asl  a
-		clc
-		adc  c64.ESTACK_LO+1,x
-		clc
-		adc  c64.ESTACK_LO+1,x
 		sta  c64.ESTACK_LO+1,x
 		rts
 		.pend
 
 mul_word_10	.proc
-		; W*2 + W*8
-		lda  c64.ESTACK_LO+1,x
-		sta  c64.SCRATCH_ZPWORD1
+		; (W*4 + W)*2
 		lda  c64.ESTACK_HI+1,x
-		sta  c64.SCRATCH_ZPWORD1+1
-		asl  c64.SCRATCH_ZPWORD1
-		rol  c64.SCRATCH_ZPWORD1+1
-		lda  c64.SCRATCH_ZPWORD1
-		sta  c64.SCRATCH_ZPWORD2
-		lda  c64.SCRATCH_ZPWORD1+1
-		sta  c64.SCRATCH_ZPWORD2+1
-		asl  c64.SCRATCH_ZPWORD2
-		rol  c64.SCRATCH_ZPWORD2+1
-		asl  c64.SCRATCH_ZPWORD2
-		rol  c64.SCRATCH_ZPWORD2+1
+		sta  c64.SCRATCH_ZPREG
+		lda  c64.ESTACK_LO+1,x
+		asl  a
+		rol  c64.SCRATCH_ZPREG
+		asl  a
+		rol  c64.SCRATCH_ZPREG
 		clc
-		lda  c64.SCRATCH_ZPWORD1
-		adc  c64.SCRATCH_ZPWORD2
+		adc  c64.ESTACK_LO+1,x
 		sta  c64.ESTACK_LO+1,x
-		lda  c64.SCRATCH_ZPWORD1+1
-		adc  c64.SCRATCH_ZPWORD2+1
+		lda  c64.SCRATCH_ZPREG
+		adc  c64.ESTACK_HI+1,x
+		asl  c64.ESTACK_LO+1,x
+                rol  a
 		sta  c64.ESTACK_HI+1,x
 		rts
 		.pend
 		
 mul_byte_11	.proc
-		; X + X + X + X*8
+		; (X*2 + X)*4 - X
 		lda  c64.ESTACK_LO+1,x
-		sta  c64.SCRATCH_ZPREG
-		asl  a
-		asl  a
 		asl  a
 		clc
-		adc  c64.SCRATCH_ZPREG
-		clc
-		adc  c64.SCRATCH_ZPREG
-		clc
-		adc  c64.SCRATCH_ZPREG
+		adc  c64.ESTACK_LO+1,x
+		asl  a
+		asl  a
+		sec
+		sbc  c64.ESTACK_LO+1,x
 		sta  c64.ESTACK_LO+1,x
 		rts
 		.pend
@@ -456,58 +429,47 @@ mul_byte_11	.proc
 ; mul_word_11 is skipped (too much code)
 
 mul_byte_12	.proc
-		; X*4 + X*8
+		; (X*2 + X)*4
 		lda  c64.ESTACK_LO+1,x
 		asl  a
-		asl  a
-		sta  c64.SCRATCH_ZPREG
-		asl  a
 		clc
-		adc  c64.SCRATCH_ZPREG
+		adc  c64.ESTACK_LO+1,x
+		asl  a
+		asl  a
 		sta  c64.ESTACK_LO+1,x
 		rts
 		.pend
 
 mul_word_12	.proc
-		; W*4 + W*8
-		lda  c64.ESTACK_LO+1,x
-		sta  c64.SCRATCH_ZPWORD1
+		; (W*2 + W)*4
 		lda  c64.ESTACK_HI+1,x
-		sta  c64.SCRATCH_ZPWORD1+1
-		asl  c64.SCRATCH_ZPWORD1
-		rol  c64.SCRATCH_ZPWORD1+1
-		asl  c64.SCRATCH_ZPWORD1
-		rol  c64.SCRATCH_ZPWORD1+1
-		lda  c64.SCRATCH_ZPWORD1
-		sta  c64.SCRATCH_ZPWORD2
-		lda  c64.SCRATCH_ZPWORD1+1
-		sta  c64.SCRATCH_ZPWORD2+1
-		asl  c64.SCRATCH_ZPWORD2
-		rol  c64.SCRATCH_ZPWORD2+1
+		sta  c64.SCRATCH_ZPREG
+		lda  c64.ESTACK_LO+1,x
+		asl  a
+		rol  c64.SCRATCH_ZPREG
 		clc
-		lda  c64.SCRATCH_ZPWORD1
-		adc  c64.SCRATCH_ZPWORD2
+		adc  c64.ESTACK_LO+1,x
 		sta  c64.ESTACK_LO+1,x
-		lda  c64.SCRATCH_ZPWORD1+1
-		adc  c64.SCRATCH_ZPWORD2+1
+		lda  c64.SCRATCH_ZPREG
+		adc  c64.ESTACK_HI+1,x
+		asl  c64.ESTACK_LO+1,x
+                rol  a
+		asl  c64.ESTACK_LO+1,x
+                rol  a
 		sta  c64.ESTACK_HI+1,x
 		rts
 		.pend
 
 mul_byte_13	.proc
-		; X*16 - X -X -X
+		; (X*2 + X)*4 + X
 		lda  c64.ESTACK_LO+1,x
-		sta  c64.SCRATCH_ZPREG
+		asl  a
+                clc
+		adc  c64.ESTACK_LO+1,x
 		asl  a
 		asl  a
-		asl  a
-		asl  a
-		sec
-		sbc  c64.SCRATCH_ZPREG
-		sec
-		sbc  c64.SCRATCH_ZPREG
-		sec
-		sbc  c64.SCRATCH_ZPREG
+                clc
+		adc  c64.ESTACK_LO+1,x
 		sta  c64.ESTACK_LO+1,x
 		rts
 		.pend
@@ -515,16 +477,14 @@ mul_byte_13	.proc
 ; mul_word_13 is skipped (too much code)
 
 mul_byte_14	.proc
-		; X*16 - X -X
+		; (X*8 - X)*2
 		lda  c64.ESTACK_LO+1,x
 		asl  a
 		asl  a
 		asl  a
-		asl  a
-		sec
-		sbc  c64.ESTACK_LO+1,x
-		sec
+                sec
 		sbc  c64.ESTACK_LO+1,x
+                asl  a
 		sta  c64.ESTACK_LO+1,x
 		rts
 		.pend
@@ -534,7 +494,6 @@ mul_byte_14	.proc
 mul_byte_15	.proc
 		; X*16 - X
 		lda  c64.ESTACK_LO+1,x
-		sta  c64.SCRATCH_ZPREG
 		asl  a
 		asl  a
 		asl  a
@@ -547,80 +506,70 @@ mul_byte_15	.proc
 
 mul_word_15	.proc
 		; W*16 - W
-		lda  c64.ESTACK_LO+1,x
-		sta  c64.SCRATCH_ZPWORD1
 		lda  c64.ESTACK_HI+1,x
-		sta  c64.SCRATCH_ZPWORD1+1
-		asl  c64.SCRATCH_ZPWORD1
-		rol  c64.SCRATCH_ZPWORD1+1
-		asl  c64.SCRATCH_ZPWORD1
-		rol  c64.SCRATCH_ZPWORD1+1
-		asl  c64.SCRATCH_ZPWORD1
-		rol  c64.SCRATCH_ZPWORD1+1
-		asl  c64.SCRATCH_ZPWORD1
-		rol  c64.SCRATCH_ZPWORD1+1
+		sta  c64.SCRATCH_ZPREG
+		lda  c64.ESTACK_LO+1,x
+		asl  a
+		rol  c64.SCRATCH_ZPREG
+		asl  a
+		rol  c64.SCRATCH_ZPREG
+		asl  a
+		rol  c64.SCRATCH_ZPREG
+		asl  a
+		rol  c64.SCRATCH_ZPREG
 		sec
-		lda  c64.SCRATCH_ZPWORD1
 		sbc  c64.ESTACK_LO+1,x
 		sta  c64.ESTACK_LO+1,x
-		lda  c64.SCRATCH_ZPWORD1+1
+		lda  c64.SCRATCH_ZPREG
 		sbc  c64.ESTACK_HI+1,x
 		sta  c64.ESTACK_HI+1,x
 		rts
 		.pend
 
 mul_byte_20	.proc
-		; X*4 + X*16
+		; (X*4 + X)*4
 		lda  c64.ESTACK_LO+1,x
 		asl  a
 		asl  a
-		sta  c64.SCRATCH_ZPREG
-		asl  a
-		asl  a
 		clc
-		adc  c64.SCRATCH_ZPREG
+		adc  c64.ESTACK_LO+1,x
+		asl  a
+		asl  a
 		sta  c64.ESTACK_LO+1,x
 		rts
 		.pend
 
 mul_word_20	.proc
-		; W*4 + W*16
-		lda  c64.ESTACK_LO+1,x
-		sta  c64.SCRATCH_ZPWORD1
+		; (W*4 + W)*4
 		lda  c64.ESTACK_HI+1,x
-		sta  c64.SCRATCH_ZPWORD1+1
-		asl  c64.SCRATCH_ZPWORD1
-		rol  c64.SCRATCH_ZPWORD1+1
-		asl  c64.SCRATCH_ZPWORD1
-		rol  c64.SCRATCH_ZPWORD1+1
-		lda  c64.SCRATCH_ZPWORD1
-		sta  c64.SCRATCH_ZPWORD2
-		lda  c64.SCRATCH_ZPWORD1+1
-		sta  c64.SCRATCH_ZPWORD2+1
-		asl  c64.SCRATCH_ZPWORD2
-		rol  c64.SCRATCH_ZPWORD2+1
-		asl  c64.SCRATCH_ZPWORD2
-		rol  c64.SCRATCH_ZPWORD2+1
+		sta  c64.SCRATCH_ZPREG
+		lda  c64.ESTACK_LO+1,x
+		asl  a
+		rol  c64.SCRATCH_ZPREG
+		asl  a
+		rol  c64.SCRATCH_ZPREG
 		clc
-		lda  c64.SCRATCH_ZPWORD1
-		adc  c64.SCRATCH_ZPWORD2
+		adc  c64.ESTACK_LO+1,x
 		sta  c64.ESTACK_LO+1,x
-		lda  c64.SCRATCH_ZPWORD1+1
-		adc  c64.SCRATCH_ZPWORD2+1
+		lda  c64.SCRATCH_ZPREG
+		adc  c64.ESTACK_HI+1,x
+		asl  c64.ESTACK_LO+1,x
+                rol  a
+		asl  c64.ESTACK_LO+1,x
+                rol  a
 		sta  c64.ESTACK_HI+1,x
 		rts
 		.pend
 
 mul_byte_25	.proc
-		; X + X*8 + X*16
+		; (X*2 + X)*8 + X
 		lda  c64.ESTACK_LO+1,x
 		asl  a
-		asl  a
-		asl  a
-		sta  c64.SCRATCH_ZPREG
-		asl  a
 		clc
-		adc  c64.SCRATCH_ZPREG
+		adc  c64.ESTACK_LO+1,x
+		asl  a
+		asl  a
+		asl  a
 		clc
 		adc  c64.ESTACK_LO+1,x
 		sta  c64.ESTACK_LO+1,x
@@ -629,76 +578,68 @@ mul_byte_25	.proc
 
 mul_word_25	.proc
 		; W + W*8 + W*16
-		lda  c64.ESTACK_LO+1,x
-		sta  c64.SCRATCH_ZPWORD1
 		lda  c64.ESTACK_HI+1,x
 		sta  c64.SCRATCH_ZPWORD1+1
-		asl  c64.SCRATCH_ZPWORD1
-		rol  c64.SCRATCH_ZPWORD1+1
-		asl  c64.SCRATCH_ZPWORD1
-		rol  c64.SCRATCH_ZPWORD1+1
-		asl  c64.SCRATCH_ZPWORD1
-		rol  c64.SCRATCH_ZPWORD1+1
-		clc
 		lda  c64.ESTACK_LO+1,x
-		adc  c64.SCRATCH_ZPWORD1
+		asl  a
+		rol  c64.SCRATCH_ZPWORD1+1
+		asl  a
+		rol  c64.SCRATCH_ZPWORD1+1
+		asl  a
+		rol  c64.SCRATCH_ZPWORD1+1
+		sta  c64.SCRATCH_ZPWORD1
+		clc
+		adc  c64.ESTACK_LO+1,x
 		sta  c64.ESTACK_LO+1,x
-		lda  c64.ESTACK_HI+1,x
-		adc  c64.SCRATCH_ZPWORD1+1
+		lda  c64.SCRATCH_ZPWORD1+1
+		adc  c64.ESTACK_HI+1,x
 		sta  c64.ESTACK_HI+1,x
-		asl  c64.SCRATCH_ZPWORD1
+		lda  c64.SCRATCH_ZPWORD1
+		asl  a
 		rol  c64.SCRATCH_ZPWORD1+1
 		clc
-		lda  c64.ESTACK_LO+1,x
-		adc  c64.SCRATCH_ZPWORD1
+		adc  c64.ESTACK_LO+1,x
 		sta  c64.ESTACK_LO+1,x
-		lda  c64.ESTACK_HI+1,x
-		adc  c64.SCRATCH_ZPWORD1+1
+		lda  c64.SCRATCH_ZPWORD1+1
+		adc  c64.ESTACK_HI+1,x
 		sta  c64.ESTACK_HI+1,x
 		rts
 		.pend		
 
 mul_byte_40	.proc
-		; X*8 + X*32
+		; (X*4 + X)*8
 		lda  c64.ESTACK_LO+1,x
 		asl  a
 		asl  a
+                clc
+		adc  c64.ESTACK_LO+1,x
 		asl  a
-		sta  c64.SCRATCH_ZPREG
 		asl  a
 		asl  a
-		clc
-		adc  c64.SCRATCH_ZPREG
 		sta  c64.ESTACK_LO+1,x
 		rts
 		.pend
 		
 mul_word_40	.proc
-		; W*8 + W*32
-		lda  c64.ESTACK_LO+1,x
-		sta  c64.SCRATCH_ZPWORD1
+		; (W*4 + W)*8
 		lda  c64.ESTACK_HI+1,x
-		sta  c64.SCRATCH_ZPWORD1+1
-		asl  c64.SCRATCH_ZPWORD1
-		rol  c64.SCRATCH_ZPWORD1+1
-		asl  c64.SCRATCH_ZPWORD1
-		rol  c64.SCRATCH_ZPWORD1+1
-		asl  c64.SCRATCH_ZPWORD1
-		rol  c64.SCRATCH_ZPWORD1+1
-		lda  c64.SCRATCH_ZPWORD1
-		sta  c64.ESTACK_LO+1,x
-		lda  c64.SCRATCH_ZPWORD1+1
-		sta  c64.ESTACK_HI+1,x
-		asl  c64.SCRATCH_ZPWORD1
-		rol  c64.SCRATCH_ZPWORD1+1
-		asl  c64.SCRATCH_ZPWORD1
-		rol  c64.SCRATCH_ZPWORD1+1
+		sta  c64.SCRATCH_ZPREG
+		lda  c64.ESTACK_LO+1,x
+		asl  a
+		rol  c64.SCRATCH_ZPREG
+		asl  a
+		rol  c64.SCRATCH_ZPREG
 		clc
-		lda  c64.ESTACK_LO+1,x
-		adc  c64.SCRATCH_ZPWORD1
+		adc  c64.ESTACK_LO+1,x
 		sta  c64.ESTACK_LO+1,x
-		lda  c64.ESTACK_HI+1,x
-		adc  c64.SCRATCH_ZPWORD1+1
+		lda  c64.SCRATCH_ZPREG
+		adc  c64.ESTACK_HI+1,x
+		asl  c64.ESTACK_LO+1,x
+                rol  a
+		asl  c64.ESTACK_LO+1,x
+                rol  a
+		asl  c64.ESTACK_LO+1,x
+                rol  a
 		sta  c64.ESTACK_HI+1,x
 		rts
 		.pend

compiler/res/prog8lib/prog8lib.asm

@@ -49,19 +49,17 @@ add_a_to_zpword	.proc
 pop_index_times_5	.proc
 		inx
 		lda  c64.ESTACK_LO,x
-		sta  c64.SCRATCH_ZPB1
 		asl  a
 		asl  a
 		clc
-		adc  c64.SCRATCH_ZPB1	; A*=5
+		adc  c64.ESTACK_LO,x
 		rts
 		.pend
 
 neg_b		.proc
-		lda  c64.ESTACK_LO+1,x
-		eor  #255
-		clc
-		adc  #1
+		lda  #0
+		sec
+		sbc  c64.ESTACK_LO+1,x
 		sta  c64.ESTACK_LO+1,x
 		rts
 		.pend
@@ -90,10 +88,9 @@ inv_word	.proc
 not_byte	.proc
 		lda  c64.ESTACK_LO+1,x
 		beq  +
-		lda  #0
-		beq ++
-+		lda  #1
-+		sta  c64.ESTACK_LO+1,x
+		lda  #1
++		eor  #1
+		sta  c64.ESTACK_LO+1,x
 		rts
 		.pend
 
@@ -101,13 +98,168 @@ not_word	.proc
 		lda  c64.ESTACK_LO + 1,x
 		ora  c64.ESTACK_HI + 1,x
 		beq  +
-		lda  #0
-		beq  ++
-+		lda  #1
-+		sta  c64.ESTACK_LO + 1,x
+		lda  #1
++		eor  #1
+		sta  c64.ESTACK_LO + 1,x
+		lsr  a
 		sta  c64.ESTACK_HI + 1,x
 		rts
 		.pend
+		
+bitand_b	.proc
+		; -- bitwise and (of 2 bytes)
+		lda  c64.ESTACK_LO+2,x
+		and  c64.ESTACK_LO+1,x
+		inx
+		sta  c64.ESTACK_LO+1,x
+		rts
+		.pend
+		
+bitor_b		.proc
+		; -- bitwise or (of 2 bytes)
+		lda  c64.ESTACK_LO+2,x
+		ora  c64.ESTACK_LO+1,x
+		inx
+		sta  c64.ESTACK_LO+1,x
+		rts
+		.pend
+		
+bitxor_b	.proc
+		; -- bitwise xor (of 2 bytes)
+		lda  c64.ESTACK_LO+2,x
+		eor  c64.ESTACK_LO+1,x
+		inx
+		sta  c64.ESTACK_LO+1,x
+		rts
+		.pend
+
+bitand_w	.proc
+		; -- bitwise and (of 2 words)
+		lda  c64.ESTACK_LO+2,x
+		and  c64.ESTACK_LO+1,x
+		sta  c64.ESTACK_LO+2,x
+		lda  c64.ESTACK_HI+2,x
+		and  c64.ESTACK_HI+1,x
+		sta  c64.ESTACK_HI+2,x
+		inx
+		rts
+		.pend
+		
+bitor_w		.proc
+		; -- bitwise or (of 2 words)
+		lda  c64.ESTACK_LO+2,x
+		ora  c64.ESTACK_LO+1,x
+		sta  c64.ESTACK_LO+2,x
+		lda  c64.ESTACK_HI+2,x
+		ora  c64.ESTACK_HI+1,x
+		sta  c64.ESTACK_HI+2,x
+		inx
+		rts
+		.pend
+		
+bitxor_w	.proc
+		; -- bitwise xor (of 2 bytes)
+		lda  c64.ESTACK_LO+2,x
+		eor  c64.ESTACK_LO+1,x
+		sta  c64.ESTACK_LO+2,x
+		lda  c64.ESTACK_HI+2,x
+		eor  c64.ESTACK_HI+1,x
+		sta  c64.ESTACK_HI+2,x
+		inx
+		rts
+		.pend
+		
+and_b		.proc
+		; -- logical and (of 2 bytes)
+		lda  c64.ESTACK_LO+2,x
+		beq  +
+		lda  #1
++		sta  c64.SCRATCH_ZPB1
+		lda  c64.ESTACK_LO+1,x
+		beq  +
+		lda  #1
++		and  c64.SCRATCH_ZPB1
+		inx
+		sta  c64.ESTACK_LO+1,x
+		rts
+		.pend
+		
+or_b		.proc
+		; -- logical or (of 2 bytes)
+		lda  c64.ESTACK_LO+2,x
+		ora  c64.ESTACK_LO+1,x
+		beq  +
+		lda  #1
++		inx
+		sta  c64.ESTACK_LO+1,x
+		rts
+		.pend
+		
+xor_b		.proc
+		; -- logical xor (of 2 bytes)
+		lda  c64.ESTACK_LO+2,x
+		beq  +
+		lda  #1
++		sta  c64.SCRATCH_ZPB1
+		lda  c64.ESTACK_LO+1,x
+		beq  +
+		lda  #1
++		eor  c64.SCRATCH_ZPB1
+		inx
+		sta  c64.ESTACK_LO+1,x
+		rts
+		.pend
+
+and_w		.proc
+		; -- logical and (word and word -> byte)
+		lda  c64.ESTACK_LO+2,x
+		ora  c64.ESTACK_HI+2,x
+		beq  +
+		lda  #1
++		sta  c64.SCRATCH_ZPB1
+		lda  c64.ESTACK_LO+1,x
+		ora  c64.ESTACK_HI+1,x
+		beq  +
+		lda  #1
++		and  c64.SCRATCH_ZPB1
+		inx
+ 		sta  c64.ESTACK_LO+1,x
+ 		sta  c64.ESTACK_HI+1,x
+		rts
+		.pend
+		
+or_w		.proc
+		; -- logical or (word or word -> byte)
+		lda  c64.ESTACK_LO+2,x
+		ora  c64.ESTACK_LO+1,x
+		ora  c64.ESTACK_HI+2,x
+		ora  c64.ESTACK_HI+1,x
+		beq  +
+		lda  #1
++		inx
+		sta  c64.ESTACK_LO+1,x
+		sta  c64.ESTACK_HI+1,x
+		rts
+		.pend
+		
+xor_w		.proc
+		; -- logical xor (word xor word -> byte)
+		lda  c64.ESTACK_LO+2,x
+		ora  c64.ESTACK_HI+2,x
+		beq  +
+		lda  #1
++		sta  c64.SCRATCH_ZPB1
+		lda  c64.ESTACK_LO+1,x
+		ora  c64.ESTACK_HI+1,x
+		beq  +
+		lda  #1
++		eor  c64.SCRATCH_ZPB1
+		inx
+ 		sta  c64.ESTACK_LO+1,x
+ 		sta  c64.ESTACK_HI+1,x
+		rts
+		.pend
+
 
 abs_b		.proc
 	; -- push abs(byte) on stack (as byte)
@@ -300,25 +452,18 @@ equal_w		.proc
 
 notequal_b	.proc
 	; -- are the two bytes on the stack different?
-		inx
-		lda  c64.ESTACK_LO,x
-		eor  c64.ESTACK_LO+1,x
-		sta  c64.ESTACK_LO+1,x
-		rts
+		lda  c64.ESTACK_LO+1,x
+		cmp  c64.ESTACK_LO+2,x
+		beq  equal_b._equal_b_false
+		bne  equal_b._equal_b_true
 		.pend
 
 notequal_w	.proc
 	; -- are the two words on the stack different?
-		inx
-		lda  c64.ESTACK_LO,x
-		eor  c64.ESTACK_LO+1,x
-		beq  +
-		sta  c64.ESTACK_LO+1,x
-		rts
-+		lda  c64.ESTACK_HI,x
-		eor  c64.ESTACK_HI+1,x
-		sta  c64.ESTACK_LO+1,x
-		rts
+		lda  c64.ESTACK_HI+1,x
+		cmp  c64.ESTACK_HI+2,x
+		beq  notequal_b
+		bne  equal_b._equal_b_true
 		.pend
 
 less_ub		.proc
@@ -375,11 +520,10 @@ _equal_b_false	lda  #0
 		.pend
 
 lesseq_ub	.proc
-		lda  c64.ESTACK_LO+2,x
-		cmp  c64.ESTACK_LO+1,x
-		bcc  equal_b._equal_b_true
-		beq  equal_b._equal_b_true
-		bcs  equal_b._equal_b_false
+		lda  c64.ESTACK_LO+1,x
+		cmp  c64.ESTACK_LO+2,x
+		bcs  equal_b._equal_b_true
+		bcc  equal_b._equal_b_false
 		.pend
 
 lesseq_b	.proc
@@ -496,6 +640,15 @@ greatereq_w	.proc
 		bmi  equal_b._equal_b_false
 		.pend
 
+func_read_flags	.proc
+		; -- put the processor status register on the stack
+		php
+		pla
+		sta  c64.ESTACK_LO,x
+		dex
+		rts
+		.pend
+		
 
 func_sin8	.proc
 		ldy  c64.ESTACK_LO+1,x
@@ -790,17 +943,15 @@ _loop		lda  (c64.SCRATCH_ZPWORD1),y
 func_sum_ub	.proc
 		jsr  pop_array_and_lengthmin1Y
 		lda  #0
-		sta  c64.ESTACK_LO,x
 		sta  c64.ESTACK_HI,x
--		lda  (c64.SCRATCH_ZPWORD1),y
-		clc
-		adc  c64.ESTACK_LO,x
-		sta  c64.ESTACK_LO,x
+-		clc
+		adc  (c64.SCRATCH_ZPWORD1),y
 		bcc  +
 		inc  c64.ESTACK_HI,x
 +		dey
 		cpy  #255
 		bne  -
+		sta  c64.ESTACK_LO,x
 		dex
 		rts
 		.pend

compiler/res/version.txt

@@ -1 +1 @@
-1.1 (beta)
+1.4 (beta)

compiler/src/prog8/CompilerMain.kt

@@ -46,6 +46,7 @@ private fun compileMain(args: Array<String>) {
     var moduleFile = ""
     var writeVmCode = false
     var writeAssembly = true
+    var optimize = true
     for (arg in args) {
         if(arg=="-emu")
             emulatorToStart = "x64"
@@ -55,6 +56,8 @@ private fun compileMain(args: Array<String>) {
             writeVmCode = true
         else if(arg=="-noasm")
             writeAssembly = false
+        else if(arg=="-noopt")
+            optimize = false
         else if(!arg.startsWith("-"))
             moduleFile = arg
         else
@@ -101,15 +104,19 @@ private fun compileMain(args: Array<String>) {
             }
             //println(" time4: $time4")
 
-            // optimize the parse tree
-            println("Optimizing...")
             val allScopedSymbolDefinitions = moduleAst.checkIdentifiers(heap)       // useful for checking symbol usage later?
-            while (true) {
-                // keep optimizing expressions and statements until no more steps remain
-                val optsDone1 = moduleAst.simplifyExpressions(namespace, heap)
-                val optsDone2 = moduleAst.optimizeStatements(namespace, heap)
-                if (optsDone1 + optsDone2 == 0)
-                    break
+//            moduleAst.simplifyExpressions(namespace, heap)
+//            moduleAst.optimizeStatements(namespace, heap)
+            if(optimize) {
+                // optimize the parse tree
+                println("Optimizing...")
+                while (true) {
+                    // keep optimizing expressions and statements until no more steps remain
+                    val optsDone1 = moduleAst.simplifyExpressions(namespace, heap)
+                    val optsDone2 = moduleAst.optimizeStatements(namespace, heap)
+                    if (optsDone1 + optsDone2 == 0)
+                        break
+                }
             }
 
             namespace = moduleAst.definingScope()       // create it again, it could have changed in the meantime
@@ -121,7 +128,8 @@ private fun compileMain(args: Array<String>) {
             // compile the syntax tree into stackvmProg form, and optimize that
             val compiler = Compiler(moduleAst, namespace, heap)
             val intermediate = compiler.compile(compilerOptions)
-            intermediate.optimize()
+            if(optimize)
+                intermediate.optimize()
 
             if(writeVmCode) {
                 val stackVmFilename = intermediate.name + ".vm.txt"
@@ -134,7 +142,7 @@ private fun compileMain(args: Array<String>) {
             if(writeAssembly) {
                 val zeropage = C64Zeropage(compilerOptions)
                 intermediate.allocateZeropage(zeropage)
-                val assembly = AsmGen(compilerOptions, intermediate, heap, zeropage).compileToAssembly()
+                val assembly = AsmGen(compilerOptions, intermediate, heap, zeropage).compileToAssembly(optimize)
                 assembly.assemble(compilerOptions)
                 programname = assembly.name
             }
@@ -182,7 +190,7 @@ fun determineCompilationOptions(moduleAst: Module): CompilationOptions {
     val floatsEnabled = options.any { it.name == "enable_floats" }
     val zpType: ZeropageType =
             if (zpoption == null)
-                if(floatsEnabled) ZeropageType.BASICSAFE else ZeropageType.KERNALSAFE
+                if(floatsEnabled) ZeropageType.FLOATSAFE else ZeropageType.KERNALSAFE
             else
                 try {
                     ZeropageType.valueOf(zpoption)
@@ -211,6 +219,7 @@ private fun usage() {
     System.err.println("    [-writevm]   write intermediate vm code to a file as well")
     System.err.println("    [-noasm]     don't create assembly code")
     System.err.println("    [-vm]        launch the prog8 virtual machine instead of the compiler")
+    System.err.println("    [-noopt]     don't perform optimizations")
     System.err.println("    modulefile   main module file to compile")
     exitProcess(1)
 }

compiler/src/prog8/ast/AST.kt

@@ -9,6 +9,7 @@ import prog8.compiler.target.c64.Petscii
 import prog8.functions.BuiltinFunctions
 import prog8.functions.NotConstArgumentException
 import prog8.functions.builtinFunctionReturnType
+import prog8.parser.CustomLexer
 import prog8.parser.prog8Parser
 import java.io.File
 import java.nio.file.Path
@@ -25,9 +26,7 @@ enum class DataType {
     WORD,
     FLOAT,
     STR,
-    STR_P,
     STR_S,
-    STR_PS,
     ARRAY_UB,
     ARRAY_B,
     ARRAY_UW,
@@ -37,20 +36,18 @@ enum class DataType {
     fun assignableTo(targetType: DataType) =
             // what types are assignable to others without loss of precision?
             when(this) {
-                UBYTE -> targetType == BYTE || targetType == UBYTE || targetType == UWORD || targetType==WORD || targetType == FLOAT
-                BYTE -> targetType == BYTE || targetType == UBYTE || targetType == WORD || targetType == FLOAT
+                UBYTE -> targetType == UBYTE || targetType == UWORD || targetType==WORD || targetType == FLOAT
+                BYTE -> targetType == BYTE || targetType == UBYTE || targetType == UWORD || targetType==WORD || targetType == FLOAT
                 UWORD -> targetType == UWORD || targetType == FLOAT
-                WORD -> targetType == WORD || targetType == FLOAT
+                WORD -> targetType == WORD || targetType==UWORD || targetType == FLOAT
                 FLOAT -> targetType == FLOAT
                 STR -> targetType == STR || targetType==STR_S || targetType == UWORD
-                STR_P -> targetType == STR_P || targetType==STR_PS || targetType == UWORD
                 STR_S -> targetType == STR || targetType==STR_S || targetType == UWORD
-                STR_PS -> targetType == STR_P || targetType==STR_PS || targetType == UWORD
-                ARRAY_UB -> targetType == UWORD
-                ARRAY_B -> targetType == UWORD
-                ARRAY_UW -> targetType == UWORD
-                ARRAY_W -> targetType == UWORD
-                ARRAY_F -> targetType == UWORD
+                ARRAY_UB -> targetType == UWORD || targetType==ARRAY_UB
+                ARRAY_B -> targetType == UWORD  || targetType==ARRAY_B
+                ARRAY_UW -> targetType == UWORD || targetType==ARRAY_UW
+                ARRAY_W -> targetType == UWORD || targetType==ARRAY_W
+                ARRAY_F -> targetType == UWORD || targetType==ARRAY_F
             }
 
 
@@ -97,14 +94,15 @@ enum class BranchCondition {
 
 val IterableDatatypes = setOf(
         DataType.STR, DataType.STR_S,
-        DataType.STR_P, DataType.STR_PS,  // note: these are a bit weird they store their length as the first byte
         DataType.ARRAY_UB, DataType.ARRAY_B,
         DataType.ARRAY_UW, DataType.ARRAY_W,
         DataType.ARRAY_F)
 
-val StringDatatypes = setOf(DataType.STR, DataType.STR_P, DataType.STR_S, DataType.STR_PS)
-val NumericDatatypes = setOf(DataType.UBYTE, DataType.BYTE, DataType.UWORD, DataType.WORD, DataType.FLOAT)
+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)
 
 
@@ -174,9 +172,9 @@ interface IAstProcessor {
         return functionCall
     }
 
-    fun process(functionCall: FunctionCallStatement): IStatement {
-        functionCall.arglist = functionCall.arglist.map { it.process(this) }.toMutableList()
-        return functionCall
+    fun process(functionCallStatement: FunctionCallStatement): IStatement {
+        functionCallStatement.arglist = functionCallStatement.arglist.map { it.process(this) }.toMutableList()
+        return functionCallStatement
     }
 
     fun process(identifier: IdentifierReference): IExpression {
@@ -506,11 +504,11 @@ private class GlobalNamespace(override val name: String,
 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
     val scopedname: String by lazy { makeScopedName(name).joinToString(".") }
 
-
     override fun linkParents(parent: Node) {
         this.parent = parent
         statements.forEach {it.linkParents(this)}
@@ -789,7 +787,7 @@ data class AssignTarget(val register: Register?,
 
     fun shortString(withTypePrefix: Boolean=false): String {
         if(register!=null)
-            return (if(withTypePrefix) "0register::" else "") + register.toString()
+            return (if(withTypePrefix) "0register::" else "") + register.name
         if(identifier!=null)
             return (if(withTypePrefix) "3identifier::" else "") + identifier.nameInSource.last()
         if(arrayindexed!=null)
@@ -917,8 +915,8 @@ class BinaryExpression(var left: IExpression, var operator: String, var right: I
                     else -> throw FatalAstException("arithmetic operation on incompatible datatypes: $leftDt and $rightDt")
                 }
                 DataType.BYTE -> when(rightDt) {
-                    DataType.BYTE, DataType.UBYTE -> DataType.BYTE
-                    DataType.WORD, DataType.UWORD -> DataType.WORD
+                    in ByteDatatypes -> DataType.BYTE
+                    in WordDatatypes -> DataType.WORD
                     DataType.FLOAT -> DataType.FLOAT
                     else -> throw FatalAstException("arithmetic operation on incompatible datatypes: $leftDt and $rightDt")
                 }
@@ -929,7 +927,7 @@ class BinaryExpression(var left: IExpression, var operator: String, var right: I
                     else -> throw FatalAstException("arithmetic operation on incompatible datatypes: $leftDt and $rightDt")
                 }
                 DataType.WORD -> when(rightDt) {
-                    DataType.BYTE, DataType.UBYTE, DataType.WORD, DataType.UWORD -> DataType.WORD
+                    in IntegerDatatypes -> DataType.WORD
                     DataType.FLOAT -> DataType.FLOAT
                     else -> throw FatalAstException("arithmetic operation on incompatible datatypes: $leftDt and $rightDt")
                 }
@@ -1072,8 +1070,8 @@ class LiteralValue(val type: DataType,
 
         fun fromNumber(value: Number, type: DataType, position: Position) : LiteralValue {
             return when(type) {
-                DataType.UBYTE, DataType.BYTE -> LiteralValue(type, bytevalue = value.toShort(), position = position)
-                DataType.UWORD, DataType.WORD -> LiteralValue(type, wordvalue = value.toInt(), position = position)
+                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")
             }
@@ -1109,8 +1107,8 @@ class LiteralValue(val type: DataType,
 
     init {
         when(type){
-            DataType.UBYTE, DataType.BYTE -> if(bytevalue==null) throw FatalAstException("literal value missing bytevalue")
-            DataType.UWORD, DataType.WORD -> if(wordvalue==null) throw FatalAstException("literal value missing wordvalue")
+            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(initialstrvalue==null && heapId==null) throw FatalAstException("literal value missing strvalue/heapId")
@@ -1158,14 +1156,15 @@ class LiteralValue(val type: DataType,
             DataType.UWORD -> "uword:$wordvalue"
             DataType.WORD -> "word:$wordvalue"
             DataType.FLOAT -> "float:$floatvalue"
-            DataType.STR, DataType.STR_P, DataType.STR_S, DataType.STR_PS-> {
+            in StringDatatypes -> {
                 if(heapId!=null) "str:#$heapId"
                 else "str:$initialstrvalue"
             }
-            DataType.ARRAY_UB, DataType.ARRAY_B, DataType.ARRAY_UW, DataType.ARRAY_W, DataType.ARRAY_F -> {
+            in ArrayDatatypes -> {
                 if(heapId!=null) "arrayspec:#$heapId"
                 else "arrayspec:$arrayvalue"
             }
+            else -> throw FatalAstException("weird datatype")
         }
         return "LiteralValue($vstr)"
     }
@@ -1271,7 +1270,7 @@ class LiteralValue(val type: DataType,
                         return LiteralValue(targettype, wordvalue = value, position = position)
                 }
             }
-            DataType.STR, DataType.STR_P,  DataType.STR_S, DataType.STR_PS -> {
+            in StringDatatypes -> {
                 if(targettype in StringDatatypes)
                     return this
             }
@@ -1313,9 +1312,7 @@ class RangeExpr(var from: IExpression,
             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_P && toDt==DataType.STR_P -> DataType.STR_P
             fromDt==DataType.STR_S && toDt==DataType.STR_S -> DataType.STR_S
-            fromDt==DataType.STR_PS && toDt==DataType.STR_PS -> DataType.STR_PS
             fromDt==DataType.WORD || toDt==DataType.WORD -> DataType.WORD
             fromDt==DataType.BYTE || toDt==DataType.BYTE -> DataType.BYTE
             else -> DataType.UBYTE
@@ -1647,6 +1644,40 @@ class Subroutine(override val name: String,
             .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
+    }
 }
 
 
@@ -1753,34 +1784,38 @@ class RepeatLoop(var body: AnonymousScope,
 
 /***************** Antlr Extension methods to create AST ****************/
 
-fun prog8Parser.ModuleContext.toAst(name: String, isLibrary: Boolean, importedFrom: Path) : Module =
-        Module(name, modulestatement().asSequence().map { it.toAst() }.toMutableList(), toPosition(), isLibrary, importedFrom)
-
-
-private fun ParserRuleContext.toPosition() : Position {
-    val file =
-            if(start.inputStream.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(file, start.line, start.charPositionInLine, stop.charPositionInLine+stop.text.length)
+fun prog8Parser.ModuleContext.toAst(name: String, isLibrary: Boolean, importedFrom: Path) : Module {
+    val nameWithoutSuffix = if(name.endsWith(".p8")) name.substringBeforeLast('.') else name
+    return Module(nameWithoutSuffix, modulestatement().asSequence().map { it.toAst(isLibrary) }.toMutableList(), toPosition(), isLibrary, importedFrom)
 }
 
 
-private fun prog8Parser.ModulestatementContext.toAst() : IStatement {
+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()
+    val block = block()?.toAst(isInLibrary)
     if(block!=null) return block
 
     throw FatalAstException(text)
 }
 
 
-private fun prog8Parser.BlockContext.toAst() : IStatement =
-        Block(identifier().text, integerliteral()?.toAst()?.number?.toInt(), statement_block().toAst(), toPosition())
+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> =
@@ -2039,7 +2074,11 @@ private fun prog8Parser.IntegerliteralContext.toAst(): NumericLiteral {
         var datatype = DataType.UBYTE
         when (radix) {
             10 -> {
-                integer = text.toInt()
+                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
@@ -2051,12 +2090,20 @@ private fun prog8Parser.IntegerliteralContext.toAst(): NumericLiteral {
             2 -> {
                 if(text.length>8)
                     datatype = DataType.UWORD
-                integer = text.toInt(2)
+                try {
+                    integer = text.toInt(2)
+                } catch(x: NumberFormatException) {
+                    throw AstException("${toPosition()} invalid binary literal ${x.message}")
+                }
             }
             16 -> {
                 if(text.length>2)
                     datatype = DataType.UWORD
-                integer = text.toInt(16)
+                try {
+                    integer = text.toInt(16)
+                } catch(x: NumberFormatException) {
+                    throw AstException("${toPosition()} invalid hexadecimal literal ${x.message}")
+                }
             }
             else -> throw FatalAstException("invalid radix")
         }

compiler/src/prog8/ast/AstChecker.kt

@@ -592,9 +592,10 @@ private class AstChecker(private val namespace: INameScope,
                 if(directive.parent !is Module) err("this directive may only occur at module level")
                 if(directive.args.size!=1 ||
                         directive.args[0].name != "basicsafe" &&
+                        directive.args[0].name != "floatsafe" &&
                         directive.args[0].name != "kernalsafe" &&
                         directive.args[0].name != "full")
-                    err("invalid zp type, expected basicsafe, kernalsafe, or full")
+                    err("invalid zp type, expected basicsafe, floatsafe, kernalsafe, or full")
             }
             "%zpreserved" -> {
                 if(directive.parent !is Module) err("this directive may only occur at module level")
@@ -694,10 +695,17 @@ private class AstChecker(private val namespace: INameScope,
                         checkResult.add(ExpressionError("remainder can only be used on unsigned integer operands", expr.right.position))
                 }
             }
+            "and", "or", "xor", "&", "|", "^" -> {
+                // only integer numeric operands accepted
+                val rightDt = expr.right.resultingDatatype(namespace, heap)
+                val leftDt = expr.left.resultingDatatype(namespace, heap)
+                if(leftDt !in IntegerDatatypes || rightDt !in IntegerDatatypes)
+                    checkResult.add(ExpressionError("logical or bitwise operator can only be used on integer operands", expr.right.position))
+            }
         }
 
-        val leftDt = expr.left.resultingDatatype(namespace, heap)!!
-        val rightDt = expr.right.resultingDatatype(namespace, heap)!!
+        val leftDt = expr.left.resultingDatatype(namespace, heap)
+        val rightDt = expr.right.resultingDatatype(namespace, heap)
         if(leftDt !in NumericDatatypes)
             checkResult.add(ExpressionError("left operand is not numeric", expr.left.position))
         if(rightDt!in NumericDatatypes)
@@ -769,13 +777,13 @@ private class AstChecker(private val namespace: INameScope,
         return super.process(functionCall)
     }
 
-    override fun process(functionCall: FunctionCallStatement): IStatement {
-        val targetStatement = checkFunctionOrLabelExists(functionCall.target, functionCall)
+    override fun process(functionCallStatement: FunctionCallStatement): IStatement {
+        val targetStatement = checkFunctionOrLabelExists(functionCallStatement.target, functionCallStatement)
         if(targetStatement!=null)
-            checkFunctionCall(targetStatement, functionCall.arglist, functionCall.position)
+            checkFunctionCall(targetStatement, functionCallStatement.arglist, functionCallStatement.position)
         if(targetStatement is Subroutine && targetStatement.returntypes.isNotEmpty())
-            printWarning("result value of subroutine call is discarded", functionCall.position)
-        return super.process(functionCall)
+            printWarning("result value of subroutine call is discarded", functionCallStatement.position)
+        return super.process(functionCallStatement)
     }
 
     private fun checkFunctionCall(target: IStatement, args: List<IExpression>, position: Position) {
@@ -791,7 +799,7 @@ private class AstChecker(private val namespace: INameScope,
                 for (arg in args.withIndex().zip(func.parameters)) {
                     val argDt=arg.first.value.resultingDatatype(namespace, heap)
                     if(argDt!=null && !argDt.assignableTo(arg.second.possibleDatatypes)) {
-                        checkResult.add(ExpressionError("builtin function argument ${arg.first.index + 1} has invalid type $argDt, expected ${arg.second.possibleDatatypes}", position))
+                        checkResult.add(ExpressionError("builtin function '${target.name}' argument ${arg.first.index + 1} has invalid type $argDt, expected ${arg.second.possibleDatatypes}", position))
                     }
                 }
                 if(target.name=="swap") {
@@ -815,13 +823,26 @@ private class AstChecker(private val namespace: INameScope,
                 for (arg in args.withIndex().zip(target.parameters)) {
                     val argDt = arg.first.value.resultingDatatype(namespace, heap)
                     if(argDt!=null && !argDt.assignableTo(arg.second.type))
-                        checkResult.add(ExpressionError("subroutine argument ${arg.first.index+1} has invalid type $argDt, expected ${arg.second.type}", position))
+                        checkResult.add(ExpressionError("subroutine '${target.name}' argument ${arg.first.index+1} has invalid type $argDt, expected ${arg.second.type}", position))
 
                     if(target.isAsmSubroutine) {
                         if (target.asmParameterRegisters[arg.first.index].registerOrPair in setOf(RegisterOrPair.AX, RegisterOrPair.XY, RegisterOrPair.X)) {
                             if (arg.first.value !is LiteralValue && arg.first.value !is IdentifierReference)
                                 printWarning("calling a subroutine that expects X as a parameter is problematic, more so when providing complex arguments. If you see a compiler error/crash about this later, try to simplify this call", position)
                         }
+
+                        // check if the argument types match the register(pairs)
+                        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))
+                        } 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))
+                        } 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))
+                        }
                     }
                 }
             }
@@ -869,9 +890,6 @@ private class AstChecker(private val namespace: INameScope,
                 if(index!=null && (index<0 || index>=arraysize))
                     checkResult.add(ExpressionError("array index out of bounds", arrayIndexedExpression.arrayspec.position))
             } else if(target.datatype in StringDatatypes) {
-                // check supported string tyep
-                if(target.datatype == DataType.STR_P || target.datatype==DataType.STR_PS)
-                    checkResult.add(ExpressionError("indexing pascal-strings is not supported, use regular str type instead", arrayIndexedExpression.arrayspec.position))
                 // check string lengths
                 val heapId = (target.value as LiteralValue).heapId!!
                 val stringLen = heap.get(heapId).str!!.length
@@ -894,7 +912,7 @@ private class AstChecker(private val namespace: INameScope,
         val targetStatement = target.targetStatement(namespace)
         if(targetStatement is Label || targetStatement is Subroutine || targetStatement is BuiltinFunctionStatementPlaceholder)
             return targetStatement
-        checkResult.add(SyntaxError("undefined function or subroutine: ${target.nameInSource.joinToString(".")}", statement.position))
+        checkResult.add(NameError("undefined function or subroutine: ${target.nameInSource.joinToString(".")}", statement.position))
         return null
     }
 
@@ -946,8 +964,8 @@ private class AstChecker(private val namespace: INameScope,
         when (targetDt) {
             DataType.FLOAT -> {
                 val number = when(value.type) {
-                    DataType.UBYTE, DataType.BYTE -> value.bytevalue!!.toDouble()
-                    DataType.UWORD, DataType.WORD -> value.wordvalue!!.toDouble()
+                    in ByteDatatypes -> value.bytevalue!!.toDouble()
+                    in WordDatatypes -> value.wordvalue!!.toDouble()
                     DataType.FLOAT -> value.floatvalue!!
                     else -> return err("numeric value expected")
                 }
@@ -988,7 +1006,7 @@ private class AstChecker(private val namespace: INameScope,
                 if (number < -32768 || number > 32767)
                     return err("value '$number' out of range for word")
             }
-            DataType.STR, DataType.STR_P, DataType.STR_S, DataType.STR_PS -> {
+            DataType.STR, DataType.STR_S -> {
                 if(!value.isString)
                     return err("string value expected")
                 val str = value.strvalue(heap)
@@ -1114,8 +1132,6 @@ private class AstChecker(private val namespace: INameScope,
             DataType.FLOAT -> sourceDatatype in NumericDatatypes
             DataType.STR -> sourceDatatype==DataType.STR
             DataType.STR_S -> sourceDatatype==DataType.STR_S
-            DataType.STR_P -> sourceDatatype==DataType.STR_P
-            DataType.STR_PS -> sourceDatatype==DataType.STR_PS
             else -> checkResult.add(SyntaxError("cannot assign new value to variable of type $targetDatatype", position))
         }
 
@@ -1129,9 +1145,9 @@ private class AstChecker(private val namespace: INameScope,
                 checkResult.add(ExpressionError("cannot assign word to byte, use msb() or lsb()?", position))
         }
         else if(sourceDatatype==DataType.FLOAT && targetDatatype in IntegerDatatypes)
-            checkResult.add(ExpressionError("cannot assign float to ${targetDatatype.toString().toLowerCase()}; possible loss of precision. Suggestion: round the value or revert to integer arithmetic", position))
+            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.toString().toLowerCase()} to ${targetDatatype.toString().toLowerCase()}", position))
+            checkResult.add(ExpressionError("cannot assign ${sourceDatatype.name.toLowerCase()} to ${targetDatatype.name.toLowerCase()}", position))
 
         return false
     }

compiler/src/prog8/ast/AstIdentifiersChecker.kt

@@ -33,6 +33,7 @@ fun Module.checkIdentifiers(heap: HeapValues): MutableMap<String, IStatement> {
             }
             else -> TODO("replace literalvalue by identifierref: $variable  (in $parent)")
         }
+        variable.second.linkParents(scope as Node)
     }
 
     printErrors(checker.result(), name)
@@ -124,7 +125,8 @@ private class AstIdentifiersChecker(val heap: HeapValues) : IAstProcessor {
             // NOTE:
             // - numeric types BYTE and WORD and FLOAT are passed by value;
             // - strings, arrays, matrices are passed by reference (their 16-bit address is passed as an uword parameter)
-            if(subroutine.asmAddress==null) {
+            // - do NOT do this is the statement can be transformed into an asm subroutine later!
+            if(subroutine.asmAddress==null && !subroutine.canBeAsmSubroutine) {
                 if(subroutine.asmParameterRegisters.isEmpty()) {
                     subroutine.parameters
                             .filter { it.name !in allDefinedNames }

compiler/src/prog8/ast/AstRecursionChecker.kt

@@ -92,9 +92,9 @@ private class AstRecursionChecker(private val namespace: INameScope) : IAstProce
         return listOf(AstException("Program contains recursive subroutine calls, this is not supported. Recursive chain:\n (a subroutine call in) $chain"))
     }
 
-    override fun process(functionCall: FunctionCallStatement): IStatement {
-        val scope = functionCall.definingScope()
-        val targetStatement = functionCall.target.targetStatement(namespace)
+    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
@@ -102,7 +102,7 @@ private class AstRecursionChecker(private val namespace: INameScope) : IAstProce
             }
             callGraph.add(scope, targetScope)
         }
-        return super.process(functionCall)
+        return super.process(functionCallStatement)
     }
 
     override fun process(functionCall: FunctionCall): IExpression {

compiler/src/prog8/ast/StmtReorderer.kt

@@ -33,11 +33,21 @@ private class StatementReorderer(private val namespace: INameScope, private val
         val (blocks, other) = module.statements.partition { it is Block }
         module.statements = other.asSequence().plus(blocks.sortedBy { (it as Block).address ?: Int.MAX_VALUE }).toMutableList()
 
+        // make sure user-defined blocks come BEFORE library blocks, and move the "main" block to the top of everything
+        val nonLibraryBlocks = module.statements.withIndex()
+                .filter { it.value is Block && !(it.value as Block).isInLibrary }
+                .map { it.index to it.value }
+                .reversed()
+        for(nonLibBlock in nonLibraryBlocks)
+            module.statements.removeAt(nonLibBlock.first)
+        for(nonLibBlock in nonLibraryBlocks)
+            module.statements.add(0, nonLibBlock.second)
         val mainBlock = module.statements.single { it is Block && it.name=="main" }
         if((mainBlock as Block).address==null) {
             module.statements.remove(mainBlock)
             module.statements.add(0, mainBlock)
         }
+
         val varDecls = module.statements.filterIsInstance<VarDecl>()
         module.statements.removeAll(varDecls)
         module.statements.addAll(0, varDecls)
@@ -46,8 +56,6 @@ private class StatementReorderer(private val namespace: INameScope, private val
         module.statements.removeAll(directives)
         module.statements.addAll(0, directives)
 
-        // TODO make sure user-defined blocks come BEFORE library blocks
-
         sortConstantAssignments(module.statements)
     }
 

compiler/src/prog8/compiler/Compiler.kt

@@ -92,17 +92,12 @@ class HeapValues {
 
     fun update(heapId: Int, str: String) {
         val oldVal = heap[heapId] ?: throw IllegalArgumentException("heapId not found in heap")
-        when(oldVal.type){
-            DataType.STR,
-            DataType.STR_P,
-            DataType.STR_S,
-            DataType.STR_PS -> {
-                if(oldVal.str!!.length!=str.length)
-                    throw IllegalArgumentException("heap string length mismatch")
-                heap[heapId] = oldVal.copy(str=str)
-            }
-            else-> throw IllegalArgumentException("heap data type mismatch")
+        if(oldVal.type in StringDatatypes) {
+            if (oldVal.str!!.length != str.length)
+                throw IllegalArgumentException("heap string length mismatch")
+            heap[heapId] = oldVal.copy(str = str)
         }
+        else throw IllegalArgumentException("heap data type mismatch")
     }
 
     fun update(heapId: Int, heapval: HeapValue) {
@@ -132,6 +127,7 @@ enum class LauncherType {
 
 enum class ZeropageType {
     BASICSAFE,
+    FLOATSAFE,
     KERNALSAFE,
     FULL
 }
@@ -236,12 +232,11 @@ internal class Compiler(private val rootModule: Module,
 
     private fun opcodePush(dt: DataType): Opcode {
         return when (dt) {
-            DataType.UBYTE, DataType.BYTE -> Opcode.PUSH_BYTE
-            DataType.UWORD, DataType.WORD -> Opcode.PUSH_WORD
+            in ByteDatatypes -> Opcode.PUSH_BYTE
+            in WordDatatypes -> Opcode.PUSH_WORD
+            in IterableDatatypes -> Opcode.PUSH_WORD
             DataType.FLOAT -> Opcode.PUSH_FLOAT
-            DataType.STR, DataType.STR_P, DataType.STR_S, DataType.STR_PS,
-            DataType.ARRAY_UB, DataType.ARRAY_UW, DataType.ARRAY_F,
-            DataType.ARRAY_B, DataType.ARRAY_W -> Opcode.PUSH_WORD
+            else -> throw CompilerException("invalid dt $dt")
         }
     }
 
@@ -279,12 +274,11 @@ internal class Compiler(private val rootModule: Module,
 
     private fun opcodePushvar(dt: DataType): Opcode {
         return when (dt)  {
-            DataType.UBYTE, DataType.BYTE -> Opcode.PUSH_VAR_BYTE
-            DataType.UWORD, DataType.WORD -> Opcode.PUSH_VAR_WORD
+            in ByteDatatypes -> Opcode.PUSH_VAR_BYTE
+            in WordDatatypes -> Opcode.PUSH_VAR_WORD
+            in IterableDatatypes -> Opcode.PUSH_ADDR_HEAPVAR
             DataType.FLOAT -> Opcode.PUSH_VAR_FLOAT
-            DataType.STR, DataType.STR_P, DataType.STR_S, DataType.STR_PS,
-            DataType.ARRAY_UB, DataType.ARRAY_UW, DataType.ARRAY_F,
-            DataType.ARRAY_B, DataType.ARRAY_W -> Opcode.PUSH_ADDR_HEAPVAR
+            else -> throw CompilerException("invalid dt $dt")
         }
     }
 
@@ -294,7 +288,6 @@ internal class Compiler(private val rootModule: Module,
             DataType.ARRAY_UW, DataType.ARRAY_W -> Opcode.READ_INDEXED_VAR_WORD
             DataType.ARRAY_F -> Opcode.READ_INDEXED_VAR_FLOAT
             DataType.STR, DataType.STR_S -> Opcode.READ_INDEXED_VAR_BYTE
-            DataType.STR_P, DataType.STR_PS -> throw CompilerException("cannot index on type $dt - use regular 0-terminated str type")
             else -> throw CompilerException("invalid dt for indexed access $dt")
         }
     }
@@ -305,41 +298,37 @@ internal class Compiler(private val rootModule: Module,
             DataType.ARRAY_UW, DataType.ARRAY_W -> Opcode.WRITE_INDEXED_VAR_WORD
             DataType.ARRAY_F -> Opcode.WRITE_INDEXED_VAR_FLOAT
             DataType.STR, DataType.STR_S -> Opcode.WRITE_INDEXED_VAR_BYTE
-            DataType.STR_P, DataType.STR_PS -> TODO("cannot index on type $dt - use regular str type")
             else -> throw CompilerException("invalid dt for indexed access $dt")
         }
     }
 
     private fun opcodeDiscard(dt: DataType): Opcode {
         return when(dt) {
-            DataType.UBYTE, DataType.BYTE -> Opcode.DISCARD_BYTE
-            DataType.UWORD, DataType.WORD -> Opcode.DISCARD_WORD
+            in ByteDatatypes -> Opcode.DISCARD_BYTE
+            in WordDatatypes -> Opcode.DISCARD_WORD
+            in IterableDatatypes -> Opcode.DISCARD_WORD
             DataType.FLOAT -> Opcode.DISCARD_FLOAT
-            DataType.STR, DataType.STR_P, DataType.STR_S, DataType.STR_PS,
-            DataType.ARRAY_UB, DataType.ARRAY_UW, DataType.ARRAY_F,
-            DataType.ARRAY_B, DataType.ARRAY_W -> Opcode.DISCARD_WORD
+            else -> throw CompilerException("invalid dt $dt")
         }
     }
 
     private fun opcodePopvar(dt: DataType): Opcode {
         return when (dt) {
-            DataType.UBYTE, DataType.BYTE -> Opcode.POP_VAR_BYTE
-            DataType.UWORD, DataType.WORD -> Opcode.POP_VAR_WORD
+            in ByteDatatypes -> Opcode.POP_VAR_BYTE
+            in WordDatatypes -> Opcode.POP_VAR_WORD
+            in IterableDatatypes -> Opcode.POP_VAR_WORD
             DataType.FLOAT -> Opcode.POP_VAR_FLOAT
-            DataType.STR, DataType.STR_P, DataType.STR_S, DataType.STR_PS,
-            DataType.ARRAY_UB, DataType.ARRAY_UW, DataType.ARRAY_F,
-            DataType.ARRAY_B, DataType.ARRAY_W -> Opcode.POP_VAR_WORD
+            else -> throw CompilerException("invalid dt $dt")
         }
     }
 
     private fun opcodePopmem(dt: DataType): Opcode {
         return when (dt) {
-            DataType.UBYTE, DataType.BYTE -> Opcode.POP_MEM_BYTE
-            DataType.UWORD, DataType.WORD -> Opcode.POP_MEM_WORD
+            in ByteDatatypes -> Opcode.POP_MEM_BYTE
+            in WordDatatypes -> Opcode.POP_MEM_WORD
+            in IterableDatatypes -> Opcode.POP_MEM_WORD
             DataType.FLOAT -> Opcode.POP_MEM_FLOAT
-            DataType.STR, DataType.STR_P, DataType.STR_S, DataType.STR_PS,
-            DataType.ARRAY_UB, DataType.ARRAY_UW, DataType.ARRAY_F,
-            DataType.ARRAY_B, DataType.ARRAY_W -> Opcode.POP_MEM_WORD
+            else -> throw CompilerException("invalid dt $dt")
         }
     }
 
@@ -516,8 +505,8 @@ internal class Compiler(private val rootModule: Module,
         if(trueGoto!=null) {
             // optimization for if (condition) goto ....
             val conditionJumpOpcode = when(stmt.condition.resultingDatatype(namespace, heap)) {
-                DataType.UBYTE, DataType.BYTE -> Opcode.JNZ
-                DataType.UWORD, DataType.WORD -> Opcode.JNZW
+                in ByteDatatypes -> Opcode.JNZ
+                in WordDatatypes -> Opcode.JNZW
                 else -> throw CompilerException("invalid condition datatype (expected byte or word) $stmt")
             }
             translate(trueGoto, conditionJumpOpcode)
@@ -526,8 +515,8 @@ internal class Compiler(private val rootModule: Module,
         }
 
         val conditionJumpOpcode = when(stmt.condition.resultingDatatype(namespace, heap)) {
-            DataType.UBYTE, DataType.BYTE -> Opcode.JZ
-            DataType.UWORD, DataType.WORD -> Opcode.JZW
+            in ByteDatatypes -> Opcode.JZ
+            in WordDatatypes -> Opcode.JZW
             else -> throw CompilerException("invalid condition datatype (expected byte or word) $stmt")
         }
         val labelEnd = makeLabel("end")
@@ -572,8 +561,8 @@ internal class Compiler(private val rootModule: Module,
             }
             DataType.BYTE -> {
                 when(rightDt) {
-                    DataType.UBYTE, DataType.BYTE -> DataType.BYTE
-                    DataType.UWORD, DataType.WORD -> DataType.WORD
+                    in ByteDatatypes -> DataType.BYTE
+                    in WordDatatypes -> DataType.WORD
                     DataType.FLOAT -> {
                         printWarning(floatWarning, leftpos)
                         DataType.FLOAT
@@ -614,7 +603,7 @@ internal class Compiler(private val rootModule: Module,
     private fun translate(expr: IExpression) {
         when(expr) {
             is RegisterExpr -> {
-                prog.instr(Opcode.PUSH_VAR_BYTE, callLabel = expr.register.toString())
+                prog.instr(Opcode.PUSH_VAR_BYTE, callLabel = expr.register.name)
             }
             is PrefixExpression -> {
                 translate(expr.expression)
@@ -644,7 +633,7 @@ internal class Compiler(private val rootModule: Module,
                 if(target is BuiltinFunctionStatementPlaceholder) {
                     // call to a builtin function (some will just be an opcode!)
                     val funcname = expr.target.nameInSource[0]
-                    translateFunctionCall(funcname, expr.arglist)
+                    translateBuiltinFunctionCall(funcname, expr.arglist)
                 } else {
                     when(target) {
                         is Subroutine -> translateSubroutineCall(target, expr.arglist, expr.position)
@@ -661,20 +650,20 @@ internal class Compiler(private val rootModule: Module,
             else -> {
                 val lv = expr.constValue(namespace, heap) ?: throw CompilerException("constant expression required, not $expr")
                 when(lv.type) {
-                    DataType.UBYTE, DataType.BYTE -> prog.instr(Opcode.PUSH_BYTE, Value(lv.type, lv.bytevalue!!))
-                    DataType.UWORD, DataType.WORD -> prog.instr(Opcode.PUSH_WORD, Value(lv.type, lv.wordvalue!!))
+                    in ByteDatatypes -> prog.instr(Opcode.PUSH_BYTE, Value(lv.type, lv.bytevalue!!))
+                    in WordDatatypes -> prog.instr(Opcode.PUSH_WORD, Value(lv.type, lv.wordvalue!!))
                     DataType.FLOAT -> prog.instr(Opcode.PUSH_FLOAT, Value(lv.type, lv.floatvalue!!))
-                    DataType.STR, DataType.STR_P, DataType.STR_S, DataType.STR_PS -> {
+                    in StringDatatypes -> {
                         if(lv.heapId==null)
                             throw CompilerException("string should have been moved into heap   ${lv.position}")
                         TODO("push address of string with PUSH_ADDR_HEAPVAR")
                     }
-                    DataType.ARRAY_UB, DataType.ARRAY_UW, DataType.ARRAY_F,
-                    DataType.ARRAY_B, DataType.ARRAY_W -> {
+                    in ArrayDatatypes -> {
                         if(lv.heapId==null)
                             throw CompilerException("array should have been moved into heap  ${lv.position}")
                         TODO("push address of array with PUSH_WORD")
                     }
+                    else -> throw CompilerException("weird datatype")
                 }
             }
         }
@@ -713,12 +702,12 @@ internal class Compiler(private val rootModule: Module,
                 else -> {}
             }
             DataType.UWORD -> when(targetDt) {
-                DataType.UBYTE, DataType.BYTE -> throw CompilerException("narrowing type")
+                in ByteDatatypes -> throw CompilerException("narrowing type")
                 DataType.FLOAT -> prog.instr(Opcode.CAST_UW_TO_F)
                 else -> {}
             }
             DataType.WORD -> when(targetDt) {
-                DataType.UBYTE, DataType.BYTE -> throw CompilerException("narrowing type")
+                in ByteDatatypes -> throw CompilerException("narrowing type")
                 DataType.FLOAT -> prog.instr(Opcode.CAST_W_TO_F)
                 else -> {}
             }
@@ -760,7 +749,7 @@ internal class Compiler(private val rootModule: Module,
         val targetStmt = stmt.target.targetStatement(namespace)!!
         if(targetStmt is BuiltinFunctionStatementPlaceholder) {
             val funcname = stmt.target.nameInSource[0]
-            translateFunctionCall(funcname, stmt.arglist)
+            translateBuiltinFunctionCall(funcname, stmt.arglist)
             return
         }
 
@@ -770,20 +759,18 @@ internal class Compiler(private val rootModule: Module,
             is Subroutine -> {
                 translateSubroutineCall(targetStmt, stmt.arglist, stmt.position)
                 // make sure we clean up the unused result values from the stack
-                // only if they're non-register return values!
-                if(targetStmt.asmReturnvaluesRegisters.isEmpty())
-                    for(rv in targetStmt.returntypes) {
-                        val opcode=opcodeDiscard(rv)
-                        prog.instr(opcode)
-                    }
+                for(rv in targetStmt.returntypes) {
+                    val opcode=opcodeDiscard(rv)
+                    prog.instr(opcode)
+                }
             }
             else ->
                 throw AstException("invalid call target node type: ${targetStmt::class}")
         }
     }
 
-    private fun translateFunctionCall(funcname: String, args: List<IExpression>) {
-        // some functions are implemented as vm opcodes
+    private fun translateBuiltinFunctionCall(funcname: String, args: List<IExpression>) {
+        // some builtin functions are implemented directly as vm opcodes
 
         if(funcname == "swap") {
             translateSwap(args)
@@ -811,10 +798,7 @@ internal class Compiler(private val rootModule: Module,
                 // 1 argument, type determines the exact syscall to use
                 val arg=args.single()
                 when (arg.resultingDatatype(namespace, heap)) {
-                    DataType.STR -> createSyscall("${funcname}_str")
-                    DataType.STR_P -> createSyscall("${funcname}_strp")
-                    DataType.STR_S -> createSyscall("${funcname}_str")
-                    DataType.STR_PS -> createSyscall("${funcname}_strp")
+                    DataType.STR, DataType.STR_S -> createSyscall("${funcname}_str")
                     else -> throw CompilerException("wrong datatype for len()")
                 }
             }
@@ -894,12 +878,12 @@ internal class Compiler(private val rootModule: Module,
                 val arg = args.single()
                 val dt = arg.resultingDatatype(namespace, heap)
                 when (dt) {
-                    DataType.UBYTE, DataType.BYTE -> prog.instr(Opcode.SHL_BYTE)
-                    DataType.UWORD, DataType.WORD -> prog.instr(Opcode.SHL_WORD)
+                    in ByteDatatypes -> prog.instr(Opcode.SHL_BYTE)
+                    in WordDatatypes -> prog.instr(Opcode.SHL_WORD)
                     else -> throw CompilerException("wrong datatype")
                 }
                 // this function doesn't return a value on the stack so we pop it directly into the argument register/variable again
-                popValueIntoTarget(AssignTarget.fromExpr(arg), dt)
+                popValueIntoTarget(AssignTarget.fromExpr(arg), dt!!)
             }
             "lsr" -> {
                 val arg = args.single()
@@ -929,34 +913,34 @@ internal class Compiler(private val rootModule: Module,
                 val arg = args.single()
                 val dt = arg.resultingDatatype(namespace, heap)
                 when (dt) {
-                    DataType.UBYTE, DataType.BYTE -> prog.instr(Opcode.ROR_BYTE)
-                    DataType.UWORD, DataType.WORD -> prog.instr(Opcode.ROR_WORD)
+                    in ByteDatatypes -> prog.instr(Opcode.ROR_BYTE)
+                    in WordDatatypes -> prog.instr(Opcode.ROR_WORD)
                     else -> throw CompilerException("wrong datatype")
                 }
                 // this function doesn't return a value on the stack so we pop it directly into the argument register/variable again
-                popValueIntoTarget(AssignTarget.fromExpr(arg), dt)
+                popValueIntoTarget(AssignTarget.fromExpr(arg), dt!!)
             }
             "rol2" -> {
                 val arg = args.single()
                 val dt = arg.resultingDatatype(namespace, heap)
                 when (dt) {
-                    DataType.UBYTE, DataType.BYTE -> prog.instr(Opcode.ROL2_BYTE)
-                    DataType.UWORD, DataType.WORD -> prog.instr(Opcode.ROL2_WORD)
+                    in ByteDatatypes -> prog.instr(Opcode.ROL2_BYTE)
+                    in WordDatatypes -> prog.instr(Opcode.ROL2_WORD)
                     else -> throw CompilerException("wrong datatype")
                 }
                 // this function doesn't return a value on the stack so we pop it directly into the argument register/variable again
-                popValueIntoTarget(AssignTarget.fromExpr(arg), dt)
+                popValueIntoTarget(AssignTarget.fromExpr(arg), dt!!)
             }
             "ror2" -> {
                 val arg = args.single()
                 val dt = arg.resultingDatatype(namespace, heap)
                 when (dt) {
-                    DataType.UBYTE, DataType.BYTE -> prog.instr(Opcode.ROR2_BYTE)
-                    DataType.UWORD, DataType.WORD -> prog.instr(Opcode.ROR2_WORD)
+                    in ByteDatatypes -> prog.instr(Opcode.ROR2_BYTE)
+                    in WordDatatypes -> prog.instr(Opcode.ROR2_WORD)
                     else -> throw CompilerException("wrong datatype")
                 }
                 // this function doesn't return a value on the stack so we pop it directly into the argument register/variable again
-                popValueIntoTarget(AssignTarget.fromExpr(arg), dt)
+                popValueIntoTarget(AssignTarget.fromExpr(arg), dt!!)
             }
             "set_carry" -> prog.instr(Opcode.SEC)
             "clear_carry" -> prog.instr(Opcode.CLC)
@@ -999,157 +983,7 @@ internal class Compiler(private val rootModule: Module,
         // We don't bother about saving A and Y. They're considered expendable.
 
         if(subroutine.isAsmSubroutine) {
-            if(subroutine.parameters.size!=subroutine.asmParameterRegisters.size)
-                throw CompilerException("no support for mix of register and non-register subroutine arguments")
-
-            // only register arguments (or status-flag bits)
-            var carryParam: Boolean? = null
-            for(arg in arguments.zip(subroutine.asmParameterRegisters)) {
-                if(arg.second.statusflag!=null) {
-                    if(arg.second.statusflag==Statusflag.Pc)
-                        carryParam = arg.first.constValue(namespace, heap)!!.asBooleanValue
-                    else
-                        throw CompilerException("no support for status flag parameter: ${arg.second.statusflag}")
-                } else {
-                    when (arg.second.registerOrPair!!) {
-                        A -> {
-                            val assign = Assignment(listOf(AssignTarget(Register.A, null, null, null, callPosition)), null, arg.first, callPosition)
-                            assign.linkParents(arguments[0].parent)
-                            translate(assign)
-                        }
-                        X -> {
-                            if(!restoreX) {
-                                prog.instr(Opcode.RSAVEX)
-                                restoreX = true
-                            }
-                            val assign = Assignment(listOf(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)
-                            assign.linkParents(arguments[0].parent)
-                            translate(assign)
-                        }
-                        AX -> {
-                            if(!restoreX) {
-                                prog.instr(Opcode.RSAVEX)
-                                restoreX = true
-                            }
-                            val valueA: IExpression
-                            val valueX: IExpression
-                            val paramDt = arg.first.resultingDatatype(namespace, heap)
-                            when (paramDt) {
-                                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)
-                                    assignA.linkParents(arguments[0].parent)
-                                    assignX.linkParents(arguments[0].parent)
-                                    translate(assignA)
-                                    translate(assignX)
-                                }
-                                DataType.UWORD -> {
-                                    translate(arg.first)
-                                    prog.instr(Opcode.POP_REGAX_WORD)
-                                }
-                                DataType.STR, DataType.STR_S -> {
-                                    pushStringAddress(arg.first, false)
-                                    prog.instr(Opcode.POP_REGAX_WORD)
-                                }
-                                DataType.FLOAT -> {
-                                    pushFloatAddress(arg.first)
-                                    prog.instr(Opcode.POP_REGAX_WORD)
-                                }
-                                in ArrayDatatypes -> {
-                                    pushStringAddress(arg.first, false)
-                                    prog.instr(Opcode.POP_REGAX_WORD)
-                                }
-                                else -> TODO("pass parameter of type $paramDt in registers AX at $callPosition")
-                            }
-                        }
-                        AY -> {
-                            val valueA: IExpression
-                            val valueY: IExpression
-                            val paramDt = arg.first.resultingDatatype(namespace, heap)
-                            when (paramDt) {
-                                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)
-                                    assignA.linkParents(arguments[0].parent)
-                                    assignY.linkParents(arguments[0].parent)
-                                    translate(assignA)
-                                    translate(assignY)
-                                }
-                                DataType.UWORD, DataType.WORD -> {
-                                    translate(arg.first)
-                                    prog.instr(Opcode.POP_REGAY_WORD)
-                                }
-                                DataType.STR, DataType.STR_S -> {
-                                    pushStringAddress(arg.first, false)
-                                    prog.instr(Opcode.POP_REGAY_WORD)
-                                }
-                                DataType.FLOAT -> {
-                                    pushFloatAddress(arg.first)
-                                    prog.instr(Opcode.POP_REGAY_WORD)
-                                }
-                                in ArrayDatatypes -> {
-                                    pushStringAddress(arg.first, false)
-                                    prog.instr(Opcode.POP_REGAY_WORD)
-                                }
-                                else -> TODO("pass parameter of type $paramDt in registers AY at $callPosition")
-                            }
-                        }
-                        XY -> {
-                            if(!restoreX) {
-                                prog.instr(Opcode.RSAVEX)
-                                restoreX = true
-                            }
-                            val valueX: IExpression
-                            val valueY: IExpression
-                            val paramDt = arg.first.resultingDatatype(namespace, heap)
-                            when (paramDt) {
-                                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)
-                                    assignX.linkParents(arguments[0].parent)
-                                    assignY.linkParents(arguments[0].parent)
-                                    translate(assignX)
-                                    translate(assignY)
-                                }
-                                DataType.UWORD -> {
-                                    translate(arg.first)
-                                    prog.instr(Opcode.POP_REGXY_WORD)
-                                }
-                                DataType.STR, DataType.STR_S -> {
-                                    pushStringAddress(arg.first, false)
-                                    prog.instr(Opcode.POP_REGXY_WORD)
-                                }
-                                DataType.FLOAT -> {
-                                    pushFloatAddress(arg.first)
-                                    prog.instr(Opcode.POP_REGXY_WORD)
-                                }
-                                in ArrayDatatypes -> {
-                                    pushStringAddress(arg.first, false)
-                                    prog.instr(Opcode.POP_REGXY_WORD)
-                                }
-                                else -> TODO("pass parameter of type $paramDt in registers XY at $callPosition")
-                            }
-                        }
-                    }
-                }
-            }
-
-            // carry is set last, to avoid clobbering it when loading the other parameters
-            when(carryParam) {
-                true -> prog.instr(Opcode.SEC)
-                false -> prog.instr(Opcode.CLC)
-            }
+            restoreX = translateAsmSubCallArguments(subroutine, arguments, callPosition, restoreX)
         } else {
             // only regular (non-register) arguments
             // "assign" the arguments to the locally scoped parameter variables for this subroutine
@@ -1164,6 +998,176 @@ internal class Compiler(private val rootModule: Module,
         prog.instr(Opcode.CALL, callLabel = subroutine.scopedname)
         if(restoreX)
             prog.instr(Opcode.RRESTOREX)
+
+        if(subroutine.isAsmSubroutine && subroutine.asmReturnvaluesRegisters.isNotEmpty()) {
+            // the result values of the asm-subroutine that are returned in registers, have to be pushed on the stack
+            // (in reversed order)   otherwise the asm-subroutine can't be used in expressions.
+            for(rv in subroutine.asmReturnvaluesRegisters.reversed()) {
+                if(rv.statusflag!=null)
+                    TODO("not yet supported: return values in cpu status flag $rv  $subroutine")
+                when(rv.registerOrPair) {
+                    A,X,Y -> prog.instr(Opcode.PUSH_VAR_BYTE, callLabel = rv.registerOrPair.name)
+                    AX, AY, XY -> prog.instr(Opcode.PUSH_VAR_WORD, callLabel = rv.registerOrPair.name)
+                    null -> {}
+                }
+            }
+        }
+    }
+
+    private fun translateAsmSubCallArguments(subroutine: Subroutine, arguments: List<IExpression>, callPosition: Position, restoreXinitial: Boolean): Boolean {
+        var restoreX = restoreXinitial
+        if (subroutine.parameters.size != subroutine.asmParameterRegisters.size)
+            TODO("no support yet for mix of register and non-register subroutine arguments")
+
+        // only register arguments (or status-flag bits)
+        var carryParam: Boolean? = null
+        for (arg in arguments.zip(subroutine.asmParameterRegisters)) {
+            if (arg.second.statusflag != null) {
+                if (arg.second.statusflag == Statusflag.Pc)
+                    carryParam = arg.first.constValue(namespace, heap)!!.asBooleanValue
+                else
+                    throw CompilerException("no support for status flag parameter: ${arg.second.statusflag}")
+            } else {
+                when (arg.second.registerOrPair!!) {
+                    A -> {
+                        val assign = Assignment(listOf(AssignTarget(Register.A, null, null, null, callPosition)), null, arg.first, callPosition)
+                        assign.linkParents(arguments[0].parent)
+                        translate(assign)
+                    }
+                    X -> {
+                        if (!restoreX) {
+                            prog.instr(Opcode.RSAVEX)
+                            restoreX = true
+                        }
+                        val assign = Assignment(listOf(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)
+                        assign.linkParents(arguments[0].parent)
+                        translate(assign)
+                    }
+                    AX -> {
+                        if (!restoreX) {
+                            prog.instr(Opcode.RSAVEX)
+                            restoreX = true
+                        }
+                        val valueA: IExpression
+                        val valueX: IExpression
+                        val paramDt = arg.first.resultingDatatype(namespace, heap)
+                        when (paramDt) {
+                            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)
+                                assignA.linkParents(arguments[0].parent)
+                                assignX.linkParents(arguments[0].parent)
+                                translate(assignA)
+                                translate(assignX)
+                            }
+                            DataType.UWORD -> {
+                                translate(arg.first)
+                                prog.instr(Opcode.POP_REGAX_WORD)
+                            }
+                            DataType.STR, DataType.STR_S -> {
+                                pushStringAddress(arg.first, false)
+                                prog.instr(Opcode.POP_REGAX_WORD)
+                            }
+                            DataType.FLOAT -> {
+                                pushFloatAddress(arg.first)
+                                prog.instr(Opcode.POP_REGAX_WORD)
+                            }
+                            in ArrayDatatypes -> {
+                                pushStringAddress(arg.first, false)
+                                prog.instr(Opcode.POP_REGAX_WORD)
+                            }
+                            else -> TODO("pass parameter of type $paramDt in registers AX at $callPosition")
+                        }
+                    }
+                    AY -> {
+                        val valueA: IExpression
+                        val valueY: IExpression
+                        val paramDt = arg.first.resultingDatatype(namespace, heap)
+                        when (paramDt) {
+                            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)
+                                assignA.linkParents(arguments[0].parent)
+                                assignY.linkParents(arguments[0].parent)
+                                translate(assignA)
+                                translate(assignY)
+                            }
+                            in WordDatatypes -> {
+                                translate(arg.first)
+                                prog.instr(Opcode.POP_REGAY_WORD)
+                            }
+                            DataType.STR, DataType.STR_S -> {
+                                pushStringAddress(arg.first, false)
+                                prog.instr(Opcode.POP_REGAY_WORD)
+                            }
+                            DataType.FLOAT -> {
+                                pushFloatAddress(arg.first)
+                                prog.instr(Opcode.POP_REGAY_WORD)
+                            }
+                            in ArrayDatatypes -> {
+                                pushStringAddress(arg.first, false)
+                                prog.instr(Opcode.POP_REGAY_WORD)
+                            }
+                            else -> TODO("pass parameter of type $paramDt in registers AY at $callPosition")
+                        }
+                    }
+                    XY -> {
+                        if (!restoreX) {
+                            prog.instr(Opcode.RSAVEX)
+                            restoreX = true
+                        }
+                        val valueX: IExpression
+                        val valueY: IExpression
+                        val paramDt = arg.first.resultingDatatype(namespace, heap)
+                        when (paramDt) {
+                            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)
+                                assignX.linkParents(arguments[0].parent)
+                                assignY.linkParents(arguments[0].parent)
+                                translate(assignX)
+                                translate(assignY)
+                            }
+                            DataType.UWORD -> {
+                                translate(arg.first)
+                                prog.instr(Opcode.POP_REGXY_WORD)
+                            }
+                            DataType.STR, DataType.STR_S -> {
+                                pushStringAddress(arg.first, false)
+                                prog.instr(Opcode.POP_REGXY_WORD)
+                            }
+                            DataType.FLOAT -> {
+                                pushFloatAddress(arg.first)
+                                prog.instr(Opcode.POP_REGXY_WORD)
+                            }
+                            in ArrayDatatypes -> {
+                                pushStringAddress(arg.first, false)
+                                prog.instr(Opcode.POP_REGXY_WORD)
+                            }
+                            else -> TODO("pass parameter of type $paramDt in registers XY at $callPosition")
+                        }
+                    }
+                }
+            }
+        }
+
+        // carry is set last, to avoid clobbering it when loading the other parameters
+        when (carryParam) {
+            true -> prog.instr(Opcode.SEC)
+            false -> prog.instr(Opcode.CLC)
+        }
+        return restoreX
     }
 
     private fun translateBinaryOperator(operator: String, dt: DataType) {
@@ -1230,43 +1234,43 @@ internal class Compiler(private val rootModule: Module,
             }
             "&" -> {
                 when(dt) {
-                    DataType.UBYTE, DataType.BYTE -> Opcode.BITAND_BYTE
-                    DataType.UWORD, DataType.WORD -> Opcode.BITAND_WORD
+                    in ByteDatatypes -> Opcode.BITAND_BYTE
+                    in WordDatatypes -> Opcode.BITAND_WORD
                     else -> throw CompilerException("only byte/word possible")
                 }
             }
             "|" -> {
                 when(dt) {
-                    DataType.UBYTE, DataType.BYTE -> Opcode.BITOR_BYTE
-                    DataType.UWORD, DataType.WORD -> Opcode.BITOR_WORD
+                    in ByteDatatypes -> Opcode.BITOR_BYTE
+                    in WordDatatypes -> Opcode.BITOR_WORD
                     else -> throw CompilerException("only byte/word possible")
                 }
             }
             "^" -> {
                 when(dt) {
-                    DataType.UBYTE, DataType.BYTE -> Opcode.BITXOR_BYTE
-                    DataType.UWORD, DataType.WORD -> Opcode.BITXOR_WORD
+                    in ByteDatatypes -> Opcode.BITXOR_BYTE
+                    in WordDatatypes -> Opcode.BITXOR_WORD
                     else -> throw CompilerException("only byte/word possible")
                 }
             }
             "and" -> {
                 when(dt) {
-                    DataType.UBYTE, DataType.BYTE -> Opcode.AND_BYTE
-                    DataType.UWORD, DataType.WORD -> Opcode.AND_WORD
+                    in ByteDatatypes -> Opcode.AND_BYTE
+                    in WordDatatypes -> Opcode.AND_WORD
                     else -> throw CompilerException("only byte/word possible")
                 }
             }
             "or" -> {
                 when(dt) {
-                    DataType.UBYTE, DataType.BYTE -> Opcode.OR_BYTE
-                    DataType.UWORD, DataType.WORD -> Opcode.OR_WORD
+                    in ByteDatatypes -> Opcode.OR_BYTE
+                    in WordDatatypes -> Opcode.OR_WORD
                     else -> throw CompilerException("only byte/word possible")
                 }
             }
             "xor" -> {
                 when(dt) {
-                    DataType.UBYTE, DataType.BYTE -> Opcode.XOR_BYTE
-                    DataType.UWORD, DataType.WORD -> Opcode.XOR_WORD
+                    in ByteDatatypes -> Opcode.XOR_BYTE
+                    in WordDatatypes -> Opcode.XOR_WORD
                     else -> throw CompilerException("only byte/word possible")
                 }
             }
@@ -1312,16 +1316,16 @@ internal class Compiler(private val rootModule: Module,
             }
             "==" -> {
                 when (dt) {
-                    DataType.UBYTE, DataType.BYTE -> Opcode.EQUAL_BYTE
-                    DataType.UWORD, DataType.WORD -> Opcode.EQUAL_WORD
+                    in ByteDatatypes -> Opcode.EQUAL_BYTE
+                    in WordDatatypes -> Opcode.EQUAL_WORD
                     DataType.FLOAT -> Opcode.EQUAL_F
                     else -> throw CompilerException("only byte/word/lfoat possible")
                 }
             }
             "!=" -> {
                 when (dt) {
-                    DataType.UBYTE, DataType.BYTE -> Opcode.NOTEQUAL_BYTE
-                    DataType.UWORD, DataType.WORD -> Opcode.NOTEQUAL_WORD
+                    in ByteDatatypes -> Opcode.NOTEQUAL_BYTE
+                    in WordDatatypes -> Opcode.NOTEQUAL_WORD
                     DataType.FLOAT -> Opcode.NOTEQUAL_F
                     else -> throw CompilerException("only byte/word/lfoat possible")
                 }
@@ -1352,8 +1356,8 @@ internal class Compiler(private val rootModule: Module,
                 }
             } else if(operator=="<<") {
                 when (leftDt) {
-                    DataType.UBYTE, DataType.BYTE -> prog.instr(Opcode.SHIFTEDL_BYTE)
-                    DataType.UWORD, DataType.WORD -> prog.instr(Opcode.SHIFTEDL_WORD)
+                    in ByteDatatypes -> prog.instr(Opcode.SHIFTEDL_BYTE)
+                    in WordDatatypes -> prog.instr(Opcode.SHIFTEDL_WORD)
                     else -> throw CompilerException("wrong datatype")
                 }
             }
@@ -1376,15 +1380,15 @@ internal class Compiler(private val rootModule: Module,
             }
             "~" -> {
                 when(operandDt) {
-                    DataType.UBYTE, DataType.BYTE -> Opcode.INV_BYTE
-                    DataType.UWORD, DataType.WORD -> Opcode.INV_WORD
+                    in ByteDatatypes -> Opcode.INV_BYTE
+                    in WordDatatypes -> Opcode.INV_WORD
                     else -> throw CompilerException("only byte/word possible")
                 }
             }
             "not" -> {
                 when(operandDt) {
-                    DataType.UBYTE, DataType.BYTE -> Opcode.NOT_BYTE
-                    DataType.UWORD, DataType.WORD -> Opcode.NOT_WORD
+                    in ByteDatatypes -> Opcode.NOT_BYTE
+                    in WordDatatypes -> Opcode.NOT_WORD
                     else -> throw CompilerException("only byte/word possible")
                 }
             }
@@ -1441,8 +1445,8 @@ internal class Compiler(private val rootModule: Module,
         prog.line(stmt.position)
         when {
             stmt.target.register != null -> when(stmt.operator) {
-                "++" -> prog.instr(Opcode.INC_VAR_UB, callLabel = stmt.target.register.toString())
-                "--" -> prog.instr(Opcode.DEC_VAR_UB, callLabel = stmt.target.register.toString())
+                "++" -> prog.instr(Opcode.INC_VAR_UB, callLabel = stmt.target.register!!.name)
+                "--" -> prog.instr(Opcode.DEC_VAR_UB, callLabel = stmt.target.register!!.name)
             }
             stmt.target.identifier != null -> {
                 val targetStatement = stmt.target.identifier!!.targetStatement(namespace) as VarDecl
@@ -1495,7 +1499,7 @@ internal class Compiler(private val rootModule: Module,
             // convert value to target datatype if possible
             // @todo use convertType()????
             when(targetDt) {
-                DataType.UBYTE, DataType.BYTE ->
+                in ByteDatatypes ->
                     if(valueDt!=DataType.BYTE && valueDt!=DataType.UBYTE)
                         throw CompilerException("incompatible data types valueDt=$valueDt  targetDt=$targetDt  at $stmt")
                 DataType.WORD -> {
@@ -1531,24 +1535,15 @@ internal class Compiler(private val rootModule: Module,
                         else -> throw CompilerException("incompatible data types valueDt=$valueDt  targetDt=$targetDt  at $stmt")
                     }
                 }
-                DataType.STR, DataType.STR_P, DataType.STR_S, DataType.STR_PS -> throw CompilerException("incompatible data types valueDt=$valueDt  targetDt=$targetDt  at $stmt")
-                DataType.ARRAY_UB, DataType.ARRAY_B, DataType.ARRAY_UW, DataType.ARRAY_W, DataType.ARRAY_F -> throw CompilerException("incompatible data types valueDt=$valueDt  targetDt=$targetDt  at $stmt")
-                null -> throw CompilerException("could not determine targetdt")
+                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/unknonwn targetdt")
             }
         }
 
         if(stmt.aug_op!=null)
             throw CompilerException("augmented assignment should have been converted to regular assignment already")
 
-        if(stmt.value is FunctionCall) {
-            val sub = (stmt.value as FunctionCall).target.targetStatement(namespace)
-            if(sub is Subroutine && sub.asmReturnvaluesRegisters.isNotEmpty()) {
-                // the subroutine call returns its values in registers
-                storeRegisterIntoTarget(sub.asmReturnvaluesRegisters.single(), assignTarget, stmt)
-                return
-            }
-        }
-
         // pop the result value back into the assignment target
         val datatype = assignTarget.determineDatatype(namespace, heap, stmt)!!
         popValueIntoTarget(assignTarget, datatype)
@@ -1580,6 +1575,7 @@ internal class Compiler(private val rootModule: Module,
     private fun translateMultiReturnAssignment(stmt: Assignment) {
         val targetStmt = (stmt.value as? FunctionCall)?.target?.targetStatement(namespace)
         if(targetStmt is Subroutine && targetStmt.isAsmSubroutine) {
+            // TODO check correctness of multi-return values (they should be on the stack rather than directly assigned!)
             // we're dealing with the one case where multiple assignment targets are allowed: a call to an asmsub with multiple return values
             // for now, we only support multiple return values as long as they're returned in registers as well.
             if(targetStmt.asmReturnvaluesRegisters.isEmpty())
@@ -1666,7 +1662,7 @@ internal class Compiler(private val rootModule: Module,
                     }
                 } else throw CompilerException("invalid assignment target type ${target::class}")
             }
-            assignTarget.register != null -> prog.instr(Opcode.POP_VAR_BYTE, callLabel = assignTarget.register.toString())
+            assignTarget.register != null -> prog.instr(Opcode.POP_VAR_BYTE, callLabel = assignTarget.register.name)
             assignTarget.arrayindexed != null -> translate(assignTarget.arrayindexed, true)     // write value to it
             assignTarget.memoryAddress != null -> {
                 val address = assignTarget.memoryAddress?.addressExpression?.constValue(namespace, heap)?.asIntegerValue
@@ -1702,7 +1698,7 @@ internal class Compiler(private val rootModule: Module,
 
         if(loop.loopRegister!=null) {
             val reg = loop.loopRegister
-            loopVarName = reg.toString()
+            loopVarName = reg.name
             loopVarDt = DataType.UBYTE
         } else {
             val loopvar = (loop.loopVar!!.targetStatement(namespace) as VarDecl)
@@ -1767,7 +1763,7 @@ internal class Compiler(private val rootModule: Module,
     }
 
     private fun translateForOverIterableVar(loop: ForLoop, loopvarDt: DataType, iterableValue: LiteralValue) {
-        if(loopvarDt==DataType.UBYTE && iterableValue.type !in setOf(DataType.STR, DataType.STR_P, DataType.STR_S, DataType.STR_PS, 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)
             throw CompilerException("loop variable type doesn't match iterableValue type")
@@ -1776,10 +1772,7 @@ internal class Compiler(private val rootModule: Module,
 
         val numElements: Int
         when(iterableValue.type) {
-            DataType.UBYTE, DataType.BYTE,
-            DataType.UWORD, DataType.WORD,
-            DataType.FLOAT -> throw CompilerException("non-iterableValue type")
-            DataType.STR_P, DataType.STR_PS -> throw CompilerException("can't iterate string type ${iterableValue.type}")
+            !in IterableDatatypes -> throw CompilerException("non-iterableValue type")
             DataType.STR, DataType.STR_S -> {
                 numElements = iterableValue.strvalue(heap).length
                 if(numElements>255) throw CompilerException("string length > 255")
@@ -1793,6 +1786,7 @@ internal class Compiler(private val rootModule: Module,
                 numElements = iterableValue.arrayvalue?.size ?: heap.get(iterableValue.heapId!!).arraysize
                 if(numElements>255) throw CompilerException("string length > 255")
             }
+            else -> throw CompilerException("weird datatype")
         }
 
         if(loop.loopRegister!=null && loop.loopRegister==Register.X)
@@ -2035,15 +2029,15 @@ internal class Compiler(private val rootModule: Module,
             postIncr.linkParents(body)
             translate(postIncr)
             if(lvTarget.register!=null)
-                prog.instr(Opcode.PUSH_VAR_BYTE, callLabel =lvTarget.register.toString())
+                prog.instr(Opcode.PUSH_VAR_BYTE, callLabel =lvTarget.register.name)
             else {
                 val opcode = opcodePushvar(targetStatement!!.datatype)
                 prog.instr(opcode, callLabel = targetStatement.scopedname)
             }
             // TODO: optimize this to use a compare + branch opcode somehow?
             val conditionJumpOpcode = when(targetStatement!!.datatype) {
-                DataType.UBYTE, DataType.BYTE -> Opcode.JNZ
-                DataType.UWORD, DataType.WORD -> Opcode.JNZW
+                in ByteDatatypes -> Opcode.JNZ
+                in WordDatatypes -> Opcode.JNZW
                 else -> throw CompilerException("invalid loopvar datatype (expected byte or word) $lvTarget")
             }
             prog.instr(conditionJumpOpcode, callLabel = loopLabel)
@@ -2094,8 +2088,8 @@ internal class Compiler(private val rootModule: Module,
         prog.label(continueLabel)
         translate(stmt.condition)
         val conditionJumpOpcode = when(stmt.condition.resultingDatatype(namespace, heap)) {
-            DataType.UBYTE, DataType.BYTE -> Opcode.JNZ
-            DataType.UWORD, DataType.WORD -> Opcode.JNZW
+            in ByteDatatypes -> Opcode.JNZ
+            in WordDatatypes -> Opcode.JNZW
             else -> throw CompilerException("invalid condition datatype (expected byte or word) $stmt")
         }
         prog.instr(conditionJumpOpcode, callLabel = loopLabel)
@@ -2131,8 +2125,8 @@ internal class Compiler(private val rootModule: Module,
         prog.label(continueLabel)
         translate(stmt.untilCondition)
         val conditionJumpOpcode = when(stmt.untilCondition.resultingDatatype(namespace, heap)) {
-            DataType.UBYTE, DataType.BYTE -> Opcode.JZ
-            DataType.UWORD, DataType.WORD -> Opcode.JZW
+            in ByteDatatypes -> Opcode.JZ
+            in WordDatatypes -> Opcode.JZW
             else -> throw CompilerException("invalid condition datatype (expected byte or word) $stmt")
         }
         prog.instr(conditionJumpOpcode, callLabel = loopLabel)

compiler/src/prog8/compiler/Zeropage.kt

@@ -6,7 +6,7 @@ import prog8.ast.*
 class ZeropageDepletedError(message: String) : Exception(message)
 
 
-abstract class Zeropage(private val options: CompilationOptions) {
+abstract class Zeropage(protected val options: CompilationOptions) {
 
     private val allocations = mutableMapOf<Int, Pair<String, DataType>>()
     val free = mutableListOf<Int>()     // subclasses must set this to the appropriate free locations.
@@ -20,8 +20,8 @@ abstract class Zeropage(private val options: CompilationOptions) {
 
         val size =
                 when (datatype) {
-                    DataType.UBYTE, DataType.BYTE -> 1
-                    DataType.UWORD, DataType.WORD -> 2
+                    in ByteDatatypes -> 1
+                    in WordDatatypes -> 2
                     DataType.FLOAT -> {
                         if (options.floats) {
                             if(position!=null)
@@ -61,4 +61,12 @@ abstract class Zeropage(private val options: CompilationOptions) {
 
     private fun loneByte(address: Int) = address in free && address-1 !in free && address+1 !in free
     private fun sequentialFree(address: Int, size: Int) = free.containsAll((address until address+size).toList())
+
+    enum class ExitProgramStrategy {
+        CLEAN_EXIT,
+        SYSTEM_RESET
+    }
+
+    abstract val exitProgramStrategy: ExitProgramStrategy
+
 }

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

@@ -23,10 +23,10 @@ open class Instruction(val opcode: Opcode,
                     }
                     opcode in opcodesWithVarArgument -> {
                         // opcodes that manipulate a variable
-                        "${opcode.toString().toLowerCase()}  ${callLabel?:""}  ${callLabel2?:""}".trimEnd()
+                        "${opcode.name.toLowerCase()}  ${callLabel?:""}  ${callLabel2?:""}".trimEnd()
                     }
-                    callLabel==null -> "${opcode.toString().toLowerCase()}  $argStr"
-                    else -> "${opcode.toString().toLowerCase()}  $callLabel  $argStr"
+                    callLabel==null -> "${opcode.name.toLowerCase()}  $argStr"
+                    else -> "${opcode.name.toLowerCase()}  $callLabel  $argStr"
                 }
                 .trimEnd()
 

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

@@ -389,20 +389,20 @@ class IntermediateProgram(val name: String, var loadAddress: Int, val heap: Heap
         when(decl.type) {
             VarDeclType.VAR -> {
                 val value = when(decl.datatype) {
-                    DataType.UBYTE, DataType.BYTE, DataType.UWORD, DataType.WORD, DataType.FLOAT -> Value(decl.datatype, (decl.value as LiteralValue).asNumericValue!!)
-                    DataType.STR, DataType.STR_P, DataType.STR_S, DataType.STR_PS -> {
+                    in NumericDatatypes -> Value(decl.datatype, (decl.value as LiteralValue).asNumericValue!!)
+                    in StringDatatypes -> {
                         val litval = (decl.value as LiteralValue)
                         if(litval.heapId==null)
                             throw CompilerException("string should already be in the heap")
                         Value(decl.datatype, litval.heapId)
                     }
-                    DataType.ARRAY_B, DataType.ARRAY_W,
-                    DataType.ARRAY_UB, DataType.ARRAY_UW, DataType.ARRAY_F -> {
+                    in ArrayDatatypes -> {
                         val litval = (decl.value as LiteralValue)
                         if(litval.heapId==null)
                             throw CompilerException("array should already be in the heap")
                         Value(decl.datatype, litval.heapId)
                     }
+                    else -> throw CompilerException("weird datatype")
                 }
                 currentBlock.variables[scopedname] = value
                 if(decl.zeropage)
@@ -462,11 +462,11 @@ class IntermediateProgram(val name: String, var loadAddress: Int, val heap: Heap
         heap.allEntries().forEach {
             when {
                 it.value.str!=null ->
-                    out.println("${it.key}  ${it.value.type.toString().toLowerCase()}  \"${escape(it.value.str!!)}\"")
+                    out.println("${it.key}  ${it.value.type.name.toLowerCase()}  \"${escape(it.value.str!!)}\"")
                 it.value.array!=null ->
-                    out.println("${it.key}  ${it.value.type.toString().toLowerCase()}  ${it.value.array!!.toList()}")
+                    out.println("${it.key}  ${it.value.type.name.toLowerCase()}  ${it.value.array!!.toList()}")
                 it.value.doubleArray!=null ->
-                    out.println("${it.key}  ${it.value.type.toString().toLowerCase()}  ${it.value.doubleArray!!.toList()}")
+                    out.println("${it.key}  ${it.value.type.name.toLowerCase()}  ${it.value.doubleArray!!.toList()}")
                 else -> throw CompilerException("invalid heap entry $it")
             }
         }
@@ -477,12 +477,12 @@ class IntermediateProgram(val name: String, var loadAddress: Int, val heap: Heap
             out.println("%variables")
             for(variable in blk.variables) {
                 val valuestr = variable.value.toString()
-                out.println("${variable.key}  ${variable.value.type.toString().toLowerCase()}  $valuestr")
+                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.toString().toLowerCase()}  uw:${iconst.value.first.toString(16)}")
+                out.println("${iconst.key}  ${iconst.value.second.name.toLowerCase()}  uw:${iconst.value.first.toString(16)}")
             }
             out.println("%end_memorypointers")
             out.println("%instructions")

compiler/src/prog8/compiler/intermediate/Value.kt

@@ -79,8 +79,8 @@ class Value(val type: DataType, numericvalueOrHeapId: Number) {
 
     fun numericValue(): Number {
         return when(type) {
-            DataType.UBYTE, DataType.BYTE -> byteval!!
-            DataType.UWORD, DataType.WORD -> wordval!!
+            in ByteDatatypes -> byteval!!
+            in WordDatatypes -> wordval!!
             DataType.FLOAT -> floatval!!
             else -> throw ValueException("invalid datatype for numeric value: $type")
         }
@@ -88,8 +88,8 @@ class Value(val type: DataType, numericvalueOrHeapId: Number) {
 
     fun integerValue(): Int {
         return when(type) {
-            DataType.UBYTE, DataType.BYTE -> byteval!!.toInt()
-            DataType.UWORD, DataType.WORD -> wordval!!
+            in ByteDatatypes -> byteval!!.toInt()
+            in WordDatatypes -> wordval!!
             DataType.FLOAT -> throw ValueException("float to integer loss of precision")
             else -> throw ValueException("invalid datatype for integer value: $type")
         }
@@ -393,8 +393,8 @@ class Value(val type: DataType, numericvalueOrHeapId: Number) {
 
     fun msb(): Value {
         return when(type) {
-            DataType.UBYTE, DataType.BYTE -> Value(DataType.UBYTE, 0)
-            DataType.UWORD, DataType.WORD -> Value(DataType.UBYTE, wordval!! ushr 8 and 255)
+            in ByteDatatypes -> Value(DataType.UBYTE, 0)
+            in WordDatatypes -> Value(DataType.UBYTE, wordval!! ushr 8 and 255)
             else -> throw ValueException("msb can only work on (u)byte/(u)word")
         }
     }
@@ -428,7 +428,7 @@ class Value(val type: DataType, numericvalueOrHeapId: Number) {
             }
             DataType.UWORD -> {
                 when (targetType) {
-                    DataType.BYTE, DataType.UBYTE -> Value(DataType.UBYTE, integerValue() and 255)
+                    in ByteDatatypes -> Value(DataType.UBYTE, integerValue() and 255)
                     DataType.UWORD -> this
                     DataType.WORD -> {
                         if(integerValue()<=32767)
@@ -442,7 +442,7 @@ class Value(val type: DataType, numericvalueOrHeapId: Number) {
             }
             DataType.WORD -> {
                 when (targetType) {
-                    DataType.BYTE, DataType.UBYTE -> Value(DataType.UBYTE, integerValue() and 255)
+                    in ByteDatatypes -> Value(DataType.UBYTE, integerValue() and 255)
                     DataType.UWORD -> Value(DataType.UWORD, integerValue() and 65535)
                     DataType.WORD -> this
                     DataType.FLOAT -> Value(DataType.FLOAT, numericValue())

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

@@ -16,9 +16,6 @@ import kotlin.math.abs
 class AssemblyError(msg: String) : RuntimeException(msg)
 
 
-// TODO: code generation for POW instruction
-
-
 class AsmGen(val options: CompilationOptions, val program: IntermediateProgram, val heap: HeapValues, val zeropage: Zeropage) {
     private val globalFloatConsts = mutableMapOf<Double, String>()
     private val assemblyLines = mutableListOf<String>()
@@ -76,7 +73,7 @@ class AsmGen(val options: CompilationOptions, val program: IntermediateProgram,
         }
     }
 
-    fun compileToAssembly(): AssemblyProgram {
+    fun compileToAssembly(optimize: Boolean): AssemblyProgram {
         println("Generating assembly code from intermediate code... ")
 
         assemblyLines.clear()
@@ -84,9 +81,11 @@ class AsmGen(val options: CompilationOptions, val program: IntermediateProgram,
         for(b in program.blocks)
             block2asm(b)
 
-        var optimizationsDone=1
-        while(optimizationsDone>0) {
-            optimizationsDone = optimizeAssembly(assemblyLines)
+        if(optimize) {
+            var optimizationsDone = 1
+            while (optimizationsDone > 0) {
+                optimizationsDone = optimizeAssembly(assemblyLines)
+            }
         }
 
         File("${program.name}.asm").printWriter().use {
@@ -186,6 +185,15 @@ class AsmGen(val options: CompilationOptions, val program: IntermediateProgram,
             }
         }
 
+        if(zeropage.exitProgramStrategy!=Zeropage.ExitProgramStrategy.CLEAN_EXIT) {
+            // disable shift-commodore charset switching and run/stop key
+            out("  lda  #$80")
+            out("  lda  #$80")
+            out("  sta  657\t; disable charset switching")
+            out("  lda  #239")
+            out("  sta  808\t; disable run/stop key")
+        }
+
         out("  ldx  #\$ff\t; init estack pointer")
         out("  ; initialize the variables in each block")
         for(block in program.blocks) {
@@ -194,7 +202,15 @@ class AsmGen(val options: CompilationOptions, val program: IntermediateProgram,
                 out("  jsr  ${block.scopedname}.${initVarsLabel.name}")
         }
         out("  clc")
-        out("  jmp  main.start\t; jump to program entrypoint")
+        when(zeropage.exitProgramStrategy) {
+            Zeropage.ExitProgramStrategy.CLEAN_EXIT -> {
+                out("  jmp  main.start\t; jump to program entrypoint")
+            }
+            Zeropage.ExitProgramStrategy.SYSTEM_RESET -> {
+                out("  jsr  main.start\t; call program entrypoint")
+                out("  jmp  (c64.RESET_VEC)\t; cold reset")
+            }
+        }
         out("")
 
         // the global list of all floating point constants for the whole program
@@ -277,10 +293,7 @@ class AsmGen(val options: CompilationOptions, val program: IntermediateProgram,
                 DataType.UWORD -> out("${v.first}\t.word  0")
                 DataType.WORD -> out("${v.first}\t.sint  0")
                 DataType.FLOAT -> out("${v.first}\t.byte  0,0,0,0,0  ; float")
-                DataType.STR,
-                DataType.STR_P,
-                DataType.STR_S,
-                DataType.STR_PS -> {
+                DataType.STR, DataType.STR_S -> {
                     val rawStr = heap.get(v.second.heapId).str!!
                     val bytes = encodeStr(rawStr, v.second.type).map { "$" + it.toString(16).padStart(2, '0') }
                     out("${v.first}\t; ${v.second.type} \"${escape(rawStr)}\"")
@@ -344,24 +357,14 @@ class AsmGen(val options: CompilationOptions, val program: IntermediateProgram,
     }
 
     private fun encodeStr(str: String, dt: DataType): List<Short> {
-        when(dt) {
+        return when(dt) {
             DataType.STR -> {
                 val bytes = Petscii.encodePetscii(str, true)
-                return bytes.plus(0)
-            }
-            DataType.STR_P -> {
-                val result = listOf(str.length.toShort())
-                val bytes = Petscii.encodePetscii(str, true)
-                return result.plus(bytes)
+                bytes.plus(0)
             }
             DataType.STR_S -> {
                 val bytes = Petscii.encodeScreencode(str, true)
-                return bytes.plus(0)
-            }
-            DataType.STR_PS -> {
-                val result = listOf(str.length.toShort())
-                val bytes = Petscii.encodeScreencode(str, true)
-                return result.plus(bytes)
+                bytes.plus(0)
             }
             else -> throw AssemblyError("invalid str type")
         }
@@ -498,8 +501,9 @@ class AsmGen(val options: CompilationOptions, val program: IntermediateProgram,
                     Syscall.FUNC_MAX_F,
                     Syscall.FUNC_MIN_F,
                     Syscall.FUNC_AVG_F,
-                    Syscall.FUNC_SUM_F -> " jsr  c64flt.${call.toString().toLowerCase()}"
-                    else -> " jsr  prog8_lib.${call.toString().toLowerCase()}"
+                    Syscall.FUNC_SUM_F -> " jsr  c64flt.${call.name.toLowerCase()}"
+                    null -> ""
+                    else -> " jsr  prog8_lib.${call.name.toLowerCase()}"
                 }
             }
             Opcode.BREAKPOINT -> {
@@ -870,30 +874,20 @@ class AsmGen(val options: CompilationOptions, val program: IntermediateProgram,
             Opcode.IDIV_W -> "  jsr  prog8_lib.idiv_w"
             Opcode.IDIV_UW -> "  jsr  prog8_lib.idiv_uw"
 
-            Opcode.AND_BYTE -> {
-                """
-                lda  ${(ESTACK_LO + 2).toHex()},x
-                and  ${(ESTACK_LO + 1).toHex()},x
-                inx
-                sta  ${(ESTACK_LO + 1).toHex()},x
-                """
-            }
-            Opcode.OR_BYTE -> {
-                """
-                lda  ${(ESTACK_LO + 2).toHex()},x
-                ora  ${(ESTACK_LO + 1).toHex()},x
-                inx
-                sta  ${(ESTACK_LO + 1).toHex()},x
-                """
-            }
-            Opcode.XOR_BYTE -> {
-                """
-                lda  ${(ESTACK_LO + 2).toHex()},x
-                eor  ${(ESTACK_LO + 1).toHex()},x
-                inx
-                sta  ${(ESTACK_LO + 1).toHex()},x
-                """
-            }
+            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"
 
@@ -3310,44 +3304,7 @@ class AsmGen(val options: CompilationOptions, val program: IntermediateProgram,
                     null
             },
 
-            // 16 bit addition avoiding excessive stack usage
-            // @todo optimize 8 and 16 bit adds and subs even more with longer asmpatterns (avoid stack use altogether on most common operations)
-            AsmPattern(listOf(Opcode.PUSH_VAR_WORD, Opcode.ADD_UW),
-                    listOf(Opcode.PUSH_VAR_WORD, Opcode.ADD_W)) { segment ->
-                """
-                clc
-                lda  ${segment[0].callLabel}
-                adc  ${(ESTACK_LO+1).toHex()},x
-                sta  ${(ESTACK_LO+1).toHex()},x
-                lda  ${segment[0].callLabel}+1
-                adc  ${(ESTACK_HI+1).toHex()},x
-                sta  ${(ESTACK_HI+1).toHex()},x
-                """
-            },
-            AsmPattern(listOf(Opcode.PUSH_MEM_UW, Opcode.ADD_UW),
-                    listOf(Opcode.PUSH_MEM_W, Opcode.ADD_W)) { segment ->
-                """
-                clc
-                lda  ${hexVal(segment[0])}
-                adc  ${(ESTACK_LO + 1).toHex()},x
-                sta  ${(ESTACK_LO + 1).toHex()},x
-                lda  ${hexValPlusOne(segment[0])}
-                adc  ${(ESTACK_HI + 1).toHex()},x
-                sta  ${(ESTACK_HI + 1).toHex()},x
-                """
-            },
-            AsmPattern(listOf(Opcode.PUSH_WORD, Opcode.ADD_UW),
-                    listOf(Opcode.PUSH_WORD, Opcode.ADD_W)) { segment ->
-                """
-                clc
-                lda  #<${hexVal(segment[0])}
-                adc  ${(ESTACK_LO+1).toHex()},x
-                sta  ${(ESTACK_LO+1).toHex()},x
-                lda  #>${hexVal(segment[0])}
-                adc  ${(ESTACK_HI+1).toHex()},x
-                sta  ${(ESTACK_HI+1).toHex()},x
-                """
-            },
+            // @todo optimize 8 and 16 bit adds and subs (avoid stack use altogether on most common operations)
 
             AsmPattern(listOf(Opcode.PUSH_VAR_BYTE, Opcode.CMP_B), listOf(Opcode.PUSH_VAR_BYTE, Opcode.CMP_UB)) { segment ->
                 // this pattern is encountered as part of the loop bound condition in for loops (var + cmp + jz/jnz)

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

@@ -29,27 +29,56 @@ class C64Zeropage(options: CompilationOptions) : Zeropage(options) {
         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
+        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.zeropage== ZeropageType.FULL) {
+        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) {
-                // add the Zp addresses that are just used by BASIC routines to the free list
-                free.addAll(listOf(0x09, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f, 0x10, 0x11,
+            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, 0x6f, 0x70))
+                        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'
+                ))
             }
-            // add the other free Zp addresses
-            // these are valid for the C-64 (when no RS232 I/O is performed):
-            free.addAll(listOf(0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0d, 0x0e,
+
+            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))
         }

compiler/src/prog8/functions/BuiltinFunctions.kt

@@ -26,10 +26,11 @@ val BuiltinFunctions = mapOf(
     "lsl"         to FunctionSignature(false, listOf(BuiltinFunctionParam("item", IntegerDatatypes)), null),
     "lsr"         to FunctionSignature(false, listOf(BuiltinFunctionParam("item", IntegerDatatypes)), null),
         // these few have a return value depending on the argument(s):
-    "max"         to FunctionSignature(true, listOf(BuiltinFunctionParam("values", ArrayDatatypes)), null) { a, p, n, h -> collectionArgOutputNumber(a, p, n, h) { it.max()!! }},        // type depends on args
-    "min"         to FunctionSignature(true, listOf(BuiltinFunctionParam("values", ArrayDatatypes)), null) { a, p, n, h -> collectionArgOutputNumber(a, p, n, h) { it.min()!! }},        // type depends on args
-    "sum"         to FunctionSignature(true, listOf(BuiltinFunctionParam("values", ArrayDatatypes)), null) { a, p, n, h -> collectionArgOutputNumber(a, p, n, h) { it.sum() }},        // type depends on args
+    "max"         to FunctionSignature(true, listOf(BuiltinFunctionParam("values", ArrayDatatypes)), null) { a, p, n, h -> collectionArgOutputNumber(a, p, n, h) { it.max()!! }},    // type depends on args
+    "min"         to FunctionSignature(true, listOf(BuiltinFunctionParam("values", ArrayDatatypes)), null) { a, p, n, h -> collectionArgOutputNumber(a, p, n, h) { it.min()!! }},    // type depends on args
+    "sum"         to FunctionSignature(true, listOf(BuiltinFunctionParam("values", ArrayDatatypes)), null) { a, p, n, h -> collectionArgOutputNumber(a, p, n, h) { it.sum() }},      // type depends on args
     "abs"         to FunctionSignature(true, listOf(BuiltinFunctionParam("value", NumericDatatypes)), null, ::builtinAbs),      // type depends on argument
+    "len"         to FunctionSignature(true, listOf(BuiltinFunctionParam("values", IterableDatatypes)), null, ::builtinLen),    // type is UBYTE or UWORD depending on actual length
         // normal functions follow:
     "sin"         to FunctionSignature(true, listOf(BuiltinFunctionParam("rads", setOf(DataType.FLOAT))), DataType.FLOAT) { a, p, n, h -> oneDoubleArg(a, p, n, h, Math::sin) },
     "sin8"        to FunctionSignature(true, listOf(BuiltinFunctionParam("angle8", setOf(DataType.UBYTE))), DataType.BYTE, ::builtinSin8 ),
@@ -53,7 +54,6 @@ val BuiltinFunctions = mapOf(
     "round"       to FunctionSignature(true, listOf(BuiltinFunctionParam("value", setOf(DataType.FLOAT))), DataType.FLOAT) { a, p, n, h -> oneDoubleArgOutputWord(a, p, n, h, Math::round) },
     "floor"       to FunctionSignature(true, listOf(BuiltinFunctionParam("value", setOf(DataType.FLOAT))), DataType.FLOAT) { a, p, n, h -> oneDoubleArgOutputWord(a, p, n, h, Math::floor) },
     "ceil"        to FunctionSignature(true, listOf(BuiltinFunctionParam("value", setOf(DataType.FLOAT))), DataType.FLOAT) { a, p, n, h -> oneDoubleArgOutputWord(a, p, n, h, Math::ceil) },
-    "len"         to FunctionSignature(true, listOf(BuiltinFunctionParam("values", IterableDatatypes)), DataType.UWORD, ::builtinLen),
     "any"         to FunctionSignature(true, listOf(BuiltinFunctionParam("values", ArrayDatatypes)), DataType.UBYTE) { a, p, n, h -> collectionArgOutputBoolean(a, p, n, h) { it.any { v -> v != 0.0} }},
     "all"         to FunctionSignature(true, listOf(BuiltinFunctionParam("values", ArrayDatatypes)), DataType.UBYTE) { a, p, n, h -> collectionArgOutputBoolean(a, p, n, h) { it.all { v -> v != 0.0} }},
     "lsb"         to FunctionSignature(true, listOf(BuiltinFunctionParam("value", setOf(DataType.UWORD, DataType.WORD))), DataType.UBYTE) { a, p, n, h -> oneIntArgOutputInt(a, p, n, h) { x: Int -> x and 255 }},
@@ -70,15 +70,16 @@ val BuiltinFunctions = mapOf(
     "clear_carry" to FunctionSignature(false, emptyList(), null),
     "set_irqd"    to FunctionSignature(false, emptyList(), null),
     "clear_irqd"  to FunctionSignature(false, emptyList(), null),
+    "read_flags"  to FunctionSignature(false, emptyList(), DataType.UBYTE),
     "swap"        to FunctionSignature(false, listOf(BuiltinFunctionParam("first", NumericDatatypes), BuiltinFunctionParam("second", NumericDatatypes)), null),
     "memcopy"     to FunctionSignature(false, listOf(
                                                         BuiltinFunctionParam("from", IterableDatatypes + setOf(DataType.UWORD)),
                                                         BuiltinFunctionParam("to", IterableDatatypes + setOf(DataType.UWORD)),
-                                                        BuiltinFunctionParam("numbytes", IntegerDatatypes)), null),
+                                                        BuiltinFunctionParam("numbytes", setOf(DataType.UBYTE))), null),
     "memset"      to FunctionSignature(false, listOf(
                                                         BuiltinFunctionParam("address", IterableDatatypes + setOf(DataType.UWORD)),
                                                         BuiltinFunctionParam("numbytes", setOf(DataType.UWORD)),
-                                                        BuiltinFunctionParam("bytevalue", setOf(DataType.UBYTE, DataType.BYTE))), null),
+                                                        BuiltinFunctionParam("bytevalue", ByteDatatypes)), null),
     "memsetw"     to FunctionSignature(false, listOf(
                                                         BuiltinFunctionParam("address", IterableDatatypes + setOf(DataType.UWORD)),
                                                         BuiltinFunctionParam("numwords", setOf(DataType.UWORD)),
@@ -111,7 +112,7 @@ val BuiltinFunctions = mapOf(
 
 fun builtinFunctionReturnType(function: String, args: List<IExpression>, namespace: INameScope, heap: HeapValues): DataType? {
 
-    fun datatypeFromListArg(arglist: IExpression): DataType {
+    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) {
                 val dt = arglist.arrayvalue!!.map {it.resultingDatatype(namespace, heap)}
@@ -126,17 +127,17 @@ fun builtinFunctionReturnType(function: String, args: List<IExpression>, namespa
         if(arglist is IdentifierReference) {
             val dt = arglist.resultingDatatype(namespace, heap)
             return when(dt) {
-                DataType.UBYTE, DataType.BYTE, DataType.UWORD, DataType.WORD, DataType.FLOAT,
-                DataType.STR, DataType.STR_P, DataType.STR_S, DataType.STR_PS -> dt
+                in NumericDatatypes -> dt!!
+                in StringDatatypes -> dt!!
                 DataType.ARRAY_UB -> DataType.UBYTE
                 DataType.ARRAY_B -> DataType.BYTE
                 DataType.ARRAY_UW -> DataType.UWORD
                 DataType.ARRAY_W -> DataType.WORD
                 DataType.ARRAY_F -> DataType.FLOAT
-                null -> throw FatalAstException("function requires one argument which is an arrayspec $function")
+                else -> throw FatalAstException("function '$function' requires one argument which is an iterable")
             }
         }
-        throw FatalAstException("function requires one argument which is an arrayspec $function")
+        throw FatalAstException("function '$function' requires one argument which is an iterable")
     }
 
     val func = BuiltinFunctions.getValue(function)
@@ -145,20 +146,30 @@ fun builtinFunctionReturnType(function: String, args: List<IExpression>, namespa
     // function has return values, but the return type depends on the arguments
 
     return when (function) {
-        "max", "min", "abs" -> {
-            val dt = datatypeFromListArg(args.single())
+        "abs" -> {
+            val dt = args.single().resultingDatatype(namespace, heap)
             when(dt) {
-                DataType.UBYTE, DataType.BYTE, DataType.UWORD, DataType.WORD, DataType.FLOAT -> dt
-                DataType.STR, DataType.STR_P, DataType.STR_S, DataType.STR_PS -> DataType.UBYTE
+                in ByteDatatypes -> DataType.UBYTE
+                in WordDatatypes -> DataType.UWORD
+                DataType.FLOAT -> DataType.FLOAT
+                else -> throw FatalAstException("weird datatype passed to abs $dt")
+            }
+        }
+        "max", "min" -> {
+            val dt = datatypeFromIterableArg(args.single())
+            when(dt) {
+                in NumericDatatypes -> dt
+                in StringDatatypes -> DataType.UBYTE
                 DataType.ARRAY_UB -> DataType.UBYTE
                 DataType.ARRAY_B -> DataType.BYTE
                 DataType.ARRAY_UW -> DataType.UWORD
                 DataType.ARRAY_W -> DataType.WORD
                 DataType.ARRAY_F -> DataType.FLOAT
+                else -> null
             }
         }
         "sum" -> {
-            val dt=datatypeFromListArg(args.single())
+            val dt=datatypeFromIterableArg(args.single())
             when(dt) {
                 DataType.UBYTE, DataType.UWORD -> DataType.UWORD
                 DataType.BYTE, DataType.WORD -> DataType.WORD
@@ -166,9 +177,15 @@ fun builtinFunctionReturnType(function: String, args: List<IExpression>, namespa
                 DataType.ARRAY_UB, DataType.ARRAY_UW -> DataType.UWORD
                 DataType.ARRAY_B, DataType.ARRAY_W -> DataType.WORD
                 DataType.ARRAY_F -> DataType.FLOAT
-                DataType.STR, DataType.STR_P, DataType.STR_S, DataType.STR_PS -> DataType.UWORD
+                in StringDatatypes -> DataType.UWORD
+                else -> null
             }
         }
+        "len" -> {
+            // a length can be >255 so in that case, the result is an UWORD instead of an UBYTE
+            // but to avoid a lot of code duplication we simply assume UWORD in all cases for now
+            return DataType.UWORD
+        }
         else -> return null
     }
 }
@@ -286,7 +303,7 @@ private fun builtinAvg(args: List<IExpression>, position: Position, namespace:IN
 }
 
 private fun builtinLen(args: List<IExpression>, position: Position, namespace:INameScope, heap: HeapValues): LiteralValue {
-    // note: in some cases the length is > 255 and so we have to return a UWORD type instead of a byte.
+    // note: in some cases the length is > 255 and then we have to return a UWORD type instead of a UBYTE.
     if(args.size!=1)
         throw SyntaxError("len requires one argument", position)
     var argument = args[0].constValue(namespace, heap)
@@ -303,23 +320,22 @@ private fun builtinLen(args: List<IExpression>, position: Position, namespace:IN
             val arraySize = argument.arrayvalue?.size ?: heap.get(argument.heapId!!).arraysize
             if(arraySize>256)
                 throw CompilerException("array length exceeds byte limit ${argument.position}")
-            LiteralValue(DataType.UWORD, wordvalue=arraySize, position=args[0].position)
+            LiteralValue.optimalInteger(arraySize, args[0].position)
         }
         DataType.ARRAY_F -> {
             val arraySize = argument.arrayvalue?.size ?: heap.get(argument.heapId!!).arraysize
             if(arraySize>256)
                 throw CompilerException("array length exceeds byte limit ${argument.position}")
-            LiteralValue(DataType.UWORD, wordvalue=arraySize, position=args[0].position)
+            LiteralValue.optimalInteger(arraySize, args[0].position)
         }
-        DataType.STR, DataType.STR_P, DataType.STR_S, DataType.STR_PS -> {
+        in StringDatatypes -> {
             val str = argument.strvalue(heap)
             if(str.length>255)
                 throw CompilerException("string length exceeds byte limit ${argument.position}")
-            LiteralValue(DataType.UWORD, wordvalue=str.length, position=args[0].position)
+            LiteralValue.optimalInteger(str.length, args[0].position)
         }
-        DataType.UBYTE, DataType.BYTE,
-        DataType.UWORD, DataType.WORD,
-        DataType.FLOAT -> throw SyntaxError("len of weird argument ${args[0]}", position)
+        in NumericDatatypes -> throw SyntaxError("len of weird argument ${args[0]}", position)
+        else -> throw CompilerException("weird datatype")
     }
 }
 

compiler/src/prog8/optimizing/ConstantFolding.kt

@@ -33,7 +33,7 @@ class ConstantFolding(private val namespace: INameScope, private val heap: HeapV
 
         if(decl.type==VarDeclType.CONST || decl.type==VarDeclType.VAR) {
             val litval = decl.value as? LiteralValue
-            if(litval!=null && litval.isArray)
+            if(litval!=null && litval.isArray && litval.heapId!=null)
                 fixupArrayTypeOnHeap(decl, litval)
             when(decl.datatype) {
                 DataType.FLOAT -> {
@@ -97,9 +97,10 @@ class ConstantFolding(private val namespace: INameScope, private val heap: HeapV
     private fun fixupArrayTypeOnHeap(decl: VarDecl, litval: LiteralValue) {
         // fix the type of the array value that's on the heap, to match the vardecl.
         // notice that checking the bounds of the actual values is not done here, but in the AstChecker later.
+
         if(decl.datatype==litval.type)
             return   // already correct datatype
-        val heapId = litval.heapId!!
+        val heapId = litval.heapId ?: throw FatalAstException("expected array to be on heap $litval")
         val array=heap.get(heapId)
         when(decl.datatype) {
             DataType.ARRAY_UB, DataType.ARRAY_B, DataType.ARRAY_UW, DataType.ARRAY_W -> {
@@ -141,6 +142,7 @@ class ConstantFolding(private val namespace: INameScope, private val heap: HeapV
     override fun process(functionCall: FunctionCall): IExpression {
         return try {
             super.process(functionCall)
+            typeCastConstArguments(functionCall)
             functionCall.constValue(namespace, heap) ?: functionCall
         } catch (ax: AstException) {
             addError(ax)
@@ -148,6 +150,31 @@ class ConstantFolding(private val namespace: INameScope, private val heap: HeapV
         }
     }
 
+    override fun process(functionCallStatement: FunctionCallStatement): IStatement {
+        super.process(functionCallStatement)
+        typeCastConstArguments(functionCallStatement)
+        return functionCallStatement
+    }
+
+    private fun typeCastConstArguments(functionCall: IFunctionCall) {
+        val subroutine = functionCall.target.targetStatement(namespace) as? Subroutine
+        if(subroutine!=null) {
+            // if types differ, try to typecast constant arguments to the function call to the desired data type of the parameter
+            for(arg in functionCall.arglist.withIndex().zip(subroutine.parameters)) {
+                val expectedDt = arg.second.type
+                val argConst = arg.first.value.constValue(namespace, heap)
+                if(argConst!=null && argConst.type!=expectedDt) {
+                    val convertedValue = argConst.intoDatatype(expectedDt)
+                    if(convertedValue!=null) {
+                        functionCall.arglist[arg.first.index] = convertedValue
+                        optimizationsDone++
+                    }
+                }
+            }
+        }
+    }
+
+
     /**
      * Try to process a unary prefix expression.
      * Compile-time constant sub expressions will be evaluated on the spot.
@@ -507,7 +534,7 @@ class ConstantFolding(private val namespace: INameScope, private val heap: HeapV
             if(literalValue.strvalue(heap).length !in 1..255)
                 addError(ExpressionError("string literal length must be between 1 and 255", literalValue.position))
             else {
-                val heapId = heap.add(literalValue.type, literalValue.strvalue(heap))     // TODO: we don't know the actual string type yet, STR != STR_P etc...
+                val heapId = heap.add(literalValue.type, literalValue.strvalue(heap))     // TODO: we don't know the actual string type yet, STR != STR_S etc...
                 val newValue = LiteralValue(literalValue.type, heapId = heapId, position = literalValue.position)
                 return super.process(newValue)
             }

compiler/src/prog8/optimizing/SimplifyExpressions.kt

@@ -75,7 +75,7 @@ class SimplifyExpressions(private val namespace: INameScope, private val heap: H
         val leftDt = expr.left.resultingDatatype(namespace, heap)
         val rightDt = expr.right.resultingDatatype(namespace, heap)
         if (leftDt != null && rightDt != null && leftDt != rightDt) {
-            // try to convert a datatype into the other
+            // try to convert a datatype into the other (where ddd
             if (adjustDatatypes(expr, leftVal, leftDt, rightVal, rightDt)) {
                 optimizationsDone++
                 return expr
@@ -347,26 +347,37 @@ class SimplifyExpressions(private val namespace: INameScope, private val heap: H
         }
 
         if(leftConstVal==null && rightConstVal!=null) {
-            val (adjusted, newValue) = adjust(rightConstVal, leftDt)
-            if(adjusted) {
-                expr.right = newValue
-                optimizationsDone++
-                return true
+            if(isBiggerType(leftDt, rightDt)) {
+                val (adjusted, newValue) = adjust(rightConstVal, leftDt)
+                if (adjusted) {
+                    expr.right = newValue
+                    optimizationsDone++
+                    return true
+                }
             }
             return false
         } else if(leftConstVal!=null && rightConstVal==null) {
-            val (adjusted, newValue) = adjust(leftConstVal, rightDt)
-            if(adjusted) {
-                expr.left = newValue
-                optimizationsDone++
-                return true
+            if(isBiggerType(rightDt, leftDt)) {
+                val (adjusted, newValue) = adjust(leftConstVal, rightDt)
+                if (adjusted) {
+                    expr.left = newValue
+                    optimizationsDone++
+                    return true
+                }
             }
             return false
         } else {
-            return false
+            return false    // two const values, don't adjust (should have been const-folded away)
         }
     }
 
+    private fun isBiggerType(type: DataType, other: DataType) =
+        when(type) {
+            in ByteDatatypes -> false
+            in WordDatatypes -> other in ByteDatatypes
+            else -> true
+        }
+
 
     private data class ReorderedAssociativeBinaryExpr(val expr: BinaryExpression, val leftVal: LiteralValue?, val rightVal: LiteralValue?)
 

compiler/src/prog8/optimizing/StatementOptimizer.kt

@@ -8,6 +8,9 @@ import kotlin.math.floor
 
 
 /*
+    todo: subroutines with 1 or 2 byte args or 1 word arg can be converted to asm sub calling convention (args in registers)
+
+
     todo: implement usage counters for blocks, variables, subroutines, heap variables. Then:
         todo remove unused blocks
         todo remove unused variables
@@ -52,6 +55,18 @@ class StatementOptimizer(private val namespace: INameScope, private val heap: He
             linesToRemove.reversed().forEach{subroutine.statements.removeAt(it)}
         }
 
+        if(subroutine.canBeAsmSubroutine) {
+            optimizationsDone++
+            return subroutine.intoAsmSubroutine()   // TODO this doesn't work yet due to parameter vardecl issue
+
+            // TODO fix parameter passing so this also works:
+//            asmsub aa(byte arg @ Y) -> clobbers() -> () {
+//                byte local = arg            ; @todo fix 'undefined symbol arg' by some sort of alias name for the parameter
+//                A=44
+//            }
+
+        }
+
         return subroutine
     }
 
@@ -80,16 +95,6 @@ class StatementOptimizer(private val namespace: INameScope, private val heap: He
         return linesToRemove
     }
 
-    private fun returnregisters(subroutine: Subroutine): List<RegisterOrStatusflag> {
-        return when {
-            subroutine.returntypes.isEmpty() -> listOf()
-            subroutine.returntypes.size==1 && subroutine.returntypes[0] in setOf(DataType.BYTE, DataType.UBYTE) -> listOf(RegisterOrStatusflag(RegisterOrPair.A, null, null))
-            subroutine.returntypes.size==1 && subroutine.returntypes[0] in setOf(DataType.WORD, DataType.UWORD) -> listOf(RegisterOrStatusflag(RegisterOrPair.AY, null, null))
-            subroutine.returntypes.size==2 && subroutine.returntypes.all { it in setOf(DataType.BYTE, DataType.UBYTE)} -> listOf(RegisterOrStatusflag(RegisterOrPair.A, null, null), RegisterOrStatusflag(RegisterOrPair.Y, null, null))
-            else -> throw FatalAstException("can't convert return values to registers")
-        }
-    }
-
     private fun isNotMemory(target: AssignTarget): Boolean {
         if(target.register!=null)
             return true
@@ -109,39 +114,39 @@ class StatementOptimizer(private val namespace: INameScope, private val heap: He
     }
 
 
-    override fun process(functionCall: FunctionCallStatement): IStatement {
-        if(functionCall.target.nameInSource.size==1 && functionCall.target.nameInSource[0] in BuiltinFunctions) {
-            val functionName = functionCall.target.nameInSource[0]
+    override fun process(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)", functionCall.position)
-                statementsToRemove.add(functionCall)
-                return functionCall
+                printWarning("statement has no effect (function return value is discarded)", functionCallStatement.position)
+                statementsToRemove.add(functionCallStatement)
+                return functionCallStatement
             }
         }
 
-        if(functionCall.target.nameInSource==listOf("c64scr", "print") ||
-                functionCall.target.nameInSource==listOf("c64scr", "print_p")) {
+        if(functionCallStatement.target.nameInSource==listOf("c64scr", "print") ||
+                functionCallStatement.target.nameInSource==listOf("c64scr", "print_p")) {
             // printing a literal string of just 2 or 1 characters is replaced by directly outputting those characters
-            if(functionCall.arglist.single() is LiteralValue)
+            if(functionCallStatement.arglist.single() is LiteralValue)
                 throw AstException("string argument should be on heap already")
-            val stringVar = functionCall.arglist.single() as? IdentifierReference
+            val stringVar = functionCallStatement.arglist.single() as? IdentifierReference
             if(stringVar!=null) {
                 val heapId = stringVar.heapId(namespace)
                 val string = heap.get(heapId).str!!
                 if(string.length==1) {
                     val petscii = Petscii.encodePetscii(string, true)[0]
-                    functionCall.arglist.clear()
-                    functionCall.arglist.add(LiteralValue.optimalInteger(petscii, functionCall.position))
-                    functionCall.target = IdentifierReference(listOf("c64", "CHROUT"), functionCall.target.position)
+                    functionCallStatement.arglist.clear()
+                    functionCallStatement.arglist.add(LiteralValue.optimalInteger(petscii, functionCallStatement.position))
+                    functionCallStatement.target = IdentifierReference(listOf("c64", "CHROUT"), functionCallStatement.target.position)
                     optimizationsDone++
-                    return functionCall
+                    return functionCallStatement
                 } else if(string.length==2) {
                     val petscii = Petscii.encodePetscii(string, true)
-                    val scope = AnonymousScope(mutableListOf(), functionCall.position)
-                    scope.statements.add(FunctionCallStatement(IdentifierReference(listOf("c64", "CHROUT"), functionCall.target.position),
-                            mutableListOf(LiteralValue.optimalInteger(petscii[0], functionCall.position)), functionCall.position))
-                    scope.statements.add(FunctionCallStatement(IdentifierReference(listOf("c64", "CHROUT"), functionCall.target.position),
-                            mutableListOf(LiteralValue.optimalInteger(petscii[1], functionCall.position)), functionCall.position))
+                    val scope = AnonymousScope(mutableListOf(), functionCallStatement.position)
+                    scope.statements.add(FunctionCallStatement(IdentifierReference(listOf("c64", "CHROUT"), functionCallStatement.target.position),
+                            mutableListOf(LiteralValue.optimalInteger(petscii[0], functionCallStatement.position)), functionCallStatement.position))
+                    scope.statements.add(FunctionCallStatement(IdentifierReference(listOf("c64", "CHROUT"), functionCallStatement.target.position),
+                            mutableListOf(LiteralValue.optimalInteger(petscii[1], functionCallStatement.position)), functionCallStatement.position))
                     optimizationsDone++
                     return scope
                 }
@@ -151,20 +156,20 @@ class StatementOptimizer(private val namespace: INameScope, private val heap: He
         // 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, replace with a nop instruction
-        val subroutine = functionCall.target.targetStatement(namespace) as? Subroutine
+        val subroutine = functionCallStatement.target.targetStatement(namespace) as? Subroutine
         if(subroutine!=null) {
             val first = subroutine.statements.asSequence().filterNot { it is VarDecl || it is Directive }.firstOrNull()
             if(first is Jump && first.identifier!=null) {
                 optimizationsDone++
-                return FunctionCallStatement(first.identifier, functionCall.arglist, functionCall.position)
+                return FunctionCallStatement(first.identifier, functionCallStatement.arglist, functionCallStatement.position)
             }
             if(first is ReturnFromIrq || first is Return) {
                 optimizationsDone++
-                return NopStatement(functionCall.position)
+                return NopStatement(functionCallStatement.position)
             }
         }
 
-        return super.process(functionCall)
+        return super.process(functionCallStatement)
     }
 
     override fun process(functionCall: FunctionCall): IExpression {

compiler/src/prog8/parser/ModuleParsing.kt

@@ -26,8 +26,12 @@ private class LexerErrorListener: BaseErrorListener() {
 }
 
 
-fun importModule(stream: CharStream, moduleName: String, isLibrary: Boolean): Module {
-    val lexer = prog8Lexer(stream)
+internal class CustomLexer(val modulePath: Path, input: CharStream?) : prog8Lexer(input)
+
+
+fun importModule(stream: CharStream, modulePath: Path, isLibrary: Boolean): Module {
+    val moduleName = modulePath.fileName
+    val lexer = CustomLexer(modulePath, stream)
     val lexerErrors = LexerErrorListener()
     lexer.addErrorListener(lexerErrors)
     val tokens = CommentHandlingTokenStream(lexer)
@@ -35,13 +39,13 @@ fun importModule(stream: CharStream, moduleName: String, isLibrary: Boolean): Mo
     val parseTree = parser.module()
     val numberOfErrors = parser.numberOfSyntaxErrors + lexerErrors.numberOfErrors
     if(numberOfErrors > 0)
-        throw ParsingFailedError("There are $numberOfErrors errors in '$moduleName.p8'.")
+        throw ParsingFailedError("There are $numberOfErrors errors in '$moduleName'.")
 
     // You can do something with the parsed comments:
     // tokens.commentTokens().forEach { println(it) }
 
     // convert to Ast
-    val moduleAst = parseTree.toAst(moduleName, isLibrary, Paths.get(stream.sourceName))
+    val moduleAst = parseTree.toAst(moduleName.toString(), isLibrary, modulePath)
     importedModules[moduleAst.name] = moduleAst
 
     // process imports
@@ -63,7 +67,7 @@ fun importModule(stream: CharStream, moduleName: String, isLibrary: Boolean): Mo
             .asSequence()
             .mapIndexed { i, it -> Pair(i, it) }
             .filter { (it.second as? Directive)?.directive == "%import" }
-            .map { Pair(it.first, executeImportDirective(it.second as Directive, Paths.get("$moduleName.p8"))) }
+            .map { Pair(it.first, executeImportDirective(it.second as Directive, modulePath)) }
             .toList()
 
     imports.reversed().forEach {
@@ -95,9 +99,8 @@ fun importModule(filePath: Path) : Module {
     if(!Files.isReadable(filePath))
         throw ParsingFailedError("No such file: $filePath")
 
-    val moduleName = filePath.fileName.toString().substringBeforeLast('.')
     val input = CharStreams.fromPath(filePath)
-    return importModule(input, moduleName, filePath.parent==null)
+    return importModule(input, filePath, filePath.parent==null)
 }
 
 
@@ -136,7 +139,7 @@ private fun executeImportDirective(import: Directive, importedFrom: Path): Modul
             // load the module from the embedded resource
             resource.use {
                 println("importing '$moduleName' (embedded library)")
-                importModule(CharStreams.fromStream(it), moduleName, true)
+                importModule(CharStreams.fromStream(it), Paths.get("@embedded@/$moduleName"), true)
             }
         } else {
             val modulePath = discoverImportedModuleFile(moduleName, importedFrom, import.position)

compiler/src/prog8/stackvm/Program.kt

@@ -1,8 +1,6 @@
 package prog8.stackvm
 
-import prog8.ast.DataType
-import prog8.ast.Position
-import prog8.ast.unescape
+import prog8.ast.*
 import prog8.compiler.HeapValues
 import prog8.compiler.intermediate.*
 import java.io.File
@@ -88,10 +86,7 @@ class Program (val name: String,
             }
             heapvalues.sortedBy { it.first }.forEach {
                 when(it.second) {
-                    DataType.STR,
-                    DataType.STR_P,
-                    DataType.STR_S,
-                    DataType.STR_PS -> heap.add(it.second, unescape(it.third.substring(1, it.third.length-1), Position("<stackvmsource>", 0, 0, 0)))
+                    DataType.STR, DataType.STR_S -> heap.add(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(',')
@@ -103,7 +98,8 @@ class Program (val name: String,
                         val doublearray = numbers.map{number->number.trim().toDouble()}.toDoubleArray()
                         heap.add(it.second, doublearray)
                     }
-                    DataType.UBYTE, DataType.BYTE, DataType.UWORD, DataType.WORD, DataType.FLOAT -> throw VmExecutionException("invalid heap value type ${it.second}")
+                    in NumericDatatypes -> throw VmExecutionException("invalid heap value type ${it.second}")
+                    else -> throw VmExecutionException("weird datatype")
                 }
             }
         }
@@ -200,7 +196,7 @@ class Program (val name: String,
                     DataType.UWORD -> Value(DataType.UWORD, valueStr.substring(3).toInt(16))
                     DataType.WORD -> Value(DataType.WORD, valueStr.substring(2).toInt(16))
                     DataType.FLOAT -> Value(DataType.FLOAT, valueStr.substring(2).toDouble())
-                    DataType.STR, DataType.STR_P, DataType.STR_S, DataType.STR_PS -> {
+                    in StringDatatypes -> {
                         if(valueStr.startsWith('"') && valueStr.endsWith('"'))
                             throw VmExecutionException("encountered a var with a string value, but all string values should already have been moved into the heap")
                         else if(!valueStr.startsWith("heap:"))
@@ -210,11 +206,7 @@ class Program (val name: String,
                             Value(type, heapId)
                         }
                     }
-                    DataType.ARRAY_UB,
-                    DataType.ARRAY_B,
-                    DataType.ARRAY_UW,
-                    DataType.ARRAY_W,
-                    DataType.ARRAY_F -> {
+                    in ArrayDatatypes -> {
                         if(!valueStr.startsWith("heap:"))
                             throw VmExecutionException("invalid array value, should be a heap reference")
                         else {
@@ -222,6 +214,7 @@ class Program (val name: String,
                             Value(type, heapId)
                         }
                     }
+                    else -> throw VmExecutionException("weird datatype")
                 }
                 vars[name] = value
             }

compiler/src/prog8/stackvm/StackVm.kt

@@ -49,9 +49,7 @@ enum class Syscall(val callNr: Short) {
     FUNC_RNDW(90),               // push a random word on the stack
     FUNC_RNDF(91),               // push a random float on the stack (between 0.0 and 1.0)
     FUNC_LEN_STR(105),
-    FUNC_LEN_STRP(106),
-    FUNC_LEN_STRS(107),
-    FUNC_LEN_STRPS(108),
+    FUNC_LEN_STRS(106),
     FUNC_ANY_B(109),
     FUNC_ANY_W(110),
     FUNC_ANY_F(111),
@@ -80,7 +78,8 @@ enum class Syscall(val callNr: Short) {
     FUNC_SUM_F(134),
     FUNC_MEMCOPY(138),
     FUNC_MEMSET(139),
-    FUNC_MEMSETW(140)
+    FUNC_MEMSETW(140),
+    FUNC_READ_FLAGS(141)
 
     // note: not all builtin functions of the Prog8 language are present as functions:
     // some of them are straight opcodes (such as MSB, LSB, LSL, LSR, ROL_BYTE, ROR, ROL2, ROR2, and FLT)!
@@ -922,9 +921,9 @@ class StackVm(private var traceOutputFile: String?) {
             }
             Opcode.POP_VAR_WORD -> {
                 val value = evalstack.pop()
-                checkDt(value, DataType.UWORD, DataType.WORD, DataType.STR, DataType.STR_P, DataType.STR_S, DataType.STR_PS)
+                checkDt(value, DataType.UWORD, DataType.WORD, DataType.STR, DataType.STR_S)
                 val variable = getVar(ins.callLabel!!)
-                checkDt(variable, DataType.UWORD, DataType.WORD, DataType.STR, DataType.STR_P, DataType.STR_S, DataType.STR_PS)
+                checkDt(variable, DataType.UWORD, DataType.WORD, DataType.STR, DataType.STR_S)
                 if(value.type!=variable.type)
                     throw VmExecutionException("datatype mismatch")
                 variables[ins.callLabel] = value
@@ -1322,7 +1321,7 @@ class StackVm(private var traceOutputFile: String?) {
                         when (array.type) {
                             DataType.ARRAY_UB -> evalstack.push(Value(DataType.UBYTE, array.array!![index]))
                             DataType.ARRAY_B -> evalstack.push(Value(DataType.BYTE, array.array!![index]))
-                            DataType.STR, DataType.STR_P, DataType.STR_S, DataType.STR_PS -> evalstack.push(Value(DataType.UBYTE, Petscii.encodePetscii(array.str!![index].toString(), true)[0]))
+                            DataType.STR, DataType.STR_S -> evalstack.push(Value(DataType.UBYTE, Petscii.encodePetscii(array.str!![index].toString(), true)[0]))
                             else -> throw VmExecutionException("not a proper array/string variable with byte elements")
                         }
                     }
@@ -1413,10 +1412,7 @@ class StackVm(private var traceOutputFile: String?) {
                         when (array.type) {
                             DataType.ARRAY_UB -> array.array!![index] = value.integerValue()
                             DataType.ARRAY_B -> array.array!![index] = value.integerValue()
-                            DataType.STR,
-                            DataType.STR_P,
-                            DataType.STR_S,
-                            DataType.STR_PS -> {
+                            DataType.STR, DataType.STR_S -> {
                                 val chars = array.str!!.toCharArray()
                                 chars[index] = Petscii.decodePetscii(listOf(value.integerValue().toShort()), true)[0]
                                 heap.update(variable.heapId, chars.joinToString(""))
@@ -1608,11 +1604,19 @@ class StackVm(private var traceOutputFile: String?) {
             Syscall.FUNC_RND -> evalstack.push(Value(DataType.UBYTE, rnd.nextInt() and 255))
             Syscall.FUNC_RNDW -> evalstack.push(Value(DataType.UWORD, rnd.nextInt() and 65535))
             Syscall.FUNC_RNDF -> evalstack.push(Value(DataType.FLOAT, rnd.nextDouble()))
-            Syscall.FUNC_LEN_STR, Syscall.FUNC_LEN_STRS, Syscall.FUNC_LEN_STRP, Syscall.FUNC_LEN_STRPS -> {
+            Syscall.FUNC_LEN_STR, Syscall.FUNC_LEN_STRS -> {
                 val strPtr = evalstack.pop().integerValue()
                 val text = heap.get(strPtr).str!!
                 evalstack.push(Value(DataType.UBYTE, text.length))
             }
+            Syscall.FUNC_READ_FLAGS -> {
+                val carry = if(P_carry) 1 else 0
+                val zero = if(P_zero) 2 else 0
+                val irqd = if(P_irqd) 4 else 0
+                val negative = if(P_negative) 128 else 0
+                val flags = carry or zero or irqd or negative
+                evalstack.push(Value(DataType.UBYTE, flags))
+            }
             Syscall.FUNC_SIN -> evalstack.push(Value(DataType.FLOAT, sin(evalstack.pop().numericValue().toDouble())))
             Syscall.FUNC_COS -> evalstack.push(Value(DataType.FLOAT, cos(evalstack.pop().numericValue().toDouble())))
             Syscall.FUNC_SIN8 -> {

compiler/test/StackVMOpcodeTests.kt

@@ -4,7 +4,10 @@ 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.HeapValues
 import prog8.compiler.intermediate.Instruction
 import prog8.compiler.intermediate.Opcode
@@ -1234,12 +1237,11 @@ class TestStackVmOpcodes {
 
     private fun pushOpcode(dt: DataType): Opcode {
         return when (dt) {
-            DataType.UBYTE, DataType.BYTE -> Opcode.PUSH_BYTE
-            DataType.UWORD, DataType.WORD -> Opcode.PUSH_WORD
+            in ByteDatatypes -> Opcode.PUSH_BYTE
+            in WordDatatypes -> Opcode.PUSH_WORD
+            in IterableDatatypes -> Opcode.PUSH_WORD
             DataType.FLOAT -> Opcode.PUSH_FLOAT
-            DataType.STR, DataType.STR_P, DataType.STR_S, DataType.STR_PS,
-            DataType.ARRAY_UB, DataType.ARRAY_UW, DataType.ARRAY_F,
-            DataType.ARRAY_B, DataType.ARRAY_W -> Opcode.PUSH_WORD
+            else -> throw IllegalArgumentException("invalid datatype")
         }
     }
 

compiler/test/UnitTests.kt

@@ -138,23 +138,41 @@ class TestZeropage {
         assertFailsWith<CompilerException> {
             zp.allocate("", DataType.FLOAT, null)
         }
-        val zp2 = C64Zeropage(CompilationOptions(OutputType.RAW, LauncherType.NONE, ZeropageType.FULL, emptyList(), true))
+        val zp2 = C64Zeropage(CompilationOptions(OutputType.RAW, LauncherType.NONE, ZeropageType.FLOATSAFE, emptyList(), true))
         zp2.allocate("", DataType.FLOAT, null)
     }
 
+    @Test
+    fun testZpModesWithFloats() {
+        C64Zeropage(CompilationOptions(OutputType.RAW, LauncherType.NONE, ZeropageType.FULL, emptyList(), false))
+        C64Zeropage(CompilationOptions(OutputType.RAW, LauncherType.NONE, ZeropageType.KERNALSAFE, emptyList(), false))
+        C64Zeropage(CompilationOptions(OutputType.RAW, LauncherType.NONE, ZeropageType.BASICSAFE, emptyList(), false))
+        C64Zeropage(CompilationOptions(OutputType.RAW, LauncherType.NONE, ZeropageType.FLOATSAFE, emptyList(), false))
+        C64Zeropage(CompilationOptions(OutputType.RAW, LauncherType.NONE, ZeropageType.BASICSAFE, emptyList(), true))
+        C64Zeropage(CompilationOptions(OutputType.RAW, LauncherType.NONE, ZeropageType.FLOATSAFE, emptyList(), true))
+        assertFailsWith<CompilerException> {
+            C64Zeropage(CompilationOptions(OutputType.RAW, LauncherType.NONE, ZeropageType.FULL, emptyList(), true))
+        }
+        assertFailsWith<CompilerException> {
+            C64Zeropage(CompilationOptions(OutputType.RAW, LauncherType.NONE, ZeropageType.KERNALSAFE, emptyList(), true))
+        }
+    }
+
     @Test
     fun testFreeSpaces() {
         val zp1 = C64Zeropage(CompilationOptions(OutputType.RAW, LauncherType.NONE, ZeropageType.BASICSAFE, emptyList(), true))
-        assertEquals(19, zp1.available())
-        val zp2 = C64Zeropage(CompilationOptions(OutputType.RAW, LauncherType.NONE, ZeropageType.KERNALSAFE, emptyList(), true))
-        assertEquals(67, zp2.available())
-        val zp3 = C64Zeropage(CompilationOptions(OutputType.RAW, LauncherType.NONE, ZeropageType.FULL, emptyList(), true))
-        assertEquals(238, zp3.available())
+        assertEquals(20, zp1.available())
+        val zp2 = C64Zeropage(CompilationOptions(OutputType.RAW, LauncherType.NONE, ZeropageType.FLOATSAFE, emptyList(), false))
+        assertEquals(95, zp2.available())
+        val zp3 = C64Zeropage(CompilationOptions(OutputType.RAW, LauncherType.NONE, ZeropageType.KERNALSAFE, emptyList(), false))
+        assertEquals(129, zp3.available())
+        val zp4 = C64Zeropage(CompilationOptions(OutputType.RAW, LauncherType.NONE, ZeropageType.FULL, emptyList(), false))
+        assertEquals(238, zp4.available())
     }
 
     @Test
     fun testReservedSpace() {
-        val zp1 = C64Zeropage(CompilationOptions(OutputType.RAW, LauncherType.NONE, ZeropageType.FULL, emptyList(), true))
+        val zp1 = C64Zeropage(CompilationOptions(OutputType.RAW, LauncherType.NONE, ZeropageType.FULL, emptyList(), false))
         assertEquals(238, zp1.available())
         assertTrue(50 in zp1.free)
         assertTrue(100 in zp1.free)
@@ -163,8 +181,7 @@ class TestZeropage {
         assertTrue(200 in zp1.free)
         assertTrue(255 in zp1.free)
         assertTrue(199 in zp1.free)
-        val zp2 = C64Zeropage(CompilationOptions(OutputType.RAW, LauncherType.NONE, ZeropageType.FULL,
-                listOf(50 .. 100, 200..255), true))
+        val zp2 = C64Zeropage(CompilationOptions(OutputType.RAW, LauncherType.NONE, ZeropageType.FULL, listOf(50 .. 100, 200..255), false))
         assertEquals(139, zp2.available())
         assertFalse(50 in zp2.free)
         assertFalse(100 in zp2.free)
@@ -178,7 +195,7 @@ class TestZeropage {
     @Test
     fun testBasicsafeAllocation() {
         val zp = C64Zeropage(CompilationOptions(OutputType.RAW, LauncherType.NONE, ZeropageType.BASICSAFE, emptyList(), true))
-        assertEquals(19, zp.available())
+        assertEquals(20, zp.available())
 
         zp.allocate("", DataType.FLOAT, null)
         assertFailsWith<ZeropageDepletedError> {
@@ -201,32 +218,28 @@ class TestZeropage {
 
     @Test
     fun testFullAllocation() {
-        val zp = C64Zeropage(CompilationOptions(OutputType.RAW, LauncherType.NONE, ZeropageType.FULL, emptyList(), true))
+        val zp = C64Zeropage(CompilationOptions(OutputType.RAW, LauncherType.NONE, ZeropageType.FULL, emptyList(), false))
         assertEquals(238, zp.available())
-        val loc = zp.allocate("", DataType.FLOAT, null)
+        val loc = zp.allocate("", DataType.UWORD, null)
         assertTrue(loc > 3)
         assertFalse(loc in zp.free)
-        val num = zp.available() / 5
-        val rest = zp.available() % 5
+        val num = zp.available() / 2
 
         for(i in 0..num-4) {
-            zp.allocate("", DataType.FLOAT, null)
+            zp.allocate("", DataType.UWORD, null)
         }
-        assertEquals(18,zp.available())
+        assertEquals(6,zp.available())
 
         assertFailsWith<ZeropageDepletedError> {
             // can't allocate because no more sequential bytes, only fragmented
-            zp.allocate("", DataType.FLOAT, null)
+            zp.allocate("", DataType.UWORD, null)
         }
 
-        for(i in 0..13) {
+        for(i in 0..5) {
             zp.allocate("", DataType.UBYTE, null)
         }
-        zp.allocate("", DataType.UWORD, null)
 
-        assertEquals(2, zp.available())
-        zp.allocate("", DataType.UBYTE, null)
-        zp.allocate("", DataType.UBYTE, null)
+        assertEquals(0, zp.available())
         assertFailsWith<ZeropageDepletedError> {
             // no more space
             zp.allocate("", DataType.UBYTE, null)
@@ -236,7 +249,7 @@ class TestZeropage {
     @Test
     fun testEfficientAllocation() {
         val zp = C64Zeropage(CompilationOptions(OutputType.RAW, LauncherType.NONE, ZeropageType.BASICSAFE, emptyList(),  true))
-        assertEquals(19, zp.available())
+        assertEquals(20, zp.available())
         assertEquals(0x04, zp.allocate("", DataType.FLOAT, null))
         assertEquals(0x09, zp.allocate("", DataType.UBYTE, null))
         assertEquals(0x0d, zp.allocate("", DataType.UWORD, null))
@@ -245,6 +258,7 @@ class TestZeropage {
         assertEquals(0xa9, zp.allocate("", DataType.UWORD, null))
         assertEquals(0xb5, zp.allocate("", DataType.UWORD, null))
         assertEquals(0xf7, zp.allocate("", DataType.UWORD, null))
+        assertEquals(0x0a, zp.allocate("", DataType.UBYTE, null))
         assertEquals(0xf9, zp.allocate("", DataType.UBYTE, null))
         assertEquals(0, zp.available())
     }

compiler/test/ValueOperationsTests.kt

@@ -82,7 +82,6 @@ class TestStackVmValue {
     fun testEqualsAndNotEqualsHeapTypes()
     {
         assertTrue(sameValueAndType(Value(DataType.STR, 999), Value(DataType.STR, 999)))
-        assertFalse(sameValueAndType(Value(DataType.STR, 999), Value(DataType.STR_P, 999)))
         assertFalse(sameValueAndType(Value(DataType.STR, 999), Value(DataType.STR, 222)))
 
         assertTrue(sameValueAndType(Value(DataType.ARRAY_UB, 99), Value(DataType.ARRAY_UB, 99)))

docs/docs.iml

@@ -5,7 +5,7 @@
     <content url="file://$MODULE_DIR$">
       <excludeFolder url="file://$MODULE_DIR$/build" />
     </content>
-    <orderEntry type="jdk" jdkName="Python 3.7" jdkType="Python SDK" />
+    <orderEntry type="jdk" jdkName="Python 3.7 (py3)" jdkType="Python SDK" />
     <orderEntry type="sourceFolder" forTests="false" />
   </component>
 </module>

docs/source/building.rst

@@ -2,8 +2,33 @@
 Writing and building a program
 ==============================
 
-What is a "Program" anyway?
----------------------------
+First, getting a working compiler
+---------------------------------
+
+Before you can compile Prog8 programs, you'll have to build the compiler itself.
+First make sure you have installed the :ref:`requirements`.
+Then you can choose a few ways to create the compiler:
+
+**Using the shell script:**
+
+#. 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.
+
+**using the Gradle build system:**
+
+#. 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.
+
+**download a precompiled version from github:**
+
+#. 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?
+---------------------------------
 
 A "complete runnable program" is a compiled, assembled, and linked together single unit.
 It contains all of the program's code and data and has a certain file format that

docs/source/index.rst

@@ -120,8 +120,12 @@ A recent .exe version of this tool for Windows can be obtained from my `clone <h
 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.
 
-A C-64 emulator or a real C-64 to run the programs on. The compiler assumes the presence
+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::
@@ -130,11 +134,16 @@ of the `Vice emulator <http://vice-emu.sourceforge.net/>`_.
     packaged jar file.
 
 .. note::
-    To build the compiler from source, Kotlin SDK version 1.3 or newer is needed.
+    Building the compiler itself:
+
+    (re)building the compiler itself requires a Kotlin SDK version 1.3.
     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 is provided to build and package the compiler from the command line.
+    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

docs/source/programming.rst

@@ -187,9 +187,13 @@ Values will usually be part of an expression or assignment statement::
     byte  counter  = 42   ; variable of size 8 bits, with initial value 42
 
 
-.. todo::
-    There must be a way to tell the compiler which variables you require to be in Zeropage:
-    ``zeropage`` modifier keyword on vardecl perhaps?
+*zeropage tag:*
+If you add the ``@zp`` tag to the variable declaration, the compiler will prioritize this variable
+when selecting variables to put into zero page. If there are enough free locations in the zeropage,
+it will then try to fill it with as much other variables as possible (before they will be put in regular memory pages).
+Example::
+
+    byte  @zp  zeropageCounter = 42
 
 
 Variables that represent CPU hardware registers
@@ -321,6 +325,11 @@ be set to zero only for the first run of the program. A second run will utilize
 where it left off (but your code will be a bit smaller because no initialization instructions
 are generated)
 
+.. caution::
+   variables that get allocated in zero-page will *not* have a zero starting value when you omit
+   the variable's initialization. They'll be whatever the last value in that zero page
+   location was. So it's best to don't depend on the uninitialized starting value!
+
 .. warning::
     this behavior may change in a future version so that subsequent runs always
     use the same initial values
@@ -462,11 +471,7 @@ There are various built-in functions such as sin(), cos(), min(), max() that can
 You can also reference idendifiers defined elsewhere in your code.
 
 .. attention::
-    **Data type conversion (during calculations) and floating point handling:**
-
-    BYTE values used in arithmetic expressions (calculations) will be automatically converted into WORD values
-    if the calculation needs that to store the resulting value. Once a WORD value is used, all other results will be WORDs as well
-    (there's no automatic conversion of WORD into BYTE).
+    **Floating points used in expressions:**
 
     When a floating point value is used in a calculation, the result will be a floating point, and byte or word values
     will be automatically converted into floats in this case. The compiler will issue a warning though when this happens, because floating
@@ -494,6 +499,28 @@ Usually the normal precedence rules apply (``*`` goes before ``+`` etc.) but sub
 within parentheses will be evaluated first. So ``(4 + 8) * 2`` is 24 and not 20,
 and ``(true or false) and false`` is false instead of true.
 
+.. attention::
+    **calculations keep their datatype:**
+    When you do calculations on a BYTE type, the result will remain a BYTE.
+    When you do calculations on a WORD type, the result will remain a WORD.
+    For instance::
+
+        byte b = 44
+        word w = b*55   ; the result will be 116! (even though the target variable is a word)
+        w *= 999        ; the result will be -15188  (the multiplication stays within a word)
+
+    The compiler will NOT give a warning about this! It's doing this for
+    performance reasons - so you won't get sudden 16 bit (or even float)
+    calculations where you needed only simple fast byte arithmetic.
+    If you do need the extended resulting value, cast at least one of the
+    operands of an operator to the larger datatype. For example::
+
+        byte b = 44
+        word w = b*55.w     ; the result will be 2420
+        w = (b as word)*55  ; same result
+
+
+
 
 Subroutines
 -----------
@@ -505,7 +532,6 @@ Subroutines are parts of the code that can be repeatedly invoked using a subrout
 Their definition, using the ``sub`` statement, includes the specification of the required parameters and return value.
 Subroutines can be defined in a Block, but also nested inside another subroutine. Everything is scoped accordingly.
 
-
 Calling a subroutine
 ^^^^^^^^^^^^^^^^^^^^
 
@@ -514,9 +540,13 @@ It is possible to not store the return value but the compiler
 will issue a warning then telling you the result values of a subroutine call are discarded.
 
 .. caution::
-    Note that *recursive* subroutine calls are not supported at this time.
+    Note that due to the way parameters are processed by the compiler,
+    subroutines are *non-reentrant*. This means you cannot create recursive calls.
     If you do need a recursive algorithm, you'll have to hand code it in embedded assembly for now,
     or rewrite it into an iterative algorithm.
+    Also, subroutines used in the main program should not be used from an IRQ handler. This is because
+    the subroutine may be interrupted, and will then call itself from the IRQ handler. Results are
+    then undefined because the variables will get overwritten.
 
 
 .. _builtinfunctions:
@@ -707,3 +737,19 @@ rsave()
 
 rrestore()
     Restores the CPU registers and the status flags from previously saved values.
+
+read_flags()
+    Returns the current value of the CPU status register.
+
+
+
+Library routines
+----------------
+
+There are many routines available in the compiler libraries.
+Some are used internally by the compiler as well.
+There's too many to list here, just have a look through the source code
+of the library modules to see what's there.
+(They can be found in the compiler/res directory)
+The example programs also use a small set of the library routines, you can study
+their source code to see how they might be used.

docs/source/syntaxreference.rst

@@ -60,16 +60,20 @@ Directives
     - style ``kernalsafe`` -- use the part of the ZP that is 'free' or only used by BASIC routines,
       and don't change anything else.  This allows full use of KERNAL ROM routines (but not BASIC routines),
       including default IRQs during normal system operation.
+      When the program exits, a system reset is performed (because BASIC will be in a corrupt state).
+    - style ``floatsafe`` -- like the previous one but also reserves the addresses that
+      are required to perform floating point operations (from the BASIC kernel). No clean exit is possible.
     - style ``basicsafe`` -- the most restricted mode; only use the handful 'free' addresses in the ZP, and don't
       touch change anything else. This allows full use of BASIC and KERNAL ROM routines including default IRQs
       during normal system operation.
+      When the program exits, it simply returns to the BASIC ready prompt.
     - style ``full`` -- claim the whole ZP for variables for the program, overwriting everything,
       except the few addresses mentioned above that are used by the system's IRQ routine.
       Even though the default IRQ routine is still active, it is impossible to use most BASIC and KERNAL ROM routines.
       This includes many floating point operations and several utility routines that do I/O, such as ``print_string``.
-      It is also not possible to cleanly exit the program, other than resetting the machine.
-      This option makes programs smaller and faster because many more variables can
-      be stored in the ZP, which is more efficient.
+      As with ``kernalsafe``, it is not possible to cleanly exit the program, other than to reset the machine.
+      This option makes programs smaller and faster because even more variables can
+      be stored in the ZP (which allows for more efficient assembly code).
 
     Also read :ref:`zeropage`.
 
@@ -209,9 +213,11 @@ Variable declarations
 
 Variables should be declared with their exact type and size so the compiler can allocate storage
 for them. You must give them an initial value as well. That value can be a simple literal value,
-or an expression. The syntax is::
+or an expression. You can add a ``@zp`` zeropage-tag, to tell the compiler to prioritize it
+when selecting variables to be put into zeropage.
+The syntax is::
 
-	<datatype>   <variable name>   [ = <initial value> ]
+	<datatype>  [ @zp ]  <variable name>   [ = <initial value> ]
 
 Various examples::
 
@@ -224,6 +230,8 @@ Various examples::
     byte[5]     values  = [11, 22, 33, 44, 55]
     byte[5]     values  = 255           ; initialize with five 255 bytes
 
+    word  @zp   zpword = 9999           ; prioritize this when selecting vars for zeropage storage
+
 
 
 Data types
@@ -250,12 +258,8 @@ type identifier  type                     storage size       example var declara
 ``float[x]``     floating-point array     5*x bytes          ``float[4] myvar = [1.1, 2.2, 3.3, 4.4]``
 ``str``          string (petscii)         varies             ``str myvar = "hello."``
                                                              implicitly terminated by a 0-byte
-``str_p``        pascal-string (petscii)  varies             ``str_p myvar = "hello."``
-                                                             implicit first byte = length, no 0-byte
 ``str_s``        string (screencodes)     varies             ``str_s myvar = "hello."``
                                                              implicitly terminated by a 0-byte
-``str_ps``       pascal-string            varies             ``str_ps myvar = "hello."``
-                 (screencodes)                               implicit first byte = length, no 0-byte
 ===============  =======================  =================  =========================================
 
 **arrays:** you can split an array initializer list over several lines if you want.
@@ -357,8 +361,13 @@ Operators
 ---------
 
 .. todo::
-    address-of: ``#``
-	    Takes the address of the symbol following it:   ``word  address =  #somevar``
+    address-of: ``#`` or ``&`` (to stay close to C)
+	Takes the address of the symbol following it:   ``word  address =  &somevar``
+    Perhaps requires an explicit pointer type as well instead of just word?
+
+    This can replace the ``memory`` var decl prefix as well, instead of
+    ``memory uword var = $c000`` we could write ``&uword var = $c000``
+
 
 
 arithmetic: ``+``  ``-``  ``*``  ``/``  ``**``  ``%``
@@ -506,6 +515,13 @@ And this is a loop over the values of the array ``fibonacci_numbers`` where the
     }
 
 
+You can inline the loop variable declaration in the for statement, including optional zp-tag::
+
+    for ubyte @zp fastindex in 10 to 20 {
+        ; do something
+    }
+
+
 while loop
 ^^^^^^^^^^
 

docs/source/targetsystem.rst

@@ -77,11 +77,6 @@ Theoretically they can all be used in a program, with the follwoing limitations:
 - it's more convenient and safe to let the compiler allocate these addresses for you and just
   use symbolic names in the program code.
 
-.. todo::
-    There must be a way to tell the compiler which variables you require to be in Zeropage:
-    ``zeropage`` modifier keyword on vardecl perhaps?
-
-
 Prog8 knows what addresses are safe to use in the various ZP handling configurations.
 It will use the free ZP addresses to place its ZP variables in,
 until they're all used up. If instructed to output a program that takes over the entire
@@ -93,6 +88,7 @@ treats the ZP for the program. The default is to be reasonably restrictive to us
 part of the ZP that is not used by the C64's kernal routines.
 It's possible to claim the whole ZP as well (by disabling the operating system or kernal).
 If you want, it's also possible to be more restricive and stay clear of the addresses used by BASIC routines too.
+This allows the program to exit cleanly back to a BASIC ready prompt - something that is not possible in the other modes.
 
 
 IRQs and the ZeroPage
@@ -121,7 +117,8 @@ The following 6502 CPU hardware registers are directly usable in program code (a
 
 - ``A``, ``X``, ``Y``  the three main cpu registers (8 bits)
 - the status register (P) carry flag and interrupt disable flag can be written via a couple of special
-  builtin functions (``set_carry()``, ``clear_carry()``, ``set_irqd()``,  ``clear_irqd()``)
+  builtin functions (``set_carry()``, ``clear_carry()``, ``set_irqd()``,  ``clear_irqd()``),
+  and read via the ``read_flags()`` function.
 
 However, you must assume that the 3 hardware registers ``A``, ``X`` and ``Y``
 are volatile. Their values cannot be depended upon, the compiler will use them as required.
@@ -148,3 +145,35 @@ Arguments and result values are passed via global variables stored in memory
 *These are not allocated on a stack* so it is not possible to create recursive calls!
 The result value(s) of a subroutine are returned on the evaluation stack,
 to make it possible to use subroutines in expressions.
+
+
+IRQ Handling
+============
+
+Normally, the system's default IRQ handling is not interfered with.
+You can however install your own IRQ handler.
+This is possible ofcourse by doing it all using customized inline assembly,
+but there are a few library routines available to make setting up C-64 IRQs and raster IRQs a lot easier (no assembly code required).
+
+These routines are::
+
+    c64utils.set_irqvec()
+    c64utils.set_irqvec_excl()
+
+    c64utils.set_rasterirq( <raster line> )
+    c64utils.set_rasterirq_excl( <raster line> )
+
+    c64utils.restore_irqvec()     ; set it back to the systems default irq handler
+
+If you activate an IRQ handler with one of these, it expects the handler to be defined
+as a subroutine ``irq`` in the module ``irq`` so like this::
+
+    ~ irq {
+        sub irq() {
+            ; ... irq handling here ...
+        }
+    }
+
+
+.. todo::
+    @todo the irq handler should use its own eval-stack to avoid stack interference issues

docs/source/todo.rst

@@ -29,14 +29,63 @@ Add more compiler optimizations to the existing ones.
 - on the language AST level
 - on the StackVM intermediate code level
 - on the final assembly source level
+- can the parameter passing to subroutines be optimized to avoid copying?
+
+- subroutines with 1 or 2 byte args (or 1 word arg) should be converted to asm calling convention with the args in A/Y register
+  this requires rethinking the way parameters are represented, simply injecting vardecls to
+  declare local variables for them is not always correct anymore
 
 
 Also some library routines and code patterns could perhaps be optimized further
 
 
+Eval stack redesign? (lot of work)
+^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+The eval stack is now a split lsb/msb stack using X as the stackpointer.
+Is it easier/faster to just use a single page unsplit stack?
+It could then even be moved into the zeropage to greatly reduce code size and slowness.
+
+Or just move the LSB portion into a slab of the zeropage.
+
+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?
+
+
+More flexible (non-const) arrays?
+^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+Currently, array literals can only be constants
+Allow for non-const arrays? Such as::
+
+    ubyte[16]  block1
+    ubyte[16]  block2
+    ubyte[16]  block3
+    ubyte[3] blocks = [block1, block2, block3]
+
+
+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[3] vec = [0,0,0]
+    }
+
+    Point p1
+    Point p2
+    Point p3
+
+    p1.color = 3
+    p1.vec[2] = 2
+
+
 Misc
 ^^^^
 
 - sqrt() should have integer implementation as well, instead of relying on float SQRT for all argument types
 - code generation for POW instruction
-- make sure user-defined blocks come BEFORE library blocks (this helps zeropage variable allocations)
+- are there any other missing instructions in the code generator?
+- implement %asmbinary

examples/comparison_ifs_byte.p8

@@ -1,4 +1,6 @@
 %import c64utils
+%zeropage basicsafe
+
 
 ~ main {
 

examples/comparison_ifs_float.p8

@@ -1,5 +1,6 @@
 %import c64utils
 %import c64flt
+%zeropage basicsafe
 
 ~ main {
 

examples/comparison_ifs_ubyte.p8

@@ -1,4 +1,5 @@
 %import c64utils
+%zeropage basicsafe
 
 
 ~ main {

examples/comparison_ifs_uword.p8

@@ -1,4 +1,5 @@
 %import c64utils
+%zeropage basicsafe
 
 
 ~ main {

examples/comparison_ifs_word.p8

@@ -1,4 +1,5 @@
 %import c64utils
+%zeropage basicsafe
 
 
 ~ main {

examples/comparisons_byte.p8

@@ -1,4 +1,5 @@
 %import c64utils
+%zeropage basicsafe
 
 ~ main {
 

examples/comparisons_float.p8

@@ -1,5 +1,6 @@
 %import c64utils
 %import c64flt
+%zeropage basicsafe
 
 ~ main {
 

examples/comparisons_ubyte.p8

@@ -1,4 +1,5 @@
 %import c64utils
+%zeropage basicsafe
 
 ~ main {
 

examples/comparisons_uword.p8

@@ -1,4 +1,5 @@
 %import c64utils
+%zeropage basicsafe
 
 ~ main {
 

examples/comparisons_word.p8

@@ -1,4 +1,5 @@
 %import c64utils
+%zeropage basicsafe
 
 ~ main {
 

examples/fibonacci.p8

@@ -1,4 +1,5 @@
 %import c64utils
+%zeropage basicsafe
 
 ; This example computes the first 20 values of the Fibonacci sequence.
 ; It uses the feature that variables that don't have an initialization value,

examples/hello.p8

@@ -1,6 +1,7 @@
 %import c64lib
 %import c64utils
 %import c64flt
+%zeropage basicsafe
 
 
 ~ main {

examples/looplabelproblem.p8

@@ -0,0 +1,18 @@
+
+~ main {
+
+    sub start() {
+
+        if A>10 {
+            A=44
+            while true {
+                ;derp
+            }
+        } else {
+
+            gameover:
+                goto gameover
+        }
+    }
+
+}

examples/mandelbrot.p8

@@ -1,6 +1,8 @@
 %import c64lib
 %import c64utils
 %import c64flt
+%zeropage basicsafe
+
 
 ~ main {
     const uword width = 30

examples/numbergame.p8

@@ -1,5 +1,6 @@
 %import c64utils
 %import c64lib
+%zeropage basicsafe
 
 ; The classic number guessing game.
 ; This version uses mostly high level subroutine calls and loops.

examples/primes.p8

@@ -1,27 +1,34 @@
 %import c64utils
+%zeropage basicsafe
 
 ~ main {
 
     ubyte[256] sieve
-    ubyte candidate_prime = 2
+    ubyte candidate_prime = 2       ; is increased in the loop
 
     sub start() {
-        memset(sieve, 256, false)   ; clear the sieve
+        memset(sieve, 256, false)   ; clear the sieve, to reset starting situation on subsequent runs
 
         ; calculate primes
         c64scr.print("prime numbers up to 255:\n\n")
+        ubyte amount=0
         while true {
             ubyte prime = find_next_prime()
             if prime==0
                 break
             c64scr.print_ub(prime)
             c64scr.print(", ")
+            amount++
         }
         c64.CHROUT('\n')
+        c64scr.print("number of primes (expected 54): ")
+        c64scr.print_ub(amount)
+        c64.CHROUT('\n')
     }
 
 
     sub find_next_prime() -> ubyte {
+
         while sieve[candidate_prime] {
             candidate_prime++
             if candidate_prime==0
@@ -30,7 +37,7 @@
 
         ; found next one, mark the multiples and return it.
         sieve[candidate_prime] = true
-        uword multiple = candidate_prime**2
+        uword multiple = candidate_prime
         while multiple < len(sieve) {
             sieve[lsb(multiple)] = true
             multiple += candidate_prime

examples/sprites.p8

@@ -1,5 +1,6 @@
 %import c64utils
 %import c64lib
+%zeropage basicsafe
 
 
 ~ spritedata $0a00 {

examples/tehtriz.p8

@@ -0,0 +1,636 @@
+; TehTriz - a Tetris clone.
+;
+; features:
+;   holding area
+;   wall kick rotations
+;   shows next piece
+;   staged speed increase
+;   some simple sound effects
+;
+; @todo show ghost?
+
+
+~ main {
+
+    const ubyte boardOffsetX = 14
+    const ubyte boardOffsetY = 3
+    const ubyte boardWidth = 10
+    const ubyte boardHeight = 20
+    const ubyte startXpos = boardOffsetX + 3
+    const ubyte startYpos = boardOffsetY - 2
+    uword lines
+    uword score
+    ubyte xpos
+    ubyte ypos
+    ubyte nextBlock
+    ubyte speedlevel
+    ubyte holding
+    ubyte holdingAllowed
+
+
+    sub start() {
+        @(650) = 128        ; set all keys to repeat
+        sound.init()
+        newGame()
+        drawBoard()
+        gameOver()
+
+newgame:
+        newGame()
+        drawBoard()
+        spawnNextBlock()
+
+waitkey:
+        if c64.TIME_LO>=(60-4*speedlevel) {
+            c64.TIME_LO = 0
+
+            drawBlock(xpos, ypos, 32) ; hide block
+            if blocklogic.noCollision(xpos, ypos+1) {
+                ; slowly move the block down
+                ypos++
+                drawBlock(xpos, ypos, 160)  ; show block on new position
+            } else {
+                ; block can't move further down!
+                ; check if the game area is full, if not, spawn the next block at the top.
+                if blocklogic.isGameOver(xpos, ypos) {
+                    gameOver()
+                    goto newgame
+                } else {
+                    sound.blockrotate()
+                    checkForLines()
+                    spawnNextBlock()
+                    score++
+                }
+            }
+
+            drawScore()
+        }
+
+        ubyte key=c64.GETIN()
+        if key==0 goto waitkey
+
+        keypress(key)
+
+        goto waitkey
+
+    }
+
+    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
+                }
+            }
+            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()
+                }
+                drawHoldBlock()
+            }
+        }
+    }
+
+    sub checkForLines() {
+        ; check if line(s) are full -> flash/clear line(s) + add score + move rest down
+        ubyte[boardHeight] complete_lines
+        ubyte num_lines=0
+        memset(complete_lines, len(complete_lines), 0)
+        for ubyte linepos in boardOffsetY to boardOffsetY+boardHeight-1 {
+            if blocklogic.isLineFull(linepos) {
+                complete_lines[num_lines]=linepos
+                num_lines++
+                for ubyte x in boardOffsetX to boardOffsetX+boardWidth-1
+                    c64scr.setcc(x, linepos, 160, 1)
+            }
+        }
+        if num_lines {
+            if num_lines>3
+                sound.lineclear_big()
+            else
+                sound.lineclear()
+            c64.TIME_LO=0
+            while c64.TIME_LO<20 {
+                ; slight delay to flash the line
+            }
+            c64.TIME_LO=0
+            for ubyte linepos in complete_lines
+                if linepos and blocklogic.isLineFull(linepos)
+                    blocklogic.collapse(linepos)
+            lines += num_lines
+            uword[4] scores = [10, 25, 50, 100]      ; can never clear more than 4 lines
+            score += scores[num_lines-1]
+            speedlevel = 1+lsb(lines/10)
+            drawScore()
+        }
+    }
+
+    sub gameOver() {
+        sound.gameover()
+        c64scr.PLOT(7, 7)
+        c64.CHROUT('U')
+        c64scr.print("────────────────────────")
+        c64.CHROUT('I')
+        c64scr.PLOT(7, 8)
+        c64scr.print("│*** g a m e  o v e r ***│")
+        c64scr.PLOT(7, 9)
+        c64.CHROUT('J')
+        c64scr.print("────────────────────────")
+        c64.CHROUT('K')
+
+        c64scr.PLOT(7, 18)
+        c64.CHROUT('U')
+        c64scr.print("────────────────────────")
+        c64.CHROUT('I')
+        c64scr.PLOT(7, 19)
+        c64scr.print("│    f1 for new game     │")
+        c64scr.PLOT(7, 20)
+        c64.CHROUT('J')
+        c64scr.print("────────────────────────")
+        c64.CHROUT('K')
+
+        while(c64.GETIN()!=133) {
+            ; endless loop until user presses F1 to restart the game
+        }
+    }
+
+    sub newGame() {
+        lines = 0
+        score = 0
+        xpos = startXpos
+        ypos = startYpos
+        speedlevel = 1
+        nextBlock = rnd() % 7
+        holding = 255
+        holdingAllowed = true
+    }
+
+    sub swapBlock(ubyte newblock) {
+        c64.TIME_LO = 0
+        blocklogic.newCurrentBlock(newblock)
+        xpos = startXpos
+        ypos = startYpos
+        drawBlock(xpos, ypos, 160)
+    }
+
+    sub spawnNextBlock() {
+        swapBlock(nextBlock)
+        nextBlock = (rnd() + c64.RASTER) % 7
+        drawNextBlock()
+        holdingAllowed = true
+    }
+
+    sub drawBoard() {
+        c64.CLEARSCR()
+        c64.COLOR = 7
+        c64scr.PLOT(1,1)
+        c64scr.print("irmen's")
+        c64scr.PLOT(2,2)
+        c64scr.print("teh▁triz")
+        c64.COLOR = 5
+        c64scr.PLOT(6,4)
+        c64scr.print("hold:")
+        c64scr.PLOT(2,22)
+        c64scr.print("speed: ")
+        c64scr.PLOT(28,3)
+        c64scr.print("next:")
+        c64scr.PLOT(28,10)
+        c64scr.print("lines:")
+        c64scr.PLOT(28,14)
+        c64scr.print("score:")
+        c64.COLOR = 12
+        c64scr.PLOT(27,18)
+        c64scr.print("controls:")
+        c64.COLOR = 11
+        c64scr.PLOT(28,19)
+        c64scr.print(",/  move")
+        c64scr.PLOT(28,20)
+        c64scr.print("zx  rotate")
+        c64scr.PLOT(29,21)
+        c64scr.print(".  descend")
+        c64scr.PLOT(27,22)
+        c64scr.print("spc  drop")
+        c64scr.PLOT(29,23)
+        c64scr.print("c  hold")
+
+        c64scr.setcc(boardOffsetX-1, boardOffsetY-2, 255, 0)           ; invisible barrier
+        c64scr.setcc(boardOffsetX-1, boardOffsetY-3, 255, 0)           ; invisible barrier
+        c64scr.setcc(boardOffsetX+boardWidth, boardOffsetY-2, 255, 0)  ; invisible barrier
+        c64scr.setcc(boardOffsetX+boardWidth, boardOffsetY-3, 255, 0)  ; invisible barrier
+
+        c64scr.setcc(boardOffsetX-1, boardOffsetY-1, 108, 12)
+        c64scr.setcc(boardOffsetX+boardWidth, boardOffsetY-1, 123, 12)
+        c64scr.setcc(boardOffsetX+boardWidth, boardOffsetY-1, 123, 12)
+        c64scr.setcc(boardOffsetX-1, boardOffsetY+boardHeight, 124, 12)
+        c64scr.setcc(boardOffsetX+boardWidth, boardOffsetY+boardHeight, 126, 12)
+        ubyte i
+        for i in boardOffsetX+boardWidth-1 to boardOffsetX step -1 {
+            c64scr.setcc(i, boardOffsetY-3, 255, 0)           ; invisible barrier
+            c64scr.setcc(i, boardOffsetY+boardHeight, 69, 11)
+        }
+        for i in boardOffsetY+boardHeight-1 to boardOffsetY step -1 {
+            c64scr.setcc(boardOffsetX-1, i, 89, 11)
+            c64scr.setcc(boardOffsetX+boardWidth, i, 84, 11)
+        }
+
+        ubyte[5] colors = [6,8,7,5,4]
+        for i in len(colors)-1 to 0 step -1 {
+            for ubyte x in 5 to 0 step -1 {
+                c64scr.setcc(6+x-i, 11+2*i, 102, colors[i])
+            }
+        }
+        drawScore()
+    }
+
+    sub drawScore() {
+        c64.COLOR=1
+        c64scr.PLOT(30,11)
+        c64scr.print_uw(lines)
+        c64scr.PLOT(30,15)
+        c64scr.print_uw(score)
+        c64scr.PLOT(9,22)
+        c64scr.print_ub(speedlevel)
+    }
+
+    sub drawNextBlock() {
+        const ubyte nextBlockXpos = 29
+        const ubyte nextBlockYpos = 5
+        for ubyte x in nextBlockXpos+3 to nextBlockXpos step -1 {
+            c64scr.setcc(x, nextBlockYpos, ' ', 0)
+            c64scr.setcc(x, nextBlockYpos+1, ' ', 0)
+        }
+
+        ; reuse the normal block draw routine (because we can't manipulate array pointers yet)
+        ubyte prev = blocklogic.currentBlockNum
+        blocklogic.newCurrentBlock(nextBlock)
+        drawBlock(nextBlockXpos, nextBlockYpos, 160)
+        blocklogic.newCurrentBlock(prev)
+    }
+
+    sub drawHoldBlock() {
+        const ubyte holdBlockXpos = 7
+        const ubyte holdBlockYpos = 6
+        for ubyte x in holdBlockXpos+3 to holdBlockXpos step -1 {
+            c64scr.setcc(x, holdBlockYpos, '@', 0)
+            c64scr.setcc(x, holdBlockYpos+1, '@', 0)
+        }
+        if holding < 7 {
+            ; reuse the normal block draw routine (because we can't manipulate array pointers yet)
+            ubyte prev = blocklogic.currentBlockNum
+            blocklogic.newCurrentBlock(holding)
+            drawBlock(holdBlockXpos, holdBlockYpos, 160)
+            blocklogic.newCurrentBlock(prev)
+        }
+    }
+
+    sub drawBlock(ubyte x, ubyte y, ubyte character) {
+        for ubyte i in 15 to 0 step -1 {
+            ubyte c=blocklogic.currentBlock[i]
+            if c
+                c64scr.setcc((i&3)+x, (i/4)+y, character, c)
+        }
+    }
+}
+
+
+~ blocklogic {
+
+    ubyte currentBlockNum
+    ubyte[16] currentBlock
+    ubyte[16] rotated
+
+    ; the 7 tetrominos
+    ubyte[16] blockI = [0,0,0,0,        ; cyan ; note: special rotation (around matrix center)
+                        3,3,3,3,
+                        0,0,0,0,
+                        0,0,0,0]
+    ubyte[16] blockJ = [6,0,0,0,        ; blue
+                        6,6,6,0,
+                        0,0,0,0,
+                        0,0,0,0]
+    ubyte[16] blockL = [0,0,8,0,        ; orange
+                        8,8,8,0,
+                        0,0,0,0,
+                        0,0,0,0]
+    ubyte[16] blockO = [0,7,7,0,        ; yellow ; note: no rotation (square)
+                        0,7,7,0,
+                        0,0,0,0,
+                        0,0,0,0]
+    ubyte[16] blockS = [0,5,5,0,        ; green
+                        5,5,0,0,
+                        0,0,0,0,
+                        0,0,0,0]
+    ubyte[16] blockT = [0,4,0,0,        ; purple
+                        4,4,4,0,
+                        0,0,0,0,
+                        0,0,0,0]
+    ubyte[16] blockZ = [2,2,0,0,        ; red
+                        0,2,2,0,
+                        0,0,0,0,
+                        0,0,0,0]
+
+    ; @todo would be nice to have a pointer type, like so:
+    ;  uword[7] blocks = [&blockI, &blockJ, &blockL, &blockO, &blockS, &blockT, &blockZ]
+
+    sub newCurrentBlock(ubyte block) {
+        currentBlockNum = block
+        if block==0
+            memcopy(blockI, currentBlock, len(currentBlock))
+        else if block==1
+            memcopy(blockJ, currentBlock, len(currentBlock))
+        else if block==2
+            memcopy(blockL, currentBlock, len(currentBlock))
+        else if block==3
+            memcopy(blockO, currentBlock, len(currentBlock))
+        else if block==4
+            memcopy(blockS, currentBlock, len(currentBlock))
+        else if block==5
+            memcopy(blockT, currentBlock, len(currentBlock))
+        else if block==6
+            memcopy(blockZ, currentBlock, len(currentBlock))
+    }
+
+    sub rotateCW() {
+        ; rotates the current block clockwise.
+        if currentBlockNum==0 {
+            ; the 'I' block rotates a 4x4 matrix around the center
+            rotated[0] = currentBlock[12]
+            rotated[1] = currentBlock[8]
+            rotated[2] = currentBlock[4]
+            rotated[3] = currentBlock[0]
+            rotated[4] = currentBlock[13]
+            rotated[5] = currentBlock[9]
+            rotated[6] = currentBlock[5]
+            rotated[7] = currentBlock[1]
+            rotated[8] = currentBlock[14]
+            rotated[9] = currentBlock[10]
+            rotated[10] = currentBlock[6]
+            rotated[11] = currentBlock[2]
+            rotated[12] = currentBlock[15]
+            rotated[13] = currentBlock[11]
+            rotated[14] = currentBlock[7]
+            rotated[15] = currentBlock[3]
+            memcopy(rotated, currentBlock, len(currentBlock))
+        }
+        else if currentBlockNum!=3 {
+            ; rotate all blocks (except 3, the square) around their center square in a 3x3 matrix
+            memset(rotated, len(rotated), 0)
+            rotated[0] = currentBlock[8]
+            rotated[1] = currentBlock[4]
+            rotated[2] = currentBlock[0]
+            rotated[4] = currentBlock[9]
+            rotated[5] = currentBlock[5]
+            rotated[6] = currentBlock[1]
+            rotated[8] = currentBlock[10]
+            rotated[9] = currentBlock[6]
+            rotated[10] = currentBlock[2]
+            memcopy(rotated, currentBlock, len(currentBlock))
+        }
+    }
+
+    sub rotateCCW() {
+        ; rotates the current block counterclockwise.
+        if currentBlockNum==0 {
+            ; the 'I' block rotates a 4x4 matrix around the center
+            rotated[0] = currentBlock[3]
+            rotated[1] = currentBlock[7]
+            rotated[2] = currentBlock[11]
+            rotated[3] = currentBlock[15]
+            rotated[4] = currentBlock[2]
+            rotated[5] = currentBlock[6]
+            rotated[6] = currentBlock[10]
+            rotated[7] = currentBlock[14]
+            rotated[8] = currentBlock[1]
+            rotated[9] = currentBlock[5]
+            rotated[10] = currentBlock[9]
+            rotated[11] = currentBlock[13]
+            rotated[12] = currentBlock[0]
+            rotated[13] = currentBlock[4]
+            rotated[14] = currentBlock[8]
+            rotated[15] = currentBlock[12]
+            memcopy(rotated, currentBlock, len(currentBlock))
+        }
+        else if currentBlockNum!=3 {
+            ; rotate all blocks (except 3, the square) around their center square in a 3x3 matrix
+            memset(rotated, len(rotated), 0)
+            rotated[0] = currentBlock[2]
+            rotated[1] = currentBlock[6]
+            rotated[2] = currentBlock[10]
+            rotated[4] = currentBlock[1]
+            rotated[5] = currentBlock[5]
+            rotated[6] = currentBlock[9]
+            rotated[8] = currentBlock[0]
+            rotated[9] = currentBlock[4]
+            rotated[10] = currentBlock[8]
+            memcopy(rotated, currentBlock, len(currentBlock))
+        }
+    }
+
+    ; For movement checking it is not needed to clamp the x/y coordinates,
+    ; because we have to check for brick collisions anyway.
+    ; The full play area is bordered by (in)visible characters that will collide.
+    ; Collision is determined by reading the screen data directly.
+
+    sub canRotateCW(ubyte xpos, ubyte ypos) -> ubyte {
+        rotateCW()
+        ubyte nocollision = noCollision(xpos, ypos)
+        rotateCCW()
+        return nocollision
+    }
+
+    sub canRotateCCW(ubyte xpos, ubyte ypos) -> ubyte {
+        rotateCCW()
+        ubyte nocollision = noCollision(xpos, ypos)
+        rotateCW()
+        return nocollision
+    }
+
+    sub noCollision(ubyte xpos, ubyte ypos) -> ubyte {
+        for ubyte i in 15 to 0 step -1 {
+            if currentBlock[i] and c64scr.getchr(xpos + (i&3), ypos+i/4)!=32
+                return false
+        }
+        return true
+    }
+
+    sub isGameOver(ubyte xpos, ubyte ypos) -> ubyte {
+        main.drawBlock(xpos, ypos, 32)
+        ubyte result = ypos==main.startYpos and not noCollision(xpos, ypos+1)
+        main.drawBlock(xpos, ypos, 160)
+        return result
+    }
+
+    sub isLineFull(ubyte ypos) -> ubyte {
+        for ubyte x in main.boardOffsetX to main.boardOffsetX+main.boardWidth-1 {
+            if c64scr.getchr(x, ypos)==32
+                return false
+        }
+        return true
+    }
+
+    sub collapse(ubyte ypos) {
+        while(ypos>main.startYpos+1) {
+            for ubyte x in main.boardOffsetX+main.boardWidth-1 to main.boardOffsetX step -1 {
+                ubyte char = c64scr.getchr(x, ypos-1)
+                ubyte color = c64scr.getclr(x, ypos-1)
+                c64scr.setcc(x, ypos, char, color)
+            }
+            ypos--
+        }
+    }
+}
+
+
+~ sound {
+
+    sub init() {
+        c64.MVOL = 15
+    }
+
+    sub blockrotate() {
+        ; soft click
+        c64.MVOL = 5
+        c64.AD1 = %00100010
+        c64.SR1 = %00000000
+        c64.FREQ1 = 15600
+        c64.CR1 = %10000000
+        c64.CR1 = %10000001
+    }
+
+    sub blockdrop() {
+        ; swish
+        c64.MVOL = 5
+        c64.AD1 = %01010111
+        c64.SR1 = %00000000
+        c64.FREQ1 = 4600
+        c64.CR1 = %10000000
+        c64.CR1 = %10000001
+    }
+
+    sub swapping() {
+        ; beep
+        c64.MVOL = 8
+        c64.AD1 = %01010111
+        c64.SR1 = %00000000
+        c64.FREQ1 = 5500
+        c64.CR1 = %00010000
+        c64.CR1 = %00010001
+    }
+
+    sub lineclear() {
+        ; explosion
+        c64.MVOL = 15
+        c64.AD1 = %01100110
+        c64.SR1 = %00000000
+        c64.FREQ1 = 1600
+        c64.CR1 = %10000000
+        c64.CR1 = %10000001
+    }
+
+    sub lineclear_big() {
+        ; big explosion
+        c64.MVOL = 15
+        c64.AD1 = %01101010
+        c64.SR1 = %00000000
+        c64.FREQ1 = 2600
+        c64.CR1 = %10000000
+        c64.CR1 = %10000001
+    }
+
+    sub gameover() {
+        ; buzz
+        c64.MVOL = 15
+        c64.FREQ2 = 600
+        c64.AD2 = %00111010
+        c64.SR2 = %00000000
+        c64.CR2 = %00110000
+        c64.CR2 = %00110001
+    }
+}

examples/test.p8

@@ -1,35 +1,12 @@
 %import c64utils
-%option enable_floats
+%zeropage basicsafe
 
 ~ main {
 
+    ; @todo see problem in looplabelproblem.p8
+    ; @todo compiler error for using literal values other than 0 or 1 with boolean expressions
+
     sub start() {
 
-        ubyte @zp ub = 22
-        byte  @zp b = 22
-        word @zp w = 2222
-        uword @zp uw = 2222
-
-
-        byte nonzp1 = 42
-        byte nonzp2 = 42
-        byte nonzp3 = 42
-        foo.bar()
     }
-
-}
-
-~ foo {
-
-sub bar() {
-        ubyte @zp ub = 33
-        byte  @zp b = 33
-        word @zp w = 3333
-        uword @zp uw = 3333
-
-    word nonzp1 = 4444
-    word nonzp2 = 4444
-    word nonzp3 = 4444
-    A=55
-}
 }

examples/wizzine.p8

@@ -1,5 +1,6 @@
 %import c64utils
 %import c64lib
+%zeropage basicsafe
 
 
 ~ spritedata $0a00 {

gradle.properties

@@ -0,0 +1,2 @@
+org.gradle.caching=true
+

gradle/wrapper/gradle-wrapper.properties

@@ -0,0 +1,5 @@
+distributionBase=GRADLE_USER_HOME
+distributionPath=wrapper/dists
+distributionUrl=https\://services.gradle.org/distributions/gradle-5.1.1-bin.zip
+zipStoreBase=GRADLE_USER_HOME
+zipStorePath=wrapper/dists

gradlew

@@ -0,0 +1,172 @@
+#!/usr/bin/env sh
+
+##############################################################################
+##
+##  Gradle start up script for UN*X
+##
+##############################################################################
+
+# Attempt to set APP_HOME
+# Resolve links: $0 may be a link
+PRG="$0"
+# Need this for relative symlinks.
+while [ -h "$PRG" ] ; do
+    ls=`ls -ld "$PRG"`
+    link=`expr "$ls" : '.*-> \(.*\)$'`
+    if expr "$link" : '/.*' > /dev/null; then
+        PRG="$link"
+    else
+        PRG=`dirname "$PRG"`"/$link"
+    fi
+done
+SAVED="`pwd`"
+cd "`dirname \"$PRG\"`/" >/dev/null
+APP_HOME="`pwd -P`"
+cd "$SAVED" >/dev/null
+
+APP_NAME="Gradle"
+APP_BASE_NAME=`basename "$0"`
+
+# Add default JVM options here. You can also use JAVA_OPTS and GRADLE_OPTS to pass JVM options to this script.
+DEFAULT_JVM_OPTS='"-Xmx64m"'
+
+# Use the maximum available, or set MAX_FD != -1 to use that value.
+MAX_FD="maximum"
+
+warn () {
+    echo "$*"
+}
+
+die () {
+    echo
+    echo "$*"
+    echo
+    exit 1
+}
+
+# OS specific support (must be 'true' or 'false').
+cygwin=false
+msys=false
+darwin=false
+nonstop=false
+case "`uname`" in
+  CYGWIN* )
+    cygwin=true
+    ;;
+  Darwin* )
+    darwin=true
+    ;;
+  MINGW* )
+    msys=true
+    ;;
+  NONSTOP* )
+    nonstop=true
+    ;;
+esac
+
+CLASSPATH=$APP_HOME/gradle/wrapper/gradle-wrapper.jar
+
+# Determine the Java command to use to start the JVM.
+if [ -n "$JAVA_HOME" ] ; then
+    if [ -x "$JAVA_HOME/jre/sh/java" ] ; then
+        # IBM's JDK on AIX uses strange locations for the executables
+        JAVACMD="$JAVA_HOME/jre/sh/java"
+    else
+        JAVACMD="$JAVA_HOME/bin/java"
+    fi
+    if [ ! -x "$JAVACMD" ] ; then
+        die "ERROR: JAVA_HOME is set to an invalid directory: $JAVA_HOME
+
+Please set the JAVA_HOME variable in your environment to match the
+location of your Java installation."
+    fi
+else
+    JAVACMD="java"
+    which java >/dev/null 2>&1 || die "ERROR: JAVA_HOME is not set and no 'java' command could be found in your PATH.
+
+Please set the JAVA_HOME variable in your environment to match the
+location of your Java installation."
+fi
+
+# Increase the maximum file descriptors if we can.
+if [ "$cygwin" = "false" -a "$darwin" = "false" -a "$nonstop" = "false" ] ; then
+    MAX_FD_LIMIT=`ulimit -H -n`
+    if [ $? -eq 0 ] ; then
+        if [ "$MAX_FD" = "maximum" -o "$MAX_FD" = "max" ] ; then
+            MAX_FD="$MAX_FD_LIMIT"
+        fi
+        ulimit -n $MAX_FD
+        if [ $? -ne 0 ] ; then
+            warn "Could not set maximum file descriptor limit: $MAX_FD"
+        fi
+    else
+        warn "Could not query maximum file descriptor limit: $MAX_FD_LIMIT"
+    fi
+fi
+
+# For Darwin, add options to specify how the application appears in the dock
+if $darwin; then
+    GRADLE_OPTS="$GRADLE_OPTS \"-Xdock:name=$APP_NAME\" \"-Xdock:icon=$APP_HOME/media/gradle.icns\""
+fi
+
+# For Cygwin, switch paths to Windows format before running java
+if $cygwin ; then
+    APP_HOME=`cygpath --path --mixed "$APP_HOME"`
+    CLASSPATH=`cygpath --path --mixed "$CLASSPATH"`
+    JAVACMD=`cygpath --unix "$JAVACMD"`
+
+    # We build the pattern for arguments to be converted via cygpath
+    ROOTDIRSRAW=`find -L / -maxdepth 1 -mindepth 1 -type d 2>/dev/null`
+    SEP=""
+    for dir in $ROOTDIRSRAW ; do
+        ROOTDIRS="$ROOTDIRS$SEP$dir"
+        SEP="|"
+    done
+    OURCYGPATTERN="(^($ROOTDIRS))"
+    # Add a user-defined pattern to the cygpath arguments
+    if [ "$GRADLE_CYGPATTERN" != "" ] ; then
+        OURCYGPATTERN="$OURCYGPATTERN|($GRADLE_CYGPATTERN)"
+    fi
+    # Now convert the arguments - kludge to limit ourselves to /bin/sh
+    i=0
+    for arg in "$@" ; do
+        CHECK=`echo "$arg"|egrep -c "$OURCYGPATTERN" -`
+        CHECK2=`echo "$arg"|egrep -c "^-"`                                 ### Determine if an option
+
+        if [ $CHECK -ne 0 ] && [ $CHECK2 -eq 0 ] ; then                    ### Added a condition
+            eval `echo args$i`=`cygpath --path --ignore --mixed "$arg"`
+        else
+            eval `echo args$i`="\"$arg\""
+        fi
+        i=$((i+1))
+    done
+    case $i in
+        (0) set -- ;;
+        (1) set -- "$args0" ;;
+        (2) set -- "$args0" "$args1" ;;
+        (3) set -- "$args0" "$args1" "$args2" ;;
+        (4) set -- "$args0" "$args1" "$args2" "$args3" ;;
+        (5) set -- "$args0" "$args1" "$args2" "$args3" "$args4" ;;
+        (6) set -- "$args0" "$args1" "$args2" "$args3" "$args4" "$args5" ;;
+        (7) set -- "$args0" "$args1" "$args2" "$args3" "$args4" "$args5" "$args6" ;;
+        (8) set -- "$args0" "$args1" "$args2" "$args3" "$args4" "$args5" "$args6" "$args7" ;;
+        (9) set -- "$args0" "$args1" "$args2" "$args3" "$args4" "$args5" "$args6" "$args7" "$args8" ;;
+    esac
+fi
+
+# Escape application args
+save () {
+    for i do printf %s\\n "$i" | sed "s/'/'\\\\''/g;1s/^/'/;\$s/\$/' \\\\/" ; done
+    echo " "
+}
+APP_ARGS=$(save "$@")
+
+# Collect all arguments for the java command, following the shell quoting and substitution rules
+eval set -- $DEFAULT_JVM_OPTS $JAVA_OPTS $GRADLE_OPTS "\"-Dorg.gradle.appname=$APP_BASE_NAME\"" -classpath "\"$CLASSPATH\"" org.gradle.wrapper.GradleWrapperMain "$APP_ARGS"
+
+# by default we should be in the correct project dir, but when run from Finder on Mac, the cwd is wrong
+if [ "$(uname)" = "Darwin" ] && [ "$HOME" = "$PWD" ]; then
+  cd "$(dirname "$0")"
+fi
+
+exec "$JAVACMD" "$@"

gradlew.bat

@@ -0,0 +1,84 @@
+@if "%DEBUG%" == "" @echo off
+@rem ##########################################################################
+@rem
+@rem  Gradle startup script for Windows
+@rem
+@rem ##########################################################################
+
+@rem Set local scope for the variables with windows NT shell
+if "%OS%"=="Windows_NT" setlocal
+
+set DIRNAME=%~dp0
+if "%DIRNAME%" == "" set DIRNAME=.
+set APP_BASE_NAME=%~n0
+set APP_HOME=%DIRNAME%
+
+@rem Add default JVM options here. You can also use JAVA_OPTS and GRADLE_OPTS to pass JVM options to this script.
+set DEFAULT_JVM_OPTS="-Xmx64m"
+
+@rem Find java.exe
+if defined JAVA_HOME goto findJavaFromJavaHome
+
+set JAVA_EXE=java.exe
+%JAVA_EXE% -version >NUL 2>&1
+if "%ERRORLEVEL%" == "0" goto init
+
+echo.
+echo ERROR: JAVA_HOME is not set and no 'java' command could be found in your PATH.
+echo.
+echo Please set the JAVA_HOME variable in your environment to match the
+echo location of your Java installation.
+
+goto fail
+
+:findJavaFromJavaHome
+set JAVA_HOME=%JAVA_HOME:"=%
+set JAVA_EXE=%JAVA_HOME%/bin/java.exe
+
+if exist "%JAVA_EXE%" goto init
+
+echo.
+echo ERROR: JAVA_HOME is set to an invalid directory: %JAVA_HOME%
+echo.
+echo Please set the JAVA_HOME variable in your environment to match the
+echo location of your Java installation.
+
+goto fail
+
+:init
+@rem Get command-line arguments, handling Windows variants
+
+if not "%OS%" == "Windows_NT" goto win9xME_args
+
+:win9xME_args
+@rem Slurp the command line arguments.
+set CMD_LINE_ARGS=
+set _SKIP=2
+
+:win9xME_args_slurp
+if "x%~1" == "x" goto execute
+
+set CMD_LINE_ARGS=%*
+
+:execute
+@rem Setup the command line
+
+set CLASSPATH=%APP_HOME%\gradle\wrapper\gradle-wrapper.jar
+
+@rem Execute Gradle
+"%JAVA_EXE%" %DEFAULT_JVM_OPTS% %JAVA_OPTS% %GRADLE_OPTS% "-Dorg.gradle.appname=%APP_BASE_NAME%" -classpath "%CLASSPATH%" org.gradle.wrapper.GradleWrapperMain %CMD_LINE_ARGS%
+
+:end
+@rem End local scope for the variables with windows NT shell
+if "%ERRORLEVEL%"=="0" goto mainEnd
+
+:fail
+rem Set variable GRADLE_EXIT_CONSOLE if you need the _script_ return code instead of
+rem the _cmd.exe /c_ return code!
+if  not "" == "%GRADLE_EXIT_CONSOLE%" exit 1
+exit /b 1
+
+:mainEnd
+if "%OS%"=="Windows_NT" endlocal
+
+:omega

p8compile.cmd

@@ -1,4 +1,6 @@
-set PROG8CLASSPATH=./out/production/compiler;./out/production/parser
+@echo off
+
+set PROG8CLASSPATH=./out/production/compiler_main;./out/production/parser_main
 set KOTLINPATH=%USERPROFILE%/.IdeaIC2018.3/config/plugins/Kotlin
 set LIBJARS=%KOTLINPATH%/lib/kotlin-stdlib.jar;%KOTLINPATH%/lib/kotlin-reflect.jar;./parser/antlr/lib/antlr-runtime-4.7.2.jar
 

p8compile.sh

@@ -1,6 +1,6 @@
 #!/usr/bin/env sh
 
-PROG8CLASSPATH=./out/production/compiler:./out/production/parser
+PROG8CLASSPATH=./out/production/compiler_main:./out/production/parser_main
 KOTLINPATH=${HOME}/.IntelliJIdea2018.3/config/plugins/Kotlin
 LIBJARS=${KOTLINPATH}/lib/kotlin-stdlib.jar:${KOTLINPATH}/lib/kotlin-reflect.jar:./parser/antlr/lib/antlr-runtime-4.7.2.jar
 

p8vm.cmd

@@ -1,4 +1,6 @@
-set PROG8CLASSPATH=./out/production/compiler
+@echo off
+
+set PROG8CLASSPATH=./out/production/compiler_main
 set KOTLINPATH=%USERPROFILE%/.IdeaIC2018.3/config/plugins/Kotlin
 set LIBJARS=%KOTLINPATH%/lib/kotlin-stdlib.jar;%KOTLINPATH%/lib/kotlin-reflect.jar
 

p8vm.sh

@@ -1,6 +1,6 @@
 #!/usr/bin/env sh
 
-PROG8CLASSPATH=./out/production/compiler
+PROG8CLASSPATH=./out/production/compiler_main
 KOTLINPATH=${HOME}/.IntelliJIdea2018.3/config/plugins/Kotlin
 LIBJARS=${KOTLINPATH}/lib/kotlin-stdlib.jar:${KOTLINPATH}/lib/kotlin-reflect.jar
 

parser/antlr/prog8.g4

@@ -10,6 +10,9 @@ NOTES:
 
 grammar prog8;
 
+@header {
+package prog8.parser;
+}
 
 LINECOMMENT : [\r\n][ \t]* COMMENT -> channel(HIDDEN);
 COMMENT :  ';' ~[\r\n]* -> channel(HIDDEN) ;
@@ -108,7 +111,7 @@ constdecl: 'const' varinitializer ;
 
 memoryvardecl: 'memory' varinitializer;
 
-datatype:  'ubyte' | 'byte' | 'uword' | 'word' | 'float' | 'str' | 'str_p' | 'str_s' | 'str_ps' ;
+datatype:  'ubyte' | 'byte' | 'uword' | 'word' | 'float' | 'str' | 'str_s' ;
 
 arrayspec:  '[' expression ']' ;
 

parser/build.gradle

@@ -0,0 +1,34 @@
+plugins {
+    id 'antlr'
+    id 'java'
+}
+
+repositories {
+    mavenCentral()
+}
+
+dependencies {
+    antlr('org.antlr:antlr4:4.7.2') {
+        exclude group: 'com.ibm.icu', module: 'icu4j'
+    }
+}
+
+compileJava {
+    dependsOn tasks.withType(AntlrTask)
+}
+
+generateGrammarSource {
+    outputDirectory = file("src/prog8/parser")
+    arguments += ["-no-listener","-no-visitor"]
+}
+
+sourceSets {
+    main {
+        java {
+            srcDirs = ["${project.projectDir}/src"]
+        }
+        antlr {
+        	srcDirs = ["${project.projectDir}/antlr"]
+        }
+    }
+}

parser/src/prog8/parser/prog8Lexer.java

@@ -1,5 +1,7 @@
-// Generated from /home/irmen/Projects/prog8/parser/antlr/prog8.g4 by ANTLR 4.7.2
+// Generated from ./parser/antlr/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;
@@ -32,10 +34,9 @@ public class prog8Lexer extends Lexer {
 		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, T__108=109, T__109=110, T__110=111, T__111=112, LINECOMMENT=113, 
-		COMMENT=114, WS=115, EOL=116, NAME=117, DEC_INTEGER=118, HEX_INTEGER=119, 
-		BIN_INTEGER=120, FLOAT_NUMBER=121, STRING=122, INLINEASMBLOCK=123, SINGLECHAR=124, 
-		ZEROPAGE=125;
+		T__107=108, T__108=109, T__109=110, LINECOMMENT=111, COMMENT=112, WS=113, 
+		EOL=114, NAME=115, DEC_INTEGER=116, HEX_INTEGER=117, BIN_INTEGER=118, 
+		FLOAT_NUMBER=119, STRING=120, INLINEASMBLOCK=121, SINGLECHAR=122, ZEROPAGE=123;
 	public static String[] channelNames = {
 		"DEFAULT_TOKEN_CHANNEL", "HIDDEN"
 	};
@@ -59,10 +60,10 @@ public class prog8Lexer extends Lexer {
 			"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", "T__108", "T__109", "T__110", "T__111", 
-			"LINECOMMENT", "COMMENT", "WS", "EOL", "NAME", "DEC_INTEGER", "HEX_INTEGER", 
-			"BIN_INTEGER", "FLOAT_NUMBER", "FNUMBER", "STRING_ESCAPE_SEQ", "STRING", 
-			"INLINEASMBLOCK", "SINGLECHAR", "ZEROPAGE"
+			"T__105", "T__106", "T__107", "T__108", "T__109", "LINECOMMENT", "COMMENT", 
+			"WS", "EOL", "NAME", "DEC_INTEGER", "HEX_INTEGER", "BIN_INTEGER", "FLOAT_NUMBER", 
+			"FNUMBER", "STRING_ESCAPE_SEQ", "STRING", "INLINEASMBLOCK", "SINGLECHAR", 
+			"ZEROPAGE"
 		};
 	}
 	public static final String[] ruleNames = makeRuleNames();
@@ -72,19 +73,19 @@ public class prog8Lexer extends Lexer {
 			null, "'~'", "':'", "'goto'", "'%output'", "'%launcher'", "'%zeropage'", 
 			"'%zpreserved'", "'%address'", "'%import'", "'%breakpoint'", "'%asminclude'", 
 			"'%asmbinary'", "'%option'", "','", "'='", "'const'", "'memory'", "'ubyte'", 
-			"'byte'", "'uword'", "'word'", "'float'", "'str'", "'str_p'", "'str_s'", 
-			"'str_ps'", "'['", "']'", "'+='", "'-='", "'/='", "'*='", "'**='", "'&='", 
-			"'|='", "'^='", "'%='", "'<<='", "'>>='", "'++'", "'--'", "'+'", "'-'", 
-			"'**'", "'*'", "'/'", "'%'", "'<<'", "'>>'", "'<'", "'>'", "'<='", "'>='", 
-			"'=='", "'!='", "'&'", "'^'", "'|'", "'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'"
+			"'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();
@@ -99,9 +100,9 @@ public class prog8Lexer extends Lexer {
 			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", "FLOAT_NUMBER", 
-			"STRING", "INLINEASMBLOCK", "SINGLECHAR", "ZEROPAGE"
+			null, null, null, "LINECOMMENT", "COMMENT", "WS", "EOL", "NAME", "DEC_INTEGER", 
+			"HEX_INTEGER", "BIN_INTEGER", "FLOAT_NUMBER", "STRING", "INLINEASMBLOCK", 
+			"SINGLECHAR", "ZEROPAGE"
 		};
 	}
 	private static final String[] _SYMBOLIC_NAMES = makeSymbolicNames();
@@ -165,13 +166,13 @@ public class prog8Lexer extends Lexer {
 	@Override
 	public void action(RuleContext _localctx, int ruleIndex, int actionIndex) {
 		switch (ruleIndex) {
-		case 123:
+		case 121:
 			STRING_action((RuleContext)_localctx, actionIndex);
 			break;
-		case 124:
+		case 122:
 			INLINEASMBLOCK_action((RuleContext)_localctx, actionIndex);
 			break;
-		case 125:
+		case 123:
 			SINGLECHAR_action((RuleContext)_localctx, actionIndex);
 			break;
 		}
@@ -211,299 +212,292 @@ public class prog8Lexer extends Lexer {
 	}
 
 	public static final String _serializedATN =
-		"\3\u608b\ua72a\u8133\ub9ed\u417c\u3be7\u7786\u5964\2\177\u0373\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\4"+
-		"I\tI\4J\tJ\4K\tK\4L\tL\4M\tM\4N\tN\4O\tO\4P\tP\4Q\tQ\4R\tR\4S\tS\4T\t"+
-		"T\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"+
-		"\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\177\t\177\4\u0080\t"+
-		"\u0080\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\22\3\23\3\23\3"+
-		"\23\3\23\3\23\3\23\3\24\3\24\3\24\3\24\3\24\3\25\3\25\3\25\3\25\3\25\3"+
-		"\25\3\26\3\26\3\26\3\26\3\26\3\27\3\27\3\27\3\27\3\27\3\27\3\30\3\30\3"+
-		"\30\3\30\3\31\3\31\3\31\3\31\3\31\3\31\3\32\3\32\3\32\3\32\3\32\3\32\3"+
-		"\33\3\33\3\33\3\33\3\33\3\33\3\33\3\34\3\34\3\35\3\35\3\36\3\36\3\36\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/\3/\3\60\3\60\3\61\3\61\3\61\3\62\3\62\3\62\3\63\3"+
-		"\63\3\64\3\64\3\65\3\65\3\65\3\66\3\66\3\66\3\67\3\67\3\67\38\38\38\3"+
-		"9\39\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\3B\3B\3C\3C\3D\3D\3D\3E\3E\3F\3F\3F\3F\3F\3F\3F\3G\3"+
-		"G\3G\3G\3G\3G\3H\3H\3H\3H\3H\3H\3H\3H\3H\3I\3I\3J\3J\3K\3K\3L\3L\3M\3"+
-		"M\3M\3N\3N\3N\3O\3O\3O\3P\3P\3P\3Q\3Q\3Q\3R\3R\3R\3S\3S\3S\3T\3T\3T\3"+
-		"U\3U\3U\3U\3U\3V\3V\3V\3V\3V\3V\3W\3W\3W\3W\3W\3X\3X\3X\3X\3Y\3Y\3Y\3"+
-		"Z\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`\3`\3a\3a\3a\3a\3a\3a\3b\3b\3b\3b\3"+
-		"b\3b\3c\3c\3c\3c\3c\3c\3d\3d\3d\3d\3d\3e\3e\3e\3e\3e\3e\3f\3f\3f\3f\3"+
-		"f\3f\3g\3g\3g\3g\3g\3g\3h\3h\3h\3h\3h\3h\3h\3i\3i\3i\3i\3i\3i\3j\3j\3"+
-		"j\3j\3j\3j\3j\3k\3k\3k\3k\3k\3k\3l\3l\3l\3l\3l\3l\3m\3m\3m\3m\3n\3n\3"+
-		"n\3o\3o\3o\3o\3o\3o\3p\3p\3p\3p\3p\3p\3p\3q\3q\3q\3q\3q\3q\3r\3r\7r\u02fe"+
-		"\nr\fr\16r\u0301\13r\3r\3r\3r\3r\3s\3s\7s\u0309\ns\fs\16s\u030c\13s\3"+
-		"s\3s\3t\3t\3t\3t\3u\6u\u0315\nu\ru\16u\u0316\3v\3v\7v\u031b\nv\fv\16v"+
-		"\u031e\13v\3w\3w\3w\6w\u0323\nw\rw\16w\u0324\5w\u0327\nw\3x\3x\6x\u032b"+
-		"\nx\rx\16x\u032c\3y\3y\6y\u0331\ny\ry\16y\u0332\3z\3z\3z\5z\u0338\nz\3"+
-		"z\5z\u033b\nz\3{\6{\u033e\n{\r{\16{\u033f\3{\3{\6{\u0344\n{\r{\16{\u0345"+
-		"\5{\u0348\n{\3|\3|\3|\3|\5|\u034e\n|\3}\3}\3}\7}\u0353\n}\f}\16}\u0356"+
-		"\13}\3}\3}\3}\3~\3~\3~\3~\6~\u035f\n~\r~\16~\u0360\3~\3~\3~\3~\3~\3\177"+
-		"\3\177\3\177\5\177\u036b\n\177\3\177\3\177\3\177\3\u0080\3\u0080\3\u0080"+
-		"\3\u0080\3\u0360\2\u0081\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\62"+
-		"c\63e\64g\65i\66k\67m8o9q:s;u<w=y>{?}@\177A\u0081B\u0083C\u0085D\u0087"+
-		"E\u0089F\u008bG\u008dH\u008fI\u0091J\u0093K\u0095L\u0097M\u0099N\u009b"+
-		"O\u009dP\u009fQ\u00a1R\u00a3S\u00a5T\u00a7U\u00a9V\u00abW\u00adX\u00af"+
-		"Y\u00b1Z\u00b3[\u00b5\\\u00b7]\u00b9^\u00bb_\u00bd`\u00bfa\u00c1b\u00c3"+
-		"c\u00c5d\u00c7e\u00c9f\u00cbg\u00cdh\u00cfi\u00d1j\u00d3k\u00d5l\u00d7"+
-		"m\u00d9n\u00dbo\u00ddp\u00dfq\u00e1r\u00e3s\u00e5t\u00e7u\u00e9v\u00eb"+
-		"w\u00edx\u00efy\u00f1z\u00f3{\u00f5\2\u00f7\2\u00f9|\u00fb}\u00fd~\u00ff"+
-		"\177\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\u0382\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\2"+
-		"Y\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\u00ef\3\2\2\2\2\u00f1\3\2\2\2\2\u00f3"+
-		"\3\2\2\2\2\u00f9\3\2\2\2\2\u00fb\3\2\2\2\2\u00fd\3\2\2\2\2\u00ff\3\2\2"+
-		"\2\3\u0101\3\2\2\2\5\u0103\3\2\2\2\7\u0105\3\2\2\2\t\u010a\3\2\2\2\13"+
-		"\u0112\3\2\2\2\r\u011c\3\2\2\2\17\u0126\3\2\2\2\21\u0132\3\2\2\2\23\u013b"+
-		"\3\2\2\2\25\u0143\3\2\2\2\27\u014f\3\2\2\2\31\u015b\3\2\2\2\33\u0166\3"+
-		"\2\2\2\35\u016e\3\2\2\2\37\u0170\3\2\2\2!\u0172\3\2\2\2#\u0178\3\2\2\2"+
-		"%\u017f\3\2\2\2\'\u0185\3\2\2\2)\u018a\3\2\2\2+\u0190\3\2\2\2-\u0195\3"+
-		"\2\2\2/\u019b\3\2\2\2\61\u019f\3\2\2\2\63\u01a5\3\2\2\2\65\u01ab\3\2\2"+
-		"\2\67\u01b2\3\2\2\29\u01b4\3\2\2\2;\u01b6\3\2\2\2=\u01b9\3\2\2\2?\u01bc"+
-		"\3\2\2\2A\u01bf\3\2\2\2C\u01c2\3\2\2\2E\u01c6\3\2\2\2G\u01c9\3\2\2\2I"+
-		"\u01cc\3\2\2\2K\u01cf\3\2\2\2M\u01d2\3\2\2\2O\u01d6\3\2\2\2Q\u01da\3\2"+
-		"\2\2S\u01dd\3\2\2\2U\u01e0\3\2\2\2W\u01e2\3\2\2\2Y\u01e4\3\2\2\2[\u01e7"+
-		"\3\2\2\2]\u01e9\3\2\2\2_\u01eb\3\2\2\2a\u01ed\3\2\2\2c\u01f0\3\2\2\2e"+
-		"\u01f3\3\2\2\2g\u01f5\3\2\2\2i\u01f7\3\2\2\2k\u01fa\3\2\2\2m\u01fd\3\2"+
-		"\2\2o\u0200\3\2\2\2q\u0203\3\2\2\2s\u0205\3\2\2\2u\u0207\3\2\2\2w\u0209"+
-		"\3\2\2\2y\u020c\3\2\2\2{\u0211\3\2\2\2}\u0215\3\2\2\2\177\u0218\3\2\2"+
-		"\2\u0081\u021c\3\2\2\2\u0083\u0220\3\2\2\2\u0085\u0222\3\2\2\2\u0087\u0224"+
-		"\3\2\2\2\u0089\u0227\3\2\2\2\u008b\u0229\3\2\2\2\u008d\u0230\3\2\2\2\u008f"+
-		"\u0236\3\2\2\2\u0091\u023f\3\2\2\2\u0093\u0241\3\2\2\2\u0095\u0243\3\2"+
-		"\2\2\u0097\u0245\3\2\2\2\u0099\u0247\3\2\2\2\u009b\u024a\3\2\2\2\u009d"+
-		"\u024d\3\2\2\2\u009f\u0250\3\2\2\2\u00a1\u0253\3\2\2\2\u00a3\u0256\3\2"+
-		"\2\2\u00a5\u0259\3\2\2\2\u00a7\u025c\3\2\2\2\u00a9\u025f\3\2\2\2\u00ab"+
-		"\u0264\3\2\2\2\u00ad\u026a\3\2\2\2\u00af\u026f\3\2\2\2\u00b1\u0273\3\2"+
-		"\2\2\u00b3\u0276\3\2\2\2\u00b5\u0278\3\2\2\2\u00b7\u027a\3\2\2\2\u00b9"+
-		"\u0281\3\2\2\2\u00bb\u028a\3\2\2\2\u00bd\u0290\3\2\2\2\u00bf\u0293\3\2"+
-		"\2\2\u00c1\u0298\3\2\2\2\u00c3\u029e\3\2\2\2\u00c5\u02a4\3\2\2\2\u00c7"+
-		"\u02aa\3\2\2\2\u00c9\u02af\3\2\2\2\u00cb\u02b5\3\2\2\2\u00cd\u02bb\3\2"+
-		"\2\2\u00cf\u02c1\3\2\2\2\u00d1\u02c8\3\2\2\2\u00d3\u02ce\3\2\2\2\u00d5"+
-		"\u02d5\3\2\2\2\u00d7\u02db\3\2\2\2\u00d9\u02e1\3\2\2\2\u00db\u02e5\3\2"+
-		"\2\2\u00dd\u02e8\3\2\2\2\u00df\u02ee\3\2\2\2\u00e1\u02f5\3\2\2\2\u00e3"+
-		"\u02fb\3\2\2\2\u00e5\u0306\3\2\2\2\u00e7\u030f\3\2\2\2\u00e9\u0314\3\2"+
-		"\2\2\u00eb\u0318\3\2\2\2\u00ed\u0326\3\2\2\2\u00ef\u0328\3\2\2\2\u00f1"+
-		"\u032e\3\2\2\2\u00f3\u0334\3\2\2\2\u00f5\u033d\3\2\2\2\u00f7\u034d\3\2"+
-		"\2\2\u00f9\u034f\3\2\2\2\u00fb\u035a\3\2\2\2\u00fd\u0367\3\2\2\2\u00ff"+
-		"\u036f\3\2\2\2\u0101\u0102\7\u0080\2\2\u0102\4\3\2\2\2\u0103\u0104\7<"+
-		"\2\2\u0104\6\3\2\2\2\u0105\u0106\7i\2\2\u0106\u0107\7q\2\2\u0107\u0108"+
-		"\7v\2\2\u0108\u0109\7q\2\2\u0109\b\3\2\2\2\u010a\u010b\7\'\2\2\u010b\u010c"+
-		"\7q\2\2\u010c\u010d\7w\2\2\u010d\u010e\7v\2\2\u010e\u010f\7r\2\2\u010f"+
-		"\u0110\7w\2\2\u0110\u0111\7v\2\2\u0111\n\3\2\2\2\u0112\u0113\7\'\2\2\u0113"+
-		"\u0114\7n\2\2\u0114\u0115\7c\2\2\u0115\u0116\7w\2\2\u0116\u0117\7p\2\2"+
-		"\u0117\u0118\7e\2\2\u0118\u0119\7j\2\2\u0119\u011a\7g\2\2\u011a\u011b"+
-		"\7t\2\2\u011b\f\3\2\2\2\u011c\u011d\7\'\2\2\u011d\u011e\7|\2\2\u011e\u011f"+
-		"\7g\2\2\u011f\u0120\7t\2\2\u0120\u0121\7q\2\2\u0121\u0122\7r\2\2\u0122"+
-		"\u0123\7c\2\2\u0123\u0124\7i\2\2\u0124\u0125\7g\2\2\u0125\16\3\2\2\2\u0126"+
-		"\u0127\7\'\2\2\u0127\u0128\7|\2\2\u0128\u0129\7r\2\2\u0129\u012a\7t\2"+
-		"\2\u012a\u012b\7g\2\2\u012b\u012c\7u\2\2\u012c\u012d\7g\2\2\u012d\u012e"+
-		"\7t\2\2\u012e\u012f\7x\2\2\u012f\u0130\7g\2\2\u0130\u0131\7f\2\2\u0131"+
-		"\20\3\2\2\2\u0132\u0133\7\'\2\2\u0133\u0134\7c\2\2\u0134\u0135\7f\2\2"+
-		"\u0135\u0136\7f\2\2\u0136\u0137\7t\2\2\u0137\u0138\7g\2\2\u0138\u0139"+
-		"\7u\2\2\u0139\u013a\7u\2\2\u013a\22\3\2\2\2\u013b\u013c\7\'\2\2\u013c"+
-		"\u013d\7k\2\2\u013d\u013e\7o\2\2\u013e\u013f\7r\2\2\u013f\u0140\7q\2\2"+
-		"\u0140\u0141\7t\2\2\u0141\u0142\7v\2\2\u0142\24\3\2\2\2\u0143\u0144\7"+
-		"\'\2\2\u0144\u0145\7d\2\2\u0145\u0146\7t\2\2\u0146\u0147\7g\2\2\u0147"+
-		"\u0148\7c\2\2\u0148\u0149\7m\2\2\u0149\u014a\7r\2\2\u014a\u014b\7q\2\2"+
-		"\u014b\u014c\7k\2\2\u014c\u014d\7p\2\2\u014d\u014e\7v\2\2\u014e\26\3\2"+
-		"\2\2\u014f\u0150\7\'\2\2\u0150\u0151\7c\2\2\u0151\u0152\7u\2\2\u0152\u0153"+
-		"\7o\2\2\u0153\u0154\7k\2\2\u0154\u0155\7p\2\2\u0155\u0156\7e\2\2\u0156"+
-		"\u0157\7n\2\2\u0157\u0158\7w\2\2\u0158\u0159\7f\2\2\u0159\u015a\7g\2\2"+
-		"\u015a\30\3\2\2\2\u015b\u015c\7\'\2\2\u015c\u015d\7c\2\2\u015d\u015e\7"+
-		"u\2\2\u015e\u015f\7o\2\2\u015f\u0160\7d\2\2\u0160\u0161\7k\2\2\u0161\u0162"+
-		"\7p\2\2\u0162\u0163\7c\2\2\u0163\u0164\7t\2\2\u0164\u0165\7{\2\2\u0165"+
-		"\32\3\2\2\2\u0166\u0167\7\'\2\2\u0167\u0168\7q\2\2\u0168\u0169\7r\2\2"+
-		"\u0169\u016a\7v\2\2\u016a\u016b\7k\2\2\u016b\u016c\7q\2\2\u016c\u016d"+
-		"\7p\2\2\u016d\34\3\2\2\2\u016e\u016f\7.\2\2\u016f\36\3\2\2\2\u0170\u0171"+
-		"\7?\2\2\u0171 \3\2\2\2\u0172\u0173\7e\2\2\u0173\u0174\7q\2\2\u0174\u0175"+
-		"\7p\2\2\u0175\u0176\7u\2\2\u0176\u0177\7v\2\2\u0177\"\3\2\2\2\u0178\u0179"+
-		"\7o\2\2\u0179\u017a\7g\2\2\u017a\u017b\7o\2\2\u017b\u017c\7q\2\2\u017c"+
-		"\u017d\7t\2\2\u017d\u017e\7{\2\2\u017e$\3\2\2\2\u017f\u0180\7w\2\2\u0180"+
-		"\u0181\7d\2\2\u0181\u0182\7{\2\2\u0182\u0183\7v\2\2\u0183\u0184\7g\2\2"+
-		"\u0184&\3\2\2\2\u0185\u0186\7d\2\2\u0186\u0187\7{\2\2\u0187\u0188\7v\2"+
-		"\2\u0188\u0189\7g\2\2\u0189(\3\2\2\2\u018a\u018b\7w\2\2\u018b\u018c\7"+
-		"y\2\2\u018c\u018d\7q\2\2\u018d\u018e\7t\2\2\u018e\u018f\7f\2\2\u018f*"+
-		"\3\2\2\2\u0190\u0191\7y\2\2\u0191\u0192\7q\2\2\u0192\u0193\7t\2\2\u0193"+
-		"\u0194\7f\2\2\u0194,\3\2\2\2\u0195\u0196\7h\2\2\u0196\u0197\7n\2\2\u0197"+
-		"\u0198\7q\2\2\u0198\u0199\7c\2\2\u0199\u019a\7v\2\2\u019a.\3\2\2\2\u019b"+
-		"\u019c\7u\2\2\u019c\u019d\7v\2\2\u019d\u019e\7t\2\2\u019e\60\3\2\2\2\u019f"+
-		"\u01a0\7u\2\2\u01a0\u01a1\7v\2\2\u01a1\u01a2\7t\2\2\u01a2\u01a3\7a\2\2"+
-		"\u01a3\u01a4\7r\2\2\u01a4\62\3\2\2\2\u01a5\u01a6\7u\2\2\u01a6\u01a7\7"+
-		"v\2\2\u01a7\u01a8\7t\2\2\u01a8\u01a9\7a\2\2\u01a9\u01aa\7u\2\2\u01aa\64"+
-		"\3\2\2\2\u01ab\u01ac\7u\2\2\u01ac\u01ad\7v\2\2\u01ad\u01ae\7t\2\2\u01ae"+
-		"\u01af\7a\2\2\u01af\u01b0\7r\2\2\u01b0\u01b1\7u\2\2\u01b1\66\3\2\2\2\u01b2"+
-		"\u01b3\7]\2\2\u01b38\3\2\2\2\u01b4\u01b5\7_\2\2\u01b5:\3\2\2\2\u01b6\u01b7"+
-		"\7-\2\2\u01b7\u01b8\7?\2\2\u01b8<\3\2\2\2\u01b9\u01ba\7/\2\2\u01ba\u01bb"+
-		"\7?\2\2\u01bb>\3\2\2\2\u01bc\u01bd\7\61\2\2\u01bd\u01be\7?\2\2\u01be@"+
-		"\3\2\2\2\u01bf\u01c0\7,\2\2\u01c0\u01c1\7?\2\2\u01c1B\3\2\2\2\u01c2\u01c3"+
-		"\7,\2\2\u01c3\u01c4\7,\2\2\u01c4\u01c5\7?\2\2\u01c5D\3\2\2\2\u01c6\u01c7"+
-		"\7(\2\2\u01c7\u01c8\7?\2\2\u01c8F\3\2\2\2\u01c9\u01ca\7~\2\2\u01ca\u01cb"+
-		"\7?\2\2\u01cbH\3\2\2\2\u01cc\u01cd\7`\2\2\u01cd\u01ce\7?\2\2\u01ceJ\3"+
-		"\2\2\2\u01cf\u01d0\7\'\2\2\u01d0\u01d1\7?\2\2\u01d1L\3\2\2\2\u01d2\u01d3"+
-		"\7>\2\2\u01d3\u01d4\7>\2\2\u01d4\u01d5\7?\2\2\u01d5N\3\2\2\2\u01d6\u01d7"+
-		"\7@\2\2\u01d7\u01d8\7@\2\2\u01d8\u01d9\7?\2\2\u01d9P\3\2\2\2\u01da\u01db"+
-		"\7-\2\2\u01db\u01dc\7-\2\2\u01dcR\3\2\2\2\u01dd\u01de\7/\2\2\u01de\u01df"+
-		"\7/\2\2\u01dfT\3\2\2\2\u01e0\u01e1\7-\2\2\u01e1V\3\2\2\2\u01e2\u01e3\7"+
-		"/\2\2\u01e3X\3\2\2\2\u01e4\u01e5\7,\2\2\u01e5\u01e6\7,\2\2\u01e6Z\3\2"+
-		"\2\2\u01e7\u01e8\7,\2\2\u01e8\\\3\2\2\2\u01e9\u01ea\7\61\2\2\u01ea^\3"+
-		"\2\2\2\u01eb\u01ec\7\'\2\2\u01ec`\3\2\2\2\u01ed\u01ee\7>\2\2\u01ee\u01ef"+
-		"\7>\2\2\u01efb\3\2\2\2\u01f0\u01f1\7@\2\2\u01f1\u01f2\7@\2\2\u01f2d\3"+
-		"\2\2\2\u01f3\u01f4\7>\2\2\u01f4f\3\2\2\2\u01f5\u01f6\7@\2\2\u01f6h\3\2"+
-		"\2\2\u01f7\u01f8\7>\2\2\u01f8\u01f9\7?\2\2\u01f9j\3\2\2\2\u01fa\u01fb"+
-		"\7@\2\2\u01fb\u01fc\7?\2\2\u01fcl\3\2\2\2\u01fd\u01fe\7?\2\2\u01fe\u01ff"+
-		"\7?\2\2\u01ffn\3\2\2\2\u0200\u0201\7#\2\2\u0201\u0202\7?\2\2\u0202p\3"+
-		"\2\2\2\u0203\u0204\7(\2\2\u0204r\3\2\2\2\u0205\u0206\7`\2\2\u0206t\3\2"+
-		"\2\2\u0207\u0208\7~\2\2\u0208v\3\2\2\2\u0209\u020a\7v\2\2\u020a\u020b"+
-		"\7q\2\2\u020bx\3\2\2\2\u020c\u020d\7u\2\2\u020d\u020e\7v\2\2\u020e\u020f"+
-		"\7g\2\2\u020f\u0210\7r\2\2\u0210z\3\2\2\2\u0211\u0212\7c\2\2\u0212\u0213"+
-		"\7p\2\2\u0213\u0214\7f\2\2\u0214|\3\2\2\2\u0215\u0216\7q\2\2\u0216\u0217"+
-		"\7t\2\2\u0217~\3\2\2\2\u0218\u0219\7z\2\2\u0219\u021a\7q\2\2\u021a\u021b"+
-		"\7t\2\2\u021b\u0080\3\2\2\2\u021c\u021d\7p\2\2\u021d\u021e\7q\2\2\u021e"+
-		"\u021f\7v\2\2\u021f\u0082\3\2\2\2\u0220\u0221\7*\2\2\u0221\u0084\3\2\2"+
-		"\2\u0222\u0223\7+\2\2\u0223\u0086\3\2\2\2\u0224\u0225\7c\2\2\u0225\u0226"+
-		"\7u\2\2\u0226\u0088\3\2\2\2\u0227\u0228\7B\2\2\u0228\u008a\3\2\2\2\u0229"+
-		"\u022a\7t\2\2\u022a\u022b\7g\2\2\u022b\u022c\7v\2\2\u022c\u022d\7w\2\2"+
-		"\u022d\u022e\7t\2\2\u022e\u022f\7p\2\2\u022f\u008c\3\2\2\2\u0230\u0231"+
-		"\7d\2\2\u0231\u0232\7t\2\2\u0232\u0233\7g\2\2\u0233\u0234\7c\2\2\u0234"+
-		"\u0235\7m\2\2\u0235\u008e\3\2\2\2\u0236\u0237\7e\2\2\u0237\u0238\7q\2"+
-		"\2\u0238\u0239\7p\2\2\u0239\u023a\7v\2\2\u023a\u023b\7k\2\2\u023b\u023c"+
-		"\7p\2\2\u023c\u023d\7w\2\2\u023d\u023e\7g\2\2\u023e\u0090\3\2\2\2\u023f"+
-		"\u0240\7\60\2\2\u0240\u0092\3\2\2\2\u0241\u0242\7C\2\2\u0242\u0094\3\2"+
-		"\2\2\u0243\u0244\7Z\2\2\u0244\u0096\3\2\2\2\u0245\u0246\7[\2\2\u0246\u0098"+
-		"\3\2\2\2\u0247\u0248\7C\2\2\u0248\u0249\7Z\2\2\u0249\u009a\3\2\2\2\u024a"+
-		"\u024b\7C\2\2\u024b\u024c\7[\2\2\u024c\u009c\3\2\2\2\u024d\u024e\7Z\2"+
-		"\2\u024e\u024f\7[\2\2\u024f\u009e\3\2\2\2\u0250\u0251\7R\2\2\u0251\u0252"+
-		"\7e\2\2\u0252\u00a0\3\2\2\2\u0253\u0254\7R\2\2\u0254\u0255\7|\2\2\u0255"+
-		"\u00a2\3\2\2\2\u0256\u0257\7R\2\2\u0257\u0258\7p\2\2\u0258\u00a4\3\2\2"+
-		"\2\u0259\u025a\7R\2\2\u025a\u025b\7x\2\2\u025b\u00a6\3\2\2\2\u025c\u025d"+
-		"\7\60\2\2\u025d\u025e\7y\2\2\u025e\u00a8\3\2\2\2\u025f\u0260\7v\2\2\u0260"+
-		"\u0261\7t\2\2\u0261\u0262\7w\2\2\u0262\u0263\7g\2\2\u0263\u00aa\3\2\2"+
-		"\2\u0264\u0265\7h\2\2\u0265\u0266\7c\2\2\u0266\u0267\7n\2\2\u0267\u0268"+
-		"\7u\2\2\u0268\u0269\7g\2\2\u0269\u00ac\3\2\2\2\u026a\u026b\7\'\2\2\u026b"+
-		"\u026c\7c\2\2\u026c\u026d\7u\2\2\u026d\u026e\7o\2\2\u026e\u00ae\3\2\2"+
-		"\2\u026f\u0270\7u\2\2\u0270\u0271\7w\2\2\u0271\u0272\7d\2\2\u0272\u00b0"+
-		"\3\2\2\2\u0273\u0274\7/\2\2\u0274\u0275\7@\2\2\u0275\u00b2\3\2\2\2\u0276"+
-		"\u0277\7}\2\2\u0277\u00b4\3\2\2\2\u0278\u0279\7\177\2\2\u0279\u00b6\3"+
-		"\2\2\2\u027a\u027b\7c\2\2\u027b\u027c\7u\2\2\u027c\u027d\7o\2\2\u027d"+
-		"\u027e\7u\2\2\u027e\u027f\7w\2\2\u027f\u0280\7d\2\2\u0280\u00b8\3\2\2"+
-		"\2\u0281\u0282\7e\2\2\u0282\u0283\7n\2\2\u0283\u0284\7q\2\2\u0284\u0285"+
-		"\7d\2\2\u0285\u0286\7d\2\2\u0286\u0287\7g\2\2\u0287\u0288\7t\2\2\u0288"+
-		"\u0289\7u\2\2\u0289\u00ba\3\2\2\2\u028a\u028b\7u\2\2\u028b\u028c\7v\2"+
-		"\2\u028c\u028d\7c\2\2\u028d\u028e\7e\2\2\u028e\u028f\7m\2\2\u028f\u00bc"+
-		"\3\2\2\2\u0290\u0291\7k\2\2\u0291\u0292\7h\2\2\u0292\u00be\3\2\2\2\u0293"+
-		"\u0294\7g\2\2\u0294\u0295\7n\2\2\u0295\u0296\7u\2\2\u0296\u0297\7g\2\2"+
-		"\u0297\u00c0\3\2\2\2\u0298\u0299\7k\2\2\u0299\u029a\7h\2\2\u029a\u029b"+
-		"\7a\2\2\u029b\u029c\7e\2\2\u029c\u029d\7u\2\2\u029d\u00c2\3\2\2\2\u029e"+
-		"\u029f\7k\2\2\u029f\u02a0\7h\2\2\u02a0\u02a1\7a\2\2\u02a1\u02a2\7e\2\2"+
-		"\u02a2\u02a3\7e\2\2\u02a3\u00c4\3\2\2\2\u02a4\u02a5\7k\2\2\u02a5\u02a6"+
-		"\7h\2\2\u02a6\u02a7\7a\2\2\u02a7\u02a8\7g\2\2\u02a8\u02a9\7s\2\2\u02a9"+
-		"\u00c6\3\2\2\2\u02aa\u02ab\7k\2\2\u02ab\u02ac\7h\2\2\u02ac\u02ad\7a\2"+
-		"\2\u02ad\u02ae\7|\2\2\u02ae\u00c8\3\2\2\2\u02af\u02b0\7k\2\2\u02b0\u02b1"+
-		"\7h\2\2\u02b1\u02b2\7a\2\2\u02b2\u02b3\7p\2\2\u02b3\u02b4\7g\2\2\u02b4"+
-		"\u00ca\3\2\2\2\u02b5\u02b6\7k\2\2\u02b6\u02b7\7h\2\2\u02b7\u02b8\7a\2"+
-		"\2\u02b8\u02b9\7p\2\2\u02b9\u02ba\7|\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\7r\2\2\u02bf"+
-		"\u02c0\7n\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\7r\2\2\u02c5\u02c6\7q\2\2\u02c6\u02c7"+
-		"\7u\2\2\u02c7\u00d0\3\2\2\2\u02c8\u02c9\7k\2\2\u02c9\u02ca\7h\2\2\u02ca"+
-		"\u02cb\7a\2\2\u02cb\u02cc\7o\2\2\u02cc\u02cd\7k\2\2\u02cd\u00d2\3\2\2"+
-		"\2\u02ce\u02cf\7k\2\2\u02cf\u02d0\7h\2\2\u02d0\u02d1\7a\2\2\u02d1\u02d2"+
-		"\7p\2\2\u02d2\u02d3\7g\2\2\u02d3\u02d4\7i\2\2\u02d4\u00d4\3\2\2\2\u02d5"+
-		"\u02d6\7k\2\2\u02d6\u02d7\7h\2\2\u02d7\u02d8\7a\2\2\u02d8\u02d9\7x\2\2"+
-		"\u02d9\u02da\7u\2\2\u02da\u00d6\3\2\2\2\u02db\u02dc\7k\2\2\u02dc\u02dd"+
-		"\7h\2\2\u02dd\u02de\7a\2\2\u02de\u02df\7x\2\2\u02df\u02e0\7e\2\2\u02e0"+
-		"\u00d8\3\2\2\2\u02e1\u02e2\7h\2\2\u02e2\u02e3\7q\2\2\u02e3\u02e4\7t\2"+
-		"\2\u02e4\u00da\3\2\2\2\u02e5\u02e6\7k\2\2\u02e6\u02e7\7p\2\2\u02e7\u00dc"+
-		"\3\2\2\2\u02e8\u02e9\7y\2\2\u02e9\u02ea\7j\2\2\u02ea\u02eb\7k\2\2\u02eb"+
-		"\u02ec\7n\2\2\u02ec\u02ed\7g\2\2\u02ed\u00de\3\2\2\2\u02ee\u02ef\7t\2"+
-		"\2\u02ef\u02f0\7g\2\2\u02f0\u02f1\7r\2\2\u02f1\u02f2\7g\2\2\u02f2\u02f3"+
-		"\7c\2\2\u02f3\u02f4\7v\2\2\u02f4\u00e0\3\2\2\2\u02f5\u02f6\7w\2\2\u02f6"+
-		"\u02f7\7p\2\2\u02f7\u02f8\7v\2\2\u02f8\u02f9\7k\2\2\u02f9\u02fa\7n\2\2"+
-		"\u02fa\u00e2\3\2\2\2\u02fb\u02ff\t\2\2\2\u02fc\u02fe\t\3\2\2\u02fd\u02fc"+
-		"\3\2\2\2\u02fe\u0301\3\2\2\2\u02ff\u02fd\3\2\2\2\u02ff\u0300\3\2\2\2\u0300"+
-		"\u0302\3\2\2\2\u0301\u02ff\3\2\2\2\u0302\u0303\5\u00e5s\2\u0303\u0304"+
-		"\3\2\2\2\u0304\u0305\br\2\2\u0305\u00e4\3\2\2\2\u0306\u030a\7=\2\2\u0307"+
-		"\u0309\n\2\2\2\u0308\u0307\3\2\2\2\u0309\u030c\3\2\2\2\u030a\u0308\3\2"+
-		"\2\2\u030a\u030b\3\2\2\2\u030b\u030d\3\2\2\2\u030c\u030a\3\2\2\2\u030d"+
-		"\u030e\bs\2\2\u030e\u00e6\3\2\2\2\u030f\u0310\t\3\2\2\u0310\u0311\3\2"+
-		"\2\2\u0311\u0312\bt\3\2\u0312\u00e8\3\2\2\2\u0313\u0315\t\2\2\2\u0314"+
-		"\u0313\3\2\2\2\u0315\u0316\3\2\2\2\u0316\u0314\3\2\2\2\u0316\u0317\3\2"+
-		"\2\2\u0317\u00ea\3\2\2\2\u0318\u031c\t\4\2\2\u0319\u031b\t\5\2\2\u031a"+
-		"\u0319\3\2\2\2\u031b\u031e\3\2\2\2\u031c\u031a\3\2\2\2\u031c\u031d\3\2"+
-		"\2\2\u031d\u00ec\3\2\2\2\u031e\u031c\3\2\2\2\u031f\u0327\4\62;\2\u0320"+
-		"\u0322\4\63;\2\u0321\u0323\4\62;\2\u0322\u0321\3\2\2\2\u0323\u0324\3\2"+
-		"\2\2\u0324\u0322\3\2\2\2\u0324\u0325\3\2\2\2\u0325\u0327\3\2\2\2\u0326"+
-		"\u031f\3\2\2\2\u0326\u0320\3\2\2\2\u0327\u00ee\3\2\2\2\u0328\u032a\7&"+
-		"\2\2\u0329\u032b\t\6\2\2\u032a\u0329\3\2\2\2\u032b\u032c\3\2\2\2\u032c"+
-		"\u032a\3\2\2\2\u032c\u032d\3\2\2\2\u032d\u00f0\3\2\2\2\u032e\u0330\7\'"+
-		"\2\2\u032f\u0331\4\62\63\2\u0330\u032f\3\2\2\2\u0331\u0332\3\2\2\2\u0332"+
-		"\u0330\3\2\2\2\u0332\u0333\3\2\2\2\u0333\u00f2\3\2\2\2\u0334\u033a\5\u00f5"+
-		"{\2\u0335\u0337\t\7\2\2\u0336\u0338\t\b\2\2\u0337\u0336\3\2\2\2\u0337"+
-		"\u0338\3\2\2\2\u0338\u0339\3\2\2\2\u0339\u033b\5\u00f5{\2\u033a\u0335"+
-		"\3\2\2\2\u033a\u033b\3\2\2\2\u033b\u00f4\3\2\2\2\u033c\u033e\4\62;\2\u033d"+
-		"\u033c\3\2\2\2\u033e\u033f\3\2\2\2\u033f\u033d\3\2\2\2\u033f\u0340\3\2"+
-		"\2\2\u0340\u0347\3\2\2\2\u0341\u0343\7\60\2\2\u0342\u0344\4\62;\2\u0343"+
-		"\u0342\3\2\2\2\u0344\u0345\3\2\2\2\u0345\u0343\3\2\2\2\u0345\u0346\3\2"+
-		"\2\2\u0346\u0348\3\2\2\2\u0347\u0341\3\2\2\2\u0347\u0348\3\2\2\2\u0348"+
-		"\u00f6\3\2\2\2\u0349\u034a\7^\2\2\u034a\u034e\13\2\2\2\u034b\u034c\7^"+
-		"\2\2\u034c\u034e\5\u00e9u\2\u034d\u0349\3\2\2\2\u034d\u034b\3\2\2\2\u034e"+
-		"\u00f8\3\2\2\2\u034f\u0354\7$\2\2\u0350\u0353\5\u00f7|\2\u0351\u0353\n"+
-		"\t\2\2\u0352\u0350\3\2\2\2\u0352\u0351\3\2\2\2\u0353\u0356\3\2\2\2\u0354"+
-		"\u0352\3\2\2\2\u0354\u0355\3\2\2\2\u0355\u0357\3\2\2\2\u0356\u0354\3\2"+
-		"\2\2\u0357\u0358\7$\2\2\u0358\u0359\b}\4\2\u0359\u00fa\3\2\2\2\u035a\u035b"+
-		"\7}\2\2\u035b\u035c\7}\2\2\u035c\u035e\3\2\2\2\u035d\u035f\13\2\2\2\u035e"+
-		"\u035d\3\2\2\2\u035f\u0360\3\2\2\2\u0360\u0361\3\2\2\2\u0360\u035e\3\2"+
-		"\2\2\u0361\u0362\3\2\2\2\u0362\u0363\7\177\2\2\u0363\u0364\7\177\2\2\u0364"+
-		"\u0365\3\2\2\2\u0365\u0366\b~\5\2\u0366\u00fc\3\2\2\2\u0367\u036a\7)\2"+
-		"\2\u0368\u036b\5\u00f7|\2\u0369\u036b\n\t\2\2\u036a\u0368\3\2\2\2\u036a"+
-		"\u0369\3\2\2\2\u036b\u036c\3\2\2\2\u036c\u036d\7)\2\2\u036d\u036e\b\177"+
-		"\6\2\u036e\u00fe\3\2\2\2\u036f\u0370\7B\2\2\u0370\u0371\7|\2\2\u0371\u0372"+
-		"\7r\2\2\u0372\u0100\3\2\2\2\26\2\u02ff\u030a\u0316\u031c\u0324\u0326\u032a"+
-		"\u032c\u0332\u0337\u033a\u033f\u0345\u0347\u034d\u0352\u0354\u0360\u036a"+
-		"\7\2\3\2\b\2\2\3}\2\3~\3\3\177\4";
+		"\3\u608b\ua72a\u8133\ub9ed\u417c\u3be7\u7786\u5964\2}\u0362\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\22\3\23\3\23\3\23\3\23\3\23\3\23\3\24\3\24\3"+
+		"\24\3\24\3\24\3\25\3\25\3\25\3\25\3\25\3\25\3\26\3\26\3\26\3\26\3\26\3"+
+		"\27\3\27\3\27\3\27\3\27\3\27\3\30\3\30\3\30\3\30\3\31\3\31\3\31\3\31\3"+
+		"\31\3\31\3\32\3\32\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 \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\60\3\61\3\61\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\66\3\67\3\67\38\38\39"+
+		"\39\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\3B\3B\3B\3C\3C\3D\3D\3D\3D\3D\3D\3D\3E\3E\3E\3E\3E\3E"+
+		"\3F\3F\3F\3F\3F\3F\3F\3F\3F\3G\3G\3H\3H\3I\3I\3J\3J\3K\3K\3K\3L\3L\3L"+
+		"\3M\3M\3M\3N\3N\3N\3O\3O\3O\3P\3P\3P\3Q\3Q\3Q\3R\3R\3R\3S\3S\3S\3S\3S"+
+		"\3T\3T\3T\3T\3T\3T\3U\3U\3U\3U\3U\3V\3V\3V\3V\3W\3W\3W\3X\3X\3Y\3Y\3Z"+
+		"\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`\3`\3`\3`\3`\3a\3a\3a"+
+		"\3a\3a\3a\3b\3b\3b\3b\3b\3c\3c\3c\3c\3c\3c\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\3h"+
+		"\3i\3i\3i\3i\3i\3i\3j\3j\3j\3j\3j\3j\3k\3k\3k\3k\3l\3l\3l\3m\3m\3m\3m"+
+		"\3m\3m\3n\3n\3n\3n\3n\3n\3n\3o\3o\3o\3o\3o\3o\3p\3p\7p\u02ed\np\fp\16"+
+		"p\u02f0\13p\3p\3p\3p\3p\3q\3q\7q\u02f8\nq\fq\16q\u02fb\13q\3q\3q\3r\3"+
+		"r\3r\3r\3s\6s\u0304\ns\rs\16s\u0305\3t\3t\7t\u030a\nt\ft\16t\u030d\13"+
+		"t\3u\3u\3u\6u\u0312\nu\ru\16u\u0313\5u\u0316\nu\3v\3v\6v\u031a\nv\rv\16"+
+		"v\u031b\3w\3w\6w\u0320\nw\rw\16w\u0321\3x\3x\3x\5x\u0327\nx\3x\5x\u032a"+
+		"\nx\3y\6y\u032d\ny\ry\16y\u032e\3y\3y\6y\u0333\ny\ry\16y\u0334\5y\u0337"+
+		"\ny\3z\3z\3z\3z\5z\u033d\nz\3{\3{\3{\7{\u0342\n{\f{\16{\u0345\13{\3{\3"+
+		"{\3{\3|\3|\3|\3|\6|\u034e\n|\r|\16|\u034f\3|\3|\3|\3|\3|\3}\3}\3}\5}\u035a"+
+		"\n}\3}\3}\3}\3~\3~\3~\3~\3\u034f\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\63e\64g\65i\66k\67m8o9q:s;u<w=y>{?}@\177A\u0081B\u0083"+
+		"C\u0085D\u0087E\u0089F\u008bG\u008dH\u008fI\u0091J\u0093K\u0095L\u0097"+
+		"M\u0099N\u009bO\u009dP\u009fQ\u00a1R\u00a3S\u00a5T\u00a7U\u00a9V\u00ab"+
+		"W\u00adX\u00afY\u00b1Z\u00b3[\u00b5\\\u00b7]\u00b9^\u00bb_\u00bd`\u00bf"+
+		"a\u00c1b\u00c3c\u00c5d\u00c7e\u00c9f\u00cbg\u00cdh\u00cfi\u00d1j\u00d3"+
+		"k\u00d5l\u00d7m\u00d9n\u00dbo\u00ddp\u00dfq\u00e1r\u00e3s\u00e5t\u00e7"+
+		"u\u00e9v\u00ebw\u00edx\u00efy\u00f1\2\u00f3\2\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\u0371\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\u00ef\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%\u017b\3\2\2\2\'\u0181\3\2\2\2)\u0186\3"+
+		"\2\2\2+\u018c\3\2\2\2-\u0191\3\2\2\2/\u0197\3\2\2\2\61\u019b\3\2\2\2\63"+
+		"\u01a1\3\2\2\2\65\u01a3\3\2\2\2\67\u01a5\3\2\2\29\u01a8\3\2\2\2;\u01ab"+
+		"\3\2\2\2=\u01ae\3\2\2\2?\u01b1\3\2\2\2A\u01b5\3\2\2\2C\u01b8\3\2\2\2E"+
+		"\u01bb\3\2\2\2G\u01be\3\2\2\2I\u01c1\3\2\2\2K\u01c5\3\2\2\2M\u01c9\3\2"+
+		"\2\2O\u01cc\3\2\2\2Q\u01cf\3\2\2\2S\u01d1\3\2\2\2U\u01d3\3\2\2\2W\u01d6"+
+		"\3\2\2\2Y\u01d8\3\2\2\2[\u01da\3\2\2\2]\u01dc\3\2\2\2_\u01df\3\2\2\2a"+
+		"\u01e2\3\2\2\2c\u01e4\3\2\2\2e\u01e6\3\2\2\2g\u01e9\3\2\2\2i\u01ec\3\2"+
+		"\2\2k\u01ef\3\2\2\2m\u01f2\3\2\2\2o\u01f4\3\2\2\2q\u01f6\3\2\2\2s\u01f8"+
+		"\3\2\2\2u\u01fb\3\2\2\2w\u0200\3\2\2\2y\u0204\3\2\2\2{\u0207\3\2\2\2}"+
+		"\u020b\3\2\2\2\177\u020f\3\2\2\2\u0081\u0211\3\2\2\2\u0083\u0213\3\2\2"+
+		"\2\u0085\u0216\3\2\2\2\u0087\u0218\3\2\2\2\u0089\u021f\3\2\2\2\u008b\u0225"+
+		"\3\2\2\2\u008d\u022e\3\2\2\2\u008f\u0230\3\2\2\2\u0091\u0232\3\2\2\2\u0093"+
+		"\u0234\3\2\2\2\u0095\u0236\3\2\2\2\u0097\u0239\3\2\2\2\u0099\u023c\3\2"+
+		"\2\2\u009b\u023f\3\2\2\2\u009d\u0242\3\2\2\2\u009f\u0245\3\2\2\2\u00a1"+
+		"\u0248\3\2\2\2\u00a3\u024b\3\2\2\2\u00a5\u024e\3\2\2\2\u00a7\u0253\3\2"+
+		"\2\2\u00a9\u0259\3\2\2\2\u00ab\u025e\3\2\2\2\u00ad\u0262\3\2\2\2\u00af"+
+		"\u0265\3\2\2\2\u00b1\u0267\3\2\2\2\u00b3\u0269\3\2\2\2\u00b5\u0270\3\2"+
+		"\2\2\u00b7\u0279\3\2\2\2\u00b9\u027f\3\2\2\2\u00bb\u0282\3\2\2\2\u00bd"+
+		"\u0287\3\2\2\2\u00bf\u028d\3\2\2\2\u00c1\u0293\3\2\2\2\u00c3\u0299\3\2"+
+		"\2\2\u00c5\u029e\3\2\2\2\u00c7\u02a4\3\2\2\2\u00c9\u02aa\3\2\2\2\u00cb"+
+		"\u02b0\3\2\2\2\u00cd\u02b7\3\2\2\2\u00cf\u02bd\3\2\2\2\u00d1\u02c4\3\2"+
+		"\2\2\u00d3\u02ca\3\2\2\2\u00d5\u02d0\3\2\2\2\u00d7\u02d4\3\2\2\2\u00d9"+
+		"\u02d7\3\2\2\2\u00db\u02dd\3\2\2\2\u00dd\u02e4\3\2\2\2\u00df\u02ea\3\2"+
+		"\2\2\u00e1\u02f5\3\2\2\2\u00e3\u02fe\3\2\2\2\u00e5\u0303\3\2\2\2\u00e7"+
+		"\u0307\3\2\2\2\u00e9\u0315\3\2\2\2\u00eb\u0317\3\2\2\2\u00ed\u031d\3\2"+
+		"\2\2\u00ef\u0323\3\2\2\2\u00f1\u032c\3\2\2\2\u00f3\u033c\3\2\2\2\u00f5"+
+		"\u033e\3\2\2\2\u00f7\u0349\3\2\2\2\u00f9\u0356\3\2\2\2\u00fb\u035e\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\7"+
+		"n\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\7d\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\7o\2\2\u0175"+
+		"\u0176\7g\2\2\u0176\u0177\7o\2\2\u0177\u0178\7q\2\2\u0178\u0179\7t\2\2"+
+		"\u0179\u017a\7{\2\2\u017a$\3\2\2\2\u017b\u017c\7w\2\2\u017c\u017d\7d\2"+
+		"\2\u017d\u017e\7{\2\2\u017e\u017f\7v\2\2\u017f\u0180\7g\2\2\u0180&\3\2"+
+		"\2\2\u0181\u0182\7d\2\2\u0182\u0183\7{\2\2\u0183\u0184\7v\2\2\u0184\u0185"+
+		"\7g\2\2\u0185(\3\2\2\2\u0186\u0187\7w\2\2\u0187\u0188\7y\2\2\u0188\u0189"+
+		"\7q\2\2\u0189\u018a\7t\2\2\u018a\u018b\7f\2\2\u018b*\3\2\2\2\u018c\u018d"+
+		"\7y\2\2\u018d\u018e\7q\2\2\u018e\u018f\7t\2\2\u018f\u0190\7f\2\2\u0190"+
+		",\3\2\2\2\u0191\u0192\7h\2\2\u0192\u0193\7n\2\2\u0193\u0194\7q\2\2\u0194"+
+		"\u0195\7c\2\2\u0195\u0196\7v\2\2\u0196.\3\2\2\2\u0197\u0198\7u\2\2\u0198"+
+		"\u0199\7v\2\2\u0199\u019a\7t\2\2\u019a\60\3\2\2\2\u019b\u019c\7u\2\2\u019c"+
+		"\u019d\7v\2\2\u019d\u019e\7t\2\2\u019e\u019f\7a\2\2\u019f\u01a0\7u\2\2"+
+		"\u01a0\62\3\2\2\2\u01a1\u01a2\7]\2\2\u01a2\64\3\2\2\2\u01a3\u01a4\7_\2"+
+		"\2\u01a4\66\3\2\2\2\u01a5\u01a6\7-\2\2\u01a6\u01a7\7?\2\2\u01a78\3\2\2"+
+		"\2\u01a8\u01a9\7/\2\2\u01a9\u01aa\7?\2\2\u01aa:\3\2\2\2\u01ab\u01ac\7"+
+		"\61\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\u01b3\u01b4"+
+		"\7?\2\2\u01b4@\3\2\2\2\u01b5\u01b6\7(\2\2\u01b6\u01b7\7?\2\2\u01b7B\3"+
+		"\2\2\2\u01b8\u01b9\7~\2\2\u01b9\u01ba\7?\2\2\u01baD\3\2\2\2\u01bb\u01bc"+
+		"\7`\2\2\u01bc\u01bd\7?\2\2\u01bdF\3\2\2\2\u01be\u01bf\7\'\2\2\u01bf\u01c0"+
+		"\7?\2\2\u01c0H\3\2\2\2\u01c1\u01c2\7>\2\2\u01c2\u01c3\7>\2\2\u01c3\u01c4"+
+		"\7?\2\2\u01c4J\3\2\2\2\u01c5\u01c6\7@\2\2\u01c6\u01c7\7@\2\2\u01c7\u01c8"+
+		"\7?\2\2\u01c8L\3\2\2\2\u01c9\u01ca\7-\2\2\u01ca\u01cb\7-\2\2\u01cbN\3"+
+		"\2\2\2\u01cc\u01cd\7/\2\2\u01cd\u01ce\7/\2\2\u01ceP\3\2\2\2\u01cf\u01d0"+
+		"\7-\2\2\u01d0R\3\2\2\2\u01d1\u01d2\7/\2\2\u01d2T\3\2\2\2\u01d3\u01d4\7"+
+		",\2\2\u01d4\u01d5\7,\2\2\u01d5V\3\2\2\2\u01d6\u01d7\7,\2\2\u01d7X\3\2"+
+		"\2\2\u01d8\u01d9\7\61\2\2\u01d9Z\3\2\2\2\u01da\u01db\7\'\2\2\u01db\\\3"+
+		"\2\2\2\u01dc\u01dd\7>\2\2\u01dd\u01de\7>\2\2\u01de^\3\2\2\2\u01df\u01e0"+
+		"\7@\2\2\u01e0\u01e1\7@\2\2\u01e1`\3\2\2\2\u01e2\u01e3\7>\2\2\u01e3b\3"+
+		"\2\2\2\u01e4\u01e5\7@\2\2\u01e5d\3\2\2\2\u01e6\u01e7\7>\2\2\u01e7\u01e8"+
+		"\7?\2\2\u01e8f\3\2\2\2\u01e9\u01ea\7@\2\2\u01ea\u01eb\7?\2\2\u01ebh\3"+
+		"\2\2\2\u01ec\u01ed\7?\2\2\u01ed\u01ee\7?\2\2\u01eej\3\2\2\2\u01ef\u01f0"+
+		"\7#\2\2\u01f0\u01f1\7?\2\2\u01f1l\3\2\2\2\u01f2\u01f3\7(\2\2\u01f3n\3"+
+		"\2\2\2\u01f4\u01f5\7`\2\2\u01f5p\3\2\2\2\u01f6\u01f7\7~\2\2\u01f7r\3\2"+
+		"\2\2\u01f8\u01f9\7v\2\2\u01f9\u01fa\7q\2\2\u01fat\3\2\2\2\u01fb\u01fc"+
+		"\7u\2\2\u01fc\u01fd\7v\2\2\u01fd\u01fe\7g\2\2\u01fe\u01ff\7r\2\2\u01ff"+
+		"v\3\2\2\2\u0200\u0201\7c\2\2\u0201\u0202\7p\2\2\u0202\u0203\7f\2\2\u0203"+
+		"x\3\2\2\2\u0204\u0205\7q\2\2\u0205\u0206\7t\2\2\u0206z\3\2\2\2\u0207\u0208"+
+		"\7z\2\2\u0208\u0209\7q\2\2\u0209\u020a\7t\2\2\u020a|\3\2\2\2\u020b\u020c"+
+		"\7p\2\2\u020c\u020d\7q\2\2\u020d\u020e\7v\2\2\u020e~\3\2\2\2\u020f\u0210"+
+		"\7*\2\2\u0210\u0080\3\2\2\2\u0211\u0212\7+\2\2\u0212\u0082\3\2\2\2\u0213"+
+		"\u0214\7c\2\2\u0214\u0215\7u\2\2\u0215\u0084\3\2\2\2\u0216\u0217\7B\2"+
+		"\2\u0217\u0086\3\2\2\2\u0218\u0219\7t\2\2\u0219\u021a\7g\2\2\u021a\u021b"+
+		"\7v\2\2\u021b\u021c\7w\2\2\u021c\u021d\7t\2\2\u021d\u021e\7p\2\2\u021e"+
+		"\u0088\3\2\2\2\u021f\u0220\7d\2\2\u0220\u0221\7t\2\2\u0221\u0222\7g\2"+
+		"\2\u0222\u0223\7c\2\2\u0223\u0224\7m\2\2\u0224\u008a\3\2\2\2\u0225\u0226"+
+		"\7e\2\2\u0226\u0227\7q\2\2\u0227\u0228\7p\2\2\u0228\u0229\7v\2\2\u0229"+
+		"\u022a\7k\2\2\u022a\u022b\7p\2\2\u022b\u022c\7w\2\2\u022c\u022d\7g\2\2"+
+		"\u022d\u008c\3\2\2\2\u022e\u022f\7\60\2\2\u022f\u008e\3\2\2\2\u0230\u0231"+
+		"\7C\2\2\u0231\u0090\3\2\2\2\u0232\u0233\7Z\2\2\u0233\u0092\3\2\2\2\u0234"+
+		"\u0235\7[\2\2\u0235\u0094\3\2\2\2\u0236\u0237\7C\2\2\u0237\u0238\7Z\2"+
+		"\2\u0238\u0096\3\2\2\2\u0239\u023a\7C\2\2\u023a\u023b\7[\2\2\u023b\u0098"+
+		"\3\2\2\2\u023c\u023d\7Z\2\2\u023d\u023e\7[\2\2\u023e\u009a\3\2\2\2\u023f"+
+		"\u0240\7R\2\2\u0240\u0241\7e\2\2\u0241\u009c\3\2\2\2\u0242\u0243\7R\2"+
+		"\2\u0243\u0244\7|\2\2\u0244\u009e\3\2\2\2\u0245\u0246\7R\2\2\u0246\u0247"+
+		"\7p\2\2\u0247\u00a0\3\2\2\2\u0248\u0249\7R\2\2\u0249\u024a\7x\2\2\u024a"+
+		"\u00a2\3\2\2\2\u024b\u024c\7\60\2\2\u024c\u024d\7y\2\2\u024d\u00a4\3\2"+
+		"\2\2\u024e\u024f\7v\2\2\u024f\u0250\7t\2\2\u0250\u0251\7w\2\2\u0251\u0252"+
+		"\7g\2\2\u0252\u00a6\3\2\2\2\u0253\u0254\7h\2\2\u0254\u0255\7c\2\2\u0255"+
+		"\u0256\7n\2\2\u0256\u0257\7u\2\2\u0257\u0258\7g\2\2\u0258\u00a8\3\2\2"+
+		"\2\u0259\u025a\7\'\2\2\u025a\u025b\7c\2\2\u025b\u025c\7u\2\2\u025c\u025d"+
+		"\7o\2\2\u025d\u00aa\3\2\2\2\u025e\u025f\7u\2\2\u025f\u0260\7w\2\2\u0260"+
+		"\u0261\7d\2\2\u0261\u00ac\3\2\2\2\u0262\u0263\7/\2\2\u0263\u0264\7@\2"+
+		"\2\u0264\u00ae\3\2\2\2\u0265\u0266\7}\2\2\u0266\u00b0\3\2\2\2\u0267\u0268"+
+		"\7\177\2\2\u0268\u00b2\3\2\2\2\u0269\u026a\7c\2\2\u026a\u026b\7u\2\2\u026b"+
+		"\u026c\7o\2\2\u026c\u026d\7u\2\2\u026d\u026e\7w\2\2\u026e\u026f\7d\2\2"+
+		"\u026f\u00b4\3\2\2\2\u0270\u0271\7e\2\2\u0271\u0272\7n\2\2\u0272\u0273"+
+		"\7q\2\2\u0273\u0274\7d\2\2\u0274\u0275\7d\2\2\u0275\u0276\7g\2\2\u0276"+
+		"\u0277\7t\2\2\u0277\u0278\7u\2\2\u0278\u00b6\3\2\2\2\u0279\u027a\7u\2"+
+		"\2\u027a\u027b\7v\2\2\u027b\u027c\7c\2\2\u027c\u027d\7e\2\2\u027d\u027e"+
+		"\7m\2\2\u027e\u00b8\3\2\2\2\u027f\u0280\7k\2\2\u0280\u0281\7h\2\2\u0281"+
+		"\u00ba\3\2\2\2\u0282\u0283\7g\2\2\u0283\u0284\7n\2\2\u0284\u0285\7u\2"+
+		"\2\u0285\u0286\7g\2\2\u0286\u00bc\3\2\2\2\u0287\u0288\7k\2\2\u0288\u0289"+
+		"\7h\2\2\u0289\u028a\7a\2\2\u028a\u028b\7e\2\2\u028b\u028c\7u\2\2\u028c"+
+		"\u00be\3\2\2\2\u028d\u028e\7k\2\2\u028e\u028f\7h\2\2\u028f\u0290\7a\2"+
+		"\2\u0290\u0291\7e\2\2\u0291\u0292\7e\2\2\u0292\u00c0\3\2\2\2\u0293\u0294"+
+		"\7k\2\2\u0294\u0295\7h\2\2\u0295\u0296\7a\2\2\u0296\u0297\7g\2\2\u0297"+
+		"\u0298\7s\2\2\u0298\u00c2\3\2\2\2\u0299\u029a\7k\2\2\u029a\u029b\7h\2"+
+		"\2\u029b\u029c\7a\2\2\u029c\u029d\7|\2\2\u029d\u00c4\3\2\2\2\u029e\u029f"+
+		"\7k\2\2\u029f\u02a0\7h\2\2\u02a0\u02a1\7a\2\2\u02a1\u02a2\7p\2\2\u02a2"+
+		"\u02a3\7g\2\2\u02a3\u00c6\3\2\2\2\u02a4\u02a5\7k\2\2\u02a5\u02a6\7h\2"+
+		"\2\u02a6\u02a7\7a\2\2\u02a7\u02a8\7p\2\2\u02a8\u02a9\7|\2\2\u02a9\u00c8"+
+		"\3\2\2\2\u02aa\u02ab\7k\2\2\u02ab\u02ac\7h\2\2\u02ac\u02ad\7a\2\2\u02ad"+
+		"\u02ae\7r\2\2\u02ae\u02af\7n\2\2\u02af\u00ca\3\2\2\2\u02b0\u02b1\7k\2"+
+		"\2\u02b1\u02b2\7h\2\2\u02b2\u02b3\7a\2\2\u02b3\u02b4\7r\2\2\u02b4\u02b5"+
+		"\7q\2\2\u02b5\u02b6\7u\2\2\u02b6\u00cc\3\2\2\2\u02b7\u02b8\7k\2\2\u02b8"+
+		"\u02b9\7h\2\2\u02b9\u02ba\7a\2\2\u02ba\u02bb\7o\2\2\u02bb\u02bc\7k\2\2"+
+		"\u02bc\u00ce\3\2\2\2\u02bd\u02be\7k\2\2\u02be\u02bf\7h\2\2\u02bf\u02c0"+
+		"\7a\2\2\u02c0\u02c1\7p\2\2\u02c1\u02c2\7g\2\2\u02c2\u02c3\7i\2\2\u02c3"+
+		"\u00d0\3\2\2\2\u02c4\u02c5\7k\2\2\u02c5\u02c6\7h\2\2\u02c6\u02c7\7a\2"+
+		"\2\u02c7\u02c8\7x\2\2\u02c8\u02c9\7u\2\2\u02c9\u00d2\3\2\2\2\u02ca\u02cb"+
+		"\7k\2\2\u02cb\u02cc\7h\2\2\u02cc\u02cd\7a\2\2\u02cd\u02ce\7x\2\2\u02ce"+
+		"\u02cf\7e\2\2\u02cf\u00d4\3\2\2\2\u02d0\u02d1\7h\2\2\u02d1\u02d2\7q\2"+
+		"\2\u02d2\u02d3\7t\2\2\u02d3\u00d6\3\2\2\2\u02d4\u02d5\7k\2\2\u02d5\u02d6"+
+		"\7p\2\2\u02d6\u00d8\3\2\2\2\u02d7\u02d8\7y\2\2\u02d8\u02d9\7j\2\2\u02d9"+
+		"\u02da\7k\2\2\u02da\u02db\7n\2\2\u02db\u02dc\7g\2\2\u02dc\u00da\3\2\2"+
+		"\2\u02dd\u02de\7t\2\2\u02de\u02df\7g\2\2\u02df\u02e0\7r\2\2\u02e0\u02e1"+
+		"\7g\2\2\u02e1\u02e2\7c\2\2\u02e2\u02e3\7v\2\2\u02e3\u00dc\3\2\2\2\u02e4"+
+		"\u02e5\7w\2\2\u02e5\u02e6\7p\2\2\u02e6\u02e7\7v\2\2\u02e7\u02e8\7k\2\2"+
+		"\u02e8\u02e9\7n\2\2\u02e9\u00de\3\2\2\2\u02ea\u02ee\t\2\2\2\u02eb\u02ed"+
+		"\t\3\2\2\u02ec\u02eb\3\2\2\2\u02ed\u02f0\3\2\2\2\u02ee\u02ec\3\2\2\2\u02ee"+
+		"\u02ef\3\2\2\2\u02ef\u02f1\3\2\2\2\u02f0\u02ee\3\2\2\2\u02f1\u02f2\5\u00e1"+
+		"q\2\u02f2\u02f3\3\2\2\2\u02f3\u02f4\bp\2\2\u02f4\u00e0\3\2\2\2\u02f5\u02f9"+
+		"\7=\2\2\u02f6\u02f8\n\2\2\2\u02f7\u02f6\3\2\2\2\u02f8\u02fb\3\2\2\2\u02f9"+
+		"\u02f7\3\2\2\2\u02f9\u02fa\3\2\2\2\u02fa\u02fc\3\2\2\2\u02fb\u02f9\3\2"+
+		"\2\2\u02fc\u02fd\bq\2\2\u02fd\u00e2\3\2\2\2\u02fe\u02ff\t\3\2\2\u02ff"+
+		"\u0300\3\2\2\2\u0300\u0301\br\3\2\u0301\u00e4\3\2\2\2\u0302\u0304\t\2"+
+		"\2\2\u0303\u0302\3\2\2\2\u0304\u0305\3\2\2\2\u0305\u0303\3\2\2\2\u0305"+
+		"\u0306\3\2\2\2\u0306\u00e6\3\2\2\2\u0307\u030b\t\4\2\2\u0308\u030a\t\5"+
+		"\2\2\u0309\u0308\3\2\2\2\u030a\u030d\3\2\2\2\u030b\u0309\3\2\2\2\u030b"+
+		"\u030c\3\2\2\2\u030c\u00e8\3\2\2\2\u030d\u030b\3\2\2\2\u030e\u0316\4\62"+
+		";\2\u030f\u0311\4\63;\2\u0310\u0312\4\62;\2\u0311\u0310\3\2\2\2\u0312"+
+		"\u0313\3\2\2\2\u0313\u0311\3\2\2\2\u0313\u0314\3\2\2\2\u0314\u0316\3\2"+
+		"\2\2\u0315\u030e\3\2\2\2\u0315\u030f\3\2\2\2\u0316\u00ea\3\2\2\2\u0317"+
+		"\u0319\7&\2\2\u0318\u031a\t\6\2\2\u0319\u0318\3\2\2\2\u031a\u031b\3\2"+
+		"\2\2\u031b\u0319\3\2\2\2\u031b\u031c\3\2\2\2\u031c\u00ec\3\2\2\2\u031d"+
+		"\u031f\7\'\2\2\u031e\u0320\4\62\63\2\u031f\u031e\3\2\2\2\u0320\u0321\3"+
+		"\2\2\2\u0321\u031f\3\2\2\2\u0321\u0322\3\2\2\2\u0322\u00ee\3\2\2\2\u0323"+
+		"\u0329\5\u00f1y\2\u0324\u0326\t\7\2\2\u0325\u0327\t\b\2\2\u0326\u0325"+
+		"\3\2\2\2\u0326\u0327\3\2\2\2\u0327\u0328\3\2\2\2\u0328\u032a\5\u00f1y"+
+		"\2\u0329\u0324\3\2\2\2\u0329\u032a\3\2\2\2\u032a\u00f0\3\2\2\2\u032b\u032d"+
+		"\4\62;\2\u032c\u032b\3\2\2\2\u032d\u032e\3\2\2\2\u032e\u032c\3\2\2\2\u032e"+
+		"\u032f\3\2\2\2\u032f\u0336\3\2\2\2\u0330\u0332\7\60\2\2\u0331\u0333\4"+
+		"\62;\2\u0332\u0331\3\2\2\2\u0333\u0334\3\2\2\2\u0334\u0332\3\2\2\2\u0334"+
+		"\u0335\3\2\2\2\u0335\u0337\3\2\2\2\u0336\u0330\3\2\2\2\u0336\u0337\3\2"+
+		"\2\2\u0337\u00f2\3\2\2\2\u0338\u0339\7^\2\2\u0339\u033d\13\2\2\2\u033a"+
+		"\u033b\7^\2\2\u033b\u033d\5\u00e5s\2\u033c\u0338\3\2\2\2\u033c\u033a\3"+
+		"\2\2\2\u033d\u00f4\3\2\2\2\u033e\u0343\7$\2\2\u033f\u0342\5\u00f3z\2\u0340"+
+		"\u0342\n\t\2\2\u0341\u033f\3\2\2\2\u0341\u0340\3\2\2\2\u0342\u0345\3\2"+
+		"\2\2\u0343\u0341\3\2\2\2\u0343\u0344\3\2\2\2\u0344\u0346\3\2\2\2\u0345"+
+		"\u0343\3\2\2\2\u0346\u0347\7$\2\2\u0347\u0348\b{\4\2\u0348\u00f6\3\2\2"+
+		"\2\u0349\u034a\7}\2\2\u034a\u034b\7}\2\2\u034b\u034d\3\2\2\2\u034c\u034e"+
+		"\13\2\2\2\u034d\u034c\3\2\2\2\u034e\u034f\3\2\2\2\u034f\u0350\3\2\2\2"+
+		"\u034f\u034d\3\2\2\2\u0350\u0351\3\2\2\2\u0351\u0352\7\177\2\2\u0352\u0353"+
+		"\7\177\2\2\u0353\u0354\3\2\2\2\u0354\u0355\b|\5\2\u0355\u00f8\3\2\2\2"+
+		"\u0356\u0359\7)\2\2\u0357\u035a\5\u00f3z\2\u0358\u035a\n\t\2\2\u0359\u0357"+
+		"\3\2\2\2\u0359\u0358\3\2\2\2\u035a\u035b\3\2\2\2\u035b\u035c\7)\2\2\u035c"+
+		"\u035d\b}\6\2\u035d\u00fa\3\2\2\2\u035e\u035f\7B\2\2\u035f\u0360\7|\2"+
+		"\2\u0360\u0361\7r\2\2\u0361\u00fc\3\2\2\2\26\2\u02ee\u02f9\u0305\u030b"+
+		"\u0313\u0315\u0319\u031b\u0321\u0326\u0329\u032e\u0334\u0336\u033c\u0341"+
+		"\u0343\u034f\u0359\7\2\3\2\b\2\2\3{\2\3|\3\3}\4";
 	public static final ATN _ATN =
 		new ATNDeserializer().deserialize(_serializedATN.toCharArray());
 	static {

prog8.iml

@@ -0,0 +1,16 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<module external.linked.project.id="prog8" external.linked.project.path="$MODULE_DIR$" external.root.project.path="$MODULE_DIR$" external.system.id="GRADLE" external.system.module.group="" external.system.module.version="unspecified" type="JAVA_MODULE" version="4">
+  <component name="NewModuleRootManager" inherit-compiler-output="true">
+    <exclude-output />
+    <content url="file://$MODULE_DIR$">
+      <excludeFolder url="file://$MODULE_DIR$/.gradle" />
+      <excludeFolder url="file://$MODULE_DIR$/.idea" />
+      <excludeFolder url="file://$MODULE_DIR$/build" />
+      <excludeFolder url="file://$MODULE_DIR$/docs/build" />
+      <excludeFolder url="file://$MODULE_DIR$/gradle" />
+      <excludeFolder url="file://$MODULE_DIR$/out" />
+    </content>
+    <orderEntry type="inheritedJdk" />
+    <orderEntry type="sourceFolder" forTests="false" />
+  </component>
+</module>

settings.gradle

@@ -0,0 +1,2 @@
+include ':parser'
+include ':compiler'