Better Economics

<!DOCTYPE html>

<html>

body {background-color: gray;}

td { overflow='clip';}

textarea

{background-color: green; color: white; font-size: 25px; padding = 10px}

canvas {background-color=navy;}

th { color:black}

select { color:black;background-color : lime}

table {color: blue; text-align: center; border : 2px;}

button {background-color : red }

h1 {background-color : green; font-size : 24px; }

ul {background-color : blue; color : white; border : 4px ; text-align : center}

caption {background-color : yellow;font-size:20px;}

p {background-color : yellow; color: black;font-size: 15px;

text-align: center; vertical-align : top; width " 70"; hidden=true}

</style>

<button onclick ='cancel()'>Cancel</button>

<textarea cols=50 rows = 3 font-size = 14px>Javascript libraries use this part of the screen for user input. The dialog docking area. Operators hide this window as desired.</textarea>

</form>

<div>

<caption>Simple Menu System V1.77</caption>

<tr>

<td>

</td>

<td>

</td>

</tr>

</tbody>

</table>

</div>

<br>

<caption>Incoming Connection Reports</caption>

<tr>

<td ><textarea class = 'Display' cols=15 id = "D1"> Frequ 10</textarea></td>

<td><textarea class = 'Display' cols=15 id = "D2"> Power 10</textarea>

</td>

</tr>

<tr>

</td>

</td>

</tr>

</tbody>

</table>

<div >

</colgroup>

<caption>Ham Assembly Language</caption>

<tr>

<option onclick = 'closeText()'>Close</option>

<option onclick = 'createText()'>Create</option>

</select>

</th>

<th id = 'sources' contenteditable=true>Sources</th>

</tr>

<td>

</td>

<td>

<textarea class = 'visible' id = 'logger' cols="35" rows="25" border = 2 >Logger </textarea>

</td>

<td>

</td>

</tr>

</tbody>

</table>

</div>

<li class = 'debug' onclick = 'DebugStep(TOKEN)'>Token</li>

</ul>

<li class = "method" onclick ="USBConnect(current)">Connect</li>

<li class = "method" onclick ="getports()">Ports</li>

<li class = "method" onclick ="writeport()">Write</li>

<li class = "method" onclick ="closeport()">Close</li>

</ul>

<li class = 'list' onclick ="listLibrary()">Library</li>

<li class = 'list' onclick ="listOpcodes()">Opcodes</li>

<li class = 'list' onclick ="listSysOps();">Sysops</li>

<li class = 'list' onclick ="listSymbols();">Symbols</li>

</ul>

#log nice start;

add r0 hope;

#log end;

hope sub r0 r2;

#log done it;

</div>

//tokens

// tokens can have various types

// with precedances

// / scoping rules

const NEWLINE = 32;

const LITERAL = 20;

const VAL = 19; const NUM = 18; const REG = 17;

const MUL = 16; const DIV = 15;

const ADD = 14; const SUB = 13;

const LP = 12; const RP = 11;

const COMMA = 10;

const MACRO = 9;

const OP = 8; const SEMI = 7;

const ALPHA = 6;

const SYSOP = 5

const DISCARD = 4;

const QUOTE = 3;

// return status

const OK = 101; const DONE =102; // normal or source done

const WAIT = 103; const ERROR = -3; // forward reference or syntax error

// symbol classes

const USER = 40; const HAL = 41; const CONST = 42;

const EMBED = 43; const MODULE = 44; const LIB = 45;

// step indicators

const TEST = 56; const INIT = 55; const INDEX = 54;

const LINE = 53; const TOKEN = 52; const OFF = 51;

// symbol,states

const NULL = -1; const UNDEF = -2;

const DEF = 202; const PREDEF = 203;

const LOG = document.getElementById('logger');

</script>

//bigtable

// const USER,OP,SYSOP,EMBED,MODULE,LIB / scoping rules

// All symbols in one table, sysops, opodes, user symbols

const Symbol = {str : "",expr : 0,type : 0,value : 0,handle : null}

var symtable = [

{str : 'R0',expr : RegExp(/R0/,'i'),type : USER, value : 0,handle : 0},

{str : 'R1',expr : RegExp(/R1/,'i'),type : USER, value : 1,handle : null},

{str : 'R2',expr : RegExp(/R2/,'i'),type : USER, value : 2,handle : null},

{str : 'R3',expr : RegExp(/R3/,'i'),type : USER, value : 3,handle : null},

{str : 'define', expr : RegExp(/define/), type : SYSOP, value : 0,handle : function(){return define()}},

{str : 'assign', expr : RegExp(/assign/), type : SYSOP,value : 0,handle : function(){return assign() }},

{str : 'include', expr : RegExp(/include/),type : SYSOP,value : 0,handle : function(){return include()}},

{str : 'end', expr : RegExp(/end/), type : SYSOP,value : 0,handle : function(){return OK}},

{str : 'log', expr : RegExp(/log/), type : SYSOP,value : 0,handle : function(){return log()}},

{str : 'ifdef', expr : RegExp(/ifdef/), type : SYSOP,value : 0,handle : function(){return OK }},

{str : 'else', expr : RegExp(/else/) , type : SYSOP,value : 0,handle :

function(){return OK }},

{str : 'seg', expr : RegExp(/seg/) , type : SYSOP,value : 0,handle :

function(){return OK }},

{str : 'add', expr : RegExp(/add/), type : OP, value : 0,handle : null},

{str : 'sub', expr : RegExp(/sub/), type : OP, value : 0,handle : null},

{str : 'mul' ,expr : RegExp(/mul/), type : OP, value : 0,handle : null},

{str : 'div' ,expr : RegExp(/div/), type : OP, value : 0,handle : null},

{str : 'shft',expr : RegExp(/shft/),type : OP, value : 0,handle : null},

{str : 'and', expr : RegExp(/and/), type : OP, value : 0,handle : null},

{str : 'or' ,expr : RegExp(/or/), type : OP, value : 0,handle : null},

{str : 'xor' ,expr : RegExp(/xor/), type : OP, value : 0,handle : null},

{str : 'addi',expr : RegExp(/addi/),type : OP, value : 0,handle : null},

{str : 'subi',expr : RegExp(/subi/),type : OP, value : 0,handle : null},

{str : 'ori', expr : RegExp(/ori/), type : OP, value : 0,handle : null},

{str : 'xori',expr : RegExp(/xori/),type : OP, value : 0,handle : null},

{str : 'clr' ,expr : RegExp(/clr/), type : OP, value : 0,handle : null},

{str : 'comp',expr : RegExp(/comp/),type : OP, value : 0,handle : null},

{str : 'jmp' ,expr : RegExp(/jmp/), type : OP, value : 0,handle : null},

{str : 'call',expr : RegExp(/call/),type : OP, value : 0,handle : null},

{str : 'bre' ,expr : RegExp(/br/) , type : OP, value : 0,handle : null},

{str : 'brn' ,expr : RegExp(/brn/), type : OP, value : 0,handle : null},

{str : 'br' ,expr : RegExp(/brp/), type : OP, value : 0,handle : null},

{str : 'ret' ,expr : RegExp(/ret/), type : OP, value : 0,handle : null},

{str : 'btst',expr : RegExp(/btst/),type : OP, value : 0,handle : null},

{str : 'bset',expr : RegExp(/bset/),type : OP, value : 0,handle : null},

{str : 'ld' ,expr : RegExp(/ld/), type : OP, value : 0,handle : null},

{str : 'ldm' ,expr : RegExp(/stm/), type : OP, value : 0,handle : null},

{str : 'ldw' ,expr : RegExp(/ldw/), type : OP, value : 0,handle : null},

{str : 'st' ,expr : RegExp(/st/), type : OP, value : 0,handle : null},

{str : 'stm' ,expr : RegExp(/stm/), type : OP, value : 0,handle : null},

{str : 'stw' ,expr : RegExp(/stw/), type : OP, value : 0,handle : null}

]

var symLength = symtable.length;

function listSymbols(type) {

clearLog();

strLog('\n Symbols ');

for(let i=0; i < symtable.length;i++)

if(symtable[i] = type)

strLog('\n: ' + i +' ' + symtable[i].str + ' '+symtable[i].expr +' '+symtable[i].value );

}

function symValue(index) {

if(index == false) index =0;

if((index< 0) || (index > symtable.length)) return syntaxError('Bad index');

return symtable[index].value;

}

function addSym(name,type,value) {

var index = findSym(name)

if(index > -1) {

symtable[index].expr = RegExp(name);

symtable[inde].type = type

symtable[index].value = value;

}

else{

var sym = Object(Symbol);

sym.str =name;

sym.expr = RegExp(name)

sym.type = type;

sym.value = value;

symtable.push(sym);

}

return OK;

}

function findSym(name) {

len = name.length;

for(let i =0; i < symtable.length;i++) {

if(len == symtable[i].str.length)

if(symtable[i].expr.test(name)) {

return i;

}

return UNDEF;

}

// Drop entries from user symbols

function delSym() {

do {

if(nextToken() < 0) return syntaxError('No token')

if(index = findSym(cc.slice) < 0)

break;

var type = cc.type;

if(type == SEMI) break;

symtable.splice(index,1);

} while(type != SEMI);

return endOfLine();

}

// assembler found a symbol

// a finite string of alpha numerics

// that begins with an alpha

function symbol(opContext) {

var index;

if(arguments.length == 0) {// symbol defined

console.log('New symbol');

index=newSym(cc.slice(),cc.line())

symtable[index].state = DEF;

symtable[index].value = cc.line();

return waitService(i);

} else { // this maybe a wait

if( (index = findSym(cc.slice())) < 0){

opContext.index =newSym(cc.slice());

return waitRequest(opContext); // opcode context pushed onto wait stack

} else {

if(symtable[index].state == UNDEF) {

opContext.index = index;

return waitRequest(opContext); // opcode context pushed onto wait stace

} else {

cc.setIndex(symtable[index].value)

cc.setType(VAL); //resolved

return OK

}

// text

function clearLog() {

LOG.textContent = ' ';

}

// send string to log

function strLog(str){

LOG.textContent+= str;

}

// send string to log

function strPrependLog(str){

LOG.textContent = str + LOG.textContent;

}

function srcCharByIndex(node,index) {

var ch = node.textContent.charAt(index);

return ch

}

function tokenText(str) {

var s= String();

s = '|'+cc.slice()+'|';

//s.replace(/\n/,'X')

if(arguments > 1) s += str;

strPrependLog(

'\nTok ' + s + ' ' + ' t: ' + cc.type()+' s: '+cc.start()+ ' e: ' + cc.end()+'\n' );

}

// generic find a name among

// a list of html children

function findItemByName(items,name) {

for(i=0;i < items.length;i++)

if(items[i].name == name)

return items[i];

return null;

}

function findText(name) {

items = document.getElementById('textanchor').children;

return findItemByName(items,name);

}

function findListItem(name) {

items = document.getElementsByClassName('openmacro');

return findItemByName(items,name);

}

// when the user clicks on a macro list item

function setListEvent(node) {

node.addEventListener('click', () => {

showText(node.name);

blinkListItems(node.name);

//console.log('Set up ' +node.name)

});

}

function newListItem(name) {

var list = document.createElement('li')

list.name = name;

list.className = 'openmacro'

list.textContent = name

//console.log('NewItem '+ name);

setListEvent(list);

document.getElementById('macroList').appendChild(list);

showText(name);

}

function delListItem(name) {

parent = document.getElementById('macroList');

node = findName(name,parent.children);

parents.removeChild(node);

}

////////////// Methods to manage textareas////////////////

function listTexts() {

var items = document.getElementById('textanchor').children;

for(let i =0; i < items.length;i++) {

strLog(': '+ items[i].name);

}

function saveText() {

strPrependLog('Save\n');

var nameNode = document.getElementById('sources');

var textNode = findTextByName(nameNode.textContent);

if(textNode.hidden == false) {// The macro in focus

localStorage.setItem(nameNode.name,textNode.textContent);

nameSelector();

}

return;

}

// th element as editable input

function newText(name) {

strPrependLog('New\n');

if(name == null)

name = document.findElementByID('sources').textContent;

addText(name);

}

function openText(name) {

strPrependLog('Open\n');

}

function closeText() { strPrependLog('Close\n');

parent = document.getElementById('macroList');

name = document.getElementById('sources').textContent;

node = nodeFindByName(parent.chldren,name);

parent.removeChild(node);

parent = documemt.getElementById('textanchor');

node = nodeFindByName(parent.chldren,name);

parent.removeChild(node);

}

function showText(name) {

items = document.getElementById('textanchor').children;

for(i=0;i < items.length;i++) {

if(items[i].name == name)

items[i].hidden=false;

else

items[i].hidden=true;

document.getElementById('sources').textContent = name;

}

function createText(name) {

var td = document.getElementById('textanchor');

var text = document.createElement('textarea');

text.hidden = false;

text.cols =30

text.rows = 15

if(name == null)

text.name = document.getElementById('sources').textContent;

else

text.name = name;

text.className = 'invisible';

td.appendChild(text);

showText(text.name);

return text;

}

function context() {

this.hidden = true;

this.nextSibling().hidden = false;

//this.parent.onchange();

}

function actionText(node) {

var items = node.children;

for(i=0;i < items.length;i++)

if(items[i].selected) {

items[i].onclick(items[i].value);

return;}

}

function blinkListItems(name) {

items = document.getElementById('macroList').children;

radioButtons(name,items);

}

function source(name) {

getElementById('sources').textContent=name;

showTextArea(name);

console.log('arrived');

}

// Make a name list from local storage

function nameSelector() {

var len = localStorage.length;

parent = document.getElementById('sources');

var sel = document.createElement('select');

sel.hidden = true;

sel.onchange = 'source()'.

parent.append(sel);

for(let i = 0;i < len;i++) {

name = localStorage.key(i);

var opt = document.createElement('option');

opt.textContent = name;

sel.appendChild(opt)

}

opt = document.createElement('option');

opt.textContent='rename';

sel.appendChild(opt);

}

function listLibrary() {

clearLog();

var len = localStorage.length;

strLog('\nLocal storage ' + len)

for(let i =0;i < len;i++) {

var name = localStorage.key(i);

value = localStorage.getItem(name);

strLog('\n '+i+': ' +name + ' '+ value);

}

// sysops

//Install a module from local storage

// put up a selector for it, add its own

// text area, and install the name

// on the sysop table

function installModule(name,str) {

console.log('Install');

if(arguments.length == 2)

localStorage.setItem(name,str);

var index = findSym(name); // is it installed?

if((index > -1) && (index < builtinsLength))

return syntaxError('Opcode redefined i '+index+' '+builtinsLength+'|'+name+'|')

if(index >= 0) { // already in the opcode table

node= findListItem(name);

if(node==null) syntaxError('Library misorder')

node = findText(name)

if(node== 0) syntaxError('Set up wrong')

} else { // new set up

strPrependLog('\nNew set '+name);

node = createText(name);

console.log('Installed '+node.name + ' '+name);

addSym(name);

newListItem(name);

}

node.textContent=localStorage.getItem(name);

return OK;

}

// drop an entry in the sysop table

function undef() {

remove(delSys); }

// in user table

function remove() {

remove(delSym); }

function define() {

do {

if(nextToken() < 0) return syntaxError('No token')

newSysop(cc.slice());

}while(cc.type() != SEMI)

}

// manipulate the user symbol table

function assign(){

do {

if(nextToken() < 0) return syntaxError('No token')

type = cc.type();

if(type() == SEMI) break;

token1 = cc.slice();

if(nextToken() > 0) {

type = cc.type()

if(type ==ARG)

newSym(token1,args.pop());

else if(type = NUM)

newSym(token1,JSON.parse(cc.slice()));

} else

newSym(token1,UNDEF);

strPrependLog('Define: '+ token1 + ' ' + symValue(findSym(token1))+'\n')

} while(cc.type() != SEMI);

//nextToken(); //pass the semi

return endOfLine();

}

function log(ptr){

var start,end;

var eol = endOfLine(); // move the newline pointer

//console.log('log ' + newline.lastIndex + ' '+ SRC.textContent.length);

start = cc.end();

if(newline.lastIndex !== 0)

end = newline.lastIndex-1;

else

end = cc.node().textContent.length;

strPrependLog('\n '+ cc.slice(start,end)+'\n');

return eol;

}

function newSysop(name) {

var i=0;

var symbol = new Object(opCode);

i = findSym(name,optable)

console.log('New sys '+name + ' '+i)

if(i < 0) {// New entry

symbol.str = name;

symbol.expr = RegExp(name);

symbol.idx=optable.length+1;

optable.push(symbol);

opcodesLength = optable.length;

}

return OK;

}

function delsysop(name) {

i = findSym(name,optable);

if(i < 0) return OK;

optable.splice(i,1);

return OK;

}

function include(){

var node;

console.log('Include');

do {

r=nextToken()

var type = cc.type();

if(type == SEMI)

break; // move the newline pointer

if(r < 0) return syntaxError('No token');

if(type != ALPHA) return syntaxError('Expected Name');

var name = cc.slice();

installsysop(name);

strPrependLog('Add sysop '+ name+'\n')

} while(type != SEMI);

return OK;

}

// Bracket quoted HAL must be valid

// Should end with end; pseudo opcode

function macro() {

var index = nextToken();

if(index > -1) syntaxError('cannot redefine');

token = cc.slice();

nextToken();

if(cc.type() != LB) syntaxError('No start');

newOpcode(token,cc.end());

while(true) {

nextToken()

if(cc.type() == RB)

break;

endOfLine(); // skip the line

}

</script>

// sneak in a fake source on startup

function sneak() {

var str = document.getElementById('startcode').textContent

installModule('source',str);

}

sneak();

</script>

// exec

//Define a context of some type of token

// must include the node holding textContent,

// and a start, end, lastIndex

// scanned in a textArea of node, possibly

//having a symbol index pointing into the symbol table

// .

const Context = { start : 0, end : 0, type : 0,

node : 0,index : 0,line:1,lastIndex:0}

var CS = Array();

const cc = {

k : -1,

version : function(){ strPrependLog('V1.0\n')},

length : function(){ return CS[this.k].end - CS[this.k].start;},

get : function() {return CS[this.k]},

clear : function(){CS.length =0; this.k =-1;},

incLine : function(){ CS[this.k].line++;return CS[this.k].line;},

line : function(){ return CS[this.k].line;},

push : function(x){ this.k++; return CS.push(x)},

pop : function(){ this.k--; return CS.pop()},

startChar : function(){ return CS[this.k].node.textContent.charAt(CS[this.k].start)},

endChar : function(){ return CS[this.k].node.textContent.charAt(CS[this.k].end)},

indexChar : function(index) { return CS[this.k].node.textContent.charAt(index);},

setStart : function(start) {CS[this.k].start =start;},

incStart : function(start) {CS[this.k].start++;},

setLastIndex : function() {CS[this.k].lastIndex =CS[this.k].end;},

start : function(start) {return CS[this.k].start;},

setIndex : function(index) {CS[this.k].index =index;},

setEnd : function(end) { CS[this.k].end =end;},

end : function() {return CS[this.k].end;},

node : function() {return CS[this.k].node;},

setType : function(type) { CS[this.k].type =type;},

type : function() {return CS[this.k].type;},

text : function() { return CS[this.k.node.textContent];},

slice : function(start,end){

var s,e;

var i = this.k;

if(arguments.length > 0) s = start; else s = CS[this.k].start;

if(arguments.length > 1) e = end; else e =CS[this.k].end;

return CS[this.k].node.textContent.slice(s,e);

twoChars : function(){

var s = CS[this.k].end; // aftr the newline

return CS[this.k].node.textContent.slice(s,s+2);

}

// Initialize the assembler

function initHal() {

tokend.lastIndex =0;

newline.lastIndex =0;//

clearLog();

resetRpn();

//resetWaits();

return OK;

}

function endOfLine() {

newline.lastIndex = tokend.lastIndex;

newline.exec(cc.node().textContent)

if(newline.lastIndex !== 0) {

// Do not allow parser to chew past arguments

tokend.lastIndex = newline.lastIndex;

return OK;

}else return DONE;

}

// everything needed to process textContent

function newContext(node) {

var p = new Object(CONTEXT);

var x =0;

p.lastIndex = 0;

p.line = 1;

p.start = 0;

p.end = 0;

p.type = DISCARD;

p.node = node;

p.name = node.name;

cc.push(p);

// Newline required here

if(cc.indexChar(0) != '\n') return syntaxError('No starting newline');

strLog('New Context ' + node.name);

return endOfLine();

}

function execLines(){

var result=OK;

var count = 0;

while( (result == OK) || (result == WAIT)) {

count++;

result = firstColumn();

if(result==DONE)

return strPrependLog('\nSource done');

}

syntaxAlert('Assembly error ' + result)

}

function ExecSource() {

node = findText('source')

if(node == null) return syntaxError('Nosource');

initHal();

console.log('CC ' +cc.k)

newContext(node);

execLines();

return OK;

}

function listToken() {

var result = nextToken();

if(result == OK)

tokenText();

return result;

}

function listTokens() {

var result=OK;

var str;

clearLog()

strPrependLog('\n...All tokens....');

cc.setStart(0);

cc.setEnd(1);

tokstart.lastIndex =0;

tokend.lastIndex = 0;

newline.lastIndex =0;

//endOfLine(); // to starting line

do result = listToken(); while(result == OK);

strPrependLog('End of source');

return result;

}

function DebugStep(as) {

var result;

switch(as) {

case TEST:

e = findText('source');

if(e.hidden == 1) delete e.hidden;

else e.hidden = 1;

break;

case TOKEN :

if(listToken() == DONE) InitHal();

break;+tokend.lastIndex

case LINE :

if(nextToken() != DONE);

result = firstColumn();

//console.log('col end |'+cc.slice()+'|'+tokend.lastIndex);

break;

case INDEX:

break;

case INIT:

var node = findText('source');

if(node == null) console.log('Nosource');

initHal();

newContext(node);

break;

}

// forward reference array

var waits = new Array();

function waitService(index) {

var n = waits.length;

console.log('Wait service len ' + n)

for(let i = 0; i < n;i++)

if(waits[i].index == index) {

cc.push(waits[i]);

console.log('Service '+tokenText())

waits.splice(i,1);

argsProcess();

CS.pop();

}

return OK;

}

function waitRequest(context,index) {

console.log('Wait request');

context.index =index;

waits.push(context);

return WAIT;

}

function opProcess(token){}

function funProcess(token) {

var result = 0;

var textNodes = document.getElementsByClassName('invisible');

var el = findName(textNodes,optable[token.index].str);

initHal();

result = newContext(el);

while(result != DONE) {

result = firstColumn();

}

return OK;

}

// Global and local regx

const newline = RegExp(/\n/ ,'g'); // a regx to find end of line

const tokstart = RegExp(/\S|\n/, 'g');

const semi = RegExp(/;/,'g');

const tokend = RegExp(/\W/,'g'); // no alpha or numeric

const quote = RegExp(/\"/,'g'); // open literal

const bracket = RegExp(/\{\}/,'g'); // open literal

// local operators

const alum = RegExp(/\w/); // alpha or numeric

const space = RegExp(/\t| /); // valid separators

const nospace = RegExp(/\S/); // drk

const operator = RegExp(/[;\*\\\+\-#\(\)]/);

const white = RegExp(/\s/); //not words

const primes = [

{ str : 'register', expr : RegExp(/r\d/), type : REG},

{ str : 'alpha', expr : RegExp(/[a-zA-Z]/),type : ALPHA},

{ str : 'number', expr : RegExp(/[0-9]/),type : NUM},

{ str : 'sysop', expr : RegExp(/#/),type : SYSOP},

{ str : 'muliply', expr : RegExp(/[\*]/),type : MUL},

{ str : 'divide', expr: RegExp(/[\\]/),type : DIV},

{ str : 'add', expr : RegExp(/[\+]/),type : ADD},

{ str : 'sub', expr : RegExp(/[\-]/),type : SUB},

{ str : 'comma', expr : RegExp(/\,/),type : COMMA},

{ str : 'semi', expr : RegExp(/;/),type : SEMI},

{ str : 'left', expr : RegExp(/\(/),type : LP},

{ str : 'right', expr : RegExp(/\)/),type : RP},

{ str : 'newline', expr : RegExp(/\n/),type : NEWLINE}

]

const primeLength = primes.length;

function regtest(regx,str){

let x = regx.test(str);

return x;

}

// errors

function syntaxAlert(msg) {

var l;

alert(msg +' type '+cc.type()+' '+cc.start()+' '+cc.end()+' '+cc.slice()+'\n')

return OK;

}

// errors

function syntaxError(msg) {

var l;

strPrependLog(msg +' '+cc.start()+' '+cc.end()+' '+cc.slice()+'\n')

return ERROR;

}

function typeGet(index,str){

let x = primes[index].expr.test(str);

if(x) return primes[index].type;

else return ERROR;

}

function updateToken(index) {

var type,ch;

ch = cc.indexChar(index);

for(i=0;i < primeLength;i++)

if( (type = typeGet(i,ch)) > -1){

cc.setType(type);

return cc.type();

}

return syntaxError('No type |'+ch+'|' );

}

//args process found a quote character

function literal() {

cc.setStart(cc.end());

quote.lastIndex = cc.start();

quote.exec(cc.text());

if( (quote.lastIndex ==0) || (quote.lastIndex >= newlne.lastIndex) )

return syntaxError('missing quote');

cc.setEnd(quote.lastIndex-1);

rpn();

return OK;

}

// The function sets the start and end indices

// for a token of three classes:

// numeric, alphanumeric and single char operators

// New lin3 is a valid operator, right associated.

// It changes assmbler state based on the next two chars.

function nextToken() {

SRC= cc.node();

if(SRC ===null) syntaxError('No source');

var ch,index,result;

tokstart.lastIndex = tokend.lastIndex-1; // get end of last token

if(regtest(space,SRC.textContent.charAt(tokstart.lastIndex) )){

tokstart.exec(cc.node().textContent)

if(tokstart.lastIndex == 0) return DONE;

} else tokstart.lastIndex++;

updateToken(tokstart.lastIndex-1);

tokend.lastIndex = tokstart.lastIndex; // get start of current token

if(regtest(alum,SRC.textContent.charAt(tokend.lastIndex-1)) ){

tokend.exec(SRC.textContent);

if(tokend.lastIndex == 0) return syntaxError('No line terminator')

} else tokend.lastIndex++; //must be a single char

cc.setStart(tokstart.lastIndex-1);

cc.setEnd(tokend.lastIndex-1);

return OK;

}

//First argument always an opcode

// handle opcode and multiple arguments

// symbol argument, literals, end of line

function argsProcess() {

opContext = cc.get(); // restart here on forward reference

if(nextToken() == DONE) return DONE;

if(cc.type() == NEWLINE) { //blank line

return OK;

}

// opcode required here

index = findSym(cc.slice());

if( index< 0) return syntaxError('\nNo op ' + cc.slice())

rpn(); // process opcode

let type = cc.type();

while((type != SEMI) && (type != NEWLINE )) {

if(nextToken() == ERROR) return syntaxError('Or a bug'); // line done

type = cc.type();

if(type == QUOTE) { // literals shipped as is.

literal(); // one literal per line

break;

} else if(type == ALPHA)

if(symbol(opContext ) == WAIT ) {

return endOfLine(); // fludh to end of line

}

// ready to activate rpn)

if(type > OP )

rpn();

}

return OK;

//endOfLine();

}

//the currnt token is newline

// which triggers first column call

function firstColumn() {

var result;

if(cc.type() != NEWLINE) return syntaxError('Col bug');

var twochars = cc.twoChars();

// arrive here once per line and never more

cc.incLine(); // Every context keeps its own line counter

if(white.test(twochars)) // if no column one work

return argsProcess(); // pass it on

console.log('after args |'+cc.slice()+'|'+tokend.lastIndex);

nextToken(); // there is column one work

if(cc.type() == SYSOP) {

if(nextToken() < 0)return syntaxError('No sysop ');

let index = findMacro(cc.slice());

if(index < 0)

return syntaxError('Undefined sysop ');

else {

//console.log('Sysop '+cc.slice())

return mactable[index].handle();

}

// source defines symbol

else if(cc.type() == ALPHA) {

// we just set the symbol to the current lineZ

symbol();

return argsProcess();

}

else

return syntaxError('Illegal char ');

}

if ("serial" in navigator) {

// The Web Serial API is supported.

}

var port;

async function getport() {

console.log('get port')

port = await navigator.serial.requestPort();

if(port)

var info = port.getInfo();

else console.log('no port')

console.log('info '+ info)

}

// Get all serial ports the user has previously granted the website access to.

async function getports() {

ports = await navigator.serial.getPorts();

console.log('Get ports ' + ports.length)

console.log(ports[0])

}

async function closeport() {

await port.close();

}

// Filter on devices with te Arduino Uno USB Vendor/Product IDs.

const filters = [

{ usbVendorId: 0x2341, usbProductId: 0x0043 },

{ usbVendorId: 0x2341, usbProductId: 0x0001 }

];

// Prompt user to select an Arduino Uno device.

async function getPort() {

port = await navigator.serial.requestPort([filters]);

if(port)

var info = port.getInfo();

}

// Wait for the serial port to open.

async function openport() {

await port.open({ baudRate: 9600 });

}

//After the serial port connection is established, the readable and writable properties //from the SerialPort object return a ReadableStream and a WritableStream. Those will be //used to receive data from and send data to the serial device. Both use Uint8Array //instances for data transfer.

//When new data arrives from the serial device, port.readable.getReader().read() returns //two properties asynchronously: the value and a done boolean. If done is true, the serial //port has been closed or there is no more data coming in. Calling //port.readable.getReader() creates a reader and locks readable to it. While readable is //locked, the serial port can't be closed.

async function readport() {

reader = port.readable.getReader();

console.log('read '+ reader);

// Listen to data coming from the serial device.

while (true) {

var { value, done } = await reader.read();

if (done)

{

console.log('Value ' + value.length)

// Allow the serial port to be closed later.

reader.releaseLock();

break;

}

// value is a Uint8Array.

}

console.log('Done '+value.length);

}

function freeport(){

if(reader)

reader.releaseLock();

if(writer)

writr.relaseLock();

}

async function writeport() {

var writer = port.writable.getWriter();

var data = new Uint8Array([104, 101, 108, 108, 111,010,013]); // hello

await writer.write(data);

console.log('Written ');

// Allow the serial port to be closed later.

writer.releaseLock();

}

function getreader() {

const textDecoder = new TextDecoderStream();

const readableStreamClosed = port.readable.pipeTo(textDecoder.writable);

reader = textDecoder.readable.getReader();

}

// menu

var iCount=-1;

var current;

var selected = document.getElementById("selectedItem")

var menuItems = document.getElementById('simpleMenu').childNodes

current= menuItems[0];

parent=current.parentNode;

function radioButtons(name,items){

for(i=0;i < items.length;i++) {

if(items[i].name == name)

items[i].style.backgroundColor = "orange";

else

items[i].style.backgroundColor = "navy";

}

// set up the radio buttons

function setRadioEvent(element) {

element.addEventListener('click', () => {

element.style.backgroundColor = 'red'

let items=element.parentNode.children;

radioButtons(element.name,items);

//for(i=0;i<items.length;i++)

// if(items[i].name != element.name)

// items[i].style.backgroundColor = "blue"

});

}

function setConnects(str) {

var element = document.getElementById(str)

var items = element.children

for(i=0; i < items.length;i++) setRadioEvent(items[i]);

}

button = document.getElementById("menuNext")

button.addEventListener('click', () => {

do{

iCount++

if(menuItems.length == iCount) iCount = 0;

current = menuItems[iCount];

if(current.nodeName=="UL")

selected.textContent= current.className;

else if(current.nodeName=="LI")

selected.textContent= current.textContent;

} while(current.nodeType !=1)

});

button = document.getElementById("menuDown")

button.addEventListener('click', () => {

if(current.nodeName == "UL") {

parent=current;

menuItems = parent.childNodes;

current = menuItems[0];

iCount=-1

if(current.nodeName=="UL")

selected.textContent= current.className

}

else {

selected.textContent= current.textContent;

current.onclick()

}

});

button = document.getElementById("menuUp")

button.addEventListener('click', () => {

if(parent.nodeName =="UL") {

current = parent

parent = current.parentNode;

menuItems = parent.childNodes;

iCount=-1

selected.textContent= current.className

} else

console.log('To level')

});

setConnects('connectTop')

setConnects('connectBottom')

// resolve

objectCode = new Uint8Array(100);

arg = new Array();

oper = new Array();

function resetRpn() {

arg.length = 0;

oper.length = 0;}

function operLast() {

return oper[oper.length-1]}

function argLast() {

return arg[arg.length-1]}

function OpProcess(index) {

var result = 0;

switch(optable[index].type) {

case MODULE:

var str = optable[index].str;

var node = findTextarea(str);

newContext(node);

execLines();

cc.pop();

break

case MACRO:

var state = nextToken();

while(state != DONE)

executeLine();

break

case END:

return DONE;

break;

}

if(index < builtinsLength) processOpcode(index)

else { // must be a module

var str = optable[index].str;

var node = findText(str);

newContext(node);

execLines();

CS.pop();

}

return OK;

}

function flushLiteral(addr) {

start = cc.start();

end = start + cc.length;

node=cc.node();

while(start < end) {

objectCode[addr] = node.textContent[start];

start++;addr++;

}

function flushNum(n,addr) {

var list = String('0123456789abcdef')

var out = String(' ');

bit = 1;

while(bit < n) {

var r = 0;

var t = 1;

for(j=0;j < 4;j++) { // for each bit

if(n & bit)

r += t;

t *=2;

bit *=2;

}

out = list[r] +out;

}

for(j=0;j < out.length;j++){

objectCode[addr] = out[j];

addr++;

}

return addr;

}

// numbers or operators

function flushExpression(arg,addr) {

var len = expr.length;

var x;

var y;

var z;

console.log('flush');

while(arg.length>2) { // there should remain one resolved literal

x = arg.pop();

y = arg.pop();

z = 0;

switch(lastOper.type) {

case MUL:

z = (x*y);

break;

case DIV:

z =(x/y);

break;

case ADD:

z =(x+y);

break;

case SUB:

z =(x-y)

break;

}

arg.push(z);

arg.splice(0,1)

}

flushNum(z);

return OK;

}

// make the source line shunted

// evaluate arg expressions

// separat arguments

var addr=0;

function rpn()

{

strLog('\nrpn ' + cc.slice());

var type = cc.type();

switch(type) {

case LITERAL:

addr=flushLiteral(addr);

break;

case VAL:

arg.push(cc.index());

break;

case NUM:

x = JSON.parse(cc.slice());

arg.push(x);

break;

case RP:

while(oper.length > 0 )

if (type = lastOper.type != LP)

arg.push(oper.pop().type)

else

addr = flushExpression(addr);

if(oper.length == 0)return syntaxError('no left parenth')

oper.pop();

break;

case SEMI: // The last argument

if(oper.length==0) return(syntaxError('Semi-colon mismatch'));

addr = flushExpression(addr); // one last arg

type = oper.pop().type;

if((type != OP) && (type != MACRO))

return(sytaxError('Line not closed'));

// call the OP or MACRO process

processOpcode(cc.index());

break;

case COMMA:

addr = flushExpression(addr);

break

case ALPHA:

case SYSOP:

return syntaxError('Not prime');

break;

default:

while( (oper.length != 0) && (operLast.type > type) )

arg.push(oper.pop().type);

}

return OK;

}

</script>

</html>

Better Economics

Sunday, November 12, 2023

Ham Radio Assembly Language for Browsers

Monday, September 25, 2023

Progressive politicians on the take

Busted! Adam Schiff Funneled Millions To Defense Contractors After Taking Donations

Sunday, September 24, 2023

Commie rats are control freaks

Thursday, September 14, 2023

No, actually. I have seen the name thrown about

Tuesday, September 5, 2023

Cannot disrespect the great color genderizor

Biden Allies Say It Would Be Racist For Gavin Newsom To Run In 2024

Wednesday, August 30, 2023

Srokes in mid conference

Monday, August 21, 2023

Chicago street battles

Thursday, August 17, 2023

What did Mickey Mouse say?

Wednesday, August 16, 2023

You have your Trumpsters and now your Dump Trumpsters

Kevin McCarthy, it’s time to dump Trump and restore the Republican party’s values | Opinion

Tuesday, August 8, 2023

Prolife Reubs plan to spend trillions on artificial wombs

Search