Apple-2-SW/prog8
1
0
Fork 0
mirror of https://github.com/irmen/prog8.git synced 2025-01-11 13:29:45 +00:00
Code Issues Projects Releases Wiki Activity

moved all *integer* builtin trig functions (sin8u, cos8u etc) as regular asmsubs in math module

Browse Source
This commit is contained in:
Irmen de Jong 2022-04-12 23:58:19 +02:00
parent 51bf33040a
commit ab1766a559
30 changed files with 300 additions and 689 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

21
codeGenCpu6502/src/prog8/codegen/cpu6502/BuiltinFunctionsAsmGen.kt
View File

@ -85,10 +85,6 @@ internal class BuiltinFunctionsAsmGen(private val program: Program,
"min", "max" -> funcMinMax(fcall, func, resultToStack, resultRegister, sscope)
"sum" -> funcSum(fcall, resultToStack, resultRegister, sscope)
"any", "all" -> funcAnyAll(fcall, func, resultToStack, resultRegister, sscope)
"sin8", "sin8u", "sin16", "sin16u",
"sinr8", "sinr8u", "sinr16", "sinr16u",
"cos8", "cos8u", "cos16", "cos16u",
"cosr8", "cosr8u", "cosr16", "cosr16u" -> funcSinCosInt(fcall, func, resultToStack, resultRegister, sscope)
"sgn" -> funcSgn(fcall, func, resultToStack, resultRegister, sscope)
"sin", "cos", "tan", "atan",
"ln", "log2", "sqrt", "rad",
@ -391,23 +387,6 @@ internal class BuiltinFunctionsAsmGen(private val program: Program,
}
}
private fun funcSinCosInt(fcall: IFunctionCall, func: FSignature, resultToStack: Boolean, resultRegister: RegisterOrPair?, scope: Subroutine?) {
translateArguments(fcall.args, func, scope)
if(resultToStack)
asmgen.out(" jsr prog8_lib.func_${func.name}_stack")
else
when(func.name) {
"sin8", "sin8u", "sinr8", "sinr8u", "cos8", "cos8u", "cosr8", "cosr8u" -> {
asmgen.out(" jsr prog8_lib.func_${func.name}_into_A")
assignAsmGen.assignRegisterByte(AsmAssignTarget.fromRegisters(resultRegister ?: RegisterOrPair.A, false, scope, program, asmgen), CpuRegister.A)
}
"sin16", "sin16u", "sinr16", "sinr16u", "cos16", "cos16u", "cosr16", "cosr16u" -> {
asmgen.out(" jsr prog8_lib.func_${func.name}_into_AY")
assignAsmGen.assignRegisterpairWord(AsmAssignTarget.fromRegisters(resultRegister ?: RegisterOrPair.AY, false, scope, program, asmgen), RegisterOrPair.AY)
}
}
}
private fun funcReverse(fcall: IFunctionCall) {
val variable = fcall.args.single()
if (variable is IdentifierReference) {

16
codeGenVirtual/src/prog8/codegen/virtual/BuiltinFuncGen.kt
View File

@ -12,28 +12,14 @@ internal class BuiltinFuncGen(private val codeGen: CodeGen, private val exprGen:
fun translate(call: PtBuiltinFunctionCall, resultRegister: Int): VmCodeChunk {
return when(call.name) {
"cmp" -> TODO()
"cmp" -> TODO("cmp() can't be used on vm because no processor status bits implemented")
"max" -> TODO()
"min" -> TODO()
"sum" -> TODO()
"abs" -> TODO()
"sgn" -> funcSgn(call, resultRegister)
"sin" -> TODO("floats not yet implemented")
"sin8" -> TODO()
"sin16" -> TODO()
"sin16u" -> TODO()
"sinr8" -> TODO()
"sinr8u" -> TODO()
"sinr16" -> TODO()
"sinr16u" -> TODO()
"cos" -> TODO("floats not yet implemented")
"cos8" -> TODO()
"cos16" -> TODO()
"cos16u" -> TODO()
"cosr8" -> TODO()
"cosr8u" -> TODO()
"cosr16" -> TODO()
"cosr16u" -> TODO()
"tan" -> TODO("floats not yet implemented")
"atan" -> TODO("floats not yet implemented")
"ln" -> TODO("floats not yet implemented")

176
compiler/res/prog8lib/math.p8
View File

@ -4,4 +4,180 @@
math {
%asminclude "library:math.asm"
asmsub sin8u(ubyte angle @A) clobbers(Y) -> ubyte @A {
%asm {{
tay
lda _sinecos8u,y
rts
_sinecos8u .byte trunc(128.0 + 127.5 * sin(range(256+64) * rad(360.0/256.0)))
}}
}
asmsub cos8u(ubyte angle @A) clobbers(Y) -> ubyte @A {
%asm {{
tay
lda sin8u._sinecos8u+64,y
rts
}}
}
asmsub sin8(ubyte angle @A) clobbers(Y) -> byte @A {
%asm {{
tay
lda _sinecos8,y
rts
_sinecos8 .char trunc(127.0 * sin(range(256+64) * rad(360.0/256.0)))
}}
}
asmsub cos8(ubyte angle @A) clobbers(Y) -> byte @A {
%asm {{
tay
lda sin8._sinecos8+64,y
rts
}}
}
asmsub sin16(ubyte angle @A) -> word @AY {
%asm {{
tay
lda _sinecos8lo,y
pha
lda _sinecos8hi,y
tay
pla
rts
_ := trunc(32767.0 * sin(range(256+64) * rad(360.0/256.0)))
_sinecos8lo .byte <_
_sinecos8hi .byte >_
}}
}
asmsub cos16(ubyte angle @A) -> word @AY {
%asm {{
tay
lda sin16._sinecos8lo+64,y
pha
lda sin16._sinecos8hi+64,y
tay
pla
rts
}}
}
asmsub sin16u(ubyte angle @A) -> uword @AY {
%asm {{
tay
lda _sinecos8ulo,y
pha
lda _sinecos8uhi,y
tay
pla
rts
_ := trunc(32768.0 + 32767.5 * sin(range(256+64) * rad(360.0/256.0)))
_sinecos8ulo .byte <_
_sinecos8uhi .byte >_
}}
}
asmsub cos16u(ubyte angle @A) -> uword @AY {
%asm {{
tay
lda sin16u._sinecos8ulo+64,y
pha
lda sin16u._sinecos8uhi+64,y
tay
pla
rts
}}
}
asmsub sinr8u(ubyte radians @A) clobbers(Y) -> ubyte @A {
%asm {{
tay
lda _sinecosR8u,y
rts
_sinecosR8u .byte trunc(128.0 + 127.5 * sin(range(180+45) * rad(360.0/180.0)))
}}
}
asmsub cosr8u(ubyte radians @A) clobbers(Y) -> ubyte @A {
%asm {{
tay
lda sinr8u._sinecosR8u+45,y
rts
}}
}
asmsub sinr8(ubyte radians @A) clobbers(Y) -> byte @A {
%asm {{
tay
lda _sinecosR8,y
rts
_sinecosR8 .char trunc(127.0 * sin(range(180+45) * rad(360.0/180.0)))
}}
}
asmsub cosr8(ubyte radians @A) clobbers(Y) -> byte @A {
%asm {{
tay
lda sinr8._sinecosR8+45,y
rts
}}
}
asmsub sinr16(ubyte radians @A) -> word @AY {
%asm {{
tay
lda _sinecosR8lo,y
pha
lda _sinecosR8hi,y
tay
pla
rts
_ := trunc(32767.0 * sin(range(180+45) * rad(360.0/180.0)))
_sinecosR8lo .byte <_
_sinecosR8hi .byte >_
}}
}
asmsub cosr16(ubyte radians @A) -> word @AY {
%asm {{
tay
lda sinr16._sinecosR8lo+45,y
pha
lda sinr16._sinecosR8hi+45,y
tay
pla
rts
}}
}
asmsub sinr16u(ubyte radians @A) -> uword @AY {
%asm {{
tay
lda _sinecosR8ulo,y
pha
lda _sinecosR8uhi,y
tay
pla
rts
_ := trunc(32768.0 + 32767.5 * sin(range(180+45) * rad(360.0/180.0)))
_sinecosR8ulo .byte <_
_sinecosR8uhi .byte >_
}}
}
asmsub cosr16u(ubyte radians @A) -> uword @AY {
%asm {{
tay
lda sinr16u._sinecosR8ulo+45,y
pha
lda sinr16u._sinecosR8uhi+45,y
tay
pla
rts
}}
}
}

288
compiler/res/prog8lib/prog8_funcs.asm
View File

@ -84,294 +84,6 @@ func_all_w_stack .proc
rts
.pend
func_sin8_into_A .proc
tay
lda _sinecos8,y
rts
_sinecos8 .char trunc(127.0 * sin(range(256+64) * rad(360.0/256.0)))
.pend
func_sinr8_into_A .proc
tay
lda _sinecosR8,y
rts
_sinecosR8 .char trunc(127.0 * sin(range(180+45) * rad(360.0/180.0)))
.pend
func_sin8u_into_A .proc
tay
lda _sinecos8u,y
rts
_sinecos8u .byte trunc(128.0 + 127.5 * sin(range(256+64) * rad(360.0/256.0)))
.pend
func_sinr8u_into_A .proc
tay
lda _sinecosR8u,y
rts
_sinecosR8u .byte trunc(128.0 + 127.5 * sin(range(180+45) * rad(360.0/180.0)))
.pend
func_sin8_stack .proc
tay
lda func_sin8_into_A._sinecos8,y
sta P8ESTACK_LO,x
dex
rts
.pend
func_sinr8_stack .proc
tay
lda func_sinr8_into_A._sinecosR8,y
sta P8ESTACK_LO,x
dex
rts
.pend
func_sin8u_stack .proc
tay
lda func_sin8u_into_A._sinecos8u,y
sta P8ESTACK_LO,x
dex
rts
.pend
func_sinr8u_stack .proc
tay
lda func_sinr8u_into_A._sinecosR8u,y
sta P8ESTACK_LO,x
dex
rts
.pend
func_cos8_into_A .proc
tay
lda func_sin8_into_A._sinecos8+64,y
rts
.pend
func_cosr8_into_A .proc
tay
lda func_sinr8_into_A._sinecosR8+45,y
rts
.pend
func_cos8u_into_A .proc
tay
lda func_sin8u_into_A._sinecos8u+64,y
rts
.pend
func_cosr8u_into_A .proc
tay
lda func_sinr8u_into_A._sinecosR8u+45,y
rts
.pend
func_cos8_stack .proc
tay
lda func_sin8_into_A._sinecos8+64,y
sta P8ESTACK_LO,x
dex
rts
.pend
func_cosr8_stack .proc
tay
lda func_sinr8_into_A._sinecosR8+45,y
sta P8ESTACK_LO,x
dex
rts
.pend
func_cos8u_stack .proc
tay
lda func_sin8u_into_A._sinecos8u+64,y
sta P8ESTACK_LO,x
dex
rts
.pend
func_cosr8u_stack .proc
tay
lda func_sinr8u_into_A._sinecosR8u+45,y
sta P8ESTACK_LO,x
dex
rts
.pend
func_sin16_into_AY .proc
tay
lda _sinecos8lo,y
pha
lda _sinecos8hi,y
tay
pla
rts
_ := trunc(32767.0 * sin(range(256+64) * rad(360.0/256.0)))
_sinecos8lo .byte <_
_sinecos8hi .byte >_
.pend
func_sinr16_into_AY .proc
tay
lda _sinecosR8lo,y
pha
lda _sinecosR8hi,y
tay
pla
rts
_ := trunc(32767.0 * sin(range(180+45) * rad(360.0/180.0)))
_sinecosR8lo .byte <_
_sinecosR8hi .byte >_
.pend
func_sin16u_into_AY .proc
tay
lda _sinecos8ulo,y
pha
lda _sinecos8uhi,y
tay
pla
rts
_ := trunc(32768.0 + 32767.5 * sin(range(256+64) * rad(360.0/256.0)))
_sinecos8ulo .byte <_
_sinecos8uhi .byte >_
.pend
func_sinr16u_into_AY .proc
tay
lda _sinecosR8ulo,y
pha
lda _sinecosR8uhi,y
tay
pla
rts
_ := trunc(32768.0 + 32767.5 * sin(range(180+45) * rad(360.0/180.0)))
_sinecosR8ulo .byte <_
_sinecosR8uhi .byte >_
.pend
func_sin16_stack .proc
tay
lda func_sin16_into_AY._sinecos8lo,y
sta P8ESTACK_LO,x
lda func_sin16_into_AY._sinecos8hi,y
sta P8ESTACK_HI,x
dex
rts
.pend
func_sinr16_stack .proc
tay
lda func_sinr16_into_AY._sinecosR8lo,y
sta P8ESTACK_LO,x
lda func_sinr16_into_AY._sinecosR8hi,y
sta P8ESTACK_HI,x
dex
rts
.pend
func_sin16u_stack .proc
tay
lda func_sin16u_into_AY._sinecos8ulo,y
sta P8ESTACK_LO,x
lda func_sin16u_into_AY._sinecos8uhi,y
sta P8ESTACK_HI,x
dex
rts
.pend
func_sinr16u_stack .proc
tay
lda func_sinr16u_into_AY._sinecosR8ulo,y
sta P8ESTACK_LO,x
lda func_sinr16u_into_AY._sinecosR8uhi,y
sta P8ESTACK_HI,x
dex
rts
.pend
func_cos16_into_AY .proc
tay
lda func_sin16_into_AY._sinecos8lo+64,y
pha
lda func_sin16_into_AY._sinecos8hi+64,y
tay
pla
rts
.pend
func_cosr16_into_AY .proc
tay
lda func_sinr16_into_AY._sinecosR8lo+45,y
pha
lda func_sinr16_into_AY._sinecosR8hi+45,y
tay
pla
rts
.pend
func_cos16u_into_AY .proc
tay
lda func_sin16u_into_AY._sinecos8ulo+64,y
pha
lda func_sin16u_into_AY._sinecos8uhi+64,y
tay
pla
rts
.pend
func_cosr16u_into_AY .proc
tay
lda func_sinr16u_into_AY._sinecosR8ulo+45,y
pha
lda func_sinr16u_into_AY._sinecosR8uhi+45,y
tay
pla
rts
.pend
func_cos16_stack .proc
tay
lda func_sin16_into_AY._sinecos8lo+64,y
sta P8ESTACK_LO,x
lda func_sin16_into_AY._sinecos8hi+64,y
sta P8ESTACK_HI,x
dex
rts
.pend
func_cosr16_stack .proc
tay
lda func_sinr16_into_AY._sinecosR8lo+45,y
sta P8ESTACK_LO,x
lda func_sinr16_into_AY._sinecosR8hi+45,y
sta P8ESTACK_HI,x
dex
rts
.pend
func_cos16u_stack .proc
tay
lda func_sin16u_into_AY._sinecos8ulo+64,y
sta P8ESTACK_LO,x
lda func_sin16u_into_AY._sinecos8uhi+64,y
sta P8ESTACK_HI,x
dex
rts
.pend
func_cosr16u_stack .proc
tay
lda func_sinr16u_into_AY._sinecosR8ulo+45,y
sta P8ESTACK_LO,x
lda func_sinr16u_into_AY._sinecosR8uhi+45,y
sta P8ESTACK_HI,x
dex
rts
.pend
abs_b_stack .proc
; -- push abs(A) on stack (as byte)
jsr abs_b_into_A

12
compiler/test/TestBuiltinFunctions.kt
View File

@ -10,21 +10,21 @@ import prog8.compiler.BuiltinFunctions
class TestBuiltinFunctions: FunSpec({
test("pure func with fixed type") {
val func = BuiltinFunctions.getValue("sin8u")
func.name shouldBe "sin8u"
val func = BuiltinFunctions.getValue("sgn")
func.name shouldBe "sgn"
func.parameters.size shouldBe 1
func.parameters[0].name shouldBe "angle8"
func.parameters[0].possibleDatatypes shouldBe arrayOf(DataType.UBYTE)
func.parameters[0].name shouldBe "value"
func.parameters[0].possibleDatatypes shouldBe NumericDatatypes
func.pure shouldBe true
func.hasReturn shouldBe true
func.returnType shouldBe DataType.UBYTE
func.returnType shouldBe DataType.BYTE
val conv = func.callConvention(listOf(DataType.UBYTE))
conv.params.size shouldBe 1
conv.params[0].dt shouldBe DataType.UBYTE
conv.params[0].reg shouldBe RegisterOrPair.A
conv.params[0].variable shouldBe false
conv.returns.dt shouldBe DataType.UBYTE
conv.returns.dt shouldBe DataType.BYTE
conv.returns.floatFac1 shouldBe false
conv.returns.reg shouldBe RegisterOrPair.A
}

10
compiler/test/TestOptimization.kt
View File

@ -334,7 +334,7 @@ class TestOptimization: FunSpec({
main {
sub start() {
ubyte r
ubyte @shared bb = (cos8(r)/2 + 100) as ubyte
ubyte @shared bb = (sgn(r)*2 + 100) as ubyte
}
}
"""
@ -343,8 +343,8 @@ class TestOptimization: FunSpec({
ubyte r
r = 0
ubyte bb
prog8_lib.retval_interm_b = cos8(r)
prog8_lib.retval_interm_b >>= 1
prog8_lib.retval_interm_b = sgn(r)
prog8_lib.retval_interm_b <<= 1
prog8_lib.retval_interm_b += 100
bb = prog8_lib.retval_interm_b
return
@ -604,7 +604,7 @@ class TestOptimization: FunSpec({
uword @shared zz
zz += 60 ; NOT ok to remove initializer, should evaluate to 60
ubyte @shared xx
xx = 6+sin8u(xx) ; is not an initializer because it references xx
xx = 6+abs(xx) ; is not an initializer because it references xx
}
}
"""
@ -617,7 +617,7 @@ class TestOptimization: FunSpec({
zz = 60
ubyte xx
xx = 0
xx = sin8u(xx)
xx = abs(xx)
xx += 6
*/
val stmts = result.program.entrypoint.statements

24
compiler/test/TestPipes.kt
View File

@ -267,8 +267,8 @@ class TestPipes: FunSpec({
uword @shared ww = startvalue(99) |> addword()
|> addword()
ubyte @shared cc = 30 |> sin8u() |> cos8u()
cc = cc |> sin8u() |> cos8u()
ubyte @shared cc = 30 |> abs() |> sqrt16()
cc = cc |> abs() |> sqrt16()
}
sub startvalue(ubyte arg) -> uword {
@ -308,9 +308,9 @@ class TestPipes: FunSpec({
value.source shouldBe NumericLiteral(DataType.UBYTE, 30.0, Position.DUMMY)
value.segments.size shouldBe 2
call = value.segments[0] as IFunctionCall
call.target.nameInSource shouldBe listOf("sin8u")
call.target.nameInSource shouldBe listOf("abs")
call = value.segments[1] as IFunctionCall
call.target.nameInSource shouldBe listOf("cos8u")
call.target.nameInSource shouldBe listOf("sqrt16")
assigncc = stmts[6] as Assignment
val pipecc = assigncc.value as PipeExpression
@ -333,8 +333,8 @@ class TestPipes: FunSpec({
uword @shared ww = startvalue(99) |> addword()
|> addword()
ubyte @shared cc = 30 |> sin8u() |> cos8u() ; will be optimized away into a const number
cc = cc |> sin8u() |> cos8u()
ubyte @shared cc = 80 |> abs() |> sqrt16() ; will be optimized away into a const number
cc = cc |> abs() |> sqrt16()
}
sub startvalue(ubyte arg) -> uword {
@ -366,16 +366,16 @@ class TestPipes: FunSpec({
var assigncc = stmts[5] as Assignment
val value = assigncc.value as NumericLiteral
value.number shouldBe 190.0
value.number shouldBe 8.0
assigncc = stmts[6] as Assignment
val pipecc = assigncc.value as PipeExpression
pipecc.source shouldBe instanceOf<BuiltinFunctionCall>()
(pipecc.source as BuiltinFunctionCall).target.nameInSource shouldBe listOf("sin8u")
(pipecc.source as BuiltinFunctionCall).target.nameInSource shouldBe listOf("abs")
pipecc.segments.size shouldBe 1
pipecc.segments[0] shouldBe instanceOf<BuiltinFunctionCall>()
(pipecc.segments[0] as BuiltinFunctionCall).target.nameInSource shouldBe listOf("cos8u")
(pipecc.segments[0] as BuiltinFunctionCall).target.nameInSource shouldBe listOf("sqrt16")
}
test("incorrect type in pipe expression") {
@ -455,7 +455,7 @@ class TestPipes: FunSpec({
uword ww = startvalue() |> addword()
|> addword()
ubyte cc = 30 |> sin8u(99) |> cos8u(22)
ubyte cc = 30 |> abs(99) |> sqrt16(22)
}
sub startvalue(ubyte arg) -> uword {
@ -469,7 +469,7 @@ class TestPipes: FunSpec({
compileText(C64Target(), optimize = false, text, writeAssembly = false, errors=errors) shouldBe null
errors.errors.size shouldBe 3
errors.errors[0] shouldContain ":4:32: invalid number of arguments"
errors.errors[1] shouldContain ":7:44: invalid number of arguments"
errors.errors[2] shouldContain ":7:57: invalid number of arguments"
errors.errors[1] shouldContain ":7:42: invalid number of arguments"
errors.errors[2] shouldContain ":7:56: invalid number of arguments"
}
})

65
compiler/test/arithmetic/builtins.p8
View File

@ -338,71 +338,6 @@ main {
txt.print_b(bb)
txt.nl()
ub = 0
uw = sin16u(ub)
txt.print_uw(uw)
txt.nl()
uw = zero+sin16u(ub)*1+zero
txt.print_uw(uw)
txt.nl()
ub = 0
uw = cos16u(ub)
txt.print_uw(uw)
txt.nl()
uw = zero+cos16u(ub)*1+zero
txt.print_uw(uw)
txt.nl()
ub = 0
ww = sin16(ub)
txt.print_w(ww)
txt.nl()
ww = zero+sin16(ub)*1+zero
txt.print_w(ww)
txt.nl()
ub = 0
ww = cos16(ub)
txt.print_w(ww)
txt.nl()
uw = 0
ww = zero+cos16(ub)*1+zero
txt.print_w(ww)
txt.nl()
ub2 = 0
ub = sin8u(ub2)
txt.print_ub(ub)
txt.nl()
ub = zero+sin8u(ub2)*1+zero
txt.print_ub(ub)
txt.nl()
ub2 = 0
ub = cos8u(ub2)
txt.print_ub(ub)
txt.nl()
ub = zero+cos8u(ub2)*1+zero
txt.print_ub(ub)
txt.nl()
ub2 = 0
bb = sin8(ub2)
txt.print_b(bb)
txt.nl()
bb = zero+sin8(ub2)*1+zero
txt.print_b(bb)
txt.nl()
ub2 = 0
bb = cos8(ub2)
txt.print_b(bb)
txt.nl()
bb = zero+cos8(ub2)*1+zero
txt.print_b(bb)
txt.nl()
bb = -100
bb = abs(bb)
txt.print_b(bb)

2
compiler/test/ast/TestIntermediateAst.kt
View File

@ -22,7 +22,7 @@ class TestIntermediateAst: FunSpec({
ubyte cc
ubyte[] array = [1,2,3]
cc = 11 in array
cc = cc |> sin8u() |> cos8u()
cc = cc |> lsb() |> sqrt16()
}
}
"""

149
compilerAst/src/prog8/compiler/BuiltinFunctions.kt
View File

@ -113,23 +113,7 @@ private val functionSignatures: List<FSignature> = listOf(
// normal functions follow:
FSignature("sgn" , true, listOf(FParam("value", NumericDatatypes)), true, DataType.BYTE, ::builtinSgn ),
FSignature("sin" , true, listOf(FParam("rads", arrayOf(DataType.FLOAT))), true, DataType.FLOAT) { a, p, prg -> oneDoubleArg(a, p, prg, Math::sin) },
FSignature("sin8" , true, listOf(FParam("angle8", arrayOf(DataType.UBYTE))), true, DataType.BYTE, ::builtinSin8 ),
FSignature("sin8u" , true, listOf(FParam("angle8", arrayOf(DataType.UBYTE))), true, DataType.UBYTE, ::builtinSin8u ),
FSignature("sin16" , true, listOf(FParam("angle8", arrayOf(DataType.UBYTE))), true, DataType.WORD, ::builtinSin16 ),
FSignature("sin16u" , true, listOf(FParam("angle8", arrayOf(DataType.UBYTE))), true, DataType.UWORD, ::builtinSin16u ),
FSignature("sinr8" , true, listOf(FParam("angle8", arrayOf(DataType.UBYTE))), true, DataType.BYTE, ::builtinSinR8 ),
FSignature("sinr8u" , true, listOf(FParam("angle8", arrayOf(DataType.UBYTE))), true, DataType.UBYTE, ::builtinSinR8u ),
FSignature("sinr16" , true, listOf(FParam("angle8", arrayOf(DataType.UBYTE))), true, DataType.WORD, ::builtinSinR16 ),
FSignature("sinr16u" , true, listOf(FParam("angle8", arrayOf(DataType.UBYTE))), true, DataType.UWORD, ::builtinSinR16u ),
FSignature("cos" , true, listOf(FParam("rads", arrayOf(DataType.FLOAT))), true, DataType.FLOAT) { a, p, prg -> oneDoubleArg(a, p, prg, Math::cos) },
FSignature("cos8" , true, listOf(FParam("angle8", arrayOf(DataType.UBYTE))), true, DataType.BYTE, ::builtinCos8 ),
FSignature("cos8u" , true, listOf(FParam("angle8", arrayOf(DataType.UBYTE))), true, DataType.UBYTE, ::builtinCos8u ),
FSignature("cos16" , true, listOf(FParam("angle8", arrayOf(DataType.UBYTE))), true, DataType.WORD, ::builtinCos16 ),
FSignature("cos16u" , true, listOf(FParam("angle8", arrayOf(DataType.UBYTE))), true, DataType.UWORD, ::builtinCos16u ),
FSignature("cosr8" , true, listOf(FParam("angle8", arrayOf(DataType.UBYTE))), true, DataType.BYTE, ::builtinCosR8 ),
FSignature("cosr8u" , true, listOf(FParam("angle8", arrayOf(DataType.UBYTE))), true, DataType.UBYTE, ::builtinCosR8u ),
FSignature("cosr16" , true, listOf(FParam("angle8", arrayOf(DataType.UBYTE))), true, DataType.WORD, ::builtinCosR16 ),
FSignature("cosr16u" , true, listOf(FParam("angle8", arrayOf(DataType.UBYTE))), true, DataType.UWORD, ::builtinCosR16u ),
FSignature("tan" , true, listOf(FParam("rads", arrayOf(DataType.FLOAT))), true, DataType.FLOAT) { a, p, prg -> oneDoubleArg(a, p, prg, Math::tan) },
FSignature("atan" , true, listOf(FParam("rads", arrayOf(DataType.FLOAT))), true, DataType.FLOAT) { a, p, prg -> oneDoubleArg(a, p, prg, Math::atan) },
FSignature("ln" , true, listOf(FParam("value", arrayOf(DataType.FLOAT))), true, DataType.FLOAT) { a, p, prg -> oneDoubleArg(a, p, prg, Math::log) },
@ -220,6 +204,8 @@ fun builtinFunctionReturnType(function: String, args: List<Expression>, program:
return InferredTypes.InferredType.void()
// function has return values, but the return type depends on the arguments
if(args.isEmpty())
return InferredTypes.InferredType.unknown()
return when (function) {
"abs" -> {
val dt = args.single().inferType(program)
@ -386,7 +372,6 @@ private fun builtinLen(args: List<Expression>, position: Position, program: Prog
}
}
private fun builtinMkword(args: List<Expression>, position: Position, program: Program): NumericLiteral {
if (args.size != 2)
throw SyntaxError("mkword requires msb and lsb arguments", position)
@ -396,134 +381,6 @@ private fun builtinMkword(args: List<Expression>, position: Position, program: P
return NumericLiteral(DataType.UWORD, result.toDouble(), position)
}
private fun builtinSin8(args: List<Expression>, position: Position, program: Program): NumericLiteral {
if (args.size != 1)
throw SyntaxError("sin8 requires one argument", position)
val constval = args[0].constValue(program) ?: throw NotConstArgumentException()
val rad = constval.number /256.0 * 2.0 * PI
return NumericLiteral(DataType.BYTE, truncate(127.0 * sin(rad)), position)
}
private fun builtinSin8u(args: List<Expression>, position: Position, program: Program): NumericLiteral {
if (args.size != 1)
throw SyntaxError("sin8u requires one argument", position)
val constval = args[0].constValue(program) ?: throw NotConstArgumentException()
val rad = constval.number /256.0 * 2.0 * PI
return NumericLiteral(DataType.UBYTE, truncate(128.0 + 127.5 * sin(rad)), position)
}
private fun builtinSinR8(args: List<Expression>, position: Position, program: Program): NumericLiteral {
if (args.size != 1)
throw SyntaxError("sinr8 requires one argument", position)
val constval = args[0].constValue(program) ?: throw NotConstArgumentException()
val rad = constval.number / 180.0 * 2.0 * PI
return NumericLiteral(DataType.BYTE, truncate(127.0 * sin(rad)), position)
}
private fun builtinSinR8u(args: List<Expression>, position: Position, program: Program): NumericLiteral {
if (args.size != 1)
throw SyntaxError("sinr8u requires one argument", position)
val constval = args[0].constValue(program) ?: throw NotConstArgumentException()
val rad = constval.number / 180.0 * 2.0 * PI
return NumericLiteral(DataType.UBYTE, truncate(128.0 + 127.5 * sin(rad)), position)
}
private fun builtinCos8(args: List<Expression>, position: Position, program: Program): NumericLiteral {
if (args.size != 1)
throw SyntaxError("cos8 requires one argument", position)
val constval = args[0].constValue(program) ?: throw NotConstArgumentException()
val rad = constval.number /256.0 * 2.0 * PI
return NumericLiteral(DataType.BYTE, truncate(127.0 * cos(rad)), position)
}
private fun builtinCos8u(args: List<Expression>, position: Position, program: Program): NumericLiteral {
if (args.size != 1)
throw SyntaxError("cos8u requires one argument", position)
val constval = args[0].constValue(program) ?: throw NotConstArgumentException()
val rad = constval.number /256.0 * 2.0 * PI
return NumericLiteral(DataType.UBYTE, truncate(128.0 + 127.5 * cos(rad)), position)
}
private fun builtinCosR8(args: List<Expression>, position: Position, program: Program): NumericLiteral {
if (args.size != 1)
throw SyntaxError("cosr8 requires one argument", position)
val constval = args[0].constValue(program) ?: throw NotConstArgumentException()
val rad = constval.number / 180.0 * 2.0 * PI
return NumericLiteral(DataType.BYTE, truncate(127.0 * cos(rad)), position)
}
private fun builtinCosR8u(args: List<Expression>, position: Position, program: Program): NumericLiteral {
if (args.size != 1)
throw SyntaxError("cosr8u requires one argument", position)
val constval = args[0].constValue(program) ?: throw NotConstArgumentException()
val rad = constval.number / 180.0 * 2.0 * PI
return NumericLiteral(DataType.UBYTE, truncate(128.0 + 127.5 * cos(rad)), position)
}
private fun builtinSin16(args: List<Expression>, position: Position, program: Program): NumericLiteral {
if (args.size != 1)
throw SyntaxError("sin16 requires one argument", position)
val constval = args[0].constValue(program) ?: throw NotConstArgumentException()
val rad = constval.number /256.0 * 2.0 * PI
return NumericLiteral(DataType.WORD, truncate(32767.0 * sin(rad)), position)
}
private fun builtinSin16u(args: List<Expression>, position: Position, program: Program): NumericLiteral {
if (args.size != 1)
throw SyntaxError("sin16u requires one argument", position)
val constval = args[0].constValue(program) ?: throw NotConstArgumentException()
val rad = constval.number /256.0 * 2.0 * PI
return NumericLiteral(DataType.UWORD, truncate(32768.0 + 32767.5 * sin(rad)), position)
}
private fun builtinSinR16(args: List<Expression>, position: Position, program: Program): NumericLiteral {
if (args.size != 1)
throw SyntaxError("sinr16 requires one argument", position)
val constval = args[0].constValue(program) ?: throw NotConstArgumentException()
val rad = constval.number / 180.0 * 2.0 * PI
return NumericLiteral(DataType.WORD, truncate(32767.0 * sin(rad)), position)
}
private fun builtinSinR16u(args: List<Expression>, position: Position, program: Program): NumericLiteral {
if (args.size != 1)
throw SyntaxError("sinr16u requires one argument", position)
val constval = args[0].constValue(program) ?: throw NotConstArgumentException()
val rad = constval.number / 180.0 * 2.0 * PI
return NumericLiteral(DataType.UWORD, truncate(32768.0 + 32767.5 * sin(rad)), position)
}
private fun builtinCos16(args: List<Expression>, position: Position, program: Program): NumericLiteral {
if (args.size != 1)
throw SyntaxError("cos16 requires one argument", position)
val constval = args[0].constValue(program) ?: throw NotConstArgumentException()
val rad = constval.number /256.0 * 2.0 * PI
return NumericLiteral(DataType.WORD, truncate(32767.0 * cos(rad)), position)
}
private fun builtinCos16u(args: List<Expression>, position: Position, program: Program): NumericLiteral {
if (args.size != 1)
throw SyntaxError("cos16u requires one argument", position)
val constval = args[0].constValue(program) ?: throw NotConstArgumentException()
val rad = constval.number /256.0 * 2.0 * PI
return NumericLiteral(DataType.UWORD, truncate(32768.0 + 32767.5 * cos(rad)), position)
}
private fun builtinCosR16(args: List<Expression>, position: Position, program: Program): NumericLiteral {
if (args.size != 1)
throw SyntaxError("cosr16 requires one argument", position)
val constval = args[0].constValue(program) ?: throw NotConstArgumentException()
val rad = constval.number / 180.0 * 2.0 * PI
return NumericLiteral(DataType.WORD, truncate(32767.0 * cos(rad)), position)
}
private fun builtinCosR16u(args: List<Expression>, position: Position, program: Program): NumericLiteral {
if (args.size != 1)
throw SyntaxError("cosr16u requires one argument", position)
val constval = args[0].constValue(program) ?: throw NotConstArgumentException()
val rad = constval.number / 180.0 * 2.0 * PI
return NumericLiteral(DataType.UWORD, truncate(32768.0 + 32767.5 * cos(rad)), position)
}
private fun builtinSgn(args: List<Expression>, position: Position, program: Program): NumericLiteral {
if (args.size != 1)
throw SyntaxError("sgn requires one argument", position)
@ -531,8 +388,6 @@ private fun builtinSgn(args: List<Expression>, position: Position, program: Prog
return NumericLiteral(DataType.BYTE, constval.number.sign, position)
}
private fun numericLiteral(value: UInt, position: Position): NumericLiteral = numericLiteral(value.toInt(), position)
private fun numericLiteral(value: Number, position: Position): NumericLiteral {
val floatNum=value.toDouble()
val tweakedValue: Number =

64
docs/source/programming.rst
View File

@ -745,35 +745,9 @@ ceil(x)
Rounds the floating point up to an integer towards positive infinity.
cos(x)
Cosine. (floating point version)
cos8u(x)
Fast 8-bit ubyte cosine of angle 0..255, result is in range 0..255
cos8(x)
Fast 8-bit byte cosine of angle 0..255, result is in range -127..127
cos16u(x)
Fast 16-bit uword cosine of angle 0..255, result is in range 0..65535
cos16(x)
Fast 16-bit word cosine of angle 0..255, result is in range -32767..32767
cosr8u(x)
Fast 8-bit ubyte cosine of angle 0..179 (each is a 2 degree step), result is in range 0..255
Angles 180..255 will yield a garbage result!
cosr8(x)
Fast 8-bit byte cosine of angle 0..179 (each is a 2 degree step), result is in range -127..127
Angles 180..255 will yield a garbage result!
cosr16u(x)
Fast 16-bit uword cosine of angle 0..179 (each is a 2 degree step), result is in range 0..65535
Angles 180..255 will yield a garbage result!
cosr16(x)
Fast 16-bit word cosine of angle 0..179 (each is a 2 degree step), result is in range -32767..32767
Angles 180..255 will yield a garbage result!
Cosine. (floating point)
If you want a fast integer cosine, have a look at examples/cx16/sincos.p8
that contains various lookup tables generated by the 64tass assembler.
deg(x)
Radians to degrees.
@ -794,39 +768,13 @@ round(x)
Rounds the floating point to the closest integer.
sin(x)
Sine. (floating point version)
Sine. (floating point)
If you want a fast integer sine, have a look at examples/cx16/sincos.p8
that contains various lookup tables generated by the 64tass assembler.
sgn(x)
Get the sign of the value. Result is -1, 0 or 1 (negative, zero, positive).
sin8u(x)
Fast 8-bit ubyte sine of angle 0..255, result is in range 0..255
sin8(x)
Fast 8-bit byte sine of angle 0..255, result is in range -127..127
sin16u(x)
Fast 16-bit uword sine of angle 0..255, result is in range 0..65535
sin16(x)
Fast 16-bit word sine of angle 0..255, result is in range -32767..32767
sinr8u(x)
Fast 8-bit ubyte sine of angle 0..179 (each is a 2 degree step), result is in range 0..255
Angles 180..255 will yield a garbage result!
sinr8(x)
Fast 8-bit byte sine of angle 0..179 (each is a 2 degree step), result is in range -127..127
Angles 180..255 will yield a garbage result!
sinr16u(x)
Fast 16-bit uword sine of angle 0..179 (each is a 2 degree step), result is in range 0..65535
Angles 180..255 will yield a garbage result!
sinr16(x)
Fast 16-bit word sine of angle 0..179 (each is a 2 degree step), result is in range -32767..32767
Angles 180..255 will yield a garbage result!
sqrt16(w)
16 bit unsigned integer Square root. Result is unsigned byte.
To do the reverse, squaring an integer, just write ``x*x``.

1
docs/source/todo.rst
View File

@ -4,6 +4,7 @@ TODO
For next release
^^^^^^^^^^^^^^^^
- vm: add support for all builtin functions
- can't use abs() etc in pipe expression because return type depends on argument type
- pipe operator: allow non-unary function calls in the pipe that specify the other argument(s) in the calls.
- createAssemblyAndAssemble(): make it possible to actually get rid of the VarDecl nodes by fixing the rest of the code mentioned there.
- allow "xxx" * constexpr (where constexpr is not a number literal), now gives expression error not same type

13
examples/cube3d-gfx.p8
View File

@ -1,5 +1,6 @@
%import syslib
%import graphics
%import math
; Note: this program is compatible with C64 and CX16.
@ -45,12 +46,12 @@ main {
; rotate around origin (0,0,0)
; set up the 3d rotation matrix values
word wcosa = cos8(ax)
word wsina = sin8(ax)
word wcosb = cos8(ay)
word wsinb = sin8(ay)
word wcosc = cos8(az)
word wsinc = sin8(az)
word wcosa = math.cos8(ax)
word wsina = math.sin8(ax)
word wcosb = math.cos8(ay)
word wsinb = math.sin8(ay)
word wcosc = math.cos8(az)
word wsinc = math.sin8(az)
word wcosa_sinb = wcosa*wsinb / 128
word wsina_sinb = wsina*wsinb / 128

13
examples/cube3d-sprites.p8
View File

@ -1,5 +1,6 @@
%import syslib
%import textio
%import math
%import test_stack
@ -105,12 +106,12 @@ main {
; rotate around origin (0,0,0)
; set up the 3d rotation matrix values
word wcosa = cos8(ax)
word wsina = sin8(ax)
word wcosb = cos8(ay)
word wsinb = sin8(ay)
word wcosc = cos8(az)
word wsinc = sin8(az)
word wcosa = math.cos8(ax)
word wsina = math.sin8(ax)
word wcosb = math.cos8(ay)
word wsinb = math.sin8(ay)
word wcosc = math.cos8(az)
word wsinc = math.sin8(az)
word wcosa_sinb = wcosa*wsinb / 128
word wsina_sinb = wsina*wsinb / 128

13
examples/cube3d.p8
View File

@ -1,6 +1,7 @@
%import syslib
%import test_stack
%import textio
%import math
main {
@ -43,12 +44,12 @@ main {
; rotate around origin (0,0,0)
; set up the 3d rotation matrix values
word wcosa = cos8(ax)
word wsina = sin8(ax)
word wcosb = cos8(ay)
word wsinb = sin8(ay)
word wcosc = cos8(az)
word wsinc = sin8(az)
word wcosa = math.cos8(ax)
word wsina = math.sin8(ax)
word wcosb = math.cos8(ay)
word wsinb = math.sin8(ay)
word wcosc = math.cos8(az)
word wsinc = math.sin8(az)
word wcosa_sinb = wcosa*wsinb / 128
word wsina_sinb = wsina*wsinb / 128

5
examples/cx16/bobs.p8
View File

@ -1,6 +1,7 @@
%import palette
%import conv
%import textio
%import math
; "unlimited sprites / bobs" demo effect.
; Note that everything is prog8, no inline assembly used/required.
@ -97,8 +98,8 @@ main {
sub blit(ubyte vmembase) {
ubyte bank = vmembase>=32
uword vmem = vmembase * 2048 ; mkword(vmembase,0) * 8
uword blit_x = (cos8u(msb(anim1)) as uword) + sin8u(msb(anim2))/6
ubyte blit_y = sin8u(msb(anim3))/2 + cos8u(msb(anim4))/5
uword blit_x = (math.cos8u(msb(anim1)) as uword) + math.sin8u(msb(anim2))/6
ubyte blit_y = math.sin8u(msb(anim3))/2 + math.cos8u(msb(anim4))/5
vmem += blit_x/8 + (blit_y as uword) * 40
bitshift(lsb(blit_x) & 7)

13
examples/cx16/cobramk3-gfx.p8
View File

@ -1,6 +1,7 @@
%import syslib
%import test_stack
%import conv
%import math
; TODO add all other Elite's ships, show their name, advance to next ship on keypress
@ -90,12 +91,12 @@ _ones pla
; rotate around origin (0,0,0)
; set up the 3d rotation matrix values
word wcosa = cos8(ax)
word wsina = sin8(ax)
word wcosb = cos8(ay)
word wsinb = sin8(ay)
word wcosc = cos8(az)
word wsinc = sin8(az)
word wcosa = math.cos8(ax)
word wsina = math.sin8(ax)
word wcosb = math.cos8(ay)
word wsinb = math.sin8(ay)
word wcosc = math.cos8(az)
word wsinc = math.sin8(az)
word wcosa_sinb = wcosa*wsinb / 128
word wsina_sinb = wsina*wsinb / 128

13
examples/cx16/cube3d.p8
View File

@ -1,4 +1,5 @@
%import textio
%import math
main {
@ -34,12 +35,12 @@ main {
; rotate around origin (0,0,0)
; set up the 3d rotation matrix values
word wcosa = cos8(ax)
word wsina = sin8(ax)
word wcosb = cos8(ay)
word wsinb = sin8(ay)
word wcosc = cos8(az)
word wsinc = sin8(az)
word wcosa = math.cos8(ax)
word wsina = math.sin8(ax)
word wcosb = math.cos8(ay)
word wsinb = math.sin8(ay)
word wcosc = math.cos8(az)
word wsinc = math.sin8(az)
word wcosa_sinb = wcosa*wsinb / 128
word wsina_sinb = wsina*wsinb / 128

3
examples/cx16/kefrenbars.p8
View File

@ -1,4 +1,5 @@
%import palette
%import math
%option no_sysinit
; Vertical rasterbars a.k.a. "Kefren bars"
@ -59,7 +60,7 @@ irq {
cx16.FB_fill_pixels(320, 1, 0)
} else {
; add new bar
cx16.FB_cursor_position(sin8u(anim1)/2 + cos8u(anim2)/2 + $0010, 0)
cx16.FB_cursor_position(math.sin8u(anim1)/2 + math.cos8u(anim2)/2 + $0010, 0)
cx16.FB_set_pixels(pixels, len(pixels))
}

3
examples/cx16/rasterbars.p8
View File

@ -1,5 +1,6 @@
%import textio
%import palette
%import math
; horizontal raster bars
; also see: kefrenbars.p8
@ -48,7 +49,7 @@ irq {
if color_idx==0 {
yanim++
next_irq_line = $0030 + sin8u(yanim)
next_irq_line = $0030 + math.sin8u(yanim)
} else {
next_irq_line += barheight
}

36
examples/cx16/sincos.p8
View File

@ -1,4 +1,8 @@
%import graphics
%import math
; Draw sine and cosine graphs. The sine and cosine functions are table lookups
; where the tables are generated by 64tass list functions.
; Note: this program is compatible with CX16 only.
; it doesn't work correctly on C64 because the bitmap screen data overlaps
@ -35,16 +39,16 @@ main {
ubyte pixelxb
for pixelxb in 0 to 255 {
pixelyb = cos8u(pixelxb) / 2
pixelyb = math.cos8u(pixelxb) / 2
graphics.plot(pixelxb, pixelyb)
pixelyb = sin8u(pixelxb) / 2
pixelyb = math.sin8u(pixelxb) / 2
graphics.plot(pixelxb, pixelyb)
}
for pixelxb in 0 to 255 {
pixelyw = cos16u(pixelxb) / 1024 + 120
pixelyw = math.cos16u(pixelxb) / 1024 + 120
graphics.plot(pixelxb, pixelyw)
pixelyw = sin16u(pixelxb) / 1024 + 120
pixelyw = math.sin16u(pixelxb) / 1024 + 120
graphics.plot(pixelxb, pixelyw)
}
}
@ -57,16 +61,16 @@ main {
ubyte pixelxb
for pixelxb in 0 to 179 {
pixelyb = cosr8u(pixelxb) / 2
pixelyb = math.cosr8u(pixelxb) / 2
graphics.plot(pixelxb, pixelyb)
pixelyb = sinr8u(pixelxb) / 2
pixelyb = math.sinr8u(pixelxb) / 2
graphics.plot(pixelxb, pixelyb)
}
for pixelxb in 0 to 179 {
pixelyw = cosr16u(pixelxb) / 1024 + 120
pixelyw = math.cosr16u(pixelxb) / 1024 + 120
graphics.plot(pixelxb, pixelyw)
pixelyw = sinr16u(pixelxb) / 1024 + 120
pixelyw = math.sinr16u(pixelxb) / 1024 + 120
graphics.plot(pixelxb, pixelyw)
}
}
@ -78,27 +82,27 @@ main {
; circles with "degrees" from 0 to 255
for r in 0 to 255 {
pixelxw = ((sin8(r)/2 as word) + 80) as uword
pixelyb = (cos8(r)/2 + height/2) as ubyte
pixelxw = ((math.sin8(r)/2 as word) + 80) as uword
pixelyb = (math.cos8(r)/2 + height/2) as ubyte
graphics.plot(pixelxw, pixelyb)
}
for r in 0 to 255 {
pixelxw = (sin16(r)/1024 + 80) as uword
pixelyb = (cos16(r)/1024 + height/2) as ubyte
pixelxw = (math.sin16(r)/1024 + 80) as uword
pixelyb = (math.cos16(r)/1024 + height/2) as ubyte
graphics.plot(pixelxw, pixelyb)
}
; circles with half-degrees from 0 to 179 (=full degrees 0..358 with steps of 2 degrees)
for r in 0 to 179 {
pixelxw = (sinr8(r) as word /2 + 220) as uword
pixelyb = (cosr8(r)/2 + height/2) as ubyte
pixelxw = (math.sinr8(r) as word /2 + 220) as uword
pixelyb = (math.cosr8(r)/2 + height/2) as ubyte
graphics.plot(pixelxw, pixelyb)
}
for r in 0 to 179 {
pixelxw = (sinr16(r) as word /1024 + 220) as uword
pixelyb = (cosr16(r)/1024 + height/2) as ubyte
pixelxw = (math.sinr16(r) as word /1024 + 220) as uword
pixelyb = (math.cosr16(r)/1024 + height/2) as ubyte
graphics.plot(pixelxw, pixelyb)
}

10
examples/cx16/testgfx2.p8
View File

@ -1,6 +1,8 @@
%import gfx2
%import textio
%import test_stack
%import math
main {
@ -170,10 +172,10 @@ main {
ubyte i
for i in 0 to 254 step 4 {
uword x1 = ((gfx2.width-256)/2 as uword) + sin8u(i)
uword y1 = (gfx2.height-128)/2 + cos8u(i)/2
uword x2 = ((gfx2.width-64)/2 as uword) + sin8u(i)/4
uword y2 = (gfx2.height-64)/2 + cos8u(i)/4
uword x1 = ((gfx2.width-256)/2 as uword) + math.sin8u(i)
uword y1 = (gfx2.height-128)/2 + math.cos8u(i)/2
uword x2 = ((gfx2.width-64)/2 as uword) + math.sin8u(i)/4
uword y2 = (gfx2.height-64)/2 + math.cos8u(i)/4
gfx2.line(x1, y1, x2, y2, i+1)
}

9
examples/line-circle-gfx.p8
View File

@ -1,5 +1,6 @@
%import graphics
%import test_stack
%import math
; Note: this program is compatible with C64 and CX16.
@ -38,10 +39,10 @@ main {
sub draw_lines() {
ubyte i
for i in 0 to 255 step 4 {
uword x1 = ((graphics.WIDTH-256)/2 as uword) + sin8u(i)
uword y1 = (graphics.HEIGHT-128)/2 + cos8u(i)/2
uword x2 = ((graphics.WIDTH-64)/2 as uword) + sin8u(i)/4
uword y2 = (graphics.HEIGHT-64)/2 + cos8u(i)/4
uword x1 = ((graphics.WIDTH-256)/2 as uword) + math.sin8u(i)
uword y1 = (graphics.HEIGHT-128)/2 + math.cos8u(i)/2
uword x2 = ((graphics.WIDTH-64)/2 as uword) + math.sin8u(i)/4
uword y2 = (graphics.HEIGHT-64)/2 + math.cos8u(i)/4
graphics.line(x1, lsb(y1), x2, lsb(y2))
}
}

7
examples/plasma.p8
View File

@ -1,6 +1,7 @@
%import syslib
%import test_stack
%import textio
%import math
; converted from plasma test program for cc65.
; which is (w)2001 by groepaz/hitmen
@ -61,14 +62,14 @@ main {
ubyte @zp y
for y in 24 downto 0 {
ybuf[y] = sin8u(c1a) + sin8u(c1b)
ybuf[y] = math.sin8u(c1a) + math.sin8u(c1b)
c1a += 4
c1b += 9
}
c1A += 3
c1B -= 5
for x in 39 downto 0 {
xbuf[x] = sin8u(c2a) + sin8u(c2b)
xbuf[x] = math.sin8u(c2a) + math.sin8u(c2b)
c2a += 3
c2b += 7
}
@ -98,7 +99,7 @@ main {
ubyte[8] bittab = [ $01, $02, $04, $08, $10, $20, $40, $80 ]
ubyte c
for c in 0 to 255 {
ubyte @zp s = sin8u(c)
ubyte @zp s = math.sin8u(c)
ubyte i
for i in 0 to 7 {
ubyte b=0

3
examples/rasterbars.p8
View File

@ -1,4 +1,5 @@
%import syslib
%import math
main {
@ -31,7 +32,7 @@ irq {
c64.EXTCOL = 0
color = 0
yanim += 2
c64.RASTER = sin8u(yanim)/2+30 ; new start of raster Irq
c64.RASTER = math.sin8u(yanim)/2+30 ; new start of raster Irq
}
c64.SCROLY &= $7f ; set high bit of the raster pos to zero
}

5
examples/swirl.p8
View File

@ -1,3 +1,4 @@
%import math
%import textio
%zeropage basicsafe
@ -12,8 +13,8 @@ main {
sub start() {
repeat {
ubyte x = msb(sin8u(msb(anglex)) * screenwidth)
ubyte y = msb(cos8u(msb(angley)) * screenheight)
ubyte x = msb(math.sin8u(msb(anglex)) * screenwidth)
ubyte y = msb(math.cos8u(msb(angley)) * screenheight)
txt.setcc(x, y, 81, color)
anglex+=366
angley+=291

5
examples/wizzine.p8
View File

@ -1,4 +1,5 @@
%import syslib
%import math
%zeropage basicsafe
@ -53,8 +54,8 @@ irq {
ubyte @zp spri
for spri in 7 downto 0 {
c64.EXTCOL++
uword @zp x = sin8u(angle1-spri*16) as uword + 50
ubyte @zp y = sin8u(angle2-spri*16) / 2 + 70
uword @zp x = math.sin8u(angle1-spri*16) as uword + 50
ubyte @zp y = math.sin8u(angle2-spri*16) / 2 + 70
c64.SPXYW[spri] = mkword(y, lsb(x))
c64.MSIGX <<= 1
if msb(x) c64.MSIGX++

4
syntax-files/IDEA/Prog8.xml
View File

@ -14,10 +14,10 @@
<keywords keywords="&amp;;-&gt;;@;\$;and;as;asmsub;break;clobbers;do;downto;else;false;for;goto;if;if_cc;if_cs;if_eq;if_mi;if_ne;if_neg;if_nz;if_pl;if_pos;if_vc;if_vs;if_z;in;inline;not;or;repeat;return;romsub;step;sub;to;true;until;when;while;xor;~" ignore_case="false" />
<keywords2 keywords="%address;%asm;%asmbinary;%asminclude;%breakpoint;%import;%launcher;%option;%output;%zeropage;%zpreserved;iso:;petscii:;sc:" />
<keywords3 keywords="@requirezp;@shared;@zp;byte;const;float;str;ubyte;uword;void;word" />
<keywords4 keywords="abs;acos;all;any;asin;atan;avg;callfar;callrom;ceil;cmp;cos;cos16;cos16u;cos8;cos8u;cosr16;cosr16u;cosr8;cosr8u;deg;floor;len;ln;log2;lsb;max;memory;min;mkword;msb;peek;peekw;poke;pokew;pop;popw;push;pushw;rad;reverse;rnd;rndf;rndw;rol;rol2;ror;ror2;round;rrestore;rrestorex;rsave;rsavex;sgn;sin;sin16;sin16u;sin8;sin8u;sinr16;sinr16u;sinr8;sinr8u;sizeof;sort;sqrt;sqrt16;sum;swap;tan;|&gt;" />
<keywords4 keywords="abs;acos;all;any;asin;atan;avg;callfar;callrom;ceil;cmp;cos;deg;floor;len;ln;log2;lsb;max;memory;min;mkword;msb;peek;peekw;poke;pokew;pop;popw;push;pushw;rad;reverse;rnd;rndf;rndw;rol;rol2;ror;ror2;round;rrestore;rrestorex;rsave;rsavex;sgn;sin;sizeof;sort;sqrt;sqrt16;sum;swap;tan;|&gt;" />
</highlighting>
<extensionMap>
<mapping ext="p8" />
<mapping ext="prog8" />
</extensionMap>
</filetype>
</filetype>

2
syntax-files/NotepadPlusPlus/Prog8.xml
View File

@ -27,7 +27,7 @@
<Keywords name="Keywords1">void const&#x000D;&#x000A;str&#x000D;&#x000A;byte ubyte&#x000D;&#x000A;word uword&#x000D;&#x000A;float&#x000D;&#x000A;zp shared requirezp</Keywords>
<Keywords name="Keywords2">%address&#x000D;&#x000A;%asm&#x000D;&#x000A;%asmbinary&#x000D;&#x000A;%asminclude&#x000D;&#x000A;%breakpoint&#x000D;&#x000A;%import&#x000D;&#x000A;%launcher&#x000D;&#x000A;%option&#x000D;&#x000A;%output&#x000D;&#x000A;%zeropage&#x000D;&#x000A;%zpreserved</Keywords>
<Keywords name="Keywords3">inline sub asmsub romsub&#x000D;&#x000A;clobbers&#x000D;&#x000A;asm&#x000D;&#x000A;if&#x000D;&#x000A;when else&#x000D;&#x000A;if_cc if_cs if_eq if_mi if_neg if_nz if_pl if_pos if_vc if_vs if_z&#x000D;&#x000A;for in step do while repeat&#x000D;&#x000A;break return goto</Keywords>
<Keywords name="Keywords4">abs acos all any asin atan avg callfar callrom ceil cmp cos cos16 cos16u cos8 cos8u cosr8 cosr8u cosr16 cosr16u deg floor len ln log2 lsb lsl lsr max memory min mkword msb peek peekw poke pokew push pushw pop popw rsave rsavex rrestore rrestorex rad reverse rnd rndf rndw rol rol2 ror ror2 round sgn sin sin16 sin16u sin8 sin8u sinr8 sinr8u sinr16 sinr16u sizeof sort sqrt sqrt16 sum swap tan</Keywords>
<Keywords name="Keywords4">abs acos all any asin atan avg callfar callrom ceil cmp cos deg floor len ln log2 lsb lsl lsr max memory min mkword msb peek peekw poke pokew push pushw pop popw rsave rsavex rrestore rrestorex rad reverse rnd rndf rndw rol rol2 ror ror2 round sgn sin sizeof sort sqrt sqrt16 sum swap tan</Keywords>
<Keywords name="Keywords5">true false&#x000D;&#x000A;not and or xor&#x000D;&#x000A;as to downto |&gt;</Keywords>
<Keywords name="Keywords6"></Keywords>
<Keywords name="Keywords7"></Keywords>

4
syntax-files/Vim/prog8_builtins.vim
View File

@ -7,8 +7,8 @@
" Built-in functions
" Math functions
syn keyword prog8BuiltInFunc abs atan ceil cos cos8u cos8 cos16u cos16 cosr8 cosr8u cosr16 cosr16u deg floor
syn keyword prog8BuiltInFunc ln log2 rad round sin sgn sin8u sin8 sin16u sin16 sinr8 sinr8u sinr16 sinr16u
syn keyword prog8BuiltInFunc abs atan ceil cos deg floor
syn keyword prog8BuiltInFunc ln log2 rad round sin sgn
syn keyword prog8BuiltInFunc sqrt16 sqrt tan
" Array functions