X-Git-Url: https://git.kengrimes.com/?p=watForth.git;a=blobdiff_plain;f=forth.js;h=d3a2f833b2dc74e36880cd3d8fa0a749e6f2d849;hp=486a50cf14db0a3c1e4c3e6dea169fbe99226873;hb=18b72639839461c074eb18fc2b58aa2a326485a1;hpb=0096f7eba3c6c1584234866ee3cbfe5b1df765c2

diff --git a/forth.js b/forth.js
index 486a50c..d3a2f83 100644
--- a/forth.js
+++ b/forth.js
@@ -1,97 +1,84 @@
+/*  This program is free software: you can redistribute it and/or modify
+    it under the terms of the GNU General Public License as published by
+    the Free Software Foundation, either version 3 of the License, or
+    (at your option) any later version.
+
+    This program is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+    GNU General Public License for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with this program.  If not, see <http://www.gnu.org/licenses/>. */
 'use strict'
-let txtdiv = document.createElement("div")
-document.body.appendChild(txtdiv)
+
+/* State */
 const output = {
-  print: (string) => txtdiv.textContent += string
+  print: (string) => {},
+  updateViews: () => {}
 }
-let wasmMem
-let forth
+let wasmMem, wasmMain
 
-/* Input capture */
-let stdin = ""
-document.addEventListener('keydown', (event) => {
-  console.log(`keydown: ${event.key}`)
-  if (event.key != "F5") {
-    event.preventDefault()
-    event.stopPropagation()
-    switch (event.key) {
-    case "Enter":
-      txtdiv = document.createElement("div")
-      document.body.appendChild(txtdiv)
-      forth()
-      output.print("__ok.")
-      txtdiv = document.createElement("div")
-      document.body.appendChild(txtdiv)
-      break
-    case "Backspace":
-      stdin = stdin.substring(0, stdin.length - 1)
-      txtdiv.textContent = txtdiv.textContent.substring(0, txtdiv.textContent.length - 1)
-      break
-    default:
-      if (event.key.length == 1) {
-	stdin += event.key
-        output.print(event.key)
-      }
-      break
-    }
+/* Environment functions */
+const bufString = (arrayBuf, addr, u) =>
+      String.fromCharCode.apply(null, new Uint16Array(arrayBuf, addr, u >> 1))
+const wasmString = (addr, u) => bufString(wasmMem, addr, u)
+const wasmBase = () => new DataView(wasmMem, 14348, 4).getUint32(0,true)
+const strToArrayBuffer = (str) => {
+  const buf = new ArrayBuffer(str.length << 1)
+  const bufView = new Uint16Array(buf)
+  for (let i = 0, strLen = str.length; i < strLen; i++)
+    bufView[i] = str.charCodeAt(i)
+  return buf
+}
+const bufJoin = (buf1, buf2) => {
+  const newBuf = new Uint8Array(buf1.byteLength + buf2.byteLength)
+  newBuf.set(new Uint8Array(buf1), 0)
+  newBuf.set(new Uint8Array(buf2), buf1.byteLength)
+  return newBuf.buffer
+}
+
+/* I/O Channel Drivers */
+const channels = []
+const getChannel = (chno) => {
+  const channel = channels[chno]
+  if (!channel)
+    throw new Error(`invalid channel access ${chno}`)
+  return channel
+}
+class Channel {
+  constructor(opt) {
+    opt = opt || Object.create(null)
+    opt.chno = channels.indexOf(undefined)
+    if (opt.chno === -1)
+      opt.chno = channels.length
+    Object.assign(this, opt)
+    if (this.buffer === undefined)
+      this.buffer = new ArrayBuffer(0)
+    channels[this.chno] = this
+    return this
   }
-})
+  read(writeArray, writeAddr, writeMax) {
+    const bufBytes = Math.min(writeMax, this.buffer.byteLength)
+    new Uint8Array(writeArray).set(new Uint8Array(this.buffer, 0, bufBytes), writeAddr)
+    this.buffer = this.buffer.slice(bufBytes)
+    return bufBytes
+  }
+  write(readArray, readAddr, readSize) {
+    this.buffer = bufJoin(this.buffer, new Uint8Array(readArray, readAddr, readSize))
+    wasmMain(this.chno)
+    output.updateViews()
+  }
+  send(readArray, readAddr, readSize) {
+    this.write(readArray, readAddr, readSize)
+  }
+}
 
-const channels = [{
-  read: (writeAddr, maxBytes) => {
-    const maxChars = maxBytes >> 1
-    const bufView = new Uint16Array(wasmMem.buffer, writeAddr, maxChars)
-    let i
-    for (i = 0; i < maxChars && i < stdin.length; i++)
-      bufView[i] = stdin.charCodeAt(i)
-    stdin = stdin.substring(maxChars)
-    return i << 1
-  },
-  write: (readAddr, maxBytes) =>
-    output.print(String.fromCharCode.apply(
-      null,
-      new Uint16Array(wasmMem.buffer, readAddr, maxBytes)
-    ))
-}]
+/* System runtime */
 const simstack = []
 const rstack = []
-const dictionary = {
-  ';': 1,
-  'LIT': 2,
-  RINIT: 3,
-  WORD: 696,
-  KEY: 5,
-  DUP: 6,
-  '+': 7,
-  'NOOP2': 8,
-  '.': 9,
-  '@': 10,
-  '!': 11,
-  EXECUTE: 12,
-  NOOP: 13,
-  'JZ:': 14,
-  'JNZ:': 15,
-  DROP: 16,
-  'WS?': 17,
-  'JMP:': 18,
-  'WPUTC': 19,
-  'WB0': 20,
-  'FIND': 21,
-  'NUMBER': 22,
-  'W!LEN': 23,
-  'J-1:': 24,
-  'BYE': 25,
-  'SWAP': 26,
-  'WORDS': 27,
-  'HERE': 28,
-  'DEFINE': 29,
-  ':': 900,
-  'MODE': 384,
-  'WBUF': 256,
-  'EXECUTE-MODE': 800,
-  'QUIT': 600,
-  'INTERPRET': 512
-}
+const dictionary = { EXECUTE: 12 }
+const doesDictionary = {}
 const wasmImport = {
   env: {
     pop: () => simstack.pop(),
@@ -99,99 +86,70 @@ const wasmImport = {
     rinit: () => rstack.length = 0,
     rpop: () => rstack.pop(),
     rpush: (val) => rstack.push(val),
-    sys_write: (channel, fromBuffer) => {
-      if (channels[channel] === undefined)
-	return
-      const maxBytes = new DataView(
-	wasmMem.buffer,
-	fromBuffer,
-	4
-      ).getUint32(0,true)
-      console.log(`write ch:${channel} addr:${fromBuffer} len:${maxBytes}`)
-      channels[channel].write(fromBuffer + 4, maxBytes)
-    },
-    sys_read: (channel, toBuffer) => {
-      console.log(`read ch:${channel} buf:${toBuffer} current: ${stdin}`)
-      const lenView = new DataView(wasmMem.buffer, toBuffer, 8)
-      const maxBytes = lenView.getUint32(0,true)
-      console.log(`read blen:${lenView.getUint32(0,true)} cstrlen:${lenView.getUint32(4,true)}`)
-      /* If the channel is undefined, or if there isn't enough room in
-       * toBuffer for even one character, then, if there is enough
-       * room for an int write a zero, exit */
-      if (channels[channel] === undefined || maxBytes < 6) {
-	if (maxBytes >= 4)
-	  lenView.setUint32(4,0,true)
-      }
-      const numBytes = channels[channel].read(toBuffer + 8, maxBytes - 4)
-      lenView.setUint32(4,numBytes,true);
-      console.log(`read wrote ${lenView.getUint32(4,true)} bytes, remainder: ${stdin}`)
-      console.log(`read blen:${lenView.getUint32(0,true)} cstrlen:${lenView.getUint32(4,true)}`)   },
-    sys_listen: (reqAddr, cbAddr) => {
+    sys_write: (chno, addr, u) => getChannel(chno).write(wasmMem, addr, u),
+    sys_read: (chno, addr, u) => getChannel(chno).read(wasmMem, addr, u),
+    sys_send: (chno, addr, u) => getChannel(chno).send(wasmMem, addr, u),
+    sys_connect: (addr, u) => {
       //TODO: call into the module to wasm fn "event" to push an event
       //to forth, which pushes esi to the return stack and queues the
       //callback function provided from listen. reqaddr could be
       //"fetch", in which case no channel is used.  otherwise very
       //similar to sys_fetch.
+
+      //callbacks are events, like listen events
+      //totally event-driven, one listener per event
+      //other listen types: mouse, keyboard, touch, main_loop (10ms interval), wrtc, etc
+      //fetch is different because it offers no "write" interface, doesn't repeat
     },
-    sys_fetch: (channel, reqAddr) => {
-      //TODO: map to fetch promise, write to channel buffer,
-      //javascript "fetch" as fallback, explicit handles for
-      //"textEntry" or any third party protocols like activitypub
-      console.log(`fetch ${channel} ${reqAddr}`)
+    sys_fetch: (chno, addr, u) => {
+      const str = wasmString(addr, u)
+      console.log(`fetching: ${str} || ${addr} ${u}`)
+      const args = JSON.parse(wasmString(addr, u))
+      console.log(args)
+      const url = args.url
+      delete args.url
+      const channel = channels[chno]
+      if (!channel) {
+        console.error(`invalid channel fetch: ${chno}`)
+        return -1
+      }
+      fetch(url, args).then((re) => {
+        if (args.headers === undefined ||
+            args.headers['content-type'] === undefined ||
+            args.headers['content-type'].toLowerCase().indexOf('text/plain') === 0 )
+          re.text().then((txt) => channel.write(strToArrayBuffer(txt), 0, txt.length << 1))
+        else {
+          const reader = new FileReader()
+          reader.onload = (evt) => channel.write(evt.target.result, 0, evt.target.result.byteLength)
+          re.blob().then((blob) => reader.readAsArrayBuffer(blob))
+        }
+      }).catch(console.error)
+      return 0
     },
-    sys_echo: (val) => output.print(`${val} `),
-    sys_echochar: (val) => output.print(String.fromCharCode(val)),
+    sys_open: () => new Channel().chno,
+    sys_close: (chno) => chno < 3 ? 0 : delete channels[chno],
+    sys_echo: (val) => output.print(`\\\ => ${val.toString(wasmBase())}\n`),
+    sys_log: (addr, u) => console.log(`=> ${wasmString(addr, u)}`),
     sys_reflect: (addr) => {
       console.log(`reflect: ${addr}: ${
-        new DataView(wasmMem.buffer, addr, 4)
+        new DataView(wasmMem, addr, 4)
               .getUint32(0,true)
       }`)
     },
-    vocab_get: (addr) => {
-      const bytes = new DataView(
-	wasmMem.buffer,
-	addr,
-	4
-      ).getUint32(0,true)
-      const word = String.fromCharCode.apply(
-	null,
-	new Uint16Array(wasmMem.buffer, addr + 4, bytes >> 1)
-      )
-      const answer = dictionary[word.toUpperCase()]
-      console.log(`vocab_get ${word}: ${answer}`)
-      if (answer === undefined)
-	return 0
-      return answer
-    },
-    vocab_set: (addr, num) => {
-      const bytes = new DataView(
-	wasmMem.buffer,
-	addr,
-	4
-      ).getUint32(0,true)
-      const word = String.fromCharCode.apply(
-	null,
-	new Uint16Array(wasmMem.buffer, addr + 4, bytes >> 1)
-      )
-      console.log(`vocab_set ${word}: ${num}`)
-      dictionary[word.toUpperCase()] = num
-      return 0
-    },
+    vocab_get: (addr, u) => dictionary[wasmString(addr, u).toUpperCase()] || 0, 
+    vocab_set: (addr, u, v) => dictionary[wasmString(addr, u).toUpperCase()] = v,
+    does_get: (addr, u) => doesDictionary[wasmString(addr, u).toUpperCase()] || 0,
+    does_set: (addr, u, v) => doesDictionary[wasmString(addr, u).toUpperCase()] = v,
     is_whitespace: (key) => /\s/.test(String.fromCharCode(key)),
-    sys_stack: () => console.log(`[${simstack}]`),
-    sys_parsenum: (addr, base) => {
-      const byteV = new DataView(
-	wasmMem.buffer,
-	addr,
-	4
-      )
-      const word = String.fromCharCode.apply(
-	null,
-	new Uint16Array(wasmMem.buffer, addr + 4, byteV.getUint32(0,true) >> 1)
-      )
-      const answer = Number.parseInt(word, base)
-      byteV.setUint32(0,Number.isNaN(answer),true)
-      return answer
+    sys_stack: () => { console.log(`[${simstack}][${rstack}]`)
+                       console.log(new Uint32Array(wasmMem, 16900, 28))
+                     },
+    sys_parsenum: (addr, u) => {
+      const answer = Number.parseInt(wasmString(addr, u), wasmBase())
+      if (Number.isNaN(answer))
+        return -1
+      new DataView(wasmMem, addr, 4).setUint32(0,answer,true)
+      return 0
     },
     sys_words: () => {
       output.print(Object.getOwnPropertyNames(dictionary).toString().split(',').join('  '))
@@ -199,12 +157,110 @@ const wasmImport = {
   }
 }
 
-fetch('forth.wasm')
-  .then(re => re.arrayBuffer())
-  .then(buf => WebAssembly.instantiate(buf, wasmImport))
-  .then(result => {
-    wasmMem = result.instance.exports.memory
-    forth = result.instance.exports.main
-    console.log('wasm loaded');
-    forth()
+/* Initialization */
+/* 0 STDIN, 1 STDOUT, 2 STDERR */
+new Channel({
+  send(readArray, readAddr, readSize) { output.print(bufString(readArray, readAddr, readSize)) }
+})
+new Channel({
+  write(readArray, readAddr, readSize) { output.print(bufString(readArray, readAddr, readSize)) },
+  send(readArray, readAddr, readSize) { output.print(`\n\\\ => ${bufString(readArray, readAddr, readSize)}\n`) }
+})
+new Channel({
+  write(readArray, readAddr, readSize) { console.error(bufString(readArray, readAddr, readSize)) }
+})
+
+/* Fetch wasm file, and initial forth file */
+Promise.all([
+  fetch('forth.forth', {credentials: 'include', headers:{'content-type':'text/plain'}}).then((re) => re.text()),
+  fetch('forth.wasm', {credentials: 'include', headers:{'content-type':'application/wasm'}}).then(re => re.arrayBuffer())
+]).then((results) => {
+  WebAssembly.instantiate(results[1], wasmImport).then((module) => {
+    wasmMem = module.instance.exports.memory.buffer
+    wasmMain = module.instance.exports.main
+    console.log('wasm loaded')
+    getChannel(0).write(strToArrayBuffer(results[0]))
   })
+})
+
+/* View Logic */
+window.onload = () => {
+  let forthdiv = document.getElementById("forth")
+  if (forthdiv === null) {
+    forthdiv = document.createElement("div")
+    forthdiv.setAttribute("style","height:100%;margin:auto;width:100%;max-width:640px;overflow-x:hidden;")
+    document.body.appendChild(forthdiv)
+  }
+  const outframe = document.createElement("div")
+  outframe.setAttribute("style", "background-color:black;padding-left:6px;padding-right:6px;color:chartreuse;height:268px;resize:vertical;display:flex;align-items:flex-end;flex-flow:row;")
+  const stackview = document.createElement("pre")
+  stackview.setAttribute("style", "white-space:pre-wrap;flex:0 0 6%;")
+  outframe.appendChild(stackview)
+  const txtoutput = document.createElement("pre")
+  txtoutput.setAttribute("style", "white-space:pre-wrap;max-height:256px;overflow-y:scroll;flex:1 0 342px;")
+  outframe.appendChild(txtoutput)
+  /* const rstackview = document.createElement("pre")
+  rstackview.setAttribute("style", "white-space:pre-wrap;flex:0 1 8%;")
+  outframe.appendChild(rstackview) */
+  const memview = document.createElement("pre")
+  memview.setAttribute("style", "padding-left: 8px; white-space:pre-wrap;flex:0 0 88px;")
+  outframe.appendChild(memview)
+  const txtinput = document.createElement("textarea")
+  txtinput.setAttribute("autofocus", "true")
+  txtinput.setAttribute("wrap", "hard")
+  txtinput.setAttribute("style", "resize:none;white-space:pre;margin-left:6%;width:77%;")
+  txtinput.oninput = () => txtinput.setAttribute("rows", ((txtinput.value.match(/[\n]/g) || [1]).length + 1).toString());
+  txtinput.oninput()
+  txtinput.onkeydown = (event) => {
+    switch (event.key) {
+    case "Enter":
+      if (event.ctrlKey) {
+        const endPos = txtinput.selectionStart + 1
+        txtinput.value =
+          txtinput.value.substring(0, txtinput.selectionStart) +
+          '\n' +
+          txtinput.value.substring(txtinput.selectionEnd, txtinput.value.length)
+        txtinput.setSelectionRange(endPos, endPos)
+        txtinput.oninput()
+      }
+      else {
+        if (txtinput.value.length && !/\s/.test(txtinput.value.slice(-1)))
+          txtinput.value += " "
+        event.preventDefault()
+        event.stopPropagation()
+        getChannel(0).write(strToArrayBuffer(txtinput.value))
+        txtinput.value = ""
+      }
+      break
+    case "Backspace":
+      break
+    default:
+      break
+    }
+  }
+  forthdiv.appendChild(outframe)
+  forthdiv.appendChild(txtinput)
+  /* Set up output functions */
+  output.print = (string) => txtoutput.textContent += string,
+  output.updateViews = () => {
+    const base = wasmBase()
+    stackview.textContent = simstack.map((v) => v.toString(base)).join('\n')
+    // rstackview.textContent = rstack.join('\n')
+    let cnt = 0;
+    const maxBytes = 64
+    let here = new DataView(wasmMem, 14340 /* here */, 4).getUint32(0,true)
+    memview.textContent = Array.from(new Uint8Array(wasmMem, here - maxBytes, maxBytes), (v) => {
+      cnt++;
+      v = ('0' + (v & 0xFF).toString(16)).slice(-2)
+      if (cnt === maxBytes)
+        return v
+      if ((cnt % 16) === 0)
+        return `${v}\n=> ${(here -maxBytes + cnt).toString(base)}\n`
+      if ((cnt % 4) === 0)
+        return `${v}\n`
+      return `${v} `
+    }).join('')
+    outframe.scrollTop = outframe.scrollHeight
+    txtoutput.scrollTop = txtoutput.scrollHeight
+  }
+}