removed ROM-float optimizations, too troublesome. Fixed LOG2 not being defined on Cx16 as well.

compiler/res/prog8lib/c64/floats.asm

@@ -2,6 +2,8 @@
 
 FL_ONE_const	.byte  129     			; 1.0
 FL_ZERO_const	.byte  0,0,0,0,0		; 0.0
+FL_LOG2_const	.byte  $80, $31, $72, $17, $f8	; log(2)
+
 
 floats_store_reg	.byte  0		; temp storage
 

compiler/res/prog8lib/c64/floats.p8

@@ -19,23 +19,6 @@ floats {
 		; note: the fac1 and fac2 are working registers and take 6 bytes each,
 		; floats in memory  (and rom) are stored in 5-byte MFLPT packed format.
 
-		; constants in five-byte "mflpt" format in the BASIC ROM
-		&float  FL_PIVAL	= $aea8  ; 3.1415926...
-		&float  FL_N32768	= $b1a5  ; -32768
-		&float  FL_FONE		= $b9bc  ; 1
-		&float  FL_SQRHLF	= $b9d6  ; SQR(2) / 2
-		&float  FL_SQRTWO	= $b9db  ; SQR(2)
-		&float  FL_NEGHLF	= $b9e0  ; -.5
-		&float  FL_LOG2		= $b9e5  ; LOG(2)
-		&float  FL_TENC		= $baf9  ; 10
-		&float  FL_NZMIL	= $bdbd  ; 1e9 (1 billion)
-		&float  FL_FHALF	= $bf11  ; .5
-		&float  FL_LOGEB2	= $bfbf  ; 1 / LOG(2)
-		&float  FL_PIHALF	= $e2e0  ; PI / 2
-		&float  FL_TWOPI	= $e2e5  ; 2 * PI
-		&float  FL_FR4		= $e2ea  ; .25
-		; oddly enough, 0.0 isn't available in the kernel.
-
 
 ; note: fac1/2 might get clobbered even if not mentioned in the function's name.
 ; note: for subtraction and division, the left operand is in fac2, the right operand in fac1.

compiler/res/prog8lib/c64/floats_funcs.asm

@@ -175,8 +175,8 @@ func_log2_fac1	.proc
 		stx  P8ZP_SCRATCH_REG
 		jsr  LOG
 		jsr  MOVEF
-		lda  #<FL_LOG2
+		lda  #<FL_LOG2_const
-		ldy  #>FL_LOG2
+		ldy  #>FL_LOG2_const
 		jsr  MOVFM
 		jsr  FDIVT
 		ldx  P8ZP_SCRATCH_REG

compiler/src/prog8/compiler/target/IMachineDefinition.kt

@@ -32,7 +32,6 @@ internal interface IMachineDefinition {
 
     fun initializeZeropage(compilerOptions: CompilationOptions)
     fun getFloat(num: Number): IMachineFloat
-    fun getFloatRomConst(number: Double): String?
     fun importLibs(compilerOptions: CompilationOptions, importer: ModuleImporter, program: Program)
     fun launchEmulator(programName: String)
     fun isRegularRAMaddress(address: Int): Boolean

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

@@ -7,7 +7,6 @@ import prog8.compiler.target.IMachineDefinition
 import prog8.compiler.target.IMachineFloat
 import prog8.parser.ModuleImporter
 import java.io.IOException
-import java.math.RoundingMode
 import kotlin.math.absoluteValue
 import kotlin.math.pow
 
@@ -31,41 +30,6 @@ internal object C64MachineDefinition: IMachineDefinition {
 
     override fun getFloat(num: Number) = Mflpt5.fromNumber(num)
 
-    override fun getFloatRomConst(number: Double): String? {
-        // try to match the ROM float constants to save memory
-        val mflpt5 = Mflpt5.fromNumber(number)
-        val floatbytes = shortArrayOf(mflpt5.b0, mflpt5.b1, mflpt5.b2, mflpt5.b3, mflpt5.b4)
-        when {
-            floatbytes.contentEquals(shortArrayOf(0x00, 0x00, 0x00, 0x00, 0x00)) -> return "floats.FL_ZERO_const"        // not a ROM const
-            floatbytes.contentEquals(shortArrayOf(0x81, 0x00, 0x00, 0x00, 0x00)) -> return "floats.FL_ONE_const"        // not a ROM const
-            floatbytes.contentEquals(shortArrayOf(0x82, 0x49, 0x0f, 0xda, 0xa1)) -> return "floats.FL_PIVAL"
-            floatbytes.contentEquals(shortArrayOf(0x90, 0x80, 0x00, 0x00, 0x00)) -> return "floats.FL_N32768"
-            floatbytes.contentEquals(shortArrayOf(0x81, 0x00, 0x00, 0x00, 0x00)) -> return "floats.FL_FONE"
-            floatbytes.contentEquals(shortArrayOf(0x80, 0x35, 0x04, 0xf3, 0x34)) -> return "floats.FL_SQRHLF"
-            floatbytes.contentEquals(shortArrayOf(0x81, 0x35, 0x04, 0xf3, 0x34)) -> return "floats.FL_SQRTWO"
-            floatbytes.contentEquals(shortArrayOf(0x80, 0x80, 0x00, 0x00, 0x00)) -> return "floats.FL_NEGHLF"
-            floatbytes.contentEquals(shortArrayOf(0x80, 0x31, 0x72, 0x17, 0xf8)) -> return "floats.FL_LOG2"
-            floatbytes.contentEquals(shortArrayOf(0x84, 0x20, 0x00, 0x00, 0x00)) -> return "floats.FL_TENC"
-            floatbytes.contentEquals(shortArrayOf(0x9e, 0x6e, 0x6b, 0x28, 0x00)) -> return "floats.FL_NZMIL"
-            floatbytes.contentEquals(shortArrayOf(0x80, 0x00, 0x00, 0x00, 0x00)) -> return "floats.FL_FHALF"
-            floatbytes.contentEquals(shortArrayOf(0x81, 0x38, 0xaa, 0x3b, 0x29)) -> return "floats.FL_LOGEB2"
-            floatbytes.contentEquals(shortArrayOf(0x81, 0x49, 0x0f, 0xda, 0xa2)) -> return "floats.FL_PIHALF"
-            floatbytes.contentEquals(shortArrayOf(0x83, 0x49, 0x0f, 0xda, 0xa2)) -> return "floats.FL_TWOPI"
-            floatbytes.contentEquals(shortArrayOf(0x7f, 0x00, 0x00, 0x00, 0x00)) -> return "floats.FL_FR4"
-            else -> {
-                // attempt to correct for a few rounding issues
-                when (number.toBigDecimal().setScale(10, RoundingMode.HALF_DOWN).toDouble()) {
-                    3.1415926536 -> return "floats.FL_PIVAL"
-                    1.4142135624 -> return "floats.FL_SQRTWO"
-                    0.7071067812 -> return "floats.FL_SQRHLF"
-                    0.6931471806 -> return "floats.FL_LOG2"
-                    else -> {}
-                }
-            }
-        }
-        return null
-    }
-
     override fun importLibs(compilerOptions: CompilationOptions, importer: ModuleImporter, program: Program) {
         if (compilerOptions.launcher == LauncherType.BASIC || compilerOptions.output == OutputType.PRG)
             importer.importLibraryModule(program, "syslib")

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

@@ -470,16 +470,13 @@ internal class AsmGen(private val program: Program,
     }
 
     internal fun getFloatAsmConst(number: Double): String {
-        var asmName = CompilationTarget.instance.machine.getFloatRomConst(number)
+        val asmName = globalFloatConsts[number]
-        if(asmName.isNullOrEmpty()) {
+        if(asmName!=null)
-            // no ROM float const for this value, create our own
+            return asmName
-            asmName = globalFloatConsts[number]
+
-            if(asmName==null) {
+        val newName = "prog8_float_const_${globalFloatConsts.size}"
-                asmName = "prog8_float_const_${globalFloatConsts.size}"
+        globalFloatConsts[number] = newName
-                globalFloatConsts[number] = asmName
+        return newName
-            }
-        }
-        return asmName
     }
 
     internal fun asmSymbolName(identifier: IdentifierReference): String {

compiler/src/prog8/compiler/target/cx16/CX16MachineDefinition.kt

@@ -28,7 +28,6 @@ internal object CX16MachineDefinition: IMachineDefinition {
 
     override fun getFloat(num: Number) = C64MachineDefinition.Mflpt5.fromNumber(num)
 
-    override fun getFloatRomConst(number: Double): String? = null       // Cx16 has no pulblic ROM float locations
     override fun importLibs(compilerOptions: CompilationOptions, importer: ModuleImporter, program: Program) {
         if (compilerOptions.launcher == LauncherType.BASIC || compilerOptions.output == OutputType.PRG)
             importer.importLibraryModule(program, "syslib")

examples/test.p8

@@ -7,34 +7,10 @@
 %option no_sysinit
 
 main {
-
-    asmsub GRAPH_draw_line(uword x1 @R0, uword y1 @R1, uword x2 @R2, uword y2 @R3)  clobbers(A,X,Y)  {
-        %asm {{
-            lda  cx16.r0
-            ldy  cx16.r0+1
-            jsr  txt.print_uw
-            lda  #13
-            jsr  c64.CHROUT
-            lda  cx16.r1
-            ldy  cx16.r1+1
-            jsr  txt.print_uw
-            lda  #13
-            jsr  c64.CHROUT
-            lda  cx16.r2
-            ldy  cx16.r2+1
-            jsr  txt.print_uw
-            lda  #13
-            jsr  c64.CHROUT
-            lda  cx16.r3
-            ldy  cx16.r3+1
-            jsr  txt.print_uw
-            lda  #13
-            jsr  c64.CHROUT
-            rts
-        }}
-    }
-
     sub start () {
-        GRAPH_draw_line(1111,2222,3333,4444)        ; TODO allocate R0-R15 for the C64 as well (at the bottom of the eval stack hi at $cf00)
+        float fl
+
+        fl = log2(10)
+        floats.print_f(fl)
     }
 }