palette: changed some of the available presets. Also fix sizeof(array) crash.

compiler/res/prog8lib/cx16/palette.p8

@@ -1,11 +1,11 @@
 ; Manipulate the Commander X16's display color palette.
-; Should you want to restore the default palette, you have to reinitialize the Vera yourself.
+; Should you want to restore the full default palette, you can call cbm.CINT()
+; The first 16 colors can be restored to their default with set_default16()
 
 palette {
     %option no_symbol_prefixing
 
     uword vera_palette_ptr
-    ubyte cc
 
     sub set_color(ubyte index, uword color) {
         vera_palette_ptr = $fa00+(index as uword * 2)
@@ -89,105 +89,84 @@ palette {
     }
 
     sub set_grayscale() {
+        ; set first 16 colors to a grayscale gradient from black to white
         vera_palette_ptr = $fa00
-        cc=0
+        cx16.r2L=0
         repeat 16 {
-            cx16.vpoke(1, vera_palette_ptr, cc)
+            cx16.vpoke(1, vera_palette_ptr, cx16.r2L)
             vera_palette_ptr++
-            cx16.vpoke(1, vera_palette_ptr, cc)
+            cx16.vpoke(1, vera_palette_ptr, cx16.r2L)
             vera_palette_ptr++
-            cc += $11
+            cx16.r2L += $11
         }
     }
 
-    uword[] C64_colorpalette_dark = [   ; this is a darker palette with more contrast
-        $000,  ; 0 = black
-        $FFF,  ; 1 = white
-        $632,  ; 2 = red
-        $7AB,  ; 3 = cyan
-        $638,  ; 4 = purple
-        $584,  ; 5 = green
-        $327,  ; 6 = blue
-        $BC6,  ; 7 = yellow
-        $642,  ; 8 = orange
-        $430,  ; 9 = brown
-        $965,  ; 10 = light red
-        $444,  ; 11 = dark grey
-        $666,  ; 12 = medium grey
-        $9D8,  ; 13 = light green
-        $65B,  ; 14 = light blue
-        $999   ; 15 = light grey
-    ]
-
-    uword[] C64_colorpalette_pepto = [  ; # this is Pepto's Commodore-64 palette  http://www.pepto.de/projects/colorvic/
-        $000,  ; 0 = black
-        $FFF,  ; 1 = white
-        $833,  ; 2 = red
-        $7cc,  ; 3 = cyan
-        $839,  ; 4 = purple
-        $5a4,  ; 5 = green
-        $229,  ; 6 = blue
-        $ef7,  ; 7 = yellow
-        $852,  ; 8 = orange
-        $530,  ; 9 = brown
-        $c67,  ; 10 = light red
-        $444,  ; 11 = dark grey
-        $777,  ; 12 = medium grey
-        $af9,  ; 13 = light green
-        $76e,  ; 14 = light blue
-        $bbb   ; 15 = light grey
-    ]
-
-    uword[] C64_colorpalette_light = [  ; this is a lighter palette
-        $000,  ; 0 = black
-        $FFF,  ; 1 = white
-        $944,  ; 2 = red
-        $7CC,  ; 3 = cyan
-        $95A,  ; 4 = purple
-        $6A5,  ; 5 = green
-        $549,  ; 6 = blue
-        $CD8,  ; 7 = yellow
-        $963,  ; 8 = orange
-        $650,  ; 9 = brown
-        $C77,  ; 10 = light red
-        $666,  ; 11 = dark grey
-        $888,  ; 12 = medium grey
-        $AE9,  ; 13 = light green
-        $87C,  ; 14 = light blue
-        $AAA   ; 15 = light grey
-    ]
-
     sub set_c64pepto() {
-        vera_palette_ptr = $fa00
+        ; set first 16 colors to the "Pepto" PAL commodore-64 palette  http://www.pepto.de/projects/colorvic/
-        for cc in 0 to 15 {
+        uword[] colors = [
-            uword ccp = C64_colorpalette_pepto[cc]
+            $000,  ; 0 = black
-            cx16.vpoke(1, vera_palette_ptr, lsb(ccp))     ; G, B
+            $FFF,  ; 1 = white
-            vera_palette_ptr++
+            $833,  ; 2 = red
-            cx16.vpoke(1, vera_palette_ptr, msb(ccp))     ; R
+            $7cc,  ; 3 = cyan
-            vera_palette_ptr++
+            $839,  ; 4 = purple
-        }
+            $5a4,  ; 5 = green
+            $229,  ; 6 = blue
+            $ef7,  ; 7 = yellow
+            $852,  ; 8 = orange
+            $530,  ; 9 = brown
+            $c67,  ; 10 = light red
+            $444,  ; 11 = dark grey
+            $777,  ; 12 = medium grey
+            $af9,  ; 13 = light green
+            $76e,  ; 14 = light blue
+            $bbb   ; 15 = light grey
+        ]
+        set_rgb(colors, len(colors))
     }
 
-    sub set_c64light() {
+    sub set_c64ntsc() {
-        vera_palette_ptr = $fa00
+        ; set first 16 colors to a NTSC commodore-64 palette
-        for cc in 0 to 15 {
+        uword[] colors = [
-            uword ccp = C64_colorpalette_light[cc]
+            $000,   ; 0 = black
-            cx16.vpoke(1, vera_palette_ptr, lsb(ccp))     ; G, B
+            $FFF,   ; 1 = white
-            vera_palette_ptr++
+            $934,   ; 2 = red
-            cx16.vpoke(1, vera_palette_ptr, msb(ccp))     ; R
+            $9ff,   ; 3 = cyan
-            vera_palette_ptr++
+            $73f,   ; 4 = purple
-        }
+            $4b1,   ; 5 = green
+            $20c,   ; 6 = blue
+            $ee6,   ; 7 = yellow
+            $b53,   ; 8 = orange
+            $830,   ; 9 = brown
+            $f8a,   ; 10 = light red
+            $444,   ; 11 = dark grey
+            $999,   ; 12 = medium grey
+            $9f9,   ; 13 = light green
+            $36f,   ; 14 = light blue
+            $ccc    ; 15 = light grey
+        ]
+        set_rgb(colors, len(colors))
     }
 
-    sub set_c64dark() {
+    sub set_default16() {
-        vera_palette_ptr = $fa00
+        ; set first 16 colors to the defaults on the X16
-        for cc in 0 to 15 {
+        uword[] colors = [
-            uword ccp = C64_colorpalette_dark[cc]
+            $000,   ; 0 = black
-            cx16.vpoke(1, vera_palette_ptr, lsb(ccp))     ; G, B
+            $fff,   ; 1 = white
-            vera_palette_ptr++
+            $800,   ; 2 = red
-            cx16.vpoke(1, vera_palette_ptr, msb(ccp))     ; R
+            $afe,   ; 3 = cyan
-            vera_palette_ptr++
+            $c4c,   ; 4 = purple
-        }
+            $0c5,   ; 5 = green
+            $00a,   ; 6 = blue
+            $ee7,   ; 7 = yellow
+            $d85,   ; 8 = orange
+            $640,   ; 9 = brown
+            $f77,   ; 10 = light red
+            $333,   ; 11 = dark grey
+            $777,   ; 12 = medium grey
+            $af6,   ; 13 = light green
+            $08f,   ; 14 = light blue
+            $bbb    ; 15 = light grey
+        ]
+        set_rgb(colors, len(colors))
     }
-
 }

compiler/src/prog8/compiler/BuiltinFunctions.kt

@@ -121,7 +121,7 @@ private fun builtinSizeof(args: List<Expression>, position: Position, program: P
 
         return when {
             dt.isArray -> {
-                val length = (target as VarDecl).arraysize!!.constIndex() ?: throw CannotEvaluateException("sizeof", "unknown array size")
+                val length = (target as VarDecl).arraysize?.constIndex() ?: throw CannotEvaluateException("sizeof", "unknown array size")
                 val elementDt = ArrayToElementTypes.getValue(dt.getOr(DataType.UNDEFINED))
                 NumericLiteral.optimalInteger(program.memsizer.memorySize(elementDt) * length, position)
             }

compiler/test/TestBuiltinFunctions.kt

@@ -5,6 +5,7 @@ import io.kotest.matchers.shouldBe
 import io.kotest.matchers.shouldNotBe
 import prog8.ast.expressions.NumericLiteral
 import prog8.ast.statements.Assignment
+import prog8.ast.statements.FunctionCallStatement
 import prog8.code.core.BuiltinFunctions
 import prog8.code.core.DataType
 import prog8.code.core.NumericDatatypesNoBool
@@ -85,26 +86,31 @@ class TestBuiltinFunctions: FunSpec({
         val src="""
 main {
     sub start() {
-
         uword[] array = [1,2,3]
         str name = "hello"
         cx16.r0L = len(array)
-        cx16.r0L = len(name)
+        cx16.r1L = len(name)
-        cx16.r0L = sizeof(array)
+        cx16.r2L = sizeof(array)
-        cx16.r0 = mkword(200,100)
+        cx16.r4 = mkword(200,100)
+        test(sizeof(array))
+    }
+    sub test(uword value) {
+        value++
     }
 }"""
         val result = compileText(Cx16Target(), false, src, writeAssembly = false)
         val statements = result!!.compilerAst.entrypoint.statements
-        statements.size shouldBe 6
+        statements.size shouldBe 7
         val a1 = statements[2] as Assignment
         val a2 = statements[3] as Assignment
         val a3 = statements[4] as Assignment
         val a4 = statements[5] as Assignment
+        val a5 = statements[6] as FunctionCallStatement
         (a1.value as NumericLiteral).number shouldBe 3.0
         (a2.value as NumericLiteral).number shouldBe 5.0
         (a3.value as NumericLiteral).number shouldBe 6.0
         (a4.value as NumericLiteral).number shouldBe 200*256+100
+        (a5.args[0] as NumericLiteral).number shouldBe 6.0
     }
 })
 

docs/source/todo.rst

@@ -3,7 +3,6 @@ TODO
 ====
 
 - [on branch: shortcircuit] investigate McCarthy evaluation again? this may also reduce code size perhaps for things like if a>4 or a<2 ....
-- once VAL_1 is merged into the kernal properly, remove all the workarounds in cx16 floats.parse_f()
 
 ...
 
@@ -47,6 +46,7 @@ Compiler:
 
 Libraries:
 
+- once a VAL_1 implementation is merged into the X16 kernal properly, remove all the workarounds in cx16 floats.parse_f()
 - fix the problems in atari target, and flesh out its libraries.
 - c128 target: make syslib more complete (missing kernal routines)?
 - pet32 target: make syslib more complete (missing kernal routines)?