Fix nullary function declarations

Reviewed-on: #1

core/cpu.c

@@ -234,7 +234,7 @@ static int cpuOnExecute(VB *sim) {
     #define VB_ON_READ VB_DIRECT_READ
 #endif
 static int cpuRead(VB *sim, uint32_t address, int type, int32_t *value) {
-    uint32_t cycles = 4; /* TODO: Research this */
+    uint32_t cycles = 0; /* TODO: Research this */
 
     /* Retrieve the value from the simulation state directly */
     busRead(sim, address, type, value);
@@ -289,7 +289,7 @@ static int cpuReadFetch(VB *sim, int fetch, uint32_t address, int32_t *value) {
 #endif
 static int cpuWrite(VB *sim, uint32_t address, int type, int32_t value) {
     int      cancel = 0;
-    uint32_t cycles = 3; /* TODO: Research this */
+    uint32_t cycles = 0; /* TODO: Research this */
 
     /* Reset pseudo-halt */
     if (sim->ph.enabled)
@@ -495,7 +495,7 @@ static int cpuException(VB *sim) {
         sim->cpu.eipc     = sim->cpu.pc;
         sim->cpu.psw.ep   = 1;
         sim->cpu.nextPC   = 0xFFFF0000 |
-            ((cause & 0xFFF0) == 0xFF60 ? 0xFF60 : cause & 0xFFF0);
+            ((cause & 0xFFF0) == 0xFF70 ? 0xFF60 : cause & 0xFFF0);
     }
 
     /* All exceptions */

core/vb.c

@@ -361,6 +361,7 @@ struct VB {
 
             /* Other state */
             uint32_t clocks;   /* Clocks until modification */
+            uint8_t  freqmask; /* Frequency mask */
             uint8_t  modmask;  /* Modifications masked */
             uint16_t next;     /* Next frequency value */
             int      sample;   /* Current sample index */
@@ -899,7 +900,7 @@ VBAPI vbOnWrite vbSetWriteCallback(VB *sim, vbOnWrite callback) {
 }
 
 /* Determine the size of a simulation instance */
-VBAPI size_t vbSizeOf() {
+VBAPI size_t vbSizeOf(void) {
     return sizeof (VB);
 }
 

core/vb.h

@@ -166,7 +166,7 @@ VBAPI vbOnSamples   vbSetSamplesCallback  (VB *sim, vbOnSamples callback);
 VBAPI uint32_t      vbSetSystemRegister   (VB *sim, unsigned index, uint32_t value);
 VBAPI void*         vbSetUserData         (VB *sim, void *tag);
 VBAPI vbOnWrite     vbSetWriteCallback    (VB *sim, vbOnWrite callback);
-VBAPI size_t        vbSizeOf              ();
+VBAPI size_t        vbSizeOf              (void);
 VBAPI int32_t       vbWrite               (VB *sim, uint32_t address, int type, int32_t value);
 
 

core/vip.c

@@ -436,6 +436,9 @@ static void vipWriteIO(
 
         case 0x5F802>>1: /* INTENB */
             sim->vip.intenb = (sim->vip.intenb & mask) | (value & 0xE01F);
+            if (sim->vip.intenb & sim->vip.intpnd)
+                sim->cpu.irq  |=  0x0010;
+            else sim->cpu.irq &= ~0x0010;
             break;
         case 0x5F804>>1: /* INTCLR */
             sim->vip.intpnd &= ~value;
@@ -981,7 +984,7 @@ static void vipDrawHBias(VB *sim, World *world) {
         /* Process all visible lines */
         param = &sim->vip.ram[world->paramBase +
             ((y1 - world->gy) << 2) + (i << 1)];
-        for (y = y1; y < y2; y++, param += 2) {
+        for (y = y1; y < y2; y++, param += 4) {
 
             /* Configure window bounds */
             wnd.y1 = y;
@@ -989,7 +992,7 @@ static void vipDrawHBias(VB *sim, World *world) {
 
             /* Draw the background into the window */
             vipDrawBackground(sim->vip.shadow[i], &wnd, world,
-                mx + busReadBuffer(param, VB_S16), my);
+                mx - busReadBuffer(param, VB_S16), my);
         }
 
     }

core/vsu.c

@@ -82,12 +82,12 @@ static void vsuNextFreqMod(VB *sim, Channel *chan) {
 
     /* Modulation */
     else {
-        next = (int32_t) chan->freq.written +
-            sim->vsu.modulation[sim->vsu.freqmod.sample];
-        if (next < 0)
-            next = 0;
-        if (next > 2047)
-            next = 2047;
+        next = ((int32_t) chan->freq.written +
+            sim->vsu.modulation[sim->vsu.freqmod.sample]) & 0x7FF;
+        if (sim->vsu.freqmod.freqmask == 1)
+            next = (next & 0x700) | (chan->freq.written & 0x0FF);
+        else if (sim->vsu.freqmod.freqmask == 2)
+            next = (next & 0x0FF) | (chan->freq.written & 0x700);
     }
 
     /* Configure state */
@@ -132,14 +132,19 @@ static void vsuEmulateChannel(VB *sim, Channel *chan) {
     }
 
     /* Envelope modification */
-    if (chan->env.enb && !chan->env.modmask && chan->env.clocks == 0) {
+    if (chan->env.clocks == 0) {
+        uint8_t new_envelope = chan->env.value;
         if (chan->env.dir == 0 && chan->env.value != 0)
-            chan->env.value--;
+            new_envelope--;
         else if (chan->env.dir == 1 && chan->env.value != 15)
-            chan->env.value++;
-        else if (chan->env.rep)
-            chan->env.value = chan->env.reload;
-        else chan->env.modmask = 1;
+            new_envelope++;
+        else if (chan->env.rep && chan->env.modmask != 2) {
+            new_envelope = chan->env.reload;
+            chan->env.modmask = 0;
+        } else if (!chan->env.modmask)
+            chan->env.modmask = 1;
+        if (chan->env.enb && !chan->env.modmask)
+            chan->env.value = new_envelope;
         chan->env.clocks = ((uint32_t) chan->env.interval + 1) * 307220;
     }
 
@@ -215,6 +220,7 @@ static void vsuWriteEV0(VB *sim, int index, uint8_t value) {
     chan->env.interval = value      &  7;
     chan->env.value    = value >> 4 & 15;
     chan->env.reload   = chan->env.value;
+    if (chan->env.modmask == 1) chan->env.modmask = 2;
     if (index == 4) {
         chan->freqmod = vsuCheckFreqMod(sim);
         vsuNextFreqMod(sim, chan);
@@ -231,6 +237,12 @@ static void vsuWriteEV1(VB *sim, int index, uint8_t value) {
     /* Parse fields */
     chan->env.enb = value      & 1;
     chan->env.rep = value >> 1 & 1;
+    if (
+        !chan->env.rep && (
+            (chan->env.reload ==  0 && chan->env.dir == 0) ||
+            (chan->env.reload == 15 && chan->env.dir == 1)
+        )
+    ) chan->env.modmask = 1;
 
     /* Processing by channel */
     switch (index) {
@@ -257,7 +269,9 @@ static void vsuWriteFQH(VB *sim, int index, uint16_t value) {
     value = value << 8 & 0x0700;
     chan->freq.current = (chan->freq.current & 0x00FF) | value;
     chan->freq.written = (chan->freq.written & 0x00FF) | value;
-    if (index == 4)
+    if (index != 4)
+        return;
+    sim->vsu.freqmod.freqmask = 2;
     vsuNextFreqMod(sim, chan);
 }
 
@@ -266,7 +280,9 @@ static void vsuWriteFQL(VB *sim, int index, uint8_t value) {
     Channel *chan = &sim->vsu.channels[index];
     chan->freq.current = (chan->freq.current & 0x0700) | value;
     chan->freq.written = (chan->freq.written & 0x0700) | value;
-    if (index == 4)
+    if (index != 4)
+        return;
+    sim->vsu.freqmod.freqmask = 1;
     vsuNextFreqMod(sim, chan);
 }
 
@@ -282,7 +298,12 @@ static void vsuWriteINT(VB *sim, int index, uint8_t value) {
     /* Update state */
     chan->int_.clocks = 76805 * ((uint32_t) chan->int_.interval + 1);
     chan->env.modmask = 0;
-    if (chan->env.enb)
+    if (
+        !chan->env.rep && (
+            (chan->env.reload ==  0 && chan->env.dir == 0) ||
+            (chan->env.reload == 15 && chan->env.dir == 1)
+        )
+    ) chan->env.modmask = 1;
     chan->env.clocks = 307220 * ((uint32_t) chan->env.interval + 1);
     if (index != 5) {
         chan->wave.sample = 0;
@@ -373,7 +394,7 @@ static void vsuEmulate(VB *sim, uint32_t clocks) {
 
                     /* Clocks until next state change */
                     chan->until = chan->clocks;
-                    if (chan->env.enb && !chan->env.modmask &&
+                    if (chan->env.enb && chan->env.modmask != 2 &&
                         chan->env.clocks < chan->until)
                         chan->until = chan->env.clocks;
                     if (chan->int_.auto_ && chan->int_.clocks < chan->until)
@@ -383,7 +404,7 @@ static void vsuEmulate(VB *sim, uint32_t clocks) {
 
                     /* Manage clocks */
                     chan->clocks -= chan->until;
-                    if (chan->env.enb && !chan->env.modmask)
+                    if (chan->env.enb && chan->env.modmask != 2)
                         chan->env.clocks -= chan->until;
                     if (chan->int_.auto_)
                         chan->int_.clocks -= chan->until;
@@ -507,6 +528,7 @@ static void vsuReset(VB *sim) {
     sim->vsu.freqmod.clocks   = 0;
     sim->vsu.freqmod.dir      = 0;
     sim->vsu.freqmod.enb      = 0;
+    sim->vsu.freqmod.freqmask = 0;
     sim->vsu.freqmod.func     = 0;
     sim->vsu.freqmod.interval = 0;
     sim->vsu.freqmod.modmask  = 0;
@@ -526,21 +548,17 @@ static void vsuReset(VB *sim) {
 
 /* Write a typed value to the VSU bus */
 static void vsuWrite(VB*sim,uint32_t address,int type,int32_t value,int debug){
-
-    /* Only byte writes are allowed */
-    switch (type) {
-        case VB_S16:
-        case VB_U16:
-        case VB_S32:
-            return;
-    }
+    (void) type;
 
     /* Unmapped */
-    if (address & 3)
+    if (address & 1)
         return;
 
     /* Working variables */
-    address &= 0x7FF;
+    address &= 0x7FC;
+
+    /* Clear frequency mask */
+    sim->vsu.freqmod.freqmask = 0;
 
     /* Wave memory */
     if (address < 0x280) {

web/Core.js

@@ -293,6 +293,12 @@ new class Core {
         }, [ output.buffer ]);
     }
 
+    // Reset simulation state
+    reset(message) {
+        this.vbReset(message.sim);
+        this.dom.postMessage({ promised: true });
+    }
+
     // Specify anaglyph colors
     setAnaglyph(message) {
         this.SetAnaglyph(message.sim, message.left, message.right);

web/VB.js

@@ -436,8 +436,17 @@ class Sim extends HTMLElement {
             response.lines.map(l=>new DasmLine(GUARD, l));
     }
 
+    // Reset simulation state
+    reset() {
+        return this.#core.toCore({
+            command : "reset",
+            promised: true,
+            sim     : this.#pointer
+        });
+    }
+
     // Specify anaglyph colors
-    async setAnaglyph(left, right) {
+    setAnaglyph(left, right) {
 
         // Error checking
         if (!Number.isSafeInteger(left ) || left  < 0 || left  > 0xFFFFFF)
@@ -455,7 +464,7 @@ class Sim extends HTMLElement {
         this.#anaglyph[1] = right;
 
         // Send the colors to the core
-        await this.#core.toCore({
+        return this.#core.toCore({
             command : "setAnaglyph",
             promised: true,
             sim     : this.#pointer,
@@ -475,7 +484,7 @@ class Sim extends HTMLElement {
     }
 
     // Specify new game pad keys
-    async setKeys(keys) {
+    setKeys(keys) {
 
         // Error checking
         if (!Number.isSafeInteger(keys) || keys < 0 || keys > 0xFFFF)
@@ -487,7 +496,7 @@ class Sim extends HTMLElement {
         this.#keys = keys;
 
         // Send the keys to the core
-        await this.#core.toCore({
+        return this.#core.toCore({
             command : "setKeys",
             promised: true,
             sim     : this.#pointer,
@@ -496,7 +505,7 @@ class Sim extends HTMLElement {
     }
 
     // Specify audio panning
-    async setPanning(panning) {
+    setPanning(panning) {
 
         // Error checking
         if (!Number.isFinite(panning) ||panning < -1 || panning > +1) {
@@ -508,7 +517,7 @@ class Sim extends HTMLElement {
         this.#panning = panning;
 
         // Send the panning to the core
-        await this.#core.toCore({
+        return this.#core.toCore({
             command : "setPanning",
             promised: true,
             sim     : this.#pointer,
@@ -529,7 +538,7 @@ class Sim extends HTMLElement {
     }
 
     // Specify audio volume
-    async setVolume(volume) {
+    setVolume(volume) {
 
         // Error checking
         if (!Number.isFinite(volume) ||volume < 0 || volume > 10) {
@@ -541,7 +550,7 @@ class Sim extends HTMLElement {
         this.#volume = volume;
 
         // Send the volume to the core
-        await this.#core.toCore({
+        return this.#core.toCore({
             command : "setVolume",
             promised: true,
             sim     : this.#pointer,
@@ -596,7 +605,7 @@ class VB {
     #commands;  // Computed method table
     #core;      // Core worker
     #proxy;     // Self proxy for sim access
-    #sims;      // All sims
+    #sims;      // Mapping of Sim|pointer -> proxy
     #state;     // Operations state
 
 
@@ -683,8 +692,8 @@ class VB {
     ///////////////////////////// Static Methods //////////////////////////////
 
     // Create a core instance
-    static async create(options) {
-        return await new VB(GUARD).#construct(options);
+    static create(options) {
+        return new VB(GUARD).#construct(options);
     }
 
 
@@ -769,6 +778,16 @@ class VB {
 
 
 
+    /////////////////////////////// Properties ////////////////////////////////
+
+    // Number of managed simulations
+    get size() { return this.#sims.size / 2; }
+
+    // Managed simulations
+    get sims() { return [... this.#sims.keys()].filter(s=>s instanceof Sim); }
+
+
+
     ///////////////////////////// Public Methods //////////////////////////////
 
     // Create one or more sims
@@ -809,7 +828,7 @@ class VB {
         if (
             !Array.isArray(sims) ||
             sims.length == 0     ||
-            sims.find(s=>!this.#sims.has(s))
+            sims.some(s=>!this.#sims.has(s))
         ) {
             throw new TypeError("Must specify a Sim or array of Sims " +
                 "that belong to this core.");