diff --git a/compiler/res/prog8lib/c64/syslib.p8 b/compiler/res/prog8lib/c64/syslib.p8 index 8bc9b4bf7..91768aa2a 100644 --- a/compiler/res/prog8lib/c64/syslib.p8 +++ b/compiler/res/prog8lib/c64/syslib.p8 @@ -474,6 +474,9 @@ _raster_irq_handler sys { ; ------- lowlevel system routines -------- + const ubyte target = 64 ; compilation target specifier. 64 = C64, 16 = CommanderX16. + + asmsub reset_system() { ; Soft-reset the system back to Basic prompt. %asm {{ diff --git a/compiler/res/prog8lib/cx16/syslib.p8 b/compiler/res/prog8lib/cx16/syslib.p8 index c83eeece9..1cc9f4965 100644 --- a/compiler/res/prog8lib/cx16/syslib.p8 +++ b/compiler/res/prog8lib/cx16/syslib.p8 @@ -473,6 +473,9 @@ asmsub init_system() { sys { ; ------- lowlevel system routines -------- + const ubyte target = 16 ; compilation target specifier. 64 = C64, 16 = CommanderX16. + + asmsub reset_system() { ; Soft-reset the system back to Basic prompt. %asm {{ diff --git a/compiler/src/prog8/functions/BuiltinFunctions.kt b/compiler/src/prog8/functions/BuiltinFunctions.kt index ea71aba71..3d4800f5d 100644 --- a/compiler/src/prog8/functions/BuiltinFunctions.kt +++ b/compiler/src/prog8/functions/BuiltinFunctions.kt @@ -6,9 +6,6 @@ import prog8.ast.expressions.* import prog8.ast.statements.StructDecl import prog8.ast.statements.VarDecl import prog8.compiler.CompilerException -import prog8.compiler.target.C64Target -import prog8.compiler.target.CompilationTarget -import prog8.compiler.target.Cx16Target import kotlin.math.* @@ -146,7 +143,6 @@ private val functionSignatures: List = listOf( FSignature("read_flags" , true, emptyList(), DataType.UBYTE), FSignature("progend" , true, emptyList(), DataType.UWORD), FSignature("memory" , true, listOf(FParam("name", setOf(DataType.STR)), FParam("size", setOf(DataType.UWORD))), DataType.UWORD), - FSignature("target" , true, emptyList(), DataType.UBYTE, ::builtinTarget), FSignature("swap" , false, listOf(FParam("first", NumericDatatypes), FParam("second", NumericDatatypes)), null), FSignature("memcopy" , false, listOf( FParam("from", IterableDatatypes + DataType.UWORD), @@ -452,17 +448,6 @@ private fun builtinSgn(args: List, position: Position, program: Prog return NumericLiteralValue(DataType.BYTE, constval.number.toDouble().sign.toInt().toShort(), position) } -private fun builtinTarget(args: List, position: Position, program: Program): NumericLiteralValue { - if (args.isNotEmpty()) - throw SyntaxError("target requires no arguments", position) - val target = when(CompilationTarget.instance) { - is C64Target -> 64 - is Cx16Target -> 16 - else -> throw CompilerException("unrecognised compilation target") - } - return NumericLiteralValue(DataType.UBYTE, target, position) -} - private fun numericLiteral(value: Number, position: Position): NumericLiteralValue { val floatNum=value.toDouble() val tweakedValue: Number = diff --git a/docs/source/libraries.rst b/docs/source/libraries.rst index 6ce83c11b..5fc26b574 100644 --- a/docs/source/libraries.rst +++ b/docs/source/libraries.rst @@ -34,6 +34,17 @@ as ROM/kernal subroutine definitions, memory location constants, and utility sub Many of these definitions overlap for the C64 and Commander X16 targets so it is still possible to write programs that work on both targets without modifications. +``sys.target`` + A constant ubyte value designating the target machine that the program is compiled for. + Notice that this is a compile-time constant value and is not determined on the + system when the program is running. + The following return values are currently defined: + + - 16 = compiled for CommanderX16 with 65C02 CPU + - 64 = compiled for Commodore-64 with 6502/6510 CPU + + + conv ---- Routines to convert strings to numbers or vice versa. @@ -69,40 +80,40 @@ string ------ Provides string manipulation routines. -length(str) -> ubyte length +``length(str) -> ubyte length`` Number of bytes in the string. This value is determined during runtime and counts upto the first terminating 0 byte in the string, regardless of the size of the string during compilation time. Don't confuse this with ``len`` and ``sizeof`` -left(source, length, target) +``left(source, length, target)`` Copies the left side of the source string of the given length to target string. It is assumed the target string buffer is large enough to contain the result. Also, you have to make sure yourself that length is smaller or equal to the length of the source string. Modifies in-place, doesn't return a value (so can't be used in an expression). -right(source, length, target) +``right(source, length, target)`` Copies the right side of the source string of the given length to target string. It is assumed the target string buffer is large enough to contain the result. Also, you have to make sure yourself that length is smaller or equal to the length of the source string. Modifies in-place, doesn't return a value (so can't be used in an expression). -slice(source, start, length, target) +``slice(source, start, length, target)`` Copies a segment from the source string, starting at the given index, and of the given length to target string. It is assumed the target string buffer is large enough to contain the result. Also, you have to make sure yourself that start and length are within bounds of the strings. Modifies in-place, doesn't return a value (so can't be used in an expression). -find(string, char) -> uword address +``find(string, char) -> uword address`` Locates the first position of the given character in the string, returns the string starting with this character or $0000 if the character is not found. -compare(string1, string2) -> ubyte result +``compare(string1, string2) -> ubyte result`` Returns -1, 0 or 1 depeding on wether string1 sorts before, equal or after string2. Note that you can also directly compare strings and string values with eachother using ``==``, ``<`` etcetera (it will use string.compare for you under water automatically). -copy(from, to) -> ubyte length +``copy(from, to) -> ubyte length`` Copy a string to another, overwriting that one. Returns the length of the string that was copied. Often you don't have to call this explicitly and can just write ``string1 = string2`` but this function is useful if you're dealing with addresses for instance. diff --git a/docs/source/programming.rst b/docs/source/programming.rst index 7cfe5ea99..e3712decf 100644 --- a/docs/source/programming.rst +++ b/docs/source/programming.rst @@ -888,15 +888,6 @@ set_irqd() / clear_irqd() swap(x, y) Swap the values of numerical variables (or memory locations) x and y in a fast way. -target() - Returns byte value designating the target machine that the program was compiled for. - Notice that this is a compile-time constant value and is not determined on the - system when the program is running. - The following return values are currently defined: - - - 16 = compiled for CommanderX16 with 65C02 CPU - - 64 = compiled for Commodore-64 with 6502/6510 CPU - memory(name, size) Statically allocates a fixed portion of memory of the given size in bytes, and returns its address. Slabs are considered identical if their name and size are the same. diff --git a/docs/source/todo.rst b/docs/source/todo.rst index 5d56cfcc9..d644c89d9 100644 --- a/docs/source/todo.rst +++ b/docs/source/todo.rst @@ -2,8 +2,7 @@ TODO ==== -- move all str* builtin functions to a strings library module, mem* to the sys module. update docs. -- move target() builtin to sys.target constant +- move all mem* builtins to the sys module. update docs. - use (zp) addressing mode on 65c02 specific code rather than ldy#0 / lda (zp),y - optimize pointer access code @(pointer)? use a subroutine? macro? 65c02 vs 6502? - allow byte return type with single register for asmsubs, for instance string.compare diff --git a/examples/test.p8 b/examples/test.p8 index 4d7e35c3c..6f3b53c8d 100644 --- a/examples/test.p8 +++ b/examples/test.p8 @@ -7,6 +7,7 @@ main { sub start() { + txt.print_ub(sys.target) } sub start2 () {