From d498d5445c2e90e6649961a2f1a4b5564822e72f Mon Sep 17 00:00:00 2001
From: Irmen de Jong <irmen@razorvine.net>
Date: Mon, 5 Aug 2019 21:01:41 +0200
Subject: [PATCH] added more examples/test programs

---
 examples/arithmetic/bitshift.p8     |  75 +++++++++++++++
 examples/arithmetic/div.p8          | 105 ++++++++++++++++++++
 examples/arithmetic/minus.p8        | 113 ++++++++++++++++++++++
 examples/arithmetic/mult.p8         | 107 +++++++++++++++++++++
 examples/arithmetic/plus.p8         | 111 ++++++++++++++++++++++
 examples/arithmetic/postincrdecr.p8 | 142 ++++++++++++++++++++++++++++
 examples/arithmetic/remainder.p8    |  49 ++++++++++
 7 files changed, 702 insertions(+)
 create mode 100644 examples/arithmetic/bitshift.p8
 create mode 100644 examples/arithmetic/div.p8
 create mode 100644 examples/arithmetic/minus.p8
 create mode 100644 examples/arithmetic/mult.p8
 create mode 100644 examples/arithmetic/plus.p8
 create mode 100644 examples/arithmetic/postincrdecr.p8
 create mode 100644 examples/arithmetic/remainder.p8

diff --git a/examples/arithmetic/bitshift.p8 b/examples/arithmetic/bitshift.p8
new file mode 100644
index 000000000..a505547ba
--- /dev/null
+++ b/examples/arithmetic/bitshift.p8
@@ -0,0 +1,75 @@
+%import c64utils
+%zeropage basicsafe
+
+main {
+
+    byte bb
+    ubyte ub
+    word ww
+    uword uw
+    &ubyte  membyte=9999
+    &uword  memword=9999
+    ubyte[10] barray
+
+    sub start() {
+        lsr(A)
+        lsl(A)
+        ror(A)
+        rol(A)
+        ror2(A)
+        rol2(A)
+        lsr(membyte)
+        lsl(membyte)
+        ror(membyte)
+        rol(membyte)
+        ror2(membyte)
+        rol2(membyte)
+        lsr(memword)
+        lsl(memword)
+        ror(memword)
+        rol(memword)
+        ror2(memword)
+        rol2(memword)
+        lsl(@(9999))
+        lsr(@(9999))
+        ror(@(9999))
+        rol(@(9999))
+        ror2(@(9999))
+        rol2(@(9999))
+        lsr(barray[1])
+        lsl(barray[1])
+        ror(barray[1])
+        rol(barray[1])
+        ror2(barray[1])
+        rol2(barray[1])
+
+
+        bb /= 2
+        bb >>= 1
+        bb *= 4
+        bb <<= 2
+
+        ub /= 2
+        ub >>= 1
+        ub *= 4
+        ub <<= 2
+        rol(ub)
+        ror(ub)
+        rol2(ub)
+        ror2(ub)
+
+        ww /= 2
+        ww >>= 1
+        ww *= 4
+        ww <<= 2
+
+        uw /= 2
+        uw >>= 1
+        uw *= 4
+        uw <<= 2
+        rol(uw)
+        ror(uw)
+        rol2(uw)
+        ror2(uw)
+    }
+}
diff --git a/examples/arithmetic/div.p8 b/examples/arithmetic/div.p8
new file mode 100644
index 000000000..a2d052c59
--- /dev/null
+++ b/examples/arithmetic/div.p8
@@ -0,0 +1,105 @@
+%import c64lib
+%import c64utils
+%import c64flt
+%zeropage basicsafe
+
+main {
+
+    sub start() {
+        div_ubyte(0, 1, 0)
+        div_ubyte(100, 6, 16)
+        div_ubyte(255, 2, 127)
+
+        div_byte(0, 1, 0)
+        div_byte(100, -6, -16)
+        div_byte(127, -2, -63)
+
+        div_uword(0,1,0)
+        div_uword(40000,500,80)
+        div_uword(43211,2,21605)
+
+        div_word(0,1,0)
+        div_word(-20000,500,-40)
+        div_word(-2222,2,-1111)
+
+        div_float(0,1,0)
+        div_float(999.9,111.0,9.008108108108107)
+
+    }
+
+    sub div_ubyte(ubyte a1, ubyte a2, ubyte c) {
+        ubyte r = a1/a2
+        if r==c
+            c64scr.print(" ok  ")
+        else
+            c64scr.print("err! ")
+        c64scr.print("ubyte ")
+        c64scr.print_ub(a1)
+        c64scr.print(" / ")
+        c64scr.print_ub(a2)
+        c64scr.print(" = ")
+        c64scr.print_ub(r)
+        c64.CHROUT('\n')
+    }
+
+    sub div_byte(byte a1, byte a2, byte c) {
+        byte r = a1/a2
+        if r==c
+            c64scr.print(" ok  ")
+        else
+            c64scr.print("err! ")
+        c64scr.print("byte ")
+        c64scr.print_b(a1)
+        c64scr.print(" / ")
+        c64scr.print_b(a2)
+        c64scr.print(" = ")
+        c64scr.print_b(r)
+        c64.CHROUT('\n')
+    }
+
+    sub div_uword(uword a1, uword  a2, uword c) {
+        uword  r = a1/a2
+        if r==c
+            c64scr.print(" ok  ")
+        else
+            c64scr.print("err! ")
+        c64scr.print("uword ")
+        c64scr.print_uw(a1)
+        c64scr.print(" / ")
+        c64scr.print_uw(a2)
+        c64scr.print(" = ")
+        c64scr.print_uw(r)
+        c64.CHROUT('\n')
+    }
+
+    sub div_word(word a1, word a2, word c) {
+        word r = a1/a2
+        if r==c
+            c64scr.print(" ok  ")
+        else
+            c64scr.print("err! ")
+        c64scr.print("word ")
+        c64scr.print_w(a1)
+        c64scr.print(" / ")
+        c64scr.print_w(a2)
+        c64scr.print(" = ")
+        c64scr.print_w(r)
+        c64.CHROUT('\n')
+    }
+
+    sub div_float(float  a1, float a2, float  c) {
+        float r = a1/a2
+        if abs(r-c)<0.00001
+            c64scr.print(" ok  ")
+        else
+            c64scr.print("err! ")
+
+        c64scr.print("float ")
+        c64flt.print_f(a1)
+        c64scr.print(" / ")
+        c64flt.print_f(a2)
+        c64scr.print(" = ")
+        c64flt.print_f(r)
+        c64.CHROUT('\n')
+    }
+}
diff --git a/examples/arithmetic/minus.p8 b/examples/arithmetic/minus.p8
new file mode 100644
index 000000000..ebb85229a
--- /dev/null
+++ b/examples/arithmetic/minus.p8
@@ -0,0 +1,113 @@
+%import c64lib
+%import c64utils
+%import c64flt
+%zeropage basicsafe
+
+main {
+
+    sub start() {
+        minus_ubyte(0, 0, 0)
+        minus_ubyte(200, 0, 200)
+        minus_ubyte(200, 100, 100)
+        minus_ubyte(100, 200, 156)
+
+        minus_byte(0, 0, 0)
+        minus_byte(100, 100, 0)
+        minus_byte(50, -50, 100)
+        minus_byte(0, -30, 30)
+        minus_byte(-30, 0, -30)
+
+        minus_uword(0,0,0)
+        minus_uword(50000,0, 50000)
+        minus_uword(50000,20000,30000)
+        minus_uword(20000,50000,35536)
+
+        minus_word(0,0,0)
+        minus_word(1000,1000,0)
+        minus_word(-1000,1000,-2000)
+        minus_word(1000,500,500)
+        minus_word(0,-3333,3333)
+        minus_word(-3333,0,-3333)
+
+        minus_float(0,0,0)
+        minus_float(2.5,1.5,1.0)
+        minus_float(-1.5,3.5,-5.0)
+
+    }
+
+    sub minus_ubyte(ubyte a1, ubyte a2, ubyte c) {
+        ubyte r = a1-a2
+        if r==c
+            c64scr.print(" ok  ")
+        else
+            c64scr.print("err! ")
+        c64scr.print("ubyte ")
+        c64scr.print_ub(a1)
+        c64scr.print(" - ")
+        c64scr.print_ub(a2)
+        c64scr.print(" = ")
+        c64scr.print_ub(r)
+        c64.CHROUT('\n')
+    }
+
+    sub minus_byte(byte a1, byte a2, byte c) {
+        byte r = a1-a2
+        if r==c
+            c64scr.print(" ok  ")
+        else
+            c64scr.print("err! ")
+        c64scr.print("byte ")
+        c64scr.print_b(a1)
+        c64scr.print(" - ")
+        c64scr.print_b(a2)
+        c64scr.print(" = ")
+        c64scr.print_b(r)
+        c64.CHROUT('\n')
+    }
+
+    sub minus_uword(uword a1, uword  a2, uword c) {
+        uword  r = a1-a2
+        if r==c
+            c64scr.print(" ok  ")
+        else
+            c64scr.print("err! ")
+        c64scr.print("uword ")
+        c64scr.print_uw(a1)
+        c64scr.print(" - ")
+        c64scr.print_uw(a2)
+        c64scr.print(" = ")
+        c64scr.print_uw(r)
+        c64.CHROUT('\n')
+    }
+
+    sub minus_word(word a1, word a2, word c) {
+        word r = a1-a2
+        if r==c
+            c64scr.print(" ok  ")
+        else
+            c64scr.print("err! ")
+        c64scr.print("word ")
+        c64scr.print_w(a1)
+        c64scr.print(" - ")
+        c64scr.print_w(a2)
+        c64scr.print(" = ")
+        c64scr.print_w(r)
+        c64.CHROUT('\n')
+    }
+
+    sub minus_float(float  a1, float a2, float  c) {
+        float r = a1-a2
+        if abs(r-c)<0.00001
+            c64scr.print(" ok  ")
+        else
+            c64scr.print("err! ")
+
+        c64scr.print("float ")
+        c64flt.print_f(a1)
+        c64scr.print(" - ")
+        c64flt.print_f(a2)
+        c64scr.print(" = ")
+        c64flt.print_f(r)
+        c64.CHROUT('\n')
+    }
+}
diff --git a/examples/arithmetic/mult.p8 b/examples/arithmetic/mult.p8
new file mode 100644
index 000000000..50aff68e7
--- /dev/null
+++ b/examples/arithmetic/mult.p8
@@ -0,0 +1,107 @@
+%import c64lib
+%import c64utils
+%import c64flt
+%zeropage basicsafe
+
+main {
+
+    sub start() {
+        mul_ubyte(0, 0, 0)
+        mul_ubyte(20, 1, 20)
+        mul_ubyte(20, 10, 200)
+
+        mul_byte(0, 0, 0)
+        mul_byte(10, 10, 100)
+        mul_byte(5, -5, -25)
+        mul_byte(0, -30, 0)
+
+        mul_uword(0,0,0)
+        mul_uword(50000,1, 50000)
+        mul_uword(500,100,50000)
+
+        mul_word(0,0,0)
+        mul_word(-10,1000,-10000)
+        mul_word(1,-3333,-3333)
+
+        mul_float(0,0,0)
+        mul_float(2.5,10,25)
+        mul_float(-1.5,10,-15)
+
+    }
+
+    sub mul_ubyte(ubyte a1, ubyte a2, ubyte c) {
+        ubyte r = a1*a2
+        if r==c
+            c64scr.print(" ok  ")
+        else
+            c64scr.print("err! ")
+        c64scr.print("ubyte ")
+        c64scr.print_ub(a1)
+        c64scr.print(" * ")
+        c64scr.print_ub(a2)
+        c64scr.print(" = ")
+        c64scr.print_ub(r)
+        c64.CHROUT('\n')
+    }
+
+    sub mul_byte(byte a1, byte a2, byte c) {
+        byte r = a1*a2
+        if r==c
+            c64scr.print(" ok  ")
+        else
+            c64scr.print("err! ")
+        c64scr.print("byte ")
+        c64scr.print_b(a1)
+        c64scr.print(" * ")
+        c64scr.print_b(a2)
+        c64scr.print(" = ")
+        c64scr.print_b(r)
+        c64.CHROUT('\n')
+    }
+
+    sub mul_uword(uword a1, uword  a2, uword c) {
+        uword  r = a1*a2
+        if r==c
+            c64scr.print(" ok  ")
+        else
+            c64scr.print("err! ")
+        c64scr.print("uword ")
+        c64scr.print_uw(a1)
+        c64scr.print(" * ")
+        c64scr.print_uw(a2)
+        c64scr.print(" = ")
+        c64scr.print_uw(r)
+        c64.CHROUT('\n')
+    }
+
+    sub mul_word(word a1, word a2, word c) {
+        word r = a1*a2
+        if r==c
+            c64scr.print(" ok  ")
+        else
+            c64scr.print("err! ")
+        c64scr.print("word ")
+        c64scr.print_w(a1)
+        c64scr.print(" * ")
+        c64scr.print_w(a2)
+        c64scr.print(" = ")
+        c64scr.print_w(r)
+        c64.CHROUT('\n')
+    }
+
+    sub mul_float(float  a1, float a2, float  c) {
+        float r = a1*a2
+        if abs(r-c)<0.00001
+            c64scr.print(" ok  ")
+        else
+            c64scr.print("err! ")
+
+        c64scr.print("float ")
+        c64flt.print_f(a1)
+        c64scr.print(" * ")
+        c64flt.print_f(a2)
+        c64scr.print(" = ")
+        c64flt.print_f(r)
+        c64.CHROUT('\n')
+    }
+}
diff --git a/examples/arithmetic/plus.p8 b/examples/arithmetic/plus.p8
new file mode 100644
index 000000000..f57f4fa56
--- /dev/null
+++ b/examples/arithmetic/plus.p8
@@ -0,0 +1,111 @@
+%import c64lib
+%import c64utils
+%import c64flt
+%zeropage basicsafe
+
+main {
+
+    sub start() {
+        plus_ubyte(0, 0, 0)
+        plus_ubyte(0, 200, 200)
+        plus_ubyte(100, 200, 44)
+
+        plus_byte(0, 0, 0)
+        plus_byte(-100, 100, 0)
+        plus_byte(-50, 100, 50)
+        plus_byte(0, -30, -30)
+        plus_byte(-30, 0, -30)
+
+        plus_uword(0,0,0)
+        plus_uword(0,50000,50000)
+        plus_uword(50000,20000,4464)
+
+        plus_word(0,0,0)
+        plus_word(-1000,1000,0)
+        plus_word(-500,1000,500)
+        plus_word(0,-3333,-3333)
+        plus_word(-3333,0,-3333)
+
+        plus_float(0,0,0)
+        plus_float(1.5,2.5,4.0)
+        plus_float(-1.5,3.5,2.0)
+        plus_float(-1.1,3.3,2.2)
+
+    }
+
+    sub plus_ubyte(ubyte a1, ubyte a2, ubyte c) {
+        ubyte r = a1+a2
+        if r==c
+            c64scr.print(" ok  ")
+        else
+            c64scr.print("err! ")
+        c64scr.print("ubyte ")
+        c64scr.print_ub(a1)
+        c64scr.print(" + ")
+        c64scr.print_ub(a2)
+        c64scr.print(" = ")
+        c64scr.print_ub(r)
+        c64.CHROUT('\n')
+    }
+
+    sub plus_byte(byte a1, byte a2, byte c) {
+        byte r = a1+a2
+        if r==c
+            c64scr.print(" ok  ")
+        else
+            c64scr.print("err! ")
+        c64scr.print("byte ")
+        c64scr.print_b(a1)
+        c64scr.print(" + ")
+        c64scr.print_b(a2)
+        c64scr.print(" = ")
+        c64scr.print_b(r)
+        c64.CHROUT('\n')
+    }
+
+    sub plus_uword(uword a1, uword  a2, uword c) {
+        uword  r = a1+a2
+        if r==c
+            c64scr.print(" ok  ")
+        else
+            c64scr.print("err! ")
+        c64scr.print("uword ")
+        c64scr.print_uw(a1)
+        c64scr.print(" + ")
+        c64scr.print_uw(a2)
+        c64scr.print(" = ")
+        c64scr.print_uw(r)
+        c64.CHROUT('\n')
+    }
+
+    sub plus_word(word a1, word a2, word c) {
+        word r = a1+a2
+        if r==c
+            c64scr.print(" ok  ")
+        else
+            c64scr.print("err! ")
+        c64scr.print("word ")
+        c64scr.print_w(a1)
+        c64scr.print(" + ")
+        c64scr.print_w(a2)
+        c64scr.print(" = ")
+        c64scr.print_w(r)
+        c64.CHROUT('\n')
+    }
+
+    sub plus_float(float  a1, float a2, float  c) {
+        float r = a1+a2
+        if abs(r-c)<0.00001
+            c64scr.print(" ok  ")
+        else
+            c64scr.print("err! ")
+
+        c64scr.print("float ")
+        c64flt.print_f(a1)
+        c64scr.print(" + ")
+        c64flt.print_f(a2)
+        c64scr.print(" = ")
+        c64flt.print_f(r)
+        c64.CHROUT('\n')
+    }
+}
diff --git a/examples/arithmetic/postincrdecr.p8 b/examples/arithmetic/postincrdecr.p8
new file mode 100644
index 000000000..01191bbb5
--- /dev/null
+++ b/examples/arithmetic/postincrdecr.p8
@@ -0,0 +1,142 @@
+%import c64utils
+%import c64flt
+%option enable_floats
+%zeropage basicsafe
+
+main {
+
+
+    sub start()  {
+
+        c64scr.plot(0,24)
+
+        ubyte ub=200
+        byte bb=-100
+        uword uw = 2000
+        word ww = -1000
+        float fl = 999.99
+        ubyte[3] ubarr = 200
+        byte[3] barr = -100
+        uword[3] uwarr = 2000
+        word[3] warr = -1000
+        float[3] flarr = 999.99
+
+        c64scr.print("++\n")
+        ub++
+        bb++
+        uw++
+        ww++
+        fl++
+        ubarr[1]++
+        barr[1]++
+        uwarr[1]++
+        warr[1]++
+        flarr[1] ++
+
+        check_ub(ub, 201)
+        Y=100
+        Y++
+        check_ub(Y, 101)
+        check_fl(fl, 1000.99)
+        check_b(bb, -99)
+        check_uw(uw, 2001)
+        check_w(ww, -999)
+        check_ub(ubarr[0], 200)
+        check_fl(flarr[0], 999.99)
+        check_b(barr[0], -100)
+        check_uw(uwarr[0], 2000)
+        check_w(warr[0], -1000)
+        check_ub(ubarr[1], 201)
+        check_fl(flarr[1], 1000.99)
+        check_b(barr[1], -99)
+        check_uw(uwarr[1], 2001)
+        check_w(warr[1], -999)
+
+        c64scr.print("--\n")
+        ub--
+        bb--
+        uw--
+        ww--
+        fl--
+        ubarr[1]--
+        barr[1]--
+        uwarr[1]--
+        warr[1]--
+        flarr[1] --
+        check_ub(ub, 200)
+        Y=100
+        Y--
+        check_ub(Y, 99)
+        check_fl(fl, 999.99)
+        check_b(bb, -100)
+        check_uw(uw, 2000)
+        check_w(ww, -1000)
+        check_ub(ubarr[1], 200)
+        check_fl(flarr[1], 999.99)
+        check_b(barr[1], -100)
+        check_uw(uwarr[1], 2000)
+        check_w(warr[1], -1000)
+
+        @($0400+400-1) = X
+    }
+
+    sub check_ub(ubyte value, ubyte expected) {
+        if value==expected
+            c64scr.print(" ok  ")
+        else
+            c64scr.print("err! ")
+        c64scr.print(" ubyte ")
+        c64scr.print_ub(value)
+        c64.CHROUT(',')
+        c64scr.print_ub(expected)
+        c64.CHROUT('\n')
+    }
+
+    sub check_b(byte value, byte expected) {
+        if value==expected
+            c64scr.print(" ok  ")
+        else
+            c64scr.print("err! ")
+        c64scr.print(" byte ")
+        c64scr.print_b(value)
+        c64.CHROUT(',')
+        c64scr.print_b(expected)
+        c64.CHROUT('\n')
+    }
+
+    sub check_uw(uword value, uword expected) {
+        if value==expected
+            c64scr.print(" ok  ")
+        else
+            c64scr.print("err! ")
+        c64scr.print(" uword ")
+        c64scr.print_uw(value)
+        c64.CHROUT(',')
+        c64scr.print_uw(expected)
+        c64.CHROUT('\n')
+    }
+
+    sub check_w(word value, word expected) {
+        if value==expected
+            c64scr.print(" ok  ")
+        else
+            c64scr.print("err! ")
+        c64scr.print(" word ")
+        c64scr.print_w(value)
+        c64.CHROUT(',')
+        c64scr.print_w(expected)
+        c64.CHROUT('\n')
+    }
+
+    sub check_fl(float value, float expected) {
+        if value==expected
+            c64scr.print(" ok  ")
+        else
+            c64scr.print("err! ")
+        c64scr.print(" float ")
+        c64flt.print_f(value)
+        c64.CHROUT(',')
+        c64flt.print_f(expected)
+        c64.CHROUT('\n')
+    }
+}
diff --git a/examples/arithmetic/remainder.p8 b/examples/arithmetic/remainder.p8
new file mode 100644
index 000000000..77a6f4dda
--- /dev/null
+++ b/examples/arithmetic/remainder.p8
@@ -0,0 +1,49 @@
+%import c64lib
+%import c64utils
+%import c64flt
+%zeropage basicsafe
+
+main {
+
+    sub start() {
+        remainder_ubyte(0, 1, 0)
+        remainder_ubyte(100, 6, 4)
+        remainder_ubyte(255, 2, 1)
+        remainder_ubyte(255, 20, 15)
+
+        remainder_uword(0,1,0)
+        remainder_uword(40000,511,142)
+        remainder_uword(40000,500,0)
+        remainder_uword(43211,12,11)
+    }
+
+    sub remainder_ubyte(ubyte a1, ubyte a2, ubyte c) {
+        ubyte r = a1%a2
+        if r==c
+            c64scr.print(" ok  ")
+        else
+            c64scr.print("err! ")
+        c64scr.print("ubyte ")
+        c64scr.print_ub(a1)
+        c64scr.print(" % ")
+        c64scr.print_ub(a2)
+        c64scr.print(" = ")
+        c64scr.print_ub(r)
+        c64.CHROUT('\n')
+    }
+
+    sub remainder_uword(uword a1, uword  a2, uword c) {
+        uword  r = a1%a2
+        if r==c
+            c64scr.print(" ok  ")
+        else
+            c64scr.print("err! ")
+        c64scr.print("uword ")
+        c64scr.print_uw(a1)
+        c64scr.print(" % ")
+        c64scr.print_uw(a2)
+        c64scr.print(" = ")
+        c64scr.print_uw(r)
+        c64.CHROUT('\n')
+    }
+}