tweak library routines for multiple return values.

cbm:
MEMTOP changed (now also returns nr of banks in A)
STOP2 removed (just use STOP)
RDTIM_safe() added                  TEST IRQ ENABLE
RDTIM16 changed (internally)        TEST IRQ ENABLE

cx16:
screen_mode changed (now also returns width and height in X,Y)
kbdbuf_peek2 removed (just use kbdbuf_peek)
joystick_get changed (presence now returned as bool in Y)
joystick_get2 removed (just use joystick_get)
mouse_pos changed (now properly returns x and y position in R0 and R1)
set_led_brightness changed into set_led_state, with only a boolean on/off argument. There is no variable brightness.

sys.set_leds_brightness() removed. Use cx16.set_led_brightness().

codeGenCpu6502/src/prog8/codegen/cpu6502/assignment/AssignmentAsmGen.kt

@@ -55,14 +55,53 @@ internal class AssignmentAsmGen(private val program: PtProgram,
             else
                 true
 
-        fun assignCarryResult(target: PtAssignTarget, saveA: Boolean) {
+        fun assignCarryFlagResult(target: PtAssignTarget, saveA: Boolean) {
             if(saveA) asmgen.out("  pha")
             asmgen.out("  lda  #0  |  rol  a")
             val tgt = AsmAssignTarget.fromAstAssignment(target, target.definingISub(), asmgen)
             assignRegisterByte(tgt, CpuRegister.A, false, false)
             if(saveA) asmgen.out("  pla")
         }
 
+        fun assignZeroFlagResult(target: PtAssignTarget, saveA: Boolean) {
+            if(saveA) asmgen.out("  pha")
+            asmgen.out("""
+                beq  +
+                lda  #0
+                beq  ++
++               lda  #1
++""")
+            val tgt = AsmAssignTarget.fromAstAssignment(target, target.definingISub(), asmgen)
+            assignRegisterByte(tgt, CpuRegister.A, false, false)
+            if(saveA) asmgen.out("  pla")
+        }
+
+        fun assignNegativeFlagResult(target: PtAssignTarget, saveA: Boolean) {
+            if(saveA) asmgen.out("  pha")
+            asmgen.out("""
+                bmi  +
+                lda  #0
+                beq  ++
++               lda  #1
++""")
+            val tgt = AsmAssignTarget.fromAstAssignment(target, target.definingISub(), asmgen)
+            assignRegisterByte(tgt, CpuRegister.A, false, false)
+            if(saveA) asmgen.out("  pla")
+        }
+
+        fun assignOverflowFlagResult(target: PtAssignTarget, saveA: Boolean) {
+            if(saveA) asmgen.out("  pha")
+            asmgen.out("""
+                bvs  +
+                lda  #0
+                beq  ++
++               lda  #1
++""")
+            val tgt = AsmAssignTarget.fromAstAssignment(target, target.definingISub(), asmgen)
+            assignRegisterByte(tgt, CpuRegister.A, false, false)
+            if(saveA) asmgen.out("  pla")
+        }
+
         fun assignRegisterResults(registersResults: List<Pair<StRomSubParameter, PtNode>>) {
             registersResults.forEach { (returns, target) ->
                 target as PtAssignTarget
@@ -94,9 +133,6 @@ internal class AssignmentAsmGen(private val program: PtProgram,
                 if(statusFlagResults.size>1)
                     TODO("handle multiple status flag results")
                 val (returns, target) = statusFlagResults.single()
-                if(returns.register.statusflag!=Statusflag.Pc)
-                    TODO("other status flag for return value")
-
                 target as PtAssignTarget
                 if(target.void) {
                     // forget about the Carry status flag, only assign the normal return values
@@ -110,10 +146,21 @@ internal class AssignmentAsmGen(private val program: PtProgram,
                     // all other results are just stored into identifiers directly so first handle those
                     // (simple store instructions that don't modify the carry flag)
                     assignRegisterResults(registersResults)
-                    assignCarryResult(target, false)
-                    return
+                    return when(returns.register.statusflag!!) {
+                        Statusflag.Pc -> assignCarryFlagResult(target, false)
+                        Statusflag.Pz -> assignZeroFlagResult(target, false)
+                        Statusflag.Pv -> assignOverflowFlagResult(target, false)
+                        Statusflag.Pn -> assignNegativeFlagResult(target, false)
+                    }
+                }
+
+                val saveA = needsToSaveA(registersResults)
+                when(returns.register.statusflag!!) {
+                    Statusflag.Pc -> assignCarryFlagResult(target, saveA)
+                    Statusflag.Pz -> assignZeroFlagResult(target, saveA)
+                    Statusflag.Pv -> assignOverflowFlagResult(target, saveA)
+                    Statusflag.Pn -> assignNegativeFlagResult(target, saveA)
                 }
-                assignCarryResult(target, needsToSaveA(registersResults))
             }
             assignRegisterResults(registersResults)
         } else {

compiler/res/prog8lib/c128/syslib.p8

@@ -105,18 +105,6 @@ romsub $FFF3 = IOBASE() -> uword @ XY                           ; read base addr
 
 ; ---- utilities -----
 
-asmsub STOP2() clobbers(X) -> bool @A  {
-    ; -- check if STOP key was pressed, returns true if so.  More convenient to use than STOP() because that only sets the carry status flag.
-    %asm {{
-        jsr  cbm.STOP
-        beq  +
-        lda  #0
-        rts
-+       lda  #1
-        rts
-    }}
-}
-
 asmsub RDTIM16() clobbers(X) -> uword @AY {
     ; --  like RDTIM() but only returning the lower 16 bits in AY for convenience
     %asm {{

compiler/res/prog8lib/c64/syslib.p8

@@ -102,18 +102,6 @@ romsub $FFED = SCREEN() -> ubyte @ X, ubyte @ Y                 ; read number of
 romsub $FFF0 = PLOT(ubyte col @ Y, ubyte row @ X, bool dir @ Pc) clobbers(A) -> ubyte @ X, ubyte @ Y       ; read/set position of cursor on screen.  Use txt.plot for a 'safe' wrapper that preserves X.
 romsub $FFF3 = IOBASE() -> uword @ XY                           ; read base address of I/O devices
 
-asmsub STOP2() clobbers(X) -> bool @A  {
-    ; -- check if STOP key was pressed, returns true if so.  More convenient to use than STOP() because that only sets the carry status flag.
-    %asm {{
-        jsr  cbm.STOP
-        beq  +
-        lda  #0
-        rts
-+       lda  #1
-        rts
-    }}
-}
-
 asmsub RDTIM16() clobbers(X) -> uword @AY {
     ; --  like RDTIM() but only returning the lower 16 bits in AY for convenience
     %asm {{

compiler/res/prog8lib/cx16/diskio.p8

@@ -81,7 +81,8 @@ diskio {
             void cbm.CHRIN()     ; skip 2 bytes
             void cbm.CHRIN()
             status = cbm.READST()
-            if cbm.STOP2()
+            void cbm.STOP()
+            if_z
                 break
         }
         status = cbm.READST()