p5js emulation and zlib update

.gitignore

@@ -18,7 +18,7 @@ dexport.c
 *.dxe
 jSH-cppcheck-build-dir/
 *.undef
-dexport.c
+src/dexport.c
 capture/
 tmp/
 TEST.DB

3rdparty/curl-7.80.0/packages/DOS/common.dj

@@ -109,7 +109,7 @@ default: all
 #
 WATT32_ROOT  = ../../watt32-2.2dev.rel.11
 OPENSSL_ROOT = ../../openssl-1.1.1n
-ZLIB_ROOT    = ../../zlib-1.2.11
+ZLIB_ROOT    = ../../zlib-1.2.12
 LIBIDN_ROOT  = $(TOPDIR)/../IDN/libidn
 ARES_ROOT    = $(TOPDIR)/ares
 

3rdparty/pctimer/gccint8.c

@@ -0,0 +1,234 @@
+/* PCTIMER 1.4
+   Millisecond Resolution Timing Library for DJGPP V2
+   Release Date: 3/15/1998
+   Chih-Hao Tsai ([email protected])
+ */
+
+#include <dos.h>
+#include <dpmi.h>
+#include <pc.h>
+#include <go32.h>
+#include <bios.h>
+#include <string.h>
+#include "gccint8.h"
+
+#define IRQ0 0x8
+#define PIT0 0x40
+#define PIT1 0x41
+#define PIT2 0x42
+#define PITMODE 0x43
+#define PITCONST 1193180L
+#define PIT0DEF 18.2067597
+#define KBCTRL 0x61
+#define NEW8H 1
+#define TRUE_FAILURE 0
+#define CHAIN_TERMINATION 1
+#define OUTPORTB_TERMINATION 2
+
+static float tick_per_ms = 0.0182068;
+static float ms_per_tick = 54.9246551;
+static float freq8h = 18.2067597;
+static unsigned char flag8h = 0;
+static _go32_dpmi_seginfo rm_old_handler, rm_new_handler, pm_old_handler, pm_new_handler;
+static _go32_dpmi_registers r, r1;
+int counter_8h;
+int counter_reset;
+unsigned long int ticks_8h = 0;
+unsigned char flag_pm_termination = TRUE_FAILURE;
+
+void pctimer_init(unsigned int Hz) {
+    unsigned int pit0_set, pit0_value;
+
+    if (flag8h != NEW8H) {
+        disable();
+
+        lock_rm_new8h();
+        lock_pm_new8h();
+
+        _go32_dpmi_lock_data(&ticks_8h, sizeof(ticks_8h));
+        _go32_dpmi_lock_data(&counter_8h, sizeof(counter_8h));
+        _go32_dpmi_lock_data(&counter_8h, sizeof(counter_reset));
+        _go32_dpmi_lock_data(&flag_pm_termination, sizeof(flag_pm_termination));
+        _go32_dpmi_lock_data(&r, sizeof(r));
+        _go32_dpmi_lock_data(&r1, sizeof(r1));
+
+        _go32_dpmi_get_protected_mode_interrupt_vector(8, &pm_old_handler);
+        pm_new_handler.pm_offset = (int)pm_new8h;
+        pm_new_handler.pm_selector = _go32_my_cs();
+        _go32_dpmi_chain_protected_mode_interrupt_vector(8, &pm_new_handler);
+
+        _go32_dpmi_get_real_mode_interrupt_vector(8, &rm_old_handler);
+        rm_new_handler.pm_offset = (int)rm_new8h;
+        _go32_dpmi_allocate_real_mode_callback_iret(&rm_new_handler, &r1);
+        _go32_dpmi_set_real_mode_interrupt_vector(8, &rm_new_handler);
+
+        outportb(PITMODE, 0x36);
+        pit0_value = PITCONST / Hz;
+        pit0_set = (pit0_value & 0x00ff);
+        outportb(PIT0, pit0_set);
+        pit0_set = (pit0_value >> 8);
+        outportb(PIT0, pit0_set);
+
+        ticks_8h = 0;
+        flag8h = NEW8H;
+        freq8h = Hz;
+        counter_8h = 0;
+        counter_reset = freq8h / PIT0DEF;
+        tick_per_ms = freq8h / 1000;
+        ms_per_tick = 1000 / freq8h;
+
+        enable();
+    }
+}
+
+void pctimer_exit(void) {
+    // unsigned int pit0_set, pit0_value;
+    unsigned long tick;
+    char *cmostime;
+
+    if (flag8h == NEW8H) {
+        disable();
+
+        outportb(PITMODE, 0x36);
+        outportb(PIT0, 0x00);
+        outportb(PIT0, 0x00);
+
+        _go32_dpmi_set_protected_mode_interrupt_vector(8, &pm_old_handler);
+
+        _go32_dpmi_set_real_mode_interrupt_vector(8, &rm_old_handler);
+        _go32_dpmi_free_real_mode_callback(&rm_new_handler);
+
+        enable();
+
+        cmostime = get_cmostime();
+        tick = PIT0DEF * ((((float)*cmostime) * 3600) + (((float)*(cmostime + 1)) * 60) + (((float)*(cmostime + 2))));
+        biostime(1, tick);
+
+        flag8h = 0;
+        freq8h = PIT0DEF;
+        counter_reset = freq8h / PIT0DEF;
+        tick_per_ms = freq8h / 1000;
+        ms_per_tick = 1000 / freq8h;
+    }
+}
+
+void rm_new8h(void) {
+    disable();
+
+    if (flag_pm_termination == TRUE_FAILURE) {
+        ticks_8h++;
+        counter_8h++;
+    }
+
+    if ((counter_8h == counter_reset) || (flag_pm_termination == CHAIN_TERMINATION)) {
+        flag_pm_termination = TRUE_FAILURE;
+        counter_8h = 0;
+        memset(&r, 0, sizeof(r));
+        r.x.cs = rm_old_handler.rm_segment;
+        r.x.ip = rm_old_handler.rm_offset;
+        r.x.ss = r.x.sp = 0;
+        _go32_dpmi_simulate_fcall_iret(&r);
+        enable();
+    } else {
+        flag_pm_termination = TRUE_FAILURE;
+        outportb(0x20, 0x20);
+        enable();
+    }
+}
+
+void lock_rm_new8h(void) { _go32_dpmi_lock_code(rm_new8h, (unsigned long)(lock_rm_new8h - rm_new8h)); }
+
+void pm_new8h(void) {
+    disable();
+
+    ticks_8h++;
+    counter_8h++;
+
+    flag_pm_termination = TRUE_FAILURE;
+
+    if (counter_8h == counter_reset) {
+        flag_pm_termination = CHAIN_TERMINATION;
+        counter_8h = 0;
+        enable();
+    } else {
+        flag_pm_termination = OUTPORTB_TERMINATION;
+        outportb(0x20, 0x20);
+        enable();
+    }
+}
+
+void lock_pm_new8h(void) { _go32_dpmi_lock_code(pm_new8h, (unsigned long)(lock_pm_new8h - pm_new8h)); }
+
+unsigned long pctimer_get_ticks(void) { return ticks_8h; }
+
+unsigned long pctimer_time(unsigned long start, unsigned long finish) {
+    unsigned long duration, millisec;
+
+    if (finish < start)
+        return 0;
+    else {
+        duration = finish - start;
+        millisec = duration * ms_per_tick;
+        return millisec;
+    }
+}
+
+void pctimer_sleep(unsigned int delayms) {
+    unsigned long int delaybegin = 0;
+    unsigned long int delayend = 0;
+    unsigned int delaytick;
+
+    delaytick = delayms * tick_per_ms;
+
+    if (flag8h == NEW8H)
+        delaybegin = pctimer_get_ticks();
+    else
+        delaybegin = biostime(0, 0);
+
+    do {
+        if (flag8h == NEW8H)
+            delayend = pctimer_get_ticks();
+        else
+            delayend = biostime(0, 0);
+    } while ((delayend - delaybegin) < delaytick);
+}
+
+void pctimer_sound(int freq, int duration) {
+    int byte;
+    unsigned int freq1;
+
+    freq1 = PITCONST / freq;
+    outportb(PITMODE, 0xb6);
+    byte = (freq1 & 0xff);
+    outportb(PIT2, byte);
+    byte = (freq1 >> 8);
+    outportb(PIT2, byte);
+    byte = inportb(KBCTRL);
+    outportb(KBCTRL, (byte | 3));
+
+    pctimer_sleep(duration);
+    outportb(KBCTRL, (byte & 0xfc));
+}
+
+char *get_cmostime(void) {
+    char *buff;
+    static char buffer[6];
+    char ch;
+
+    buff = buffer;
+    memset(&r, 0, sizeof(r));
+    r.h.ah = 0x02;
+    _go32_dpmi_simulate_int(0x1a, &r);
+
+    ch = r.h.ch;
+    buffer[0] = (char)((int)(ch & 0x0f) + (int)((ch >> 4) & 0x0f) * 10);
+    ch = r.h.cl;
+    buffer[1] = (char)((int)(ch & 0x0f) + (int)((ch >> 4) & 0x0f) * 10);
+    ch = r.h.dh;
+    buffer[2] = (char)((int)(ch & 0x0f) + (int)((ch >> 4) & 0x0f) * 10);
+    buffer[3] = r.h.dl;
+    buffer[4] = (char)(r.x.flags & 0x0001);
+    buffer[5] = 0x00;
+
+    return (buff);
+}

3rdparty/pctimer/gccint8.h

@@ -0,0 +1,17 @@
+/* PCTIMER 1.4
+   Millisecond Resolution Timing Library for DJGPP V2
+   Release Date: 3/15/1998
+   Chih-Hao Tsai ([email protected])
+ */
+
+void pctimer_init (unsigned int);
+void pctimer_exit (void);
+void rm_new8h (void);
+void lock_rm_new8h (void);
+void pm_new8h (void);
+void lock_pm_new8h (void);
+unsigned long pctimer_get_ticks (void);
+unsigned long pctimer_time (unsigned long, unsigned long);
+void pctimer_sleep (unsigned int);
+void pctimer_sound (int, int);
+char *get_cmostime (void);

3rdparty/pctimer/maketest.bat

@@ -0,0 +1,2 @@
+gcc -o test.exe test.c gccint8.c -lpc
+strip test.exe