ver

added some dbus experiments for future compilation service

.gitignore

@@ -1,8 +1,8 @@
 .idea/workspace.xml
 .idea/discord.xml
-/build/
-/dist/
-/output/
+build/
+dist/
+output/
 .*cache/
 *.directory
 *.prg
@@ -12,8 +12,8 @@
 *.vice-mon-list
 docs/build
 out/
-**/*.interp
-**/*.tokens
+parser/**/*.interp
+parser/**/*.tokens
 
 *.py[cod]
 *.egg
@@ -28,5 +28,4 @@ parsetab.py
 .attach_pid*
 
 .gradle
-build/
 /prog8compiler.jar

compiler/build.gradle

@@ -1,11 +1,11 @@
 buildscript {
     dependencies {
-        classpath "org.jetbrains.kotlin:kotlin-gradle-plugin:1.3.61"
+        classpath "org.jetbrains.kotlin:kotlin-gradle-plugin:1.3.70"
     }
 }
 
 plugins {
-    // id "org.jetbrains.kotlin.jvm" version "1.3.61"
+    // id "org.jetbrains.kotlin.jvm" version "1.3.70"
     id 'application'
     id 'org.jetbrains.dokka' version "0.9.18"
     id 'com.github.johnrengelman.shadow' version '5.2.0'
@@ -34,6 +34,7 @@ dependencies {
     implementation 'org.antlr:antlr4-runtime:4.8'
     implementation 'org.jetbrains.kotlinx:kotlinx-cli-jvm:0.1.0-dev-5'
     // implementation 'net.razorvine:ksim65:1.6'
+    // implementation "com.github.hypfvieh:dbus-java:3.2.0"
     implementation project(':parser')
 
     testImplementation "org.jetbrains.kotlin:kotlin-test-junit5"
@@ -100,7 +101,7 @@ test {
 
     // Show test results.
     testLogging {
-        events "passed", "skipped", "failed"
+        events "skipped", "failed"
     }
 }
 

compiler/res/prog8lib/c64floats.asm

@@ -0,0 +1,741 @@
+; --- low level floating point assembly routines for the C64
+
+ub2float	.proc
+		; -- convert ubyte in SCRATCH_ZPB1 to float at address A/Y
+		;    clobbers A, Y
+		stx  c64.SCRATCH_ZPREGX
+		sta  c64.SCRATCH_ZPWORD2
+		sty  c64.SCRATCH_ZPWORD2+1
+		ldy  c64.SCRATCH_ZPB1
+		jsr  FREADUY
+_fac_to_mem	ldx  c64.SCRATCH_ZPWORD2
+		ldy  c64.SCRATCH_ZPWORD2+1
+		jsr  MOVMF
+		ldx  c64.SCRATCH_ZPREGX
+		rts
+		.pend
+
+b2float		.proc
+		; -- convert byte in SCRATCH_ZPB1 to float at address A/Y
+		;    clobbers A, Y
+		stx  c64.SCRATCH_ZPREGX
+		sta  c64.SCRATCH_ZPWORD2
+		sty  c64.SCRATCH_ZPWORD2+1
+		lda  c64.SCRATCH_ZPB1
+		jsr  FREADSA
+		jmp  ub2float._fac_to_mem
+		.pend
+
+uw2float	.proc
+		; -- convert uword in SCRATCH_ZPWORD1 to float at address A/Y
+		stx  c64.SCRATCH_ZPREGX
+		sta  c64.SCRATCH_ZPWORD2
+		sty  c64.SCRATCH_ZPWORD2+1
+		lda  c64.SCRATCH_ZPWORD1
+		ldy  c64.SCRATCH_ZPWORD1+1
+		jsr  GIVUAYFAY
+		jmp  ub2float._fac_to_mem
+		.pend
+
+w2float		.proc
+		; -- convert word in SCRATCH_ZPWORD1 to float at address A/Y
+		stx  c64.SCRATCH_ZPREGX
+		sta  c64.SCRATCH_ZPWORD2
+		sty  c64.SCRATCH_ZPWORD2+1
+		ldy  c64.SCRATCH_ZPWORD1
+		lda  c64.SCRATCH_ZPWORD1+1
+		jsr  GIVAYF
+		jmp  ub2float._fac_to_mem
+		.pend
+
+stack_b2float	.proc
+		; -- b2float operating on the stack
+		inx
+		lda  c64.ESTACK_LO,x
+		stx  c64.SCRATCH_ZPREGX
+		jsr  FREADSA
+		jmp  push_fac1_as_result
+		.pend
+
+stack_w2float	.proc
+		; -- w2float operating on the stack
+		inx
+		ldy  c64.ESTACK_LO,x
+		lda  c64.ESTACK_HI,x
+		stx  c64.SCRATCH_ZPREGX
+		jsr  GIVAYF
+		jmp  push_fac1_as_result
+		.pend
+
+stack_ub2float	.proc
+		; -- ub2float operating on the stack
+		inx
+		lda  c64.ESTACK_LO,x
+		stx  c64.SCRATCH_ZPREGX
+		tay
+		jsr  FREADUY
+		jmp  push_fac1_as_result
+		.pend
+
+stack_uw2float	.proc
+		; -- uw2float operating on the stack
+		inx
+		lda  c64.ESTACK_LO,x
+		ldy  c64.ESTACK_HI,x
+		stx  c64.SCRATCH_ZPREGX
+		jsr  GIVUAYFAY
+		jmp  push_fac1_as_result
+		.pend
+
+stack_float2w	.proc               ; also used for float2b
+		jsr  pop_float_fac1
+		stx  c64.SCRATCH_ZPREGX
+		jsr  AYINT
+		ldx  c64.SCRATCH_ZPREGX
+		lda  $64
+		sta  c64.ESTACK_HI,x
+		lda  $65
+		sta  c64.ESTACK_LO,x
+		dex
+		rts
+		.pend
+
+stack_float2uw	.proc               ; also used for float2ub
+		jsr  pop_float_fac1
+		stx  c64.SCRATCH_ZPREGX
+		jsr  GETADR
+		ldx  c64.SCRATCH_ZPREGX
+		sta  c64.ESTACK_HI,x
+		tya
+		sta  c64.ESTACK_LO,x
+		dex
+		rts
+		.pend
+
+push_float	.proc
+		; ---- push mflpt5 in A/Y onto stack
+		; (taking 3 stack positions = 6 bytes of which 1 is padding)
+		sta  c64.SCRATCH_ZPWORD1
+		sty  c64.SCRATCH_ZPWORD1+1
+		ldy  #0
+		lda  (c64.SCRATCH_ZPWORD1),y
+		sta  c64.ESTACK_LO,x
+		iny
+		lda  (c64.SCRATCH_ZPWORD1),y
+		sta  c64.ESTACK_HI,x
+		dex
+		iny
+		lda  (c64.SCRATCH_ZPWORD1),y
+		sta  c64.ESTACK_LO,x
+		iny
+		lda  (c64.SCRATCH_ZPWORD1),y
+		sta  c64.ESTACK_HI,x
+		dex
+		iny
+		lda  (c64.SCRATCH_ZPWORD1),y
+		sta  c64.ESTACK_LO,x
+		dex
+		rts
+		.pend
+
+func_rndf	.proc
+		; -- put a random floating point value on the stack
+		stx  c64.SCRATCH_ZPREG
+		lda  #1
+		jsr  FREADSA
+		jsr  RND		; rng into fac1
+		ldx  #<_rndf_rnum5
+		ldy  #>_rndf_rnum5
+		jsr  MOVMF	; fac1 to mem X/Y
+		ldx  c64.SCRATCH_ZPREG
+		lda  #<_rndf_rnum5
+		ldy  #>_rndf_rnum5
+		jmp  push_float
+_rndf_rnum5	.byte  0,0,0,0,0
+		.pend
+
+push_float_from_indexed_var	.proc
+		; -- push the float from the array at A/Y with index on stack, onto the stack.
+		sta  c64.SCRATCH_ZPWORD1
+		sty  c64.SCRATCH_ZPWORD1+1
+		jsr  prog8_lib.pop_index_times_5
+		jsr  prog8_lib.add_a_to_zpword
+		lda  c64.SCRATCH_ZPWORD1
+		ldy  c64.SCRATCH_ZPWORD1+1
+		jmp  push_float
+		.pend
+
+pop_float	.proc
+		; ---- pops mflpt5 from stack to memory A/Y
+		; (frees 3 stack positions = 6 bytes of which 1 is padding)
+		sta  c64.SCRATCH_ZPWORD1
+		sty  c64.SCRATCH_ZPWORD1+1
+		ldy  #4
+		inx
+		lda  c64.ESTACK_LO,x
+		sta  (c64.SCRATCH_ZPWORD1),y
+		dey
+		inx
+		lda  c64.ESTACK_HI,x
+		sta  (c64.SCRATCH_ZPWORD1),y
+		dey
+		lda  c64.ESTACK_LO,x
+		sta  (c64.SCRATCH_ZPWORD1),y
+		dey
+		inx
+		lda  c64.ESTACK_HI,x
+		sta  (c64.SCRATCH_ZPWORD1),y
+		dey
+		lda  c64.ESTACK_LO,x
+		sta  (c64.SCRATCH_ZPWORD1),y
+		rts
+		.pend
+
+pop_float_fac1	.proc
+		; -- pops float from stack into FAC1
+		lda  #<fmath_float1
+		ldy  #>fmath_float1
+		jsr  pop_float
+		lda  #<fmath_float1
+		ldy  #>fmath_float1
+		jmp  MOVFM
+		.pend
+
+pop_float_to_indexed_var	.proc
+		; -- pop the float on the stack, to the memory in the array at A/Y indexed by the byte on stack
+		sta  c64.SCRATCH_ZPWORD1
+		sty  c64.SCRATCH_ZPWORD1+1
+		jsr  prog8_lib.pop_index_times_5
+		jsr  prog8_lib.add_a_to_zpword
+		lda  c64.SCRATCH_ZPWORD1
+		ldy  c64.SCRATCH_ZPWORD1+1
+		jmp  pop_float
+		.pend
+
+copy_float	.proc
+		; -- copies the 5 bytes of the mflt value pointed to by SCRATCH_ZPWORD1,
+		;    into the 5 bytes pointed to by A/Y.  Clobbers A,Y.
+		sta  c64.SCRATCH_ZPWORD2
+		sty  c64.SCRATCH_ZPWORD2+1
+		ldy  #0
+		lda  (c64.SCRATCH_ZPWORD1),y
+		sta  (c64.SCRATCH_ZPWORD2),y
+		iny
+		lda  (c64.SCRATCH_ZPWORD1),y
+		sta  (c64.SCRATCH_ZPWORD2),y
+		iny
+		lda  (c64.SCRATCH_ZPWORD1),y
+		sta  (c64.SCRATCH_ZPWORD2),y
+		iny
+		lda  (c64.SCRATCH_ZPWORD1),y
+		sta  (c64.SCRATCH_ZPWORD2),y
+		iny
+		lda  (c64.SCRATCH_ZPWORD1),y
+		sta  (c64.SCRATCH_ZPWORD2),y
+		rts
+		.pend
+
+inc_var_f	.proc
+		; -- add 1 to float pointed to by A/Y
+		sta  c64.SCRATCH_ZPWORD1
+		sty  c64.SCRATCH_ZPWORD1+1
+		stx  c64.SCRATCH_ZPREGX
+		jsr  MOVFM
+		lda  #<FL_FONE
+		ldy  #>FL_FONE
+		jsr  FADD
+		ldx  c64.SCRATCH_ZPWORD1
+		ldy  c64.SCRATCH_ZPWORD1+1
+		jsr  MOVMF
+		ldx  c64.SCRATCH_ZPREGX
+		rts
+		.pend
+
+dec_var_f	.proc
+		; -- subtract 1 from float pointed to by A/Y
+		sta  c64.SCRATCH_ZPWORD1
+		sty  c64.SCRATCH_ZPWORD1+1
+		stx  c64.SCRATCH_ZPREGX
+		lda  #<FL_FONE
+		ldy  #>FL_FONE
+		jsr  MOVFM
+		lda  c64.SCRATCH_ZPWORD1
+		ldy  c64.SCRATCH_ZPWORD1+1
+		jsr  FSUB
+		ldx  c64.SCRATCH_ZPWORD1
+		ldy  c64.SCRATCH_ZPWORD1+1
+		jsr  MOVMF
+		ldx  c64.SCRATCH_ZPREGX
+		rts
+		.pend
+
+inc_indexed_var_f	.proc
+		; -- add 1 to float in array pointed to by A/Y, at index X
+		pha
+		txa
+		sta  c64.SCRATCH_ZPB1
+		asl  a
+		asl  a
+		clc
+		adc  c64.SCRATCH_ZPB1
+		sta  c64.SCRATCH_ZPB1
+		pla
+		clc
+		adc  c64.SCRATCH_ZPB1
+		bcc  +
+		iny
++		jmp  inc_var_f
+		.pend
+
+dec_indexed_var_f	.proc
+		; -- subtract 1 to float in array pointed to by A/Y, at index X
+		pha
+		txa
+		sta  c64.SCRATCH_ZPB1
+		asl  a
+		asl  a
+		clc
+		adc  c64.SCRATCH_ZPB1
+		sta  c64.SCRATCH_ZPB1
+		pla
+		clc
+		adc  c64.SCRATCH_ZPB1
+		bcc  +
+		iny
++		jmp  dec_var_f
+		.pend
+
+
+pop_2_floats_f2_in_fac1	.proc
+		; -- pop 2 floats from stack, load the second one in FAC1 as well
+		lda  #<fmath_float2
+		ldy  #>fmath_float2
+		jsr  pop_float
+		lda  #<fmath_float1
+		ldy  #>fmath_float1
+		jsr  pop_float
+		lda  #<fmath_float2
+		ldy  #>fmath_float2
+		jmp  MOVFM
+		.pend
+
+
+fmath_float1	.byte 0,0,0,0,0	; storage for a mflpt5 value
+fmath_float2	.byte 0,0,0,0,0	; storage for a mflpt5 value
+
+push_fac1_as_result	.proc
+		; -- push the float in FAC1 onto the stack, and return from calculation
+		ldx  #<fmath_float1
+		ldy  #>fmath_float1
+		jsr  MOVMF
+		lda  #<fmath_float1
+		ldy  #>fmath_float1
+		ldx  c64.SCRATCH_ZPREGX
+		jmp  push_float
+		.pend
+
+pow_f		.proc
+		; -- push f1 ** f2 on stack
+		lda  #<fmath_float2
+		ldy  #>fmath_float2
+		jsr  pop_float
+		lda  #<fmath_float1
+		ldy  #>fmath_float1
+		jsr  pop_float
+		stx  c64.SCRATCH_ZPREGX
+		lda  #<fmath_float1
+		ldy  #>fmath_float1
+		jsr  CONUPK		; fac2 = float1
+		lda  #<fmath_float2
+		ldy  #>fmath_float2
+		jsr  FPWR
+		ldx  c64.SCRATCH_ZPREGX
+		jmp  push_fac1_as_result
+		.pend
+
+div_f		.proc
+		; -- push f1/f2 on stack
+		jsr  pop_2_floats_f2_in_fac1
+		stx  c64.SCRATCH_ZPREGX
+		lda  #<fmath_float1
+		ldy  #>fmath_float1
+		jsr  FDIV
+		jmp  push_fac1_as_result
+		.pend
+
+add_f		.proc
+		; -- push f1+f2 on stack
+		jsr  pop_2_floats_f2_in_fac1
+		stx  c64.SCRATCH_ZPREGX
+		lda  #<fmath_float1
+		ldy  #>fmath_float1
+		jsr  FADD
+		jmp  push_fac1_as_result
+		.pend
+
+sub_f		.proc
+		; -- push f1-f2 on stack
+		jsr  pop_2_floats_f2_in_fac1
+		stx  c64.SCRATCH_ZPREGX
+		lda  #<fmath_float1
+		ldy  #>fmath_float1
+		jsr  FSUB
+		jmp  push_fac1_as_result
+		.pend
+
+mul_f		.proc
+		; -- push f1*f2 on stack
+		jsr  pop_2_floats_f2_in_fac1
+		stx  c64.SCRATCH_ZPREGX
+		lda  #<fmath_float1
+		ldy  #>fmath_float1
+		jsr  FMULT
+		jmp  push_fac1_as_result
+		.pend
+
+neg_f		.proc
+		; -- push -flt back on stack
+		jsr  pop_float_fac1
+		stx  c64.SCRATCH_ZPREGX
+		jsr  NEGOP
+		jmp  push_fac1_as_result
+		.pend
+
+abs_f		.proc
+		; -- push abs(float) on stack (as float)
+		jsr  pop_float_fac1
+		stx  c64.SCRATCH_ZPREGX
+		jsr  ABS
+		jmp  push_fac1_as_result
+		.pend
+
+equal_f		.proc
+		; -- are the two mflpt5 numbers on the stack identical?
+		inx
+		inx
+		inx
+		inx
+		lda  c64.ESTACK_LO-3,x
+		cmp  c64.ESTACK_LO,x
+		bne  _equals_false
+		lda  c64.ESTACK_LO-2,x
+		cmp  c64.ESTACK_LO+1,x
+		bne  _equals_false
+		lda  c64.ESTACK_LO-1,x
+		cmp  c64.ESTACK_LO+2,x
+		bne  _equals_false
+		lda  c64.ESTACK_HI-2,x
+		cmp  c64.ESTACK_HI+1,x
+		bne  _equals_false
+		lda  c64.ESTACK_HI-1,x
+		cmp  c64.ESTACK_HI+2,x
+		bne  _equals_false
+_equals_true	lda  #1
+_equals_store	inx
+		sta  c64.ESTACK_LO+1,x
+		rts
+_equals_false	lda  #0
+		beq  _equals_store
+		.pend
+
+notequal_f	.proc
+		; -- are the two mflpt5 numbers on the stack different?
+		jsr  equal_f
+		eor  #1		; invert the result
+		sta  c64.ESTACK_LO+1,x
+		rts
+		.pend
+
+less_f		.proc
+		; -- is f1 < f2?
+		jsr  compare_floats
+		cmp  #255
+		beq  compare_floats._return_true
+		bne  compare_floats._return_false
+		.pend
+
+
+lesseq_f	.proc
+		; -- is f1 <= f2?
+		jsr  compare_floats
+		cmp  #255
+		beq  compare_floats._return_true
+		cmp  #0
+		beq  compare_floats._return_true
+		bne  compare_floats._return_false
+		.pend
+
+greater_f	.proc
+		; -- is f1 > f2?
+		jsr  compare_floats
+		cmp  #1
+		beq  compare_floats._return_true
+		bne  compare_floats._return_false
+		.pend
+
+greatereq_f	.proc
+		; -- is f1 >= f2?
+		jsr  compare_floats
+		cmp  #1
+		beq  compare_floats._return_true
+		cmp  #0
+		beq  compare_floats._return_true
+		bne  compare_floats._return_false
+		.pend
+
+compare_floats	.proc
+		lda  #<fmath_float2
+		ldy  #>fmath_float2
+		jsr  pop_float
+		lda  #<fmath_float1
+		ldy  #>fmath_float1
+		jsr  pop_float
+		lda  #<fmath_float1
+		ldy  #>fmath_float1
+		jsr  MOVFM		; fac1 = flt1
+		lda  #<fmath_float2
+		ldy  #>fmath_float2
+		stx  c64.SCRATCH_ZPREG
+		jsr  FCOMP		; A = flt1 compared with flt2 (0=equal, 1=flt1>flt2, 255=flt1<flt2)
+		ldx  c64.SCRATCH_ZPREG
+		rts
+_return_false	lda  #0
+_return_result  sta  c64.ESTACK_LO,x
+		dex
+		rts
+_return_true	lda  #1
+		bne  _return_result
+		.pend
+
+func_sin	.proc
+		; -- push sin(f) back onto stack
+		jsr  pop_float_fac1
+		stx  c64.SCRATCH_ZPREGX
+		jsr  SIN
+		jmp  push_fac1_as_result
+		.pend
+
+func_cos	.proc
+		; -- push cos(f) back onto stack
+		jsr  pop_float_fac1
+		stx  c64.SCRATCH_ZPREGX
+		jsr  COS
+		jmp  push_fac1_as_result
+		.pend
+
+func_tan	.proc
+		; -- push tan(f) back onto stack
+		jsr  pop_float_fac1
+		stx  c64.SCRATCH_ZPREGX
+		jsr  TAN
+		jmp  push_fac1_as_result
+		.pend
+
+func_atan	.proc
+		; -- push atan(f) back onto stack
+		jsr  pop_float_fac1
+		stx  c64.SCRATCH_ZPREGX
+		jsr  ATN
+		jmp  push_fac1_as_result
+		.pend
+
+func_ln		.proc
+		; -- push ln(f) back onto stack
+		jsr  pop_float_fac1
+		stx  c64.SCRATCH_ZPREGX
+		jsr  LOG
+		jmp  push_fac1_as_result
+		.pend
+
+func_log2	.proc
+		; -- push log base 2, ln(f)/ln(2), back onto stack
+		jsr  pop_float_fac1
+		stx  c64.SCRATCH_ZPREGX
+		jsr  LOG
+		jsr  MOVEF
+		lda  #<c64.FL_LOG2
+		ldy  #>c64.FL_LOG2
+		jsr  MOVFM
+		jsr  FDIVT
+		jmp  push_fac1_as_result
+		.pend
+
+func_sqrt	.proc
+		jsr  pop_float_fac1
+		stx  c64.SCRATCH_ZPREGX
+		jsr  SQR
+		jmp  push_fac1_as_result
+		.pend
+
+func_rad	.proc
+		; -- convert degrees to radians (d * pi / 180)
+		jsr  pop_float_fac1
+		stx  c64.SCRATCH_ZPREGX
+		lda  #<_pi_div_180
+		ldy  #>_pi_div_180
+		jsr  FMULT
+		jmp  push_fac1_as_result
+_pi_div_180	.byte 123, 14, 250, 53, 18		; pi / 180
+		.pend
+
+func_deg	.proc
+		; -- convert radians to degrees (d * (1/ pi * 180))
+		jsr  pop_float_fac1
+		stx  c64.SCRATCH_ZPREGX
+		lda  #<_one_over_pi_div_180
+		ldy  #>_one_over_pi_div_180
+		jsr  FMULT
+		jmp  push_fac1_as_result
+_one_over_pi_div_180	.byte 134, 101, 46, 224, 211		; 1 / (pi * 180)
+		.pend
+
+func_round	.proc
+		jsr  pop_float_fac1
+		stx  c64.SCRATCH_ZPREGX
+		jsr  FADDH
+		jsr  INT
+		jmp  push_fac1_as_result
+		.pend
+
+func_floor	.proc
+		jsr  pop_float_fac1
+		stx  c64.SCRATCH_ZPREGX
+		jsr  INT
+		jmp  push_fac1_as_result
+		.pend
+
+func_ceil	.proc
+		; -- ceil: tr = int(f); if tr==f -> return  else return tr+1
+		jsr  pop_float_fac1
+		stx  c64.SCRATCH_ZPREGX
+		ldx  #<fmath_float1
+		ldy  #>fmath_float1
+		jsr  MOVMF
+		jsr  INT
+		lda  #<fmath_float1
+		ldy  #>fmath_float1
+		jsr  FCOMP
+		cmp  #0
+		beq  +
+		lda  #<FL_FONE
+		ldy  #>FL_FONE
+		jsr  FADD
++		jmp  push_fac1_as_result
+		.pend
+
+func_any_f	.proc
+		inx
+		lda  c64.ESTACK_LO,x	; array size
+		sta  c64.SCRATCH_ZPB1
+		asl  a
+		asl  a
+		clc
+		adc  c64.SCRATCH_ZPB1	; times 5 because of float
+		jmp  prog8_lib.func_any_b._entry
+		.pend
+
+func_all_f	.proc
+		inx
+		jsr  prog8_lib.peek_address
+		lda  c64.ESTACK_LO,x	; array size
+		sta  c64.SCRATCH_ZPB1
+		asl  a
+		asl  a
+		clc
+		adc  c64.SCRATCH_ZPB1	; times 5 because of float
+		tay
+		dey
+-		lda  (c64.SCRATCH_ZPWORD1),y
+		clc
+		dey
+		adc  (c64.SCRATCH_ZPWORD1),y
+		dey
+		adc  (c64.SCRATCH_ZPWORD1),y
+		dey
+		adc  (c64.SCRATCH_ZPWORD1),y
+		dey
+		adc  (c64.SCRATCH_ZPWORD1),y
+		dey
+		cmp  #0
+		beq  +
+        cpy  #255
+        bne  -
+		lda  #1
+		sta  c64.ESTACK_LO+1,x
+		rts
++		sta  c64.ESTACK_LO+1,x
+		rts
+		.pend
+
+func_max_f	.proc
+		lda  #255
+		sta  _minmax_cmp+1
+		lda  #<_largest_neg_float
+		ldy  #>_largest_neg_float
+_minmax_entry	jsr  MOVFM
+		jsr  prog8_lib.pop_array_and_lengthmin1Y
+		stx  c64.SCRATCH_ZPREGX
+-		sty  c64.SCRATCH_ZPREG
+		lda  c64.SCRATCH_ZPWORD1
+		ldy  c64.SCRATCH_ZPWORD1+1
+		jsr  FCOMP
+_minmax_cmp	cmp  #255			; modified
+		bne  +
+		lda  c64.SCRATCH_ZPWORD1
+		ldy  c64.SCRATCH_ZPWORD1+1
+		jsr  MOVFM
++		lda  c64.SCRATCH_ZPWORD1
+		clc
+		adc  #5
+		sta  c64.SCRATCH_ZPWORD1
+		bcc  +
+		inc  c64.SCRATCH_ZPWORD1+1
++		ldy  c64.SCRATCH_ZPREG
+		dey
+		cpy  #255
+		bne  -
+		jmp  push_fac1_as_result
+_largest_neg_float	.byte 255,255,255,255,255		; largest negative float -1.7014118345e+38
+		.pend
+
+func_min_f	.proc
+		lda  #1
+		sta  func_max_f._minmax_cmp+1
+		lda  #<_largest_pos_float
+		ldy  #>_largest_pos_float
+		jmp  func_max_f._minmax_entry
+_largest_pos_float	.byte  255,127,255,255,255		; largest positive float
+		rts
+		.pend
+
+func_sum_f	.proc
+		lda  #<FL_ZERO
+		ldy  #>FL_ZERO
+		jsr  MOVFM
+		jsr  prog8_lib.pop_array_and_lengthmin1Y
+		stx  c64.SCRATCH_ZPREGX
+-		sty  c64.SCRATCH_ZPREG
+		lda  c64.SCRATCH_ZPWORD1
+		ldy  c64.SCRATCH_ZPWORD1+1
+		jsr  FADD
+		ldy  c64.SCRATCH_ZPREG
+		dey
+		cpy  #255
+		beq  +
+		lda  c64.SCRATCH_ZPWORD1
+		clc
+		adc  #5
+		sta  c64.SCRATCH_ZPWORD1
+		bcc  -
+		inc  c64.SCRATCH_ZPWORD1+1
+		bne  -
++		jmp  push_fac1_as_result
+		.pend
+
+sign_f		.proc
+		jsr  pop_float_fac1
+		jsr  SIGN
+		sta  c64.ESTACK_LO,x
+		dex
+		rts
+		.pend

compiler/res/prog8lib/c64flt.p8

@@ -41,25 +41,25 @@ c64flt {
 ; note: for subtraction and division, the left operand is in fac2, the right operand in fac1.
 
 ; checked functions below:
-asmsub	MOVFM		(uword mflpt @ AY) clobbers(A,Y)	= $bba2		; load mflpt value from memory  in A/Y into fac1
-asmsub	FREADMEM	() clobbers(A,Y)			= $bba6		; load mflpt value from memory  in $22/$23 into fac1
-asmsub	CONUPK		(uword mflpt @ AY) clobbers(A,Y)	= $ba8c		; load mflpt value from memory  in A/Y into fac2
-asmsub	FAREADMEM	() clobbers(A,Y)			= $ba90		; load mflpt value from memory  in $22/$23 into fac2
-asmsub	MOVFA		() clobbers(A,X)			= $bbfc		; copy fac2 to fac1
-asmsub	MOVAF		() clobbers(A,X)			= $bc0c		; copy fac1 to fac2  (rounded)
-asmsub	MOVEF		() clobbers(A,X)			= $bc0f		; copy fac1 to fac2
-asmsub	MOVMF		(uword mflpt @ XY) clobbers(A,Y)	= $bbd4		; store fac1 to memory  X/Y as 5-byte mflpt
+romsub $bba2 = MOVFM(uword mflpt @ AY) clobbers(A,Y)        ; load mflpt value from memory  in A/Y into fac1
+romsub $bba6 = FREADMEM() clobbers(A,Y)                     ; load mflpt value from memory  in $22/$23 into fac1
+romsub $ba8c = CONUPK(uword mflpt @ AY) clobbers(A,Y)       ; load mflpt value from memory  in A/Y into fac2
+romsub $ba90 = FAREADMEM() clobbers(A,Y)                    ; load mflpt value from memory  in $22/$23 into fac2
+romsub $bbfc = MOVFA() clobbers(A,X)                        ; copy fac2 to fac1
+romsub $bc0c = MOVAF() clobbers(A,X)                        ; copy fac1 to fac2  (rounded)
+romsub $bc0f = MOVEF() clobbers(A,X)                        ; copy fac1 to fac2
+romsub $bbd4 = MOVMF(uword mflpt @ XY) clobbers(A,Y)        ; store fac1 to memory  X/Y as 5-byte mflpt
 
 ; fac1-> signed word in Y/A (might throw ILLEGAL QUANTITY)
 ; (tip: use c64flt.FTOSWRDAY to get A/Y output; lo/hi switched to normal little endian order)
-asmsub	FTOSWORDYA	() clobbers(X) -> ubyte @ Y, ubyte @ A  = $b1aa     ; note: calls AYINT.
+romsub $b1aa = FTOSWORDYA() clobbers(X) -> ubyte @ Y, ubyte @ A       ; note: calls AYINT.
 
 ; fac1 -> unsigned word in Y/A (might throw ILLEGAL QUANTITY) (result also in $14/15)
 ; (tip: use c64flt.GETADRAY to get A/Y output; lo/hi switched to normal little endian order)
-asmsub	GETADR		() clobbers(X) -> ubyte @ Y, ubyte @ A  = $b7f7
+romsub $b7f7 = GETADR() clobbers(X) -> ubyte @ Y, ubyte @ A
 
-asmsub	QINT		() clobbers(A,X,Y)			= $bc9b		; fac1 -> 4-byte signed integer in 98-101 ($62-$65), with the MSB FIRST.
-asmsub	AYINT		() clobbers(A,X,Y)			= $b1bf		; fac1-> signed word in 100-101 ($64-$65) MSB FIRST. (might throw ILLEGAL QUANTITY)
+romsub $bc9b = QINT() clobbers(A,X,Y)           ; fac1 -> 4-byte signed integer in 98-101 ($62-$65), with the MSB FIRST.
+romsub $b1bf = AYINT() clobbers(A,X,Y)          ; fac1-> signed word in 100-101 ($64-$65) MSB FIRST. (might throw ILLEGAL QUANTITY)
 
 ; GIVAYF: signed word in Y/A (note different lsb/msb order) -> float in fac1
 ; (tip: use c64flt.GIVAYFAY to use A/Y input; lo/hi switched to normal order)
@@ -67,50 +67,49 @@ asmsub	AYINT		() clobbers(A,X,Y)			= $b1bf		; fac1-> signed word in 100-101 ($64
 ; there is also c64flt.FREADS32  that reads from 98-101 ($62-$65) MSB FIRST
 ; there is also c64flt.FREADUS32  that reads from 98-101 ($62-$65) MSB FIRST
 ; there is also c64flt.FREADS24AXY  that reads signed int24 into fac1 from A/X/Y (lo/mid/hi bytes)
-asmsub	GIVAYF		(ubyte lo @ Y, ubyte hi @ A) clobbers(A,X,Y)	= $b391
+romsub $b391 = GIVAYF(ubyte lo @ Y, ubyte hi @ A) clobbers(A,X,Y)
 
-asmsub	FREADUY		(ubyte value @ Y) clobbers(A,X,Y)	= $b3a2		; 8 bit unsigned Y -> float in fac1
-asmsub	FREADSA		(byte value @ A) clobbers(A,X,Y)	= $bc3c		; 8 bit signed A -> float in fac1
-asmsub	FREADSTR	(ubyte length @ A) clobbers(A,X,Y)	= $b7b5		; str -> fac1, $22/23 must point to string, A=string length
-asmsub	FPRINTLN	() clobbers(A,X,Y)			= $aabc		; print string of fac1, on one line (= with newline) destroys fac1.  (consider FOUT + STROUT as well)
-asmsub	FOUT		() clobbers(X) -> uword @ AY		= $bddd		; fac1 -> string, address returned in AY ($0100)
+romsub $b3a2 = FREADUY(ubyte value @ Y) clobbers(A,X,Y)     ; 8 bit unsigned Y -> float in fac1
+romsub $bc3c = FREADSA(byte value @ A) clobbers(A,X,Y)      ; 8 bit signed A -> float in fac1
+romsub $b7b5 = FREADSTR(ubyte length @ A) clobbers(A,X,Y)   ; str -> fac1, $22/23 must point to string, A=string length
+romsub $aabc = FPRINTLN() clobbers(A,X,Y)                   ; print string of fac1, on one line (= with newline) destroys fac1.  (consider FOUT + STROUT as well)
+romsub $bddd = FOUT() clobbers(X) -> uword @ AY             ; fac1 -> string, address returned in AY ($0100)
 
-asmsub	FADDH		() clobbers(A,X,Y)			= $b849		; fac1 += 0.5, for rounding- call this before INT
-asmsub	MUL10		() clobbers(A,X,Y)			= $bae2		; fac1 *= 10
-asmsub	DIV10		() clobbers(A,X,Y)			= $bafe		; fac1 /= 10 , CAUTION: result is always positive!
-asmsub	FCOMP		(uword mflpt @ AY) clobbers(X,Y) -> ubyte @ A = $bc5b		; A = compare fac1 to mflpt in A/Y, 0=equal 1=fac1 is greater, 255=fac1 is less than
+romsub $b849 = FADDH() clobbers(A,X,Y)                      ; fac1 += 0.5, for rounding- call this before INT
+romsub $bae2 = MUL10() clobbers(A,X,Y)                      ; fac1 *= 10
+romsub $bafe = DIV10() clobbers(A,X,Y)                      ; fac1 /= 10 , CAUTION: result is always positive!
+romsub $bc5b = FCOMP(uword mflpt @ AY) clobbers(X,Y) -> ubyte @ A   ; A = compare fac1 to mflpt in A/Y, 0=equal 1=fac1 is greater, 255=fac1 is less than
 
-asmsub	FADDT		() clobbers(A,X,Y)			= $b86a		; fac1 += fac2
-asmsub	FADD		(uword mflpt @ AY) clobbers(A,X,Y)	= $b867		; fac1 += mflpt value from A/Y
-asmsub	FSUBT		() clobbers(A,X,Y)			= $b853		; fac1 = fac2-fac1   mind the order of the operands
-asmsub	FSUB		(uword mflpt @ AY) clobbers(A,X,Y)	= $b850		; fac1 = mflpt from A/Y - fac1
-asmsub	FMULTT 		() clobbers(A,X,Y)			= $ba2b		; fac1 *= fac2
-asmsub	FMULT		(uword mflpt @ AY) clobbers(A,X,Y)	= $ba28		; fac1 *= mflpt value from A/Y
-asmsub	FDIVT 		() clobbers(A,X,Y)			= $bb12		; fac1 = fac2/fac1  (remainder in fac2)  mind the order of the operands
-asmsub	FDIV  		(uword mflpt @ AY) clobbers(A,X,Y)	= $bb0f		; fac1 = mflpt in A/Y / fac1  (remainder in fac2)
-asmsub	FPWRT		() clobbers(A,X,Y)			= $bf7b		; fac1 = fac2 ** fac1
-asmsub	FPWR		(uword mflpt @ AY) clobbers(A,X,Y)	= $bf78		; fac1 = fac2 ** mflpt from A/Y
+romsub $b86a = FADDT() clobbers(A,X,Y)                      ; fac1 += fac2
+romsub $b867 = FADD(uword mflpt @ AY) clobbers(A,X,Y)       ; fac1 += mflpt value from A/Y
+romsub $b853 = FSUBT() clobbers(A,X,Y)                      ; fac1 = fac2-fac1   mind the order of the operands
+romsub $b850 = FSUB(uword mflpt @ AY) clobbers(A,X,Y)       ; fac1 = mflpt from A/Y - fac1
+romsub $ba2b = FMULTT() clobbers(A,X,Y)                     ; fac1 *= fac2
+romsub $ba28 = FMULT(uword mflpt @ AY) clobbers(A,X,Y)      ; fac1 *= mflpt value from A/Y
+romsub $bb12 = FDIVT() clobbers(A,X,Y)                      ; fac1 = fac2/fac1  (remainder in fac2)  mind the order of the operands
+romsub $bb0f = FDIV(uword mflpt @ AY) clobbers(A,X,Y)       ; fac1 = mflpt in A/Y / fac1  (remainder in fac2)
+romsub $bf7b = FPWRT() clobbers(A,X,Y)                      ; fac1 = fac2 ** fac1
+romsub $bf78 = FPWR(uword mflpt @ AY) clobbers(A,X,Y)       ; fac1 = fac2 ** mflpt from A/Y
 
-asmsub	NOTOP		() clobbers(A,X,Y)			= $aed4		; fac1 = NOT(fac1)
-asmsub	INT		() clobbers(A,X,Y)			= $bccc		; INT() truncates, use FADDH first to round instead of trunc
-asmsub	LOG		() clobbers(A,X,Y)			= $b9ea		; fac1 = LN(fac1)  (natural log)
-asmsub	SGN		() clobbers(A,X,Y)			= $bc39		; fac1 = SGN(fac1), result of SIGN (-1, 0 or 1)
-asmsub	SIGN		() -> ubyte @ A				= $bc2b		; SIGN(fac1) to A, $ff, $0, $1 for negative, zero, positive
-asmsub	ABS		()					= $bc58		; fac1 = ABS(fac1)
-asmsub	SQR		() clobbers(A,X,Y)			= $bf71		; fac1 = SQRT(fac1)
-asmsub	SQRA		() clobbers(A,X,Y)			= $bf74		; fac1 = SQRT(fac2)
-asmsub	EXP		() clobbers(A,X,Y)			= $bfed		; fac1 = EXP(fac1)  (e ** fac1)
-asmsub	NEGOP		() clobbers(A)				= $bfb4		; switch the sign of fac1
-asmsub	RND		() clobbers(A,X,Y)			= $e097		; fac1 = RND(fac1) float random number generator
-asmsub	COS		() clobbers(A,X,Y)			= $e264		; fac1 = COS(fac1)
-asmsub	SIN		() clobbers(A,X,Y)			= $e26b		; fac1 = SIN(fac1)
-asmsub	TAN		() clobbers(A,X,Y)			= $e2b4		; fac1 = TAN(fac1)
-asmsub	ATN		() clobbers(A,X,Y)			= $e30e		; fac1 = ATN(fac1)
+romsub $aed4 = NOTOP() clobbers(A,X,Y)                      ; fac1 = NOT(fac1)
+romsub $bccc = INT() clobbers(A,X,Y)                        ; INT() truncates, use FADDH first to round instead of trunc
+romsub $b9ea = LOG() clobbers(A,X,Y)                        ; fac1 = LN(fac1)  (natural log)
+romsub $bc39 = SGN() clobbers(A,X,Y)                        ; fac1 = SGN(fac1), result of SIGN (-1, 0 or 1)
+romsub $bc2b = SIGN() -> ubyte @ A                          ; SIGN(fac1) to A, $ff, $0, $1 for negative, zero, positive
+romsub $bc58 = ABS()                                        ; fac1 = ABS(fac1)
+romsub $bf71 = SQR() clobbers(A,X,Y)                        ; fac1 = SQRT(fac1)
+romsub $bf74 = SQRA() clobbers(A,X,Y)                       ; fac1 = SQRT(fac2)
+romsub $bfed = EXP() clobbers(A,X,Y)                        ; fac1 = EXP(fac1)  (e ** fac1)
+romsub $bfb4 = NEGOP() clobbers(A)                          ; switch the sign of fac1
+romsub $e097 = RND() clobbers(A,X,Y)                        ; fac1 = RND(fac1) float random number generator
+romsub $e264 = COS() clobbers(A,X,Y)                        ; fac1 = COS(fac1)
+romsub $e26b = SIN() clobbers(A,X,Y)                        ; fac1 = SIN(fac1)
+romsub $e2b4 = TAN() clobbers(A,X,Y)                        ; fac1 = TAN(fac1)
+romsub $e30e = ATN() clobbers(A,X,Y)                        ; fac1 = ATN(fac1)
 
 
 
-
-asmsub  FREADS32  () clobbers(A,X,Y)  {
+asmsub  FREADS32() clobbers(A,X,Y)  {
 	; ---- fac1 = signed int32 from $62-$65 big endian (MSB FIRST)
 	%asm {{
 		lda  $62
@@ -220,750 +219,6 @@ sub  print_fln  (float value) {
 
 }
 
-
-; --- low level floating point assembly routines
-%asm {{
-ub2float	.proc
-		; -- convert ubyte in SCRATCH_ZPB1 to float at address A/Y
-		;    clobbers A, Y
-		stx  c64.SCRATCH_ZPREGX
-		sta  c64.SCRATCH_ZPWORD2
-		sty  c64.SCRATCH_ZPWORD2+1
-		ldy  c64.SCRATCH_ZPB1
-		jsr  FREADUY
-_fac_to_mem	ldx  c64.SCRATCH_ZPWORD2
-		ldy  c64.SCRATCH_ZPWORD2+1
-		jsr  MOVMF
-		ldx  c64.SCRATCH_ZPREGX
-		rts
-		.pend
-
-b2float		.proc
-		; -- convert byte in SCRATCH_ZPB1 to float at address A/Y
-		;    clobbers A, Y
-		stx  c64.SCRATCH_ZPREGX
-		sta  c64.SCRATCH_ZPWORD2
-		sty  c64.SCRATCH_ZPWORD2+1
-		lda  c64.SCRATCH_ZPB1
-		jsr  FREADSA
-		jmp  ub2float._fac_to_mem
-		.pend
-
-uw2float	.proc
-		; -- convert uword in SCRATCH_ZPWORD1 to float at address A/Y
-		stx  c64.SCRATCH_ZPREGX
-		sta  c64.SCRATCH_ZPWORD2
-		sty  c64.SCRATCH_ZPWORD2+1
-		lda  c64.SCRATCH_ZPWORD1
-		ldy  c64.SCRATCH_ZPWORD1+1
-		jsr  GIVUAYFAY
-		jmp  ub2float._fac_to_mem
-		.pend
-
-w2float		.proc
-		; -- convert word in SCRATCH_ZPWORD1 to float at address A/Y
-		stx  c64.SCRATCH_ZPREGX
-		sta  c64.SCRATCH_ZPWORD2
-		sty  c64.SCRATCH_ZPWORD2+1
-		ldy  c64.SCRATCH_ZPWORD1
-		lda  c64.SCRATCH_ZPWORD1+1
-		jsr  GIVAYF
-		jmp  ub2float._fac_to_mem
-		.pend
-
-stack_b2float	.proc
-		; -- b2float operating on the stack
-		inx
-		lda  c64.ESTACK_LO,x
-		stx  c64.SCRATCH_ZPREGX
-		jsr  FREADSA
-		jmp  push_fac1_as_result
-		.pend
-
-stack_w2float	.proc
-		; -- w2float operating on the stack
-		inx
-		ldy  c64.ESTACK_LO,x
-		lda  c64.ESTACK_HI,x
-		stx  c64.SCRATCH_ZPREGX
-		jsr  GIVAYF
-		jmp  push_fac1_as_result
-		.pend
-
-stack_ub2float	.proc
-		; -- ub2float operating on the stack
-		inx
-		lda  c64.ESTACK_LO,x
-		stx  c64.SCRATCH_ZPREGX
-		tay
-		jsr  FREADUY
-		jmp  push_fac1_as_result
-		.pend
-
-stack_uw2float	.proc
-		; -- uw2float operating on the stack
-		inx
-		lda  c64.ESTACK_LO,x
-		ldy  c64.ESTACK_HI,x
-		stx  c64.SCRATCH_ZPREGX
-		jsr  GIVUAYFAY
-		jmp  push_fac1_as_result
-		.pend
-
-stack_float2w	.proc               ; also used for float2b
-		jsr  pop_float_fac1
-		stx  c64.SCRATCH_ZPREGX
-		jsr  AYINT
-		ldx  c64.SCRATCH_ZPREGX
-		lda  $64
-		sta  c64.ESTACK_HI,x
-		lda  $65
-		sta  c64.ESTACK_LO,x
-		dex
-		rts
-		.pend
-
-stack_float2uw	.proc               ; also used for float2ub
-		jsr  pop_float_fac1
-		stx  c64.SCRATCH_ZPREGX
-		jsr  GETADR
-		ldx  c64.SCRATCH_ZPREGX
-		sta  c64.ESTACK_HI,x
-		tya
-		sta  c64.ESTACK_LO,x
-		dex
-		rts
-		.pend
-
-push_float	.proc
-		; ---- push mflpt5 in A/Y onto stack
-		; (taking 3 stack positions = 6 bytes of which 1 is padding)
-		sta  c64.SCRATCH_ZPWORD1
-		sty  c64.SCRATCH_ZPWORD1+1
-		ldy  #0
-		lda  (c64.SCRATCH_ZPWORD1),y
-		sta  c64.ESTACK_LO,x
-		iny
-		lda  (c64.SCRATCH_ZPWORD1),y
-		sta  c64.ESTACK_HI,x
-		dex
-		iny
-		lda  (c64.SCRATCH_ZPWORD1),y
-		sta  c64.ESTACK_LO,x
-		iny
-		lda  (c64.SCRATCH_ZPWORD1),y
-		sta  c64.ESTACK_HI,x
-		dex
-		iny
-		lda  (c64.SCRATCH_ZPWORD1),y
-		sta  c64.ESTACK_LO,x
-		dex
-		rts
-		.pend
-
-func_rndf	.proc
-		; -- put a random floating point value on the stack
-		stx  c64.SCRATCH_ZPREG
-		lda  #1
-		jsr  FREADSA
-		jsr  RND		; rng into fac1
-		ldx  #<_rndf_rnum5
-		ldy  #>_rndf_rnum5
-		jsr  MOVMF	; fac1 to mem X/Y
-		ldx  c64.SCRATCH_ZPREG
-		lda  #<_rndf_rnum5
-		ldy  #>_rndf_rnum5
-		jmp  push_float
-_rndf_rnum5	.byte  0,0,0,0,0
-		.pend
-
-push_float_from_indexed_var	.proc
-		; -- push the float from the array at A/Y with index on stack, onto the stack.
-		sta  c64.SCRATCH_ZPWORD1
-		sty  c64.SCRATCH_ZPWORD1+1
-		jsr  prog8_lib.pop_index_times_5
-		jsr  prog8_lib.add_a_to_zpword
-		lda  c64.SCRATCH_ZPWORD1
-		ldy  c64.SCRATCH_ZPWORD1+1
-		jmp  push_float
-		.pend
-
-pop_float	.proc
-		; ---- pops mflpt5 from stack to memory A/Y
-		; (frees 3 stack positions = 6 bytes of which 1 is padding)
-		sta  c64.SCRATCH_ZPWORD1
-		sty  c64.SCRATCH_ZPWORD1+1
-		ldy  #4
-		inx
-		lda  c64.ESTACK_LO,x
-		sta  (c64.SCRATCH_ZPWORD1),y
-		dey
-		inx
-		lda  c64.ESTACK_HI,x
-		sta  (c64.SCRATCH_ZPWORD1),y
-		dey
-		lda  c64.ESTACK_LO,x
-		sta  (c64.SCRATCH_ZPWORD1),y
-		dey
-		inx
-		lda  c64.ESTACK_HI,x
-		sta  (c64.SCRATCH_ZPWORD1),y
-		dey
-		lda  c64.ESTACK_LO,x
-		sta  (c64.SCRATCH_ZPWORD1),y
-		rts
-		.pend
-
-pop_float_fac1	.proc
-		; -- pops float from stack into FAC1
-		lda  #<fmath_float1
-		ldy  #>fmath_float1
-		jsr  pop_float
-		lda  #<fmath_float1
-		ldy  #>fmath_float1
-		jmp  MOVFM
-		.pend
-
-pop_float_to_indexed_var	.proc
-		; -- pop the float on the stack, to the memory in the array at A/Y indexed by the byte on stack
-		sta  c64.SCRATCH_ZPWORD1
-		sty  c64.SCRATCH_ZPWORD1+1
-		jsr  prog8_lib.pop_index_times_5
-		jsr  prog8_lib.add_a_to_zpword
-		lda  c64.SCRATCH_ZPWORD1
-		ldy  c64.SCRATCH_ZPWORD1+1
-		jmp  pop_float
-		.pend
-
-copy_float	.proc
-		; -- copies the 5 bytes of the mflt value pointed to by SCRATCH_ZPWORD1,
-		;    into the 5 bytes pointed to by A/Y.  Clobbers A,Y.
-		sta  c64.SCRATCH_ZPWORD2
-		sty  c64.SCRATCH_ZPWORD2+1
-		ldy  #0
-		lda  (c64.SCRATCH_ZPWORD1),y
-		sta  (c64.SCRATCH_ZPWORD2),y
-		iny
-		lda  (c64.SCRATCH_ZPWORD1),y
-		sta  (c64.SCRATCH_ZPWORD2),y
-		iny
-		lda  (c64.SCRATCH_ZPWORD1),y
-		sta  (c64.SCRATCH_ZPWORD2),y
-		iny
-		lda  (c64.SCRATCH_ZPWORD1),y
-		sta  (c64.SCRATCH_ZPWORD2),y
-		iny
-		lda  (c64.SCRATCH_ZPWORD1),y
-		sta  (c64.SCRATCH_ZPWORD2),y
-		rts
-		.pend
-
-inc_var_f	.proc
-		; -- add 1 to float pointed to by A/Y
-		sta  c64.SCRATCH_ZPWORD1
-		sty  c64.SCRATCH_ZPWORD1+1
-		stx  c64.SCRATCH_ZPREGX
-		jsr  MOVFM
-		lda  #<FL_FONE
-		ldy  #>FL_FONE
-		jsr  FADD
-		ldx  c64.SCRATCH_ZPWORD1
-		ldy  c64.SCRATCH_ZPWORD1+1
-		jsr  MOVMF
-		ldx  c64.SCRATCH_ZPREGX
-		rts
-		.pend
-
-dec_var_f	.proc
-		; -- subtract 1 from float pointed to by A/Y
-		sta  c64.SCRATCH_ZPWORD1
-		sty  c64.SCRATCH_ZPWORD1+1
-		stx  c64.SCRATCH_ZPREGX
-		lda  #<FL_FONE
-		ldy  #>FL_FONE
-		jsr  MOVFM
-		lda  c64.SCRATCH_ZPWORD1
-		ldy  c64.SCRATCH_ZPWORD1+1
-		jsr  FSUB
-		ldx  c64.SCRATCH_ZPWORD1
-		ldy  c64.SCRATCH_ZPWORD1+1
-		jsr  MOVMF
-		ldx  c64.SCRATCH_ZPREGX
-		rts
-		.pend
-
-inc_indexed_var_f	.proc
-		; -- add 1 to float in array pointed to by A/Y, at index X
-		pha
-		txa
-		sta  c64.SCRATCH_ZPB1
-		asl  a
-		asl  a
-		clc
-		adc  c64.SCRATCH_ZPB1
-		sta  c64.SCRATCH_ZPB1
-		pla
-		clc
-		adc  c64.SCRATCH_ZPB1
-		bcc  +
-		iny
-+		jmp  inc_var_f
-		.pend
-
-dec_indexed_var_f	.proc
-		; -- subtract 1 to float in array pointed to by A/Y, at index X
-		pha
-		txa
-		sta  c64.SCRATCH_ZPB1
-		asl  a
-		asl  a
-		clc
-		adc  c64.SCRATCH_ZPB1
-		sta  c64.SCRATCH_ZPB1
-		pla
-		clc
-		adc  c64.SCRATCH_ZPB1
-		bcc  +
-		iny
-+		jmp  dec_var_f
-		.pend
-
-
-pop_2_floats_f2_in_fac1	.proc
-		; -- pop 2 floats from stack, load the second one in FAC1 as well
-		lda  #<fmath_float2
-		ldy  #>fmath_float2
-		jsr  pop_float
-		lda  #<fmath_float1
-		ldy  #>fmath_float1
-		jsr  pop_float
-		lda  #<fmath_float2
-		ldy  #>fmath_float2
-		jmp  MOVFM
-		.pend
-
-
-fmath_float1	.byte 0,0,0,0,0	; storage for a mflpt5 value
-fmath_float2	.byte 0,0,0,0,0	; storage for a mflpt5 value
-
-push_fac1_as_result	.proc
-		; -- push the float in FAC1 onto the stack, and return from calculation
-		ldx  #<fmath_float1
-		ldy  #>fmath_float1
-		jsr  MOVMF
-		lda  #<fmath_float1
-		ldy  #>fmath_float1
-		ldx  c64.SCRATCH_ZPREGX
-		jmp  push_float
-		.pend
-
-pow_f		.proc
-		; -- push f1 ** f2 on stack
-		lda  #<fmath_float2
-		ldy  #>fmath_float2
-		jsr  pop_float
-		lda  #<fmath_float1
-		ldy  #>fmath_float1
-		jsr  pop_float
-		stx  c64.SCRATCH_ZPREGX
-		lda  #<fmath_float1
-		ldy  #>fmath_float1
-		jsr  CONUPK		; fac2 = float1
-		lda  #<fmath_float2
-		ldy  #>fmath_float2
-		jsr  FPWR
-		ldx  c64.SCRATCH_ZPREGX
-		jmp  push_fac1_as_result
-		.pend
-
-div_f		.proc
-		; -- push f1/f2 on stack
-		jsr  pop_2_floats_f2_in_fac1
-		stx  c64.SCRATCH_ZPREGX
-		lda  #<fmath_float1
-		ldy  #>fmath_float1
-		jsr  FDIV
-		jmp  push_fac1_as_result
-		.pend
-
-add_f		.proc
-		; -- push f1+f2 on stack
-		jsr  pop_2_floats_f2_in_fac1
-		stx  c64.SCRATCH_ZPREGX
-		lda  #<fmath_float1
-		ldy  #>fmath_float1
-		jsr  FADD
-		jmp  push_fac1_as_result
-		.pend
-
-sub_f		.proc
-		; -- push f1-f2 on stack
-		jsr  pop_2_floats_f2_in_fac1
-		stx  c64.SCRATCH_ZPREGX
-		lda  #<fmath_float1
-		ldy  #>fmath_float1
-		jsr  FSUB
-		jmp  push_fac1_as_result
-		.pend
-
-mul_f		.proc
-		; -- push f1*f2 on stack
-		jsr  pop_2_floats_f2_in_fac1
-		stx  c64.SCRATCH_ZPREGX
-		lda  #<fmath_float1
-		ldy  #>fmath_float1
-		jsr  FMULT
-		jmp  push_fac1_as_result
-		.pend
-
-neg_f		.proc
-		; -- push -flt back on stack
-		jsr  pop_float_fac1
-		stx  c64.SCRATCH_ZPREGX
-		jsr  NEGOP
-		jmp  push_fac1_as_result
-		.pend
-
-abs_f		.proc
-		; -- push abs(float) on stack (as float)
-		jsr  pop_float_fac1
-		stx  c64.SCRATCH_ZPREGX
-		jsr  ABS
-		jmp  push_fac1_as_result
-		.pend
-
-equal_f		.proc
-		; -- are the two mflpt5 numbers on the stack identical?
-		inx
-		inx
-		inx
-		inx
-		lda  c64.ESTACK_LO-3,x
-		cmp  c64.ESTACK_LO,x
-		bne  _equals_false
-		lda  c64.ESTACK_LO-2,x
-		cmp  c64.ESTACK_LO+1,x
-		bne  _equals_false
-		lda  c64.ESTACK_LO-1,x
-		cmp  c64.ESTACK_LO+2,x
-		bne  _equals_false
-		lda  c64.ESTACK_HI-2,x
-		cmp  c64.ESTACK_HI+1,x
-		bne  _equals_false
-		lda  c64.ESTACK_HI-1,x
-		cmp  c64.ESTACK_HI+2,x
-		bne  _equals_false
-_equals_true	lda  #1
-_equals_store	inx
-		sta  c64.ESTACK_LO+1,x
-		rts
-_equals_false	lda  #0
-		beq  _equals_store
-		.pend
-
-notequal_f	.proc
-		; -- are the two mflpt5 numbers on the stack different?
-		jsr  equal_f
-		eor  #1		; invert the result
-		sta  c64.ESTACK_LO+1,x
-		rts
-		.pend
-
-less_f		.proc
-		; -- is f1 < f2?
-		jsr  compare_floats
-		cmp  #255
-		beq  compare_floats._return_true
-		bne  compare_floats._return_false
-		.pend
-
-
-lesseq_f	.proc
-		; -- is f1 <= f2?
-		jsr  compare_floats
-		cmp  #255
-		beq  compare_floats._return_true
-		cmp  #0
-		beq  compare_floats._return_true
-		bne  compare_floats._return_false
-		.pend
-
-greater_f	.proc
-		; -- is f1 > f2?
-		jsr  compare_floats
-		cmp  #1
-		beq  compare_floats._return_true
-		bne  compare_floats._return_false
-		.pend
-
-greatereq_f	.proc
-		; -- is f1 >= f2?
-		jsr  compare_floats
-		cmp  #1
-		beq  compare_floats._return_true
-		cmp  #0
-		beq  compare_floats._return_true
-		bne  compare_floats._return_false
-		.pend
-
-compare_floats	.proc
-		lda  #<fmath_float2
-		ldy  #>fmath_float2
-		jsr  pop_float
-		lda  #<fmath_float1
-		ldy  #>fmath_float1
-		jsr  pop_float
-		lda  #<fmath_float1
-		ldy  #>fmath_float1
-		jsr  MOVFM		; fac1 = flt1
-		lda  #<fmath_float2
-		ldy  #>fmath_float2
-		stx  c64.SCRATCH_ZPREG
-		jsr  FCOMP		; A = flt1 compared with flt2 (0=equal, 1=flt1>flt2, 255=flt1<flt2)
-		ldx  c64.SCRATCH_ZPREG
-		rts
-_return_false	lda  #0
-_return_result  sta  c64.ESTACK_LO,x
-		dex
-		rts
-_return_true	lda  #1
-		bne  _return_result
-		.pend
-
-func_sin	.proc
-		; -- push sin(f) back onto stack
-		jsr  pop_float_fac1
-		stx  c64.SCRATCH_ZPREGX
-		jsr  SIN
-		jmp  push_fac1_as_result
-		.pend
-
-func_cos	.proc
-		; -- push cos(f) back onto stack
-		jsr  pop_float_fac1
-		stx  c64.SCRATCH_ZPREGX
-		jsr  COS
-		jmp  push_fac1_as_result
-		.pend
-
-func_tan	.proc
-		; -- push tan(f) back onto stack
-		jsr  pop_float_fac1
-		stx  c64.SCRATCH_ZPREGX
-		jsr  TAN
-		jmp  push_fac1_as_result
-		.pend
-
-func_atan	.proc
-		; -- push atan(f) back onto stack
-		jsr  pop_float_fac1
-		stx  c64.SCRATCH_ZPREGX
-		jsr  ATN
-		jmp  push_fac1_as_result
-		.pend
-
-func_ln		.proc
-		; -- push ln(f) back onto stack
-		jsr  pop_float_fac1
-		stx  c64.SCRATCH_ZPREGX
-		jsr  LOG
-		jmp  push_fac1_as_result
-		.pend
-
-func_log2	.proc
-		; -- push log base 2, ln(f)/ln(2), back onto stack
-		jsr  pop_float_fac1
-		stx  c64.SCRATCH_ZPREGX
-		jsr  LOG
-		jsr  MOVEF
-		lda  #<c64.FL_LOG2
-		ldy  #>c64.FL_LOG2
-		jsr  MOVFM
-		jsr  FDIVT
-		jmp  push_fac1_as_result
-		.pend
-
-func_sqrt	.proc
-		jsr  pop_float_fac1
-		stx  c64.SCRATCH_ZPREGX
-		jsr  SQR
-		jmp  push_fac1_as_result
-		.pend
-
-func_rad	.proc
-		; -- convert degrees to radians (d * pi / 180)
-		jsr  pop_float_fac1
-		stx  c64.SCRATCH_ZPREGX
-		lda  #<_pi_div_180
-		ldy  #>_pi_div_180
-		jsr  FMULT
-		jmp  push_fac1_as_result
-_pi_div_180	.byte 123, 14, 250, 53, 18		; pi / 180
-		.pend
-
-func_deg	.proc
-		; -- convert radians to degrees (d * (1/ pi * 180))
-		jsr  pop_float_fac1
-		stx  c64.SCRATCH_ZPREGX
-		lda  #<_one_over_pi_div_180
-		ldy  #>_one_over_pi_div_180
-		jsr  FMULT
-		jmp  push_fac1_as_result
-_one_over_pi_div_180	.byte 134, 101, 46, 224, 211		; 1 / (pi * 180)
-		.pend
-
-func_round	.proc
-		jsr  pop_float_fac1
-		stx  c64.SCRATCH_ZPREGX
-		jsr  FADDH
-		jsr  INT
-		jmp  push_fac1_as_result
-		.pend
-
-func_floor	.proc
-		jsr  pop_float_fac1
-		stx  c64.SCRATCH_ZPREGX
-		jsr  INT
-		jmp  push_fac1_as_result
-		.pend
-
-func_ceil	.proc
-		; -- ceil: tr = int(f); if tr==f -> return  else return tr+1
-		jsr  pop_float_fac1
-		stx  c64.SCRATCH_ZPREGX
-		ldx  #<fmath_float1
-		ldy  #>fmath_float1
-		jsr  MOVMF
-		jsr  INT
-		lda  #<fmath_float1
-		ldy  #>fmath_float1
-		jsr  FCOMP
-		cmp  #0
-		beq  +
-		lda  #<FL_FONE
-		ldy  #>FL_FONE
-		jsr  FADD
-+		jmp  push_fac1_as_result
-		.pend
-
-func_any_f	.proc
-		inx
-		lda  c64.ESTACK_LO,x	; array size
-		sta  c64.SCRATCH_ZPB1
-		asl  a
-		asl  a
-		clc
-		adc  c64.SCRATCH_ZPB1	; times 5 because of float
-		jmp  prog8_lib.func_any_b._entry
-		.pend
-
-func_all_f	.proc
-		inx
-		jsr  prog8_lib.peek_address
-		lda  c64.ESTACK_LO,x	; array size
-		sta  c64.SCRATCH_ZPB1
-		asl  a
-		asl  a
-		clc
-		adc  c64.SCRATCH_ZPB1	; times 5 because of float
-		tay
-		dey
--		lda  (c64.SCRATCH_ZPWORD1),y
-		clc
-		dey
-		adc  (c64.SCRATCH_ZPWORD1),y
-		dey
-		adc  (c64.SCRATCH_ZPWORD1),y
-		dey
-		adc  (c64.SCRATCH_ZPWORD1),y
-		dey
-		adc  (c64.SCRATCH_ZPWORD1),y
-		dey
-		cmp  #0
-		beq  +
-        cpy  #255
-        bne  -
-		lda  #1
-		sta  c64.ESTACK_LO+1,x
-		rts
-+		sta  c64.ESTACK_LO+1,x
-		rts
-		.pend
-
-func_max_f	.proc
-		lda  #255
-		sta  _minmax_cmp+1
-		lda  #<_largest_neg_float
-		ldy  #>_largest_neg_float
-_minmax_entry	jsr  MOVFM
-		jsr  prog8_lib.pop_array_and_lengthmin1Y
-		stx  c64.SCRATCH_ZPREGX
--		sty  c64.SCRATCH_ZPREG
-		lda  c64.SCRATCH_ZPWORD1
-		ldy  c64.SCRATCH_ZPWORD1+1
-		jsr  FCOMP
-_minmax_cmp	cmp  #255			; modified
-		bne  +
-		lda  c64.SCRATCH_ZPWORD1
-		ldy  c64.SCRATCH_ZPWORD1+1
-		jsr  MOVFM
-+		lda  c64.SCRATCH_ZPWORD1
-		clc
-		adc  #5
-		sta  c64.SCRATCH_ZPWORD1
-		bcc  +
-		inc  c64.SCRATCH_ZPWORD1+1
-+		ldy  c64.SCRATCH_ZPREG
-		dey
-		cpy  #255
-		bne  -
-		jmp  push_fac1_as_result
-_largest_neg_float	.byte 255,255,255,255,255		; largest negative float -1.7014118345e+38
-		.pend
-
-func_min_f	.proc
-		lda  #1
-		sta  func_max_f._minmax_cmp+1
-		lda  #<_largest_pos_float
-		ldy  #>_largest_pos_float
-		jmp  func_max_f._minmax_entry
-_largest_pos_float	.byte  255,127,255,255,255		; largest positive float
-		rts
-		.pend
-
-func_sum_f	.proc
-		lda  #<FL_ZERO
-		ldy  #>FL_ZERO
-		jsr  MOVFM
-		jsr  prog8_lib.pop_array_and_lengthmin1Y
-		stx  c64.SCRATCH_ZPREGX
--		sty  c64.SCRATCH_ZPREG
-		lda  c64.SCRATCH_ZPWORD1
-		ldy  c64.SCRATCH_ZPWORD1+1
-		jsr  FADD
-		ldy  c64.SCRATCH_ZPREG
-		dey
-		cpy  #255
-		beq  +
-		lda  c64.SCRATCH_ZPWORD1
-		clc
-		adc  #5
-		sta  c64.SCRATCH_ZPWORD1
-		bcc  -
-		inc  c64.SCRATCH_ZPWORD1+1
-		bne  -
-+		jmp  push_fac1_as_result
-		.pend
-		
-sign_f		.proc
-		jsr  pop_float_fac1
-		jsr  SIGN
-		sta  c64.ESTACK_LO,x
-		dex
-		rts
-		.pend
-		
-
-}}
+%asminclude "library:c64floats.asm", ""
 
 }  ; ------ end of block c64flt

compiler/res/prog8lib/c64lib.p8

@@ -7,178 +7,178 @@
 
 
 c64 {
-		const   uword  ESTACK_LO	= $ce00		; evaluation stack (lsb)
-		const   uword  ESTACK_HI	= $cf00		; evaluation stack (msb)
-		&ubyte  SCRATCH_ZPB1		= $02		; scratch byte 1 in ZP
-		&ubyte  SCRATCH_ZPREG		= $03		; scratch register in ZP
-		&ubyte  SCRATCH_ZPREGX		= $fa		; temp storage for X register (stack pointer)
-		&uword  SCRATCH_ZPWORD1		= $fb		; scratch word in ZP ($fb/$fc)
-		&uword  SCRATCH_ZPWORD2		= $fd		; scratch word in ZP ($fd/$fe)
+        const  uword  ESTACK_LO = $ce00     ; evaluation stack (lsb)
+        const  uword  ESTACK_HI = $cf00     ; evaluation stack (msb)
+        &ubyte  SCRATCH_ZPB1    = $02       ; scratch byte 1 in ZP
+        &ubyte  SCRATCH_ZPREG   = $03       ; scratch register in ZP
+        &ubyte  SCRATCH_ZPREGX  = $fa       ; temp storage for X register (stack pointer)
+        &uword  SCRATCH_ZPWORD1 = $fb       ; scratch word in ZP ($fb/$fc)
+        &uword  SCRATCH_ZPWORD2 = $fd       ; scratch word in ZP ($fd/$fe)
 
 
-		&ubyte  TIME_HI			= $a0		; software jiffy clock, hi byte
-		&ubyte  TIME_MID		= $a1		;  .. mid byte
-		&ubyte  TIME_LO			= $a2		;    .. lo byte. Updated by IRQ every 1/60 sec
-		&ubyte  STKEY			= $91		; various keyboard statuses (updated by IRQ)
-		&ubyte  SFDX			= $cb		; current key pressed (matrix value) (updated by IRQ)
+        &ubyte  TIME_HI         = $a0       ; software jiffy clock, hi byte
+        &ubyte  TIME_MID        = $a1       ;  .. mid byte
+        &ubyte  TIME_LO         = $a2       ;    .. lo byte. Updated by IRQ every 1/60 sec
+        &ubyte  STKEY           = $91       ; various keyboard statuses (updated by IRQ)
+        &ubyte  SFDX            = $cb       ; current key pressed (matrix value) (updated by IRQ)
 
-		&ubyte  COLOR			= $0286		; cursor color
-		&ubyte  HIBASE			= $0288		; screen base address / 256 (hi-byte of screen memory address)
-		&uword  CINV			= $0314		; IRQ vector
-		&uword  NMI_VEC			= $FFFA		; 6502 nmi vector, determined by the kernal if banked in
-		&uword  RESET_VEC		= $FFFC		; 6502 reset vector, determined by the kernal if banked in
-		&uword  IRQ_VEC			= $FFFE		; 6502 interrupt vector, determined by the kernal if banked in
+        &ubyte  COLOR           = $0286     ; cursor color
+        &ubyte  HIBASE          = $0288     ; screen base address / 256 (hi-byte of screen memory address)
+        &uword  CINV            = $0314     ; IRQ vector
+        &uword  NMI_VEC         = $FFFA     ; 6502 nmi vector, determined by the kernal if banked in
+        &uword  RESET_VEC       = $FFFC     ; 6502 reset vector, determined by the kernal if banked in
+        &uword  IRQ_VEC         = $FFFE     ; 6502 interrupt vector, determined by the kernal if banked in
 
-		; the default addresses for the character screen chars and colors
-		const   uword  Screen		= $0400		; to have this as an array[40*25] the compiler would have to support array size > 255
-		const   uword  Colors		= $d800		; to have this as an array[40*25] the compiler would have to support array size > 255
+        ; the default addresses for the character screen chars and colors
+        const  uword  Screen    = $0400     ; to have this as an array[40*25] the compiler would have to support array size > 255
+        const  uword  Colors    = $d800     ; to have this as an array[40*25] the compiler would have to support array size > 255
 
-		; the default locations of the 8 sprite pointers (store address of sprite / 64)
-		&ubyte  SPRPTR0			= 2040
-		&ubyte  SPRPTR1			= 2041
-		&ubyte  SPRPTR2			= 2042
-		&ubyte  SPRPTR3			= 2043
-		&ubyte  SPRPTR4			= 2044
-		&ubyte  SPRPTR5			= 2045
-		&ubyte  SPRPTR6			= 2046
-		&ubyte  SPRPTR7			= 2047
-		&ubyte[8]  SPRPTR		= 2040		; the 8 sprite pointers as an array.
+        ; the default locations of the 8 sprite pointers (store address of sprite / 64)
+        &ubyte  SPRPTR0         = 2040
+        &ubyte  SPRPTR1         = 2041
+        &ubyte  SPRPTR2         = 2042
+        &ubyte  SPRPTR3         = 2043
+        &ubyte  SPRPTR4         = 2044
+        &ubyte  SPRPTR5         = 2045
+        &ubyte  SPRPTR6         = 2046
+        &ubyte  SPRPTR7         = 2047
+        &ubyte[8]  SPRPTR       = 2040      ; the 8 sprite pointers as an array.
 
 
 ; ---- VIC-II 6567/6569/856x registers ----
 
-		&ubyte  SP0X		= $d000
-		&ubyte  SP0Y		= $d001
-		&ubyte  SP1X		= $d002
-		&ubyte  SP1Y		= $d003
-		&ubyte  SP2X		= $d004
-		&ubyte  SP2Y		= $d005
-		&ubyte  SP3X		= $d006
-		&ubyte  SP3Y		= $d007
-		&ubyte  SP4X		= $d008
-		&ubyte  SP4Y		= $d009
-		&ubyte  SP5X		= $d00a
-		&ubyte  SP5Y		= $d00b
-		&ubyte  SP6X		= $d00c
-		&ubyte  SP6Y		= $d00d
-		&ubyte  SP7X		= $d00e
-		&ubyte  SP7Y		= $d00f
-		&ubyte[16]  SPXY	= $d000		; the 8 sprite X and Y registers as an array.
-		&uword[8]  SPXYW	= $d000		; the 8 sprite X and Y registers as a combined xy word array.
+        &ubyte  SP0X            = $d000
+        &ubyte  SP0Y            = $d001
+        &ubyte  SP1X            = $d002
+        &ubyte  SP1Y            = $d003
+        &ubyte  SP2X            = $d004
+        &ubyte  SP2Y            = $d005
+        &ubyte  SP3X            = $d006
+        &ubyte  SP3Y            = $d007
+        &ubyte  SP4X            = $d008
+        &ubyte  SP4Y            = $d009
+        &ubyte  SP5X            = $d00a
+        &ubyte  SP5Y            = $d00b
+        &ubyte  SP6X            = $d00c
+        &ubyte  SP6Y            = $d00d
+        &ubyte  SP7X            = $d00e
+        &ubyte  SP7Y            = $d00f
+        &ubyte[16]  SPXY        = $d000        ; the 8 sprite X and Y registers as an array.
+        &uword[8]  SPXYW        = $d000        ; the 8 sprite X and Y registers as a combined xy word array.
 
-		&ubyte  MSIGX		= $d010
-		&ubyte  SCROLY		= $d011
-		&ubyte  RASTER		= $d012
-		&ubyte  LPENX		= $d013
-		&ubyte  LPENY		= $d014
-		&ubyte  SPENA		= $d015
-		&ubyte  SCROLX		= $d016
-		&ubyte  YXPAND		= $d017
-		&ubyte  VMCSB		= $d018
-		&ubyte  VICIRQ		= $d019
-		&ubyte  IREQMASK	= $d01a
-		&ubyte  SPBGPR		= $d01b
-		&ubyte  SPMC		= $d01c
-		&ubyte  XXPAND		= $d01d
-		&ubyte  SPSPCL		= $d01e
-		&ubyte  SPBGCL		= $d01f
+        &ubyte  MSIGX           = $d010
+        &ubyte  SCROLY          = $d011
+        &ubyte  RASTER          = $d012
+        &ubyte  LPENX           = $d013
+        &ubyte  LPENY           = $d014
+        &ubyte  SPENA           = $d015
+        &ubyte  SCROLX          = $d016
+        &ubyte  YXPAND          = $d017
+        &ubyte  VMCSB           = $d018
+        &ubyte  VICIRQ          = $d019
+        &ubyte  IREQMASK        = $d01a
+        &ubyte  SPBGPR          = $d01b
+        &ubyte  SPMC            = $d01c
+        &ubyte  XXPAND          = $d01d
+        &ubyte  SPSPCL          = $d01e
+        &ubyte  SPBGCL          = $d01f
 
-		&ubyte  EXTCOL		= $d020		; border color
-		&ubyte  BGCOL0		= $d021		; screen color
-		&ubyte  BGCOL1		= $d022
-		&ubyte  BGCOL2		= $d023
-		&ubyte  BGCOL4		= $d024
-		&ubyte  SPMC0		= $d025
-		&ubyte  SPMC1		= $d026
-		&ubyte  SP0COL		= $d027
-		&ubyte  SP1COL		= $d028
-		&ubyte  SP2COL		= $d029
-		&ubyte  SP3COL		= $d02a
-		&ubyte  SP4COL		= $d02b
-		&ubyte  SP5COL		= $d02c
-		&ubyte  SP6COL		= $d02d
-		&ubyte  SP7COL		= $d02e
-		&ubyte[8]  SPCOL	= $d027
+        &ubyte  EXTCOL          = $d020        ; border color
+        &ubyte  BGCOL0          = $d021        ; screen color
+        &ubyte  BGCOL1          = $d022
+        &ubyte  BGCOL2          = $d023
+        &ubyte  BGCOL4          = $d024
+        &ubyte  SPMC0           = $d025
+        &ubyte  SPMC1           = $d026
+        &ubyte  SP0COL          = $d027
+        &ubyte  SP1COL          = $d028
+        &ubyte  SP2COL          = $d029
+        &ubyte  SP3COL          = $d02a
+        &ubyte  SP4COL          = $d02b
+        &ubyte  SP5COL          = $d02c
+        &ubyte  SP6COL          = $d02d
+        &ubyte  SP7COL          = $d02e
+        &ubyte[8]  SPCOL        = $d027
 
 
 ; ---- end of VIC-II registers ----
 
 ; ---- CIA 6526 1 & 2 registers ----
 
-		&ubyte  CIA1PRA		= $DC00		; CIA 1 DRA, keyboard column drive (and joystick control port #2)
-		&ubyte  CIA1PRB		= $DC01		; CIA 1 DRB, keyboard row port (and joystick control port #1)
-		&ubyte  CIA1DDRA	= $DC02		; CIA 1 DDRA, keyboard column
-		&ubyte  CIA1DDRB	= $DC03		; CIA 1 DDRB, keyboard row
-		&ubyte  CIA1TAL		= $DC04		; CIA 1 timer A low byte
-		&ubyte  CIA1TAH		= $DC05		; CIA 1 timer A high byte
-		&ubyte  CIA1TBL		= $DC06		; CIA 1 timer B low byte
-		&ubyte  CIA1TBH		= $DC07		; CIA 1 timer B high byte
-		&ubyte  CIA1TOD10	= $DC08		; time of day, 1/10 sec.
-		&ubyte  CIA1TODSEC	= $DC09		; time of day, seconds
-		&ubyte  CIA1TODMMIN	= $DC0A		; time of day, minutes
-		&ubyte  CIA1TODHR	= $DC0B		; time of day, hours
-		&ubyte  CIA1SDR		= $DC0C		; Serial Data Register
-		&ubyte  CIA1ICR		= $DC0D
-		&ubyte  CIA1CRA		= $DC0E
-		&ubyte  CIA1CRB		= $DC0F
+        &ubyte  CIA1PRA         = $DC00        ; CIA 1 DRA, keyboard column drive (and joystick control port #2)
+        &ubyte  CIA1PRB         = $DC01        ; CIA 1 DRB, keyboard row port (and joystick control port #1)
+        &ubyte  CIA1DDRA        = $DC02        ; CIA 1 DDRA, keyboard column
+        &ubyte  CIA1DDRB        = $DC03        ; CIA 1 DDRB, keyboard row
+        &ubyte  CIA1TAL         = $DC04        ; CIA 1 timer A low byte
+        &ubyte  CIA1TAH         = $DC05        ; CIA 1 timer A high byte
+        &ubyte  CIA1TBL         = $DC06        ; CIA 1 timer B low byte
+        &ubyte  CIA1TBH         = $DC07        ; CIA 1 timer B high byte
+        &ubyte  CIA1TOD10       = $DC08        ; time of day, 1/10 sec.
+        &ubyte  CIA1TODSEC      = $DC09        ; time of day, seconds
+        &ubyte  CIA1TODMMIN     = $DC0A        ; time of day, minutes
+        &ubyte  CIA1TODHR       = $DC0B        ; time of day, hours
+        &ubyte  CIA1SDR         = $DC0C        ; Serial Data Register
+        &ubyte  CIA1ICR         = $DC0D
+        &ubyte  CIA1CRA         = $DC0E
+        &ubyte  CIA1CRB         = $DC0F
 
-		&ubyte  CIA2PRA		= $DD00		; CIA 2 DRA, serial port and video address
-		&ubyte  CIA2PRB		= $DD01		; CIA 2 DRB, RS232 port / USERPORT
-		&ubyte  CIA2DDRA	= $DD02		; CIA 2 DDRA, serial port and video address
-		&ubyte  CIA2DDRB	= $DD03		; CIA 2 DDRB, RS232 port / USERPORT
-		&ubyte  CIA2TAL		= $DD04		; CIA 2 timer A low byte
-		&ubyte  CIA2TAH		= $DD05		; CIA 2 timer A high byte
-		&ubyte  CIA2TBL		= $DD06		; CIA 2 timer B low byte
-		&ubyte  CIA2TBH		= $DD07		; CIA 2 timer B high byte
-		&ubyte  CIA2TOD10	= $DD08		; time of day, 1/10 sec.
-		&ubyte  CIA2TODSEC	= $DD09		; time of day, seconds
-		&ubyte  CIA2TODMIN	= $DD0A		; time of day, minutes
-		&ubyte  CIA2TODHR	= $DD0B		; time of day, hours
-		&ubyte  CIA2SDR		= $DD0C		; Serial Data Register
-		&ubyte  CIA2ICR		= $DD0D
-		&ubyte  CIA2CRA		= $DD0E
-		&ubyte  CIA2CRB		= $DD0F
+        &ubyte  CIA2PRA         = $DD00        ; CIA 2 DRA, serial port and video address
+        &ubyte  CIA2PRB         = $DD01        ; CIA 2 DRB, RS232 port / USERPORT
+        &ubyte  CIA2DDRA        = $DD02        ; CIA 2 DDRA, serial port and video address
+        &ubyte  CIA2DDRB        = $DD03        ; CIA 2 DDRB, RS232 port / USERPORT
+        &ubyte  CIA2TAL         = $DD04        ; CIA 2 timer A low byte
+        &ubyte  CIA2TAH         = $DD05        ; CIA 2 timer A high byte
+        &ubyte  CIA2TBL         = $DD06        ; CIA 2 timer B low byte
+        &ubyte  CIA2TBH         = $DD07        ; CIA 2 timer B high byte
+        &ubyte  CIA2TOD10       = $DD08        ; time of day, 1/10 sec.
+        &ubyte  CIA2TODSEC      = $DD09        ; time of day, seconds
+        &ubyte  CIA2TODMIN      = $DD0A        ; time of day, minutes
+        &ubyte  CIA2TODHR       = $DD0B        ; time of day, hours
+        &ubyte  CIA2SDR         = $DD0C        ; Serial Data Register
+        &ubyte  CIA2ICR         = $DD0D
+        &ubyte  CIA2CRA         = $DD0E
+        &ubyte  CIA2CRB         = $DD0F
 
 ; ---- end of CIA registers ----
 
 ; ---- SID 6581/8580 registers ----
 
-		&ubyte  FREQLO1		= $D400		; channel 1 freq lo
-		&ubyte  FREQHI1		= $D401		; channel 1 freq hi
-		&uword  FREQ1		= $D400		; channel 1 freq (word)
-		&ubyte  PWLO1		= $D402		; channel 1 pulse width lo (7-0)
-		&ubyte  PWHI1		= $D403		; channel 1 pulse width hi (11-8)
-		&uword  PW1		= $D402		; channel 1 pulse width (word)
-		&ubyte  CR1		= $D404		; channel 1 voice control register
-		&ubyte  AD1		= $D405		; channel 1 attack & decay
-		&ubyte  SR1		= $D406		; channel 1 sustain & release
-		&ubyte  FREQLO2		= $D407		; channel 2 freq lo
-		&ubyte  FREQHI2		= $D408		; channel 2 freq hi
-		&uword  FREQ2		= $D407		; channel 2 freq (word)
-		&ubyte  PWLO2		= $D409		; channel 2 pulse width lo (7-0)
-		&ubyte  PWHI2		= $D40A		; channel 2 pulse width hi (11-8)
-		&uword  PW2		= $D409		; channel 2 pulse width (word)
-		&ubyte  CR2		= $D40B		; channel 2 voice control register
-		&ubyte  AD2		= $D40C		; channel 2 attack & decay
-		&ubyte  SR2		= $D40D		; channel 2 sustain & release
-		&ubyte  FREQLO3		= $D40E		; channel 3 freq lo
-		&ubyte  FREQHI3		= $D40F		; channel 3 freq hi
-		&uword  FREQ3		= $D40E		; channel 3 freq (word)
-		&ubyte  PWLO3		= $D410		; channel 3 pulse width lo (7-0)
-		&ubyte  PWHI3		= $D411		; channel 3 pulse width hi (11-8)
-		&uword  PW3		= $D410		; channel 3 pulse width (word)
-		&ubyte  CR3		= $D412		; channel 3 voice control register
-		&ubyte  AD3		= $D413		; channel 3 attack & decay
-		&ubyte  SR3		= $D414		; channel 3 sustain & release
-		&ubyte  FCLO		= $D415		; filter cutoff lo (2-0)
-		&ubyte  FCHI		= $D416		; filter cutoff hi (10-3)
-		&uword  FC		= $D415		; filter cutoff (word)
-		&ubyte  RESFILT		= $D417		; filter resonance and routing
-		&ubyte  MVOL		= $D418		; filter mode and main volume control
-		&ubyte  POTX		= $D419		; potentiometer X
-		&ubyte  POTY		= $D41A		; potentiometer Y
-		&ubyte  OSC3		= $D41B		; channel 3 oscillator value read
-		&ubyte  ENV3		= $D41C		; channel 3 envelope value read
+        &ubyte  FREQLO1         = $D400        ; channel 1 freq lo
+        &ubyte  FREQHI1         = $D401        ; channel 1 freq hi
+        &uword  FREQ1           = $D400        ; channel 1 freq (word)
+        &ubyte  PWLO1           = $D402        ; channel 1 pulse width lo (7-0)
+        &ubyte  PWHI1           = $D403        ; channel 1 pulse width hi (11-8)
+        &uword  PW1             = $D402        ; channel 1 pulse width (word)
+        &ubyte  CR1             = $D404        ; channel 1 voice control register
+        &ubyte  AD1             = $D405        ; channel 1 attack & decay
+        &ubyte  SR1             = $D406        ; channel 1 sustain & release
+        &ubyte  FREQLO2         = $D407        ; channel 2 freq lo
+        &ubyte  FREQHI2         = $D408        ; channel 2 freq hi
+        &uword  FREQ2           = $D407        ; channel 2 freq (word)
+        &ubyte  PWLO2           = $D409        ; channel 2 pulse width lo (7-0)
+        &ubyte  PWHI2           = $D40A        ; channel 2 pulse width hi (11-8)
+        &uword  PW2             = $D409        ; channel 2 pulse width (word)
+        &ubyte  CR2             = $D40B        ; channel 2 voice control register
+        &ubyte  AD2             = $D40C        ; channel 2 attack & decay
+        &ubyte  SR2             = $D40D        ; channel 2 sustain & release
+        &ubyte  FREQLO3         = $D40E        ; channel 3 freq lo
+        &ubyte  FREQHI3         = $D40F        ; channel 3 freq hi
+        &uword  FREQ3           = $D40E        ; channel 3 freq (word)
+        &ubyte  PWLO3           = $D410        ; channel 3 pulse width lo (7-0)
+        &ubyte  PWHI3           = $D411        ; channel 3 pulse width hi (11-8)
+        &uword  PW3             = $D410        ; channel 3 pulse width (word)
+        &ubyte  CR3             = $D412        ; channel 3 voice control register
+        &ubyte  AD3             = $D413        ; channel 3 attack & decay
+        &ubyte  SR3             = $D414        ; channel 3 sustain & release
+        &ubyte  FCLO            = $D415        ; filter cutoff lo (2-0)
+        &ubyte  FCHI            = $D416        ; filter cutoff hi (10-3)
+        &uword  FC              = $D415        ; filter cutoff (word)
+        &ubyte  RESFILT         = $D417        ; filter resonance and routing
+        &ubyte  MVOL            = $D418        ; filter mode and main volume control
+        &ubyte  POTX            = $D419        ; potentiometer X
+        &ubyte  POTY            = $D41A        ; potentiometer Y
+        &ubyte  OSC3            = $D41B        ; channel 3 oscillator value read
+        &ubyte  ENV3            = $D41C        ; channel 3 envelope value read
 
 ; ---- end of SID registers ----
 
@@ -186,8 +186,8 @@ c64 {
 
 ; ---- C64 basic routines ----
 
-asmsub	CLEARSCR	() clobbers(A,X,Y)		= $E544		; clear the screen
-asmsub	HOMECRSR	() clobbers(A,X,Y)		= $E566		; cursor to top left of screen
+romsub $E544 = CLEARSCR() clobbers(A,X,Y)       ; clear the screen
+romsub $E566 = HOMECRSR() clobbers(A,X,Y)       ; cursor to top left of screen
 
 
 ; ---- end of C64 basic routines ----
@@ -195,48 +195,48 @@ asmsub	HOMECRSR	() clobbers(A,X,Y)		= $E566		; cursor to top left of screen
 
 ; ---- C64 kernal routines ----
 
-asmsub	STROUT   (uword strptr @ AY) clobbers(A, X, Y)	= $AB1E		; print null-terminated string (use c64scr.print instead)
-asmsub	IRQDFRT  () clobbers(A,X,Y)			= $EA31		; default IRQ routine
-asmsub	IRQDFEND () clobbers(A,X,Y)			= $EA81		; default IRQ end/cleanup
-asmsub	CINT     () clobbers(A,X,Y)			= $FF81		; (alias: SCINIT) initialize screen editor and video chip
-asmsub	IOINIT   () clobbers(A, X)			= $FF84		; initialize I/O devices (CIA, SID, IRQ)
-asmsub	RAMTAS   () clobbers(A,X,Y)			= $FF87		; initialize RAM, tape buffer, screen
-asmsub	RESTOR   () clobbers(A,X,Y)			= $FF8A		; restore default I/O vectors
-asmsub	VECTOR   (uword userptr @ XY, ubyte dir @ Pc) clobbers(A,Y)  = $FF8D		; read/set I/O vector table
-asmsub	SETMSG   (ubyte value @ A)			= $FF90		; set Kernal message control flag
-asmsub	SECOND   (ubyte address @ A) clobbers(A)	= $FF93		; (alias: LSTNSA) send secondary address after LISTEN
-asmsub	TKSA     (ubyte address @ A) clobbers(A)	= $FF96		; (alias: TALKSA) send secondary address after TALK
-asmsub	MEMTOP   (uword address @ XY, ubyte dir @ Pc) -> uword @ XY	= $FF99		; read/set top of memory  pointer
-asmsub	MEMBOT   (uword address @ XY, ubyte dir @ Pc) -> uword @ XY	= $FF9C		; read/set bottom of memory  pointer
-asmsub	SCNKEY   () clobbers(A,X,Y)			= $FF9F		; scan the keyboard
-asmsub	SETTMO   (ubyte timeout @ A)			= $FFA2		; set time-out flag for IEEE bus
-asmsub	ACPTR    () -> ubyte @ A			= $FFA5		; (alias: IECIN) input byte from serial bus
-asmsub	CIOUT    (ubyte databyte @ A)			= $FFA8		; (alias: IECOUT) output byte to serial bus
-asmsub	UNTLK    () clobbers(A)				= $FFAB		; command serial bus device to UNTALK
-asmsub	UNLSN    () clobbers(A)				= $FFAE		; command serial bus device to UNLISTEN
-asmsub	LISTEN   (ubyte device @ A) clobbers(A)		= $FFB1		; command serial bus device to LISTEN
-asmsub	TALK     (ubyte device @ A) clobbers(A)		= $FFB4		; command serial bus device to TALK
-asmsub	READST   () -> ubyte @ A			= $FFB7		; read I/O status word
-asmsub	SETLFS   (ubyte logical @ A, ubyte device @ X, ubyte address @ Y) = $FFBA	; set logical file parameters
-asmsub	SETNAM   (ubyte namelen @ A, str filename @ XY)	= $FFBD		; set filename parameters
-asmsub	OPEN     () clobbers(A,X,Y)			= $FFC0		; (via 794 ($31A)) open a logical file
-asmsub	CLOSE    (ubyte logical @ A) clobbers(A,X,Y)	= $FFC3		; (via 796 ($31C)) close a logical file
-asmsub	CHKIN    (ubyte logical @ X) clobbers(A,X)	= $FFC6		; (via 798 ($31E)) define an input channel
-asmsub	CHKOUT   (ubyte logical @ X) clobbers(A,X)	= $FFC9		; (via 800 ($320)) define an output channel
-asmsub	CLRCHN   () clobbers(A,X)			= $FFCC		; (via 802 ($322)) restore default devices
-asmsub	CHRIN    () clobbers(Y) -> ubyte @ A		= $FFCF		; (via 804 ($324)) input a character (for keyboard, read a whole line from the screen) A=byte read.
-asmsub	CHROUT   (ubyte char @ A)			= $FFD2		; (via 806 ($326)) output a character
-asmsub	LOAD     (ubyte verify @ A, uword address @ XY) -> ubyte @Pc, ubyte @ A, ubyte @ X, ubyte @ Y = $FFD5	; (via 816 ($330)) load from device
-asmsub	SAVE     (ubyte zp_startaddr @ A, uword endaddr @ XY) -> ubyte @ Pc, ubyte @ A = $FFD8	; (via 818 ($332)) save to a device
-asmsub	SETTIM   (ubyte low @ A, ubyte middle @ X, ubyte high @ Y)	= $FFDB		; set the software clock
-asmsub	RDTIM    () -> ubyte @ A, ubyte @ X, ubyte @ Y	= $FFDE	; read the software clock
-asmsub	STOP     () clobbers(A,X) -> ubyte @ Pz, ubyte @ Pc	= $FFE1		; (via 808 ($328)) check the STOP key
-asmsub	GETIN    () clobbers(X,Y) -> ubyte @ A		= $FFE4		; (via 810 ($32A)) get a character
-asmsub	CLALL    () clobbers(A,X)			= $FFE7		; (via 812 ($32C)) close all files
-asmsub	UDTIM    () clobbers(A,X)			= $FFEA		; update the software clock
-asmsub	SCREEN   () -> ubyte @ X, ubyte @ Y		= $FFED		; read number of screen rows and columns
-asmsub	PLOT     (ubyte col @ Y, ubyte row @ X, ubyte dir @ Pc) -> ubyte @ X, ubyte @ Y	= $FFF0		; read/set position of cursor on screen.  Use c64scr.plot for a 'safe' wrapper that preserves X.
-asmsub	IOBASE   () -> uword @ XY			= $FFF3		; read base address of I/O devices
+romsub $AB1E = STROUT(uword strptr @ AY) clobbers(A, X, Y)      ; print null-terminated string (use c64scr.print instead)
+romsub $EA31 = IRQDFRT() clobbers(A,X,Y)                        ; default IRQ routine
+romsub $EA81 = IRQDFEND() clobbers(A,X,Y)                       ; default IRQ end/cleanup
+romsub $FF81 = CINT() clobbers(A,X,Y)                           ; (alias: SCINIT) initialize screen editor and video chip
+romsub $FF84 = IOINIT() clobbers(A, X)                          ; initialize I/O devices (CIA, SID, IRQ)
+romsub $FF87 = RAMTAS() clobbers(A,X,Y)                         ; initialize RAM, tape buffer, screen
+romsub $FF8A = RESTOR() clobbers(A,X,Y)                         ; restore default I/O vectors
+romsub $FF8D = VECTOR(uword userptr @ XY, ubyte dir @ Pc) clobbers(A,Y)     ; read/set I/O vector table
+romsub $FF90 = SETMSG(ubyte value @ A)                          ; set Kernal message control flag
+romsub $FF93 = SECOND(ubyte address @ A) clobbers(A)            ; (alias: LSTNSA) send secondary address after LISTEN
+romsub $FF96 = TKSA(ubyte address @ A) clobbers(A)              ; (alias: TALKSA) send secondary address after TALK
+romsub $FF99 = MEMTOP(uword address @ XY, ubyte dir @ Pc) -> uword @ XY     ; read/set top of memory  pointer
+romsub $FF9C = MEMBOT(uword address @ XY, ubyte dir @ Pc) -> uword @ XY     ; read/set bottom of memory  pointer
+romsub $FF9F = SCNKEY() clobbers(A,X,Y)                         ; scan the keyboard
+romsub $FFA2 = SETTMO(ubyte timeout @ A)                        ; set time-out flag for IEEE bus
+romsub $FFA5 = ACPTR() -> ubyte @ A                             ; (alias: IECIN) input byte from serial bus
+romsub $FFA8 = CIOUT(ubyte databyte @ A)                        ; (alias: IECOUT) output byte to serial bus
+romsub $FFAB = UNTLK() clobbers(A)                              ; command serial bus device to UNTALK
+romsub $FFAE = UNLSN() clobbers(A)                              ; command serial bus device to UNLISTEN
+romsub $FFB1 = LISTEN(ubyte device @ A) clobbers(A)             ; command serial bus device to LISTEN
+romsub $FFB4 = TALK(ubyte device @ A) clobbers(A)               ; command serial bus device to TALK
+romsub $FFB7 = READST() -> ubyte @ A                            ; read I/O status word
+romsub $FFBA = SETLFS(ubyte logical @ A, ubyte device @ X, ubyte address @ Y)   ; set logical file parameters
+romsub $FFBD = SETNAM(ubyte namelen @ A, str filename @ XY)     ; set filename parameters
+romsub $FFC0 = OPEN() clobbers(A,X,Y)                           ; (via 794 ($31A)) open a logical file
+romsub $FFC3 = CLOSE(ubyte logical @ A) clobbers(A,X,Y)         ; (via 796 ($31C)) close a logical file
+romsub $FFC6 = CHKIN(ubyte logical @ X) clobbers(A,X)           ; (via 798 ($31E)) define an input channel
+romsub $FFC9 = CHKOUT(ubyte logical @ X) clobbers(A,X)          ; (via 800 ($320)) define an output channel
+romsub $FFCC = CLRCHN() clobbers(A,X)                           ; (via 802 ($322)) restore default devices
+romsub $FFCF = CHRIN() clobbers(Y) -> ubyte @ A                 ; (via 804 ($324)) input a character (for keyboard, read a whole line from the screen) A=byte read.
+romsub $FFD2 = CHROUT(ubyte char @ A)                           ; (via 806 ($326)) output a character
+romsub $FFD5 = LOAD(ubyte verify @ A, uword address @ XY) -> ubyte @Pc, ubyte @ A, ubyte @ X, ubyte @ Y     ; (via 816 ($330)) load from device
+romsub $FFD8 = SAVE(ubyte zp_startaddr @ A, uword endaddr @ XY) -> ubyte @ Pc, ubyte @ A                    ; (via 818 ($332)) save to a device
+romsub $FFDB = SETTIM(ubyte low @ A, ubyte middle @ X, ubyte high @ Y)      ; set the software clock
+romsub $FFDE = RDTIM() -> ubyte @ A, ubyte @ X, ubyte @ Y       ; read the software clock
+romsub $FFE1 = STOP() clobbers(A,X) -> ubyte @ Pz, ubyte @ Pc   ; (via 808 ($328)) check the STOP key
+romsub $FFE4 = GETIN() clobbers(X,Y) -> ubyte @ A               ; (via 810 ($32A)) get a character
+romsub $FFE7 = CLALL() clobbers(A,X)                            ; (via 812 ($32C)) close all files
+romsub $FFEA = UDTIM() clobbers(A,X)                            ; update the software clock
+romsub $FFED = SCREEN() -> ubyte @ X, ubyte @ Y                 ; read number of screen rows and columns
+romsub $FFF0 = PLOT(ubyte col @ Y, ubyte row @ X, ubyte dir @ Pc) -> ubyte @ X, ubyte @ Y       ; read/set position of cursor on screen.  Use c64scr.plot for a 'safe' wrapper that preserves X.
+romsub $FFF3 = IOBASE() -> uword @ XY                           ; read base address of I/O devices
 
 ; ---- end of C64 kernal routines ----
 

compiler/res/prog8lib/c64utils.p8

@@ -975,6 +975,7 @@ asmsub  print_uw  (uword value @ AY) clobbers(A,Y)  {
 	%asm {{
 	    stx  c64.SCRATCH_ZPREGX
 		jsr  c64utils.uword2decimal
+		ldx  c64.SCRATCH_ZPREGX
 		ldy  #0
 -		lda  c64utils.uword2decimal.decTenThousands,y
 		beq  _allzero

compiler/res/prog8lib/prog8lib.asm

@@ -651,6 +651,18 @@ greatereq_w	.proc
 		bmi  equal_b._equal_b_false
 		.pend
 
+
+orig_stackpointer	.byte  0	; stores the Stack pointer register at program start
+
+func_exit	.proc
+		; -- immediately exit the program with a return code in the A register
+		lda  c64.ESTACK_LO+1,x
+		ldx  orig_stackpointer
+		txs
+		rts		; return to original caller
+		.pend
+
+
 func_read_flags	.proc
 		; -- put the processor status register on the stack
 		php
@@ -1577,96 +1589,182 @@ _work3	.word  0
 reverse_b	.proc
 		; --- reverse an array of bytes (in-place)
 		; inputs:  pointer to array in c64.SCRATCH_ZPWORD1, length in A
-_left_index = c64.SCRATCH_ZPWORD2
-_right_index = c64.SCRATCH_ZPWORD2+1
-		pha
+_index_right = c64.SCRATCH_ZPWORD2
+_index_left = c64.SCRATCH_ZPWORD2+1
+_loop_count = c64.SCRATCH_ZPREG
+		sta  _loop_count
+		lsr  _loop_count
 		sec
 		sbc  #1
-		sta  _left_index
+		sta  _index_right
 		lda  #0
+		sta  _index_left
+_loop		ldy  _index_right
+		lda  (c64.SCRATCH_ZPWORD1),y
+		pha
+		ldy  _index_left
+		lda  (c64.SCRATCH_ZPWORD1),y
+		ldy  _index_right
+		sta  (c64.SCRATCH_ZPWORD1),y
+		pla
+		ldy  _index_left
+		sta  (c64.SCRATCH_ZPWORD1),y
+		inc  _index_left
+		dec  _index_right
+		dec  _loop_count
+		bne  _loop
+		rts
+		.pend
+
+
+reverse_f	.proc
+		; --- reverse an array of floats
+_left_index = c64.SCRATCH_ZPWORD2
+_right_index = c64.SCRATCH_ZPWORD2+1
+_loop_count = c64.SCRATCH_ZPREG
+		pha
+		sta  c64.SCRATCH_ZPREG
+		asl  a
+		asl  a
+		clc
+		adc  c64.SCRATCH_ZPREG		; *5 because float
+		sec
+		sbc  #5
 		sta  _right_index
+		lda  #0
+		sta  _left_index
 		pla
 		lsr  a
-		tay
-_loop		sty  c64.SCRATCH_ZPREG
+		sta  _loop_count
+_loop		; push the left indexed float on the stack
 		ldy  _left_index
 		lda  (c64.SCRATCH_ZPWORD1),y
 		pha
+		iny
+		lda  (c64.SCRATCH_ZPWORD1),y
+		pha
+		iny
+		lda  (c64.SCRATCH_ZPWORD1),y
+		pha
+		iny
+		lda  (c64.SCRATCH_ZPWORD1),y
+		pha
+		iny
+		lda  (c64.SCRATCH_ZPWORD1),y
+		pha
+		; copy right index float to left index float
 		ldy  _right_index
 		lda  (c64.SCRATCH_ZPWORD1),y
 		ldy  _left_index
 		sta  (c64.SCRATCH_ZPWORD1),y
-		pla
-		ldy  _right_index
-		sta  (c64.SCRATCH_ZPWORD1),y
+		inc  _left_index
 		inc  _right_index
-		dec  _left_index
-		ldy  c64.SCRATCH_ZPREG
+		ldy  _right_index
+		lda  (c64.SCRATCH_ZPWORD1),y
+		ldy  _left_index
+		sta  (c64.SCRATCH_ZPWORD1),y
+		inc  _left_index
+		inc  _right_index
+		ldy  _right_index
+		lda  (c64.SCRATCH_ZPWORD1),y
+		ldy  _left_index
+		sta  (c64.SCRATCH_ZPWORD1),y
+		inc  _left_index
+		inc  _right_index
+		ldy  _right_index
+		lda  (c64.SCRATCH_ZPWORD1),y
+		ldy  _left_index
+		sta  (c64.SCRATCH_ZPWORD1),y
+		inc  _left_index
+		inc  _right_index
+		ldy  _right_index
+		lda  (c64.SCRATCH_ZPWORD1),y
+		ldy  _left_index
+		sta  (c64.SCRATCH_ZPWORD1),y
+		; pop the float off the stack into the right index float
+		ldy  _right_index
+		pla
+		sta  (c64.SCRATCH_ZPWORD1),y
 		dey
+		pla
+		sta  (c64.SCRATCH_ZPWORD1),y
+		dey
+		pla
+		sta  (c64.SCRATCH_ZPWORD1),y
+		dey
+		pla
+		sta  (c64.SCRATCH_ZPWORD1),y
+		dey
+		pla
+		sta  (c64.SCRATCH_ZPWORD1),y
+		inc  _left_index
+		lda  _right_index
+		sec
+		sbc  #9
+		sta  _right_index
+		dec  _loop_count
 		bne  _loop
 		rts
+
 		.pend
 
 
 reverse_w	.proc
 		; --- reverse an array of words (in-place)
 		; inputs:  pointer to array in c64.SCRATCH_ZPWORD1, length in A
-_left_index = c64.SCRATCH_ZPWORD2
-_right_index = c64.SCRATCH_ZPWORD2+1
+_index_first = c64.SCRATCH_ZPWORD2
+_index_second = c64.SCRATCH_ZPWORD2+1
+_loop_count = c64.SCRATCH_ZPREG
 		pha
 		asl  a     ; *2 because words
 		sec
 		sbc  #2
-		sta  _left_index
+		sta  _index_first
 		lda  #0
-		sta  _right_index
+		sta  _index_second
 		pla
 		lsr  a
 		pha
-		tay
+		sta  _loop_count
 		; first reverse the lsbs
-_loop_lo	sty  c64.SCRATCH_ZPREG
-		ldy  _left_index
+_loop_lo	ldy  _index_first
 		lda  (c64.SCRATCH_ZPWORD1),y
 		pha
-		ldy  _right_index
+		ldy  _index_second
 		lda  (c64.SCRATCH_ZPWORD1),y
-		ldy  _left_index
+		ldy  _index_first
 		sta  (c64.SCRATCH_ZPWORD1),y
 		pla
-		ldy  _right_index
+		ldy  _index_second
 		sta  (c64.SCRATCH_ZPWORD1),y
-		inc  _right_index
-		inc  _right_index
-		dec  _left_index
-		dec  _left_index
-		ldy  c64.SCRATCH_ZPREG
-		dey
+		inc  _index_second
+		inc  _index_second
+		dec  _index_first
+		dec  _index_first
+		dec  _loop_count
 		bne  _loop_lo
 		; now reverse the msbs
-		dec  _right_index
-		inc  _left_index
-		inc  _left_index
-		inc  _left_index
+		dec  _index_second
+		inc  _index_first
+		inc  _index_first
+		inc  _index_first
 		pla
-		tay
-_loop_hi	sty  c64.SCRATCH_ZPREG
-		ldy  _left_index
+		sta  _loop_count
+_loop_hi	ldy  _index_first
 		lda  (c64.SCRATCH_ZPWORD1),y
 		pha
-		ldy  _right_index
+		ldy  _index_second
 		lda  (c64.SCRATCH_ZPWORD1),y
-		ldy  _left_index
+		ldy  _index_first
 		sta  (c64.SCRATCH_ZPWORD1),y
 		pla
-		ldy  _right_index
+		ldy  _index_second
 		sta  (c64.SCRATCH_ZPWORD1),y
-		dec  _right_index
-		dec  _right_index
-		inc  _left_index
-		inc  _left_index
-		ldy  c64.SCRATCH_ZPREG
-		dey
+		dec  _index_second
+		dec  _index_second
+		inc  _index_first
+		inc  _index_first
+		dec  _loop_count
 		bne  _loop_hi
 
 		rts

compiler/res/version.txt

@@ -1 +1 @@
-1.70
+1.81

compiler/src/prog8/CompilerMain.kt

@@ -2,7 +2,8 @@ package prog8
 
 import kotlinx.cli.*
 import prog8.ast.base.AstException
-import prog8.compiler.*
+import prog8.compiler.CompilationResult
+import prog8.compiler.compileProgram
 import prog8.compiler.target.CompilationTarget
 import prog8.compiler.target.c64.C64MachineDefinition
 import prog8.compiler.target.c64.Petscii
@@ -55,8 +56,12 @@ private fun compileMain(args: Array<String>) {
             with(CompilationTarget) {
                 name = "c64"
                 machine = C64MachineDefinition
-                encodeString = { str -> Petscii.encodePetscii(str, true) }
-                decodeString = { bytes -> Petscii.decodePetscii(bytes, true) }
+                encodeString = { str, altEncoding ->
+                    if(altEncoding) Petscii.encodeScreencode(str, true) else Petscii.encodePetscii(str, true)
+                }
+                decodeString = { bytes, altEncoding ->
+                    if(altEncoding) Petscii.decodeScreencode(bytes, true) else Petscii.decodePetscii(bytes, true)
+                }
                 asmGenerator = ::AsmGen
             }
         }

compiler/src/prog8/ast/AstToSourceCode.kt

@@ -331,6 +331,11 @@ class AstToSourceCode(val output: (text: String) -> Unit, val program: Program):
         whileLoop.body.accept(this)
     }
 
+    override fun visit(foreverLoop: ForeverLoop) {
+        output("forever ")
+        foreverLoop.body.accept(this)
+    }
+
     override fun visit(repeatLoop: RepeatLoop) {
         output("repeat ")
         repeatLoop.body.accept(this)

compiler/src/prog8/ast/AstToplevel.kt

@@ -158,6 +158,30 @@ interface INameScope {
         if(!statements.remove(stmt))
             throw FatalAstException("stmt to remove wasn't found in scope")
     }
+
+    fun getAllLabels(label: String): List<Label> {
+        val result = mutableListOf<Label>()
+
+        fun find(scope: INameScope) {
+            scope.statements.forEach {
+                when(it) {
+                    is Label -> result.add(it)
+                    is INameScope -> find(it)
+                    is IfStatement -> {
+                        find(it.truepart)
+                        find(it.elsepart)
+                    }
+                    is RepeatLoop -> find(it.body)
+                    is ForeverLoop -> find(it.body)
+                    is WhileLoop -> find(it.body)
+                    is WhenStatement -> it.choices.forEach { choice->find(choice.statements) }
+                }
+            }
+        }
+
+        find(this)
+        return result
+    }
 }
 
 interface IAssignable {
@@ -246,7 +270,7 @@ class GlobalNamespace(val modules: List<Module>): Node, INameScope {
         return when (val stmt = localContext.definingModule().lookup(scopedName, localContext)) {
             is Label, is VarDecl, is Block, is Subroutine -> stmt
             null -> null
-            else -> throw NameError("wrong identifier target: $stmt", stmt.position)
+            else -> throw SyntaxError("wrong identifier target: $stmt", stmt.position)
         }
     }
 }

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

@@ -19,13 +19,13 @@ import java.nio.file.Path
 
 private data class NumericLiteral(val number: Number, val datatype: DataType)
 
-
-fun prog8Parser.ModuleContext.toAst(name: String, isLibrary: Boolean, source: Path) : Module {
+internal fun prog8Parser.ModuleContext.toAst(name: String, isLibrary: Boolean, source: Path) : Module {
     val nameWithoutSuffix = if(name.endsWith(".p8")) name.substringBeforeLast('.') else name
-    return Module(nameWithoutSuffix, modulestatement().asSequence().map { it.toAst(isLibrary) }.toMutableList(), toPosition(), isLibrary, source)
+    val directives = this.directive().map { it.toAst() }
+    val blocks = this.block().map { it.toAst(isLibrary) }
+    return Module(nameWithoutSuffix, (directives + blocks).toMutableList(), toPosition(), isLibrary, source)
 }
 
-
 private fun ParserRuleContext.toPosition() : Position {
     val customTokensource = this.start.tokenSource as? CustomLexer
     val filename =
@@ -38,27 +38,23 @@ private fun ParserRuleContext.toPosition() : Position {
     return Position(filename, start.line, start.charPositionInLine, stop.charPositionInLine + stop.text.length)
 }
 
-
-private fun prog8Parser.ModulestatementContext.toAst(isInLibrary: Boolean) : Statement {
-    val directive = directive()?.toAst()
-    if(directive!=null) return directive
-
-    val block = block()?.toAst(isInLibrary)
-    if(block!=null) return block
-
-    throw FatalAstException(text)
+private fun prog8Parser.BlockContext.toAst(isInLibrary: Boolean) : Statement {
+    val blockstatements = block_statement().map {
+        when {
+            it.variabledeclaration()!=null -> it.variabledeclaration().toAst()
+            it.subroutinedeclaration()!=null -> it.subroutinedeclaration().toAst()
+            it.directive()!=null -> it.directive().toAst()
+            it.inlineasm()!=null -> it.inlineasm().toAst()
+            else -> throw FatalAstException("weird block statement $it")
+        }
+    }
+    return Block(identifier().text, integerliteral()?.toAst()?.number?.toInt(), blockstatements.toMutableList(), isInLibrary, toPosition())
 }
 
-
-private fun prog8Parser.BlockContext.toAst(isInLibrary: Boolean) : Statement =
-        Block(identifier().text, integerliteral()?.toAst()?.number?.toInt(), statement_block().toAst(), isInLibrary, toPosition())
-
-
 private fun prog8Parser.Statement_blockContext.toAst(): MutableList<Statement> =
         statement().asSequence().map { it.toAst() }.toMutableList()
 
-
-private fun prog8Parser.StatementContext.toAst() : Statement {
+private fun prog8Parser.VariabledeclarationContext.toAst() : Statement {
     vardecl()?.let { return it.toAst() }
 
     varinitializer()?.let {
@@ -66,7 +62,7 @@ private fun prog8Parser.StatementContext.toAst() : Statement {
         return VarDecl(
                 VarDeclType.VAR,
                 vd.datatype()?.toAst() ?: DataType.STRUCT,
-                if(vd.ZEROPAGE() != null) ZeropageWish.PREFER_ZEROPAGE else ZeropageWish.DONTCARE,
+                if (vd.ZEROPAGE() != null) ZeropageWish.PREFER_ZEROPAGE else ZeropageWish.DONTCARE,
                 vd.arrayindex()?.toAst(),
                 vd.varname.text,
                 null,
@@ -114,7 +110,7 @@ private fun prog8Parser.StatementContext.toAst() : Statement {
         return VarDecl(
                 VarDeclType.CONST,
                 vd.datatype()?.toAst() ?: DataType.STRUCT,
-                if(vd.ZEROPAGE() != null) ZeropageWish.PREFER_ZEROPAGE else ZeropageWish.DONTCARE,
+                if (vd.ZEROPAGE() != null) ZeropageWish.PREFER_ZEROPAGE else ZeropageWish.DONTCARE,
                 vd.arrayindex()?.toAst(),
                 vd.varname.text,
                 null,
@@ -131,7 +127,7 @@ private fun prog8Parser.StatementContext.toAst() : Statement {
         return VarDecl(
                 VarDeclType.MEMORY,
                 vd.datatype()?.toAst() ?: DataType.STRUCT,
-                if(vd.ZEROPAGE() != null) ZeropageWish.PREFER_ZEROPAGE else ZeropageWish.DONTCARE,
+                if (vd.ZEROPAGE() != null) ZeropageWish.PREFER_ZEROPAGE else ZeropageWish.DONTCARE,
                 vd.arrayindex()?.toAst(),
                 vd.varname.text,
                 null,
@@ -142,6 +138,28 @@ private fun prog8Parser.StatementContext.toAst() : Statement {
         )
     }
 
+    structdecl()?.let {
+        return StructDecl(it.identifier().text,
+                it.vardecl().map { vd->vd.toAst() }.toMutableList(),
+                toPosition())
+    }
+
+    throw FatalAstException("weird variable decl $this")
+}
+
+private fun prog8Parser.SubroutinedeclarationContext.toAst() : Subroutine {
+    return when {
+        subroutine()!=null -> subroutine().toAst()
+        asmsubroutine()!=null -> asmsubroutine().toAst()
+        romsubroutine()!=null -> romsubroutine().toAst()
+        else -> throw FatalAstException("weird subroutine decl $this")
+    }
+}
+
+private fun prog8Parser.StatementContext.toAst() : Statement {
+    val vardecl = variabledeclaration()?.toAst()
+    if(vardecl!=null) return vardecl
+
     assignment()?.let {
         return Assignment(it.assign_target().toAst(), null, it.expression().toAst(), it.toPosition())
     }
@@ -175,8 +193,8 @@ private fun prog8Parser.StatementContext.toAst() : Statement {
     val returnstmt = returnstmt()?.toAst()
     if(returnstmt!=null) return returnstmt
 
-    val sub = subroutine()?.toAst()
-    if(sub!=null) return sub
+    val subroutine = subroutinedeclaration()?.toAst()
+    if(subroutine!=null) return subroutine
 
     val asm = inlineasm()?.toAst()
     if(asm!=null) return asm
@@ -193,40 +211,54 @@ private fun prog8Parser.StatementContext.toAst() : Statement {
     val whileloop = whileloop()?.toAst()
     if(whileloop!=null) return whileloop
 
+    val foreverloop = foreverloop()?.toAst()
+    if(foreverloop!=null) return foreverloop
+
     val breakstmt = breakstmt()?.toAst()
     if(breakstmt!=null) return breakstmt
 
     val continuestmt = continuestmt()?.toAst()
     if(continuestmt!=null) return continuestmt
 
-    val asmsubstmt = asmsubroutine()?.toAst()
-    if(asmsubstmt!=null) return asmsubstmt
-
     val whenstmt = whenstmt()?.toAst()
     if(whenstmt!=null) return whenstmt
 
-    structdecl()?.let {
-        return StructDecl(it.identifier().text,
-                it.vardecl().map { vd->vd.toAst() }.toMutableList(),
-                toPosition())
-    }
-
     throw FatalAstException("unprocessed source text (are we missing ast conversion rules for parser elements?): $text")
 }
 
-private fun prog8Parser.AsmsubroutineContext.toAst(): Statement {
+private fun prog8Parser.AsmsubroutineContext.toAst(): Subroutine {
+    val subdecl = asmsub_decl().toAst()
+    val statements = statement_block()?.toAst() ?: mutableListOf()
+    return Subroutine(subdecl.name, subdecl.parameters, subdecl.returntypes,
+            subdecl.asmParameterRegisters, subdecl.asmReturnvaluesRegisters,
+            subdecl.asmClobbers, null, true, statements, toPosition())
+}
+
+private fun prog8Parser.RomsubroutineContext.toAst(): Subroutine {
+    val subdecl = asmsub_decl().toAst()
+    val address = integerliteral().toAst().number.toInt()
+    return Subroutine(subdecl.name, subdecl.parameters, subdecl.returntypes,
+            subdecl.asmParameterRegisters, subdecl.asmReturnvaluesRegisters,
+            subdecl.asmClobbers, address, true, mutableListOf(), toPosition())
+}
+
+private class AsmsubDecl(val name: String,
+                         val parameters: List<SubroutineParameter>,
+                         val returntypes: List<DataType>,
+                         val asmParameterRegisters: List<RegisterOrStatusflag>,
+                         val asmReturnvaluesRegisters: List<RegisterOrStatusflag>,
+                         val asmClobbers: Set<Register>)
+
+private fun prog8Parser.Asmsub_declContext.toAst(): AsmsubDecl {
     val name = identifier().text
-    val address = asmsub_address()?.address?.toAst()?.number?.toInt()
     val params = asmsub_params()?.toAst() ?: emptyList()
     val returns = asmsub_returns()?.toAst() ?: emptyList()
+    val clobbers = asmsub_clobbers()?.clobber()?.toAst() ?: emptySet()
     val normalParameters = params.map { SubroutineParameter(it.name, it.type, it.position) }
-    val normalReturnvalues = returns.map { it.type }
+    val normalReturntypes = returns.map { it.type }
     val paramRegisters = params.map { RegisterOrStatusflag(it.registerOrPair, it.statusflag, it.stack) }
     val returnRegisters = returns.map { RegisterOrStatusflag(it.registerOrPair, it.statusflag, it.stack) }
-    val clobbers = asmsub_clobbers()?.clobber()?.toAst() ?: emptySet()
-    val statements = statement_block()?.toAst() ?: mutableListOf()
-    return Subroutine(name, normalParameters, normalReturnvalues,
-            paramRegisters, returnRegisters, clobbers, address, true, statements, toPosition())
+    return AsmsubDecl(name, normalParameters, normalReturntypes, paramRegisters, returnRegisters, clobbers)
 }
 
 private class AsmSubroutineParameter(name: String,
@@ -245,7 +277,6 @@ private class AsmSubroutineReturn(val type: DataType,
 private fun prog8Parser.ClobberContext.toAst(): Set<Register>
         = this.register().asSequence().map { it.toAst() }.toSet()
 
-
 private fun prog8Parser.Asmsub_returnsContext.toAst(): List<AsmSubroutineReturn>
         = asmsub_return().map { AsmSubroutineReturn(it.datatype().toAst(), it.registerorpair()?.toAst(), it.statusregister()?.toAst(), !it.stack?.text.isNullOrEmpty(), toPosition()) }
 
@@ -259,10 +290,8 @@ private fun prog8Parser.Asmsub_paramsContext.toAst(): List<AsmSubroutineParamete
             !it.stack?.text.isNullOrEmpty(), toPosition())
 }
 
-
 private fun prog8Parser.StatusregisterContext.toAst() = Statusflag.valueOf(text)
 
-
 private fun prog8Parser.Functioncall_stmtContext.toAst(): Statement {
     val void = this.VOID() != null
     val location = scoped_identifier().toAst()
@@ -272,7 +301,6 @@ private fun prog8Parser.Functioncall_stmtContext.toAst(): Statement {
         FunctionCallStatement(location, expression_list().toAst().toMutableList(), void, toPosition())
 }
 
-
 private fun prog8Parser.FunctioncallContext.toAst(): FunctionCall {
     val location = scoped_identifier().toAst()
     return if(expression_list() == null)
@@ -281,11 +309,9 @@ private fun prog8Parser.FunctioncallContext.toAst(): FunctionCall {
         FunctionCall(location, expression_list().toAst().toMutableList(), toPosition())
 }
 
-
 private fun prog8Parser.InlineasmContext.toAst() =
         InlineAssembly(INLINEASMBLOCK().text, toPosition())
 
-
 private fun prog8Parser.ReturnstmtContext.toAst() : Return {
     return Return(expression()?.toAst(), toPosition())
 }
@@ -296,11 +322,9 @@ private fun prog8Parser.UnconditionaljumpContext.toAst(): Jump {
     return Jump(address, identifier, null, toPosition())
 }
 
-
 private fun prog8Parser.LabeldefContext.toAst(): Statement =
         Label(children[0].text, toPosition())
 
-
 private fun prog8Parser.SubroutineContext.toAst() : Subroutine {
     return Subroutine(identifier().text,
             sub_params()?.toAst() ?: emptyList(),
@@ -319,14 +343,12 @@ private fun prog8Parser.Sub_return_partContext.toAst(): List<DataType> {
     return returns.datatype().map { it.toAst() }
 }
 
-
 private fun prog8Parser.Sub_paramsContext.toAst(): List<SubroutineParameter> =
         vardecl().map {
             val datatype = it.datatype()?.toAst() ?: DataType.STRUCT
             SubroutineParameter(it.varname.text, datatype, it.toPosition())
         }
 
-
 private fun prog8Parser.Assign_targetContext.toAst() : AssignTarget {
     val register = register()?.toAst()
     val identifier = scoped_identifier()
@@ -345,18 +367,19 @@ private fun prog8Parser.DatatypeContext.toAst() = DataType.valueOf(text.toUpperC
 
 private fun prog8Parser.RegisterorpairContext.toAst() = RegisterOrPair.valueOf(text.toUpperCase())
 
-
 private fun prog8Parser.ArrayindexContext.toAst() : ArrayIndex =
         ArrayIndex(expression().toAst(), toPosition())
 
-
 private fun prog8Parser.DirectiveContext.toAst() : Directive =
         Directive(directivename.text, directivearg().map { it.toAst() }, toPosition())
 
+private fun prog8Parser.DirectiveargContext.toAst() : DirectiveArg {
+    val str = stringliteral()
+    if(str?.ALT_STRING_ENCODING() != null)
+        throw AstException("${toPosition()} can't use alternate string encodings for directive arguments")
 
-private fun prog8Parser.DirectiveargContext.toAst() : DirectiveArg =
-        DirectiveArg(stringliteral()?.text, identifier()?.text, integerliteral()?.toAst()?.number?.toInt(), toPosition())
-
+    return DirectiveArg(stringliteral()?.text, identifier()?.text, integerliteral()?.toAst()?.number?.toInt(), toPosition())
+}
 
 private fun prog8Parser.IntegerliteralContext.toAst(): NumericLiteral {
     fun makeLiteral(text: String, radix: Int, forceWord: Boolean): NumericLiteral {
@@ -409,7 +432,6 @@ private fun prog8Parser.IntegerliteralContext.toAst(): NumericLiteral {
     }
 }
 
-
 private fun prog8Parser.ExpressionContext.toAst() : Expression {
 
     val litval = literalvalue()
@@ -430,11 +452,13 @@ private fun prog8Parser.ExpressionContext.toAst() : Expression {
                     else -> throw FatalAstException("invalid datatype for numeric literal")
                 }
                 litval.floatliteral()!=null -> NumericLiteralValue(DataType.FLOAT, litval.floatliteral().toAst(), litval.toPosition())
-                litval.stringliteral()!=null -> StringLiteralValue(unescape(litval.stringliteral().text, litval.toPosition()), litval.toPosition())
+                litval.stringliteral()!=null -> litval.stringliteral().toAst()
                 litval.charliteral()!=null -> {
                     try {
+                        val cc=litval.charliteral()
                         NumericLiteralValue(DataType.UBYTE, CompilationTarget.encodeString(
-                                unescape(litval.charliteral().text, litval.toPosition()))[0], litval.toPosition())
+                                unescape(litval.charliteral().SINGLECHAR().text, litval.toPosition()),
+                                litval.charliteral().ALT_STRING_ENCODING()!=null)[0], litval.toPosition())
                     } catch (ce: CharConversionException) {
                         throw SyntaxError(ce.message ?: ce.toString(), litval.toPosition())
                     }
@@ -443,7 +467,7 @@ private fun prog8Parser.ExpressionContext.toAst() : Expression {
                     val array = litval.arrayliteral().toAst()
                     // the actual type of the arraysize can not yet be determined here (missing namespace & heap)
                     // the ConstantFold takes care of that and converts the type if needed.
-                    ArrayLiteralValue(DataType.ARRAY_UB, array, position = litval.toPosition())
+                    ArrayLiteralValue(InferredTypes.InferredType.unknown(), array, position = litval.toPosition())
                 }
                 litval.structliteral()!=null -> {
                     val values = litval.structliteral().expression().map { it.toAst() }
@@ -470,7 +494,8 @@ private fun prog8Parser.ExpressionContext.toAst() : Expression {
     if(funcall!=null) return funcall
 
     if (rangefrom!=null && rangeto!=null) {
-        val step = rangestep?.toAst() ?: NumericLiteralValue(DataType.UBYTE, 1, toPosition())
+        val defaultstep = if(rto.text == "to") 1 else -1
+        val step = rangestep?.toAst() ?: NumericLiteralValue(DataType.UBYTE, defaultstep, toPosition())
         return RangeExpr(rangefrom.toAst(), rangeto.toAst(), step, toPosition())
     }
 
@@ -492,6 +517,8 @@ private fun prog8Parser.ExpressionContext.toAst() : Expression {
     throw FatalAstException(text)
 }
 
+private fun prog8Parser.StringliteralContext.toAst(): StringLiteralValue =
+    StringLiteralValue(unescape(this.STRING().text, toPosition()), ALT_STRING_ENCODING()!=null, toPosition())
 
 private fun prog8Parser.ArrayindexedContext.toAst(): ArrayIndexedExpression {
     return ArrayIndexedExpression(scoped_identifier().toAst(),
@@ -499,28 +526,22 @@ private fun prog8Parser.ArrayindexedContext.toAst(): ArrayIndexedExpression {
             toPosition())
 }
 
-
 private fun prog8Parser.Expression_listContext.toAst() = expression().map{ it.toAst() }
 
-
 private fun prog8Parser.IdentifierContext.toAst() : IdentifierReference =
         IdentifierReference(listOf(text), toPosition())
 
-
 private fun prog8Parser.Scoped_identifierContext.toAst() : IdentifierReference =
         IdentifierReference(NAME().map { it.text }, toPosition())
 
-
 private fun prog8Parser.FloatliteralContext.toAst() = text.toDouble()
 
-
 private fun prog8Parser.BooleanliteralContext.toAst() = when(text) {
     "true" -> true
     "false" -> false
     else -> throw FatalAstException(text)
 }
 
-
 private fun prog8Parser.ArrayliteralContext.toAst() : Array<Expression> =
         expression().map { it.toAst() }.toTypedArray()
 
@@ -538,7 +559,6 @@ private fun prog8Parser.Else_partContext.toAst(): MutableList<Statement> {
     return statement_block()?.toAst() ?: mutableListOf(statement().toAst())
 }
 
-
 private fun prog8Parser.Branch_stmtContext.toAst(): BranchStatement {
     val branchcondition = branchcondition().toAst()
     val trueStatements = statement_block()?.toAst() ?: mutableListOf(statement().toAst())
@@ -551,7 +571,6 @@ private fun prog8Parser.Branch_stmtContext.toAst(): BranchStatement {
 
 private fun prog8Parser.BranchconditionContext.toAst() = BranchCondition.valueOf(text.substringAfter('_').toUpperCase())
 
-
 private fun prog8Parser.ForloopContext.toAst(): ForLoop {
     val loopregister = register()?.toAst()
     val loopvar = identifier()?.toAst()
@@ -564,12 +583,10 @@ private fun prog8Parser.ForloopContext.toAst(): ForLoop {
     return ForLoop(loopregister, loopvar, iterable, scope, toPosition())
 }
 
-
 private fun prog8Parser.ContinuestmtContext.toAst() = Continue(toPosition())
 
 private fun prog8Parser.BreakstmtContext.toAst() = Break(toPosition())
 
-
 private fun prog8Parser.WhileloopContext.toAst(): WhileLoop {
     val condition = expression().toAst()
     val statements = statement_block()?.toAst() ?: mutableListOf(statement().toAst())
@@ -578,6 +595,12 @@ private fun prog8Parser.WhileloopContext.toAst(): WhileLoop {
     return WhileLoop(condition, scope, toPosition())
 }
 
+private fun prog8Parser.ForeverloopContext.toAst(): ForeverLoop {
+    val statements = statement_block()?.toAst() ?: mutableListOf(statement().toAst())
+    val scope = AnonymousScope(statements, statement_block()?.toPosition()
+            ?: statement().toPosition())
+    return ForeverLoop(scope, toPosition())
+}
 
 private fun prog8Parser.RepeatloopContext.toAst(): RepeatLoop {
     val untilCondition = expression().toAst()
@@ -643,4 +666,3 @@ internal fun unescape(str: String, position: Position): String {
     }
     return result.joinToString("")
 }
-

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

@@ -126,6 +126,13 @@ val ArrayElementTypes = mapOf(
         DataType.ARRAY_W to DataType.WORD,
         DataType.ARRAY_UW to DataType.UWORD,
         DataType.ARRAY_F to DataType.FLOAT)
+val ElementArrayTypes = mapOf(
+        DataType.BYTE to DataType.ARRAY_B,
+        DataType.UBYTE to DataType.ARRAY_UB,
+        DataType.WORD to DataType.ARRAY_W,
+        DataType.UWORD to DataType.ARRAY_UW,
+        DataType.FLOAT to DataType.ARRAY_F
+)
 
 // find the parent node of a specific type or interface
 // (useful to figure out in what namespace/block something is defined, etc)

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

@@ -3,35 +3,42 @@ package prog8.ast.base
 import prog8.parser.ParsingFailedError
 
 
-fun printErrors(errors: List<Any>, moduleName: String) {
-    val reportedMessages = mutableSetOf<String>()
-    System.err.print("\u001b[91m")  // bright red
-    errors.forEach {
-        val msg = it.toString()
-        if(msg !in reportedMessages) {
-            System.err.println(msg)
-            reportedMessages.add(msg)
-        }
+class ErrorReporter {
+    private enum class MessageSeverity {
+        WARNING,
+        ERROR
     }
-    System.err.print("\u001b[0m")  // reset color
-    if(reportedMessages.isNotEmpty())
-        throw ParsingFailedError("There are ${reportedMessages.size} errors in module '$moduleName'.")
-}
+    private class CompilerMessage(val severity: MessageSeverity, val message: String, val position: Position?)
 
+    private val messages = mutableListOf<CompilerMessage>()
+    private val alreadyReportedMessages = mutableSetOf<String>()
 
-fun printWarning(msg: String, position: Position, detailInfo: String?=null) {
-    print("\u001b[93m")  // bright yellow
-    print("$position Warning: $msg")
-    if(detailInfo==null)
-        print("\n")
-    else
-        println(": $detailInfo\n")
-    print("\u001b[0m")  // normal
-}
+    fun err(msg: String, position: Position?) = messages.add(CompilerMessage(MessageSeverity.ERROR, msg, position))
+    fun warn(msg: String, position: Position?) = messages.add(CompilerMessage(MessageSeverity.WARNING, msg, position))
 
+    fun handle() {
+        var numErrors = 0
+        var numWarnings = 0
+        messages.forEach {
+            when(it.severity) {
+                MessageSeverity.ERROR -> System.err.print("\u001b[91m")  // bright red
+                MessageSeverity.WARNING -> System.err.print("\u001b[93m")  // bright yellow
+            }
+            val msg = "${it.position} ${it.severity} ${it.message}".trim()
+            if(msg !in alreadyReportedMessages) {
+                System.err.println(msg)
+                alreadyReportedMessages.add(msg)
+                when(it.severity) {
+                    MessageSeverity.WARNING -> numWarnings++
+                    MessageSeverity.ERROR -> numErrors++
+                }
+            }
+            System.err.print("\u001b[0m")  // reset color
+        }
+        messages.clear()
+        if(numErrors>0)
+            throw ParsingFailedError("There are $numErrors errors and $numWarnings warnings.")
+    }
 
-fun printWarning(msg: String) {
-    print("\u001b[93m")  // bright yellow
-    print("Warning: $msg")
-    print("\u001b[0m\n")  // normal
+    fun isEmpty() = messages.isEmpty()
 }

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

@@ -6,17 +6,13 @@ class FatalAstException (override var message: String) : Exception(message)
 
 open class AstException (override var message: String) : Exception(message)
 
-class SyntaxError(override var message: String, val position: Position) : AstException(message) {
+open class SyntaxError(override var message: String, val position: Position) : AstException(message) {
     override fun toString() = "$position Syntax error: $message"
 }
 
-open class NameError(override var message: String, val position: Position) : AstException(message) {
-    override fun toString() = "$position Name error: $message"
-}
-
 class ExpressionError(message: String, val position: Position) : AstException(message) {
     override fun toString() = "$position Error: $message"
 }
 
 class UndefinedSymbolError(symbol: IdentifierReference)
-    : NameError("undefined symbol: ${symbol.nameInSource.joinToString(".")}", symbol.position)
+    : SyntaxError("undefined symbol: ${symbol.nameInSource.joinToString(".")}", symbol.position)

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

@@ -17,17 +17,15 @@ internal fun Program.removeNopsFlattenAnonScopes() {
 }
 
 
-internal fun Program.checkValid(compilerOptions: CompilationOptions) {
-    val checker = AstChecker(this, compilerOptions)
+internal fun Program.checkValid(compilerOptions: CompilationOptions, errors: ErrorReporter) {
+    val checker = AstChecker(this, compilerOptions, errors)
     checker.visit(this)
-    printErrors(checker.result(), name)
 }
 
 
-internal fun Program.anonscopeVarsCleanup() {
-    val mover = AnonymousScopeVarsCleanup(this)
+internal fun Program.anonscopeVarsCleanup(errors: ErrorReporter) {
+    val mover = AnonymousScopeVarsCleanup(errors)
     mover.visit(this)
-    printErrors(mover.result(), name)
 }
 
 
@@ -39,31 +37,34 @@ internal fun Program.reorderStatements() {
     checker.visit(this)
 }
 
-internal fun Program.addTypecasts() {
-    val caster = TypecastsAdder(this)
+internal fun Program.addTypecasts(errors: ErrorReporter) {
+    val caster = TypecastsAdder(this, errors)
     caster.visit(this)
 }
 
-internal fun Module.checkImportedValid() {
-    val checker = ImportedModuleDirectiveRemover()
+internal fun Module.checkImportedValid(errors: ErrorReporter) {
+    val checker = ImportedModuleDirectiveRemover(errors)
     checker.visit(this)
-    printErrors(checker.result(), name)
 }
 
-internal fun Program.checkRecursion() {
-    val checker = AstRecursionChecker(namespace)
+internal fun Program.checkRecursion(errors: ErrorReporter) {
+    val checker = AstRecursionChecker(namespace, errors)
     checker.visit(this)
-    printErrors(checker.result(), name)
+    checker.processMessages(name)
 }
 
 
-internal fun Program.checkIdentifiers() {
-    val checker = AstIdentifiersChecker(this)
+internal fun Program.checkIdentifiers(errors: ErrorReporter) {
+    val checker = AstIdentifiersChecker(this, errors)
     checker.visit(this)
 
     if(modules.map {it.name}.toSet().size != modules.size) {
         throw FatalAstException("modules should all be unique")
     }
+}
 
-    printErrors(checker.result(), name)
+
+internal fun Program.makeForeverLoops() {
+    val checker = MakeForeverLoops()
+    checker.visit(this)
 }

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

@@ -5,15 +5,12 @@ import prog8.ast.antlr.escape
 import prog8.ast.base.*
 import prog8.ast.processing.IAstModifyingVisitor
 import prog8.ast.processing.IAstVisitor
-import prog8.ast.statements.ArrayIndex
-import prog8.ast.statements.BuiltinFunctionStatementPlaceholder
-import prog8.ast.statements.Subroutine
-import prog8.ast.statements.VarDecl
+import prog8.ast.statements.*
 import prog8.compiler.target.CompilationTarget
 import prog8.functions.BuiltinFunctions
 import prog8.functions.NotConstArgumentException
 import prog8.functions.builtinFunctionReturnType
-import java.util.Objects
+import java.util.*
 import kotlin.math.abs
 
 
@@ -430,6 +427,7 @@ class StructLiteralValue(var values: List<Expression>,
 private var heapIdSequence = 0   // unique ids for strings and arrays "on the heap"
 
 class StringLiteralValue(val value: String,
+                         val altEncoding: Boolean,          // such as: screencodes instead of Petscii for the C64
                          override val position: Position) : Expression() {
     override lateinit var parent: Node
 
@@ -445,15 +443,15 @@ class StringLiteralValue(val value: String,
     override fun toString(): String = "'${escape(value)}'"
     override fun inferType(program: Program): InferredTypes.InferredType = InferredTypes.knownFor(DataType.STR)
     operator fun compareTo(other: StringLiteralValue): Int = value.compareTo(other.value)
-    override fun hashCode(): Int = value.hashCode()
+    override fun hashCode(): Int = Objects.hash(value, altEncoding)
     override fun equals(other: Any?): Boolean {
         if(other==null || other !is StringLiteralValue)
             return false
-        return value==other.value
+        return value==other.value && altEncoding == other.altEncoding
     }
 }
 
-class ArrayLiteralValue(val type: DataType,     // only array types
+class ArrayLiteralValue(val type: InferredTypes.InferredType,     // inferred because not all array literals hava a known type yet
                         val value: Array<Expression>,
                         override val position: Position) : Expression() {
     override lateinit var parent: Node
@@ -469,7 +467,8 @@ class ArrayLiteralValue(val type: DataType,     // only array types
     override fun accept(visitor: IAstModifyingVisitor) = visitor.visit(this)
     override fun accept(visitor: IAstVisitor) = visitor.visit(this)
     override fun toString(): String = "$value"
-    override fun inferType(program: Program): InferredTypes.InferredType = InferredTypes.knownFor(type)
+    override fun inferType(program: Program): InferredTypes.InferredType = if(type.isUnknown) type else guessDatatype(program)
+
     operator fun compareTo(other: ArrayLiteralValue): Int = throw ExpressionError("cannot order compare arrays", position)
     override fun hashCode(): Int = Objects.hash(value, type)
     override fun equals(other: Any?): Boolean {
@@ -478,8 +477,36 @@ class ArrayLiteralValue(val type: DataType,     // only array types
         return type==other.type && value.contentEquals(other.value)
     }
 
+    fun guessDatatype(program: Program): InferredTypes.InferredType {
+        // Educated guess of the desired array literal's datatype.
+        // If it's inside a for loop, assume the data type of the loop variable is what we want.
+        val forloop = parent as? ForLoop
+        if(forloop != null)  {
+            val loopvarDt = forloop.loopVarDt(program)
+            if(loopvarDt.isKnown) {
+                return if(loopvarDt.typeOrElse(DataType.STRUCT) !in ElementArrayTypes)
+                    InferredTypes.InferredType.unknown()
+                else
+                    InferredTypes.InferredType.known(ElementArrayTypes.getValue(loopvarDt.typeOrElse(DataType.STRUCT)))
+            }
+        }
+
+        // otherwise, select the "biggegst" datatype based on the elements in the array.
+        val datatypesInArray = value.map { it.inferType(program) }
+        require(datatypesInArray.isNotEmpty() && datatypesInArray.all { it.isKnown }) { "can't determine type of empty array" }
+        val dts = datatypesInArray.map { it.typeOrElse(DataType.STRUCT) }
+        return when {
+            DataType.FLOAT in dts -> InferredTypes.InferredType.known(DataType.ARRAY_F)
+            DataType.WORD in dts -> InferredTypes.InferredType.known(DataType.ARRAY_W)
+            DataType.UWORD in dts -> InferredTypes.InferredType.known(DataType.ARRAY_UW)
+            DataType.BYTE in dts -> InferredTypes.InferredType.known(DataType.ARRAY_B)
+            DataType.UBYTE in dts -> InferredTypes.InferredType.known(DataType.ARRAY_UB)
+            else -> InferredTypes.InferredType.unknown()
+        }
+    }
+
     fun cast(targettype: DataType): ArrayLiteralValue? {
-        if(type==targettype)
+        if(type.istype(targettype))
             return this
         if(targettype in ArrayDatatypes) {
             val elementType = ArrayElementTypes.getValue(targettype)
@@ -498,7 +525,7 @@ class ArrayLiteralValue(val type: DataType,     // only array types
                     }
                 }
             }.toTypedArray()
-            return ArrayLiteralValue(targettype, castArray, position = position)
+            return ArrayLiteralValue(InferredTypes.InferredType.known(targettype), castArray, position = position)
         }
         return null    // invalid type conversion from $this to $targettype
     }
@@ -552,9 +579,9 @@ class RangeExpr(var from: Expression,
         val fromString = from as? StringLiteralValue
         val toString = to as? StringLiteralValue
         if(fromString!=null && toString!=null ) {
-            // string range -> int range over petscii values
-            fromVal = CompilationTarget.encodeString(fromString.value)[0].toInt()
-            toVal = CompilationTarget.encodeString(toString.value)[0].toInt()
+            // string range -> int range over character values
+            fromVal = CompilationTarget.encodeString(fromString.value, fromString.altEncoding)[0].toInt()
+            toVal = CompilationTarget.encodeString(toString.value, fromString.altEncoding)[0].toInt()
         } else {
             val fromLv = from as? NumericLiteralValue
             val toLv = to as? NumericLiteralValue

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

@@ -1,7 +1,7 @@
 package prog8.ast.expressions
 
-import java.util.Objects
 import prog8.ast.base.DataType
+import java.util.*
 
 
 object InferredTypes {

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

@@ -1,20 +1,14 @@
 package prog8.ast.processing
 
 import prog8.ast.Program
-import prog8.ast.base.AstException
-import prog8.ast.base.NameError
+import prog8.ast.base.ErrorReporter
 import prog8.ast.statements.AnonymousScope
 import prog8.ast.statements.Statement
 import prog8.ast.statements.VarDecl
 
-class AnonymousScopeVarsCleanup(val program: Program): IAstModifyingVisitor {
-    private val checkResult: MutableList<AstException> = mutableListOf()
+class AnonymousScopeVarsCleanup(private val errors: ErrorReporter): IAstModifyingVisitor {
     private val varsToMove: MutableMap<AnonymousScope, List<VarDecl>> = mutableMapOf()
 
-    fun result(): List<AstException> {
-        return checkResult
-    }
-
     override fun visit(program: Program) {
         varsToMove.clear()
         super.visit(program)
@@ -25,7 +19,7 @@ class AnonymousScopeVarsCleanup(val program: Program): IAstModifyingVisitor {
             decls.forEach {
                 val existing = existingVariables[it.name]
                 if (existing!=null) {
-                    checkResult.add(NameError("variable ${it.name} already defined in subroutine ${sub.name} at ${existing.position}", it.position))
+                    errors.err("variable ${it.name} already defined in subroutine ${sub.name} at ${existing.position}", it.position)
                     conflicts = true
                 }
             }

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

@@ -1,6 +1,5 @@
 package prog8.ast.processing
 
-import prog8.ast.IFunctionCall
 import prog8.ast.INameScope
 import prog8.ast.Module
 import prog8.ast.Program
@@ -13,27 +12,23 @@ import prog8.functions.BuiltinFunctions
 import java.io.File
 
 internal class AstChecker(private val program: Program,
-                          private val compilerOptions: CompilationOptions) : IAstVisitor {
-    private val checkResult: MutableList<AstException> = mutableListOf()
-
-    fun result(): List<AstException> {
-        return checkResult
-    }
+                          private val compilerOptions: CompilationOptions,
+                          private val errors: ErrorReporter) : IAstVisitor {
 
     override fun visit(program: Program) {
         assert(program === this.program)
         // there must be a single 'main' block with a 'start' subroutine for the program entry point.
         val mainBlocks = program.modules.flatMap { it.statements }.filter { b -> b is Block && b.name=="main" }.map { it as Block }
         if(mainBlocks.size>1)
-            checkResult.add(SyntaxError("more than one 'main' block", mainBlocks[0].position))
+            errors.err("more than one 'main' block", mainBlocks[0].position)
 
         for(mainBlock in mainBlocks) {
             val startSub = mainBlock.subScopes()["start"] as? Subroutine
             if (startSub == null) {
-                checkResult.add(SyntaxError("missing program entrypoint ('start' subroutine in 'main' block)", mainBlock.position))
+                errors.err("missing program entrypoint ('start' subroutine in 'main' block)", mainBlock.position)
             } else {
                 if (startSub.parameters.isNotEmpty() || startSub.returntypes.isNotEmpty())
-                    checkResult.add(SyntaxError("program entrypoint subroutine can't have parameters and/or return values", startSub.position))
+                    errors.err("program entrypoint subroutine can't have parameters and/or return values", startSub.position)
             }
 
             // the main module cannot contain 'regular' statements (they will never be executed!)
@@ -50,7 +45,7 @@ internal class AstChecker(private val program: Program,
                     else -> false
                 }
                 if (!ok) {
-                    checkResult.add(SyntaxError("main block contains regular statements, this is not allowed (they'll never get executed). Use subroutines.", statement.position))
+                    errors.err("main block contains regular statements, this is not allowed (they'll never get executed). Use subroutines.", statement.position)
                     break
                 }
             }
@@ -60,12 +55,12 @@ internal class AstChecker(private val program: Program,
         // which will be used as the 60hz irq routine in the vm if it's present
         val irqBlocks = program.modules.flatMap { it.statements }.filter { it is Block && it.name=="irq" }.map { it as Block }
         if(irqBlocks.size>1)
-            checkResult.add(SyntaxError("more than one 'irq' block", irqBlocks[0].position))
+            errors.err("more than one 'irq' block", irqBlocks[0].position)
         for(irqBlock in irqBlocks) {
             val irqSub = irqBlock.subScopes()["irq"] as? Subroutine
             if (irqSub != null) {
                 if (irqSub.parameters.isNotEmpty() || irqSub.returntypes.isNotEmpty())
-                    checkResult.add(SyntaxError("irq entrypoint subroutine can't have parameters and/or return values", irqSub.position))
+                    errors.err("irq entrypoint subroutine can't have parameters and/or return values", irqSub.position)
             }
         }
 
@@ -78,7 +73,7 @@ internal class AstChecker(private val program: Program,
         directives.filter { it.value.size > 1 }.forEach{ entry ->
             when(entry.key) {
                 "%output", "%launcher", "%zeropage", "%address" ->
-                    entry.value.mapTo(checkResult) { SyntaxError("directive can just occur once", it.position) }
+                    entry.value.forEach { errors.err("directive can just occur once", it.position) }
             }
         }
     }
@@ -90,18 +85,18 @@ internal class AstChecker(private val program: Program,
         }
 
         if(expectedReturnValues.isEmpty() && returnStmt.value!=null) {
-            checkResult.add(SyntaxError("invalid number of return values", returnStmt.position))
+            errors.err("invalid number of return values", returnStmt.position)
         }
         if(expectedReturnValues.isNotEmpty() && returnStmt.value==null) {
-            checkResult.add(SyntaxError("invalid number of return values", returnStmt.position))
+            errors.err("invalid number of return values", returnStmt.position)
         }
         if(expectedReturnValues.size==1 && returnStmt.value!=null) {
             val valueDt = returnStmt.value!!.inferType(program)
             if(!valueDt.isKnown) {
-                checkResult.add(ExpressionError("return value type mismatch", returnStmt.value!!.position))
+                errors.err("return value type mismatch", returnStmt.value!!.position)
             } else {
                 if (expectedReturnValues[0] != valueDt.typeOrElse(DataType.STRUCT))
-                    checkResult.add(ExpressionError("type $valueDt of return value doesn't match subroutine's return type", returnStmt.value!!.position))
+                    errors.err("type $valueDt of return value doesn't match subroutine's return type", returnStmt.value!!.position)
             }
         }
         super.visit(returnStmt)
@@ -109,53 +104,53 @@ internal class AstChecker(private val program: Program,
 
     override fun visit(ifStatement: IfStatement) {
         if(ifStatement.condition.inferType(program).typeOrElse(DataType.STRUCT) !in IntegerDatatypes)
-            checkResult.add(ExpressionError("condition value should be an integer type", ifStatement.condition.position))
+            errors.err("condition value should be an integer type", ifStatement.condition.position)
         super.visit(ifStatement)
     }
 
     override fun visit(forLoop: ForLoop) {
         if(forLoop.body.containsNoCodeNorVars())
-            printWarning("for loop body is empty", forLoop.position)
+            errors.warn("for loop body is empty", forLoop.position)
 
         val iterableDt = forLoop.iterable.inferType(program).typeOrElse(DataType.BYTE)
         if(iterableDt !in IterableDatatypes && forLoop.iterable !is RangeExpr) {
-            checkResult.add(ExpressionError("can only loop over an iterable type", forLoop.position))
+            errors.err("can only loop over an iterable type", forLoop.position)
         } else {
             if (forLoop.loopRegister != null) {
                 // loop register
                 if (iterableDt != DataType.ARRAY_UB && iterableDt != DataType.ARRAY_B && iterableDt != DataType.STR)
-                    checkResult.add(ExpressionError("register can only loop over bytes", forLoop.position))
+                    errors.err("register can only loop over bytes", forLoop.position)
                 if(forLoop.loopRegister!=Register.A)
-                    checkResult.add(ExpressionError("it's only possible to use A as a loop register", forLoop.position))
+                    errors.err("it's only possible to use A as a loop register", forLoop.position)
             } else {
                 // loop variable
                 val loopvar = forLoop.loopVar!!.targetVarDecl(program.namespace)
                 if(loopvar==null || loopvar.type== VarDeclType.CONST) {
-                    checkResult.add(SyntaxError("for loop requires a variable to loop with", forLoop.position))
+                    errors.err("for loop requires a variable to loop with", forLoop.position)
                 } else {
                     when (loopvar.datatype) {
                         DataType.UBYTE -> {
                             if(iterableDt!= DataType.UBYTE && iterableDt!= DataType.ARRAY_UB && iterableDt != DataType.STR)
-                                checkResult.add(ExpressionError("ubyte loop variable can only loop over unsigned bytes or strings", forLoop.position))
+                                errors.err("ubyte loop variable can only loop over unsigned bytes or strings", forLoop.position)
                         }
                         DataType.UWORD -> {
                             if(iterableDt!= DataType.UBYTE && iterableDt!= DataType.UWORD && iterableDt != DataType.STR &&
                                     iterableDt != DataType.ARRAY_UB && iterableDt!= DataType.ARRAY_UW)
-                                checkResult.add(ExpressionError("uword loop variable can only loop over unsigned bytes, words or strings", forLoop.position))
+                                errors.err("uword loop variable can only loop over unsigned bytes, words or strings", forLoop.position)
                         }
                         DataType.BYTE -> {
                             if(iterableDt!= DataType.BYTE && iterableDt!= DataType.ARRAY_B)
-                                checkResult.add(ExpressionError("byte loop variable can only loop over bytes", forLoop.position))
+                                errors.err("byte loop variable can only loop over bytes", forLoop.position)
                         }
                         DataType.WORD -> {
                             if(iterableDt!= DataType.BYTE && iterableDt!= DataType.WORD &&
                                     iterableDt != DataType.ARRAY_B && iterableDt!= DataType.ARRAY_W)
-                                checkResult.add(ExpressionError("word loop variable can only loop over bytes or words", forLoop.position))
+                                errors.err("word loop variable can only loop over bytes or words", forLoop.position)
                         }
                         DataType.FLOAT -> {
-                            checkResult.add(ExpressionError("for loop only supports integers", forLoop.position))
+                            errors.err("for loop only supports integers", forLoop.position)
                         }
-                        else -> checkResult.add(ExpressionError("loop variable must be numeric type", forLoop.position))
+                        else -> errors.err("loop variable must be numeric type", forLoop.position)
                     }
                 }
             }
@@ -169,18 +164,18 @@ internal class AstChecker(private val program: Program,
             val targetStatement = checkFunctionOrLabelExists(jump.identifier, jump)
             if(targetStatement!=null) {
                 if(targetStatement is BuiltinFunctionStatementPlaceholder)
-                    checkResult.add(SyntaxError("can't jump to a builtin function", jump.position))
+                    errors.err("can't jump to a builtin function", jump.position)
             }
         }
 
         if(jump.address!=null && (jump.address < 0 || jump.address > 65535))
-            checkResult.add(SyntaxError("jump address must be valid integer 0..\$ffff", jump.position))
+            errors.err("jump address must be valid integer 0..\$ffff", jump.position)
         super.visit(jump)
     }
 
     override fun visit(block: Block) {
         if(block.address!=null && (block.address<0 || block.address>65535)) {
-            checkResult.add(SyntaxError("block memory address must be valid integer 0..\$ffff", block.position))
+            errors.err("block memory address must be valid integer 0..\$ffff", block.position)
         }
 
         super.visit(block)
@@ -189,15 +184,13 @@ internal class AstChecker(private val program: Program,
     override fun visit(label: Label) {
         // scope check
         if(label.parent !is Block && label.parent !is Subroutine && label.parent !is AnonymousScope) {
-            checkResult.add(SyntaxError("Labels can only be defined in the scope of a block, a loop body, or within another subroutine", label.position))
+            errors.err("Labels can only be defined in the scope of a block, a loop body, or within another subroutine", label.position)
         }
         super.visit(label)
     }
 
     override fun visit(subroutine: Subroutine) {
-        fun err(msg: String) {
-            checkResult.add(SyntaxError(msg, subroutine.position))
-        }
+        fun err(msg: String) = errors.err(msg, subroutine.position)
 
         if(subroutine.name in BuiltinFunctions)
             err("cannot redefine a built-in function")
@@ -327,36 +320,37 @@ internal class AstChecker(private val program: Program,
                 err("Pass-by-reference types (str, array) cannot occur as a parameter type directly. Instead, use an uword for their address, or access the variable from the outer scope directly.")
             }
         }
+
+        visitStatements(subroutine.statements)
     }
 
     override fun visit(repeatLoop: RepeatLoop) {
         if(repeatLoop.untilCondition.referencesIdentifiers("A", "X", "Y"))
-            printWarning("using a register in the loop condition is risky (it could get clobbered)", repeatLoop.untilCondition.position)
+            errors.warn("using a register in the loop condition is risky (it could get clobbered)", repeatLoop.untilCondition.position)
         if(repeatLoop.untilCondition.inferType(program).typeOrElse(DataType.STRUCT) !in IntegerDatatypes)
-            checkResult.add(ExpressionError("condition value should be an integer type", repeatLoop.untilCondition.position))
+            errors.err("condition value should be an integer type", repeatLoop.untilCondition.position)
         super.visit(repeatLoop)
     }
 
     override fun visit(whileLoop: WhileLoop) {
         if(whileLoop.condition.referencesIdentifiers("A", "X", "Y"))
-            printWarning("using a register in the loop condition is risky (it could get clobbered)", whileLoop.condition.position)
+            errors.warn("using a register in the loop condition is risky (it could get clobbered)", whileLoop.condition.position)
         if(whileLoop.condition.inferType(program).typeOrElse(DataType.STRUCT) !in IntegerDatatypes)
-            checkResult.add(ExpressionError("condition value should be an integer type", whileLoop.condition.position))
+            errors.err("condition value should be an integer type", whileLoop.condition.position)
         super.visit(whileLoop)
     }
 
     override fun visit(assignment: Assignment) {
-
         // assigning from a functioncall COULD return multiple values (from an asm subroutine)
         if(assignment.value is FunctionCall) {
             val stmt = (assignment.value as FunctionCall).target.targetStatement(program.namespace)
             if (stmt is Subroutine && stmt.isAsmSubroutine) {
                 if(stmt.returntypes.size>1)
-                    checkResult.add(ExpressionError("It's not possible to store the multiple results of this asmsub call; you should use a small block of custom inline assembly for this.", assignment.value.position))
+                    errors.err("It's not possible to store the multiple results of this asmsub call; you should use a small block of custom inline assembly for this.", assignment.value.position)
                 else {
                     val idt = assignment.target.inferType(program, assignment)
                     if(!idt.isKnown || stmt.returntypes.single()!=idt.typeOrElse(DataType.BYTE)) {
-                         checkResult.add(ExpressionError("return type mismatch", assignment.value.position))
+                         errors.err("return type mismatch", assignment.value.position)
                     }
                 }
             }
@@ -369,7 +363,7 @@ internal class AstChecker(private val program: Program,
             val targetVar = targetIdent.targetVarDecl(program.namespace)
             if(sourceVar?.struct!=null && targetVar?.struct!=null) {
                 if(sourceVar.struct!==targetVar.struct)
-                    checkResult.add(ExpressionError("assignment of different struct types", assignment.position))
+                    errors.err("assignment of different struct types", assignment.position)
             }
         }
 
@@ -382,7 +376,7 @@ internal class AstChecker(private val program: Program,
         val memAddr = assignTarget.memoryAddress?.addressExpression?.constValue(program)?.number?.toInt()
         if (memAddr != null) {
             if (memAddr < 0 || memAddr >= 65536)
-                checkResult.add(ExpressionError("address out of range", assignTarget.position))
+                errors.err("address out of range", assignTarget.position)
         }
 
         val assignment = assignTarget.parent as Statement
@@ -392,16 +386,16 @@ internal class AstChecker(private val program: Program,
             val targetSymbol = program.namespace.lookup(targetName, assignment)
             when (targetSymbol) {
                 null -> {
-                    checkResult.add(UndefinedSymbolError(targetIdentifier))
+                    errors.err("undefined symbol: ${targetIdentifier.nameInSource.joinToString(".")}", targetIdentifier.position)
                     return
                 }
                 !is VarDecl -> {
-                    checkResult.add(SyntaxError("assignment LHS must be register or variable", assignment.position))
+                    errors.err("assignment LHS must be register or variable", assignment.position)
                     return
                 }
                 else -> {
                     if (targetSymbol.type == VarDeclType.CONST) {
-                        checkResult.add(ExpressionError("cannot assign new value to a constant", assignment.position))
+                        errors.err("cannot assign new value to a constant", assignment.position)
                         return
                     }
                 }
@@ -409,7 +403,7 @@ internal class AstChecker(private val program: Program,
         }
         val targetDt = assignTarget.inferType(program, assignment).typeOrElse(DataType.STR)
         if(targetDt in IterableDatatypes)
-            checkResult.add(SyntaxError("cannot assign to a string or array type", assignTarget.position))
+            errors.err("cannot assign to a string or array type", assignTarget.position)
 
         if (assignment is Assignment) {
 
@@ -427,9 +421,9 @@ internal class AstChecker(private val program: Program,
                         if (assignment.value is FunctionCall) {
                             val targetStmt = (assignment.value as FunctionCall).target.targetStatement(program.namespace)
                             if (targetStmt != null)
-                                checkResult.add(ExpressionError("function call doesn't return a suitable value to use in assignment", assignment.value.position))
+                                errors.err("function call doesn't return a suitable value to use in assignment", assignment.value.position)
                         } else
-                            checkResult.add(ExpressionError("assignment value is invalid or has no proper datatype", assignment.value.position))
+                            errors.err("assignment value is invalid or has no proper datatype", assignment.value.position)
                     } else {
                         checkAssignmentCompatible(targetDatatype.typeOrElse(DataType.BYTE), assignTarget,
                                 sourceDatatype.typeOrElse(DataType.BYTE), assignment.value, assignment.position)
@@ -442,17 +436,17 @@ internal class AstChecker(private val program: Program,
     override fun visit(addressOf: AddressOf) {
         val variable=addressOf.identifier.targetVarDecl(program.namespace)
         if(variable==null)
-            checkResult.add(ExpressionError("pointer-of operand must be the name of a heap variable", addressOf.position))
+            errors.err("pointer-of operand must be the name of a heap variable", addressOf.position)
         else {
             if(variable.datatype !in ArrayDatatypes && variable.datatype != DataType.STR && variable.datatype!=DataType.STRUCT)
-                checkResult.add(ExpressionError("invalid pointer-of operand type", addressOf.position))
+                errors.err("invalid pointer-of operand type", addressOf.position)
         }
         super.visit(addressOf)
     }
 
     override fun visit(decl: VarDecl) {
         fun err(msg: String, position: Position?=null) {
-            checkResult.add(SyntaxError(msg, position ?: decl.position))
+            err(msg, position ?: decl.position)
         }
 
         // the initializer value can't refer to the variable itself (recursive definition)
@@ -468,19 +462,19 @@ internal class AstChecker(private val program: Program,
 
         // FLOATS
         if(!compilerOptions.floats && decl.datatype in setOf(DataType.FLOAT, DataType.ARRAY_F) && decl.type!= VarDeclType.MEMORY) {
-            checkResult.add(SyntaxError("floating point used, but that is not enabled via options", decl.position))
+            err("floating point used, but that is not enabled via options")
         }
 
         // ARRAY without size specifier MUST have an iterable initializer value
         if(decl.isArray && decl.arraysize==null) {
             if(decl.type== VarDeclType.MEMORY)
-                checkResult.add(SyntaxError("memory mapped array must have a size specification", decl.position))
+                err("memory mapped array must have a size specification")
             if(decl.value==null) {
-                checkResult.add(SyntaxError("array variable is missing a size specification or an initialization value", decl.position))
+                err("array variable is missing a size specification or an initialization value")
                 return
             }
             if(decl.value is NumericLiteralValue) {
-                checkResult.add(SyntaxError("unsized array declaration cannot use a single literal initialization value", decl.position))
+                err("unsized array declaration cannot use a single literal initialization value")
                 return
             }
             if(decl.value is RangeExpr)
@@ -546,19 +540,19 @@ internal class AstChecker(private val program: Program,
                             val struct = decl.struct!!
                             val structLv = decl.value as StructLiteralValue
                             if(struct.numberOfElements != structLv.values.size) {
-                                checkResult.add(ExpressionError("struct value has incorrect number of elements", structLv.position))
+                                errors.err("struct value has incorrect number of elements", structLv.position)
                                 return
                             }
                             for(value in structLv.values.zip(struct.statements)) {
                                 val memberdecl = value.second as VarDecl
                                 val constValue = value.first.constValue(program)
                                 if(constValue==null) {
-                                    checkResult.add(ExpressionError("struct literal value for field '${memberdecl.name}' should consist of compile-time constants", value.first.position))
+                                    errors.err("struct literal value for field '${memberdecl.name}' should consist of compile-time constants", value.first.position)
                                     return
                                 }
                                 val memberDt = memberdecl.datatype
                                 if(!checkValueTypeAndRange(memberDt, constValue)) {
-                                    checkResult.add(ExpressionError("struct member value's type is not compatible with member field '${memberdecl.name}'", value.first.position))
+                                    errors.err("struct member value's type is not compatible with member field '${memberdecl.name}'", value.first.position)
                                     return
                                 }
                             }
@@ -593,7 +587,7 @@ internal class AstChecker(private val program: Program,
                 } else {
                     val value = decl.value as NumericLiteralValue
                     if (value.type !in IntegerDatatypes || value.number.toInt() < 0 || value.number.toInt() > 65535) {
-                        err("memory address must be valid integer 0..\$ffff")
+                        err("memory address must be valid integer 0..\$ffff", decl.value?.position)
                     }
                 }
             }
@@ -604,21 +598,24 @@ internal class AstChecker(private val program: Program,
 
     override fun visit(directive: Directive) {
         fun err(msg: String) {
-            checkResult.add(SyntaxError(msg, directive.position))
+            errors.err(msg, directive.position)
         }
         when(directive.directive) {
             "%output" -> {
-                if(directive.parent !is Module) err("this directive may only occur at module level")
+                if(directive.parent !is Module)
+                    err("this directive may only occur at module level")
                 if(directive.args.size!=1 || directive.args[0].name != "raw" && directive.args[0].name != "prg")
                     err("invalid output directive type, expected raw or prg")
             }
             "%launcher" -> {
-                if(directive.parent !is Module) err("this directive may only occur at module level")
+                if(directive.parent !is Module)
+                    err("this directive may only occur at module level")
                 if(directive.args.size!=1 || directive.args[0].name != "basic" && directive.args[0].name != "none")
                     err("invalid launcher directive type, expected basic or none")
             }
             "%zeropage" -> {
-                if(directive.parent !is Module) err("this directive may only occur at module level")
+                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" &&
@@ -628,35 +625,41 @@ internal class AstChecker(private val program: Program,
                     err("invalid zp type, expected basicsafe, floatsafe, kernalsafe, dontuse, or full")
             }
             "%zpreserved" -> {
-                if(directive.parent !is Module) err("this directive may only occur at module level")
+                if(directive.parent !is Module)
+                    err("this directive may only occur at module level")
                 if(directive.args.size!=2 || directive.args[0].int==null || directive.args[1].int==null)
                     err("requires two addresses (start, end)")
             }
             "%address" -> {
-                if(directive.parent !is Module) err("this directive may only occur at module level")
+                if(directive.parent !is Module)
+                    err("this directive may only occur at module level")
                 if(directive.args.size!=1 || directive.args[0].int == null)
                     err("invalid address directive, expected numeric address argument")
             }
             "%import" -> {
-                if(directive.parent !is Module) err("this directive may only occur at module level")
+                if(directive.parent !is Module)
+                    err("this directive may only occur at module level")
                 if(directive.args.size!=1 || directive.args[0].name==null)
                     err("invalid import directive, expected module name argument")
                 if(directive.args[0].name == (directive.parent as? Module)?.name)
                     err("invalid import directive, cannot import itself")
             }
             "%breakpoint" -> {
-                if(directive.parent !is INameScope || directive.parent is Module) err("this directive may only occur in a block")
+                if(directive.parent !is INameScope || directive.parent is Module)
+                    err("this directive may only occur in a block")
                 if(directive.args.isNotEmpty())
                     err("invalid breakpoint directive, expected no arguments")
             }
             "%asminclude" -> {
-                if(directive.parent !is INameScope || directive.parent is Module) err("this directive may only occur in a block")
+                if(directive.parent !is INameScope || directive.parent is Module)
+                    err("this directive may only occur in a block")
                 if(directive.args.size!=2 || directive.args[0].str==null || directive.args[1].str==null)
                     err("invalid asminclude directive, expected arguments: \"filename\", \"scopelabel\"")
                 checkFileExists(directive, directive.args[0].str!!)
             }
             "%asmbinary" -> {
-                if(directive.parent !is INameScope || directive.parent is Module) err("this directive may only occur in a block")
+                if(directive.parent !is INameScope || directive.parent is Module)
+                    err("this directive may only occur in a block")
                 val errormsg = "invalid asmbinary directive, expected arguments: \"filename\" [, offset [, length ] ]"
                 if(directive.args.isEmpty()) err(errormsg)
                 else if(directive.args.isNotEmpty() && directive.args[0].str==null) err(errormsg)
@@ -666,7 +669,8 @@ internal class AstChecker(private val program: Program,
                 else checkFileExists(directive, directive.args[0].str!!)
             }
             "%option" -> {
-                if(directive.parent !is Block && directive.parent !is Module) err("this directive may only occur in a block or at module level")
+                if(directive.parent !is Block && directive.parent !is Module)
+                    err("this directive may only occur in a block or at module level")
                 if(directive.args.isEmpty())
                     err("missing option directive argument(s)")
                 else if(directive.args.map{it.name in setOf("enable_floats", "force_output")}.any { !it })
@@ -682,15 +686,17 @@ internal class AstChecker(private val program: Program,
         while (definingModule !is Module)
             definingModule = definingModule.parent
         if (!(filename.startsWith("library:") || definingModule.source.resolveSibling(filename).toFile().isFile || File(filename).isFile))
-            checkResult.add(NameError("included file not found: $filename", directive.position))
+            errors.err("included file not found: $filename", directive.position)
     }
 
     override fun visit(array: ArrayLiteralValue) {
-        if(!compilerOptions.floats && array.type in setOf(DataType.FLOAT, DataType.ARRAY_F)) {
-            checkResult.add(SyntaxError("floating point used, but that is not enabled via options", array.position))
+        if(array.type.isKnown) {
+            if (!compilerOptions.floats && array.type.typeOrElse(DataType.STRUCT) in setOf(DataType.FLOAT, DataType.ARRAY_F)) {
+                errors.err("floating point used, but that is not enabled via options", array.position)
+            }
+            val arrayspec = ArrayIndex.forArray(array)
+            checkValueTypeAndRangeArray(array.type.typeOrElse(DataType.STRUCT), null, arrayspec, array)
         }
-        val arrayspec = ArrayIndex.forArray(array)
-        checkValueTypeAndRangeArray(array.type, null, arrayspec, array)
 
         super.visit(array)
     }
@@ -704,7 +710,7 @@ internal class AstChecker(private val program: Program,
         if(expr.operator=="-") {
             val dt = expr.inferType(program).typeOrElse(DataType.STRUCT)
             if (dt != DataType.BYTE && dt != DataType.WORD && dt != DataType.FLOAT) {
-                checkResult.add(ExpressionError("can only take negative of a signed number type", expr.position))
+                errors.err("can only take negative of a signed number type", expr.position)
             }
         }
         super.visit(expr)
@@ -724,56 +730,56 @@ internal class AstChecker(private val program: Program,
                 val constvalRight = expr.right.constValue(program)
                 val divisor = constvalRight?.number?.toDouble()
                 if(divisor==0.0)
-                    checkResult.add(ExpressionError("division by zero", expr.right.position))
+                    errors.err("division by zero", expr.right.position)
                 if(expr.operator=="%") {
                     if ((rightDt != DataType.UBYTE && rightDt != DataType.UWORD) || (leftDt!= DataType.UBYTE && leftDt!= DataType.UWORD))
-                        checkResult.add(ExpressionError("remainder can only be used on unsigned integer operands", expr.right.position))
+                        errors.err("remainder can only be used on unsigned integer operands", expr.right.position)
                 }
             }
             "**" -> {
                 if(leftDt in IntegerDatatypes)
-                    checkResult.add(ExpressionError("power operator requires floating point", expr.position))
+                    errors.err("power operator requires floating point", expr.position)
             }
             "and", "or", "xor" -> {
                 // only integer numeric operands accepted, and if literal constants, only boolean values accepted (0 or 1)
                 if(leftDt !in IntegerDatatypes || rightDt !in IntegerDatatypes)
-                    checkResult.add(ExpressionError("logical operator can only be used on boolean operands", expr.right.position))
+                    errors.err("logical operator can only be used on boolean operands", expr.right.position)
                 val constLeft = expr.left.constValue(program)
                 val constRight = expr.right.constValue(program)
                 if(constLeft!=null && constLeft.number.toInt() !in 0..1 || constRight!=null && constRight.number.toInt() !in 0..1)
-                    checkResult.add(ExpressionError("const literal argument of logical operator must be boolean (0 or 1)", expr.position))
+                    errors.err("const literal argument of logical operator must be boolean (0 or 1)", expr.position)
             }
             "&", "|", "^" -> {
                 // only integer numeric operands accepted
                 if(leftDt !in IntegerDatatypes || rightDt !in IntegerDatatypes)
-                    checkResult.add(ExpressionError("bitwise operator can only be used on integer operands", expr.right.position))
+                    errors.err("bitwise operator can only be used on integer operands", expr.right.position)
             }
             "<<", ">>" -> {
                 // for now, bit-shifts can only shift by a constant number
                 val constRight = expr.right.constValue(program)
                 if(constRight==null)
-                    checkResult.add(ExpressionError("bit-shift can only be done by a constant number (for now)", expr.right.position))
+                    errors.err("bit-shift can only be done by a constant number (for now)", expr.right.position)
             }
         }
 
         if(leftDt !in NumericDatatypes)
-            checkResult.add(ExpressionError("left operand is not numeric", expr.left.position))
+            errors.err("left operand is not numeric", expr.left.position)
         if(rightDt!in NumericDatatypes)
-            checkResult.add(ExpressionError("right operand is not numeric", expr.right.position))
+            errors.err("right operand is not numeric", expr.right.position)
         if(leftDt!=rightDt)
-            checkResult.add(ExpressionError("left and right operands aren't the same type", expr.left.position))
+            errors.err("left and right operands aren't the same type", expr.left.position)
         super.visit(expr)
     }
 
     override fun visit(typecast: TypecastExpression) {
         if(typecast.type in IterableDatatypes)
-            checkResult.add(ExpressionError("cannot type cast to string or array type", typecast.position))
+            errors.err("cannot type cast to string or array type", typecast.position)
         super.visit(typecast)
     }
 
     override fun visit(range: RangeExpr) {
         fun err(msg: String) {
-            checkResult.add(SyntaxError(msg, range.position))
+            errors.err(msg, range.position)
         }
         super.visit(range)
         val from = range.from.constValue(program)
@@ -793,7 +799,7 @@ internal class AstChecker(private val program: Program,
                     val fromValue = from.number.toInt()
                     val toValue = to.number.toInt()
                     if(fromValue== toValue)
-                        printWarning("range is just a single value, don't use a loop here", range.position)
+                        errors.warn("range is just a single value, don't use a loop here", range.position)
                     else if(fromValue < toValue && step<=0)
                         err("ascending range requires step > 0")
                     else if(fromValue > toValue && step>=0)
@@ -812,6 +818,14 @@ internal class AstChecker(private val program: Program,
         val targetStatement = checkFunctionOrLabelExists(functionCall.target, stmtOfExpression)
         if(targetStatement!=null)
             checkFunctionCall(targetStatement, functionCall.args, functionCall.position)
+
+        // warn about sgn(unsigned) this is likely a mistake
+        if(functionCall.target.nameInSource.last()=="sgn") {
+            val sgnArgType = functionCall.args.first().inferType(program)
+            if(sgnArgType.istype(DataType.UBYTE) || sgnArgType.istype(DataType.UWORD))
+                errors.warn("sgn() of unsigned type is always 0 or 1, this is perhaps not what was intended", functionCall.args.first().position)
+        }
+
         super.visit(functionCall)
     }
 
@@ -821,15 +835,23 @@ internal class AstChecker(private val program: Program,
             checkFunctionCall(targetStatement, functionCallStatement.args, functionCallStatement.position)
         if(!functionCallStatement.void && targetStatement is Subroutine && targetStatement.returntypes.isNotEmpty()) {
             if(targetStatement.returntypes.size==1)
-                printWarning("result value of subroutine call is discarded (use void?)", functionCallStatement.position)
+                errors.warn("result value of subroutine call is discarded (use void?)", functionCallStatement.position)
             else
-                printWarning("result values of subroutine call are discarded (use void?)", functionCallStatement.position)
+                errors.warn("result values of subroutine call are discarded (use void?)", functionCallStatement.position)
+        }
+
+        if(functionCallStatement.target.nameInSource.last() == "sort") {
+            // sort is not supported on float arrays
+            val idref = functionCallStatement.args.singleOrNull() as? IdentifierReference
+            if(idref!=null && idref.inferType(program).istype(DataType.ARRAY_F)) {
+                errors.err("sorting a floating point array is not supported", functionCallStatement.args.first().position)
+            }
         }
 
         if(functionCallStatement.target.nameInSource.last() in setOf("lsl", "lsr", "rol", "ror", "rol2", "ror2", "swap", "sort", "reverse")) {
             // in-place modification, can't be done on literals
             if(functionCallStatement.args.any { it !is IdentifierReference && it !is RegisterExpr && it !is ArrayIndexedExpression && it !is DirectMemoryRead }) {
-                checkResult.add(ExpressionError("can't use that as argument to a in-place modifying function", functionCallStatement.position))
+                errors.err("can't use that as argument to a in-place modifying function", functionCallStatement.args.first().position)
             }
         }
         super.visit(functionCallStatement)
@@ -837,13 +859,13 @@ internal class AstChecker(private val program: Program,
 
     private fun checkFunctionCall(target: Statement, args: List<Expression>, position: Position) {
         if(target is Label && args.isNotEmpty())
-            checkResult.add(SyntaxError("cannot use arguments when calling a label", position))
+            errors.err("cannot use arguments when calling a label", position)
 
         if(target is BuiltinFunctionStatementPlaceholder) {
             // it's a call to a builtin function.
             val func = BuiltinFunctions.getValue(target.name)
             if(args.size!=func.parameters.size)
-                checkResult.add(SyntaxError("invalid number of arguments", position))
+                errors.err("invalid number of arguments", position)
             else {
                 val paramTypesForAddressOf = PassByReferenceDatatypes + DataType.UWORD
                 for (arg in args.withIndex().zip(func.parameters)) {
@@ -851,7 +873,7 @@ internal class AstChecker(private val program: Program,
                     if (argDt.isKnown
                             && !(argDt.typeOrElse(DataType.STRUCT) isAssignableTo arg.second.possibleDatatypes)
                             && (argDt.typeOrElse(DataType.STRUCT) != DataType.UWORD || arg.second.possibleDatatypes.intersect(paramTypesForAddressOf).isEmpty())) {
-                        checkResult.add(ExpressionError("builtin function '${target.name}' argument ${arg.first.index + 1} has invalid type $argDt, expected ${arg.second.possibleDatatypes}", position))
+                        errors.err("builtin function '${target.name}' argument ${arg.first.index + 1} has invalid type $argDt, expected ${arg.second.possibleDatatypes}", position)
                     }
                 }
                 if(target.name=="swap") {
@@ -859,26 +881,26 @@ internal class AstChecker(private val program: Program,
                     val dt1 = args[0].inferType(program)
                     val dt2 = args[1].inferType(program)
                     if (dt1 != dt2)
-                        checkResult.add(ExpressionError("swap requires 2 args of identical type", position))
+                        errors.err("swap requires 2 args of identical type", position)
                     else if (args[0].constValue(program) != null || args[1].constValue(program) != null)
-                        checkResult.add(ExpressionError("swap requires 2 variables, not constant value(s)", position))
+                        errors.err("swap requires 2 variables, not constant value(s)", position)
                     else if(args[0] isSameAs args[1])
-                        checkResult.add(ExpressionError("swap should have 2 different args", position))
+                        errors.err("swap should have 2 different args", position)
                     else if(dt1.typeOrElse(DataType.STRUCT) !in NumericDatatypes)
-                        checkResult.add(ExpressionError("swap requires args of numerical type", position))
+                        errors.err("swap requires args of numerical type", position)
                 }
                 else if(target.name=="all" || target.name=="any") {
                     if((args[0] as? AddressOf)?.identifier?.targetVarDecl(program.namespace)?.datatype == DataType.STR) {
-                        checkResult.add(ExpressionError("any/all on a string is useless (is always true unless the string is empty)", position))
+                        errors.err("any/all on a string is useless (is always true unless the string is empty)", position)
                     }
                     if(args[0].inferType(program).typeOrElse(DataType.STR) == DataType.STR) {
-                        checkResult.add(ExpressionError("any/all on a string is useless (is always true unless the string is empty)", position))
+                        errors.err("any/all on a string is useless (is always true unless the string is empty)", position)
                     }
                 }
             }
         } else if(target is Subroutine) {
             if(args.size!=target.parameters.size)
-                checkResult.add(SyntaxError("invalid number of arguments", position))
+                errors.err("invalid number of arguments", position)
             else {
                 for (arg in args.withIndex().zip(target.parameters)) {
                     val argIDt = arg.first.value.inferType(program)
@@ -889,26 +911,26 @@ internal class AstChecker(private val program: Program,
                     if(!(argDt isAssignableTo arg.second.type)) {
                         // for asm subroutines having STR param it's okay to provide a UWORD (address value)
                         if(!(target.isAsmSubroutine && arg.second.type == DataType.STR && argDt == DataType.UWORD))
-                            checkResult.add(ExpressionError("subroutine '${target.name}' argument ${arg.first.index + 1} has invalid type $argDt, expected ${arg.second.type}", position))
+                            errors.err("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 NumericLiteralValue && 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)
+                                errors.warn("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))
+                                errors.err("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))
+                                errors.err("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))
+                                errors.err("subroutine '${target.name}' argument ${arg.first.index + 1} must be word type for register pair", position)
                         }
                     }
                 }
@@ -921,23 +943,24 @@ internal class AstChecker(private val program: Program,
             val targetName = postIncrDecr.target.identifier!!.nameInSource
             val target = program.namespace.lookup(targetName, postIncrDecr)
             if(target==null) {
-                checkResult.add(UndefinedSymbolError(postIncrDecr.target.identifier!!))
+                val symbol = postIncrDecr.target.identifier!!
+                errors.err("undefined symbol: ${symbol.nameInSource.joinToString(".")}", symbol.position)
             } else {
                 if(target !is VarDecl || target.type== VarDeclType.CONST) {
-                    checkResult.add(SyntaxError("can only increment or decrement a variable", postIncrDecr.position))
+                    errors.err("can only increment or decrement a variable", postIncrDecr.position)
                 } else if(target.datatype !in NumericDatatypes) {
-                    checkResult.add(SyntaxError("can only increment or decrement a byte/float/word variable", postIncrDecr.position))
+                    errors.err("can only increment or decrement a byte/float/word variable", postIncrDecr.position)
                 }
             }
         } else if(postIncrDecr.target.arrayindexed != null) {
             val target = postIncrDecr.target.arrayindexed?.identifier?.targetStatement(program.namespace)
             if(target==null) {
-                checkResult.add(NameError("undefined symbol", postIncrDecr.position))
+                errors.err("undefined symbol", postIncrDecr.position)
             }
             else {
                 val dt = (target as VarDecl).datatype
                 if(dt !in NumericDatatypes && dt !in ArrayDatatypes)
-                    checkResult.add(SyntaxError("can only increment or decrement a byte/float/word", postIncrDecr.position))
+                    errors.err("can only increment or decrement a byte/float/word", postIncrDecr.position)
             }
         }
         // else if(postIncrDecr.target.memoryAddress != null) { } // a memory location can always be ++/--
@@ -948,29 +971,29 @@ internal class AstChecker(private val program: Program,
         val target = arrayIndexedExpression.identifier.targetStatement(program.namespace)
         if(target is VarDecl) {
             if(target.datatype !in IterableDatatypes)
-                checkResult.add(SyntaxError("indexing requires an iterable variable", arrayIndexedExpression.position))
+                errors.err("indexing requires an iterable variable", arrayIndexedExpression.position)
             val arraysize = target.arraysize?.size()
             if(arraysize!=null) {
                 // check out of bounds
                 val index = (arrayIndexedExpression.arrayspec.index as? NumericLiteralValue)?.number?.toInt()
                 if(index!=null && (index<0 || index>=arraysize))
-                    checkResult.add(ExpressionError("array index out of bounds", arrayIndexedExpression.arrayspec.position))
+                    errors.err("array index out of bounds", arrayIndexedExpression.arrayspec.position)
             } else if(target.datatype == DataType.STR) {
                 if(target.value is StringLiteralValue) {
                     // check string lengths for non-memory mapped strings
                     val stringLen = (target.value as StringLiteralValue).value.length
                     val index = (arrayIndexedExpression.arrayspec.index as? NumericLiteralValue)?.number?.toInt()
                     if (index != null && (index < 0 || index >= stringLen))
-                        checkResult.add(ExpressionError("index out of bounds", arrayIndexedExpression.arrayspec.position))
+                        errors.err("index out of bounds", arrayIndexedExpression.arrayspec.position)
                 }
             }
         } else
-            checkResult.add(SyntaxError("indexing requires a variable to act upon", arrayIndexedExpression.position))
+            errors.err("indexing requires a variable to act upon", arrayIndexedExpression.position)
 
         // check index value 0..255
         val dtx = arrayIndexedExpression.arrayspec.index.inferType(program).typeOrElse(DataType.STRUCT)
         if(dtx!= DataType.UBYTE && dtx!= DataType.BYTE)
-            checkResult.add(SyntaxError("array indexing is limited to byte size 0..255", arrayIndexedExpression.position))
+            errors.err("array indexing is limited to byte size 0..255", arrayIndexedExpression.position)
 
         super.visit(arrayIndexedExpression)
     }
@@ -978,15 +1001,15 @@ internal class AstChecker(private val program: Program,
     override fun visit(whenStatement: WhenStatement) {
         val conditionType = whenStatement.condition.inferType(program).typeOrElse(DataType.STRUCT)
         if(conditionType !in IntegerDatatypes)
-            checkResult.add(SyntaxError("when condition must be an integer value", whenStatement.position))
+            errors.err("when condition must be an integer value", whenStatement.position)
         val choiceValues = whenStatement.choiceValues(program)
         val occurringValues = choiceValues.map {it.first}
         val tally = choiceValues.associate { it.second to occurringValues.count { ov->it.first==ov} }
         tally.filter { it.value>1 }.forEach {
-            checkResult.add(SyntaxError("choice value occurs multiple times", it.key.position))
+            errors.err("choice value occurs multiple times", it.key.position)
         }
         if(whenStatement.choices.isEmpty())
-            checkResult.add(SyntaxError("empty when statement", whenStatement.position))
+            errors.err("empty when statement", whenStatement.position)
 
         super.visit(whenStatement)
     }
@@ -1000,14 +1023,14 @@ internal class AstChecker(private val program: Program,
             val constvalues = whenChoice.values!!.map { it.constValue(program) }
             for(constvalue in constvalues) {
                 when {
-                    constvalue == null -> checkResult.add(SyntaxError("choice value must be a constant", whenChoice.position))
-                    constvalue.type !in IntegerDatatypes -> checkResult.add(SyntaxError("choice value must be a byte or word", whenChoice.position))
-                    constvalue.type != conditionType.typeOrElse(DataType.STRUCT) -> checkResult.add(SyntaxError("choice value datatype differs from condition value", whenChoice.position))
+                    constvalue == null -> errors.err("choice value must be a constant", whenChoice.position)
+                    constvalue.type !in IntegerDatatypes -> errors.err("choice value must be a byte or word", whenChoice.position)
+                    constvalue.type != conditionType.typeOrElse(DataType.STRUCT) -> errors.err("choice value datatype differs from condition value", whenChoice.position)
                 }
             }
         } else {
             if(whenChoice !== whenStmt.choices.last())
-                checkResult.add(SyntaxError("else choice must be the last one", whenChoice.position))
+                errors.err("else choice must be the last one", whenChoice.position)
         }
         super.visit(whenChoice)
     }
@@ -1015,33 +1038,51 @@ internal class AstChecker(private val program: Program,
     override fun visit(structDecl: StructDecl) {
         // a struct can only contain 1 or more vardecls and can not be nested
         if(structDecl.statements.isEmpty())
-            checkResult.add(SyntaxError("struct must contain at least one member", structDecl.position))
+            errors.err("struct must contain at least one member", structDecl.position)
 
         for(member in structDecl.statements){
             val decl = member as? VarDecl
             if(decl==null)
-                checkResult.add(SyntaxError("struct can only contain variable declarations", structDecl.position))
+                errors.err("struct can only contain variable declarations", structDecl.position)
             else {
                 if(decl.zeropage==ZeropageWish.REQUIRE_ZEROPAGE || decl.zeropage==ZeropageWish.PREFER_ZEROPAGE)
-                    checkResult.add(SyntaxError("struct can not contain zeropage members", decl.position))
+                    errors.err("struct can not contain zeropage members", decl.position)
                 if(decl.datatype !in NumericDatatypes)
-                    checkResult.add(SyntaxError("structs can only contain numerical types", decl.position))
+                    errors.err("structs can only contain numerical types", decl.position)
             }
         }
     }
 
+    override fun visit(scope: AnonymousScope) {
+        visitStatements(scope.statements)
+    }
+
+    private fun visitStatements(statements: List<Statement>) {
+        for((index, stmt) in statements.withIndex()) {
+            if(stmt is FunctionCallStatement
+                    && stmt.target.nameInSource.last()=="exit"
+                    && index < statements.lastIndex)
+                errors.warn("unreachable code, exit call above never returns", statements[index+1].position)
+
+            if(stmt is Return && index < statements.lastIndex)
+                errors.warn("unreachable code, return statement above", statements[index+1].position)
+
+            stmt.accept(this)
+        }
+    }
+
     private fun checkFunctionOrLabelExists(target: IdentifierReference, statement: Statement): Statement? {
         val targetStatement = target.targetStatement(program.namespace)
         if(targetStatement is Label || targetStatement is Subroutine || targetStatement is BuiltinFunctionStatementPlaceholder)
             return targetStatement
-        checkResult.add(NameError("undefined function or subroutine: ${target.nameInSource.joinToString(".")}", statement.position))
+        errors.err("undefined function or subroutine: ${target.nameInSource.joinToString(".")}", statement.position)
         return null
     }
 
     private fun checkValueTypeAndRangeString(targetDt: DataType, value: StringLiteralValue) : Boolean {
         return if (targetDt == DataType.STR) {
             if (value.value.length > 255) {
-                checkResult.add(ExpressionError("string length must be 0-255", value.position))
+                errors.err("string length must be 0-255", value.position)
                 false
             }
             else
@@ -1053,14 +1094,18 @@ internal class AstChecker(private val program: Program,
     private fun checkValueTypeAndRangeArray(targetDt: DataType, struct: StructDecl?,
                                             arrayspec: ArrayIndex, value: ArrayLiteralValue) : Boolean {
         fun err(msg: String) : Boolean {
-            checkResult.add(ExpressionError(msg, value.position))
+            errors.err(msg, value.position)
             return false
         }
+
+        if(value.type.isUnknown)
+            return err("attempt to check values of array with as yet unknown datatype")
+
         when (targetDt) {
             DataType.STR -> return err("string value expected")
             DataType.ARRAY_UB, DataType.ARRAY_B -> {
                 // value may be either a single byte, or a byte arraysize (of all constant values), or a range
-                if(value.type==targetDt) {
+                if(value.type.istype(targetDt)) {
                     if(!checkArrayValues(value, targetDt))
                         return false
                     val arraySpecSize = arrayspec.size()
@@ -1082,7 +1127,7 @@ internal class AstChecker(private val program: Program,
             }
             DataType.ARRAY_UW, DataType.ARRAY_W -> {
                 // value may be either a single word, or a word arraysize, or a range
-                if(value.type==targetDt) {
+                if(value.type.istype(targetDt)) {
                     if(!checkArrayValues(value, targetDt))
                         return false
                     val arraySpecSize = arrayspec.size()
@@ -1104,7 +1149,7 @@ internal class AstChecker(private val program: Program,
             }
             DataType.ARRAY_F -> {
                 // value may be either a single float, or a float arraysize
-                if(value.type==targetDt) {
+                if(value.type.istype(targetDt)) {
                     if(!checkArrayValues(value, targetDt))
                         return false
                     val arraySize = value.value.size
@@ -1130,14 +1175,14 @@ internal class AstChecker(private val program: Program,
                 return err("invalid float array initialization value ${value.type}, expected $targetDt")
             }
             DataType.STRUCT -> {
-                if(value.type in ArrayDatatypes) {
+                if(value.type.typeOrElse(DataType.STRUCT) in ArrayDatatypes) {
                     if(value.value.size != struct!!.numberOfElements)
                         return err("number of values is not the same as the number of members in the struct")
                     for(elt in value.value.zip(struct.statements)) {
                         val vardecl = elt.second as VarDecl
                         val valuetype = elt.first.inferType(program)
                         if (!valuetype.isKnown || !(valuetype.typeOrElse(DataType.STRUCT) isAssignableTo vardecl.datatype)) {
-                            checkResult.add(ExpressionError("invalid struct member init value type $valuetype, expected ${vardecl.datatype}", elt.first.position))
+                            errors.err("invalid struct member init value type $valuetype, expected ${vardecl.datatype}", elt.first.position)
                             return false
                         }
                     }
@@ -1151,7 +1196,7 @@ internal class AstChecker(private val program: Program,
 
     private fun checkValueTypeAndRange(targetDt: DataType, value: NumericLiteralValue) : Boolean {
         fun err(msg: String) : Boolean {
-            checkResult.add(ExpressionError(msg, value.position))
+            errors.err(msg, value.position)
             return false
         }
         when (targetDt) {
@@ -1223,7 +1268,7 @@ internal class AstChecker(private val program: Program,
             else -> throw AstException("invalid array type $type")
         }
         if (!correct)
-            checkResult.add(ExpressionError("array value out of range for type $type", value.position))
+            errors.err("array value out of range for type $type", value.position)
         return correct
     }
 
@@ -1234,7 +1279,7 @@ internal class AstChecker(private val program: Program,
                                           position: Position) : Boolean {
 
         if(sourceValue is RangeExpr)
-            checkResult.add(SyntaxError("can't assign a range value to something else", position))
+            errors.err("can't assign a range value to something else", position)
 
         val result =  when(targetDatatype) {
             DataType.BYTE -> sourceDatatype== DataType.BYTE
@@ -1252,22 +1297,22 @@ internal class AstChecker(private val program: Program,
                 }
                 false
             }
-            else -> checkResult.add(SyntaxError("cannot assign new value to variable of type $targetDatatype", position))
+            else -> errors.err("cannot assign new value to variable of type $targetDatatype", position)
         }
 
         if(result)
             return true
 
         if((sourceDatatype== DataType.UWORD || sourceDatatype== DataType.WORD) && (targetDatatype== DataType.UBYTE || targetDatatype== DataType.BYTE)) {
-            checkResult.add(ExpressionError("cannot assign word to byte, use msb() or lsb()?", position))
+            errors.err("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.name.toLowerCase()}; possible loss of precision. Suggestion: round the value or revert to integer arithmetic", position))
+            errors.err("cannot assign float to ${targetDatatype.name.toLowerCase()}; possible loss of precision. Suggestion: round the value or revert to integer arithmetic", position)
         else {
             if(targetDatatype==DataType.UWORD && sourceDatatype in PassByReferenceDatatypes)
-                checkResult.add(ExpressionError("cannot assign ${sourceDatatype.name.toLowerCase()} to ${targetDatatype.name.toLowerCase()}, perhaps forgot '&' ?", position))
+                errors.err("cannot assign ${sourceDatatype.name.toLowerCase()} to ${targetDatatype.name.toLowerCase()}, perhaps forgot '&' ?", position)
             else
-                checkResult.add(ExpressionError("cannot assign ${sourceDatatype.name.toLowerCase()} to ${targetDatatype.name.toLowerCase()}", position))
+                errors.err("cannot assign ${sourceDatatype.name.toLowerCase()} to ${targetDatatype.name.toLowerCase()}", position)
         }
 
 

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

@@ -11,19 +11,13 @@ import prog8.compiler.target.CompilationTarget
 import prog8.functions.BuiltinFunctions
 
 
-internal class AstIdentifiersChecker(private val program: Program) : IAstModifyingVisitor {
-
-    private val checkResult: MutableList<AstException> = mutableListOf()
-
+internal class AstIdentifiersChecker(private val program: Program,
+                                     private val errors: ErrorReporter) : IAstModifyingVisitor {
     private var blocks = mutableMapOf<String, Block>()
     private val vardeclsToAdd = mutableMapOf<INameScope, MutableList<VarDecl>>()
 
-    internal fun result(): List<AstException> {
-        return checkResult
-    }
-
     private fun nameError(name: String, position: Position, existing: Statement) {
-        checkResult.add(NameError("name conflict '$name', also defined in ${existing.position.file} line ${existing.position.line}", position))
+        errors.err("name conflict '$name', also defined in ${existing.position.file} line ${existing.position.line}", position)
     }
 
     override fun visit(module: Module) {
@@ -59,15 +53,15 @@ internal class AstIdentifiersChecker(private val program: Program) : IAstModifyi
 
     override fun visit(decl: VarDecl): Statement {
         // first, check if there are datatype errors on the vardecl
-        decl.datatypeErrors.forEach { checkResult.add(it) }
+        decl.datatypeErrors.forEach { errors.err(it.message, it.position) }
 
         // now check the identifier
         if(decl.name in BuiltinFunctions)
             // the builtin functions can't be redefined
-            checkResult.add(NameError("builtin function cannot be redefined", decl.position))
+            errors.err("builtin function cannot be redefined", decl.position)
 
         if(decl.name in CompilationTarget.machine.opcodeNames)
-            checkResult.add(NameError("can't use a cpu opcode name as a symbol: '${decl.name}'", decl.position))
+            errors.err("can't use a cpu opcode name as a symbol: '${decl.name}'", decl.position)
 
         // is it a struct variable? then define all its struct members as mangled names,
         //    and include the original decl as well.
@@ -76,7 +70,7 @@ internal class AstIdentifiersChecker(private val program: Program) : IAstModifyi
                 return super.visit(decl)    // don't do this multiple times
 
             if(decl.struct==null) {
-                checkResult.add(NameError("undefined struct type", decl.position))
+                errors.err("undefined struct type", decl.position)
                 return super.visit(decl)
             }
 
@@ -84,7 +78,7 @@ internal class AstIdentifiersChecker(private val program: Program) : IAstModifyi
                 return super.visit(decl)     // a non-numeric member, not supported. proper error is given by AstChecker later
 
             if(decl.value is NumericLiteralValue) {
-                checkResult.add(ExpressionError("you cannot initialize a struct using a single value", decl.position))
+                errors.err("you cannot initialize a struct using a single value", decl.position)
                 return super.visit(decl)
             }
 
@@ -104,10 +98,10 @@ internal class AstIdentifiersChecker(private val program: Program) : IAstModifyi
 
     override fun visit(subroutine: Subroutine): Statement {
         if(subroutine.name in CompilationTarget.machine.opcodeNames) {
-            checkResult.add(NameError("can't use a cpu opcode name as a symbol: '${subroutine.name}'", subroutine.position))
+            errors.err("can't use a cpu opcode name as a symbol: '${subroutine.name}'", subroutine.position)
         } else if(subroutine.name in BuiltinFunctions) {
             // the builtin functions can't be redefined
-            checkResult.add(NameError("builtin function cannot be redefined", subroutine.position))
+            errors.err("builtin function cannot be redefined", subroutine.position)
         } else {
             // already reported elsewhere:
             // if (subroutine.parameters.any { it.name in BuiltinFunctions })
@@ -157,7 +151,7 @@ internal class AstIdentifiersChecker(private val program: Program) : IAstModifyi
             }
 
             if(subroutine.isAsmSubroutine && subroutine.statements.any{it !is InlineAssembly}) {
-                checkResult.add(SyntaxError("asmsub can only contain inline assembly (%asm)", subroutine.position))
+                errors.err("asmsub can only contain inline assembly (%asm)", subroutine.position)
             }
         }
         return super.visit(subroutine)
@@ -165,15 +159,21 @@ internal class AstIdentifiersChecker(private val program: Program) : IAstModifyi
 
     override fun visit(label: Label): Statement {
         if(label.name in CompilationTarget.machine.opcodeNames)
-            checkResult.add(NameError("can't use a cpu opcode name as a symbol: '${label.name}'", label.position))
+            errors.err("can't use a cpu opcode name as a symbol: '${label.name}'", label.position)
 
         if(label.name in BuiltinFunctions) {
             // the builtin functions can't be redefined
-            checkResult.add(NameError("builtin function cannot be redefined", label.position))
+            errors.err("builtin function cannot be redefined", label.position)
         } else {
-            val existing = program.namespace.lookup(listOf(label.name), label)
-            if (existing != null && existing !== label)
-                nameError(label.name, label.position, existing)
+            val existing = label.definingSubroutine()?.getAllLabels(label.name) ?: emptyList()
+            for(el in existing) {
+                if(el === label || el.name != label.name)
+                    continue
+                else {
+                    nameError(label.name, label.position, el)
+                    break
+                }
+            }
         }
         return super.visit(label)
     }
@@ -185,7 +185,7 @@ internal class AstIdentifiersChecker(private val program: Program) : IAstModifyi
         // additional interation count variable in their scope.
         if(forLoop.loopRegister!=null) {
             if(forLoop.loopRegister == Register.X)
-                printWarning("writing to the X register is dangerous, because it's used as an internal pointer", forLoop.position)
+                errors.warn("writing to the X register is dangerous, because it's used as an internal pointer", forLoop.position)
         } else {
             val loopVar = forLoop.loopVar
             if (loopVar != null) {
@@ -209,7 +209,7 @@ internal class AstIdentifiersChecker(private val program: Program) : IAstModifyi
 
     override fun visit(assignTarget: AssignTarget): AssignTarget {
         if(assignTarget.register== Register.X)
-            printWarning("writing to the X register is dangerous, because it's used as an internal pointer", assignTarget.position)
+            errors.warn("writing to the X register is dangerous, because it's used as an internal pointer", assignTarget.position)
         return super.visit(assignTarget)
     }
 
@@ -225,22 +225,34 @@ internal class AstIdentifiersChecker(private val program: Program) : IAstModifyi
         return super.visit(returnStmt)
     }
 
+
     override fun visit(arrayLiteral: ArrayLiteralValue): Expression {
         val array = super.visit(arrayLiteral)
         if(array is ArrayLiteralValue) {
             val vardecl = array.parent as? VarDecl
-            return if(vardecl!=null)
-                fixupArrayEltDatatypesFromVardecl(array, vardecl)
+            // adjust the datatype of the array (to an educated guess)
+            if(vardecl!=null) {
+                val arrayDt = array.type
+                if(!arrayDt.istype(vardecl.datatype)) {
+                    val cast = array.cast(vardecl.datatype)
+                    if (cast != null) {
+                        vardecl.value = cast
+                        cast.linkParents(vardecl)
+                        return cast
+                    }
+                }
+                return array
+            }
             else {
-                // fix the datatype of the array (also on the heap) to the 'biggest' datatype in the array
-                // (we don't know the desired datatype here exactly so we guess)
-                val datatype = determineArrayDt(array.value)
-                val litval2 = array.cast(datatype)
-                if(litval2!=null) {
-                    litval2.parent = array.parent
-                    // finally, replace the literal array by a identifier reference.
-                    makeIdentifierFromRefLv(litval2)
-                } else array
+                val arrayDt = array.guessDatatype(program)
+                if(arrayDt.isKnown) {
+                    // this array literal is part of an expression, turn it into an identifier reference
+                    val litval2 = array.cast(arrayDt.typeOrElse(DataType.STRUCT))
+                    return if (litval2 != null) {
+                        litval2.parent = array.parent
+                        makeIdentifierFromRefLv(litval2)
+                    } else array
+                }
             }
         }
         return array
@@ -252,7 +264,7 @@ internal class AstIdentifiersChecker(private val program: Program) : IAstModifyi
             val vardecl = string.parent as? VarDecl
             // intern the string; move it into the heap
             if (string.value.length !in 1..255)
-                checkResult.add(ExpressionError("string literal length must be between 1 and 255", string.position))
+                errors.err("string literal length must be between 1 and 255", string.position)
             return if (vardecl != null)
                 string
             else
@@ -261,20 +273,6 @@ internal class AstIdentifiersChecker(private val program: Program) : IAstModifyi
         return string
     }
 
-    private fun determineArrayDt(array: Array<Expression>): DataType {
-        val datatypesInArray = array.map { it.inferType(program) }
-        require(datatypesInArray.isNotEmpty() && datatypesInArray.all { it.isKnown }) { "can't determine type of empty array" }
-        val dts = datatypesInArray.map { it.typeOrElse(DataType.STRUCT) }
-        return when {
-            DataType.FLOAT in dts -> DataType.ARRAY_F
-            DataType.WORD in dts -> DataType.ARRAY_W
-            DataType.UWORD in dts -> DataType.ARRAY_UW
-            DataType.BYTE in dts -> DataType.ARRAY_B
-            DataType.UBYTE in dts -> DataType.ARRAY_UB
-            else -> throw IllegalArgumentException("can't determine type of array")
-        }
-    }
-
     private fun makeIdentifierFromRefLv(array: ArrayLiteralValue): IdentifierReference {
         // a referencetype literal value that's not declared as a variable
         // we need to introduce an auto-generated variable for this to be able to refer to the value
@@ -305,7 +303,7 @@ internal class AstIdentifiersChecker(private val program: Program) : IAstModifyi
         for(member in structDecl.statements){
             val decl = member as? VarDecl
             if(decl!=null && decl.datatype !in NumericDatatypes)
-                checkResult.add(SyntaxError("structs can only contain numerical types", decl.position))
+                errors.err("structs can only contain numerical types", decl.position)
         }
 
         return super.visit(structDecl)
@@ -326,12 +324,12 @@ internal class AstIdentifiersChecker(private val program: Program) : IAstModifyi
         if(constvalue!=null) {
             if (expr.operator == "*") {
                 // repeat a string a number of times
-                return StringLiteralValue(string.value.repeat(constvalue.number.toInt()), expr.position)
+                return StringLiteralValue(string.value.repeat(constvalue.number.toInt()), string.altEncoding, expr.position)
             }
         }
         if(expr.operator == "+" && operand is StringLiteralValue) {
             // concatenate two strings
-            return StringLiteralValue("${string.value}${operand.value}", expr.position)
+            return StringLiteralValue("${string.value}${operand.value}", string.altEncoding, expr.position)
         }
         return expr
     }
@@ -350,46 +348,3 @@ internal class AstIdentifiersChecker(private val program: Program) : IAstModifyi
     }
 
 }
-
-internal fun fixupArrayEltDatatypes(array: ArrayLiteralValue, program: Program): ArrayLiteralValue {
-    val dts = array.value.map {it.inferType(program).typeOrElse(DataType.STRUCT)}.toSet()
-    if(dts.any { it !in NumericDatatypes }) {
-        return array
-    }
-    val dt = when {
-        DataType.FLOAT in dts -> DataType.ARRAY_F
-        DataType.WORD in dts -> DataType.ARRAY_W
-        DataType.UWORD in dts -> DataType.ARRAY_UW
-        DataType.BYTE in dts -> DataType.ARRAY_B
-        else -> DataType.ARRAY_UB
-    }
-    if(dt==array.type)
-        return array
-
-    // convert values and array type
-    val elementType = ArrayElementTypes.getValue(dt)
-    val allNumerics = array.value.all { it is NumericLiteralValue }
-    if(allNumerics) {
-        val values = array.value.map { (it as NumericLiteralValue).cast(elementType) as Expression }.toTypedArray()
-        val array2 = ArrayLiteralValue(dt, values, array.position)
-        array2.linkParents(array.parent)
-        return array2
-    }
-
-    return array
-}
-
-internal fun fixupArrayEltDatatypesFromVardecl(array: ArrayLiteralValue, vardecl: VarDecl): ArrayLiteralValue {
-    val arrayDt = array.type
-    if(arrayDt!=vardecl.datatype) {
-        // fix the datatype of the array (also on the heap) to match the vardecl
-        val cast = array.cast(vardecl.datatype)
-        if (cast != null) {
-            vardecl.value = cast
-            cast.linkParents(vardecl)
-            return cast
-        }
-        // can't be casted yet, attempt again later
-    }
-    return array
-}

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

@@ -1,21 +1,22 @@
 package prog8.ast.processing
 
 import prog8.ast.INameScope
-import prog8.ast.base.AstException
+import prog8.ast.base.ErrorReporter
 import prog8.ast.expressions.FunctionCall
 import prog8.ast.statements.FunctionCallStatement
 import prog8.ast.statements.Subroutine
 
 
-internal class AstRecursionChecker(private val namespace: INameScope) : IAstVisitor {
+internal class AstRecursionChecker(private val namespace: INameScope,
+                                   private val errors: ErrorReporter) : IAstVisitor {
     private val callGraph = DirectedGraph<INameScope>()
 
-    internal fun result(): List<AstException> {
+    fun processMessages(modulename: String) {
         val cycle = callGraph.checkForCycle()
         if(cycle.isEmpty())
-            return emptyList()
+            return
         val chain = cycle.joinToString(" <-- ") { "${it.name} at ${it.position}" }
-        return listOf(AstException("Program contains recursive subroutine calls, this is not supported. Recursive chain:\n (a subroutine call in) $chain"))
+        errors.err("Program contains recursive subroutine calls, this is not supported. Recursive chain:\n (a subroutine call in) $chain", null)
     }
 
     override fun visit(functionCallStatement: FunctionCallStatement) {
@@ -44,7 +45,6 @@ internal class AstRecursionChecker(private val namespace: INameScope) : IAstVisi
         super.visit(functionCall)
     }
 
-
     private class DirectedGraph<VT> {
         private val graph = mutableMapOf<VT, MutableSet<VT>>()
         private var uniqueVertices = mutableSetOf<VT>()

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

@@ -6,6 +6,7 @@ import prog8.ast.base.FatalAstException
 import prog8.ast.expressions.*
 import prog8.ast.statements.*
 
+
 interface IAstModifyingVisitor {
     fun visit(program: Program) {
         program.modules.forEach { visit(it) }
@@ -158,6 +159,11 @@ interface IAstModifyingVisitor {
         return whileLoop
     }
 
+    fun visit(foreverLoop: ForeverLoop): Statement {
+        foreverLoop.body = foreverLoop.body.accept(this) as AnonymousScope
+        return foreverLoop
+    }
+
     fun visit(repeatLoop: RepeatLoop): Statement {
         repeatLoop.untilCondition = repeatLoop.untilCondition.accept(this)
         repeatLoop.body = repeatLoop.body.accept(this) as AnonymousScope

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

@@ -112,6 +112,10 @@ interface IAstVisitor {
         whileLoop.body.accept(this)
     }
 
+    fun visit(foreverLoop: ForeverLoop) {
+        foreverLoop.body.accept(this)
+    }
+
     fun visit(repeatLoop: RepeatLoop) {
         repeatLoop.untilCondition.accept(this)
         repeatLoop.body.accept(this)

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

@@ -1,18 +1,11 @@
 package prog8.ast.processing
 
 import prog8.ast.Module
-import prog8.ast.base.SyntaxError
-import prog8.ast.base.printWarning
+import prog8.ast.base.ErrorReporter
 import prog8.ast.statements.Directive
 import prog8.ast.statements.Statement
 
-internal class ImportedModuleDirectiveRemover : IAstModifyingVisitor {
-    private val checkResult: MutableList<SyntaxError> = mutableListOf()
-
-    internal fun result(): List<SyntaxError> {
-        return checkResult
-    }
-
+internal class ImportedModuleDirectiveRemover(private val errors: ErrorReporter) : IAstModifyingVisitor {
     /**
      * Most global directives don't apply for imported modules, so remove them
      */
@@ -25,7 +18,7 @@ internal class ImportedModuleDirectiveRemover : IAstModifyingVisitor {
             val stmt = sourceStmt.accept(this)
             if(stmt is Directive && stmt.parent is Module) {
                 if(stmt.directive in moduleLevelDirectives) {
-                    printWarning("ignoring module directive because it was imported", stmt.position, stmt.directive)
+                    errors.warn("ignoring module directive because it was imported", stmt.position)
                     continue
                 }
             }

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

@@ -0,0 +1,24 @@
+package prog8.ast.processing
+
+import prog8.ast.expressions.NumericLiteralValue
+import prog8.ast.statements.ForeverLoop
+import prog8.ast.statements.RepeatLoop
+import prog8.ast.statements.Statement
+import prog8.ast.statements.WhileLoop
+
+internal class MakeForeverLoops : IAstModifyingVisitor {
+    override fun visit(whileLoop: WhileLoop): Statement {
+        val numeric = whileLoop.condition as? NumericLiteralValue
+        if(numeric!=null && numeric.number.toInt() != 0) {
+            return ForeverLoop(whileLoop.body, whileLoop.position)
+        }
+        return super.visit(whileLoop)
+    }
+
+    override fun visit(repeatLoop: RepeatLoop): Statement {
+        val numeric = repeatLoop.untilCondition as? NumericLiteralValue
+        if(numeric!=null && numeric.number.toInt() == 0)
+            return ForeverLoop(repeatLoop.body, repeatLoop.position)
+        return super.visit(repeatLoop)
+    }
+}

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

@@ -95,7 +95,6 @@ internal class StatementReorderer(private val program: Program): IAstModifyingVi
         module.statements.addAll(0, directives)
 
         for(pos in addReturns) {
-            println(pos)
             val returnStmt = Return(null, pos.first.position)
             returnStmt.linkParents(pos.first as Node)
             pos.first.statements.add(pos.second, returnStmt)

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

@@ -4,14 +4,15 @@ import prog8.ast.IFunctionCall
 import prog8.ast.INameScope
 import prog8.ast.Program
 import prog8.ast.base.DataType
+import prog8.ast.base.ErrorReporter
 import prog8.ast.base.FatalAstException
-import prog8.ast.base.printWarning
 import prog8.ast.expressions.*
 import prog8.ast.statements.*
 import prog8.functions.BuiltinFunctions
 
 
-internal class TypecastsAdder(private val program: Program): IAstModifyingVisitor {
+internal class TypecastsAdder(private val program: Program,
+                              private val errors: ErrorReporter): IAstModifyingVisitor {
     // Make sure any value assignments get the proper type casts if needed to cast them into the target variable's type.
     // (this includes function call arguments)
 
@@ -124,7 +125,7 @@ internal class TypecastsAdder(private val program: Program): IAstModifyingVisito
     override fun visit(typecast: TypecastExpression): Expression {
         // warn about any implicit type casts to Float, because that may not be intended
         if(typecast.implicit && typecast.type in setOf(DataType.FLOAT, DataType.ARRAY_F)) {
-            printWarning("byte or word value implicitly converted to float. Suggestion: use explicit cast as float, a float number, or revert to integer arithmetic", typecast.position)
+            errors.warn("byte or word value implicitly converted to float. Suggestion: use explicit cast as float, a float number, or revert to integer arithmetic", typecast.position)
         }
         return super.visit(typecast)
     }

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

@@ -9,7 +9,7 @@ import prog8.ast.expressions.*
 import prog8.ast.statements.*
 import prog8.compiler.CompilerException
 import prog8.functions.BuiltinFunctions
-import prog8.functions.FunctionSignature
+import prog8.functions.FSignature
 
 
 internal class VarInitValueAndAddressOfCreator(private val program: Program): IAstModifyingVisitor {
@@ -42,7 +42,7 @@ internal class VarInitValueAndAddressOfCreator(private val program: Program): IA
         if(decl.isArray && decl.value==null) {
             // array datatype without initialization value, add list of zeros
             val arraysize = decl.arraysize!!.size()!!
-            val array = ArrayLiteralValue(decl.datatype,
+            val array = ArrayLiteralValue(InferredTypes.InferredType.known(decl.datatype),
                     Array(arraysize) { NumericLiteralValue.optimalInteger(0, decl.position) },
                     decl.position)
             decl.value = array
@@ -129,7 +129,7 @@ internal class VarInitValueAndAddressOfCreator(private val program: Program): IA
         }
     }
 
-    private fun addAddressOfExprIfNeededForBuiltinFuncs(signature: FunctionSignature, args: MutableList<Expression>, parent: Statement) {
+    private fun addAddressOfExprIfNeededForBuiltinFuncs(signature: FSignature, args: MutableList<Expression>, parent: Statement) {
         // val paramTypesForAddressOf = PassByReferenceDatatypes + DataType.UWORD
         for(arg in args.withIndex().zip(signature.parameters)) {
             val argvalue = arg.first.value

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

@@ -199,7 +199,7 @@ class VarDecl(val type: VarDeclType,
 
         fun createAuto(array: ArrayLiteralValue): VarDecl {
             val autoVarName = "auto_heap_value_${++autoHeapValueSequenceNumber}"
-            val declaredType = ArrayElementTypes.getValue(array.type)
+            val declaredType = ArrayElementTypes.getValue(array.type.typeOrElse(DataType.STRUCT))
             val arraysize = ArrayIndex.forArray(array)
             return VarDecl(VarDeclType.VAR, declaredType, ZeropageWish.NOT_IN_ZEROPAGE, arraysize, autoVarName, null, array,
                     isArray = true, autogeneratedDontRemove = true, position = array.position)
@@ -594,6 +594,7 @@ class Subroutine(override val name: String,
             .count { " rti" in it || "\trti" in it || " rts" in it || "\trts" in it || " jmp" in it || "\tjmp" in it }
 }
 
+
 open class SubroutineParameter(val name: String,
                                val type: DataType,
                                override val position: Position) : Node {
@@ -662,6 +663,12 @@ class ForLoop(val loopRegister: Register?,
     override fun toString(): String {
         return "ForLoop(loopVar: $loopVar, loopReg: $loopRegister, iterable: $iterable, pos=$position)"
     }
+
+    fun loopVarDt(program: Program): InferredTypes.InferredType {
+        val lv = loopVar
+        return if(loopRegister!=null) InferredTypes.InferredType.known(DataType.UBYTE)
+                else lv?.inferType(program) ?: InferredTypes.InferredType.unknown()
+    }
 }
 
 class WhileLoop(var condition: Expression,
@@ -680,6 +687,19 @@ class WhileLoop(var condition: Expression,
     override fun accept(visitor: IAstVisitor) = visitor.visit(this)
 }
 
+class ForeverLoop(var body: AnonymousScope, override val position: Position) : Statement() {
+    override lateinit var parent: Node
+    override val expensiveToInline = true
+
+    override fun linkParents(parent: Node) {
+        this.parent = parent
+        body.linkParents(this)
+    }
+
+    override fun accept(visitor: IAstModifyingVisitor) = visitor.visit(this)
+    override fun accept(visitor: IAstVisitor) = visitor.visit(this)
+}
+
 class RepeatLoop(var body: AnonymousScope,
                  var untilCondition: Expression,
                  override val position: Position) : Statement() {

compiler/src/prog8/compiler/Main.kt

@@ -8,9 +8,8 @@ import prog8.compiler.target.CompilationTarget
 import prog8.optimizer.constantFold
 import prog8.optimizer.optimizeStatements
 import prog8.optimizer.simplifyExpressions
+import prog8.parser.ModuleImporter
 import prog8.parser.ParsingFailedError
-import prog8.parser.importLibraryModule
-import prog8.parser.importModule
 import prog8.parser.moduleName
 import java.nio.file.Path
 import kotlin.system.measureTimeMillis
@@ -32,12 +31,18 @@ fun compileProgram(filepath: Path,
     var importedFiles: List<Path> = emptyList()
     var success=false
 
+    val errors = ErrorReporter()
+
     try {
         val totalTime = measureTimeMillis {
             // import main module and everything it needs
+            val importer = ModuleImporter(errors)
+            errors.handle()
+
             println("Parsing...")
             programAst = Program(moduleName(filepath.fileName), mutableListOf())
-            importModule(programAst, filepath)
+            importer.importModule(programAst, filepath)
+            errors.handle()
 
             importedFiles = programAst.modules.filter { !it.source.startsWith("@embedded@") }.map{ it.source }
 
@@ -47,61 +52,73 @@ fun compileProgram(filepath: Path,
 
             // if we're producing a PRG or BASIC program, include the c64utils and c64lib libraries
             if (compilerOptions.launcher == LauncherType.BASIC || compilerOptions.output == OutputType.PRG) {
-                importLibraryModule(programAst, "c64lib")
-                importLibraryModule(programAst, "c64utils")
+                importer.importLibraryModule(programAst, "c64lib")
+                importer.importLibraryModule(programAst, "c64utils")
             }
 
             // always import prog8lib and math
-            importLibraryModule(programAst, "math")
-            importLibraryModule(programAst, "prog8lib")
-
+            importer.importLibraryModule(programAst, "math")
+            importer.importLibraryModule(programAst, "prog8lib")
+            errors.handle()
 
             // perform initial syntax checks and constant folding
             println("Syntax check...")
             val time1 = measureTimeMillis {
-                programAst.checkIdentifiers()
+                programAst.checkIdentifiers(errors)
+                errors.handle()
+                programAst.makeForeverLoops()
             }
 
             //println(" time1: $time1")
             val time2 = measureTimeMillis {
-                programAst.constantFold()
+                programAst.constantFold(errors)
+                errors.handle()
             }
             //println(" time2: $time2")
             val time3 = measureTimeMillis {
                 programAst.removeNopsFlattenAnonScopes()
                 programAst.reorderStatements()
-                programAst.addTypecasts()
+                programAst.addTypecasts(errors)
+                errors.handle()
             }
             //println(" time3: $time3")
             val time4 = measureTimeMillis {
-                programAst.checkValid(compilerOptions)          // check if tree is valid
+                programAst.checkValid(compilerOptions, errors)          // check if tree is valid
+                errors.handle()
             }
             //println(" time4: $time4")
 
-            programAst.checkIdentifiers()
+            programAst.checkIdentifiers(errors)
+            errors.handle()
+
             if (optimize) {
                 // optimize the parse tree
                 println("Optimizing...")
                 while (true) {
                     // keep optimizing expressions and statements until no more steps remain
                     val optsDone1 = programAst.simplifyExpressions()
-                    val optsDone2 = programAst.optimizeStatements()
+                    val optsDone2 = programAst.optimizeStatements(errors)
+                    errors.handle()
                     if (optsDone1 + optsDone2 == 0)
                         break
                 }
             }
 
-            programAst.addTypecasts()
+            programAst.addTypecasts(errors)
+            errors.handle()
             programAst.removeNopsFlattenAnonScopes()
-            programAst.checkValid(compilerOptions)          // check if final tree is valid
-            programAst.checkRecursion()         // check if there are recursive subroutine calls
+            programAst.checkValid(compilerOptions, errors)          // check if final tree is valid
+            errors.handle()
+            programAst.checkRecursion(errors)         // check if there are recursive subroutine calls
+            errors.handle()
 
             // printAst(programAst)
 
             if(writeAssembly) {
                 // asm generation directly from the Ast, no need for intermediate code
                 val zeropage = CompilationTarget.machine.getZeropage(compilerOptions)
-                programAst.anonscopeVarsCleanup()
+                programAst.anonscopeVarsCleanup(errors)
+                errors.handle()
                 val assembly = CompilationTarget.asmGenerator(programAst, zeropage, compilerOptions, outputDir).compileToAssembly(optimize)
                 assembly.assemble(compilerOptions)
                 programName = assembly.name

compiler/src/prog8/compiler/Zeropage.kt

@@ -15,7 +15,7 @@ abstract class Zeropage(protected val options: CompilationOptions) {
 
     fun available() = if(options.zeropage==ZeropageType.DONTUSE) 0 else free.size
 
-    fun allocate(scopedname: String, datatype: DataType, position: Position?): Int {
+    fun allocate(scopedname: String, datatype: DataType, position: Position?, errors: ErrorReporter): Int {
         assert(scopedname.isEmpty() || !allocations.values.any { it.first==scopedname } ) {"isSameAs scopedname can't be allocated twice"}
 
         if(options.zeropage==ZeropageType.DONTUSE)
@@ -28,9 +28,9 @@ abstract class Zeropage(protected val options: CompilationOptions) {
                     DataType.FLOAT -> {
                         if (options.floats) {
                             if(position!=null)
-                                printWarning("allocated a large value (float) in zeropage", position)
+                                errors.warn("allocated a large value (float) in zeropage", position)
                             else
-                                printWarning("$scopedname: allocated a large value (float) in zeropage")
+                                errors.warn("$scopedname: allocated a large value (float) in zeropage", null)
                             5
                         } else throw CompilerException("floating point option not enabled")
                     }

compiler/src/prog8/compiler/target/CompilationTarget.kt

@@ -9,8 +9,8 @@ internal interface CompilationTarget {
     companion object {
         lateinit var name: String
         lateinit var machine: IMachineDefinition
-        lateinit var encodeString: (str: String) -> List<Short>
-        lateinit var decodeString: (bytes: List<Short>) -> String
+        lateinit var encodeString: (str: String, altEncoding: Boolean) -> List<Short>
+        lateinit var decodeString: (bytes: List<Short>, altEncoding: Boolean) -> String
         lateinit var asmGenerator: (Program, Zeropage, CompilationOptions, Path) -> IAssemblyGenerator
     }
 }

compiler/src/prog8/compiler/target/IAssemblyGenerator.kt

@@ -6,6 +6,8 @@ internal interface IAssemblyGenerator {
     fun compileToAssembly(optimize: Boolean): IAssemblyProgram
 }
 
+internal const val generatedLabelPrefix = "_prog8_label_"
+
 internal interface IAssemblyProgram {
     val name: String
     fun assemble(options: CompilationOptions)

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

@@ -3,10 +3,11 @@ package prog8.compiler.target.c64
 import prog8.compiler.CompilationOptions
 import prog8.compiler.OutputType
 import prog8.compiler.target.IAssemblyProgram
+import prog8.compiler.target.generatedLabelPrefix
 import java.nio.file.Path
 import kotlin.system.exitProcess
 
-class AssemblyProgram(override val name: String, outputDir: Path): IAssemblyProgram {
+class AssemblyProgram(override val name: String, outputDir: Path) : IAssemblyProgram {
     private val assemblyFile = outputDir.resolve("$name.asm")
     private val prgFile = outputDir.resolve("$name.prg")
     private val binFile = outputDir.resolve("$name.bin")
@@ -18,7 +19,7 @@ class AssemblyProgram(override val name: String, outputDir: Path): IAssemblyProg
                 "-Wall", "-Wno-strict-bool", "-Wno-shadow", "-Werror", "-Wno-error=long-branch",
                 "--dump-labels", "--vice-labels", "-l", viceMonListFile.toString(), "--no-monitor")
 
-        val outFile = when(options.output) {
+        val outFile = when (options.output) {
             OutputType.PRG -> {
                 command.add("--cbm-prg")
                 println("\nCreating C-64 prg.")
@@ -34,27 +35,39 @@ class AssemblyProgram(override val name: String, outputDir: Path): IAssemblyProg
 
         val proc = ProcessBuilder(command).inheritIO().start()
         val result = proc.waitFor()
-        if(result!=0) {
+        if (result != 0) {
             System.err.println("assembler failed with returncode $result")
             exitProcess(result)
         }
 
+        removeGeneratedLabelsFromMonlist()
         generateBreakpointList()
     }
 
+    private fun removeGeneratedLabelsFromMonlist() {
+        val pattern = Regex("""al (\w+) \S+${generatedLabelPrefix}.+?""")
+        val lines = viceMonListFile.toFile().readLines()
+        viceMonListFile.toFile().outputStream().bufferedWriter().use {
+            for (line in lines) {
+                if(pattern.matchEntire(line)==null)
+                    it.write(line+"\n")
+            }
+        }
+    }
+
     private fun generateBreakpointList() {
         // builds list of breakpoints, appends to monitor list file
         val breakpoints = mutableListOf<String>()
-        val pattern = Regex("""al (\w+) \S+_prog8_breakpoint_\d+.?""")      // gather breakpoints by the source label that"s generated for them
-        for(line in viceMonListFile.toFile().readLines()) {
+        val pattern = Regex("""al (\w+) \S+_prog8_breakpoint_\d+.?""")      // gather breakpoints by the source label that's generated for them
+        for (line in viceMonListFile.toFile().readLines()) {
             val match = pattern.matchEntire(line)
-            if(match!=null)
-            breakpoints.add("break \$" + match.groupValues[1])
+            if (match != null)
+                breakpoints.add("break \$" + match.groupValues[1])
         }
         val num = breakpoints.size
         breakpoints.add(0, "; vice monitor breakpoint list now follows")
         breakpoints.add(1, "; $num breakpoints have been defined")
         breakpoints.add(2, "del")
-        viceMonListFile.toFile().appendText(breakpoints.joinToString("\n")+"\n")
+        viceMonListFile.toFile().appendText(breakpoints.joinToString("\n") + "\n")
     }
 }

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

@@ -11,16 +11,17 @@ import prog8.compiler.target.IAssemblyGenerator
 import prog8.compiler.target.IAssemblyProgram
 import prog8.compiler.target.c64.AssemblyProgram
 import prog8.compiler.target.c64.C64MachineDefinition
-import prog8.compiler.target.c64.C64MachineDefinition.ESTACK_LO_HEX
 import prog8.compiler.target.c64.C64MachineDefinition.ESTACK_HI_HEX
+import prog8.compiler.target.c64.C64MachineDefinition.ESTACK_LO_HEX
 import prog8.compiler.target.c64.Petscii
+import prog8.compiler.target.generatedLabelPrefix
 import prog8.functions.BuiltinFunctions
-import prog8.functions.FunctionSignature
+import prog8.functions.FSignature
 import java.math.RoundingMode
 import java.nio.file.Path
 import java.time.LocalDate
 import java.time.LocalDateTime
-import java.util.ArrayDeque
+import java.util.*
 import kotlin.math.absoluteValue
 
 
@@ -96,11 +97,15 @@ internal class AsmGen(private val program: Program,
                 out("  .null  $9e, format(' %d ', _prog8_entrypoint), $3a, $8f, ' prog8 by idj'")
                 out("+\t.word  0")
                 out("_prog8_entrypoint\t; assembly code starts here\n")
+                out("  tsx")
+                out("  stx  prog8_lib.orig_stackpointer")
                 out("  jsr  prog8_lib.init_system")
             }
             options.output == OutputType.PRG -> {
                 out("; ---- program without basic sys call ----")
                 out("* = ${program.actualLoadAddress.toHex()}\n")
+                out("  tsx")
+                out("  stx  prog8_lib.orig_stackpointer")
                 out("  jsr  prog8_lib.init_system")
             }
             options.output == OutputType.RAW -> {
@@ -137,7 +142,6 @@ internal class AsmGen(private val program: Program,
                 out("  jmp  (c64.RESET_VEC)\t; cold reset")
             }
         }
-        out("")
     }
 
     private fun footer() {
@@ -178,7 +182,7 @@ internal class AsmGen(private val program: Program,
 
     internal fun makeLabel(postfix: String): String {
         generatedLabelSequenceNumber++
-        return "_prog8_label_${generatedLabelSequenceNumber}_$postfix"
+        return "${generatedLabelPrefix}${generatedLabelSequenceNumber}_$postfix"
     }
 
     private fun outputSourceLine(node: Node) {
@@ -206,8 +210,8 @@ internal class AsmGen(private val program: Program,
         return "$b0, $b1, $b2, $b3, $b4"
     }
 
-    private fun petscii(str: String): List<Short> {
-         val bytes = Petscii.encodePetscii(str, true)
+    private fun encode(str: String, altEncoding: Boolean): List<Short> {
+         val bytes = if(altEncoding) Petscii.encodeScreencode(str, true) else Petscii.encodePetscii(str, true)
          return bytes.plus(0)
     }
 
@@ -225,7 +229,9 @@ internal class AsmGen(private val program: Program,
                         && variable.datatype != DataType.FLOAT
                         && options.zeropage != ZeropageType.DONTUSE) {
                     try {
-                        val address = zeropage.allocate(fullName, variable.datatype, null)
+                        val errors = ErrorReporter()
+                        val address = zeropage.allocate(fullName, variable.datatype, null, errors)
+                        errors.handle()
                         out("${variable.name} = $address\t; auto zp ${variable.datatype}")
                         // make sure we add the var to the set of zpvars for this block
                         allocatedZeropageVariables[fullName] = Pair(address, variable.datatype)
@@ -246,8 +252,8 @@ internal class AsmGen(private val program: Program,
             DataType.FLOAT -> out("${decl.name}\t.byte  0,0,0,0,0  ; float")
             DataType.STRUCT -> {}       // is flattened
             DataType.STR -> {
-                val string = (decl.value as StringLiteralValue).value
-                outputStringvar(decl, petscii(string))
+                val str = decl.value as StringLiteralValue
+                outputStringvar(decl, encode(str.value, str.altEncoding))
             }
             DataType.ARRAY_UB -> {
                 val data = makeArrayFillDataUnsigned(decl)
@@ -331,7 +337,10 @@ internal class AsmGen(private val program: Program,
         // special treatment for string types: merge strings that are identical
         val encodedstringVars = normalVars
                 .filter {it.datatype == DataType.STR }
-                .map { it to petscii((it.value as StringLiteralValue).value) }
+                .map {
+                    val str = it.value as StringLiteralValue
+                    it to encode(str.value, str.altEncoding)
+                }
                 .groupBy({it.second}, {it.first})
         for((encoded, variables) in encodedstringVars) {
             variables.dropLast(1).forEach { out(it.name) }
@@ -595,11 +604,13 @@ internal class AsmGen(private val program: Program,
             is Continue -> out("  jmp  ${loopContinueLabels.peek()}")
             is Break -> out("  jmp  ${loopEndLabels.peek()}")
             is WhileLoop -> translate(stmt)
+            is ForeverLoop -> translate(stmt)
             is RepeatLoop -> translate(stmt)
             is WhenStatement -> translate(stmt)
             is BuiltinFunctionStatementPlaceholder -> throw AssemblyError("builtin function should not have placeholder anymore?")
             is AnonymousScope -> translate(stmt)
             is Block -> throw AssemblyError("block should have been handled elsewhere")
+            else -> TODO("no translation for $stmt")
         }
     }
 
@@ -625,6 +636,19 @@ internal class AsmGen(private val program: Program,
         }
     }
 
+    private fun translate(stmt: ForeverLoop) {
+        val foreverLabel = makeLabel("forever")
+        val endLabel = makeLabel("foreverend")
+        loopEndLabels.push(endLabel)
+        loopContinueLabels.push(foreverLabel)
+        out(foreverLabel)
+        translate(stmt.body)
+        out("  jmp  $foreverLabel")
+        out(endLabel)
+        loopEndLabels.pop()
+        loopContinueLabels.pop()
+    }
+
     private fun translate(stmt: WhileLoop) {
         val whileLabel = makeLabel("while")
         val endLabel = makeLabel("whileend")
@@ -726,7 +750,7 @@ internal class AsmGen(private val program: Program,
     }
 
     private fun translate(stmt: Label) {
-        out(stmt.name)
+        out("_${stmt.name}")        // underscore prefix to make sure it's a local label
     }
 
     private fun translate(scope: AnonymousScope) {
@@ -795,7 +819,14 @@ internal class AsmGen(private val program: Program,
 
     private fun getJumpTarget(jmp: Jump): String {
         return when {
-            jmp.identifier!=null -> asmIdentifierName(jmp.identifier)
+            jmp.identifier!=null -> {
+                val target = jmp.identifier.targetStatement(program.namespace)
+                val asmName = asmIdentifierName(jmp.identifier)
+                if(target is Label)
+                    "_$asmName"  // prefix with underscore to jump to local label
+                else
+                    asmName
+            }
             jmp.generatedLabel!=null -> jmp.generatedLabel
             jmp.address!=null -> jmp.address.toHex()
             else -> "????"
@@ -836,7 +867,7 @@ internal class AsmGen(private val program: Program,
     internal fun translateExpression(expression: Expression) =
             expressionsAsmGen.translateExpression(expression)
 
-    internal fun translateFunctioncallExpression(functionCall: FunctionCall, signature: FunctionSignature) =
+    internal fun translateFunctioncallExpression(functionCall: FunctionCall, signature: FSignature) =
             builtinFunctionsAsmGen.translateFunctioncallExpression(functionCall, signature)
 
     internal fun translateFunctionCall(functionCall: FunctionCall) =

compiler/src/prog8/compiler/target/c64/codegen/AssignmentAsmGen.kt

@@ -7,12 +7,12 @@ import prog8.ast.statements.AssignTarget
 import prog8.ast.statements.Assignment
 import prog8.ast.statements.DirectMemoryWrite
 import prog8.ast.statements.VarDecl
-import prog8.compiler.toHex
 import prog8.compiler.AssemblyError
 import prog8.compiler.target.c64.C64MachineDefinition
 import prog8.compiler.target.c64.C64MachineDefinition.C64Zeropage
 import prog8.compiler.target.c64.C64MachineDefinition.ESTACK_HI_HEX
 import prog8.compiler.target.c64.C64MachineDefinition.ESTACK_LO_HEX
+import prog8.compiler.toHex
 
 
 internal class AssignmentAsmGen(private val program: Program, private val asmgen: AsmGen) {
@@ -313,7 +313,7 @@ internal class AssignmentAsmGen(private val program: Program, private val asmgen
      sta  (+) +1
      sty  (+) +2
      lda  $sourceName
-+    sta  ${65535.toHex()}      ; modified              
++    sta  ${'$'}ffff      ; modified              
                             """)
                     }
                 }
@@ -469,7 +469,7 @@ internal class AssignmentAsmGen(private val program: Program, private val asmgen
      sta  (+) +1
      lda  $ESTACK_HI_HEX,x
      sta  (+) +2
-+    sty  ${65535.toHex()}      ; modified              
++    sty  ${'$'}ffff      ; modified              
                             """)
             }
         }

compiler/src/prog8/compiler/target/c64/codegen/BuiltinFunctionsAsmGen.kt

@@ -9,26 +9,26 @@ import prog8.ast.base.WordDatatypes
 import prog8.ast.expressions.*
 import prog8.ast.statements.AssignTarget
 import prog8.ast.statements.FunctionCallStatement
+import prog8.compiler.AssemblyError
 import prog8.compiler.target.c64.C64MachineDefinition.C64Zeropage
 import prog8.compiler.target.c64.C64MachineDefinition.ESTACK_HI_HEX
 import prog8.compiler.target.c64.C64MachineDefinition.ESTACK_HI_PLUS1_HEX
 import prog8.compiler.target.c64.C64MachineDefinition.ESTACK_LO_HEX
 import prog8.compiler.target.c64.C64MachineDefinition.ESTACK_LO_PLUS1_HEX
 import prog8.compiler.toHex
-import prog8.compiler.AssemblyError
-import prog8.functions.FunctionSignature
+import prog8.functions.FSignature
 
 internal class BuiltinFunctionsAsmGen(private val program: Program, private val asmgen: AsmGen) {
 
-    internal fun translateFunctioncallExpression(fcall: FunctionCall, func: FunctionSignature) {
+    internal fun translateFunctioncallExpression(fcall: FunctionCall, func: FSignature) {
         translateFunctioncall(fcall, func, false)
     }
 
-    internal fun translateFunctioncallStatement(fcall: FunctionCallStatement, func: FunctionSignature) {
+    internal fun translateFunctioncallStatement(fcall: FunctionCallStatement, func: FSignature) {
         translateFunctioncall(fcall, func, true)
     }
 
-    private fun translateFunctioncall(fcall: IFunctionCall, func: FunctionSignature, discardResult: Boolean) {
+    private fun translateFunctioncall(fcall: IFunctionCall, func: FSignature, discardResult: Boolean) {
         val functionName = fcall.target.nameInSource.last()
         if (discardResult) {
             if (func.pure)
@@ -149,7 +149,7 @@ internal class BuiltinFunctionsAsmGen(private val program: Program, private val
                     sta  (+) + 1
                     lda  $ESTACK_HI_HEX,x
                     sta  (+) + 2
-+                   asl  0            ; modified                    
++                   asl  ${'$'}ffff            ; modified                    
                                     """)
                                 }
                             }
@@ -205,7 +205,7 @@ internal class BuiltinFunctionsAsmGen(private val program: Program, private val
                     sta  (+) + 1
                     lda  $ESTACK_HI_HEX,x
                     sta  (+) + 2
-+                   lsr  0            ; modified                    
++                   lsr  ${'$'}ffff            ; modified                    
                                     """)
                                 }
                             }
@@ -286,7 +286,7 @@ internal class BuiltinFunctionsAsmGen(private val program: Program, private val
                     sta  (+) + 1
                     lda  $ESTACK_HI_HEX,x
                     sta  (+) + 2
-+                   rol  0            ; modified                    
++                   rol  ${'$'}ffff            ; modified                    
                                     """)
                                 }
                             }
@@ -397,7 +397,7 @@ internal class BuiltinFunctionsAsmGen(private val program: Program, private val
                     sta  (+) + 1
                     lda  $ESTACK_HI_HEX,x
                     sta  (+) + 2
-+                   ror  0            ; modified                    
++                   ror  ${'$'}ffff            ; modified                    
                                     """)                                }
                             }
                             is RegisterExpr -> {
@@ -512,7 +512,7 @@ internal class BuiltinFunctionsAsmGen(private val program: Program, private val
                             """)
                             asmgen.out(if(decl.datatype==DataType.ARRAY_UW) "  jsr  prog8_lib.sort_uw" else "  jsr  prog8_lib.sort_w")
                         }
-                        DataType.ARRAY_F -> TODO("sort floats (consider another solution if possible - this will be very slow, if ever implemented)")
+                        DataType.ARRAY_F -> throw AssemblyError("sorting of floating point array is not supported")
                         else -> throw AssemblyError("weird type")
                     }
                 }
@@ -546,7 +546,16 @@ internal class BuiltinFunctionsAsmGen(private val program: Program, private val
                                 jsr  prog8_lib.reverse_w
                             """)
                         }
-                        DataType.ARRAY_F -> TODO("reverse floats (consider another solution if possible - this will be quite slow, if ever implemented)")
+                        DataType.ARRAY_F -> {
+                            asmgen.out("""
+                                lda  #<$varName
+                                ldy  #>$varName
+                                sta  ${C64Zeropage.SCRATCH_W1}
+                                sty  ${C64Zeropage.SCRATCH_W1 + 1}
+                                lda  #$numElements
+                                jsr  prog8_lib.reverse_f
+                            """)
+                        }
                         else -> throw AssemblyError("weird type")
                     }
                 }
@@ -594,7 +603,7 @@ internal class BuiltinFunctionsAsmGen(private val program: Program, private val
                     """)
     }
 
-    private fun translateFunctionArguments(args: MutableList<Expression>, signature: FunctionSignature) {
+    private fun translateFunctionArguments(args: MutableList<Expression>, signature: FSignature) {
         args.forEach {
             asmgen.translateExpression(it)
         }

compiler/src/prog8/compiler/target/c64/codegen/ExpressionsAsmGen.kt

@@ -3,13 +3,13 @@ package prog8.compiler.target.c64.codegen
 import prog8.ast.Program
 import prog8.ast.base.*
 import prog8.ast.expressions.*
-import prog8.compiler.toHex
 import prog8.compiler.AssemblyError
 import prog8.compiler.target.c64.C64MachineDefinition.ESTACK_HI_HEX
 import prog8.compiler.target.c64.C64MachineDefinition.ESTACK_HI_PLUS1_HEX
 import prog8.compiler.target.c64.C64MachineDefinition.ESTACK_LO_HEX
 import prog8.compiler.target.c64.C64MachineDefinition.ESTACK_LO_PLUS1_HEX
 import prog8.compiler.target.c64.C64MachineDefinition.ESTACK_LO_PLUS2_HEX
+import prog8.compiler.toHex
 import prog8.functions.BuiltinFunctions
 import kotlin.math.absoluteValue
 
@@ -158,7 +158,7 @@ internal class ExpressionsAsmGen(private val program: Program, private val asmge
     private fun translateExpression(expr: RegisterExpr) {
         when(expr.register) {
             Register.A -> asmgen.out(" sta  $ESTACK_LO_HEX,x | dex")
-            Register.X -> throw AssemblyError("cannot push X - use a variable instead of the X register")
+            Register.X -> asmgen.out(" txa |  sta  $ESTACK_LO_HEX,x | dex")
             Register.Y -> asmgen.out(" tya |  sta  $ESTACK_LO_HEX,x | dex")
         }
     }
@@ -224,8 +224,6 @@ internal class ExpressionsAsmGen(private val program: Program, private val asmge
                 if(value!=null) {
                     if(rightDt in IntegerDatatypes) {
                         val amount = value.number.toInt()
-                        if(amount in powersOfTwo)
-                            printWarning("${expr.right.position} multiplication by power of 2 should have been optimized into a left shift instruction: $amount")
                         when(rightDt) {
                             DataType.UBYTE -> {
                                 if(amount in optimizedByteMultiplications) {

compiler/src/prog8/compiler/target/c64/codegen/ForLoopsAsmGen.kt

@@ -8,11 +8,11 @@ import prog8.ast.expressions.RangeExpr
 import prog8.ast.statements.AssignTarget
 import prog8.ast.statements.Assignment
 import prog8.ast.statements.ForLoop
+import prog8.compiler.AssemblyError
+import prog8.compiler.target.c64.C64MachineDefinition.ESTACK_HI_PLUS1_HEX
 import prog8.compiler.target.c64.C64MachineDefinition.ESTACK_LO_HEX
 import prog8.compiler.target.c64.C64MachineDefinition.ESTACK_LO_PLUS1_HEX
-import prog8.compiler.target.c64.C64MachineDefinition.ESTACK_HI_PLUS1_HEX
 import prog8.compiler.toHex
-import prog8.compiler.AssemblyError
 import kotlin.math.absoluteValue
 
 // todo choose more efficient comparisons to avoid needless lda's

compiler/src/prog8/compiler/target/c64/codegen/FunctionCallAsmGen.kt

@@ -7,10 +7,10 @@ import prog8.ast.expressions.*
 import prog8.ast.statements.AssignTarget
 import prog8.ast.statements.Subroutine
 import prog8.ast.statements.SubroutineParameter
-import prog8.compiler.toHex
 import prog8.compiler.AssemblyError
 import prog8.compiler.target.c64.C64MachineDefinition.ESTACK_HI_HEX
 import prog8.compiler.target.c64.C64MachineDefinition.ESTACK_LO_HEX
+import prog8.compiler.toHex
 
 
 internal class FunctionCallAsmGen(private val program: Program, private val asmgen: AsmGen) {

compiler/src/prog8/compiler/target/c64/codegen/PostIncrDecrAsmGen.kt

@@ -6,9 +6,9 @@ import prog8.ast.expressions.IdentifierReference
 import prog8.ast.expressions.NumericLiteralValue
 import prog8.ast.expressions.RegisterExpr
 import prog8.ast.statements.PostIncrDecr
-import prog8.compiler.toHex
 import prog8.compiler.AssemblyError
 import prog8.compiler.target.c64.C64MachineDefinition.C64Zeropage
+import prog8.compiler.toHex
 
 
 internal class PostIncrDecrAsmGen(private val program: Program, private val asmgen: AsmGen) {

compiler/src/prog8/functions/BuiltinFunctions.kt

@@ -7,88 +7,87 @@ import prog8.compiler.CompilerException
 import kotlin.math.*
 
 
-class BuiltinFunctionParam(val name: String, val possibleDatatypes: Set<DataType>)
+class FParam(val name: String, val possibleDatatypes: Set<DataType>)
 
 
 typealias ConstExpressionCaller = (args: List<Expression>, position: Position, program: Program) -> NumericLiteralValue
 
 
-class FunctionSignature(val pure: Boolean,      // does it have side effects?
-                        val parameters: List<BuiltinFunctionParam>,
-                        val returntype: DataType?,
-                        val constExpressionFunc: ConstExpressionCaller? = null)
+class FSignature(val pure: Boolean,      // does it have side effects?
+                 val parameters: List<FParam>,
+                 val returntype: DataType?,
+                 val constExpressionFunc: ConstExpressionCaller? = null)
 
 
 val BuiltinFunctions = mapOf(
         // this set of function have no return value and operate in-place:
-    "rol"         to FunctionSignature(false, listOf(BuiltinFunctionParam("item", setOf(DataType.UBYTE, DataType.UWORD))), null),
-    "ror"         to FunctionSignature(false, listOf(BuiltinFunctionParam("item", setOf(DataType.UBYTE, DataType.UWORD))), null),
-    "rol2"        to FunctionSignature(false, listOf(BuiltinFunctionParam("item", setOf(DataType.UBYTE, DataType.UWORD))), null),
-    "ror2"        to FunctionSignature(false, listOf(BuiltinFunctionParam("item", setOf(DataType.UBYTE, DataType.UWORD))), null),
-    "lsl"         to FunctionSignature(false, listOf(BuiltinFunctionParam("item", IntegerDatatypes)), null),
-    "lsr"         to FunctionSignature(false, listOf(BuiltinFunctionParam("item", IntegerDatatypes)), null),
-    "sort"        to FunctionSignature(false, listOf(BuiltinFunctionParam("array", ArrayDatatypes)), null),
-    "reverse"     to FunctionSignature(false, listOf(BuiltinFunctionParam("array", ArrayDatatypes)), null),
+    "rol"         to FSignature(false, listOf(FParam("item", setOf(DataType.UBYTE, DataType.UWORD))), null),
+    "ror"         to FSignature(false, listOf(FParam("item", setOf(DataType.UBYTE, DataType.UWORD))), null),
+    "rol2"        to FSignature(false, listOf(FParam("item", setOf(DataType.UBYTE, DataType.UWORD))), null),
+    "ror2"        to FSignature(false, listOf(FParam("item", setOf(DataType.UBYTE, DataType.UWORD))), null),
+    "lsl"         to FSignature(false, listOf(FParam("item", IntegerDatatypes)), null),
+    "lsr"         to FSignature(false, listOf(FParam("item", IntegerDatatypes)), null),
+    "sort"        to FSignature(false, listOf(FParam("array", ArrayDatatypes)), null),
+    "reverse"     to FSignature(false, listOf(FParam("array", ArrayDatatypes)), null),
         // these few have a return value depending on the argument(s):
-    "max"         to FunctionSignature(true, listOf(BuiltinFunctionParam("values", ArrayDatatypes)), null) { a, p, prg -> collectionArg(a, p, prg, ::builtinMax) },    // type depends on args
-    "min"         to FunctionSignature(true, listOf(BuiltinFunctionParam("values", ArrayDatatypes)), null) { a, p, prg -> collectionArg(a, p, prg, ::builtinMin) },    // type depends on args
-    "sum"         to FunctionSignature(true, listOf(BuiltinFunctionParam("values", ArrayDatatypes)), null) { a, p, prg -> collectionArg(a, p, prg, ::builtinSum) },      // 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
+    "max"         to FSignature(true, listOf(FParam("values", ArrayDatatypes)), null) { a, p, prg -> collectionArg(a, p, prg, ::builtinMax) },    // type depends on args
+    "min"         to FSignature(true, listOf(FParam("values", ArrayDatatypes)), null) { a, p, prg -> collectionArg(a, p, prg, ::builtinMin) },    // type depends on args
+    "sum"         to FSignature(true, listOf(FParam("values", ArrayDatatypes)), null) { a, p, prg -> collectionArg(a, p, prg, ::builtinSum) },      // type depends on args
+    "abs"         to FSignature(true, listOf(FParam("value", NumericDatatypes)), null, ::builtinAbs),      // type depends on argument
+    "len"         to FSignature(true, listOf(FParam("values", IterableDatatypes)), null, ::builtinLen),    // type is UBYTE or UWORD depending on actual length
         // normal functions follow:
-    "sgn"         to FunctionSignature(true, listOf(BuiltinFunctionParam("value", NumericDatatypes)), DataType.BYTE, ::builtinSgn ),
-    "sin"         to FunctionSignature(true, listOf(BuiltinFunctionParam("rads", setOf(DataType.FLOAT))), DataType.FLOAT) { a, p, prg -> oneDoubleArg(a, p, prg, Math::sin) },
-    "sin8"        to FunctionSignature(true, listOf(BuiltinFunctionParam("angle8", setOf(DataType.UBYTE))), DataType.BYTE, ::builtinSin8 ),
-    "sin8u"       to FunctionSignature(true, listOf(BuiltinFunctionParam("angle8", setOf(DataType.UBYTE))), DataType.UBYTE, ::builtinSin8u ),
-    "sin16"       to FunctionSignature(true, listOf(BuiltinFunctionParam("angle8", setOf(DataType.UBYTE))), DataType.WORD, ::builtinSin16 ),
-    "sin16u"      to FunctionSignature(true, listOf(BuiltinFunctionParam("angle8", setOf(DataType.UBYTE))), DataType.UWORD, ::builtinSin16u ),
-    "cos"         to FunctionSignature(true, listOf(BuiltinFunctionParam("rads", setOf(DataType.FLOAT))), DataType.FLOAT) { a, p, prg -> oneDoubleArg(a, p, prg, Math::cos) },
-    "cos8"        to FunctionSignature(true, listOf(BuiltinFunctionParam("angle8", setOf(DataType.UBYTE))), DataType.BYTE, ::builtinCos8 ),
-    "cos8u"       to FunctionSignature(true, listOf(BuiltinFunctionParam("angle8", setOf(DataType.UBYTE))), DataType.UBYTE, ::builtinCos8u ),
-    "cos16"       to FunctionSignature(true, listOf(BuiltinFunctionParam("angle8", setOf(DataType.UBYTE))), DataType.WORD, ::builtinCos16 ),
-    "cos16u"      to FunctionSignature(true, listOf(BuiltinFunctionParam("angle8", setOf(DataType.UBYTE))), DataType.UWORD, ::builtinCos16u ),
-    "tan"         to FunctionSignature(true, listOf(BuiltinFunctionParam("rads", setOf(DataType.FLOAT))), DataType.FLOAT) { a, p, prg -> oneDoubleArg(a, p, prg, Math::tan) },
-    "atan"        to FunctionSignature(true, listOf(BuiltinFunctionParam("rads", setOf(DataType.FLOAT))), DataType.FLOAT) { a, p, prg -> oneDoubleArg(a, p, prg, Math::atan) },
-    "ln"          to FunctionSignature(true, listOf(BuiltinFunctionParam("value", setOf(DataType.FLOAT))), DataType.FLOAT) { a, p, prg -> oneDoubleArg(a, p, prg, Math::log) },
-    "log2"        to FunctionSignature(true, listOf(BuiltinFunctionParam("value", setOf(DataType.FLOAT))), DataType.FLOAT) { a, p, prg -> oneDoubleArg(a, p, prg, ::log2) },
-    "sqrt16"      to FunctionSignature(true, listOf(BuiltinFunctionParam("value", setOf(DataType.UWORD))), DataType.UBYTE) { a, p, prg -> oneIntArgOutputInt(a, p, prg) { sqrt(it.toDouble()).toInt() } },
-    "sqrt"        to FunctionSignature(true, listOf(BuiltinFunctionParam("value", setOf(DataType.FLOAT))), DataType.FLOAT) { a, p, prg -> oneDoubleArg(a, p, prg, Math::sqrt) },
-    "rad"         to FunctionSignature(true, listOf(BuiltinFunctionParam("value", setOf(DataType.FLOAT))), DataType.FLOAT) { a, p, prg -> oneDoubleArg(a, p, prg, Math::toRadians) },
-    "deg"         to FunctionSignature(true, listOf(BuiltinFunctionParam("value", setOf(DataType.FLOAT))), DataType.FLOAT) { a, p, prg -> oneDoubleArg(a, p, prg, Math::toDegrees) },
-    "round"       to FunctionSignature(true, listOf(BuiltinFunctionParam("value", setOf(DataType.FLOAT))), DataType.FLOAT) { a, p, prg -> oneDoubleArgOutputWord(a, p, prg, Math::round) },
-    "floor"       to FunctionSignature(true, listOf(BuiltinFunctionParam("value", setOf(DataType.FLOAT))), DataType.FLOAT) { a, p, prg -> oneDoubleArgOutputWord(a, p, prg, Math::floor) },
-    "ceil"        to FunctionSignature(true, listOf(BuiltinFunctionParam("value", setOf(DataType.FLOAT))), DataType.FLOAT) { a, p, prg -> oneDoubleArgOutputWord(a, p, prg, Math::ceil) },
-    "any"         to FunctionSignature(true, listOf(BuiltinFunctionParam("values", ArrayDatatypes)), DataType.UBYTE) { a, p, prg -> collectionArg(a, p, prg, ::builtinAny) },
-    "all"         to FunctionSignature(true, listOf(BuiltinFunctionParam("values", ArrayDatatypes)), DataType.UBYTE) { a, p, prg -> collectionArg(a, p, prg, ::builtinAll) },
-    "lsb"         to FunctionSignature(true, listOf(BuiltinFunctionParam("value", setOf(DataType.UWORD, DataType.WORD))), DataType.UBYTE) { a, p, prg -> oneIntArgOutputInt(a, p, prg) { x: Int -> x and 255 }},
-    "msb"         to FunctionSignature(true, listOf(BuiltinFunctionParam("value", setOf(DataType.UWORD, DataType.WORD))), DataType.UBYTE) { a, p, prg -> oneIntArgOutputInt(a, p, prg) { x: Int -> x ushr 8 and 255}},
-    "mkword"      to FunctionSignature(true, listOf(
-                                                        BuiltinFunctionParam("lsb", setOf(DataType.UBYTE)),
-                                                        BuiltinFunctionParam("msb", setOf(DataType.UBYTE))), DataType.UWORD, ::builtinMkword),
-    "rnd"         to FunctionSignature(true, emptyList(), DataType.UBYTE),
-    "rndw"        to FunctionSignature(true, emptyList(), DataType.UWORD),
-    "rndf"        to FunctionSignature(true, emptyList(), DataType.FLOAT),
-    "rsave"       to FunctionSignature(false, emptyList(), null),
-    "rrestore"    to FunctionSignature(false, emptyList(), null),
-    "set_carry"   to FunctionSignature(false, emptyList(), null),
-    "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 + DataType.UWORD),
-                                                        BuiltinFunctionParam("to", IterableDatatypes + DataType.UWORD),
-                                                        BuiltinFunctionParam("numbytes", setOf(DataType.UBYTE))), null),
-    "memset"      to FunctionSignature(false, listOf(
-                                                        BuiltinFunctionParam("address", IterableDatatypes + DataType.UWORD),
-                                                        BuiltinFunctionParam("numbytes", setOf(DataType.UWORD)),
-                                                        BuiltinFunctionParam("bytevalue", ByteDatatypes)), null),
-    "memsetw"     to FunctionSignature(false, listOf(
-                                                        BuiltinFunctionParam("address", IterableDatatypes + DataType.UWORD),
-                                                        BuiltinFunctionParam("numwords", setOf(DataType.UWORD)),
-                                                        BuiltinFunctionParam("wordvalue", setOf(DataType.UWORD, DataType.WORD))), null),
-    "strlen"      to FunctionSignature(true, listOf(BuiltinFunctionParam("string", setOf(DataType.STR))), DataType.UBYTE, ::builtinStrlen)
+    "sgn"         to FSignature(true, listOf(FParam("value", NumericDatatypes)), DataType.BYTE, ::builtinSgn ),
+    "sin"         to FSignature(true, listOf(FParam("rads", setOf(DataType.FLOAT))), DataType.FLOAT) { a, p, prg -> oneDoubleArg(a, p, prg, Math::sin) },
+    "sin8"        to FSignature(true, listOf(FParam("angle8", setOf(DataType.UBYTE))), DataType.BYTE, ::builtinSin8 ),
+    "sin8u"       to FSignature(true, listOf(FParam("angle8", setOf(DataType.UBYTE))), DataType.UBYTE, ::builtinSin8u ),
+    "sin16"       to FSignature(true, listOf(FParam("angle8", setOf(DataType.UBYTE))), DataType.WORD, ::builtinSin16 ),
+    "sin16u"      to FSignature(true, listOf(FParam("angle8", setOf(DataType.UBYTE))), DataType.UWORD, ::builtinSin16u ),
+    "cos"         to FSignature(true, listOf(FParam("rads", setOf(DataType.FLOAT))), DataType.FLOAT) { a, p, prg -> oneDoubleArg(a, p, prg, Math::cos) },
+    "cos8"        to FSignature(true, listOf(FParam("angle8", setOf(DataType.UBYTE))), DataType.BYTE, ::builtinCos8 ),
+    "cos8u"       to FSignature(true, listOf(FParam("angle8", setOf(DataType.UBYTE))), DataType.UBYTE, ::builtinCos8u ),
+    "cos16"       to FSignature(true, listOf(FParam("angle8", setOf(DataType.UBYTE))), DataType.WORD, ::builtinCos16 ),
+    "cos16u"      to FSignature(true, listOf(FParam("angle8", setOf(DataType.UBYTE))), DataType.UWORD, ::builtinCos16u ),
+    "tan"         to FSignature(true, listOf(FParam("rads", setOf(DataType.FLOAT))), DataType.FLOAT) { a, p, prg -> oneDoubleArg(a, p, prg, Math::tan) },
+    "atan"        to FSignature(true, listOf(FParam("rads", setOf(DataType.FLOAT))), DataType.FLOAT) { a, p, prg -> oneDoubleArg(a, p, prg, Math::atan) },
+    "ln"          to FSignature(true, listOf(FParam("value", setOf(DataType.FLOAT))), DataType.FLOAT) { a, p, prg -> oneDoubleArg(a, p, prg, Math::log) },
+    "log2"        to FSignature(true, listOf(FParam("value", setOf(DataType.FLOAT))), DataType.FLOAT) { a, p, prg -> oneDoubleArg(a, p, prg, ::log2) },
+    "sqrt16"      to FSignature(true, listOf(FParam("value", setOf(DataType.UWORD))), DataType.UBYTE) { a, p, prg -> oneIntArgOutputInt(a, p, prg) { sqrt(it.toDouble()).toInt() } },
+    "sqrt"        to FSignature(true, listOf(FParam("value", setOf(DataType.FLOAT))), DataType.FLOAT) { a, p, prg -> oneDoubleArg(a, p, prg, Math::sqrt) },
+    "rad"         to FSignature(true, listOf(FParam("value", setOf(DataType.FLOAT))), DataType.FLOAT) { a, p, prg -> oneDoubleArg(a, p, prg, Math::toRadians) },
+    "deg"         to FSignature(true, listOf(FParam("value", setOf(DataType.FLOAT))), DataType.FLOAT) { a, p, prg -> oneDoubleArg(a, p, prg, Math::toDegrees) },
+    "round"       to FSignature(true, listOf(FParam("value", setOf(DataType.FLOAT))), DataType.FLOAT) { a, p, prg -> oneDoubleArgOutputWord(a, p, prg, Math::round) },
+    "floor"       to FSignature(true, listOf(FParam("value", setOf(DataType.FLOAT))), DataType.FLOAT) { a, p, prg -> oneDoubleArgOutputWord(a, p, prg, Math::floor) },
+    "ceil"        to FSignature(true, listOf(FParam("value", setOf(DataType.FLOAT))), DataType.FLOAT) { a, p, prg -> oneDoubleArgOutputWord(a, p, prg, Math::ceil) },
+    "any"         to FSignature(true, listOf(FParam("values", ArrayDatatypes)), DataType.UBYTE) { a, p, prg -> collectionArg(a, p, prg, ::builtinAny) },
+    "all"         to FSignature(true, listOf(FParam("values", ArrayDatatypes)), DataType.UBYTE) { a, p, prg -> collectionArg(a, p, prg, ::builtinAll) },
+    "lsb"         to FSignature(true, listOf(FParam("value", setOf(DataType.UWORD, DataType.WORD))), DataType.UBYTE) { a, p, prg -> oneIntArgOutputInt(a, p, prg) { x: Int -> x and 255 }},
+    "msb"         to FSignature(true, listOf(FParam("value", setOf(DataType.UWORD, DataType.WORD))), DataType.UBYTE) { a, p, prg -> oneIntArgOutputInt(a, p, prg) { x: Int -> x ushr 8 and 255}},
+    "mkword"      to FSignature(true, listOf(FParam("lsb", setOf(DataType.UBYTE)), FParam("msb", setOf(DataType.UBYTE))), DataType.UWORD, ::builtinMkword),
+    "rnd"         to FSignature(true, emptyList(), DataType.UBYTE),
+    "rndw"        to FSignature(true, emptyList(), DataType.UWORD),
+    "rndf"        to FSignature(true, emptyList(), DataType.FLOAT),
+    "exit"        to FSignature(false, listOf(FParam("returnvalue", setOf(DataType.UBYTE))), null),
+    "rsave"       to FSignature(false, emptyList(), null),
+    "rrestore"    to FSignature(false, emptyList(), null),
+    "set_carry"   to FSignature(false, emptyList(), null),
+    "clear_carry" to FSignature(false, emptyList(), null),
+    "set_irqd"    to FSignature(false, emptyList(), null),
+    "clear_irqd"  to FSignature(false, emptyList(), null),
+    "read_flags"  to FSignature(false, emptyList(), DataType.UBYTE),
+    "swap"        to FSignature(false, listOf(FParam("first", NumericDatatypes), FParam("second", NumericDatatypes)), null),
+    "memcopy"     to FSignature(false, listOf(
+                            FParam("from", IterableDatatypes + DataType.UWORD),
+                            FParam("to", IterableDatatypes + DataType.UWORD),
+                            FParam("numbytes", setOf(DataType.UBYTE))), null),
+    "memset"      to FSignature(false, listOf(
+                            FParam("address", IterableDatatypes + DataType.UWORD),
+                            FParam("numbytes", setOf(DataType.UWORD)),
+                            FParam("bytevalue", ByteDatatypes)), null),
+    "memsetw"     to FSignature(false, listOf(
+                            FParam("address", IterableDatatypes + DataType.UWORD),
+                            FParam("numwords", setOf(DataType.UWORD)),
+                            FParam("wordvalue", setOf(DataType.UWORD, DataType.WORD))), null),
+    "strlen"      to FSignature(true, listOf(FParam("string", setOf(DataType.STR))), DataType.UBYTE, ::builtinStrlen)
 )
 
 fun builtinMax(array: List<Number>): Number = array.maxBy { it.toDouble() }!!

compiler/src/prog8/optimizer/CallGraph.kt

@@ -14,13 +14,23 @@ import prog8.ast.processing.IAstVisitor
 import prog8.ast.statements.*
 import prog8.compiler.loadAsmIncludeFile
 
+private val alwaysKeepSubroutines = setOf(
+        Pair("main", "start"),
+        Pair("irq", "irq"),
+        Pair("prog8_lib", "init_system")
+)
 
-class CallGraph(private val program: Program): IAstVisitor {
+private val asmJumpRx = Regex("""[\-+a-zA-Z0-9_ \t]+(jmp|jsr)[ \t]+(\S+).*""", RegexOption.IGNORE_CASE)
+private val asmRefRx = Regex("""[\-+a-zA-Z0-9_ \t]+(...)[ \t]+(\S+).*""", RegexOption.IGNORE_CASE)
+
+
+class CallGraph(private val program: Program) : IAstVisitor {
 
     val modulesImporting = mutableMapOf<Module, List<Module>>().withDefault { mutableListOf() }
     val modulesImportedBy = mutableMapOf<Module, List<Module>>().withDefault { mutableListOf() }
     val subroutinesCalling = mutableMapOf<INameScope, List<Subroutine>>().withDefault { mutableListOf() }
     val subroutinesCalledBy = mutableMapOf<Subroutine, List<Node>>().withDefault { mutableListOf() }
+
     // TODO  add dataflow graph: what statements use what variables
     val usedSymbols = mutableSetOf<Statement>()
 
@@ -31,9 +41,9 @@ class CallGraph(private val program: Program): IAstVisitor {
     fun forAllSubroutines(scope: INameScope, sub: (s: Subroutine) -> Unit) {
         fun findSubs(scope: INameScope) {
             scope.statements.forEach {
-                if(it is Subroutine)
+                if (it is Subroutine)
                     sub(it)
-                if(it is INameScope)
+                if (it is INameScope)
                     findSubs(it)
             }
         }
@@ -65,7 +75,7 @@ class CallGraph(private val program: Program): IAstVisitor {
     }
 
     override fun visit(block: Block) {
-        if(block.definingModule().isLibraryModule) {
+        if (block.definingModule().isLibraryModule) {
             // make sure the block is not removed
             addNodeAndParentScopes(block)
         }
@@ -75,11 +85,11 @@ class CallGraph(private val program: Program): IAstVisitor {
 
     override fun visit(directive: Directive) {
         val thisModule = directive.definingModule()
-        if(directive.directive=="%import") {
-            val importedModule: Module = program.modules.single { it.name==directive.args[0].name }
+        if (directive.directive == "%import") {
+            val importedModule: Module = program.modules.single { it.name == directive.args[0].name }
             modulesImporting[thisModule] = modulesImporting.getValue(thisModule).plus(importedModule)
             modulesImportedBy[importedModule] = modulesImportedBy.getValue(importedModule).plus(thisModule)
-        } else if (directive.directive=="%asminclude") {
+        } else if (directive.directive == "%asminclude") {
             val asm = loadAsmIncludeFile(directive.args[0].str!!, thisModule.source)
             val scope = directive.definingScope()
             scanAssemblyCode(asm, directive, scope)
@@ -91,7 +101,7 @@ class CallGraph(private val program: Program): IAstVisitor {
     override fun visit(identifier: IdentifierReference) {
         // track symbol usage
         val target = identifier.targetStatement(this.program.namespace)
-        if(target!=null) {
+        if (target != null) {
             addNodeAndParentScopes(target)
         }
         super.visit(identifier)
@@ -99,24 +109,18 @@ class CallGraph(private val program: Program): IAstVisitor {
 
     private fun addNodeAndParentScopes(stmt: Statement) {
         usedSymbols.add(stmt)
-        var node: Node=stmt
+        var node: Node = stmt
         do {
-            if(node is INameScope && node is Statement) {
+            if (node is INameScope && node is Statement) {
                 usedSymbols.add(node)
             }
-            node=node.parent
+            node = node.parent
         } while (node !is Module && node !is ParentSentinel)
     }
 
     override fun visit(subroutine: Subroutine) {
-        val alwaysKeepSubroutines = setOf(
-                Pair("main", "start"),
-                Pair("irq", "irq"),
-                Pair("prog8_lib", "init_system")
-        )
-
-        if(Pair(subroutine.definingScope().name, subroutine.name) in alwaysKeepSubroutines
-                || subroutine.name== initvarsSubName || subroutine.definingModule().isLibraryModule) {
+        if (Pair(subroutine.definingScope().name, subroutine.name) in alwaysKeepSubroutines
+                || subroutine.name == initvarsSubName || subroutine.definingModule().isLibraryModule) {
             // make sure the entrypoint is mentioned in the used symbols
             addNodeAndParentScopes(subroutine)
         }
@@ -124,12 +128,12 @@ class CallGraph(private val program: Program): IAstVisitor {
     }
 
     override fun visit(decl: VarDecl) {
-        if(decl.autogeneratedDontRemove || (decl.definingModule().isLibraryModule && decl.type!=VarDeclType.VAR)) {
+        if (decl.autogeneratedDontRemove || (decl.definingModule().isLibraryModule && decl.type != VarDeclType.VAR)) {
             // make sure autogenerated vardecls are in the used symbols
             addNodeAndParentScopes(decl)
         }
 
-        if(decl.datatype==DataType.STRUCT)
+        if (decl.datatype == DataType.STRUCT)
             addNodeAndParentScopes(decl)
 
         super.visit(decl)
@@ -137,7 +141,7 @@ class CallGraph(private val program: Program): IAstVisitor {
 
     override fun visit(functionCall: FunctionCall) {
         val otherSub = functionCall.target.targetSubroutine(program.namespace)
-        if(otherSub!=null) {
+        if (otherSub != null) {
             functionCall.definingSubroutine()?.let { thisSub ->
                 subroutinesCalling[thisSub] = subroutinesCalling.getValue(thisSub).plus(otherSub)
                 subroutinesCalledBy[otherSub] = subroutinesCalledBy.getValue(otherSub).plus(functionCall)
@@ -148,7 +152,7 @@ class CallGraph(private val program: Program): IAstVisitor {
 
     override fun visit(functionCallStatement: FunctionCallStatement) {
         val otherSub = functionCallStatement.target.targetSubroutine(program.namespace)
-        if(otherSub!=null) {
+        if (otherSub != null) {
             functionCallStatement.definingSubroutine()?.let { thisSub ->
                 subroutinesCalling[thisSub] = subroutinesCalling.getValue(thisSub).plus(otherSub)
                 subroutinesCalledBy[otherSub] = subroutinesCalledBy.getValue(otherSub).plus(functionCallStatement)
@@ -159,7 +163,7 @@ class CallGraph(private val program: Program): IAstVisitor {
 
     override fun visit(jump: Jump) {
         val otherSub = jump.identifier?.targetSubroutine(program.namespace)
-        if(otherSub!=null) {
+        if (otherSub != null) {
             jump.definingSubroutine()?.let { thisSub ->
                 subroutinesCalling[thisSub] = subroutinesCalling.getValue(thisSub).plus(otherSub)
                 subroutinesCalledBy[otherSub] = subroutinesCalledBy.getValue(otherSub).plus(jump)
@@ -181,8 +185,6 @@ class CallGraph(private val program: Program): IAstVisitor {
     }
 
     private fun scanAssemblyCode(asm: String, context: Statement, scope: INameScope) {
-        val asmJumpRx = Regex("""[\-+a-zA-Z0-9_ \t]+(jmp|jsr)[ \t]+(\S+).*""", RegexOption.IGNORE_CASE)
-        val asmRefRx = Regex("""[\-+a-zA-Z0-9_ \t]+(...)[ \t]+(\S+).*""", RegexOption.IGNORE_CASE)
         asm.lines().forEach { line ->
             val matches = asmJumpRx.matchEntire(line)
             if (matches != null) {
@@ -192,7 +194,7 @@ class CallGraph(private val program: Program): IAstVisitor {
                     if (node is Subroutine) {
                         subroutinesCalling[scope] = subroutinesCalling.getValue(scope).plus(node)
                         subroutinesCalledBy[node] = subroutinesCalledBy.getValue(node).plus(context)
-                    } else if(jumptarget.contains('.')) {
+                    } else if (jumptarget.contains('.')) {
                         // maybe only the first part already refers to a subroutine
                         val node2 = program.namespace.lookup(listOf(jumptarget.substringBefore('.')), context)
                         if (node2 is Subroutine) {
@@ -204,9 +206,9 @@ class CallGraph(private val program: Program): IAstVisitor {
             } else {
                 val matches2 = asmRefRx.matchEntire(line)
                 if (matches2 != null) {
-                    val target= matches2.groups[2]?.value
+                    val target = matches2.groups[2]?.value
                     if (target != null && (target[0].isLetter() || target[0] == '_')) {
-                        if(target.contains('.')) {
+                        if (target.contains('.')) {
                             val node = program.namespace.lookup(listOf(target.substringBefore('.')), context)
                             if (node is Subroutine) {
                                 subroutinesCalling[scope] = subroutinesCalling.getValue(scope).plus(node)

compiler/src/prog8/optimizer/ConstantFolding.kt

@@ -5,32 +5,20 @@ import prog8.ast.Program
 import prog8.ast.base.*
 import prog8.ast.expressions.*
 import prog8.ast.processing.IAstModifyingVisitor
-import prog8.ast.processing.fixupArrayEltDatatypesFromVardecl
-import prog8.ast.processing.fixupArrayEltDatatypes
 import prog8.ast.statements.*
 import prog8.compiler.target.CompilationTarget
 import prog8.functions.BuiltinFunctions
 import kotlin.math.floor
 
 
-class ConstantFolding(private val program: Program) : IAstModifyingVisitor {
+class ConstantFolding(private val program: Program, private val errors: ErrorReporter) : IAstModifyingVisitor {
     var optimizationsDone: Int = 0
-    var errors : MutableList<AstException> = mutableListOf()
-    private val reportedErrorMessages = mutableSetOf<String>()
-
-    fun addError(x: AstException) {
-        // check that we don't add the isSameAs error more than once
-        if(x.toString() !in reportedErrorMessages) {
-            reportedErrorMessages.add(x.toString())
-            errors.add(x)
-        }
-    }
 
     override fun visit(decl: VarDecl): Statement {
         // the initializer value can't refer to the variable itself (recursive definition)
         // TODO: use call tree for this?
         if(decl.value?.referencesIdentifiers(decl.name) == true || decl.arraysize?.index?.referencesIdentifiers(decl.name) == true) {
-            errors.add(ExpressionError("recursive var declaration", decl.position))
+            errors.err("recursive var declaration", decl.position)
             return decl
         }
 
@@ -71,16 +59,16 @@ class ConstantFolding(private val program: Program) : IAstModifyingVisitor {
                         // convert the initializer range expression to an actual array
                         val declArraySize = decl.arraysize?.size()
                         if(declArraySize!=null && declArraySize!=rangeExpr.size())
-                            errors.add(ExpressionError("range expression size doesn't match declared array size", decl.value?.position!!))
+                            errors.err("range expression size doesn't match declared array size", decl.value?.position!!)
                         val constRange = rangeExpr.toConstantIntegerRange()
                         if(constRange!=null) {
                             val eltType = rangeExpr.inferType(program).typeOrElse(DataType.UBYTE)
                             if(eltType in ByteDatatypes) {
-                                decl.value = ArrayLiteralValue(decl.datatype,
+                                decl.value = ArrayLiteralValue(InferredTypes.InferredType.known(decl.datatype),
                                         constRange.map { NumericLiteralValue(eltType, it.toShort(), decl.value!!.position) }.toTypedArray(),
                                         position = decl.value!!.position)
                             } else {
-                                decl.value = ArrayLiteralValue(decl.datatype,
+                                decl.value = ArrayLiteralValue(InferredTypes.InferredType.known(decl.datatype),
                                         constRange.map { NumericLiteralValue(eltType, it, decl.value!!.position) }.toTypedArray(),
                                         position = decl.value!!.position)
                             }
@@ -90,7 +78,7 @@ class ConstantFolding(private val program: Program) : IAstModifyingVisitor {
                         }
                     }
                     if(numericLv!=null && numericLv.type== DataType.FLOAT)
-                        errors.add(ExpressionError("arraysize requires only integers here", numericLv.position))
+                        errors.err("arraysize requires only integers here", numericLv.position)
                     val size = decl.arraysize?.size() ?: return decl
                     if (rangeExpr==null && numericLv!=null) {
                         // arraysize initializer is empty or a single int, and we know the size; create the arraysize.
@@ -98,25 +86,25 @@ class ConstantFolding(private val program: Program) : IAstModifyingVisitor {
                         when(decl.datatype){
                             DataType.ARRAY_UB -> {
                                 if(fillvalue !in 0..255)
-                                    errors.add(ExpressionError("ubyte value overflow", numericLv.position))
+                                    errors.err("ubyte value overflow", numericLv.position)
                             }
                             DataType.ARRAY_B -> {
                                 if(fillvalue !in -128..127)
-                                    errors.add(ExpressionError("byte value overflow", numericLv.position))
+                                    errors.err("byte value overflow", numericLv.position)
                             }
                             DataType.ARRAY_UW -> {
                                 if(fillvalue !in 0..65535)
-                                    errors.add(ExpressionError("uword value overflow", numericLv.position))
+                                    errors.err("uword value overflow", numericLv.position)
                             }
                             DataType.ARRAY_W -> {
                                 if(fillvalue !in -32768..32767)
-                                    errors.add(ExpressionError("word value overflow", numericLv.position))
+                                    errors.err("word value overflow", numericLv.position)
                             }
                             else -> {}
                         }
                         // create the array itself, filled with the fillvalue.
                         val array = Array(size) {fillvalue}.map { NumericLiteralValue.optimalInteger(it, numericLv.position) as Expression}.toTypedArray()
-                        val refValue = ArrayLiteralValue(decl.datatype, array, position = numericLv.position)
+                        val refValue = ArrayLiteralValue(InferredTypes.InferredType.known(decl.datatype), array, position = numericLv.position)
                         decl.value = refValue
                         refValue.parent=decl
                         optimizationsDone++
@@ -133,11 +121,11 @@ class ConstantFolding(private val program: Program) : IAstModifyingVisitor {
                         // arraysize initializer is a single int, and we know the size.
                         val fillvalue = litval.number.toDouble()
                         if (fillvalue < CompilationTarget.machine.FLOAT_MAX_NEGATIVE || fillvalue > CompilationTarget.machine.FLOAT_MAX_POSITIVE)
-                            errors.add(ExpressionError("float value overflow", litval.position))
+                            errors.err("float value overflow", litval.position)
                         else {
                             // create the array itself, filled with the fillvalue.
                             val array = Array(size) {fillvalue}.map { NumericLiteralValue(DataType.FLOAT, it, litval.position) as Expression}.toTypedArray()
-                            val refValue = ArrayLiteralValue(DataType.ARRAY_F, array, position = litval.position)
+                            val refValue = ArrayLiteralValue(InferredTypes.InferredType.known(DataType.ARRAY_F), array, position = litval.position)
                             decl.value = refValue
                             refValue.parent=decl
                             optimizationsDone++
@@ -180,7 +168,7 @@ class ConstantFolding(private val program: Program) : IAstModifyingVisitor {
                 else -> identifier
             }
         } catch (ax: AstException) {
-            addError(ax)
+            errors.err("unhandled AST error: $ax", identifier.position)
             identifier
         }
     }
@@ -191,7 +179,7 @@ class ConstantFolding(private val program: Program) : IAstModifyingVisitor {
         return try {
             functionCall.constValue(program) ?: functionCall
         } catch (ax: AstException) {
-            addError(ax)
+            errors.err("unhandled AST error: $ax", functionCall.position)
             functionCall
         }
     }
@@ -286,7 +274,7 @@ class ConstantFolding(private val program: Program) : IAstModifyingVisitor {
             }
             return prefixExpr
         } catch (ax: AstException) {
-            addError(ax)
+            errors.err("unhandled AST error: $ax", expr.position)
             expr
         }
     }
@@ -346,7 +334,7 @@ class ConstantFolding(private val program: Program) : IAstModifyingVisitor {
                 else -> expr
             }
         } catch (ax: AstException) {
-            addError(ax)
+            errors.err("unhandled AST error: $ax", expr.position)
             expr
         }
     }
@@ -629,14 +617,18 @@ class ConstantFolding(private val program: Program) : IAstModifyingVisitor {
     }
 
     override fun visit(arrayLiteral: ArrayLiteralValue): Expression {
+        // because constant folding can result in arrays that are now suddenly capable
+        // of telling the type of all their elements (for instance, when they contained -2 which
+        // was a prefix expression earlier), we recalculate the array's datatype.
         val array = super.visit(arrayLiteral)
         if(array is ArrayLiteralValue) {
-            val vardecl = array.parent as? VarDecl
-            return if (vardecl!=null) {
-                fixupArrayEltDatatypesFromVardecl(array, vardecl)
-            } else {
-                // it's not an array associated with a vardecl, attempt to guess the data type from the array values
-                fixupArrayEltDatatypes(array, program)
+            if(array.type.isKnown)
+                return array
+            val arrayDt = array.guessDatatype(program)
+            if(arrayDt.isKnown) {
+                val newArray = arrayLiteral.cast(arrayDt.typeOrElse(DataType.STRUCT))
+                if(newArray!=null)
+                    return newArray
             }
         }
         return array

compiler/src/prog8/optimizer/Extensions.kt

@@ -1,34 +1,25 @@
 package prog8.optimizer
 
 import prog8.ast.Program
-import prog8.ast.base.AstException
-import prog8.parser.ParsingFailedError
+import prog8.ast.base.ErrorReporter
 
 
-internal fun Program.constantFold() {
-    val optimizer = ConstantFolding(this)
-    try {
-        optimizer.visit(this)
-    } catch (ax: AstException) {
-        optimizer.addError(ax)
-    }
+internal fun Program.constantFold(errors: ErrorReporter) {
+    val optimizer = ConstantFolding(this, errors)
+    optimizer.visit(this)
 
-    while(optimizer.errors.isEmpty() && optimizer.optimizationsDone>0) {
+    while(errors.isEmpty() && optimizer.optimizationsDone>0) {
         optimizer.optimizationsDone = 0
         optimizer.visit(this)
     }
 
-    if(optimizer.errors.isNotEmpty()) {
-        optimizer.errors.forEach { System.err.println(it) }
-        throw ParsingFailedError("There are ${optimizer.errors.size} errors.")
-    } else {
+    if(errors.isEmpty())
         modules.forEach { it.linkParents(namespace) }   // re-link in final configuration
-    }
 }
 
 
-internal fun Program.optimizeStatements(): Int {
-    val optimizer = StatementOptimizer(this)
+internal fun Program.optimizeStatements(errors: ErrorReporter): Int {
+    val optimizer = StatementOptimizer(this, errors)
     optimizer.visit(this)
     modules.forEach { it.linkParents(this.namespace) }   // re-link in final configuration
 

compiler/src/prog8/optimizer/SimplifyExpressions.kt

@@ -13,7 +13,7 @@ import kotlin.math.pow
 /*
     todo add more expression optimizations
 
-    Also see  https://egorbo.com/peephole-optimizations.html
+    Investigate what optimizations binaryen has, also see  https://egorbo.com/peephole-optimizations.html
 
  */
 
@@ -22,7 +22,7 @@ internal class SimplifyExpressions(private val program: Program) : IAstModifying
 
     override fun visit(assignment: Assignment): Statement {
         if (assignment.aug_op != null)
-            throw AstException("augmented assignments should have been converted to normal assignments before this optimizer")
+            throw AstException("augmented assignments should have been converted to normal assignments before this optimizer: $assignment")
         return super.visit(assignment)
     }
 

compiler/src/prog8/optimizer/StatementOptimizer.kt

@@ -15,12 +15,13 @@ import kotlin.math.floor
 
 
 /*
-    TODO: remove unreachable code?
-    TODO: proper inlining of tiny subroutines (correctly renaming/relocating all variables in them and refs to those as well, or restrict to subs without variables?)
+    TODO: remove unreachable code after return and exit()
+    TODO: proper inlining of tiny subroutines (at first, restrict to subs without parameters and variables in them, and build it up from there: correctly renaming/relocating all variables in them and refs to those as well)
 */
 
 
-internal class StatementOptimizer(private val program: Program) : IAstModifyingVisitor {
+internal class StatementOptimizer(private val program: Program,
+                                  private val errors: ErrorReporter) : IAstModifyingVisitor {
     var optimizationsDone: Int = 0
         private set
 
@@ -80,13 +81,13 @@ internal class StatementOptimizer(private val program: Program) : IAstModifyingV
         if("force_output" !in block.options()) {
             if (block.containsNoCodeNorVars()) {
                 optimizationsDone++
-                printWarning("removing empty block '${block.name}'", block.position)
+                errors.warn("removing empty block '${block.name}'", block.position)
                 return NopStatement.insteadOf(block)
             }
 
             if (block !in callgraph.usedSymbols) {
                 optimizationsDone++
-                printWarning("removing unused block '${block.name}'", block.position)
+                errors.warn("removing unused block '${block.name}'", block.position)
                 return NopStatement.insteadOf(block)  // remove unused block
             }
         }
@@ -99,7 +100,7 @@ internal class StatementOptimizer(private val program: Program) : IAstModifyingV
         val forceOutput = "force_output" in subroutine.definingBlock().options()
         if(subroutine.asmAddress==null && !forceOutput) {
             if(subroutine.containsNoCodeNorVars()) {
-                printWarning("removing empty subroutine '${subroutine.name}'", subroutine.position)
+                errors.warn("removing empty subroutine '${subroutine.name}'", subroutine.position)
                 optimizationsDone++
                 return NopStatement.insteadOf(subroutine)
             }
@@ -111,11 +112,12 @@ internal class StatementOptimizer(private val program: Program) : IAstModifyingV
         }
 
         if(subroutine !in callgraph.usedSymbols && !forceOutput) {
-            printWarning("removing unused subroutine '${subroutine.name}'", subroutine.position)
+            errors.warn("removing unused subroutine '${subroutine.name}'", subroutine.position)
             optimizationsDone++
             return NopStatement.insteadOf(subroutine)
         }
 
+        visitStatements(subroutine.statements)
         return subroutine
     }
 
@@ -123,7 +125,7 @@ internal class StatementOptimizer(private val program: Program) : IAstModifyingV
         val forceOutput = "force_output" in decl.definingBlock().options()
         if(decl !in callgraph.usedSymbols && !forceOutput) {
             if(decl.type == VarDeclType.VAR)
-                printWarning("removing unused variable ${decl.type} '${decl.name}'", decl.position)
+                errors.warn("removing unused variable ${decl.type} '${decl.name}'", decl.position)
             optimizationsDone++
             return NopStatement.insteadOf(decl)
         }
@@ -160,7 +162,7 @@ internal class StatementOptimizer(private val program: Program) : IAstModifyingV
         if(functionCallStatement.target.nameInSource.size==1 && functionCallStatement.target.nameInSource[0] in BuiltinFunctions) {
             val functionName = functionCallStatement.target.nameInSource[0]
             if (functionName in pureBuiltinFunctions) {
-                printWarning("statement has no effect (function return value is discarded)", functionCallStatement.position)
+                errors.warn("statement has no effect (function return value is discarded)", functionCallStatement.position)
                 optimizationsDone++
                 return NopStatement.insteadOf(functionCallStatement)
             }
@@ -180,7 +182,7 @@ internal class StatementOptimizer(private val program: Program) : IAstModifyingV
                 val vardecl = stringVar.targetVarDecl(program.namespace)!!
                 val string = vardecl.value!! as StringLiteralValue
                 if(string.value.length==1) {
-                    val firstCharEncoded = CompilationTarget.encodeString(string.value)[0]
+                    val firstCharEncoded = CompilationTarget.encodeString(string.value, string.altEncoding)[0]
                     functionCallStatement.args.clear()
                     functionCallStatement.args.add(NumericLiteralValue.optimalInteger(firstCharEncoded.toInt(), functionCallStatement.position))
                     functionCallStatement.target = IdentifierReference(listOf("c64", "CHROUT"), functionCallStatement.target.position)
@@ -188,7 +190,7 @@ internal class StatementOptimizer(private val program: Program) : IAstModifyingV
                     optimizationsDone++
                     return functionCallStatement
                 } else if(string.value.length==2) {
-                    val firstTwoCharsEncoded = CompilationTarget.encodeString(string.value.take(2))
+                    val firstTwoCharsEncoded = CompilationTarget.encodeString(string.value.take(2), string.altEncoding)
                     val scope = AnonymousScope(mutableListOf(), functionCallStatement.position)
                     scope.statements.add(FunctionCallStatement(IdentifierReference(listOf("c64", "CHROUT"), functionCallStatement.target.position),
                             mutableListOf(NumericLiteralValue.optimalInteger(firstTwoCharsEncoded[0].toInt(), functionCallStatement.position)),
@@ -263,12 +265,12 @@ internal class StatementOptimizer(private val program: Program) : IAstModifyingV
         if(constvalue!=null) {
             return if(constvalue.asBooleanValue){
                 // always true -> keep only if-part
-                printWarning("condition is always true", ifStatement.position)  // TODO don't warn this if the condition is just the single value 'true'
+                errors.warn("condition is always true", ifStatement.position)
                 optimizationsDone++
                 ifStatement.truepart
             } else {
                 // always false -> keep only else-part
-                printWarning("condition is always false", ifStatement.position)
+                errors.warn("condition is always false", ifStatement.position)
                 optimizationsDone++
                 ifStatement.elsepart
             }
@@ -311,21 +313,13 @@ internal class StatementOptimizer(private val program: Program) : IAstModifyingV
         val constvalue = whileLoop.condition.constValue(program)
         if(constvalue!=null) {
             return if(constvalue.asBooleanValue){
-                // always true -> print a warning, and optimize into body + jump (if there are no continue and break statements)
-                printWarning("condition is always true", whileLoop.condition.position)
-                if(hasContinueOrBreak(whileLoop.body))
-                    return whileLoop
-                val backLabelName = "_prog8_back${whileLoop.position.line}"
-                val label = Label(backLabelName, whileLoop.condition.position)
-                whileLoop.body.statements.add(0, label)
-                whileLoop.body.statements.add(Jump(null,
-                        IdentifierReference(listOf(backLabelName), whileLoop.condition.position),
-                        null, whileLoop.condition.position))
+                // always true -> print a warning, and optimize into a forever-loop
+                errors.warn("condition is always true", whileLoop.condition.position)
                 optimizationsDone++
-                return whileLoop.body
+                ForeverLoop(whileLoop.body, whileLoop.position)
             } else {
-                // always false -> ditch whole statement
-                printWarning("condition is always false", whileLoop.condition.position)
+                // always false -> remove the while statement altogether
+                errors.warn("condition is always false", whileLoop.condition.position)
                 optimizationsDone++
                 NopStatement.insteadOf(whileLoop)
             }
@@ -339,7 +333,7 @@ internal class StatementOptimizer(private val program: Program) : IAstModifyingV
         if(constvalue!=null) {
             return if(constvalue.asBooleanValue){
                 // always true -> keep only the statement block (if there are no continue and break statements)
-                printWarning("condition is always true", repeatLoop.untilCondition.position)
+                errors.warn("condition is always true", repeatLoop.untilCondition.position)
                 if(hasContinueOrBreak(repeatLoop.body))
                     repeatLoop
                 else {
@@ -347,18 +341,10 @@ internal class StatementOptimizer(private val program: Program) : IAstModifyingV
                     repeatLoop.body
                 }
             } else {
-                // always false -> print a warning, and optimize into body + jump (if there are no continue and break statements)
-                printWarning("condition is always false", repeatLoop.untilCondition.position)
-                if(hasContinueOrBreak(repeatLoop.body))
-                    return repeatLoop
-                val backLabelName = "_prog8_back${repeatLoop.position.line}"
-                val label = Label(backLabelName, repeatLoop.untilCondition.position)
-                repeatLoop.body.statements.add(0, label)
-                repeatLoop.body.statements.add(Jump(null,
-                        IdentifierReference(listOf(backLabelName), repeatLoop.untilCondition.position),
-                        null, repeatLoop.untilCondition.position))
+                // always false -> print a warning, and optimize into a forever loop
+                errors.warn("condition is always false", repeatLoop.untilCondition.position)
                 optimizationsDone++
-                return repeatLoop.body
+                ForeverLoop(repeatLoop.body, repeatLoop.position)
             }
         }
         return repeatLoop
@@ -424,7 +410,7 @@ internal class StatementOptimizer(private val program: Program) : IAstModifyingV
 
     override fun visit(assignment: Assignment): Statement {
         if(assignment.aug_op!=null)
-            throw AstException("augmented assignments should have been converted to normal assignments before this optimizer")
+            throw AstException("augmented assignments should have been converted to normal assignments before this optimizer: $assignment")
 
         if(assignment.target isSameAs assignment.value) {
             if(assignment.target.isNotMemory(program.namespace)) {
@@ -564,6 +550,7 @@ internal class StatementOptimizer(private val program: Program) : IAstModifyingV
         if(linesToRemove.isNotEmpty()) {
             linesToRemove.reversed().forEach{scope.statements.removeAt(it)}
         }
+        visitStatements(scope.statements)
         return super.visit(scope)
     }
 
@@ -571,11 +558,26 @@ internal class StatementOptimizer(private val program: Program) : IAstModifyingV
         // remove duplicate labels
         val stmts = label.definingScope().statements
         val startIdx = stmts.indexOf(label)
-        if(startIdx<(stmts.size-1) && stmts[startIdx+1] == label)
+        if(startIdx< stmts.lastIndex && stmts[startIdx+1] == label)
             return NopStatement.insteadOf(label)
 
         return super.visit(label)
     }
+
+
+    private fun visitStatements(statements: MutableList<Statement>) {
+        // TODO remove all unreachable code statements after call to exit() or a return
+        // this is not yet correct because we still have nested subroutines
+//        val exitCallIndex = statements.indexOfFirst { it is FunctionCallStatement && it.target.nameInSource.last()=="exit" }
+//        if(exitCallIndex>=0) {
+//            while(exitCallIndex < statements.lastIndex) {
+//                val stmt  = statements[exitCallIndex+1]
+//                println("after exit() removing: $stmt")
+//                statements.removeAt(exitCallIndex+1)
+//            }
+//        }
+    }
+
 }
 
 

compiler/src/prog8/parser/ModuleParsing.kt

@@ -4,6 +4,7 @@ import org.antlr.v4.runtime.*
 import prog8.ast.Module
 import prog8.ast.Program
 import prog8.ast.antlr.toAst
+import prog8.ast.base.ErrorReporter
 import prog8.ast.base.Position
 import prog8.ast.base.SyntaxError
 import prog8.ast.base.checkImportedValid
@@ -33,114 +34,117 @@ internal class CustomLexer(val modulePath: Path, input: CharStream?) : prog8Lexe
 internal fun moduleName(fileName: Path) = fileName.toString().substringBeforeLast('.')
 
 
-internal fun importModule(program: Program, filePath: Path): Module {
-    print("importing '${moduleName(filePath.fileName)}'")
-    if(filePath.parent!=null) {
-        var importloc = filePath.toString()
-        val curdir = Paths.get("").toAbsolutePath().toString()
-        if(importloc.startsWith(curdir))
-            importloc = "." + importloc.substring(curdir.length)
-        println(" (from '$importloc')")
-    }
-    else
-        println("")
-    if(!Files.isReadable(filePath))
-        throw ParsingFailedError("No such file: $filePath")
+internal class ModuleImporter(private val errors: ErrorReporter) {
 
-    val input = CharStreams.fromPath(filePath)
-    return importModule(program, input, filePath, false)
-}
+    internal fun importModule(program: Program, filePath: Path): Module {
+        print("importing '${moduleName(filePath.fileName)}'")
+        if(filePath.parent!=null) {
+            var importloc = filePath.toString()
+            val curdir = Paths.get("").toAbsolutePath().toString()
+            if(importloc.startsWith(curdir))
+                importloc = "." + importloc.substring(curdir.length)
+            println(" (from '$importloc')")
+        }
+        else
+            println("")
+        if(!Files.isReadable(filePath))
+            throw ParsingFailedError("No such file: $filePath")
 
-internal fun importLibraryModule(program: Program, name: String): Module? {
-    val import = Directive("%import", listOf(
-            DirectiveArg("", name, 42, position = Position("<<<implicit-import>>>", 0, 0, 0))
-    ), Position("<<<implicit-import>>>", 0, 0, 0))
-    return executeImportDirective(program, import, Paths.get(""))
-}
-
-internal fun importModule(program: Program, stream: CharStream, modulePath: Path, isLibrary: Boolean): Module {
-    val moduleName = moduleName(modulePath.fileName)
-    val lexer = CustomLexer(modulePath, stream)
-    val lexerErrors = LexerErrorListener()
-    lexer.addErrorListener(lexerErrors)
-    val tokens = CommentHandlingTokenStream(lexer)
-    val parser = prog8Parser(tokens)
-    val parseTree = parser.module()
-    val numberOfErrors = parser.numberOfSyntaxErrors + lexerErrors.numberOfErrors
-    if(numberOfErrors > 0)
-        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, modulePath)
-    moduleAst.program = program
-    moduleAst.linkParents(program.namespace)
-    program.modules.add(moduleAst)
-
-    // accept additional imports
-    val lines = moduleAst.statements.toMutableList()
-    lines.asSequence()
-         .mapIndexed { i, it -> Pair(i, it) }
-         .filter { (it.second as? Directive)?.directive == "%import" }
-         .forEach { executeImportDirective(program, it.second as Directive, modulePath) }
-
-    moduleAst.statements = lines
-    return moduleAst
-}
-
-private fun discoverImportedModuleFile(name: String, source: Path, position: Position?): Path {
-    val fileName = "$name.p8"
-    val locations = mutableListOf(source.parent)
-
-    val propPath = System.getProperty("prog8.libdir")
-    if(propPath!=null)
-        locations.add(pathFrom(propPath))
-    val envPath = System.getenv("PROG8_LIBDIR")
-    if(envPath!=null)
-        locations.add(pathFrom(envPath))
-    locations.add(Paths.get(Paths.get("").toAbsolutePath().toString(), "prog8lib"))
-
-    locations.forEach {
-        val file = pathFrom(it.toString(), fileName)
-        if (Files.isReadable(file)) return file
+        val input = CharStreams.fromPath(filePath)
+        return importModule(program, input, filePath, false)
     }
 
-    throw ParsingFailedError("$position Import: no module source file '$fileName' found  (I've looked in: $locations)")
-}
+    internal fun importLibraryModule(program: Program, name: String): Module? {
+        val import = Directive("%import", listOf(
+                DirectiveArg("", name, 42, position = Position("<<<implicit-import>>>", 0, 0, 0))
+        ), Position("<<<implicit-import>>>", 0, 0, 0))
+        return executeImportDirective(program, import, Paths.get(""))
+    }
 
-private fun executeImportDirective(program: Program, import: Directive, source: Path): Module? {
-    if(import.directive!="%import" || import.args.size!=1 || import.args[0].name==null)
-        throw SyntaxError("invalid import directive", import.position)
-    val moduleName = import.args[0].name!!
-    if("$moduleName.p8" == import.position.file)
-        throw SyntaxError("cannot import self", import.position)
+    private fun importModule(program: Program, stream: CharStream, modulePath: Path, isLibrary: Boolean): Module {
+        val moduleName = moduleName(modulePath.fileName)
+        val lexer = CustomLexer(modulePath, stream)
+        val lexerErrors = LexerErrorListener()
+        lexer.addErrorListener(lexerErrors)
+        val tokens = CommentHandlingTokenStream(lexer)
+        val parser = prog8Parser(tokens)
+        val parseTree = parser.module()
+        val numberOfErrors = parser.numberOfSyntaxErrors + lexerErrors.numberOfErrors
+        if(numberOfErrors > 0)
+            throw ParsingFailedError("There are $numberOfErrors errors in '$moduleName'.")
 
-    val existing = program.modules.singleOrNull { it.name == moduleName }
-    if(existing!=null)
-        return null
+        // You can do something with the parsed comments:
+        // tokens.commentTokens().forEach { println(it) }
 
-    val resource = tryGetEmbeddedResource("$moduleName.p8")
-    val importedModule =
-        if(resource!=null) {
-            // load the module from the embedded resource
-            resource.use {
-                if(import.args[0].int==42)
-                    println("importing '$moduleName' (library, auto)")
-                else
-                    println("importing '$moduleName' (library)")
-                importModule(program, CharStreams.fromStream(it), Paths.get("@embedded@/$moduleName"), true)
-            }
-        } else {
-            val modulePath = discoverImportedModuleFile(moduleName, source, import.position)
-            importModule(program, modulePath)
+        // convert to Ast
+        val moduleAst = parseTree.toAst(moduleName, isLibrary, modulePath)
+        moduleAst.program = program
+        moduleAst.linkParents(program.namespace)
+        program.modules.add(moduleAst)
+
+        // accept additional imports
+        val lines = moduleAst.statements.toMutableList()
+        lines.asSequence()
+                .mapIndexed { i, it -> Pair(i, it) }
+                .filter { (it.second as? Directive)?.directive == "%import" }
+                .forEach { executeImportDirective(program, it.second as Directive, modulePath) }
+
+        moduleAst.statements = lines
+        return moduleAst
+    }
+
+    private fun discoverImportedModuleFile(name: String, source: Path, position: Position?): Path {
+        val fileName = "$name.p8"
+        val locations = mutableListOf(source.parent)
+
+        val propPath = System.getProperty("prog8.libdir")
+        if(propPath!=null)
+            locations.add(pathFrom(propPath))
+        val envPath = System.getenv("PROG8_LIBDIR")
+        if(envPath!=null)
+            locations.add(pathFrom(envPath))
+        locations.add(Paths.get(Paths.get("").toAbsolutePath().toString(), "prog8lib"))
+
+        locations.forEach {
+            val file = pathFrom(it.toString(), fileName)
+            if (Files.isReadable(file)) return file
         }
 
-    importedModule.checkImportedValid()
-    return importedModule
-}
+        throw ParsingFailedError("$position Import: no module source file '$fileName' found  (I've looked in: $locations)")
+    }
 
-internal fun tryGetEmbeddedResource(name: String): InputStream? {
-    return object{}.javaClass.getResourceAsStream("/prog8lib/$name")
+    private fun executeImportDirective(program: Program, import: Directive, source: Path): Module? {
+        if(import.directive!="%import" || import.args.size!=1 || import.args[0].name==null)
+            throw SyntaxError("invalid import directive", import.position)
+        val moduleName = import.args[0].name!!
+        if("$moduleName.p8" == import.position.file)
+            throw SyntaxError("cannot import self", import.position)
+
+        val existing = program.modules.singleOrNull { it.name == moduleName }
+        if(existing!=null)
+            return null
+
+        val resource = tryGetEmbeddedResource("$moduleName.p8")
+        val importedModule =
+                if(resource!=null) {
+                    // load the module from the embedded resource
+                    resource.use {
+                        if(import.args[0].int==42)
+                            println("importing '$moduleName' (library, auto)")
+                        else
+                            println("importing '$moduleName' (library)")
+                        importModule(program, CharStreams.fromStream(it), Paths.get("@embedded@/$moduleName"), true)
+                    }
+                } else {
+                    val modulePath = discoverImportedModuleFile(moduleName, source, import.position)
+                    importModule(program, modulePath)
+                }
+
+        importedModule.checkImportedValid(errors)
+        return importedModule
+    }
+
+    private fun tryGetEmbeddedResource(name: String): InputStream? {
+        return object{}.javaClass.getResourceAsStream("/prog8lib/$name")
+    }
 }

compiler/src/prog8/server/dbus/IrmenDbusTest.kt

@@ -0,0 +1,22 @@
+package prog8.server.dbus
+
+//import org.freedesktop.dbus.interfaces.DBusInterface
+//
+//
+//interface IrmenDbusTest: DBusInterface
+//{
+//    fun Status(address: String): Map<Int, String>
+//}
+//
+//
+//internal class TestService: IrmenDbusTest {
+//    override fun Status(address: String): Map<Int, String> {
+//        return mapOf(
+//            5 to "hello",
+//            42 to address
+//        )
+//    }
+//
+//    override fun isRemote() = true
+//    override fun getObjectPath() = "/razorvine/TestService"
+//}

compiler/src/prog8/server/dbus/clientmain.kt

@@ -0,0 +1,17 @@
+package prog8.server.dbus
+
+
+//import org.freedesktop.dbus.connections.impl.DBusConnection
+//
+//
+//fun main() {
+//    DBusConnection.getConnection(DBusConnection.DBusBusType.SESSION).use {
+//        println(it.names.toList())
+//        println(it.uniqueName)
+//        println(it.address)
+//        println(it.machineId)
+//        val obj = it.getRemoteObject("local.net.razorvine.dbus.test", "/razorvine/TestService", IrmenDbusTest::class.java)
+//        println(obj.Status("irmen"))
+//    }
+//}
+//

compiler/src/prog8/server/dbus/testdbus.kt

@@ -0,0 +1,18 @@
+package prog8.server.dbus
+
+//import org.freedesktop.dbus.connections.impl.DBusConnection
+//
+//
+//fun main() {
+//    DBusConnection.getConnection(DBusConnection.DBusBusType.SESSION).use {
+//        it.requestBusName("local.net.razorvine.dbus.test")
+//        println(it.names.toList())
+//        println(it.uniqueName)
+//        println(it.address)
+//        println(it.machineId)
+//        val service = TestService()
+//        it.exportObject(service.objectPath, service)
+//
+//        Thread.sleep(100000)
+//    }
+//}

compiler/src/prog8/vm/RuntimeValue.kt

@@ -7,7 +7,7 @@ import prog8.ast.expressions.ArrayLiteralValue
 import prog8.ast.expressions.NumericLiteralValue
 import prog8.ast.expressions.StringLiteralValue
 import prog8.vm.astvm.VmExecutionException
-import java.util.Objects
+import java.util.*
 import kotlin.math.abs
 import kotlin.math.pow
 
@@ -570,10 +570,10 @@ class RuntimeValueNumeric(type: DataType, num: Number): RuntimeValueBase(type) {
 }
 
 
-class RuntimeValueString(val str: String, val heapId: Int?): RuntimeValueBase(DataType.STR) {
+class RuntimeValueString(val str: String, val altEncoding: Boolean, val heapId: Int?): RuntimeValueBase(DataType.STR) {
     companion object {
         fun fromLv(string: StringLiteralValue): RuntimeValueString {
-            return RuntimeValueString(string.value, string.heapId)
+            return RuntimeValueString(string.value, string.altEncoding, string.heapId)
         }
     }
 
@@ -603,9 +603,9 @@ open class RuntimeValueArray(type: DataType, val array: Array<Number>, val heapI
 
     companion object {
         fun fromLv(array: ArrayLiteralValue): RuntimeValueArray {
-            return if (array.type == DataType.ARRAY_F) {
+            return if (array.type.istype(DataType.ARRAY_F)) {
                 val doubleArray = array.value.map { (it as NumericLiteralValue).number }.toTypedArray()
-                RuntimeValueArray(array.type, doubleArray, array.heapId)
+                RuntimeValueArray(DataType.ARRAY_F, doubleArray, array.heapId)
             } else {
                 val resultArray = mutableListOf<Number>()
                 for (elt in array.value.withIndex()) {
@@ -615,7 +615,7 @@ open class RuntimeValueArray(type: DataType, val array: Array<Number>, val heapI
                         resultArray.add((elt.hashCode()))  // ...poor man's implementation of ADDRESSOF(array), it probably won't work very well
                     }
                 }
-                RuntimeValueArray(array.type, resultArray.toTypedArray(), array.heapId)
+                RuntimeValueArray(array.type.typeOrElse(DataType.STRUCT), resultArray.toTypedArray(), array.heapId)
             }
         }
     }

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

@@ -10,7 +10,7 @@ import prog8.ast.statements.*
 import prog8.compiler.target.c64.C64MachineDefinition
 import prog8.vm.*
 import java.awt.EventQueue
-import java.util.ArrayDeque
+import java.util.*
 import kotlin.NoSuchElementException
 import kotlin.concurrent.fixedRateTimer
 import kotlin.math.*
@@ -222,7 +222,7 @@ class AstVm(val program: Program, compilationTarget: String) {
                     when {
                         jx.generatedLabel != null -> {
                             val label = entrypoint.getLabelOrVariable(jx.generatedLabel) as Label
-                            TODO("generatedlabel $label")
+                            TODO("astvm handle generatedlabel $label")
                         }
                         jx.identifier != null -> {
                             when (val jumptarget = entrypoint.lookup(jx.identifier.nameInSource, jx.identifier.parent)) {
@@ -359,7 +359,7 @@ class AstVm(val program: Program, compilationTarget: String) {
                         }
                     }
                     else -> {
-                        TODO("weird call $target")
+                        throw VmExecutionException("weird call target $target")
                     }
                 }
             }
@@ -467,7 +467,7 @@ class AstVm(val program: Program, compilationTarget: String) {
                     BranchCondition.NE, BranchCondition.NZ -> if(statusflags.zero) executeAnonymousScope(stmt.truepart) else executeAnonymousScope(stmt.elsepart)
                     BranchCondition.MI, BranchCondition.NEG -> if(statusflags.negative) executeAnonymousScope(stmt.truepart) else executeAnonymousScope(stmt.elsepart)
                     BranchCondition.PL, BranchCondition.POS -> if(statusflags.negative) executeAnonymousScope(stmt.truepart) else executeAnonymousScope(stmt.elsepart)
-                    BranchCondition.VS, BranchCondition.VC -> TODO("overflow status")
+                    BranchCondition.VS, BranchCondition.VC -> TODO("astvm branch on overflow status")
                 }
             }
             is ForLoop -> {
@@ -544,7 +544,7 @@ class AstVm(val program: Program, compilationTarget: String) {
                 }
             }
             else -> {
-                TODO("implement $stmt")
+                TODO("astvm implement statement $stmt")
             }
         }
     }
@@ -575,7 +575,7 @@ class AstVm(val program: Program, compilationTarget: String) {
                         DataType.UWORD -> mem.setUWord(address, (value as RuntimeValueNumeric).wordval!!)
                         DataType.WORD -> mem.setSWord(address, (value as RuntimeValueNumeric).wordval!!)
                         DataType.FLOAT -> mem.setFloat(address, (value as RuntimeValueNumeric).floatval!!)
-                        DataType.STR -> mem.setString(address, (value as RuntimeValueString).str)
+                        DataType.STR -> mem.setString(address, (value as RuntimeValueString).str, value.altEncoding)
                         else -> throw VmExecutionException("weird memaddress type $decl")
                     }
                 } else
@@ -626,7 +626,7 @@ class AstVm(val program: Program, compilationTarget: String) {
                         val ident = contextStmt.definingScope().lookup(targetArrayIndexed.identifier.nameInSource, contextStmt) as? VarDecl
                                 ?: throw VmExecutionException("can't find assignment target ${target.identifier}")
                         val identScope = ident.definingScope()
-                        runtimeVariables.set(identScope, ident.name, RuntimeValueString(newstr, array.heapId))
+                        runtimeVariables.set(identScope, ident.name, RuntimeValueString(newstr, false, array.heapId))
                     }
                 }
                 else {
@@ -649,7 +649,7 @@ class AstVm(val program: Program, compilationTarget: String) {
             target.register != null -> {
                 runtimeVariables.set(program.namespace, target.register.name, value)
             }
-            else -> TODO("assign $target")
+            else -> TODO("assign weird target $target")
         }
     }
 
@@ -775,7 +775,7 @@ class AstVm(val program: Program, compilationTarget: String) {
                 val numericpart = argString.takeWhile { it.isDigit() }
                 result = RuntimeValueNumeric(DataType.UWORD, numericpart.toInt() and 65535)
             }
-            else -> TODO("syscall  ${sub.scopedname} $sub")
+            else -> TODO("astvm implement syscall  ${sub.scopedname} $sub")
         }
 
         return result
@@ -996,7 +996,12 @@ class AstVm(val program: Program, compilationTarget: String) {
                     else -> RuntimeValueNumeric(DataType.BYTE, 1)
                 }
             }
-            else -> TODO("builtin function $name")
+            "exit" -> {
+                val rv = args.single().numericValue()
+                dialog.canvas.printAsciiText("\n<program ended with exit($rv)>")
+                throw VmTerminationException("program ended with exit($rv)")
+            }
+            else -> TODO("astvm implement builtin function $name")
         }
     }
 }

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

@@ -124,7 +124,7 @@ fun evaluate(expr: Expression, ctx: EvalContext): RuntimeValueBase {
                             DataType.UWORD -> RuntimeValueNumeric(DataType.UWORD, ctx.mem.getUWord(address))
                             DataType.WORD -> RuntimeValueNumeric(DataType.WORD, ctx.mem.getSWord(address))
                             DataType.FLOAT -> RuntimeValueNumeric(DataType.FLOAT, ctx.mem.getFloat(address))
-                            DataType.STR -> RuntimeValueString(ctx.mem.getString(address), null)
+                            DataType.STR -> RuntimeValueString(ctx.mem.getString(address, false), false, null)
                             else -> throw VmExecutionException("unexpected datatype $variable")
                         }
                     }

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

@@ -93,14 +93,14 @@ class Memory(private val readObserver: (address: Int, value: Short) -> Short,
                 getUByte(address + 3), getUByte(address + 4)).toDouble()
     }
 
-    fun setString(address: Int, str: String) {
-        val encoded = CompilationTarget.encodeString(str)
+    fun setString(address: Int, str: String, altEncoding: Boolean) {
+        val encoded = CompilationTarget.encodeString(str, altEncoding)
         var addr = address
         for (c in encoded) setUByte(addr++, c)
         setUByte(addr, 0)
     }
 
-    fun getString(strAddress: Int): String {
+    fun getString(strAddress: Int, altEncoding: Boolean): String {
         val encoded = mutableListOf<Short>()
         var addr = strAddress
         while(true) {
@@ -108,7 +108,7 @@ class Memory(private val readObserver: (address: Int, value: Short) -> Short,
             if(byte==0.toShort()) break
             encoded.add(byte)
         }
-        return CompilationTarget.decodeString(encoded)
+        return CompilationTarget.decodeString(encoded, altEncoding)
     }
 
     fun clear() {

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

@@ -6,7 +6,7 @@ import java.awt.*
 import java.awt.event.KeyEvent
 import java.awt.event.KeyListener
 import java.awt.image.BufferedImage
-import java.util.ArrayDeque
+import java.util.*
 import javax.swing.JFrame
 import javax.swing.JPanel
 import javax.swing.Timer

compiler/test/LiteralValueTests.kt

@@ -5,6 +5,7 @@ import org.junit.jupiter.api.TestInstance
 import prog8.ast.base.DataType
 import prog8.ast.base.Position
 import prog8.ast.expressions.ArrayLiteralValue
+import prog8.ast.expressions.InferredTypes
 import prog8.ast.expressions.NumericLiteralValue
 import prog8.ast.expressions.StringLiteralValue
 import kotlin.test.assertEquals
@@ -83,8 +84,11 @@ class TestParserNumericLiteralValue {
 
     @Test
     fun testEqualsRef() {
-        assertEquals(StringLiteralValue("hello", dummyPos), StringLiteralValue("hello", dummyPos))
-        assertNotEquals(StringLiteralValue("hello", dummyPos), StringLiteralValue("bye", dummyPos))
+        assertEquals(StringLiteralValue("hello", false, dummyPos), StringLiteralValue("hello", false, dummyPos))
+        assertNotEquals(StringLiteralValue("hello", false, dummyPos), StringLiteralValue("bye", false, dummyPos))
+        assertEquals(StringLiteralValue("hello", true, dummyPos), StringLiteralValue("hello", true, dummyPos))
+        assertNotEquals(StringLiteralValue("hello", true, dummyPos), StringLiteralValue("bye", true, dummyPos))
+        assertNotEquals(StringLiteralValue("hello", true, dummyPos), StringLiteralValue("hello", false, dummyPos))
 
         val lvOne = NumericLiteralValue(DataType.UBYTE, 1, dummyPos)
         val lvTwo = NumericLiteralValue(DataType.UBYTE, 2, dummyPos)
@@ -93,9 +97,9 @@ class TestParserNumericLiteralValue {
         val lvTwoR = NumericLiteralValue(DataType.UBYTE, 2, dummyPos)
         val lvThreeR = NumericLiteralValue(DataType.UBYTE, 3, dummyPos)
         val lvFour= NumericLiteralValue(DataType.UBYTE, 4, dummyPos)
-        val lv1 = ArrayLiteralValue(DataType.ARRAY_UB, arrayOf(lvOne, lvTwo, lvThree), dummyPos)
-        val lv2 = ArrayLiteralValue(DataType.ARRAY_UB, arrayOf(lvOneR, lvTwoR, lvThreeR), dummyPos)
-        val lv3 = ArrayLiteralValue(DataType.ARRAY_UB, arrayOf(lvOneR, lvTwoR, lvFour), dummyPos)
+        val lv1 = ArrayLiteralValue(InferredTypes.InferredType.known(DataType.ARRAY_UB), arrayOf(lvOne, lvTwo, lvThree), dummyPos)
+        val lv2 = ArrayLiteralValue(InferredTypes.InferredType.known(DataType.ARRAY_UB), arrayOf(lvOneR, lvTwoR, lvThreeR), dummyPos)
+        val lv3 = ArrayLiteralValue(InferredTypes.InferredType.known(DataType.ARRAY_UB), arrayOf(lvOneR, lvTwoR, lvFour), dummyPos)
         assertEquals(lv1, lv2)
         assertNotEquals(lv1, lv3)
     }

compiler/test/UnitTests.kt

@@ -6,6 +6,7 @@ import org.hamcrest.Matchers.equalTo
 import org.junit.jupiter.api.Test
 import org.junit.jupiter.api.TestInstance
 import prog8.ast.base.DataType
+import prog8.ast.base.ErrorReporter
 import prog8.ast.base.Position
 import prog8.ast.expressions.NumericLiteralValue
 import prog8.ast.expressions.StringLiteralValue
@@ -124,31 +125,34 @@ class TestCompiler {
 
 @TestInstance(TestInstance.Lifecycle.PER_CLASS)
 class TestZeropage {
+
+    private val errors = ErrorReporter()
+
     @Test
     fun testNames() {
         val zp = C64Zeropage(CompilationOptions(OutputType.RAW, LauncherType.NONE, ZeropageType.BASICSAFE, emptyList(), false))
 
-        zp.allocate("", DataType.UBYTE, null)
-        zp.allocate("", DataType.UBYTE, null)
-        zp.allocate("varname", DataType.UBYTE, null)
+        zp.allocate("", DataType.UBYTE, null, errors)
+        zp.allocate("", DataType.UBYTE, null, errors)
+        zp.allocate("varname", DataType.UBYTE, null, errors)
         assertFailsWith<AssertionError> {
-            zp.allocate("varname", DataType.UBYTE, null)
+            zp.allocate("varname", DataType.UBYTE, null, errors)
         }
-        zp.allocate("varname2", DataType.UBYTE, null)
+        zp.allocate("varname2", DataType.UBYTE, null, errors)
     }
 
     @Test
     fun testZpFloatEnable() {
         val zp = C64Zeropage(CompilationOptions(OutputType.RAW, LauncherType.NONE, ZeropageType.FULL, emptyList(), false))
         assertFailsWith<CompilerException> {
-            zp.allocate("", DataType.FLOAT, null)
+            zp.allocate("", DataType.FLOAT, null, errors)
         }
         val zp2 = C64Zeropage(CompilationOptions(OutputType.RAW, LauncherType.NONE, ZeropageType.DONTUSE, emptyList(), true))
         assertFailsWith<CompilerException> {
-            zp2.allocate("", DataType.FLOAT, null)
+            zp2.allocate("", DataType.FLOAT, null, errors)
         }
         val zp3 = C64Zeropage(CompilationOptions(OutputType.RAW, LauncherType.NONE, ZeropageType.FLOATSAFE, emptyList(), true))
-        zp3.allocate("", DataType.FLOAT, null)
+        zp3.allocate("", DataType.FLOAT, null, errors)
     }
 
     @Test
@@ -173,7 +177,7 @@ class TestZeropage {
         println(zp.free)
         assertEquals(0, zp.available())
         assertFailsWith<CompilerException> {
-            zp.allocate("", DataType.BYTE, null)
+            zp.allocate("", DataType.BYTE, null, errors)
         }
     }
 
@@ -218,19 +222,19 @@ class TestZeropage {
 
         assertFailsWith<ZeropageDepletedError> {
             // in regular zp there aren't 5 sequential bytes free
-            zp.allocate("", DataType.FLOAT, null)
+            zp.allocate("", DataType.FLOAT, null, errors)
         }
 
         for (i in 0 until zp.available()) {
-            val loc = zp.allocate("", DataType.UBYTE, null)
+            val loc = zp.allocate("", DataType.UBYTE, null, errors)
             assertTrue(loc > 0)
         }
         assertEquals(0, zp.available())
         assertFailsWith<ZeropageDepletedError> {
-            zp.allocate("", DataType.UBYTE, null)
+            zp.allocate("", DataType.UBYTE, null, errors)
         }
         assertFailsWith<ZeropageDepletedError> {
-            zp.allocate("", DataType.UWORD, null)
+            zp.allocate("", DataType.UWORD, null, errors)
         }
     }
 
@@ -238,29 +242,29 @@ class TestZeropage {
     fun testFullAllocation() {
         val zp = C64Zeropage(CompilationOptions(OutputType.RAW, LauncherType.NONE, ZeropageType.FULL, emptyList(), false))
         assertEquals(238, zp.available())
-        val loc = zp.allocate("", DataType.UWORD, null)
+        val loc = zp.allocate("", DataType.UWORD, null, errors)
         assertTrue(loc > 3)
         assertFalse(loc in zp.free)
         val num = zp.available() / 2
 
         for(i in 0..num-4) {
-            zp.allocate("", DataType.UWORD, null)
+            zp.allocate("", DataType.UWORD, null, errors)
         }
         assertEquals(6,zp.available())
 
         assertFailsWith<ZeropageDepletedError> {
             // can't allocate because no more sequential bytes, only fragmented
-            zp.allocate("", DataType.UWORD, null)
+            zp.allocate("", DataType.UWORD, null, errors)
         }
 
         for(i in 0..5) {
-            zp.allocate("", DataType.UBYTE, null)
+            zp.allocate("", DataType.UBYTE, null, errors)
         }
 
         assertEquals(0, zp.available())
         assertFailsWith<ZeropageDepletedError> {
             // no more space
-            zp.allocate("", DataType.UBYTE, null)
+            zp.allocate("", DataType.UBYTE, null, errors)
         }
     }
 
@@ -268,16 +272,16 @@ class TestZeropage {
     fun testEfficientAllocation() {
         val zp = C64Zeropage(CompilationOptions(OutputType.RAW, LauncherType.NONE, ZeropageType.BASICSAFE, emptyList(),  true))
         assertEquals(16, zp.available())
-        assertEquals(0x04, zp.allocate("", DataType.WORD, null))
-        assertEquals(0x06, zp.allocate("", DataType.UBYTE, null))
-        assertEquals(0x0a, zp.allocate("", DataType.UBYTE, null))
-        assertEquals(0x94, zp.allocate("", DataType.UWORD, null))
-        assertEquals(0xa7, zp.allocate("", DataType.UWORD, null))
-        assertEquals(0xa9, zp.allocate("", DataType.UWORD, null))
-        assertEquals(0xb5, zp.allocate("", DataType.UWORD, null))
-        assertEquals(0xf7, zp.allocate("", DataType.UWORD, null))
-        assertEquals(0x0e, zp.allocate("", DataType.UBYTE, null))
-        assertEquals(0xf9, zp.allocate("", DataType.UBYTE, null))
+        assertEquals(0x04, zp.allocate("", DataType.WORD, null, errors))
+        assertEquals(0x06, zp.allocate("", DataType.UBYTE, null, errors))
+        assertEquals(0x0a, zp.allocate("", DataType.UBYTE, null, errors))
+        assertEquals(0x94, zp.allocate("", DataType.UWORD, null, errors))
+        assertEquals(0xa7, zp.allocate("", DataType.UWORD, null, errors))
+        assertEquals(0xa9, zp.allocate("", DataType.UWORD, null, errors))
+        assertEquals(0xb5, zp.allocate("", DataType.UWORD, null, errors))
+        assertEquals(0xf7, zp.allocate("", DataType.UWORD, null, errors))
+        assertEquals(0x0e, zp.allocate("", DataType.UBYTE, null, errors))
+        assertEquals(0xf9, zp.allocate("", DataType.UBYTE, null, errors))
         assertEquals(0, zp.available())
     }
 }
@@ -369,8 +373,8 @@ class TestPetscii {
         assertTrue(ten <= ten)
         assertFalse(ten < ten)
 
-        val abc = StringLiteralValue("abc", Position("", 0, 0, 0))
-        val abd = StringLiteralValue("abd", Position("", 0, 0, 0))
+        val abc = StringLiteralValue("abc", false, Position("", 0, 0, 0))
+        val abd = StringLiteralValue("abd", false, Position("", 0, 0, 0))
         assertEquals(abc, abc)
         assertTrue(abc!=abd)
         assertFalse(abc!=abc)

docs/source/index.rst

@@ -143,6 +143,7 @@ Design principles and features
   still able to directly use memory addresses, CPU registers and ROM subroutines,
   and inline assembly to have full control when every cycle or byte matters
 - Arbitrary number of subroutine parameters (constrained only by available memory)
+- Nested subroutines can access variables from outer scopes, this avoids the need and overhead to pass everything via parameters
 - Complex nested expressions are possible
 - Values are typed. Types supported include signed and unsigned bytes and words, arrays, strings and floats.
 - No dynamic memory allocation or sizing! All variables stay fixed size as determined at compile time.
@@ -158,7 +159,7 @@ Design principles and features
 - The compiler tries to optimize the program and generated code, but hand-tuning of the
   performance or space-critical parts will likely still be required. This is supported by
   the ability to easily write embedded assembly code directly in the program source code.
-- There are many built-in functions such as ``sin``, ``cos``, ``rnd``, ``abs``, ``min``, ``max``, ``sqrt``, ``msb``, ``rol``, ``ror``, ``swap``, ``memset``, ``memcopy``, ``sort`` and ``reverse``
+- There are many built-in functions, such as ``sin``, ``cos``, ``rnd``, ``abs``, ``min``, ``max``, ``sqrt``, ``msb``, ``rol``, ``ror``, ``swap``, ``memset``, ``memcopy``, ``sort`` and ``reverse``
 
 
 .. _requirements:
@@ -167,26 +168,25 @@ Required tools
 --------------
 
 `64tass <https://sourceforge.net/projects/tass64/>`_ - cross assembler. Install this on your shell path.
-A recent .exe version of this tool for Windows can be obtained from my `clone <https://github.com/irmen/64tass/releases>`_ of this project.
-For other platforms it is very easy to compile it yourself (make ; make install).
+It's very easy to compile yourself.
+A recent precompiled .exe for Windows can be obtained from my `clone <https://github.com/irmen/64tass/releases>`_ of this project.
 
-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. Check out `AdoptOpenJDK <https://adoptopenjdk.net/>`_ for
-downloads.
+A **Java runtime (jre or jdk), version 8 or newer**  is required to run the prog8 compiler itself.
+If you're scared of Oracle's licensing terms, most Linux distributions ship OpenJDK instead.
+Fnd for Windows it's possible to get that as well. Check out `AdoptOpenJDK <https://adoptopenjdk.net/>`_ .
 
-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/>`_.
+Finally: a **C-64 emulator** (or a real C-64 ofcourse) can be nice to test and run your programs on.
+The compiler assumes the presence of the `Vice emulator <http://vice-emu.sourceforge.net/>`_.
 
 .. important::
     **Building the compiler itself:** (*Only needed if you have not downloaded a pre-built 'fat-jar'*)
 
-    (re)building the compiler itself requires a recent Kotlin SDK.
-    The compiler is developed using the `IntelliJ IDEA <https://www.jetbrains.com/idea/>`_
-    IDE from Jetbrains, with the Kotlin plugin (free community edition of this IDE is available).
-    But a bare Kotlin SDK installation should work just as well.
+    (Re)building the compiler itself requires a recent Kotlin SDK.
+    The compiler is developed using `IntelliJ IDEA <https://www.jetbrains.com/idea/>`_ ,
+    but only a Kotlin SDK installation should work as well, because the gradle tool is
+    used to compile everything from the commandline.
 
-    Instructions on how to obtain a working compiler are in :ref:`building_compiler`.
+    Instructions on how to obtain a prebuilt compiler are in :ref:`building_compiler`.
 
 
 .. toctree::

docs/source/programming.rst

@@ -12,57 +12,56 @@ Elements of a program
 ---------------------
 
 Program
-	Consists of one or more *modules*.
+    Consists of one or more *modules*.
 
 Module
-	A file on disk with the ``.p8`` suffix. It contains *directives* and *code blocks*.
-	Whitespace and indentation in the source code are arbitrary and can be tabs or spaces or both.
-	You can also add *comments* to the source code.
-	One moudule file can *import* others, and also import *library modules*.
+    A file on disk with the ``.p8`` suffix. It can contain *directives* and *code blocks*.
+    Whitespace and indentation in the source code are arbitrary and can be mixed tabs or spaces.
+    A module file can *import* other modules, including *library modules*.
 
 Comments
-	Everything after a semicolon ``;`` is a comment and is ignored by the compiler.
-	If the whole line is just a comment, it will be copied into the resulting assembly source code.
-	This makes it easier to understand and relate the generated code. Examples::
-
-		A = 42    ; set the initial value to 42
-		; next is the code that...
+    Everything after a semicolon ``;`` is a comment and is ignored by the compiler.
+    If the whole line is just a comment, this line will be copied into the resulting assembly source code for reference.
 
 Directive
-	These are special instructions for the compiler, to change how it processes the code
-	and what kind of program it creates. A directive is on its own line in the file, and
-	starts with ``%``, optionally followed by some arguments.
+    These are special instructions for the compiler, to change how it processes the code
+    and what kind of program it creates. A directive is on its own line in the file, and
+    starts with ``%``, optionally followed by some arguments.
 
 Code block
-	A block of actual program code. It defines a *scope* (also known as 'namespace') and
-	can contain Prog8 *code*, *variable declarations* and *subroutines*.
-	More details about this below: :ref:`blocks`.
+    A block of actual program code. It has a starting address in memory,
+    and defines a *scope* (also known as 'namespace').
+    It contains variables and subroutines.
+    More details about this below: :ref:`blocks`.
 
 Variable declarations
-	The data that the code works on is stored in variables ('named values that can change').
-	The compiler allocates the required memory for them.
-	There is *no dynamic memory allocation*. The storage size of all variables
-	is fixed and is determined at compile time.
-	Variable declarations tend to appear at the top of the code block that uses them.
-	They define the name and type of the variable, and its initial value.
-	Prog8 supports a small list of data types, including special 'memory mapped' types
-	that don't allocate storage but instead point to a fixed location in the address space.
+    The data that the code works on is stored in variables ('named values that can change').
+    The compiler allocates the required memory for them.
+    There is *no dynamic memory allocation*. The storage size of all variables
+    is fixed and is determined at compile time.
+    Variable declarations tend to appear at the top of the code block that uses them.
+    They define the name and type of the variable, and its initial value.
+    Prog8 supports a small list of data types, including special 'memory mapped' types
+    that don't allocate storage but instead point to a fixed location in the address space.
 
 Code
-	These are the instructions that make up the program's logic. There are different kinds of instructions
-	('statements' is a better name):
+    These are the instructions that make up the program's logic.
+    Code can only occur inside a subroutine.
+    There are different kinds of instructions ('statements' is a better name) such as:
 
-	- value assignment
-	- looping  (for, while, repeat, unconditional jumps)
-	- conditional execution (if - then - else, when, and conditional jumps)
-	- subroutine calls
-	- label definition
+    - value assignment
+    - looping  (for, while, repeat, unconditional jumps)
+    - conditional execution (if - then - else, when, and conditional jumps)
+    - subroutine calls
+    - label definition
 
 Subroutine
     Defines a piece of code that can be called by its name from different locations in your code.
     It accepts parameters and can return a value (optional).
     It can define its own variables, and it is even possible to define subroutines nested inside other subroutines.
     Their contents is scoped accordingly.
+    Nested subroutines can access the variables from outer scopes.
+    This removes the need and overhead to pass everything via parameters.
 
 Label
     This is a named position in your code where you can jump to from another place.
@@ -90,16 +89,20 @@ Scope
 Blocks, Scopes, and accessing Symbols
 -------------------------------------
 
-**Blocks** are the top level separate pieces of code and data of your program. They are combined
-into a single output program.  No code or data can occur outside a block. Here's an example::
+**Blocks** are the top level separate pieces of code and data of your program. They have a
+starting address in memory and will be combined together into a single output program.
+They can only contain *directives*, *variable declarations*, *subroutines* and *inline assembly code*.
+Your actual program code can only exist inside these subroutines.
+(except the occasional inline assembly)
 
-	main $c000 {
-		; this is code inside the block...
-	}
+Here's an example::
 
+    main $c000 {
+        ; this is code inside the block...
+    }
 
 The name of a block must be unique in your entire program.
-Also be careful when importing other modules; blocks in your own code cannot have
+Be careful when importing other modules; blocks in your own code cannot have
 the same name as a block defined in an imported module or library.
 
 If you omit both the name and address, the entire block is *ignored* by the compiler (and a warning is displayed).
@@ -109,7 +112,7 @@ want to work on later, because the contents of the ignored block are not fully p
 The address can be used to place a block at a specific location in memory.
 Usually it is omitted, and the compiler will automatically choose the location (usually immediately after
 the previous block in memory).
-The address must be >= ``$0200`` (because ``$00``--``$ff`` is the ZP and ``$100``--``$200`` is the cpu stack).
+It must be >= ``$0200`` (because ``$00``--``$ff`` is the ZP and ``$100``--``$1ff`` is the cpu stack).
 
 
 .. _scopes:
@@ -133,14 +136,13 @@ Scopes are created using either of these two statements:
 - subroutines   (nested named scope)
 
 .. note::
-    In contrast to many other programming languages, a new scope is *not* created inside
+    Unlike many other programming languages, a new scope is *not* created inside
     for, while and repeat statements, nor for the if statement and branching conditionals.
-    This is a bit restrictive because you have to think harder about what variables you
-    want to use inside a subroutine. But it is done precisely for this reason; memory in the
-    target system is very limited and it would be a waste to allocate a lot of variables.
-
-    Right now the prog8 compiler is not advanced enough to be able to 'share' or 'overlap'
-    variables intelligently by itself. So for now, it's something the programmer has to think about.
+    This can be a bit restrictive because as a programmer you have to think harder about what variables you
+    want to use inside a subroutine. But it is done precisely for this reason: memory in prog8's
+    target systems is usually very limited and it would be a waste to allocate a lot of variables.
+    The prog8 compiler is not yet advanced enough to be able to share or overlap
+    variables intelligently. So for now that is something the programmer has to think about.
 
 
 Program Start and Entry Point
@@ -159,12 +161,12 @@ taking no parameters and having no return value.
 
 As any subroutine, it has to end with a ``return`` statement (or a ``goto`` call)::
 
-	main {
-	    sub start ()  {
-	        ; program entrypoint code here
-	        return
-	    }
-	}
+    main {
+        sub start ()  {
+            ; program entrypoint code here
+            return
+        }
+    }
 
 
 The ``main`` module is always relocated to the start of your programs
@@ -175,7 +177,6 @@ calls with the SYS statement.
 
 
 
-
 Variables and values
 --------------------
 
@@ -188,9 +189,11 @@ Values will usually be part of an expression or assignment statement::
     12345                 ; integer number
     $aa43                 ; hex integer number
     %100101               ; binary integer number (% is also remainder operator so be careful)
-    "Hi, I am a string"   ; text string
-    'a'                   ; petscii value (byte) for the letter a
     -33.456e52            ; floating point number
+    "Hi, I am a string"   ; text string, encoded with compiler target default encoding
+    'a'                   ; byte value (ubyte) for the letter a
+    @"Alternate"          ; text string, encoded with alternate encoding
+    @'a'                  ; byte value of the letter a, using alternate encoding
 
     byte  counter  = 42   ; variable of size 8 bits, with initial value 42
 
@@ -271,8 +274,12 @@ Strings
 Strings are a sequence of characters enclosed in ``"`` quotes. The length is limited to 255 characters.
 They're stored and treated much the same as a byte array,
 but they have some special properties because they are considered to be *text*.
-Strings in your source code files will be encoded (translated from ASCII/UTF-8) into the byte-encoding
-that is used on the target platform. For the C-64, this is CBM PETSCII.
+Strings in your source code files will be encoded (translated from ASCII/UTF-8) into bytes via the
+default encoding that is used on the target platform. For the C-64, this is CBM PETSCII.
+Alternate-encoding strings (prefixed with ``@``) will be encoded via the alternate encoding for the
+platform (if defined). For the C-64, that is SCREEN CODES (also known as POKE codes).
+This @-prefix can also be used for character byte values.
+
 
 You can concatenate two string literals using '+' (not very useful though) or repeat
 a string literal a given number of times using '*'::
@@ -400,6 +407,10 @@ Iterating with a floating point variable is not supported. If you want to loop o
 The *while*-loop is used to repeat a piece of code while a certain condition is still true.
 The *repeat--until* loop is used to repeat a piece of code until a certain condition is true.
 
+The *forever*-loop is used to simply run a piece of code in a loop, forever. You can still
+break out of this loop if desired. A "while true" or "until false" loop is equivalent to
+a forever-loop.
+
 You can also create loops by using the ``goto`` statement, but this should usually be avoided.
 
 .. attention::
@@ -707,9 +718,13 @@ sum(x)
 
 sort(array)
     Sort the array in ascending order (in-place)
+    Note: sorting a floating-point array is not supported right now, as a general sorting routine for this will
+    be extremely slow. Either build one yourself or find another solution that doesn't require sorting
+    floating point values.
 
 reverse(array)
-    Reverse the values in the array (in-place). Can be used after sort() to sort an array in descending order.
+    Reverse the values in the array (in-place). Supports all data types including floats.
+    Can be used after sort() to sort an array in descending order.
 
 len(x)
     Number of values in the array value x, or the number of characters in a string (excluding the size or 0-byte).
@@ -826,6 +841,10 @@ rrestore()
 read_flags()
     Returns the current value of the CPU status register.
 
+exit(returncode)
+    Immediately stops the program and exits it, with the returncode in the A register.
+    Note: custom interrupt handlers remain active unless manually cleared first!
+
 
 
 Library routines

docs/source/syntaxreference.rst

@@ -172,13 +172,13 @@ Code blocks
 -----------
 
 A named block of actual program code. Itefines a *scope* (also known as 'namespace') and
-can contain Prog8 *code*, *directives*, *variable declarations* and *subroutines*::
+can only contain *directives*, *variable declarations*, *subroutines* or *inline assembly*::
 
     <blockname> [<address>] {
         <directives>
         <variables>
-        <statements>
         <subroutines>
+        <inline asm>
     }
 
 The <blockname> must be a valid identifier.
@@ -191,7 +191,6 @@ Also read :ref:`blocks`.  Here is an example of a code block, to be loaded at ``
 	}
 
 
-
 Labels
 ------
 
@@ -230,6 +229,7 @@ Various examples::
     byte        age     = 2018 - 1974
     float       wallet  = 55.25
     str         name    = "my name is Irmen"
+    str         name    = @"my name is Irmen"           ; string with alternative byte encoding
     uword       address = &counter
     byte[]      values  = [11, 22, 33, 44, 55]
     byte[5]     values                  ; array of 5 bytes, initially set to zero
@@ -248,7 +248,7 @@ Prog8 supports the following data types:
 type identifier  type                     storage size       example var declaration and literal value
 ===============  =======================  =================  =========================================
 ``byte``         signed byte              1 byte = 8 bits    ``byte myvar = -22``
-``ubyte``        unsigned byte            1 byte = 8 bits    ``ubyte myvar = $8f``
+``ubyte``        unsigned byte            1 byte = 8 bits    ``ubyte myvar = $8f``,   ``ubyte c = 'a'``,  ``ubyte c2 = @'a'``
 --               boolean                  1 byte = 8 bits    ``byte myvar = true`` or ``byte myvar == false``
                                                              The true and false are actually just aliases
                                                              for the byte values 1 and 0.
@@ -340,9 +340,16 @@ The following names are reserved, they have a special meaning::
 Range expression
 ^^^^^^^^^^^^^^^^
 
-A special value is the *range expression* ( ``<startvalue>  to  <endvalue>`` )
-which represents a range of numbers or characters,
-from the starting value to (and including) the ending value.
+A special value is the *range expression* which represents a range of numbers or characters,
+from the starting value to (and including) the ending value::
+
+    <start>  to  <end>   [ step  <step> ]
+    <start>  downto  <end>   [ step  <step> ]
+
+You an provide a step value if you need something else than the default increment which is one (or,
+in case of downto, a decrement of one).   Because a step of minus one is so common you can just use
+the downto variant to avoid having to specify the step as well.
+
 If used in the place of a literal value, it expands into the actual array of values::
 
 	byte[] array = 100 to 199     ; initialize array with [100, 101, ..., 198, 199]
@@ -464,9 +471,9 @@ If you're not interested in the return value, prefix the function call with the
 Otherwise the compiler will warn you about discarding the result of the call.
 
 Normal subroutines can only return zero or one return values.
-However, the special ``asmsub`` routines (implemented in assembly code or referencing
-a routine in kernel ROM) can return more than one return values, for instance a status
-in the carry bit and a number in A, or a 16-bit value in A/Y registers.
+However, the special ``asmsub`` routines (implemented in assembly code) or ``romsub`` routines
+(referencing a routine in kernel ROM) can return more than one return value.
+For example a status in the carry bit and a number in A, or a 16-bit value in A/Y registers.
 It is not possible to process the results of a call to these kind of routines
 directly from the language, because only single value assignments are possible.
 You can still call the subroutine and not store the results.
@@ -494,9 +501,34 @@ and can have nothing following it. The close curly brace must be on its own line
 The parameters is a (possibly empty) comma separated list of "<datatype> <parametername>" pairs specifying the input parameters.
 The return type has to be specified if the subroutine returns a value.
 
-.. todo::
-    asmsub with assigning memory address to refer to predefined ROM subroutines
-    asmsub with a regular body to precisely control what registers are used to call the subroutine
+
+Assembly /  ROM subroutines
+^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+Subroutines implemented in ROM are usually defined by compiler library files, with the following syntax::
+
+    romsub $FFD5 = LOAD(ubyte verify @ A, uword address @ XY) -> clobbers() -> ubyte @Pc, ubyte @ A, ubyte @ X, ubyte @ Y
+
+This defines the ``LOAD`` subroutine at ROM memory address $FFD5, taking arguments in all three registers A, X and Y,
+and returning stuff in several registers as well. The ``clobbers`` clause is used to signify to the compiler
+what CPU registers are clobbered by the call instead of being unchanged or returning a meaningful result value.
+
+
+Subroutines that are implemented purely in assembly code and which have an assembly calling convention (i.e.
+the parameters are strictly passed via cpu registers), are defined like this::
+
+    asmsub  FREADS32() clobbers(A,X,Y)  {
+        %asm {{
+            lda  $62
+            eor  #$ff
+            asl  a
+            lda  #0
+            ldx  #$a0
+            jmp  $bc4f
+        }}
+    }
+
+the statement body of such a subroutine should consist of just an inline assembly block.
 
 
 Expressions
@@ -565,8 +597,8 @@ You can use a single statement, or a statement block like in the example below::
 	}
 
 
-repeat--until loop
-^^^^^^^^^^^^^^^^^^
+repeat-until loop
+^^^^^^^^^^^^^^^^^
 
 Until the given condition is true (1), repeat the given statement(s).
 You can use a single statement, or a statement block like in the example below::
@@ -578,6 +610,19 @@ You can use a single statement, or a statement block like in the example below::
 	} until  <condition>
 
 
+forever loop
+^^^^^^^^^^^^
+
+Simply run the code in a loop, forever. It's the same as a while true or until false loop,
+or just a jump back to a previous label. You can still break out of this loop as well, if you want::
+
+    forever {
+        ; .. do stuff
+        if something
+            break        ; you can exit the loop if you want
+    }
+
+
 Conditional Execution and Jumps
 -------------------------------
 

docs/source/todo.rst

@@ -2,8 +2,10 @@
 TODO
 ====
 
+- remove statements after an exit() or return
+- fix warnings about that unreachable code?
+
 - option to load library files from a directory instead of the embedded ones
-- @"zzz"  screencode encoded strings  + add this to docs too
 
 
 Memory Block Operations integrated in language?
@@ -11,6 +13,9 @@ Memory Block Operations integrated in language?
 
 array/string memory block operations?
 
+- vector inc/dec/add/sub/mul/div...?  (on array or string):
+  ``arrayvar++ / arrayvar-- / arrayvar += 2 / arrayvar -= 2 / arrayvar *= 3 / arrayvar /= 3``
+
 - array operations
   copy (from another array with the same length), shift-N(left,right), rotate-N(left,right)
   clear (set whole array to the given value, default 0)

examples/arithmetic/aggregates.p8

@@ -104,7 +104,18 @@ main {
         ub = all(farr)
         if ub==0 c64scr.print("error all10\n")
 
+        check_eval_stack()
 
         c64scr.print("\nyou should see no errors above.")
     }
+
+    sub check_eval_stack() {
+        c64scr.print("x=")
+        c64scr.print_ub(X)
+        if X==255
+            c64scr.print(" ok\n")
+        else
+            c64scr.print(" error!\n")
+    }
+
 }

examples/arithmetic/bitshift.p8

@@ -36,7 +36,8 @@ main {
     }
 
     sub start() {
-        unimplemented()
+        ; TODO call this too:   unimplemented()
+
         lsr(A)
         lsl(A)
         ror(A)
@@ -107,5 +108,17 @@ main {
         ror(uw)
         rol2(uw)
         ror2(uw)
+
+        check_eval_stack()
     }
+
+    sub check_eval_stack() {
+        c64scr.print("x=")
+        c64scr.print_ub(X)
+        if X==255
+            c64scr.print(" ok\n")
+        else
+            c64scr.print(" error!\n")
+    }
+
 }

examples/arithmetic/div.p8

@@ -25,6 +25,7 @@ main {
         div_float(0,1,0)
         div_float(999.9,111.0,9.008108108108107)
 
+        check_eval_stack()
     }
 
     sub div_ubyte(ubyte a1, ubyte a2, ubyte c) {
@@ -102,4 +103,12 @@ main {
         c64flt.print_f(r)
         c64.CHROUT('\n')
     }
+
+    sub check_eval_stack() {
+        if X!=255 {
+            c64scr.print("x=")
+            c64scr.print_ub(X)
+            c64scr.print(" error!\n")
+        }
+    }
 }

examples/arithmetic/minus.p8

@@ -33,6 +33,7 @@ main {
         minus_float(2.5,1.5,1.0)
         minus_float(-1.5,3.5,-5.0)
 
+        check_eval_stack()
     }
 
     sub minus_ubyte(ubyte a1, ubyte a2, ubyte c) {
@@ -110,4 +111,13 @@ main {
         c64flt.print_f(r)
         c64.CHROUT('\n')
     }
+
+    sub check_eval_stack() {
+        if X!=255 {
+            c64scr.print("x=")
+            c64scr.print_ub(X)
+            c64scr.print(" error!\n")
+        }
+    }
+
 }

examples/arithmetic/mult.p8

@@ -27,6 +27,7 @@ main {
         mul_float(2.5,10,25)
         mul_float(-1.5,10,-15)
 
+        check_eval_stack()
     }
 
     sub mul_ubyte(ubyte a1, ubyte a2, ubyte c) {
@@ -104,4 +105,12 @@ main {
         c64flt.print_f(r)
         c64.CHROUT('\n')
     }
+
+    sub check_eval_stack() {
+        if X!=255 {
+            c64scr.print("x=")
+            c64scr.print_ub(X)
+            c64scr.print(" error!\n")
+        }
+    }
 }

examples/arithmetic/plus.p8

@@ -31,6 +31,7 @@ main {
         plus_float(-1.5,3.5,2.0)
         plus_float(-1.1,3.3,2.2)
 
+        check_eval_stack()
     }
 
     sub plus_ubyte(ubyte a1, ubyte a2, ubyte c) {
@@ -108,4 +109,13 @@ main {
         c64flt.print_f(r)
         c64.CHROUT('\n')
     }
+
+    sub check_eval_stack() {
+        if X!=255 {
+            c64scr.print("x=")
+            c64scr.print_ub(X)
+            c64scr.print(" error!\n")
+        }
+    }
+
 }

examples/arithmetic/postincrdecr.p8

@@ -5,7 +5,6 @@
 
 main {
 
-
     sub start()  {
 
         c64scr.plot(0,24)
@@ -64,6 +63,7 @@ main {
         warr[1]--
         flarr[1] --
         check_ub(ub, 200)
+
         Y=100
         Y--
         check_ub(Y, 99)
@@ -77,7 +77,7 @@ main {
         check_uw(uwarr[1], 2000)
         check_w(warr[1], -1000)
 
-        @($0400+400-1) = X
+        check_eval_stack()
     }
 
     sub check_ub(ubyte value, ubyte expected) {
@@ -139,4 +139,13 @@ main {
         c64flt.print_f(expected)
         c64.CHROUT('\n')
     }
+
+
+    sub check_eval_stack() {
+        if X!=255 {
+            c64scr.print("x=")
+            c64scr.print_ub(X)
+            c64scr.print(" error!\n")
+        }
+    }
 }

examples/arithmetic/remainder.p8

@@ -15,6 +15,8 @@ main {
         remainder_uword(40000,511,142)
         remainder_uword(40000,500,0)
         remainder_uword(43211,12,11)
+
+        check_eval_stack()
     }
 
     sub remainder_ubyte(ubyte a1, ubyte a2, ubyte c) {
@@ -46,4 +48,12 @@ main {
         c64scr.print_uw(r)
         c64.CHROUT('\n')
     }
+
+    sub check_eval_stack() {
+        if X!=255 {
+            c64scr.print("x=")
+            c64scr.print_ub(X)
+            c64scr.print(" error!\n")
+        }
+    }
 }

examples/arithmetic/sgn.p8

@@ -0,0 +1,130 @@
+%import c64flt
+%zeropage basicsafe
+
+main {
+
+    sub start() {
+        byte b1
+        byte b2
+        ubyte ub1
+        ubyte ub2
+        word w1
+        word w2
+        uword uw1
+        uword uw2
+        float f1
+        float f2
+
+        b1 = 10
+        b2 = 10
+        if sgn(b2-b1) != 0
+            c64scr.print("sgn1 error1\n")
+
+        b1 = -100
+        b2 = -100
+        if sgn(b2-b1) != 0
+            c64scr.print("sgn1 error2\n")
+
+        ub1 = 200
+        ub2 = 200
+        if sgn(ub2-ub1) != 0
+            c64scr.print("sgn1 error3\n")
+
+        w1 = 100
+        w2 = 100
+        if sgn(w2-w1) != 0
+            c64scr.print("sgn1 error4\n")
+
+        w1 = -2000
+        w2 = -2000
+        if sgn(w2-w1) != 0
+            c64scr.print("sgn1 error5\n")
+
+        uw1 = 999
+        uw2 = 999
+        if sgn(uw2-uw1) != 0
+            c64scr.print("sgn1 error6\n")
+
+        f1 = 3.45
+        f2 = 3.45
+        if sgn(f2-f1) != 0
+            c64scr.print("sgn1 error7\n")
+
+
+        ; -1
+        b1 = 11
+        b2 = 10
+        if sgn(b2-b1) != -1
+            c64scr.print("sgn2 error1\n")
+
+        b1 = -10
+        b2 = -100
+        if sgn(b2-b1) != -1
+            c64scr.print("sgn2 error2\n")
+
+        ub1 = 202
+        ub2 = 200
+        if sgn(ub2 as byte - ub1 as byte) != -1
+            c64scr.print("sgn2 error3\n")
+
+        w1 = 101
+        w2 = 100
+        if sgn(w2-w1) != -1
+            c64scr.print("sgn2 error4\n")
+
+        w1 = -200
+        w2 = -2000
+        if sgn(w2-w1) != -1
+            c64scr.print("sgn2 error5\n")
+
+        uw1 = 2222
+        uw2 = 999
+        if sgn(uw2 as word - uw1 as word) != -1
+            c64scr.print("sgn2 error6\n")
+        if sgn(uw2 - uw1) != -1
+            c64scr.print("sgn2 error6\n")
+
+        f1 = 3.45
+        f2 = 1.11
+        if sgn(f2-f1) != -1
+            c64scr.print("sgn2 error7\n")
+
+        ; +1
+        b1 = 11
+        b2 = 20
+        if sgn(b2-b1) != 1
+            c64scr.print("sgn3 error1\n")
+
+        b1 = -10
+        b2 = -1
+        if sgn(b2-b1) != 1
+            c64scr.print("sgn3 error2\n")
+
+        ub1 = 202
+        ub2 = 205
+        if sgn(ub2-ub1) != 1
+            c64scr.print("sgn3 error3\n")
+
+        w1 = 101
+        w2 = 200
+        if sgn(w2-w1) != 1
+            c64scr.print("sgn3 error4\n")
+
+        w1 = -200
+        w2 = -20
+        if sgn(w2-w1) != 1
+            c64scr.print("sgn3 error5\n")
+
+        uw1 = 2222
+        uw2 = 9999
+        if sgn(uw2-uw1) != 1
+            c64scr.print("sgn3 error6\n")
+
+        f1 = 3.45
+        f2 = 5.11
+        if sgn(f2-f1) != 1
+            c64scr.print("sgn3 error7\n")
+
+        c64scr.print("should see no sgn errors\n")
+    }
+ }

examples/bdmusic.p8

@@ -16,7 +16,7 @@ sub start() {
     void c64.CHRIN()
     c64.CLEARSCR()
 
-    while(true) {
+    forever {
         uword note
         for note in notes {
             ubyte note1 = lsb(note)
@@ -34,27 +34,28 @@ sub start() {
             delay()
         }
     }
+}
 
-    sub delay() {
-        ubyte d
-        for d in 0 to 12 {
-            while(c64.RASTER!=0) {
-                ; tempo delay synced to screen refresh
-            }
+sub delay() {
+    ubyte d
+    for d in 0 to 12 {
+        while c64.RASTER!=0 {
+            ; tempo delay synced to screen refresh
         }
     }
-
-    sub print_notes(ubyte n1, ubyte n2) {
-        c64.CHROUT('\n')
-        c64scr.plot(n1/2, 24)
-        c64.COLOR=7
-        c64.CHROUT('Q')
-        c64scr.plot(n2/2, 24)
-        c64.COLOR=4
-        c64.CHROUT('Q')
-    }
 }
 
+sub print_notes(ubyte n1, ubyte n2) {
+    c64.CHROUT('\n')
+    c64scr.plot(n1/2, 24)
+    c64.COLOR=7
+    c64.CHROUT('Q')
+    c64scr.plot(n2/2, 24)
+    c64.COLOR=4
+    c64.CHROUT('Q')
+}
+
+
     ; details about the boulderdash music can be found here:
     ; https://www.elmerproductions.com/sp/peterb/sounds.html#Theme%20tune
 

examples/comparison_ifs_byte.p8

@@ -106,12 +106,16 @@ main {
         else
             c64scr.print("error in 22>=22!\n")
 
-        ubyte endX = X
-        if endX == 255
-            c64scr.print("stack x ok!\n")
-        else
-            c64scr.print("error: stack x != 255 !\n")
-
+        check_eval_stack()
     }
 
+
+    sub check_eval_stack() {
+        c64scr.print("stack x=")
+        c64scr.print_ub(X)
+        if X==255
+            c64scr.print(" ok\n")
+        else
+            c64scr.print(" error!\n")
+    }
 }

examples/comparison_ifs_float.p8

@@ -106,11 +106,16 @@ main {
         else
             c64scr.print("error in -22.2>=-22.2!\n")
 
-        ubyte endX = X
-        if endX == 255
-            c64scr.print("stack x ok!\n")
+        check_eval_stack()
+    }
+
+    sub check_eval_stack() {
+        c64scr.print("stack x=")
+        c64scr.print_ub(X)
+        if X==255
+            c64scr.print(" ok\n")
         else
-            c64scr.print("error: stack x != 255 !\n")
+            c64scr.print(" error!\n")
     }
 
 }

examples/comparison_ifs_ubyte.p8

@@ -106,12 +106,16 @@ main {
         else
             c64scr.print("error in 22>=22!\n")
 
-        ubyte endX = X
-        if endX == 255
-            c64scr.print("stack x ok!\n")
-        else
-            c64scr.print("error: stack x != 255 !\n")
+        check_eval_stack()
+    }
 
+    sub check_eval_stack() {
+        c64scr.print("stack x=")
+        c64scr.print_ub(X)
+        if X==255
+            c64scr.print(" ok\n")
+        else
+            c64scr.print(" error!\n")
     }
 
 }

examples/comparison_ifs_uword.p8

@@ -106,13 +106,16 @@ main {
         else
             c64scr.print("error in 322>=322!\n")
 
+        check_eval_stack()
+    }
 
-        ubyte endX = X
-        if endX == 255
-            c64scr.print("stack x ok!\n")
+    sub check_eval_stack() {
+        c64scr.print("stack x=")
+        c64scr.print_ub(X)
+        if X==255
+            c64scr.print(" ok\n")
         else
-            c64scr.print("error: stack x != 255 !\n")
-
+            c64scr.print(" error!\n")
     }
 
 }

examples/comparison_ifs_word.p8

@@ -138,13 +138,16 @@ main {
         else
             c64scr.print("error in 1000>=1000!\n")
 
+        check_eval_stack()
+    }
 
-        ubyte endX = X
-        if endX == 255
-            c64scr.print("stack x ok!\n")
+    sub check_eval_stack() {
+        c64scr.print("stack x=")
+        c64scr.print_ub(X)
+        if X==255
+            c64scr.print(" ok\n")
         else
-            c64scr.print("error: stack x != 255 !\n")
-
+            c64scr.print(" error!\n")
     }
 
 }

examples/comparisons_byte.p8

@@ -52,16 +52,10 @@ main {
         c64scr.print("v1=20, v2=-111\n")
         compare()
 
-        ubyte endX = X
-        if endX == 255
-            c64scr.print("\nstack x ok!\n")
-        else
-            c64scr.print("\nerror: stack x != 255 !\n")
-
+        check_eval_stack()
         return
 
-
-    sub compare() {
+        sub compare() {
         c64scr.print("  ==  !=  <   >   <=  >=\n")
 
         if v1==v2
@@ -98,4 +92,13 @@ main {
 
     }
 
+    sub check_eval_stack() {
+        c64scr.print("stack x=")
+        c64scr.print_ub(X)
+        if X==255
+            c64scr.print(" ok\n")
+        else
+            c64scr.print(" error!\n")
+    }
+
 }

examples/comparisons_float.p8

@@ -68,16 +68,10 @@ main {
         c64scr.print("v1 = v2 = 0\n")
         compare()
 
-        ubyte endX = X
-        if endX == 255
-            c64scr.print("\nstack x ok!\n")
-        else
-            c64scr.print("\nerror: stack x != 255 !\n")
-
-
+        check_eval_stack()
         return
 
-    sub compare() {
+        sub compare() {
         c64scr.print("  ==  !=  <   >   <=  >=\n")
 
         if v1==v2
@@ -112,7 +106,14 @@ main {
 
     }
 
-
     }
 
+    sub check_eval_stack() {
+        c64scr.print("stack x=")
+        c64scr.print_ub(X)
+        if X==255
+            c64scr.print(" ok\n")
+        else
+            c64scr.print(" error!\n")
+    }
 }

examples/comparisons_ubyte.p8

@@ -52,15 +52,10 @@ main {
         c64scr.print("v1=220, v2=10\n")
         compare()
 
-        ubyte endX = X
-        if endX == 255
-            c64scr.print("\nstack x ok!\n")
-        else
-            c64scr.print("\nerror: stack x != 255 !\n")
-
+        check_eval_stack()
         return
 
-    sub compare() {
+        sub compare() {
         c64scr.print("  ==  !=  <   >   <=  >=\n")
 
         if v1==v2
@@ -97,4 +92,13 @@ main {
 
     }
 
+    sub check_eval_stack() {
+        c64scr.print("stack x=")
+        c64scr.print_ub(X)
+        if X==255
+            c64scr.print(" ok\n")
+        else
+            c64scr.print(" error!\n")
+    }
+
 }

examples/comparisons_uword.p8

@@ -82,16 +82,10 @@ main {
         c64scr.print("v1 = v2 = aa\n")
         compare()
 
-        ubyte endX = X
-        if endX == 255
-            c64scr.print("\nstack x ok!\n")
-        else
-            c64scr.print("\nerror: stack x != 255 !\n")
-
-
+        check_eval_stack()
         return
 
-    sub compare() {
+        sub compare() {
         c64scr.print("  ==  !=  <   >   <=  >=\n")
 
         if v1==v2
@@ -128,4 +122,13 @@ main {
 
     }
 
+    sub check_eval_stack() {
+        c64scr.print("stack x=")
+        c64scr.print_ub(X)
+        if X==255
+            c64scr.print(" ok\n")
+        else
+            c64scr.print(" error!\n")
+    }
+
 }

examples/comparisons_word.p8

@@ -118,15 +118,10 @@ main {
         c64scr.print("v1 = v2 = aa\n")
         compare()
 
-        ubyte endX = X
-        if endX == 255
-            c64scr.print("\nstack x ok!\n")
-        else
-            c64scr.print("\nerror: stack x != 255 !\n")
-
+        check_eval_stack()
         return
 
-    sub compare() {
+        sub compare() {
         c64scr.print("  ==  !=  <   >   <=  >=\n")
 
         if v1==v2
@@ -163,4 +158,13 @@ main {
 
     }
 
+    sub check_eval_stack() {
+        c64scr.print("stack x=")
+        c64scr.print_ub(X)
+        if X==255
+            c64scr.print(" ok\n")
+        else
+            c64scr.print(" error!\n")
+    }
+
 }

examples/compiled/makedisk.sh

@@ -1,3 +1,4 @@
+#!/bin/sh
 c1541 -format examples,01 d64 examples.d64
 for filename in *.prg; do
   c1541 examples.d64 -write $filename ${filename%.*}

examples/compiled/readme.txt

@@ -1,7 +1,7 @@
 These .prg files are the compiled versions of most of the examples.
 They can be loaded and ran on a C64 or in an emulator, for example in Vice:
 
-x64  hello.prg
+x64sc  hello.prg
 
 will load and run the hello example.