9935 lines
293 KiB
JavaScript
9935 lines
293 KiB
JavaScript
(() => {
|
|
var __defProp = Object.defineProperty;
|
|
var __getOwnPropSymbols = Object.getOwnPropertySymbols;
|
|
var __hasOwnProp = Object.prototype.hasOwnProperty;
|
|
var __propIsEnum = Object.prototype.propertyIsEnumerable;
|
|
var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
|
|
var __spreadValues = (a, b) => {
|
|
for (var prop in b || (b = {}))
|
|
if (__hasOwnProp.call(b, prop))
|
|
__defNormalProp(a, prop, b[prop]);
|
|
if (__getOwnPropSymbols)
|
|
for (var prop of __getOwnPropSymbols(b)) {
|
|
if (__propIsEnum.call(b, prop))
|
|
__defNormalProp(a, prop, b[prop]);
|
|
}
|
|
return a;
|
|
};
|
|
|
|
// src/common/util.ts
|
|
function hex(v, nd) {
|
|
if (!nd)
|
|
nd = 2;
|
|
if (nd == 8) {
|
|
return hex(v >> 16 & 65535, 4) + hex(v & 65535, 4);
|
|
} else {
|
|
return toradix(v, nd, 16);
|
|
}
|
|
}
|
|
function toradix(v, nd, radix) {
|
|
try {
|
|
var s = v.toString(radix).toUpperCase();
|
|
while (s.length < nd)
|
|
s = "0" + s;
|
|
return s;
|
|
} catch (e) {
|
|
return v + "";
|
|
}
|
|
}
|
|
function stringToByteArray(s) {
|
|
var a = new Uint8Array(s.length);
|
|
for (var i = 0; i < s.length; i++)
|
|
a[i] = s.charCodeAt(i);
|
|
return a;
|
|
}
|
|
function byteArrayToString(data) {
|
|
var str = "";
|
|
if (data != null) {
|
|
var charLUT = new Array();
|
|
for (var i = 0; i < 256; ++i)
|
|
charLUT[i] = String.fromCharCode(i);
|
|
var len = data.length;
|
|
for (var i = 0; i < len; i++)
|
|
str += charLUT[data[i]];
|
|
}
|
|
return str;
|
|
}
|
|
function getBasePlatform(platform) {
|
|
return platform.split(".")[0];
|
|
}
|
|
function getRootPlatform(platform) {
|
|
return platform.split("-")[0];
|
|
}
|
|
function getRootBasePlatform(platform) {
|
|
return getRootPlatform(getBasePlatform(platform));
|
|
}
|
|
var XMLParseError = class extends Error {
|
|
};
|
|
function escapeXML(s) {
|
|
if (s.indexOf("&") >= 0) {
|
|
return s.replace(/'/g, "'").replace(/"/g, '"').replace(/>/g, ">").replace(/</g, "<").replace(/&/g, "&");
|
|
} else {
|
|
return s;
|
|
}
|
|
}
|
|
function parseXMLPoorly(s, openfn, closefn) {
|
|
const tag_re = /[<]([/]?)([?a-z_-]+)([^>]*)[>]+|(\s*[^<]+)/gi;
|
|
const attr_re = /\s*(\w+)="(.*?)"\s*/gi;
|
|
var fm;
|
|
var stack = [];
|
|
var top;
|
|
function closetop() {
|
|
top = stack.pop();
|
|
if (top == null || top.type != ident)
|
|
throw new XMLParseError("mismatch close tag: " + ident);
|
|
if (closefn) {
|
|
top.obj = closefn(top);
|
|
}
|
|
if (stack.length == 0)
|
|
throw new XMLParseError("close tag without open: " + ident);
|
|
stack[stack.length - 1].children.push(top);
|
|
}
|
|
function parseattrs(as) {
|
|
var am;
|
|
var attrs2 = {};
|
|
if (as != null) {
|
|
while (am = attr_re.exec(as)) {
|
|
attrs2[am[1]] = escapeXML(am[2]);
|
|
}
|
|
}
|
|
return attrs2;
|
|
}
|
|
while (fm = tag_re.exec(s)) {
|
|
var [_m0, close, ident, attrs, content] = fm;
|
|
if (close) {
|
|
closetop();
|
|
} else if (ident) {
|
|
var node = { type: ident, text: null, children: [], attrs: parseattrs(attrs), obj: null };
|
|
stack.push(node);
|
|
if (attrs) {
|
|
parseattrs(attrs);
|
|
}
|
|
if (openfn) {
|
|
node.obj = openfn(node);
|
|
}
|
|
if (attrs && attrs.endsWith("/"))
|
|
closetop();
|
|
} else if (content != null) {
|
|
if (stack.length == 0)
|
|
throw new XMLParseError("content without element");
|
|
var txt = escapeXML(content).trim();
|
|
if (txt.length)
|
|
stack[stack.length - 1].text = txt;
|
|
}
|
|
}
|
|
if (stack.length != 1)
|
|
throw new XMLParseError("tag not closed");
|
|
if (stack[0].type != "?xml")
|
|
throw new XMLParseError("?xml needs to be first element");
|
|
return top;
|
|
}
|
|
|
|
// src/common/basic/compiler.ts
|
|
var CompileError = class extends Error {
|
|
constructor(msg, loc) {
|
|
super(msg);
|
|
Object.setPrototypeOf(this, CompileError.prototype);
|
|
this.$loc = loc;
|
|
}
|
|
};
|
|
var re_toks = /([0-9.]+[E][+-]?\d+|\d+[.][E0-9]*|[.][E0-9]+)|[0]*(\d+)|&([OH][0-9A-F]+)|(['].*)|([A-Z_]\w*[$]?)|(".*?")|([<>]?[=<>#])|(\*\*)|([-+*/^,;:()\[\]\?\\])|(\S+)|(\s+)/gi;
|
|
var TokenType;
|
|
(function(TokenType3) {
|
|
TokenType3[TokenType3["EOL"] = 0] = "EOL";
|
|
TokenType3[TokenType3["Float"] = 1] = "Float";
|
|
TokenType3[TokenType3["Int"] = 2] = "Int";
|
|
TokenType3[TokenType3["HexOctalInt"] = 3] = "HexOctalInt";
|
|
TokenType3[TokenType3["Remark"] = 4] = "Remark";
|
|
TokenType3[TokenType3["Ident"] = 5] = "Ident";
|
|
TokenType3[TokenType3["String"] = 6] = "String";
|
|
TokenType3[TokenType3["Relational"] = 7] = "Relational";
|
|
TokenType3[TokenType3["DoubleStar"] = 8] = "DoubleStar";
|
|
TokenType3[TokenType3["Operator"] = 9] = "Operator";
|
|
TokenType3[TokenType3["CatchAll"] = 10] = "CatchAll";
|
|
TokenType3[TokenType3["Whitespace"] = 11] = "Whitespace";
|
|
TokenType3[TokenType3["_LAST"] = 12] = "_LAST";
|
|
})(TokenType || (TokenType = {}));
|
|
var OPERATORS = {
|
|
"IMP": { f: "bimp", p: 4 },
|
|
"EQV": { f: "beqv", p: 5 },
|
|
"XOR": { f: "bxor", p: 6 },
|
|
"OR": { f: "bor", p: 7 },
|
|
"AND": { f: "band", p: 8 },
|
|
"||": { f: "lor", p: 17 },
|
|
"&&": { f: "land", p: 18 },
|
|
"=": { f: "eq", p: 50 },
|
|
"==": { f: "eq", p: 50 },
|
|
"<>": { f: "ne", p: 50 },
|
|
"><": { f: "ne", p: 50 },
|
|
"!=": { f: "ne", p: 50 },
|
|
"#": { f: "ne", p: 50 },
|
|
"<": { f: "lt", p: 50 },
|
|
">": { f: "gt", p: 50 },
|
|
"<=": { f: "le", p: 50 },
|
|
">=": { f: "ge", p: 50 },
|
|
"MIN": { f: "min", p: 75 },
|
|
"MAX": { f: "max", p: 75 },
|
|
"+": { f: "add", p: 100 },
|
|
"-": { f: "sub", p: 100 },
|
|
"%": { f: "mod", p: 140 },
|
|
"MOD": { f: "mod", p: 140 },
|
|
"\\": { f: "idiv", p: 150 },
|
|
"*": { f: "mul", p: 200 },
|
|
"/": { f: "div", p: 200 },
|
|
"^": { f: "pow", p: 300 },
|
|
"**": { f: "pow", p: 300 }
|
|
};
|
|
function getOperator(op) {
|
|
return OPERATORS[op];
|
|
}
|
|
function getPrecedence(tok) {
|
|
switch (tok.type) {
|
|
case 9:
|
|
case 8:
|
|
case 7:
|
|
case 5:
|
|
let op = getOperator(tok.str);
|
|
if (op)
|
|
return op.p;
|
|
}
|
|
return -1;
|
|
}
|
|
function isEOS(tok) {
|
|
return tok.type == 0 || tok.type == 4 || tok.str == ":" || tok.str == "ELSE";
|
|
}
|
|
function stripQuotes(s) {
|
|
return s.substr(1, s.length - 2);
|
|
}
|
|
function isLiteral(arg) {
|
|
return arg.value != null;
|
|
}
|
|
function isLookup(arg) {
|
|
return arg.name != null;
|
|
}
|
|
function isBinOp(arg) {
|
|
return arg.op != null && arg.left != null && arg.right != null;
|
|
}
|
|
function isUnOp(arg) {
|
|
return arg.op != null && arg.expr != null;
|
|
}
|
|
function mergeLocs(a, b) {
|
|
return {
|
|
line: Math.min(a.line, b.line),
|
|
start: Math.min(a.start, b.start),
|
|
end: Math.max(a.end, b.end),
|
|
label: a.label || b.label,
|
|
path: a.path || b.path
|
|
};
|
|
}
|
|
var BASICParser = class {
|
|
constructor() {
|
|
this.opts = DIALECTS["DEFAULT"];
|
|
this.maxlinelen = 255;
|
|
this.optionCount = 0;
|
|
this.lineno = 0;
|
|
this.curlabel = null;
|
|
this.stmts = [];
|
|
this.labels = {};
|
|
this.targets = {};
|
|
this.errors = [];
|
|
this.listings = {};
|
|
this.vardefs = {};
|
|
this.varrefs = {};
|
|
this.fnrefs = {};
|
|
this.scopestack = [];
|
|
this.elseifcount = 0;
|
|
}
|
|
addError(msg, loc) {
|
|
var tok = this.lasttoken || this.peekToken();
|
|
if (!loc)
|
|
loc = tok.$loc;
|
|
this.errors.push({ path: loc.path, line: loc.line, label: this.curlabel, start: loc.start, end: loc.end, msg });
|
|
}
|
|
compileError(msg, loc, loc2) {
|
|
this.addError(msg, loc);
|
|
throw new CompileError(msg, loc);
|
|
}
|
|
dialectError(what, loc) {
|
|
this.compileError(`${what} in this dialect of BASIC (${this.opts.dialectName}).`, loc);
|
|
}
|
|
dialectErrorNoSupport(what, loc) {
|
|
this.compileError(`You can't use ${what} in this dialect of BASIC (${this.opts.dialectName}).`, loc);
|
|
}
|
|
consumeToken() {
|
|
var tok = this.lasttoken = this.tokens.shift() || this.eol;
|
|
return tok;
|
|
}
|
|
expectToken(str, msg) {
|
|
var tok = this.consumeToken();
|
|
var tokstr = tok.str;
|
|
if (str != tokstr) {
|
|
this.compileError(msg || `There should be a "${str}" here.`);
|
|
}
|
|
return tok;
|
|
}
|
|
expectTokens(strlist, msg) {
|
|
var tok = this.consumeToken();
|
|
var tokstr = tok.str;
|
|
if (strlist.indexOf(tokstr) < 0) {
|
|
this.compileError(msg || `There should be a ${strlist.map((s) => `"${s}"`).join(" or ")} here.`);
|
|
}
|
|
return tok;
|
|
}
|
|
peekToken(lookahead) {
|
|
var tok = this.tokens[lookahead || 0];
|
|
return tok ? tok : this.eol;
|
|
}
|
|
pushbackToken(tok) {
|
|
this.tokens.unshift(tok);
|
|
}
|
|
parseOptLabel() {
|
|
let tok = this.consumeToken();
|
|
switch (tok.type) {
|
|
case 5:
|
|
if (this.opts.optionalLabels || tok.str == "OPTION") {
|
|
if (this.peekToken().str == ":" && !this.supportsCommand(tok.str)) {
|
|
this.consumeToken();
|
|
} else {
|
|
this.pushbackToken(tok);
|
|
break;
|
|
}
|
|
} else
|
|
this.dialectError(`Each line must begin with a line number`);
|
|
case 2:
|
|
this.addLabel(tok.str);
|
|
return;
|
|
case 3:
|
|
case 1:
|
|
this.compileError(`Line numbers must be positive integers.`);
|
|
break;
|
|
case 9:
|
|
if (this.supportsCommand(tok.str) && this.validKeyword(tok.str)) {
|
|
this.pushbackToken(tok);
|
|
break;
|
|
}
|
|
default:
|
|
if (this.opts.optionalLabels)
|
|
this.compileError(`A line must start with a line number, command, or label.`);
|
|
else
|
|
this.compileError(`A line must start with a line number.`);
|
|
case 4:
|
|
break;
|
|
}
|
|
this.addLabel("#" + this.lineno);
|
|
}
|
|
getPC() {
|
|
return this.stmts.length;
|
|
}
|
|
addStatement(stmt, cmdtok, endtok) {
|
|
if (endtok == null)
|
|
endtok = this.peekToken();
|
|
stmt.$loc = {
|
|
path: cmdtok.$loc.path,
|
|
line: cmdtok.$loc.line,
|
|
start: cmdtok.$loc.start,
|
|
end: endtok.$loc.start,
|
|
label: this.curlabel,
|
|
offset: this.stmts.length
|
|
};
|
|
this.modifyScope(stmt);
|
|
this.stmts.push(stmt);
|
|
}
|
|
addLabel(str, offset) {
|
|
if (this.labels[str] != null)
|
|
this.compileError(`There's a duplicated label named "${str}".`);
|
|
this.labels[str] = this.getPC() + (offset || 0);
|
|
this.curlabel = str;
|
|
this.tokens.forEach((tok) => tok.$loc.label = str);
|
|
}
|
|
parseFile(file, path) {
|
|
this.path = path;
|
|
var txtlines = file.split(/\n|\r\n?/);
|
|
txtlines.forEach((line) => this.parseLine(line));
|
|
var program = { opts: this.opts, stmts: this.stmts, labels: this.labels };
|
|
this.checkAll(program);
|
|
this.listings[path] = this.generateListing(file, program);
|
|
return program;
|
|
}
|
|
parseLine(line) {
|
|
try {
|
|
this.tokenize(line);
|
|
this.parse();
|
|
} catch (e) {
|
|
if (!(e instanceof CompileError))
|
|
throw e;
|
|
}
|
|
}
|
|
_tokenize(line) {
|
|
let splitre = this.opts.optionalWhitespace && new RegExp("(" + this.opts.validKeywords.map((s) => `${s}`).join("|") + ")");
|
|
var lastTokType = 10;
|
|
var m;
|
|
while (m = re_toks.exec(line)) {
|
|
for (var i = 1; i <= lastTokType; i++) {
|
|
let s = m[i];
|
|
if (s != null) {
|
|
let loc = { path: this.path, line: this.lineno, start: m.index, end: m.index + s.length };
|
|
if (this.opts.asciiOnly && !/^[\x00-\x7F]*$/.test(s))
|
|
this.dialectErrorNoSupport(`non-ASCII characters`);
|
|
if (i == 5 || i == 3 || this.opts.uppercaseOnly) {
|
|
s = s.toUpperCase();
|
|
if (s == "DATA")
|
|
lastTokType = 11;
|
|
if (s == "DATA")
|
|
splitre = null;
|
|
if (s == "OPTION")
|
|
splitre = null;
|
|
if (lastTokType == 10 && s.startsWith("REM")) {
|
|
s = "REM";
|
|
lastTokType = 0;
|
|
}
|
|
}
|
|
if (s == "[" || s == "]") {
|
|
if (!this.opts.squareBrackets)
|
|
this.dialectErrorNoSupport(`square brackets`);
|
|
if (s == "[")
|
|
s = "(";
|
|
if (s == "]")
|
|
s = ")";
|
|
}
|
|
if (splitre && i == 5) {
|
|
var splittoks = s.split(splitre).filter((s2) => s2 != "");
|
|
if (splittoks.length > 1) {
|
|
splittoks.forEach((ss) => {
|
|
if (/^[0-9]+$/.test(ss))
|
|
i = 2;
|
|
else if (/^[A-Z_]\w*[$]?$/.test(ss))
|
|
i = 5;
|
|
else
|
|
this.compileError(`Try adding whitespace before "${ss}".`);
|
|
this.tokens.push({ str: ss, type: i, $loc: loc });
|
|
});
|
|
s = null;
|
|
}
|
|
}
|
|
if (s)
|
|
this.tokens.push({ str: s, type: i, $loc: loc });
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
tokenize(line) {
|
|
this.lineno++;
|
|
this.tokens = [];
|
|
this.eol = { type: 0, str: "", $loc: { path: this.path, line: this.lineno, start: line.length } };
|
|
if (line.length > this.maxlinelen)
|
|
this.compileError(`A line should be no more than ${this.maxlinelen} characters long.`);
|
|
this._tokenize(line);
|
|
}
|
|
parse() {
|
|
if (this.tokens.length) {
|
|
this.parseOptLabel();
|
|
if (this.tokens.length) {
|
|
this.parseCompoundStatement();
|
|
}
|
|
var next = this.peekToken();
|
|
if (!isEOS(next))
|
|
this.compileError(`Expected end of line or ':'`, next.$loc);
|
|
this.curlabel = null;
|
|
}
|
|
}
|
|
parseCompoundStatement() {
|
|
if (this.opts.multipleStmtsPerLine) {
|
|
this.parseList(this.parseStatement, ":");
|
|
} else {
|
|
this.parseList(this.parseStatement, "\0");
|
|
if (this.peekToken().str == ":")
|
|
this.dialectErrorNoSupport(`multiple statements on a line`);
|
|
}
|
|
}
|
|
validKeyword(keyword) {
|
|
return this.opts.validKeywords && this.opts.validKeywords.indexOf(keyword) < 0 ? null : keyword;
|
|
}
|
|
validFunction(funcname) {
|
|
return this.opts.validFunctions && this.opts.validFunctions.indexOf(funcname) < 0 ? null : funcname;
|
|
}
|
|
supportsCommand(cmd) {
|
|
if (cmd == "?")
|
|
return this.stmt__PRINT;
|
|
else
|
|
return this["stmt__" + cmd];
|
|
}
|
|
parseStatement() {
|
|
if (this.opts.optionalWhitespace && this.peekToken().str == ":")
|
|
return null;
|
|
var cmdtok = this.consumeToken();
|
|
var cmd = cmdtok.str;
|
|
var stmt;
|
|
switch (cmdtok.type) {
|
|
case 4:
|
|
if (cmdtok.str.startsWith("'") && !this.opts.tickComments)
|
|
this.dialectErrorNoSupport(`tick comments`);
|
|
return null;
|
|
case 9:
|
|
if (cmd == this.validKeyword("?"))
|
|
cmd = "PRINT";
|
|
case 5:
|
|
if (cmd == "REM")
|
|
return null;
|
|
if (cmd == "GO" && this.peekToken().str == "TO") {
|
|
this.consumeToken();
|
|
cmd = "GOTO";
|
|
} else if (cmd == "GO" && this.peekToken().str == "SUB") {
|
|
this.consumeToken();
|
|
cmd = "GOSUB";
|
|
}
|
|
var fn = this.supportsCommand(cmd);
|
|
if (fn) {
|
|
if (this.validKeyword(cmd) == null)
|
|
this.dialectErrorNoSupport(`the ${cmd} statement`);
|
|
stmt = fn.bind(this)();
|
|
break;
|
|
} else if (this.peekToken().str == "=" || this.peekToken().str == "(") {
|
|
if (!this.opts.optionalLet)
|
|
this.dialectError(`Assignments must have a preceding LET`);
|
|
this.pushbackToken(cmdtok);
|
|
stmt = this.stmt__LET();
|
|
break;
|
|
} else {
|
|
this.compileError(`I don't understand the command "${cmd}".`);
|
|
}
|
|
case 0:
|
|
if (this.opts.optionalWhitespace)
|
|
return null;
|
|
default:
|
|
this.compileError(`There should be a command here.`);
|
|
return null;
|
|
}
|
|
if (stmt != null)
|
|
this.addStatement(stmt, cmdtok);
|
|
return stmt;
|
|
}
|
|
modifyScope(stmt) {
|
|
if (this.opts.compiledBlocks) {
|
|
var cmd = stmt.command;
|
|
if (cmd == "FOR" || cmd == "WHILE" || cmd == "SUB") {
|
|
this.scopestack.push(this.getPC());
|
|
} else if (cmd == "NEXT") {
|
|
this.popScope(stmt, "FOR");
|
|
} else if (cmd == "WEND") {
|
|
this.popScope(stmt, "WHILE");
|
|
}
|
|
}
|
|
}
|
|
popScope(close, open) {
|
|
var popidx = this.scopestack.pop();
|
|
var popstmt = popidx != null ? this.stmts[popidx] : null;
|
|
if (popstmt == null)
|
|
this.compileError(`There's a ${close.command} without a matching ${open}.`, close.$loc);
|
|
else if (popstmt.command != open)
|
|
this.compileError(`There's a ${close.command} paired with ${popstmt.command}, but it should be paired with ${open}.`, close.$loc, popstmt.$loc);
|
|
else if (close.command == "NEXT" && !this.opts.optionalNextVar && close.lexpr.name != popstmt.lexpr.name)
|
|
this.compileError(`This NEXT statement is matched with the wrong FOR variable (${close.lexpr.name}).`, close.$loc, popstmt.$loc);
|
|
close.startpc = popidx;
|
|
popstmt.endpc = this.getPC();
|
|
}
|
|
popIfThenScope(nextpc) {
|
|
var popidx = this.scopestack.pop();
|
|
var popstmt = popidx != null ? this.stmts[popidx] : null;
|
|
if (popstmt == null)
|
|
this.compileError(`There's an END IF without a matching IF or ELSE.`);
|
|
if (popstmt.command == "ELSE") {
|
|
popstmt.endpc = this.getPC();
|
|
this.popIfThenScope(popidx + 1);
|
|
} else if (popstmt.command == "IF") {
|
|
popstmt.endpc = nextpc != null ? nextpc : this.getPC();
|
|
} else {
|
|
this.compileError(`There's an END IF paired with a ${popstmt.command}, not IF or ELSE.`, this.lasttoken.$loc, popstmt.$loc);
|
|
}
|
|
}
|
|
parseVarSubscriptOrFunc() {
|
|
var tok = this.consumeToken();
|
|
switch (tok.type) {
|
|
case 5:
|
|
let args = null;
|
|
if (this.peekToken().str == "(") {
|
|
this.expectToken("(");
|
|
args = this.parseExprList();
|
|
this.expectToken(")", `There should be another expression or a ")" here.`);
|
|
}
|
|
var loc = mergeLocs(tok.$loc, this.lasttoken.$loc);
|
|
var valtype = this.exprTypeForSubscript(tok.str, args, loc);
|
|
return { valtype, name: tok.str, args, $loc: loc };
|
|
default:
|
|
this.compileError(`There should be a variable name here.`);
|
|
break;
|
|
}
|
|
}
|
|
parseLexpr() {
|
|
var lexpr = this.parseVarSubscriptOrFunc();
|
|
this.vardefs[lexpr.name] = lexpr;
|
|
this.validateVarName(lexpr);
|
|
return lexpr;
|
|
}
|
|
parseForNextLexpr() {
|
|
var lexpr = this.parseLexpr();
|
|
if (lexpr.args || lexpr.name.endsWith("$"))
|
|
this.compileError(`A FOR ... NEXT loop can only use numeric variables.`, lexpr.$loc);
|
|
return lexpr;
|
|
}
|
|
parseList(parseFunc, delim) {
|
|
var sep;
|
|
var list = [];
|
|
do {
|
|
var el = parseFunc.bind(this)();
|
|
if (el != null)
|
|
list.push(el);
|
|
sep = this.consumeToken();
|
|
} while (sep.str == delim);
|
|
this.pushbackToken(sep);
|
|
return list;
|
|
}
|
|
parseLexprList() {
|
|
return this.parseList(this.parseLexpr, ",");
|
|
}
|
|
parseExprList() {
|
|
return this.parseList(this.parseExpr, ",");
|
|
}
|
|
parseLabelList() {
|
|
return this.parseList(this.parseLabel, ",");
|
|
}
|
|
parseLabel() {
|
|
if (this.opts.computedGoto) {
|
|
var expr = this.parseExpr();
|
|
if (isLiteral(expr))
|
|
this.targets[expr.value] = this.lasttoken.$loc;
|
|
return expr;
|
|
} else {
|
|
var tok = this.consumeToken();
|
|
switch (tok.type) {
|
|
case 5:
|
|
if (!this.opts.optionalLabels)
|
|
this.dialectError(`All labels must be line numbers`);
|
|
case 2:
|
|
var label = tok.str;
|
|
this.targets[label] = tok.$loc;
|
|
return { valtype: "label", value: label };
|
|
default:
|
|
var what = this.opts.optionalLabels ? "label or line number" : "line number";
|
|
this.compileError(`There should be a ${what} here.`);
|
|
}
|
|
}
|
|
}
|
|
parseDatumList() {
|
|
return this.parseList(this.parseDatum, ",");
|
|
}
|
|
parseDatum() {
|
|
var tok = this.consumeToken();
|
|
while (tok.type == 11)
|
|
tok = this.consumeToken();
|
|
if (isEOS(tok))
|
|
this.compileError(`There should be a datum here.`);
|
|
if (tok.type <= 3) {
|
|
return this.parseValue(tok);
|
|
}
|
|
if (tok.str == "-" && this.peekToken().type <= 3) {
|
|
tok = this.consumeToken();
|
|
return { valtype: "number", value: -this.parseValue(tok).value };
|
|
}
|
|
if (tok.str == "+" && this.peekToken().type <= 3) {
|
|
tok = this.consumeToken();
|
|
return this.parseValue(tok);
|
|
}
|
|
var s = "";
|
|
while (!isEOS(tok) && tok.str != ",") {
|
|
s += this.parseValue(tok).value;
|
|
tok = this.consumeToken();
|
|
}
|
|
this.pushbackToken(tok);
|
|
return { valtype: "string", value: s };
|
|
}
|
|
parseValue(tok) {
|
|
switch (tok.type) {
|
|
case 3:
|
|
if (!this.opts.hexOctalConsts)
|
|
this.dialectErrorNoSupport(`hex/octal constants`);
|
|
let base = tok.str.startsWith("H") ? 16 : 8;
|
|
return { valtype: "number", value: parseInt(tok.str.substr(1), base) };
|
|
case 2:
|
|
case 1:
|
|
return { valtype: "number", value: this.parseNumber(tok.str) };
|
|
case 6:
|
|
return { valtype: "string", value: stripQuotes(tok.str) };
|
|
default:
|
|
return { valtype: "string", value: tok.str };
|
|
}
|
|
}
|
|
parsePrimary() {
|
|
let tok = this.consumeToken();
|
|
switch (tok.type) {
|
|
case 3:
|
|
case 2:
|
|
case 1:
|
|
case 6:
|
|
return this.parseValue(tok);
|
|
case 5:
|
|
if (tok.str == "NOT") {
|
|
let expr = this.parsePrimary();
|
|
return { valtype: "number", op: this.opts.bitwiseLogic ? "bnot" : "lnot", expr };
|
|
} else {
|
|
this.pushbackToken(tok);
|
|
return this.parseVarSubscriptOrFunc();
|
|
}
|
|
case 9:
|
|
if (tok.str == "(") {
|
|
let expr = this.parseExpr();
|
|
this.expectToken(")", `There should be another expression or a ")" here.`);
|
|
return expr;
|
|
} else if (tok.str == "-") {
|
|
let expr = this.parsePrimary();
|
|
return { valtype: "number", op: "neg", expr };
|
|
} else if (tok.str == "+") {
|
|
return this.parsePrimary();
|
|
}
|
|
default:
|
|
this.compileError(`The expression is incomplete.`);
|
|
return;
|
|
}
|
|
}
|
|
parseNumber(str) {
|
|
var n = parseFloat(str);
|
|
if (isNaN(n))
|
|
this.compileError(`The number ${str} is not a valid floating-point number.`);
|
|
if (this.opts.checkOverflow && !isFinite(n))
|
|
this.compileError(`The number ${str} is too big to fit into a floating-point value.`);
|
|
return n;
|
|
}
|
|
parseExpr1(left, minPred) {
|
|
let look = this.peekToken();
|
|
while (getPrecedence(look) >= minPred) {
|
|
let op = this.consumeToken();
|
|
if (this.opts.validOperators && this.opts.validOperators.indexOf(op.str) < 0)
|
|
this.dialectErrorNoSupport(`the "${op.str}" operator`);
|
|
let right = this.parsePrimary();
|
|
look = this.peekToken();
|
|
while (getPrecedence(look) > getPrecedence(op)) {
|
|
right = this.parseExpr1(right, getPrecedence(look));
|
|
look = this.peekToken();
|
|
}
|
|
var opfn = getOperator(op.str).f;
|
|
if (!this.opts.bitwiseLogic && op.str == "AND")
|
|
opfn = "land";
|
|
if (!this.opts.bitwiseLogic && op.str == "OR")
|
|
opfn = "lor";
|
|
var valtype = this.exprTypeForOp(opfn, left, right, op);
|
|
left = { valtype, op: opfn, left, right };
|
|
}
|
|
return left;
|
|
}
|
|
parseExpr() {
|
|
var startloc = this.peekToken().$loc;
|
|
var expr = this.parseExpr1(this.parsePrimary(), 0);
|
|
var endloc = this.lasttoken.$loc;
|
|
expr.$loc = mergeLocs(startloc, endloc);
|
|
return expr;
|
|
}
|
|
parseExprWithType(expecttype) {
|
|
var expr = this.parseExpr();
|
|
if (expr.valtype != expecttype)
|
|
this.compileError(`There should be a ${expecttype} here, but this expression evaluates to a ${expr.valtype}.`, expr.$loc);
|
|
return expr;
|
|
}
|
|
validateVarName(lexpr) {
|
|
switch (this.opts.varNaming) {
|
|
case "A":
|
|
if (!/^[A-Z]$/i.test(lexpr.name))
|
|
this.dialectErrorNoSupport(`variable names other than a single letter`);
|
|
break;
|
|
case "A1":
|
|
if (lexpr.args == null && !/^[A-Z][0-9]?[$]?$/i.test(lexpr.name))
|
|
this.dialectErrorNoSupport(`variable names other than a letter followed by an optional digit`);
|
|
if (lexpr.args != null && !/^[A-Z]?[$]?$/i.test(lexpr.name))
|
|
this.dialectErrorNoSupport(`array names other than a single letter`);
|
|
break;
|
|
case "A1$":
|
|
if (!/^[A-Z][0-9]?[$]?$/i.test(lexpr.name))
|
|
this.dialectErrorNoSupport(`variable names other than a letter followed by an optional digit`);
|
|
break;
|
|
case "AA":
|
|
if (lexpr.args == null && !/^[A-Z][A-Z0-9]?[$]?$/i.test(lexpr.name))
|
|
this.dialectErrorNoSupport(`variable names other than a letter followed by an optional letter or digit`);
|
|
break;
|
|
case "*":
|
|
break;
|
|
}
|
|
}
|
|
visitExpr(expr, callback) {
|
|
if (isBinOp(expr)) {
|
|
this.visitExpr(expr.left, callback);
|
|
this.visitExpr(expr.right, callback);
|
|
}
|
|
if (isUnOp(expr)) {
|
|
this.visitExpr(expr.expr, callback);
|
|
}
|
|
if (isLookup(expr) && expr.args != null) {
|
|
for (var arg of expr.args)
|
|
this.visitExpr(arg, callback);
|
|
}
|
|
callback(expr);
|
|
}
|
|
exprTypeForOp(fnname, left, right, optok) {
|
|
if (left.valtype == "string" || right.valtype == "string") {
|
|
if (fnname == "add") {
|
|
if (this.opts.stringConcat)
|
|
return "string";
|
|
else
|
|
this.dialectErrorNoSupport(`the "+" operator to concatenate strings`, optok.$loc);
|
|
} else if (fnname.length != 2)
|
|
this.compileError(`You can't do math on strings until they're converted to numbers.`, optok.$loc);
|
|
}
|
|
return "number";
|
|
}
|
|
exprTypeForSubscript(fnname, args, loc) {
|
|
args = args || [];
|
|
var defs = BUILTIN_MAP[fnname];
|
|
if (defs != null) {
|
|
if (!this.validFunction(fnname))
|
|
this.dialectErrorNoSupport(`the ${fnname} function`, loc);
|
|
for (var def of defs) {
|
|
if (args.length == def.args.length)
|
|
return def.result;
|
|
}
|
|
this.compileError(`The ${fnname} function takes ${def.args.length} arguments, but ${args.length} are given.`, loc);
|
|
}
|
|
this.varrefs[fnname] = loc;
|
|
return fnname.endsWith("$") ? "string" : "number";
|
|
}
|
|
stmt__LET() {
|
|
var lexprs = [this.parseLexpr()];
|
|
this.expectToken("=");
|
|
while (this.opts.chainAssignments && this.peekToken().type == 5 && this.peekToken(1).str == "=") {
|
|
lexprs.push(this.parseLexpr());
|
|
this.expectToken("=");
|
|
}
|
|
var right = this.parseExprWithType(lexprs[0].valtype);
|
|
return { command: "LET", lexprs, right };
|
|
}
|
|
stmt__PRINT() {
|
|
var sep, lastsep;
|
|
var list = [];
|
|
do {
|
|
sep = this.peekToken();
|
|
if (isEOS(sep)) {
|
|
break;
|
|
} else if (sep.str == ";") {
|
|
this.consumeToken();
|
|
lastsep = sep;
|
|
} else if (sep.str == ",") {
|
|
this.consumeToken();
|
|
list.push({ value: " " });
|
|
lastsep = sep;
|
|
} else {
|
|
list.push(this.parseExpr());
|
|
lastsep = null;
|
|
}
|
|
} while (true);
|
|
if (!(lastsep && (lastsep.str == ";" || sep.str != ","))) {
|
|
list.push({ value: "\n" });
|
|
}
|
|
return { command: "PRINT", args: list };
|
|
}
|
|
stmt__GOTO() {
|
|
return this.__GO("GOTO");
|
|
}
|
|
stmt__GOSUB() {
|
|
return this.__GO("GOSUB");
|
|
}
|
|
__GO(cmd) {
|
|
var expr = this.parseLabel();
|
|
if (this.peekToken().str == this.validKeyword("OF")) {
|
|
this.expectToken("OF");
|
|
let newcmd = cmd == "GOTO" ? "ONGOTO" : "ONGOSUB";
|
|
return { command: newcmd, expr, labels: this.parseLabelList() };
|
|
} else {
|
|
return { command: cmd, label: expr };
|
|
}
|
|
}
|
|
stmt__IF() {
|
|
var cmdtok = this.lasttoken;
|
|
var cond = this.parseExprWithType("number");
|
|
var ifstmt = { command: "IF", cond };
|
|
this.addStatement(ifstmt, cmdtok);
|
|
var thengoto = this.expectTokens(["THEN", "GOTO", "GO"]);
|
|
if (thengoto.str == "GO")
|
|
this.expectToken("TO");
|
|
if (this.opts.multilineIfThen && isEOS(this.peekToken())) {
|
|
this.scopestack.push(this.getPC() - 1);
|
|
} else {
|
|
this.parseGotoOrStatements();
|
|
if (this.peekToken().str == "ELSE") {
|
|
this.expectToken("ELSE");
|
|
ifstmt.endpc = this.getPC() + 1;
|
|
this.stmt__ELSE();
|
|
} else {
|
|
ifstmt.endpc = this.getPC();
|
|
}
|
|
}
|
|
}
|
|
stmt__ELSE() {
|
|
var elsestmt = { command: "ELSE" };
|
|
this.addStatement(elsestmt, this.lasttoken);
|
|
var nexttok = this.peekToken();
|
|
if (this.opts.multilineIfThen && isEOS(nexttok)) {
|
|
this.scopestack.push(this.getPC() - 1);
|
|
} else if (this.opts.multilineIfThen && nexttok.str == "IF") {
|
|
this.scopestack.push(this.getPC() - 1);
|
|
this.parseGotoOrStatements();
|
|
this.elseifcount++;
|
|
} else {
|
|
this.parseGotoOrStatements();
|
|
elsestmt.endpc = this.getPC();
|
|
}
|
|
}
|
|
parseGotoOrStatements() {
|
|
var lineno = this.peekToken();
|
|
if (lineno.type == 2) {
|
|
this.parseLabel();
|
|
var gotostmt = { command: "GOTO", label: { valtype: "label", value: lineno.str } };
|
|
this.addStatement(gotostmt, lineno);
|
|
} else {
|
|
this.parseCompoundStatement();
|
|
}
|
|
}
|
|
stmt__FOR() {
|
|
var lexpr = this.parseForNextLexpr();
|
|
this.expectToken("=");
|
|
var init = this.parseExprWithType("number");
|
|
this.expectToken("TO");
|
|
var targ = this.parseExprWithType("number");
|
|
if (this.peekToken().str == "STEP") {
|
|
this.consumeToken();
|
|
var step = this.parseExprWithType("number");
|
|
}
|
|
return { command: "FOR", lexpr, initial: init, target: targ, step };
|
|
}
|
|
stmt__NEXT() {
|
|
var lexpr = null;
|
|
if (!this.opts.optionalNextVar || !isEOS(this.peekToken())) {
|
|
lexpr = this.parseForNextLexpr();
|
|
if (this.opts.multipleNextVars && this.peekToken().str == ",") {
|
|
this.consumeToken();
|
|
this.tokens.unshift({ type: 5, str: "NEXT", $loc: this.peekToken().$loc });
|
|
this.tokens.unshift({ type: 9, str: ":", $loc: this.peekToken().$loc });
|
|
}
|
|
}
|
|
return { command: "NEXT", lexpr };
|
|
}
|
|
stmt__WHILE() {
|
|
var cond = this.parseExprWithType("number");
|
|
return { command: "WHILE", cond };
|
|
}
|
|
stmt__WEND() {
|
|
return { command: "WEND" };
|
|
}
|
|
stmt__DIM() {
|
|
var lexprs = this.parseLexprList();
|
|
lexprs.forEach((arr) => {
|
|
if (arr.args == null || arr.args.length == 0)
|
|
this.compileError(`An array defined by DIM must have at least one dimension.`);
|
|
else if (arr.args.length > this.opts.maxDimensions)
|
|
this.dialectErrorNoSupport(`arrays with more than ${this.opts.maxDimensions} dimensionals`);
|
|
for (var arrdim of arr.args) {
|
|
if (arrdim.valtype != "number")
|
|
this.compileError(`Array dimensions must be numeric.`, arrdim.$loc);
|
|
if (isLiteral(arrdim) && typeof arrdim.value === "number" && arrdim.value < this.opts.defaultArrayBase)
|
|
this.compileError(`An array dimension cannot be less than ${this.opts.defaultArrayBase}.`, arrdim.$loc);
|
|
}
|
|
});
|
|
return { command: "DIM", args: lexprs };
|
|
}
|
|
stmt__INPUT() {
|
|
var prompt = this.consumeToken();
|
|
var promptstr;
|
|
if (prompt.type == 6) {
|
|
this.expectTokens([";", ","]);
|
|
promptstr = stripQuotes(prompt.str);
|
|
} else {
|
|
this.pushbackToken(prompt);
|
|
promptstr = "";
|
|
}
|
|
return { command: "INPUT", prompt: { valtype: "string", value: promptstr }, args: this.parseLexprList() };
|
|
}
|
|
stmt__ENTER() {
|
|
var timeout = this.parseExpr();
|
|
this.expectToken(",");
|
|
var elapsed = this.parseLexpr();
|
|
this.expectToken(",");
|
|
return { command: "INPUT", prompt: null, args: this.parseLexprList(), timeout, elapsed };
|
|
}
|
|
stmt__DATA() {
|
|
return { command: "DATA", datums: this.parseDatumList() };
|
|
}
|
|
stmt__READ() {
|
|
return { command: "READ", args: this.parseLexprList() };
|
|
}
|
|
stmt__RESTORE() {
|
|
var label = null;
|
|
if (this.opts.restoreWithLabel && !isEOS(this.peekToken()))
|
|
label = this.parseLabel();
|
|
return { command: "RESTORE", label };
|
|
}
|
|
stmt__RETURN() {
|
|
return { command: "RETURN" };
|
|
}
|
|
stmt__STOP() {
|
|
return { command: "STOP" };
|
|
}
|
|
stmt__END() {
|
|
if (this.opts.multilineIfThen && this.scopestack.length) {
|
|
let endtok = this.expectTokens(["IF", "SUB"]);
|
|
if (endtok.str == "IF") {
|
|
this.popIfThenScope();
|
|
while (this.elseifcount--)
|
|
this.popIfThenScope();
|
|
this.elseifcount = 0;
|
|
} else if (endtok.str == "SUB") {
|
|
this.addStatement({ command: "RETURN" }, endtok);
|
|
this.popScope({ command: "END" }, "SUB");
|
|
}
|
|
} else {
|
|
return { command: "END" };
|
|
}
|
|
}
|
|
stmt__ON() {
|
|
var expr = this.parseExprWithType("number");
|
|
var gotok = this.consumeToken();
|
|
var cmd = { GOTO: "ONGOTO", THEN: "ONGOTO", GOSUB: "ONGOSUB" }[gotok.str];
|
|
if (!cmd)
|
|
this.compileError(`There should be a GOTO or GOSUB here.`);
|
|
var labels = this.parseLabelList();
|
|
return { command: cmd, expr, labels };
|
|
}
|
|
stmt__DEF() {
|
|
var lexpr = this.parseVarSubscriptOrFunc();
|
|
if (lexpr.args && lexpr.args.length > this.opts.maxDefArgs)
|
|
this.compileError(`There can be no more than ${this.opts.maxDefArgs} arguments to a function or subscript.`, lexpr.$loc);
|
|
if (!lexpr.name.startsWith("FN"))
|
|
this.compileError(`Functions defined with DEF must begin with the letters "FN".`, lexpr.$loc);
|
|
this.markVarDefs(lexpr);
|
|
this.expectToken("=");
|
|
var func = this.parseExpr();
|
|
this.visitExpr(func, (expr) => {
|
|
if (isLookup(expr) && expr.name.startsWith("FN")) {
|
|
if (!this.fnrefs[lexpr.name])
|
|
this.fnrefs[lexpr.name] = [];
|
|
this.fnrefs[lexpr.name].push(expr.name);
|
|
}
|
|
});
|
|
this.checkCallGraph(lexpr.name, new Set());
|
|
return { command: "DEF", lexpr, def: func };
|
|
}
|
|
stmt__SUB() {
|
|
var lexpr = this.parseVarSubscriptOrFunc();
|
|
this.markVarDefs(lexpr);
|
|
this.addLabel(lexpr.name, 1);
|
|
return { command: "SUB", lexpr };
|
|
}
|
|
stmt__CALL() {
|
|
return { command: "CALL", call: this.parseVarSubscriptOrFunc() };
|
|
}
|
|
markVarDefs(lexpr) {
|
|
this.vardefs[lexpr.name] = lexpr;
|
|
if (lexpr.args != null)
|
|
for (let arg of lexpr.args) {
|
|
if (isLookup(arg) && arg.args == null)
|
|
this.vardefs[arg.name] = arg;
|
|
else
|
|
this.compileError(`A definition can only define symbols, not expressions.`);
|
|
}
|
|
}
|
|
checkCallGraph(name, visited) {
|
|
if (visited.has(name))
|
|
this.compileError(`There was a cycle in the function definition graph for ${name}.`);
|
|
visited.add(name);
|
|
var refs = this.fnrefs[name] || [];
|
|
for (var ref of refs)
|
|
this.checkCallGraph(ref, visited);
|
|
visited.delete(name);
|
|
}
|
|
stmt__POP() {
|
|
return { command: "POP" };
|
|
}
|
|
stmt__GET() {
|
|
var lexpr = this.parseLexpr();
|
|
return { command: "GET", lexpr };
|
|
}
|
|
stmt__CLEAR() {
|
|
return { command: "CLEAR" };
|
|
}
|
|
stmt__RANDOMIZE() {
|
|
return { command: "RANDOMIZE" };
|
|
}
|
|
stmt__CHANGE() {
|
|
var src = this.parseExpr();
|
|
this.expectToken("TO");
|
|
var dest = this.parseLexpr();
|
|
if (dest.valtype == src.valtype)
|
|
this.compileError(`CHANGE can only convert strings to numeric arrays, or vice-versa.`, mergeLocs(src.$loc, dest.$loc));
|
|
return { command: "CHANGE", src, dest };
|
|
}
|
|
stmt__CONVERT() {
|
|
var src = this.parseExpr();
|
|
this.expectToken("TO");
|
|
var dest = this.parseLexpr();
|
|
if (dest.valtype == src.valtype)
|
|
this.compileError(`CONVERT can only convert strings to numbers, or vice-versa.`, mergeLocs(src.$loc, dest.$loc));
|
|
return { command: "CONVERT", src, dest };
|
|
}
|
|
stmt__OPTION() {
|
|
this.optionCount++;
|
|
var tokname = this.consumeToken();
|
|
var optname = tokname.str.toUpperCase();
|
|
if (tokname.type != 5)
|
|
this.compileError(`There must be a name after the OPTION statement.`);
|
|
var tokarg = this.consumeToken();
|
|
var arg = tokarg.str.toUpperCase();
|
|
switch (optname) {
|
|
case "DIALECT":
|
|
if (this.optionCount > 1)
|
|
this.compileError(`OPTION DIALECT must be the first OPTION statement in the file.`, tokname.$loc);
|
|
let dname = arg || "";
|
|
if (dname == "")
|
|
this.compileError(`OPTION DIALECT requires a dialect name.`, tokname.$loc);
|
|
let dialect = DIALECTS[dname.toUpperCase()];
|
|
if (dialect)
|
|
this.opts = dialect;
|
|
else
|
|
this.compileError(`${dname} is not a valid dialect.`);
|
|
break;
|
|
case "BASE":
|
|
let base = parseInt(arg);
|
|
if (base == 0 || base == 1)
|
|
this.opts.defaultArrayBase = base;
|
|
else
|
|
this.compileError("OPTION BASE can only be 0 or 1.");
|
|
break;
|
|
case "CPUSPEED":
|
|
if (!(this.opts.commandsPerSec = Math.min(1e7, arg == "MAX" ? Infinity : parseFloat(arg))))
|
|
this.compileError(`OPTION CPUSPEED takes a positive number or MAX.`);
|
|
break;
|
|
default:
|
|
let propname = Object.getOwnPropertyNames(this.opts).find((n) => n.toUpperCase() == optname);
|
|
if (propname == null)
|
|
this.compileError(`${optname} is not a valid option.`, tokname.$loc);
|
|
if (arg == null)
|
|
this.compileError(`OPTION ${optname} requires a parameter.`);
|
|
switch (typeof this.opts[propname]) {
|
|
case "boolean":
|
|
this.opts[propname] = arg.toUpperCase().startsWith("T") || arg > 0;
|
|
return;
|
|
case "number":
|
|
this.opts[propname] = parseFloat(arg);
|
|
return;
|
|
case "string":
|
|
this.opts[propname] = arg;
|
|
return;
|
|
case "object":
|
|
if (Array.isArray(this.opts[propname]) && arg == "ALL") {
|
|
this.opts[propname] = null;
|
|
return;
|
|
}
|
|
this.compileError(`OPTION ${optname} ALL is the only option supported.`);
|
|
}
|
|
break;
|
|
}
|
|
return { command: "OPTION", optname, optargs: [arg] };
|
|
}
|
|
generateListing(file, program) {
|
|
var srclines = [];
|
|
var laststmt;
|
|
program.stmts.forEach((stmt, idx) => {
|
|
laststmt = stmt;
|
|
srclines.push(stmt.$loc);
|
|
});
|
|
if (this.opts.endStmtRequired && (laststmt == null || laststmt.command != "END"))
|
|
this.dialectError(`All programs must have a final END statement`);
|
|
return { lines: srclines };
|
|
}
|
|
getListings() {
|
|
return this.listings;
|
|
}
|
|
checkAll(program) {
|
|
this.checkLabels();
|
|
this.checkScopes();
|
|
this.checkVarRefs();
|
|
}
|
|
checkLabels() {
|
|
for (let targ in this.targets) {
|
|
if (this.labels[targ] == null) {
|
|
var what = this.opts.optionalLabels && isNaN(parseInt(targ)) ? "label named" : "line number";
|
|
this.addError(`There isn't a ${what} ${targ}.`, this.targets[targ]);
|
|
}
|
|
}
|
|
}
|
|
checkScopes() {
|
|
if (this.opts.compiledBlocks && this.scopestack.length) {
|
|
var open = this.stmts[this.scopestack.pop()];
|
|
var close = { FOR: "NEXT", WHILE: "WEND", IF: "END IF", SUB: "END SUB" };
|
|
this.compileError(`Don't forget to add a matching ${close[open.command]} statement.`, open.$loc);
|
|
}
|
|
}
|
|
checkVarRefs() {
|
|
if (!this.opts.defaultValues) {
|
|
for (var varname in this.varrefs) {
|
|
if (this.vardefs[varname] == null)
|
|
this.compileError(`The variable ${varname} isn't defined anywhere in the program.`, this.varrefs[varname]);
|
|
}
|
|
}
|
|
}
|
|
};
|
|
var ECMA55_MINIMAL = {
|
|
dialectName: "ECMA55",
|
|
asciiOnly: true,
|
|
uppercaseOnly: true,
|
|
optionalLabels: false,
|
|
optionalWhitespace: false,
|
|
multipleStmtsPerLine: false,
|
|
varNaming: "A1",
|
|
staticArrays: true,
|
|
sharedArrayNamespace: true,
|
|
defaultArrayBase: 0,
|
|
defaultArraySize: 11,
|
|
defaultValues: false,
|
|
stringConcat: false,
|
|
maxDimensions: 2,
|
|
maxDefArgs: 255,
|
|
maxStringLength: 255,
|
|
tickComments: false,
|
|
hexOctalConsts: false,
|
|
validKeywords: [
|
|
"BASE",
|
|
"DATA",
|
|
"DEF",
|
|
"DIM",
|
|
"END",
|
|
"FOR",
|
|
"GO",
|
|
"GOSUB",
|
|
"GOTO",
|
|
"IF",
|
|
"INPUT",
|
|
"LET",
|
|
"NEXT",
|
|
"ON",
|
|
"OPTION",
|
|
"PRINT",
|
|
"RANDOMIZE",
|
|
"READ",
|
|
"REM",
|
|
"RESTORE",
|
|
"RETURN",
|
|
"STEP",
|
|
"STOP",
|
|
"THEN",
|
|
"TO"
|
|
],
|
|
validFunctions: [
|
|
"ABS",
|
|
"ATN",
|
|
"COS",
|
|
"EXP",
|
|
"INT",
|
|
"LOG",
|
|
"RND",
|
|
"SGN",
|
|
"SIN",
|
|
"SQR",
|
|
"TAB",
|
|
"TAN"
|
|
],
|
|
validOperators: [
|
|
"=",
|
|
"<>",
|
|
"<",
|
|
">",
|
|
"<=",
|
|
">=",
|
|
"+",
|
|
"-",
|
|
"*",
|
|
"/",
|
|
"^"
|
|
],
|
|
printZoneLength: 15,
|
|
numericPadding: true,
|
|
checkOverflow: true,
|
|
testInitialFor: true,
|
|
optionalNextVar: false,
|
|
multipleNextVars: false,
|
|
bitwiseLogic: false,
|
|
checkOnGotoIndex: true,
|
|
computedGoto: false,
|
|
restoreWithLabel: false,
|
|
squareBrackets: false,
|
|
arraysContainChars: false,
|
|
endStmtRequired: true,
|
|
chainAssignments: false,
|
|
optionalLet: false,
|
|
compiledBlocks: true
|
|
};
|
|
var DARTMOUTH_4TH_EDITION = {
|
|
dialectName: "DARTMOUTH4",
|
|
asciiOnly: true,
|
|
uppercaseOnly: true,
|
|
optionalLabels: false,
|
|
optionalWhitespace: false,
|
|
multipleStmtsPerLine: false,
|
|
varNaming: "A1",
|
|
staticArrays: true,
|
|
sharedArrayNamespace: false,
|
|
defaultArrayBase: 0,
|
|
defaultArraySize: 11,
|
|
defaultValues: false,
|
|
stringConcat: false,
|
|
maxDimensions: 2,
|
|
maxDefArgs: 255,
|
|
maxStringLength: 255,
|
|
tickComments: true,
|
|
hexOctalConsts: false,
|
|
validKeywords: [
|
|
"BASE",
|
|
"DATA",
|
|
"DEF",
|
|
"DIM",
|
|
"END",
|
|
"FOR",
|
|
"GO",
|
|
"GOSUB",
|
|
"GOTO",
|
|
"IF",
|
|
"INPUT",
|
|
"LET",
|
|
"NEXT",
|
|
"ON",
|
|
"OPTION",
|
|
"PRINT",
|
|
"RANDOMIZE",
|
|
"READ",
|
|
"REM",
|
|
"RESTORE",
|
|
"RETURN",
|
|
"STEP",
|
|
"STOP",
|
|
"THEN",
|
|
"TO",
|
|
"CHANGE",
|
|
"MAT",
|
|
"RANDOM",
|
|
"RESTORE$",
|
|
"RESTORE*"
|
|
],
|
|
validFunctions: [
|
|
"ABS",
|
|
"ATN",
|
|
"COS",
|
|
"EXP",
|
|
"INT",
|
|
"LOG",
|
|
"RND",
|
|
"SGN",
|
|
"SIN",
|
|
"SQR",
|
|
"TAB",
|
|
"TAN",
|
|
"TRN",
|
|
"INV",
|
|
"DET",
|
|
"NUM",
|
|
"ZER"
|
|
],
|
|
validOperators: [
|
|
"=",
|
|
"<>",
|
|
"<",
|
|
">",
|
|
"<=",
|
|
">=",
|
|
"+",
|
|
"-",
|
|
"*",
|
|
"/",
|
|
"^"
|
|
],
|
|
printZoneLength: 15,
|
|
numericPadding: true,
|
|
checkOverflow: true,
|
|
testInitialFor: true,
|
|
optionalNextVar: false,
|
|
multipleNextVars: false,
|
|
bitwiseLogic: false,
|
|
checkOnGotoIndex: true,
|
|
computedGoto: false,
|
|
restoreWithLabel: false,
|
|
squareBrackets: false,
|
|
arraysContainChars: false,
|
|
endStmtRequired: true,
|
|
chainAssignments: true,
|
|
optionalLet: false,
|
|
compiledBlocks: true
|
|
};
|
|
var TINY_BASIC = {
|
|
dialectName: "TINY",
|
|
asciiOnly: true,
|
|
uppercaseOnly: true,
|
|
optionalLabels: false,
|
|
optionalWhitespace: false,
|
|
multipleStmtsPerLine: false,
|
|
varNaming: "A",
|
|
staticArrays: false,
|
|
sharedArrayNamespace: true,
|
|
defaultArrayBase: 0,
|
|
defaultArraySize: 0,
|
|
defaultValues: true,
|
|
stringConcat: false,
|
|
maxDimensions: 0,
|
|
maxDefArgs: 255,
|
|
maxStringLength: 255,
|
|
tickComments: false,
|
|
hexOctalConsts: false,
|
|
validKeywords: [
|
|
"OPTION",
|
|
"PRINT",
|
|
"IF",
|
|
"THEN",
|
|
"GOTO",
|
|
"INPUT",
|
|
"LET",
|
|
"GOSUB",
|
|
"RETURN",
|
|
"CLEAR",
|
|
"END"
|
|
],
|
|
validFunctions: [],
|
|
validOperators: [
|
|
"=",
|
|
"<>",
|
|
"><",
|
|
"<",
|
|
">",
|
|
"<=",
|
|
">=",
|
|
"+",
|
|
"-",
|
|
"*",
|
|
"/"
|
|
],
|
|
printZoneLength: 1,
|
|
numericPadding: false,
|
|
checkOverflow: false,
|
|
testInitialFor: false,
|
|
optionalNextVar: false,
|
|
multipleNextVars: false,
|
|
bitwiseLogic: false,
|
|
checkOnGotoIndex: false,
|
|
computedGoto: true,
|
|
restoreWithLabel: false,
|
|
squareBrackets: false,
|
|
arraysContainChars: false,
|
|
endStmtRequired: false,
|
|
chainAssignments: false,
|
|
optionalLet: false,
|
|
compiledBlocks: false
|
|
};
|
|
var HP_TIMESHARED_BASIC = {
|
|
dialectName: "HP2000",
|
|
asciiOnly: true,
|
|
uppercaseOnly: true,
|
|
optionalLabels: false,
|
|
optionalWhitespace: false,
|
|
multipleStmtsPerLine: true,
|
|
varNaming: "A1$",
|
|
staticArrays: true,
|
|
sharedArrayNamespace: false,
|
|
defaultArrayBase: 1,
|
|
defaultArraySize: 11,
|
|
defaultValues: false,
|
|
stringConcat: false,
|
|
maxDimensions: 2,
|
|
maxDefArgs: 255,
|
|
maxStringLength: 255,
|
|
tickComments: false,
|
|
hexOctalConsts: false,
|
|
validKeywords: [
|
|
"BASE",
|
|
"DATA",
|
|
"DEF",
|
|
"DIM",
|
|
"END",
|
|
"FOR",
|
|
"GO",
|
|
"GOSUB",
|
|
"GOTO",
|
|
"IF",
|
|
"INPUT",
|
|
"LET",
|
|
"NEXT",
|
|
"OPTION",
|
|
"PRINT",
|
|
"RANDOMIZE",
|
|
"READ",
|
|
"REM",
|
|
"RESTORE",
|
|
"RETURN",
|
|
"STEP",
|
|
"STOP",
|
|
"THEN",
|
|
"TO",
|
|
"ENTER",
|
|
"MAT",
|
|
"CONVERT",
|
|
"OF",
|
|
"IMAGE",
|
|
"USING"
|
|
],
|
|
validFunctions: [
|
|
"ABS",
|
|
"ATN",
|
|
"BRK",
|
|
"COS",
|
|
"CTL",
|
|
"EXP",
|
|
"INT",
|
|
"LEN",
|
|
"LIN",
|
|
"LOG",
|
|
"NUM",
|
|
"POS",
|
|
"RND",
|
|
"SGN",
|
|
"SIN",
|
|
"SPA",
|
|
"SQR",
|
|
"TAB",
|
|
"TAN",
|
|
"TIM",
|
|
"TYP",
|
|
"UPS$",
|
|
"NFORMAT$"
|
|
],
|
|
validOperators: [
|
|
"=",
|
|
"<>",
|
|
"<",
|
|
">",
|
|
"<=",
|
|
">=",
|
|
"+",
|
|
"-",
|
|
"*",
|
|
"/",
|
|
"^",
|
|
"**",
|
|
"#",
|
|
"NOT",
|
|
"AND",
|
|
"OR",
|
|
"MIN",
|
|
"MAX"
|
|
],
|
|
printZoneLength: 15,
|
|
numericPadding: true,
|
|
checkOverflow: false,
|
|
testInitialFor: true,
|
|
optionalNextVar: false,
|
|
multipleNextVars: false,
|
|
bitwiseLogic: false,
|
|
checkOnGotoIndex: false,
|
|
computedGoto: true,
|
|
restoreWithLabel: true,
|
|
squareBrackets: true,
|
|
arraysContainChars: true,
|
|
endStmtRequired: true,
|
|
chainAssignments: true,
|
|
optionalLet: true,
|
|
compiledBlocks: true,
|
|
maxArrayElements: 5e3
|
|
};
|
|
var DEC_BASIC_11 = {
|
|
dialectName: "DEC11",
|
|
asciiOnly: true,
|
|
uppercaseOnly: true,
|
|
optionalLabels: false,
|
|
optionalWhitespace: false,
|
|
multipleStmtsPerLine: false,
|
|
varNaming: "A1",
|
|
staticArrays: true,
|
|
sharedArrayNamespace: false,
|
|
defaultArrayBase: 0,
|
|
defaultArraySize: 11,
|
|
defaultValues: true,
|
|
stringConcat: true,
|
|
maxDimensions: 2,
|
|
maxDefArgs: 255,
|
|
maxStringLength: 255,
|
|
tickComments: false,
|
|
hexOctalConsts: false,
|
|
validKeywords: [
|
|
"OPTION",
|
|
"DATA",
|
|
"DEF",
|
|
"DIM",
|
|
"END",
|
|
"FOR",
|
|
"STEP",
|
|
"GOSUB",
|
|
"GOTO",
|
|
"GO",
|
|
"TO",
|
|
"IF",
|
|
"THEN",
|
|
"INPUT",
|
|
"LET",
|
|
"NEXT",
|
|
"ON",
|
|
"PRINT",
|
|
"RANDOMIZE",
|
|
"READ",
|
|
"REM",
|
|
"RESET",
|
|
"RESTORE",
|
|
"RETURN",
|
|
"STOP"
|
|
],
|
|
validFunctions: [
|
|
"ABS",
|
|
"ATN",
|
|
"COS",
|
|
"EXP",
|
|
"INT",
|
|
"LOG",
|
|
"LOG10",
|
|
"PI",
|
|
"RND",
|
|
"SGN",
|
|
"SIN",
|
|
"SQR",
|
|
"TAB",
|
|
"ASC",
|
|
"BIN",
|
|
"CHR$",
|
|
"CLK$",
|
|
"DAT$",
|
|
"LEN",
|
|
"OCT",
|
|
"POS",
|
|
"SEG$",
|
|
"STR$",
|
|
"TRM$",
|
|
"VAL",
|
|
"NFORMAT$"
|
|
],
|
|
validOperators: [
|
|
"=",
|
|
"<>",
|
|
"><",
|
|
"<",
|
|
">",
|
|
"<=",
|
|
">=",
|
|
"+",
|
|
"-",
|
|
"*",
|
|
"/",
|
|
"^"
|
|
],
|
|
printZoneLength: 14,
|
|
numericPadding: true,
|
|
checkOverflow: true,
|
|
testInitialFor: true,
|
|
optionalNextVar: false,
|
|
multipleNextVars: false,
|
|
bitwiseLogic: false,
|
|
checkOnGotoIndex: true,
|
|
computedGoto: false,
|
|
restoreWithLabel: false,
|
|
squareBrackets: false,
|
|
arraysContainChars: false,
|
|
endStmtRequired: false,
|
|
chainAssignments: false,
|
|
optionalLet: true,
|
|
compiledBlocks: true
|
|
};
|
|
var DEC_BASIC_PLUS = {
|
|
dialectName: "DECPLUS",
|
|
asciiOnly: true,
|
|
uppercaseOnly: false,
|
|
optionalLabels: false,
|
|
optionalWhitespace: false,
|
|
multipleStmtsPerLine: true,
|
|
varNaming: "A1",
|
|
staticArrays: true,
|
|
sharedArrayNamespace: false,
|
|
defaultArrayBase: 0,
|
|
defaultArraySize: 11,
|
|
defaultValues: true,
|
|
stringConcat: true,
|
|
maxDimensions: 2,
|
|
maxDefArgs: 255,
|
|
maxStringLength: 255,
|
|
tickComments: true,
|
|
hexOctalConsts: false,
|
|
validKeywords: [
|
|
"OPTION",
|
|
"REM",
|
|
"LET",
|
|
"DIM",
|
|
"RANDOM",
|
|
"RANDOMIZE",
|
|
"IF",
|
|
"THEN",
|
|
"ELSE",
|
|
"FOR",
|
|
"TO",
|
|
"STEP",
|
|
"WHILE",
|
|
"UNTIL",
|
|
"NEXT",
|
|
"DEF",
|
|
"ON",
|
|
"GOTO",
|
|
"GOSUB",
|
|
"RETURN",
|
|
"CHANGE",
|
|
"READ",
|
|
"DATA",
|
|
"RESTORE",
|
|
"PRINT",
|
|
"USING",
|
|
"INPUT",
|
|
"LINE",
|
|
"NAME",
|
|
"AS",
|
|
"ERROR",
|
|
"RESUME",
|
|
"CHAIN",
|
|
"STOP",
|
|
"END",
|
|
"MAT",
|
|
"UNLESS",
|
|
"SLEEP",
|
|
"WAIT"
|
|
],
|
|
validFunctions: [
|
|
"ABS",
|
|
"ATN",
|
|
"COS",
|
|
"EXP",
|
|
"INT",
|
|
"LOG",
|
|
"LOG10",
|
|
"PI",
|
|
"RND",
|
|
"SGN",
|
|
"SIN",
|
|
"SQR",
|
|
"TAB",
|
|
"TAN",
|
|
"POS",
|
|
"TAB",
|
|
"ASCII",
|
|
"CHR$",
|
|
"CVT%$",
|
|
"CVTF$",
|
|
"CVT$%",
|
|
"CVT$F",
|
|
"LEFT$",
|
|
"RIGHT$",
|
|
"MID$",
|
|
"LEN",
|
|
"INSTR",
|
|
"SPACE$",
|
|
"NUM$",
|
|
"VAL",
|
|
"XLATE",
|
|
"DATE$",
|
|
"TIME$",
|
|
"TIME",
|
|
"ERR",
|
|
"ERL",
|
|
"SWAP%",
|
|
"RAD$",
|
|
"NFORMAT$"
|
|
],
|
|
validOperators: [
|
|
"=",
|
|
"<>",
|
|
"<",
|
|
">",
|
|
"<=",
|
|
">=",
|
|
"+",
|
|
"-",
|
|
"*",
|
|
"/",
|
|
"^",
|
|
"**",
|
|
"==",
|
|
"NOT",
|
|
"AND",
|
|
"OR",
|
|
"XOR",
|
|
"IMP",
|
|
"EQV"
|
|
],
|
|
printZoneLength: 14,
|
|
numericPadding: true,
|
|
checkOverflow: true,
|
|
testInitialFor: true,
|
|
optionalNextVar: false,
|
|
multipleNextVars: false,
|
|
bitwiseLogic: false,
|
|
checkOnGotoIndex: true,
|
|
computedGoto: false,
|
|
restoreWithLabel: false,
|
|
squareBrackets: false,
|
|
arraysContainChars: false,
|
|
endStmtRequired: false,
|
|
chainAssignments: false,
|
|
optionalLet: true,
|
|
compiledBlocks: true
|
|
};
|
|
var BASICODE = {
|
|
dialectName: "BASICODE",
|
|
asciiOnly: true,
|
|
uppercaseOnly: false,
|
|
optionalLabels: false,
|
|
optionalWhitespace: true,
|
|
multipleStmtsPerLine: true,
|
|
varNaming: "AA",
|
|
staticArrays: true,
|
|
sharedArrayNamespace: false,
|
|
defaultArrayBase: 0,
|
|
defaultArraySize: 11,
|
|
defaultValues: false,
|
|
stringConcat: true,
|
|
maxDimensions: 2,
|
|
maxDefArgs: 255,
|
|
maxStringLength: 255,
|
|
tickComments: false,
|
|
hexOctalConsts: false,
|
|
validKeywords: [
|
|
"BASE",
|
|
"DATA",
|
|
"DEF",
|
|
"DIM",
|
|
"END",
|
|
"FOR",
|
|
"GO",
|
|
"GOSUB",
|
|
"GOTO",
|
|
"IF",
|
|
"INPUT",
|
|
"LET",
|
|
"NEXT",
|
|
"ON",
|
|
"OPTION",
|
|
"PRINT",
|
|
"READ",
|
|
"REM",
|
|
"RESTORE",
|
|
"RETURN",
|
|
"STEP",
|
|
"STOP",
|
|
"THEN",
|
|
"TO",
|
|
"AND",
|
|
"NOT",
|
|
"OR"
|
|
],
|
|
validFunctions: [
|
|
"ABS",
|
|
"ASC",
|
|
"ATN",
|
|
"CHR$",
|
|
"COS",
|
|
"EXP",
|
|
"INT",
|
|
"LEFT$",
|
|
"LEN",
|
|
"LOG",
|
|
"MID$",
|
|
"RIGHT$",
|
|
"SGN",
|
|
"SIN",
|
|
"SQR",
|
|
"TAB",
|
|
"TAN",
|
|
"VAL"
|
|
],
|
|
validOperators: [
|
|
"=",
|
|
"<>",
|
|
"<",
|
|
">",
|
|
"<=",
|
|
">=",
|
|
"+",
|
|
"-",
|
|
"*",
|
|
"/",
|
|
"^",
|
|
"AND",
|
|
"NOT",
|
|
"OR"
|
|
],
|
|
printZoneLength: 15,
|
|
numericPadding: true,
|
|
checkOverflow: true,
|
|
testInitialFor: true,
|
|
optionalNextVar: false,
|
|
multipleNextVars: false,
|
|
bitwiseLogic: false,
|
|
checkOnGotoIndex: true,
|
|
computedGoto: false,
|
|
restoreWithLabel: false,
|
|
squareBrackets: false,
|
|
arraysContainChars: false,
|
|
endStmtRequired: false,
|
|
chainAssignments: false,
|
|
optionalLet: true,
|
|
compiledBlocks: false
|
|
};
|
|
var ALTAIR_BASIC41 = {
|
|
dialectName: "ALTAIR41",
|
|
asciiOnly: true,
|
|
uppercaseOnly: true,
|
|
optionalLabels: false,
|
|
optionalWhitespace: true,
|
|
multipleStmtsPerLine: true,
|
|
varNaming: "*",
|
|
staticArrays: false,
|
|
sharedArrayNamespace: true,
|
|
defaultArrayBase: 0,
|
|
defaultArraySize: 11,
|
|
defaultValues: true,
|
|
stringConcat: true,
|
|
maxDimensions: 128,
|
|
maxDefArgs: 255,
|
|
maxStringLength: 255,
|
|
tickComments: false,
|
|
hexOctalConsts: false,
|
|
validKeywords: [
|
|
"OPTION",
|
|
"CONSOLE",
|
|
"DATA",
|
|
"DEF",
|
|
"DEFUSR",
|
|
"DIM",
|
|
"END",
|
|
"ERASE",
|
|
"ERROR",
|
|
"FOR",
|
|
"GOTO",
|
|
"GOSUB",
|
|
"IF",
|
|
"THEN",
|
|
"ELSE",
|
|
"INPUT",
|
|
"LET",
|
|
"LINE",
|
|
"PRINT",
|
|
"LPRINT",
|
|
"USING",
|
|
"NEXT",
|
|
"ON",
|
|
"OUT",
|
|
"POKE",
|
|
"READ",
|
|
"REM",
|
|
"RESTORE",
|
|
"RESUME",
|
|
"RETURN",
|
|
"STOP",
|
|
"SWAP",
|
|
"TROFF",
|
|
"TRON",
|
|
"WAIT",
|
|
"TO",
|
|
"STEP",
|
|
"AND",
|
|
"NOT",
|
|
"OR",
|
|
"XOR",
|
|
"IMP",
|
|
"EQV",
|
|
"MOD",
|
|
"RANDOMIZE"
|
|
],
|
|
validFunctions: [
|
|
"ABS",
|
|
"ASC",
|
|
"ATN",
|
|
"CDBL",
|
|
"CHR$",
|
|
"CINT",
|
|
"COS",
|
|
"ERL",
|
|
"ERR",
|
|
"EXP",
|
|
"FIX",
|
|
"FRE",
|
|
"HEX$",
|
|
"INP",
|
|
"INSTR",
|
|
"INT",
|
|
"LEFT$",
|
|
"LEN",
|
|
"LOG",
|
|
"LPOS",
|
|
"MID$",
|
|
"OCT$",
|
|
"POS",
|
|
"RIGHT$",
|
|
"RND",
|
|
"SGN",
|
|
"SIN",
|
|
"SPACE$",
|
|
"SPC",
|
|
"SQR",
|
|
"STR$",
|
|
"STRING$",
|
|
"TAB",
|
|
"TAN",
|
|
"USR",
|
|
"VAL",
|
|
"VARPTR"
|
|
],
|
|
validOperators: [
|
|
"=",
|
|
"<>",
|
|
"<",
|
|
">",
|
|
"<=",
|
|
">=",
|
|
"+",
|
|
"-",
|
|
"*",
|
|
"/",
|
|
"^",
|
|
"\\",
|
|
"AND",
|
|
"NOT",
|
|
"OR",
|
|
"XOR",
|
|
"IMP",
|
|
"EQV",
|
|
"MOD"
|
|
],
|
|
printZoneLength: 15,
|
|
numericPadding: true,
|
|
checkOverflow: true,
|
|
testInitialFor: false,
|
|
optionalNextVar: true,
|
|
multipleNextVars: true,
|
|
bitwiseLogic: true,
|
|
checkOnGotoIndex: false,
|
|
computedGoto: false,
|
|
restoreWithLabel: false,
|
|
squareBrackets: false,
|
|
arraysContainChars: false,
|
|
endStmtRequired: false,
|
|
chainAssignments: false,
|
|
optionalLet: true,
|
|
compiledBlocks: false
|
|
};
|
|
var APPLESOFT_BASIC = {
|
|
dialectName: "APPLESOFT",
|
|
asciiOnly: true,
|
|
uppercaseOnly: false,
|
|
optionalLabels: false,
|
|
optionalWhitespace: true,
|
|
multipleStmtsPerLine: true,
|
|
varNaming: "*",
|
|
staticArrays: false,
|
|
sharedArrayNamespace: false,
|
|
defaultArrayBase: 0,
|
|
defaultArraySize: 11,
|
|
defaultValues: true,
|
|
stringConcat: true,
|
|
maxDimensions: 88,
|
|
maxDefArgs: 1,
|
|
maxStringLength: 255,
|
|
tickComments: false,
|
|
hexOctalConsts: false,
|
|
validKeywords: [
|
|
"OPTION",
|
|
"CLEAR",
|
|
"LET",
|
|
"DIM",
|
|
"DEF",
|
|
"GOTO",
|
|
"GOSUB",
|
|
"RETURN",
|
|
"ON",
|
|
"POP",
|
|
"FOR",
|
|
"NEXT",
|
|
"IF",
|
|
"THEN",
|
|
"END",
|
|
"STOP",
|
|
"ONERR",
|
|
"RESUME",
|
|
"PRINT",
|
|
"INPUT",
|
|
"GET",
|
|
"HOME",
|
|
"HTAB",
|
|
"VTAB",
|
|
"INVERSE",
|
|
"FLASH",
|
|
"NORMAL",
|
|
"TEXT",
|
|
"GR",
|
|
"COLOR",
|
|
"PLOT",
|
|
"HLIN",
|
|
"VLIN",
|
|
"HGR",
|
|
"HGR2",
|
|
"HPLOT",
|
|
"HCOLOR",
|
|
"AT",
|
|
"DATA",
|
|
"READ",
|
|
"RESTORE",
|
|
"REM",
|
|
"TRACE",
|
|
"NOTRACE",
|
|
"TO",
|
|
"STEP",
|
|
"AND",
|
|
"NOT",
|
|
"OR"
|
|
],
|
|
validFunctions: [
|
|
"ABS",
|
|
"ATN",
|
|
"COS",
|
|
"EXP",
|
|
"INT",
|
|
"LOG",
|
|
"RND",
|
|
"SGN",
|
|
"SIN",
|
|
"SQR",
|
|
"TAN",
|
|
"LEN",
|
|
"LEFT$",
|
|
"MID$",
|
|
"RIGHT$",
|
|
"STR$",
|
|
"VAL",
|
|
"CHR$",
|
|
"ASC",
|
|
"FRE",
|
|
"SCRN",
|
|
"PDL",
|
|
"PEEK",
|
|
"POS"
|
|
],
|
|
validOperators: [
|
|
"=",
|
|
"<>",
|
|
"<",
|
|
">",
|
|
"<=",
|
|
">=",
|
|
"+",
|
|
"-",
|
|
"*",
|
|
"/",
|
|
"^",
|
|
"AND",
|
|
"NOT",
|
|
"OR"
|
|
],
|
|
printZoneLength: 16,
|
|
numericPadding: false,
|
|
checkOverflow: true,
|
|
testInitialFor: false,
|
|
optionalNextVar: true,
|
|
multipleNextVars: true,
|
|
bitwiseLogic: false,
|
|
checkOnGotoIndex: false,
|
|
computedGoto: false,
|
|
restoreWithLabel: false,
|
|
squareBrackets: false,
|
|
arraysContainChars: false,
|
|
endStmtRequired: false,
|
|
chainAssignments: false,
|
|
optionalLet: true,
|
|
compiledBlocks: false
|
|
};
|
|
var BASIC80 = {
|
|
dialectName: "BASIC80",
|
|
asciiOnly: true,
|
|
uppercaseOnly: false,
|
|
optionalLabels: false,
|
|
optionalWhitespace: true,
|
|
multipleStmtsPerLine: true,
|
|
varNaming: "*",
|
|
staticArrays: false,
|
|
sharedArrayNamespace: true,
|
|
defaultArrayBase: 0,
|
|
defaultArraySize: 11,
|
|
defaultValues: true,
|
|
stringConcat: true,
|
|
maxDimensions: 255,
|
|
maxDefArgs: 255,
|
|
maxStringLength: 255,
|
|
tickComments: true,
|
|
hexOctalConsts: true,
|
|
validKeywords: [
|
|
"OPTION",
|
|
"CONSOLE",
|
|
"DATA",
|
|
"DEF",
|
|
"DEFUSR",
|
|
"DIM",
|
|
"END",
|
|
"ERASE",
|
|
"ERROR",
|
|
"FOR",
|
|
"GOTO",
|
|
"GOSUB",
|
|
"IF",
|
|
"THEN",
|
|
"ELSE",
|
|
"INPUT",
|
|
"LET",
|
|
"LINE",
|
|
"PRINT",
|
|
"LPRINT",
|
|
"USING",
|
|
"NEXT",
|
|
"ON",
|
|
"OUT",
|
|
"POKE",
|
|
"READ",
|
|
"REM",
|
|
"RESTORE",
|
|
"RESUME",
|
|
"RETURN",
|
|
"STOP",
|
|
"SWAP",
|
|
"TROFF",
|
|
"TRON",
|
|
"WAIT",
|
|
"CALL",
|
|
"CHAIN",
|
|
"COMMON",
|
|
"WHILE",
|
|
"WEND",
|
|
"WRITE",
|
|
"RANDOMIZE",
|
|
"TO",
|
|
"STEP",
|
|
"AND",
|
|
"NOT",
|
|
"OR",
|
|
"XOR",
|
|
"IMP",
|
|
"EQV",
|
|
"MOD"
|
|
],
|
|
validFunctions: [
|
|
"ABS",
|
|
"ASC",
|
|
"ATN",
|
|
"CDBL",
|
|
"CHR$",
|
|
"CINT",
|
|
"COS",
|
|
"CSNG",
|
|
"CVI",
|
|
"CVS",
|
|
"CVD",
|
|
"EOF",
|
|
"EXP",
|
|
"FIX",
|
|
"FRE",
|
|
"HEX$",
|
|
"INP",
|
|
"INPUT$",
|
|
"INSTR",
|
|
"INT",
|
|
"LEFT$",
|
|
"LEN",
|
|
"LOC",
|
|
"LOG",
|
|
"LPOS",
|
|
"MID$",
|
|
"MKI$",
|
|
"MKS$",
|
|
"MKD$",
|
|
"OCT$",
|
|
"PEEK",
|
|
"POS",
|
|
"RIGHT$",
|
|
"RND",
|
|
"SGN",
|
|
"SIN",
|
|
"SPACE$",
|
|
"SPC",
|
|
"SQR",
|
|
"STR$",
|
|
"STRING$",
|
|
"TAB",
|
|
"TAN",
|
|
"USR",
|
|
"VAL",
|
|
"VARPTR"
|
|
],
|
|
validOperators: [
|
|
"=",
|
|
"<>",
|
|
"<",
|
|
">",
|
|
"<=",
|
|
">=",
|
|
"+",
|
|
"-",
|
|
"*",
|
|
"/",
|
|
"^",
|
|
"\\",
|
|
"AND",
|
|
"NOT",
|
|
"OR",
|
|
"XOR",
|
|
"IMP",
|
|
"EQV",
|
|
"MOD"
|
|
],
|
|
printZoneLength: 14,
|
|
numericPadding: true,
|
|
checkOverflow: false,
|
|
testInitialFor: true,
|
|
optionalNextVar: true,
|
|
multipleNextVars: true,
|
|
bitwiseLogic: true,
|
|
checkOnGotoIndex: false,
|
|
computedGoto: false,
|
|
restoreWithLabel: true,
|
|
squareBrackets: false,
|
|
arraysContainChars: false,
|
|
endStmtRequired: false,
|
|
chainAssignments: false,
|
|
optionalLet: true,
|
|
compiledBlocks: false
|
|
};
|
|
var MODERN_BASIC = {
|
|
dialectName: "MODERN",
|
|
asciiOnly: false,
|
|
uppercaseOnly: false,
|
|
optionalLabels: true,
|
|
optionalWhitespace: false,
|
|
multipleStmtsPerLine: true,
|
|
varNaming: "*",
|
|
staticArrays: false,
|
|
sharedArrayNamespace: false,
|
|
defaultArrayBase: 0,
|
|
defaultArraySize: 0,
|
|
defaultValues: false,
|
|
stringConcat: true,
|
|
maxDimensions: 255,
|
|
maxDefArgs: 255,
|
|
maxStringLength: 2048,
|
|
tickComments: true,
|
|
hexOctalConsts: true,
|
|
validKeywords: null,
|
|
validFunctions: null,
|
|
validOperators: null,
|
|
printZoneLength: 16,
|
|
numericPadding: false,
|
|
checkOverflow: true,
|
|
testInitialFor: true,
|
|
optionalNextVar: true,
|
|
multipleNextVars: true,
|
|
bitwiseLogic: true,
|
|
checkOnGotoIndex: true,
|
|
computedGoto: false,
|
|
restoreWithLabel: true,
|
|
squareBrackets: true,
|
|
arraysContainChars: false,
|
|
endStmtRequired: false,
|
|
chainAssignments: true,
|
|
optionalLet: true,
|
|
compiledBlocks: true,
|
|
multilineIfThen: true
|
|
};
|
|
var BUILTIN_DEFS = [
|
|
["ABS", ["number"], "number"],
|
|
["ASC", ["string"], "number"],
|
|
["ATN", ["number"], "number"],
|
|
["CHR$", ["number"], "string"],
|
|
["CINT", ["number"], "number"],
|
|
["COS", ["number"], "number"],
|
|
["COT", ["number"], "number"],
|
|
["CTL", ["number"], "string"],
|
|
["EXP", ["number"], "number"],
|
|
["FIX", ["number"], "number"],
|
|
["HEX$", ["number"], "string"],
|
|
["INSTR", ["number", "string", "string"], "number"],
|
|
["INSTR", ["string", "string"], "number"],
|
|
["INT", ["number"], "number"],
|
|
["LEFT$", ["string", "number"], "string"],
|
|
["LEN", ["string"], "number"],
|
|
["LIN", ["number"], "string"],
|
|
["LOG", ["number"], "number"],
|
|
["LOG10", ["number"], "number"],
|
|
["MID$", ["string", "number"], "string"],
|
|
["MID$", ["string", "number", "number"], "string"],
|
|
["OCT$", ["number"], "string"],
|
|
["PI", [], "number"],
|
|
["POS", ["number"], "number"],
|
|
["POS", ["string", "string"], "number"],
|
|
["RIGHT$", ["string", "number"], "string"],
|
|
["RND", [], "number"],
|
|
["RND", ["number"], "number"],
|
|
["ROUND", ["number"], "number"],
|
|
["SGN", ["number"], "number"],
|
|
["SIN", ["number"], "number"],
|
|
["SPACE$", ["number"], "string"],
|
|
["SPC", ["number"], "string"],
|
|
["SQR", ["number"], "number"],
|
|
["STR$", ["number"], "string"],
|
|
["STRING$", ["number", "number"], "string"],
|
|
["STRING$", ["number", "string"], "string"],
|
|
["TAB", ["number"], "string"],
|
|
["TAN", ["number"], "number"],
|
|
["TIM", ["number"], "number"],
|
|
["TIMER", [], "number"],
|
|
["UPS$", ["string"], "string"],
|
|
["VAL", ["string"], "number"],
|
|
["LPAD$", ["string", "number"], "string"],
|
|
["RPAD$", ["string", "number"], "string"],
|
|
["NFORMAT$", ["number", "number"], "string"]
|
|
];
|
|
var BUILTIN_MAP = {};
|
|
BUILTIN_DEFS.forEach((def, idx) => {
|
|
let [name, args, result] = def;
|
|
if (!BUILTIN_MAP[name])
|
|
BUILTIN_MAP[name] = [];
|
|
BUILTIN_MAP[name].push({ args, result });
|
|
});
|
|
var DIALECTS = {
|
|
"DEFAULT": MODERN_BASIC,
|
|
"DARTMOUTH": DARTMOUTH_4TH_EDITION,
|
|
"DARTMOUTH4": DARTMOUTH_4TH_EDITION,
|
|
"ALTAIR": ALTAIR_BASIC41,
|
|
"ALTAIR4": ALTAIR_BASIC41,
|
|
"ALTAIR41": ALTAIR_BASIC41,
|
|
"TINY": TINY_BASIC,
|
|
"ECMA55": ECMA55_MINIMAL,
|
|
"MINIMAL": ECMA55_MINIMAL,
|
|
"HP": HP_TIMESHARED_BASIC,
|
|
"HPB": HP_TIMESHARED_BASIC,
|
|
"HPTSB": HP_TIMESHARED_BASIC,
|
|
"HP2000": HP_TIMESHARED_BASIC,
|
|
"HPBASIC": HP_TIMESHARED_BASIC,
|
|
"HPACCESS": HP_TIMESHARED_BASIC,
|
|
"DEC11": DEC_BASIC_11,
|
|
"DEC": DEC_BASIC_PLUS,
|
|
"DECPLUS": DEC_BASIC_PLUS,
|
|
"BASICPLUS": DEC_BASIC_PLUS,
|
|
"BASICODE": BASICODE,
|
|
"APPLESOFT": APPLESOFT_BASIC,
|
|
"BASIC80": BASIC80,
|
|
"MODERN": MODERN_BASIC
|
|
};
|
|
|
|
// src/worker/tools/misc.ts
|
|
function translateShowdown(step) {
|
|
setupRequireFunction();
|
|
load("showdown.min");
|
|
var showdown = emglobal["showdown"];
|
|
var converter = new showdown.Converter({
|
|
tables: "true",
|
|
smoothLivePreview: "true",
|
|
requireSpaceBeforeHeadingText: "true",
|
|
emoji: "true"
|
|
});
|
|
var code = getWorkFileAsString(step.path);
|
|
var html = converter.makeHtml(code);
|
|
delete emglobal["require"];
|
|
return {
|
|
output: html
|
|
};
|
|
}
|
|
function compileInform6(step) {
|
|
loadNative("inform");
|
|
var errors = [];
|
|
gatherFiles(step, { mainFilePath: "main.inf" });
|
|
var objpath = step.prefix + ".z5";
|
|
if (staleFiles(step, [objpath])) {
|
|
var errorMatcher = msvcErrorMatcher(errors);
|
|
var lstout = "";
|
|
var match_fn = (s) => {
|
|
if (s.indexOf("Error:") >= 0) {
|
|
errorMatcher(s);
|
|
} else {
|
|
lstout += s;
|
|
lstout += "\n";
|
|
}
|
|
};
|
|
var args = ["-afjnops", "-v5", "-Cu", "-E1", "-k", "+/share/lib", step.path];
|
|
var inform = emglobal.inform({
|
|
instantiateWasm: moduleInstFn("inform"),
|
|
noInitialRun: true,
|
|
print: match_fn,
|
|
printErr: match_fn
|
|
});
|
|
var FS = inform.FS;
|
|
setupFS(FS, "inform");
|
|
populateFiles(step, FS);
|
|
execMain(step, inform, args);
|
|
if (errors.length)
|
|
return { errors };
|
|
var objout = FS.readFile(objpath, { encoding: "binary" });
|
|
putWorkFile(objpath, objout);
|
|
if (!anyTargetChanged(step, [objpath]))
|
|
return;
|
|
var symbolmap = {};
|
|
var segments = [];
|
|
var entitymap = {
|
|
"object": {},
|
|
"property": {},
|
|
"attribute": {},
|
|
"constant": {},
|
|
"global-variable": {},
|
|
"routine": {}
|
|
};
|
|
var dbgout = FS.readFile("gameinfo.dbg", { encoding: "utf8" });
|
|
var xmlroot = parseXMLPoorly(dbgout);
|
|
var segtype = "ram";
|
|
xmlroot.children.forEach((node) => {
|
|
switch (node.type) {
|
|
case "global-variable":
|
|
case "routine":
|
|
var ident = node.children.find((c, v) => c.type == "identifier").text;
|
|
var address = parseInt(node.children.find((c, v) => c.type == "address").text);
|
|
symbolmap[ident] = address;
|
|
entitymap[node.type][address] = ident;
|
|
break;
|
|
case "object":
|
|
case "property":
|
|
case "attribute":
|
|
var ident = node.children.find((c, v) => c.type == "identifier").text;
|
|
var value = parseInt(node.children.find((c, v) => c.type == "value").text);
|
|
entitymap[node.type][value] = ident;
|
|
break;
|
|
case "story-file-section":
|
|
var name = node.children.find((c, v) => c.type == "type").text;
|
|
var address = parseInt(node.children.find((c, v) => c.type == "address").text);
|
|
var endAddress = parseInt(node.children.find((c, v) => c.type == "end-address").text);
|
|
if (name == "grammar table")
|
|
segtype = "rom";
|
|
segments.push({ name, start: address, size: endAddress - address, type: segtype });
|
|
}
|
|
});
|
|
var listings = {};
|
|
var lines = parseListing(lstout, /\s*(\d+)\s+[+]([0-9a-f]+)\s+([<*>]*)\s*(\w+)\s+(.+)/i, -1, 2, 4);
|
|
var lstpath = step.prefix + ".lst";
|
|
listings[lstpath] = { lines: [], asmlines: lines, text: lstout };
|
|
return {
|
|
output: objout,
|
|
listings,
|
|
errors,
|
|
symbolmap,
|
|
segments,
|
|
debuginfo: entitymap
|
|
};
|
|
}
|
|
}
|
|
function compileBASIC(step) {
|
|
var jsonpath = step.path + ".json";
|
|
gatherFiles(step);
|
|
if (staleFiles(step, [jsonpath])) {
|
|
var parser = new BASICParser();
|
|
var code = getWorkFileAsString(step.path);
|
|
try {
|
|
var ast = parser.parseFile(code, step.path);
|
|
} catch (e) {
|
|
console.log(e);
|
|
if (parser.errors.length == 0)
|
|
throw e;
|
|
}
|
|
if (parser.errors.length) {
|
|
return { errors: parser.errors };
|
|
}
|
|
var json = JSON.stringify(ast, (key, value) => {
|
|
return key == "$loc" ? void 0 : value;
|
|
});
|
|
putWorkFile(jsonpath, json);
|
|
if (anyTargetChanged(step, [jsonpath]))
|
|
return {
|
|
output: ast,
|
|
listings: parser.getListings()
|
|
};
|
|
}
|
|
}
|
|
function compileWiz(step) {
|
|
loadNative("wiz");
|
|
var params = step.params;
|
|
gatherFiles(step, { mainFilePath: "main.wiz" });
|
|
var destpath = step.prefix + (params.wiz_rom_ext || ".bin");
|
|
var errors = [];
|
|
if (staleFiles(step, [destpath])) {
|
|
var wiz = emglobal.wiz({
|
|
instantiateWasm: moduleInstFn("wiz"),
|
|
noInitialRun: true,
|
|
print: print_fn,
|
|
printErr: makeErrorMatcher(errors, /(.+?):(\d+):\s*(.+)/, 2, 3, step.path, 1)
|
|
});
|
|
var FS = wiz.FS;
|
|
setupFS(FS, "wiz");
|
|
populateFiles(step, FS);
|
|
populateExtraFiles(step, FS, params.extra_compile_files);
|
|
const FWDIR = "/share/common";
|
|
var args = [
|
|
"-o",
|
|
destpath,
|
|
"-I",
|
|
FWDIR + "/" + (params.wiz_inc_dir || getRootBasePlatform(step.platform)),
|
|
"-s",
|
|
"wla",
|
|
"--color=none",
|
|
step.path
|
|
];
|
|
args.push("--system", params.wiz_sys_type || params.arch);
|
|
execMain(step, wiz, args);
|
|
if (errors.length)
|
|
return { errors };
|
|
var binout = FS.readFile(destpath, { encoding: "binary" });
|
|
putWorkFile(destpath, binout);
|
|
var dbgout = FS.readFile(step.prefix + ".sym", { encoding: "utf8" });
|
|
var symbolmap = {};
|
|
for (var s of dbgout.split("\n")) {
|
|
var toks = s.split(/ /);
|
|
if (toks && toks.length >= 2) {
|
|
var tokrange = toks[0].split(":");
|
|
var start = parseInt(tokrange[1], 16);
|
|
var sym = toks[1];
|
|
symbolmap[sym] = start;
|
|
}
|
|
}
|
|
return {
|
|
output: binout,
|
|
errors,
|
|
symbolmap
|
|
};
|
|
}
|
|
}
|
|
|
|
// src/worker/tools/cc65.ts
|
|
function parseCA65Listing(asmfn, code, symbols, segments, params, dbg, listings) {
|
|
var _a;
|
|
var segofs = 0;
|
|
var offset = 0;
|
|
var dbgLineMatch = /^([0-9A-F]+)([r]?)\s+(\d+)\s+[.]dbg\s+(\w+), "([^"]+)", (.+)/;
|
|
var funcLineMatch = /"(\w+)", (\w+), "(\w+)"/;
|
|
var insnLineMatch = /^([0-9A-F]+)([r]?)\s{1,2}(\d+)\s{1,2}([0-9A-Frx ]{11})\s+(.*)/;
|
|
var segMatch = /[.]segment\s+"(\w+)"/i;
|
|
var origlines = [];
|
|
var lines = origlines;
|
|
var linenum = 0;
|
|
let curpath = asmfn || "";
|
|
for (var line of code.split(re_crlf)) {
|
|
var dbgm = dbgLineMatch.exec(line);
|
|
if (dbgm && dbgm[1]) {
|
|
var dbgtype = dbgm[4];
|
|
offset = parseInt(dbgm[1], 16);
|
|
curpath = dbgm[5];
|
|
if (curpath && listings) {
|
|
let l = listings[curpath];
|
|
if (!l)
|
|
l = listings[curpath] = { lines: [] };
|
|
lines = l.lines;
|
|
}
|
|
if (dbgtype == "func") {
|
|
var funcm = funcLineMatch.exec(dbgm[6]);
|
|
if (funcm) {
|
|
var funcofs = symbols[funcm[3]];
|
|
if (typeof funcofs === "number") {
|
|
segofs = funcofs - offset;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
if (dbg && dbgm && dbgtype == "line") {
|
|
lines.push({
|
|
path: dbgm[5],
|
|
line: parseInt(dbgm[6]),
|
|
offset: offset + segofs,
|
|
insns: null
|
|
});
|
|
}
|
|
let linem = insnLineMatch.exec(line);
|
|
let topfile = linem && linem[3] == "1";
|
|
if (topfile) {
|
|
let insns = ((_a = linem[4]) == null ? void 0 : _a.trim()) || "";
|
|
if (!(insns != "" && linem[5] == "")) {
|
|
linenum++;
|
|
}
|
|
if (linem[1]) {
|
|
var offset = parseInt(linem[1], 16);
|
|
if (insns.length) {
|
|
if (!dbg) {
|
|
lines.push({
|
|
path: curpath,
|
|
line: linenum,
|
|
offset: offset + segofs,
|
|
insns,
|
|
iscode: true
|
|
});
|
|
}
|
|
} else {
|
|
var sym = null;
|
|
var label = linem[5];
|
|
if (label == null ? void 0 : label.endsWith(":")) {
|
|
sym = label.substring(0, label.length - 1);
|
|
} else if (label == null ? void 0 : label.toLowerCase().startsWith(".proc")) {
|
|
sym = label.split(" ")[1];
|
|
}
|
|
if (sym && !sym.startsWith("@")) {
|
|
var symofs = symbols[sym];
|
|
if (typeof symofs === "number") {
|
|
segofs = symofs - offset;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
return origlines;
|
|
}
|
|
function assembleCA65(step) {
|
|
loadNative("ca65");
|
|
var errors = [];
|
|
gatherFiles(step, { mainFilePath: "main.s" });
|
|
var objpath = step.prefix + ".o";
|
|
var lstpath = step.prefix + ".lst";
|
|
if (staleFiles(step, [objpath, lstpath])) {
|
|
var objout, lstout;
|
|
var CA65 = emglobal.ca65({
|
|
instantiateWasm: moduleInstFn("ca65"),
|
|
noInitialRun: true,
|
|
print: print_fn,
|
|
printErr: makeErrorMatcher(errors, /(.+?):(\d+): (.+)/, 2, 3, step.path, 1)
|
|
});
|
|
var FS = CA65.FS;
|
|
setupFS(FS, "65-" + getRootBasePlatform(step.platform));
|
|
populateFiles(step, FS);
|
|
fixParamsWithDefines(step.path, step.params);
|
|
var args = ["-v", "-g", "-I", "/share/asminc", "-o", objpath, "-l", lstpath, step.path];
|
|
args.unshift.apply(args, ["-D", "__8BITWORKSHOP__=1"]);
|
|
if (step.mainfile) {
|
|
args.unshift.apply(args, ["-D", "__MAIN__=1"]);
|
|
}
|
|
execMain(step, CA65, args);
|
|
if (errors.length) {
|
|
let listings = {};
|
|
return { errors, listings };
|
|
}
|
|
objout = FS.readFile(objpath, { encoding: "binary" });
|
|
lstout = FS.readFile(lstpath, { encoding: "utf8" });
|
|
putWorkFile(objpath, objout);
|
|
putWorkFile(lstpath, lstout);
|
|
}
|
|
return {
|
|
linktool: "ld65",
|
|
files: [objpath, lstpath],
|
|
args: [objpath]
|
|
};
|
|
}
|
|
function linkLD65(step) {
|
|
var _a, _b;
|
|
loadNative("ld65");
|
|
var params = step.params;
|
|
gatherFiles(step);
|
|
var binpath = "main";
|
|
if (staleFiles(step, [binpath])) {
|
|
var errors = [];
|
|
var LD65 = emglobal.ld65({
|
|
instantiateWasm: moduleInstFn("ld65"),
|
|
noInitialRun: true,
|
|
print: print_fn,
|
|
printErr: function(s2) {
|
|
errors.push({ msg: s2, line: 0 });
|
|
}
|
|
});
|
|
var FS = LD65.FS;
|
|
setupFS(FS, "65-" + getRootBasePlatform(step.platform));
|
|
populateFiles(step, FS);
|
|
populateExtraFiles(step, FS, params.extra_link_files);
|
|
if (store.hasFile(params.cfgfile)) {
|
|
populateEntry(FS, params.cfgfile, store.getFileEntry(params.cfgfile), null);
|
|
}
|
|
var libargs = params.libargs || [];
|
|
var cfgfile = params.cfgfile;
|
|
var args = [
|
|
"--cfg-path",
|
|
"/share/cfg",
|
|
"--lib-path",
|
|
"/share/lib",
|
|
"-C",
|
|
cfgfile,
|
|
"-Ln",
|
|
"main.vice",
|
|
"-o",
|
|
"main",
|
|
"-m",
|
|
"main.map"
|
|
].concat(step.args, libargs);
|
|
execMain(step, LD65, args);
|
|
if (errors.length)
|
|
return { errors };
|
|
var aout = FS.readFile("main", { encoding: "binary" });
|
|
var mapout = FS.readFile("main.map", { encoding: "utf8" });
|
|
var viceout = FS.readFile("main.vice", { encoding: "utf8" });
|
|
if (step.platform == "pce" && aout.length > 8192) {
|
|
let newrom = new Uint8Array(aout.length);
|
|
newrom.set(aout.slice(aout.length - 8192), 0);
|
|
newrom.set(aout.slice(0, aout.length - 8192), 8192);
|
|
aout = newrom;
|
|
}
|
|
putWorkFile("main", aout);
|
|
putWorkFile("main.map", mapout);
|
|
putWorkFile("main.vice", viceout);
|
|
if (!anyTargetChanged(step, ["main", "main.map", "main.vice"]))
|
|
return;
|
|
var symbolmap = {};
|
|
for (var s of viceout.split("\n")) {
|
|
var toks = s.split(" ");
|
|
if (toks[0] == "al") {
|
|
let ident = toks[2].substr(1);
|
|
if (ident.length != 5 || !ident.startsWith("L")) {
|
|
let ofs = parseInt(toks[1], 16);
|
|
symbolmap[ident] = ofs;
|
|
}
|
|
}
|
|
}
|
|
var segments = [];
|
|
segments.push({ name: "CPU Stack", start: 256, size: 256, type: "ram" });
|
|
segments.push({ name: "CPU Vectors", start: 65530, size: 6, type: "rom" });
|
|
let re_seglist = /(\w+)\s+([0-9A-F]+)\s+([0-9A-F]+)\s+([0-9A-F]+)\s+([0-9A-F]+)/;
|
|
let parseseglist = false;
|
|
let m;
|
|
for (let s2 of mapout.split("\n")) {
|
|
if (parseseglist && (m = re_seglist.exec(s2))) {
|
|
let seg = m[1];
|
|
let start = parseInt(m[2], 16);
|
|
let size = parseInt(m[4], 16);
|
|
let type = "";
|
|
if (seg.startsWith("CODE") || seg == "STARTUP" || seg == "RODATA" || seg.endsWith("ROM"))
|
|
type = "rom";
|
|
else if (seg == "ZP" || seg == "DATA" || seg == "BSS" || seg.endsWith("RAM"))
|
|
type = "ram";
|
|
segments.push({ name: seg, start, size, type });
|
|
}
|
|
if (s2 == "Segment list:")
|
|
parseseglist = true;
|
|
if (s2 == "")
|
|
parseseglist = false;
|
|
}
|
|
var listings = {};
|
|
for (var fn of step.files) {
|
|
if (fn.endsWith(".lst")) {
|
|
var lstout = FS.readFile(fn, { encoding: "utf8" });
|
|
lstout = lstout.split("\n\n")[1] || lstout;
|
|
putWorkFile(fn, lstout);
|
|
let isECS = ((_b = (_a = step.debuginfo) == null ? void 0 : _a.systems) == null ? void 0 : _b.Init) != null;
|
|
if (isECS) {
|
|
var asmlines = [];
|
|
var srclines = parseCA65Listing(fn, lstout, symbolmap, segments, params, true, listings);
|
|
listings[fn] = {
|
|
lines: [],
|
|
text: lstout
|
|
};
|
|
} else {
|
|
var asmlines = parseCA65Listing(fn, lstout, symbolmap, segments, params, false);
|
|
var srclines = parseCA65Listing("", lstout, symbolmap, segments, params, true);
|
|
listings[fn] = {
|
|
asmlines: srclines.length ? asmlines : null,
|
|
lines: srclines.length ? srclines : asmlines,
|
|
text: lstout
|
|
};
|
|
}
|
|
}
|
|
}
|
|
return {
|
|
output: aout,
|
|
listings,
|
|
errors,
|
|
symbolmap,
|
|
segments
|
|
};
|
|
}
|
|
}
|
|
function compileCC65(step) {
|
|
loadNative("cc65");
|
|
var params = step.params;
|
|
var re_err1 = /(.*?):(\d+): (.+)/;
|
|
var errors = [];
|
|
var errline = 0;
|
|
function match_fn(s) {
|
|
console.log(s);
|
|
var matches = re_err1.exec(s);
|
|
if (matches) {
|
|
errline = parseInt(matches[2]);
|
|
errors.push({
|
|
line: errline,
|
|
msg: matches[3],
|
|
path: matches[1]
|
|
});
|
|
}
|
|
}
|
|
gatherFiles(step, { mainFilePath: "main.c" });
|
|
var destpath = step.prefix + ".s";
|
|
if (staleFiles(step, [destpath])) {
|
|
var CC65 = emglobal.cc65({
|
|
instantiateWasm: moduleInstFn("cc65"),
|
|
noInitialRun: true,
|
|
print: print_fn,
|
|
printErr: match_fn
|
|
});
|
|
var FS = CC65.FS;
|
|
setupFS(FS, "65-" + getRootBasePlatform(step.platform));
|
|
populateFiles(step, FS);
|
|
fixParamsWithDefines(step.path, params);
|
|
var args = [
|
|
"-I",
|
|
"/share/include",
|
|
"-I",
|
|
".",
|
|
"-D",
|
|
"__8BITWORKSHOP__"
|
|
];
|
|
if (params.define) {
|
|
params.define.forEach((x) => args.push("-D" + x));
|
|
}
|
|
if (step.mainfile) {
|
|
args.unshift.apply(args, ["-D", "__MAIN__"]);
|
|
}
|
|
var customArgs = params.extra_compiler_args || ["-T", "-g", "-Oirs", "-Cl", "-W", "-pointer-sign,-no-effect"];
|
|
args = args.concat(customArgs, args);
|
|
args.push(step.path);
|
|
execMain(step, CC65, args);
|
|
if (errors.length)
|
|
return { errors };
|
|
var asmout = FS.readFile(destpath, { encoding: "utf8" });
|
|
putWorkFile(destpath, asmout);
|
|
}
|
|
return {
|
|
nexttool: "ca65",
|
|
path: destpath,
|
|
args: [destpath],
|
|
files: [destpath]
|
|
};
|
|
}
|
|
|
|
// src/worker/tools/dasm.ts
|
|
function parseDASMListing(lstpath, lsttext, listings, errors, unresolved) {
|
|
let lineMatch = /\s*(\d+)\s+(\S+)\s+([0-9a-f]+)\s+([?0-9a-f][?0-9a-f ]+)?\s+(.+)?/i;
|
|
let equMatch = /\bequ\b/i;
|
|
let macroMatch = /\bMAC\s+(\S+)?/i;
|
|
let lastline = 0;
|
|
let macros = {};
|
|
let lstline = 0;
|
|
let lstlist = listings[lstpath];
|
|
for (let line of lsttext.split(re_crlf)) {
|
|
lstline++;
|
|
let linem = lineMatch.exec(line + " ");
|
|
if (linem && linem[1] != null) {
|
|
let linenum = parseInt(linem[1]);
|
|
let filename = linem[2];
|
|
let offset = parseInt(linem[3], 16);
|
|
let insns = linem[4];
|
|
let restline = linem[5];
|
|
if (insns && insns.startsWith("?"))
|
|
insns = null;
|
|
if (lstlist && lstlist.lines) {
|
|
lstlist.lines.push({
|
|
line: lstline,
|
|
offset,
|
|
insns,
|
|
iscode: true
|
|
});
|
|
}
|
|
let lst = listings[filename];
|
|
if (lst) {
|
|
var lines = lst.lines;
|
|
let macmatch = macroMatch.exec(restline);
|
|
if (macmatch) {
|
|
macros[macmatch[1]] = { line: parseInt(linem[1]), file: linem[2].toLowerCase() };
|
|
} else if (insns && restline && !restline.match(equMatch)) {
|
|
lines.push({
|
|
line: linenum,
|
|
offset,
|
|
insns,
|
|
iscode: restline[0] != "."
|
|
});
|
|
}
|
|
lastline = linenum;
|
|
} else {
|
|
let mac = macros[filename.toLowerCase()];
|
|
if (mac && linenum == 0) {
|
|
lines.push({
|
|
line: lastline + 1,
|
|
offset,
|
|
insns,
|
|
iscode: true
|
|
});
|
|
}
|
|
if (insns && mac) {
|
|
let maclst = listings[mac.file];
|
|
if (maclst && maclst.lines) {
|
|
maclst.lines.push({
|
|
path: mac.file,
|
|
line: mac.line + linenum,
|
|
offset,
|
|
insns,
|
|
iscode: true
|
|
});
|
|
}
|
|
} else {
|
|
if (insns && linem[3] && lastline > 0) {
|
|
lines.push({
|
|
line: lastline + 1,
|
|
offset,
|
|
insns: null
|
|
});
|
|
}
|
|
}
|
|
}
|
|
for (let key in unresolved) {
|
|
let l = restline || line;
|
|
let pos = l.indexOf(key);
|
|
if (pos >= 0) {
|
|
let cmt = l.indexOf(";");
|
|
if (cmt < 0 || cmt > pos) {
|
|
if (new RegExp("\\b" + key + "\\b").exec(l)) {
|
|
errors.push({
|
|
path: filename,
|
|
line: linenum,
|
|
msg: "Unresolved symbol '" + key + "'"
|
|
});
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
let errm = re_msvc.exec(line);
|
|
if (errm) {
|
|
errors.push({
|
|
path: errm[1],
|
|
line: parseInt(errm[2]),
|
|
msg: errm[4]
|
|
});
|
|
}
|
|
}
|
|
}
|
|
function assembleDASM(step) {
|
|
load("dasm");
|
|
var re_usl = /(\w+)\s+0000\s+[?][?][?][?]/;
|
|
var unresolved = {};
|
|
var errors = [];
|
|
var errorMatcher = msvcErrorMatcher(errors);
|
|
function match_fn(s2) {
|
|
var matches = re_usl.exec(s2);
|
|
if (matches) {
|
|
var key = matches[1];
|
|
if (key != "NO_ILLEGAL_OPCODES") {
|
|
unresolved[matches[1]] = 0;
|
|
}
|
|
} else if (s2.startsWith("Warning:")) {
|
|
errors.push({ line: 0, msg: s2.substr(9) });
|
|
} else if (s2.startsWith("unable ")) {
|
|
errors.push({ line: 0, msg: s2 });
|
|
} else if (s2.startsWith("segment: ")) {
|
|
errors.push({ line: 0, msg: "Segment overflow: " + s2.substring(9) });
|
|
} else if (s2.toLowerCase().indexOf("error:") >= 0) {
|
|
errors.push({ line: 0, msg: s2.trim() });
|
|
} else {
|
|
errorMatcher(s2);
|
|
}
|
|
}
|
|
var Module = emglobal.DASM({
|
|
noInitialRun: true,
|
|
print: match_fn
|
|
});
|
|
var FS = Module.FS;
|
|
populateFiles(step, FS, {
|
|
mainFilePath: "main.a"
|
|
});
|
|
var binpath = step.prefix + ".bin";
|
|
var lstpath = step.prefix + ".lst";
|
|
var sympath = step.prefix + ".sym";
|
|
execMain(step, Module, [
|
|
step.path,
|
|
"-f3",
|
|
"-l" + lstpath,
|
|
"-o" + binpath,
|
|
"-s" + sympath
|
|
]);
|
|
var alst = FS.readFile(lstpath, { "encoding": "utf8" });
|
|
var listings = {};
|
|
for (let path of step.files) {
|
|
listings[path] = { lines: [] };
|
|
}
|
|
parseDASMListing(lstpath, alst, listings, errors, unresolved);
|
|
if (errors.length) {
|
|
return { errors };
|
|
}
|
|
var aout, asym;
|
|
aout = FS.readFile(binpath);
|
|
try {
|
|
asym = FS.readFile(sympath, { "encoding": "utf8" });
|
|
} catch (e) {
|
|
console.log(e);
|
|
errors.push({ line: 0, msg: "No symbol table generated, maybe segment overflow?" });
|
|
return { errors };
|
|
}
|
|
putWorkFile(binpath, aout);
|
|
putWorkFile(lstpath, alst);
|
|
putWorkFile(sympath, asym);
|
|
if (!anyTargetChanged(step, [binpath]))
|
|
return;
|
|
var symbolmap = {};
|
|
for (var s of asym.split("\n")) {
|
|
var toks = s.split(/\s+/);
|
|
if (toks && toks.length >= 2 && !toks[0].startsWith("-")) {
|
|
symbolmap[toks[0]] = parseInt(toks[1], 16);
|
|
}
|
|
}
|
|
if (step["bblines"]) {
|
|
let lst = listings[step.path];
|
|
if (lst) {
|
|
lst.asmlines = lst.lines;
|
|
lst.text = alst;
|
|
lst.lines = [];
|
|
}
|
|
}
|
|
return {
|
|
output: aout,
|
|
listings,
|
|
errors,
|
|
symbolmap
|
|
};
|
|
}
|
|
function preprocessBatariBasic(code) {
|
|
load("bbpreprocess");
|
|
var bbout = "";
|
|
function addbbout_fn(s) {
|
|
bbout += s;
|
|
bbout += "\n";
|
|
}
|
|
var BBPRE = emglobal.preprocess({
|
|
noInitialRun: true,
|
|
print: addbbout_fn,
|
|
printErr: print_fn,
|
|
noFSInit: true
|
|
});
|
|
var FS = BBPRE.FS;
|
|
setupStdin(FS, code);
|
|
BBPRE.callMain([]);
|
|
console.log("preprocess " + code.length + " -> " + bbout.length + " bytes");
|
|
return bbout;
|
|
}
|
|
function compileBatariBasic(step) {
|
|
load("bb2600basic");
|
|
var params = step.params;
|
|
var asmout = "";
|
|
function addasmout_fn(s) {
|
|
asmout += s;
|
|
asmout += "\n";
|
|
}
|
|
var re_err1 = /[(](\d+)[)]:?\s*(.+)/;
|
|
var errors = [];
|
|
var errline = 0;
|
|
function match_fn(s) {
|
|
console.log(s);
|
|
var matches = re_err1.exec(s);
|
|
if (matches) {
|
|
errline = parseInt(matches[1]);
|
|
errors.push({
|
|
line: errline,
|
|
msg: matches[2]
|
|
});
|
|
}
|
|
}
|
|
gatherFiles(step, { mainFilePath: "main.bas" });
|
|
var destpath = step.prefix + ".asm";
|
|
if (staleFiles(step, [destpath])) {
|
|
var BB = emglobal.bb2600basic({
|
|
noInitialRun: true,
|
|
print: addasmout_fn,
|
|
printErr: match_fn,
|
|
noFSInit: true,
|
|
TOTAL_MEMORY: 64 * 1024 * 1024
|
|
});
|
|
var FS = BB.FS;
|
|
populateFiles(step, FS);
|
|
var code = getWorkFileAsString(step.path);
|
|
code = preprocessBatariBasic(code);
|
|
setupStdin(FS, code);
|
|
setupFS(FS, "2600basic");
|
|
execMain(step, BB, ["-i", "/share", step.path]);
|
|
if (errors.length)
|
|
return { errors };
|
|
var includesout = FS.readFile("includes.bB", { encoding: "utf8" });
|
|
var redefsout = FS.readFile("2600basic_variable_redefs.h", { encoding: "utf8" });
|
|
var includes = includesout.trim().split("\n");
|
|
var combinedasm = "";
|
|
var splitasm = asmout.split("bB.asm file is split here");
|
|
for (var incfile of includes) {
|
|
var inctext;
|
|
if (incfile == "bB.asm")
|
|
inctext = splitasm[0];
|
|
else if (incfile == "bB2.asm")
|
|
inctext = splitasm[1];
|
|
else
|
|
inctext = FS.readFile("/share/includes/" + incfile, { encoding: "utf8" });
|
|
console.log(incfile, inctext.length);
|
|
combinedasm += "\n\n;;;" + incfile + "\n\n";
|
|
combinedasm += inctext;
|
|
}
|
|
putWorkFile(destpath, combinedasm);
|
|
putWorkFile("2600basic.h", FS.readFile("/share/includes/2600basic.h"));
|
|
putWorkFile("2600basic_variable_redefs.h", redefsout);
|
|
}
|
|
return {
|
|
nexttool: "dasm",
|
|
path: destpath,
|
|
args: [destpath],
|
|
files: [destpath, "2600basic.h", "2600basic_variable_redefs.h"],
|
|
bblines: true
|
|
};
|
|
}
|
|
|
|
// src/worker/tools/sdcc.ts
|
|
function hexToArray(s, ofs) {
|
|
var buf = new ArrayBuffer(s.length / 2);
|
|
var arr = new Uint8Array(buf);
|
|
for (var i = 0; i < arr.length; i++) {
|
|
arr[i] = parseInt(s.slice(i * 2 + ofs, i * 2 + ofs + 2), 16);
|
|
}
|
|
return arr;
|
|
}
|
|
function parseIHX(ihx, rom_start, rom_size, errors) {
|
|
var output = new Uint8Array(new ArrayBuffer(rom_size));
|
|
var high_size = 0;
|
|
for (var s of ihx.split("\n")) {
|
|
if (s[0] == ":") {
|
|
var arr = hexToArray(s, 1);
|
|
var count = arr[0];
|
|
var address = (arr[1] << 8) + arr[2] - rom_start;
|
|
var rectype = arr[3];
|
|
if (rectype == 0) {
|
|
for (var i = 0; i < count; i++) {
|
|
var b = arr[4 + i];
|
|
output[i + address] = b;
|
|
}
|
|
if (i + address > high_size)
|
|
high_size = i + address;
|
|
} else if (rectype == 1) {
|
|
break;
|
|
} else {
|
|
console.log(s);
|
|
}
|
|
}
|
|
}
|
|
if (high_size > rom_size) {
|
|
}
|
|
return output;
|
|
}
|
|
function assembleSDASZ80(step) {
|
|
loadNative("sdasz80");
|
|
var objout, lstout, symout;
|
|
var errors = [];
|
|
gatherFiles(step, { mainFilePath: "main.asm" });
|
|
var objpath = step.prefix + ".rel";
|
|
var lstpath = step.prefix + ".lst";
|
|
if (staleFiles(step, [objpath, lstpath])) {
|
|
var match_asm_re1 = / in line (\d+) of (\S+)/;
|
|
var match_asm_re2 = / <\w> (.+)/;
|
|
var errline = 0;
|
|
var errpath = step.path;
|
|
var match_asm_fn = (s) => {
|
|
var m = match_asm_re1.exec(s);
|
|
if (m) {
|
|
errline = parseInt(m[1]);
|
|
errpath = m[2];
|
|
} else {
|
|
m = match_asm_re2.exec(s);
|
|
if (m) {
|
|
errors.push({
|
|
line: errline,
|
|
path: errpath,
|
|
msg: m[1]
|
|
});
|
|
}
|
|
}
|
|
};
|
|
var ASZ80 = emglobal.sdasz80({
|
|
instantiateWasm: moduleInstFn("sdasz80"),
|
|
noInitialRun: true,
|
|
print: match_asm_fn,
|
|
printErr: match_asm_fn
|
|
});
|
|
var FS = ASZ80.FS;
|
|
populateFiles(step, FS);
|
|
execMain(step, ASZ80, ["-plosgffwy", step.path]);
|
|
if (errors.length) {
|
|
return { errors };
|
|
}
|
|
objout = FS.readFile(objpath, { encoding: "utf8" });
|
|
lstout = FS.readFile(lstpath, { encoding: "utf8" });
|
|
putWorkFile(objpath, objout);
|
|
putWorkFile(lstpath, lstout);
|
|
}
|
|
return {
|
|
linktool: "sdldz80",
|
|
files: [objpath, lstpath],
|
|
args: [objpath]
|
|
};
|
|
}
|
|
function linkSDLDZ80(step) {
|
|
loadNative("sdldz80");
|
|
var errors = [];
|
|
gatherFiles(step);
|
|
var binpath = "main.ihx";
|
|
if (staleFiles(step, [binpath])) {
|
|
var match_aslink_re = /\?ASlink-(\w+)-(.+)/;
|
|
var match_aslink_fn = (s2) => {
|
|
var matches = match_aslink_re.exec(s2);
|
|
if (matches) {
|
|
errors.push({
|
|
line: 0,
|
|
msg: matches[2]
|
|
});
|
|
}
|
|
};
|
|
var params = step.params;
|
|
var LDZ80 = emglobal.sdldz80({
|
|
instantiateWasm: moduleInstFn("sdldz80"),
|
|
noInitialRun: true,
|
|
print: match_aslink_fn,
|
|
printErr: match_aslink_fn
|
|
});
|
|
var FS = LDZ80.FS;
|
|
setupFS(FS, "sdcc");
|
|
populateFiles(step, FS);
|
|
populateExtraFiles(step, FS, params.extra_link_files);
|
|
if (step.platform.startsWith("coleco")) {
|
|
FS.writeFile("crt0.rel", FS.readFile("/share/lib/coleco/crt0.rel", { encoding: "utf8" }));
|
|
FS.writeFile("crt0.lst", "\n");
|
|
}
|
|
var args = [
|
|
"-mjwxyu",
|
|
"-i",
|
|
"main.ihx",
|
|
"-b",
|
|
"_CODE=0x" + params.code_start.toString(16),
|
|
"-b",
|
|
"_DATA=0x" + params.data_start.toString(16),
|
|
"-k",
|
|
"/share/lib/z80",
|
|
"-l",
|
|
"z80"
|
|
];
|
|
if (params.extra_link_args)
|
|
args.push.apply(args, params.extra_link_args);
|
|
args.push.apply(args, step.args);
|
|
execMain(step, LDZ80, args);
|
|
var hexout = FS.readFile("main.ihx", { encoding: "utf8" });
|
|
var noiout = FS.readFile("main.noi", { encoding: "utf8" });
|
|
putWorkFile("main.ihx", hexout);
|
|
putWorkFile("main.noi", noiout);
|
|
if (!anyTargetChanged(step, ["main.ihx", "main.noi"]))
|
|
return;
|
|
var binout = parseIHX(hexout, params.rom_start !== void 0 ? params.rom_start : params.code_start, params.rom_size, errors);
|
|
if (errors.length) {
|
|
return { errors };
|
|
}
|
|
var listings = {};
|
|
for (var fn of step.files) {
|
|
if (fn.endsWith(".lst")) {
|
|
var rstout = FS.readFile(fn.replace(".lst", ".rst"), { encoding: "utf8" });
|
|
var asmlines = parseListing(rstout, /^\s*([0-9A-F]{4})\s+([0-9A-F][0-9A-F r]*[0-9A-F])\s+\[([0-9 ]+)\]?\s+(\d+) (.*)/i, 4, 1, 2, 3);
|
|
var srclines = parseSourceLines(rstout, /^\s+\d+ ;<stdin>:(\d+):/i, /^\s*([0-9A-F]{4})/i);
|
|
putWorkFile(fn, rstout);
|
|
listings[fn] = {
|
|
asmlines: srclines.length ? asmlines : null,
|
|
lines: srclines.length ? srclines : asmlines,
|
|
text: rstout
|
|
};
|
|
}
|
|
}
|
|
var symbolmap = {};
|
|
for (var s of noiout.split("\n")) {
|
|
var toks = s.split(" ");
|
|
if (toks[0] == "DEF" && !toks[1].startsWith("A$")) {
|
|
symbolmap[toks[1]] = parseInt(toks[2], 16);
|
|
}
|
|
}
|
|
var seg_re = /^s__(\w+)$/;
|
|
var segments = [];
|
|
for (let ident in symbolmap) {
|
|
let m = seg_re.exec(ident);
|
|
if (m) {
|
|
let seg = m[1];
|
|
let segstart = symbolmap[ident];
|
|
let segsize = symbolmap["l__" + seg];
|
|
if (segstart >= 0 && segsize > 0) {
|
|
var type = null;
|
|
if (["INITIALIZER", "GSINIT", "GSFINAL"].includes(seg))
|
|
type = "rom";
|
|
else if (seg.startsWith("CODE"))
|
|
type = "rom";
|
|
else if (["DATA", "INITIALIZED"].includes(seg))
|
|
type = "ram";
|
|
if (type == "rom" || segstart > 0)
|
|
segments.push({ name: seg, start: segstart, size: segsize, type });
|
|
}
|
|
}
|
|
}
|
|
return {
|
|
output: binout,
|
|
listings,
|
|
errors,
|
|
symbolmap,
|
|
segments
|
|
};
|
|
}
|
|
}
|
|
function compileSDCC(step) {
|
|
gatherFiles(step, {
|
|
mainFilePath: "main.c"
|
|
});
|
|
var outpath = step.prefix + ".asm";
|
|
if (staleFiles(step, [outpath])) {
|
|
var errors = [];
|
|
var params = step.params;
|
|
loadNative("sdcc");
|
|
var SDCC = emglobal.sdcc({
|
|
instantiateWasm: moduleInstFn("sdcc"),
|
|
noInitialRun: true,
|
|
noFSInit: true,
|
|
print: print_fn,
|
|
printErr: msvcErrorMatcher(errors)
|
|
});
|
|
var FS = SDCC.FS;
|
|
populateFiles(step, FS);
|
|
var code = getWorkFileAsString(step.path);
|
|
var preproc = preprocessMCPP(step, "sdcc");
|
|
if (preproc.errors) {
|
|
return { errors: preproc.errors };
|
|
} else
|
|
code = preproc.code;
|
|
setupStdin(FS, code);
|
|
setupFS(FS, "sdcc");
|
|
var args = [
|
|
"--vc",
|
|
"--std-sdcc99",
|
|
"-mz80",
|
|
"--c1mode",
|
|
"--less-pedantic",
|
|
"-o",
|
|
outpath
|
|
];
|
|
if (!/^\s*#pragma\s+opt_code/m.exec(code)) {
|
|
args.push.apply(args, [
|
|
"--oldralloc",
|
|
"--no-peep",
|
|
"--nolospre"
|
|
]);
|
|
}
|
|
if (params.extra_compile_args) {
|
|
args.push.apply(args, params.extra_compile_args);
|
|
}
|
|
execMain(step, SDCC, args);
|
|
if (errors.length) {
|
|
return { errors };
|
|
}
|
|
var asmout = FS.readFile(outpath, { encoding: "utf8" });
|
|
asmout = " .area _HOME\n .area _CODE\n .area _INITIALIZER\n .area _DATA\n .area _INITIALIZED\n .area _BSEG\n .area _BSS\n .area _HEAP\n" + asmout;
|
|
putWorkFile(outpath, asmout);
|
|
}
|
|
return {
|
|
nexttool: "sdasz80",
|
|
path: outpath,
|
|
args: [outpath],
|
|
files: [outpath]
|
|
};
|
|
}
|
|
|
|
// src/worker/assembler.ts
|
|
var isError = (o) => o.error !== void 0;
|
|
function hex2(v, nd) {
|
|
try {
|
|
if (!nd)
|
|
nd = 2;
|
|
if (nd == 8) {
|
|
return hex2(v >> 16 & 65535, 4) + hex2(v & 65535, 4);
|
|
}
|
|
var s = v.toString(16).toUpperCase();
|
|
while (s.length < nd)
|
|
s = "0" + s;
|
|
return s;
|
|
} catch (e) {
|
|
return v + "";
|
|
}
|
|
}
|
|
function stringToData(s) {
|
|
var data = [];
|
|
for (var i = 0; i < s.length; i++) {
|
|
data[i] = s.charCodeAt(i);
|
|
}
|
|
return data;
|
|
}
|
|
var Assembler = class {
|
|
constructor(spec) {
|
|
this.ip = 0;
|
|
this.origin = 0;
|
|
this.linenum = 0;
|
|
this.symbols = {};
|
|
this.errors = [];
|
|
this.outwords = [];
|
|
this.asmlines = [];
|
|
this.fixups = [];
|
|
this.width = 8;
|
|
this.codelen = 0;
|
|
this.aborted = false;
|
|
this.spec = spec;
|
|
if (spec) {
|
|
this.preprocessRules();
|
|
}
|
|
}
|
|
rule2regex(rule, vars) {
|
|
var s = rule.fmt;
|
|
if (!s || !(typeof s === "string"))
|
|
throw Error('Each rule must have a "fmt" string field');
|
|
if (!rule.bits || !(rule.bits instanceof Array))
|
|
throw Error('Each rule must have a "bits" array field');
|
|
var varlist = [];
|
|
rule.prefix = s.split(/\s+/)[0];
|
|
s = s.replace(/\+/g, "\\+");
|
|
s = s.replace(/\*/g, "\\*");
|
|
s = s.replace(/\s+/g, "\\s+");
|
|
s = s.replace(/\[/g, "\\[");
|
|
s = s.replace(/\]/g, "\\]");
|
|
s = s.replace(/\(/g, "\\(");
|
|
s = s.replace(/\)/g, "\\)");
|
|
s = s.replace(/\./g, "\\.");
|
|
s = s.replace(/~\w+/g, (varname) => {
|
|
varname = varname.substr(1);
|
|
var v = vars[varname];
|
|
varlist.push(varname);
|
|
if (!v)
|
|
throw Error('Could not find variable definition for "~' + varname + '"');
|
|
else if (v.toks)
|
|
return "(\\w+)";
|
|
else
|
|
return "([0-9]+|[$][0-9a-f]+|\\w+)";
|
|
});
|
|
try {
|
|
rule.re = new RegExp("^" + s + "$", "i");
|
|
} catch (e) {
|
|
throw Error('Bad regex for rule "' + rule.fmt + '": /' + s + "/ -- " + e);
|
|
}
|
|
rule.varlist = varlist;
|
|
return rule;
|
|
}
|
|
preprocessRules() {
|
|
if (this.spec.width) {
|
|
this.width = this.spec.width || 8;
|
|
}
|
|
for (var rule of this.spec.rules) {
|
|
this.rule2regex(rule, this.spec.vars);
|
|
}
|
|
}
|
|
warning(msg, line) {
|
|
this.errors.push({ msg, line: line ? line : this.linenum });
|
|
}
|
|
fatal(msg, line) {
|
|
this.warning(msg, line);
|
|
this.aborted = true;
|
|
}
|
|
fatalIf(msg, line) {
|
|
if (msg)
|
|
this.fatal(msg, line);
|
|
}
|
|
addBytes(result) {
|
|
this.asmlines.push({
|
|
line: this.linenum,
|
|
offset: this.ip,
|
|
nbits: result.nbits
|
|
});
|
|
var op = result.opcode;
|
|
var nb = result.nbits / this.width;
|
|
for (var i = 0; i < nb; i++) {
|
|
if (this.width < 32)
|
|
this.outwords[this.ip++ - this.origin] = op >> (nb - 1 - i) * this.width & (1 << this.width) - 1;
|
|
else
|
|
this.outwords[this.ip++ - this.origin] = op;
|
|
}
|
|
}
|
|
addWords(data) {
|
|
this.asmlines.push({
|
|
line: this.linenum,
|
|
offset: this.ip,
|
|
nbits: this.width * data.length
|
|
});
|
|
for (var i = 0; i < data.length; i++) {
|
|
if (this.width < 32)
|
|
this.outwords[this.ip++ - this.origin] = data[i] & (1 << this.width) - 1;
|
|
else
|
|
this.outwords[this.ip++ - this.origin] = data[i];
|
|
}
|
|
}
|
|
parseData(toks) {
|
|
var data = [];
|
|
for (var i = 0; i < toks.length; i++) {
|
|
data[i] = this.parseConst(toks[i]);
|
|
}
|
|
return data;
|
|
}
|
|
alignIP(align) {
|
|
if (align < 1 || align > this.codelen)
|
|
this.fatal("Invalid alignment value");
|
|
else
|
|
this.ip = Math.floor((this.ip + align - 1) / align) * align;
|
|
}
|
|
parseConst(s, nbits) {
|
|
if (s && s[0] == "$")
|
|
return parseInt(s.substr(1), 16);
|
|
else
|
|
return parseInt(s);
|
|
}
|
|
swapEndian(x, nbits) {
|
|
var y = 0;
|
|
while (nbits > 0) {
|
|
var n = Math.min(nbits, this.width);
|
|
var mask = (1 << n) - 1;
|
|
y <<= n;
|
|
y |= x & mask;
|
|
x >>>= n;
|
|
nbits -= n;
|
|
}
|
|
return y;
|
|
}
|
|
buildInstruction(rule, m) {
|
|
var opcode = 0;
|
|
var oplen = 0;
|
|
for (let b of rule.bits) {
|
|
let n, x;
|
|
if (typeof b === "string") {
|
|
n = b.length;
|
|
x = parseInt(b, 2);
|
|
} else {
|
|
var index = typeof b === "number" ? b : b.a;
|
|
var id = m[index + 1];
|
|
var v = this.spec.vars[rule.varlist[index]];
|
|
if (!v) {
|
|
return { error: `Could not find matching identifier for '${m[0]}' index ${index}` };
|
|
}
|
|
n = v.bits;
|
|
var shift = 0;
|
|
if (typeof b !== "number") {
|
|
n = b.n;
|
|
shift = b.b;
|
|
}
|
|
if (v.toks) {
|
|
x = v.toks.indexOf(id);
|
|
if (x < 0)
|
|
return { error: "Can't use '" + id + "' here, only one of: " + v.toks.join(", ") };
|
|
} else {
|
|
x = this.parseConst(id, n);
|
|
if (isNaN(x)) {
|
|
this.fixups.push({
|
|
sym: id,
|
|
ofs: this.ip,
|
|
size: v.bits,
|
|
line: this.linenum,
|
|
dstlen: n,
|
|
dstofs: oplen,
|
|
srcofs: shift,
|
|
endian: v.endian,
|
|
iprel: !!v.iprel,
|
|
ipofs: v.ipofs + 0,
|
|
ipmul: v.ipmul || 1
|
|
});
|
|
x = 0;
|
|
} else {
|
|
var mask = (1 << v.bits) - 1;
|
|
if ((x & mask) != x)
|
|
return { error: "Value " + x + " does not fit in " + v.bits + " bits" };
|
|
}
|
|
}
|
|
if (v.endian == "little")
|
|
x = this.swapEndian(x, v.bits);
|
|
if (typeof b !== "number") {
|
|
x = x >>> shift & (1 << b.n) - 1;
|
|
}
|
|
}
|
|
opcode = opcode << n | x;
|
|
oplen += n;
|
|
}
|
|
if (oplen == 0)
|
|
this.warning("Opcode had zero length");
|
|
else if (oplen > 32)
|
|
this.warning("Opcodes > 32 bits not supported");
|
|
else if (oplen % this.width != 0)
|
|
this.warning("Opcode was not word-aligned (" + oplen + " bits)");
|
|
return { opcode, nbits: oplen };
|
|
}
|
|
loadArch(arch) {
|
|
if (this.loadJSON) {
|
|
var json = this.loadJSON(arch + ".json");
|
|
if (json && json.vars && json.rules) {
|
|
this.spec = json;
|
|
this.preprocessRules();
|
|
} else {
|
|
return "Could not load arch file '" + arch + ".json'";
|
|
}
|
|
}
|
|
}
|
|
parseDirective(tokens) {
|
|
var cmd = tokens[0].toLowerCase();
|
|
if (cmd == ".define")
|
|
this.symbols[tokens[1].toLowerCase()] = { value: tokens[2] };
|
|
else if (cmd == ".org")
|
|
this.ip = this.origin = parseInt(tokens[1]);
|
|
else if (cmd == ".len")
|
|
this.codelen = parseInt(tokens[1]);
|
|
else if (cmd == ".width")
|
|
this.width = parseInt(tokens[1]);
|
|
else if (cmd == ".arch")
|
|
this.fatalIf(this.loadArch(tokens[1]));
|
|
else if (cmd == ".include")
|
|
this.fatalIf(this.loadInclude(tokens[1]));
|
|
else if (cmd == ".module")
|
|
this.fatalIf(this.loadModule(tokens[1]));
|
|
else if (cmd == ".data")
|
|
this.addWords(this.parseData(tokens.slice(1)));
|
|
else if (cmd == ".string")
|
|
this.addWords(stringToData(tokens.slice(1).join(" ")));
|
|
else if (cmd == ".align")
|
|
this.alignIP(this.parseConst(tokens[1]));
|
|
else
|
|
this.warning("Unrecognized directive: " + tokens);
|
|
}
|
|
assemble(line) {
|
|
this.linenum++;
|
|
line = line.replace(/[;].*/g, "").trim();
|
|
if (line[0] == ".") {
|
|
var tokens = line.split(/\s+/);
|
|
this.parseDirective(tokens);
|
|
return;
|
|
}
|
|
line = line.toLowerCase();
|
|
line = line.replace(/(\w+):/, (_label, label) => {
|
|
this.symbols[label] = { value: this.ip };
|
|
return "";
|
|
});
|
|
line = line.trim();
|
|
if (line == "")
|
|
return;
|
|
if (!this.spec) {
|
|
this.fatal("Need to load .arch first");
|
|
return;
|
|
}
|
|
var lastError;
|
|
for (var rule of this.spec.rules) {
|
|
var m = rule.re.exec(line);
|
|
if (m) {
|
|
var result = this.buildInstruction(rule, m);
|
|
if (!isError(result)) {
|
|
this.addBytes(result);
|
|
return result;
|
|
} else {
|
|
lastError = result.error;
|
|
}
|
|
}
|
|
}
|
|
this.warning(lastError ? lastError : "Could not decode instruction: " + line);
|
|
}
|
|
applyFixup(fix, sym) {
|
|
var ofs = fix.ofs + Math.floor(fix.dstofs / this.width);
|
|
var mask = (1 << fix.size) - 1;
|
|
var value = this.parseConst(sym.value + "", fix.dstlen);
|
|
if (fix.iprel)
|
|
value = (value - fix.ofs) * fix.ipmul - fix.ipofs;
|
|
if (fix.srcofs == 0 && (value > mask || value < -mask))
|
|
this.warning("Symbol " + fix.sym + " (" + value + ") does not fit in " + fix.dstlen + " bits", fix.line);
|
|
if (fix.srcofs > 0)
|
|
value >>>= fix.srcofs;
|
|
value &= (1 << fix.dstlen) - 1;
|
|
if (this.width == 32) {
|
|
var shift = 32 - fix.dstofs - fix.dstlen;
|
|
value <<= shift;
|
|
}
|
|
if (fix.size <= this.width) {
|
|
this.outwords[ofs - this.origin] ^= value;
|
|
} else {
|
|
if (fix.endian == "big")
|
|
value = this.swapEndian(value, fix.size);
|
|
while (value) {
|
|
if (value & this.outwords[ofs - this.origin]) {
|
|
this.warning("Instruction bits overlapped: " + hex2(this.outwords[ofs - this.origin], 8), hex2(value, 8));
|
|
} else {
|
|
this.outwords[ofs - this.origin] ^= value & (1 << this.width) - 1;
|
|
}
|
|
value >>>= this.width;
|
|
ofs++;
|
|
}
|
|
}
|
|
}
|
|
finish() {
|
|
for (var i = 0; i < this.fixups.length; i++) {
|
|
var fix = this.fixups[i];
|
|
var sym = this.symbols[fix.sym];
|
|
if (sym) {
|
|
this.applyFixup(fix, sym);
|
|
} else {
|
|
this.warning("Symbol '" + fix.sym + "' not found");
|
|
}
|
|
}
|
|
for (var i = 0; i < this.asmlines.length; i++) {
|
|
var al = this.asmlines[i];
|
|
al.insns = "";
|
|
for (var j = 0; j < al.nbits / this.width; j++) {
|
|
var word = this.outwords[al.offset + j - this.origin];
|
|
if (j > 0)
|
|
al.insns += " ";
|
|
al.insns += hex2(word, this.width / 4);
|
|
}
|
|
}
|
|
while (this.outwords.length < this.codelen) {
|
|
this.outwords.push(0);
|
|
}
|
|
this.fixups = [];
|
|
return this.state();
|
|
}
|
|
assembleFile(text) {
|
|
var lines = text.split(/\n/g);
|
|
for (var i = 0; i < lines.length && !this.aborted; i++) {
|
|
try {
|
|
this.assemble(lines[i]);
|
|
} catch (e) {
|
|
console.log(e);
|
|
this.fatal("Exception during assembly: " + e);
|
|
}
|
|
}
|
|
return this.finish();
|
|
}
|
|
state() {
|
|
return {
|
|
ip: this.ip,
|
|
line: this.linenum,
|
|
origin: this.origin,
|
|
codelen: this.codelen,
|
|
intermediate: {},
|
|
output: this.outwords,
|
|
lines: this.asmlines,
|
|
errors: this.errors,
|
|
fixups: this.fixups
|
|
};
|
|
}
|
|
};
|
|
|
|
// src/common/hdl/hdltypes.ts
|
|
function isVarDecl(arg) {
|
|
return typeof arg.isParam !== "undefined";
|
|
}
|
|
function isConstExpr(arg) {
|
|
return typeof arg.cvalue === "number";
|
|
}
|
|
|
|
// src/common/hdl/vxmlparser.ts
|
|
var CompileError2 = class extends Error {
|
|
constructor($loc, msg) {
|
|
super(msg);
|
|
this.$loc = $loc;
|
|
Object.setPrototypeOf(this, CompileError2.prototype);
|
|
}
|
|
};
|
|
var VerilogXMLParser = class {
|
|
constructor() {
|
|
this.files = {};
|
|
this.dtypes = {};
|
|
this.modules = {};
|
|
this.hierarchies = {};
|
|
this.cur_deferred = [];
|
|
this.dtypes["QData"] = { left: 63, right: 0, signed: false };
|
|
this.dtypes["IData"] = { left: 31, right: 0, signed: false };
|
|
this.dtypes["SData"] = { left: 15, right: 0, signed: false };
|
|
this.dtypes["CData"] = { left: 7, right: 0, signed: false };
|
|
this.dtypes["byte"] = { left: 7, right: 0, signed: true };
|
|
this.dtypes["shortint"] = { left: 15, right: 0, signed: true };
|
|
this.dtypes["int"] = { left: 31, right: 0, signed: true };
|
|
this.dtypes["integer"] = { left: 31, right: 0, signed: true };
|
|
this.dtypes["longint"] = { left: 63, right: 0, signed: true };
|
|
this.dtypes["time"] = { left: 63, right: 0, signed: false };
|
|
}
|
|
defer(fn) {
|
|
this.cur_deferred.unshift(fn);
|
|
}
|
|
defer2(fn) {
|
|
this.cur_deferred.push(fn);
|
|
}
|
|
run_deferred() {
|
|
this.cur_deferred.forEach((fn) => fn());
|
|
this.cur_deferred = [];
|
|
}
|
|
name2js(s) {
|
|
if (s == null)
|
|
throw new CompileError2(this.cur_loc, `no name`);
|
|
return s.replace(/[^a-z0-9_]/gi, "$");
|
|
}
|
|
findChildren(node, type, required) {
|
|
var arr = node.children.filter((n) => n.type == type);
|
|
if (arr.length == 0 && required)
|
|
throw new CompileError2(this.cur_loc, `no child of type ${type}`);
|
|
return arr;
|
|
}
|
|
parseSourceLocation(node) {
|
|
var loc = node.attrs["loc"];
|
|
if (loc) {
|
|
if (loc == this.cur_loc_str) {
|
|
return this.cur_loc;
|
|
} else {
|
|
var [fileid, line, col, end_line, end_col] = loc.split(",");
|
|
var $loc = {
|
|
hdlfile: this.files[fileid],
|
|
path: this.files[fileid].filename,
|
|
line: parseInt(line),
|
|
start: parseInt(col) - 1,
|
|
end_line: parseInt(end_line),
|
|
end: parseInt(end_col) - 1
|
|
};
|
|
this.cur_loc = $loc;
|
|
this.cur_loc_str = loc;
|
|
return $loc;
|
|
}
|
|
} else {
|
|
return null;
|
|
}
|
|
}
|
|
open_module(node) {
|
|
var module = {
|
|
$loc: this.parseSourceLocation(node),
|
|
name: node.attrs["name"],
|
|
origName: node.attrs["origName"],
|
|
blocks: [],
|
|
instances: [],
|
|
vardefs: {}
|
|
};
|
|
if (this.cur_module)
|
|
throw new CompileError2(this.cur_loc, `nested modules not supported`);
|
|
this.cur_module = module;
|
|
return module;
|
|
}
|
|
deferDataType(node, def) {
|
|
var dtype_id = node.attrs["dtype_id"];
|
|
if (dtype_id != null) {
|
|
this.defer(() => {
|
|
def.dtype = this.dtypes[dtype_id];
|
|
if (!def.dtype) {
|
|
throw new CompileError2(this.cur_loc, `Unknown data type ${dtype_id} for ${node.type}`);
|
|
}
|
|
});
|
|
}
|
|
}
|
|
parseConstValue(s) {
|
|
const re_const = /(\d+)'([s]?)h([0-9a-f]+)/i;
|
|
var m = re_const.exec(s);
|
|
if (m) {
|
|
var numstr = m[3];
|
|
if (numstr.length <= 8)
|
|
return parseInt(numstr, 16);
|
|
else
|
|
return BigInt("0x" + numstr);
|
|
} else {
|
|
throw new CompileError2(this.cur_loc, `could not parse constant "${s}"`);
|
|
}
|
|
}
|
|
resolveVar(s, mod) {
|
|
var def = mod.vardefs[s];
|
|
if (def == null)
|
|
throw new CompileError2(this.cur_loc, `could not resolve variable "${s}"`);
|
|
return def;
|
|
}
|
|
resolveModule(s) {
|
|
var mod = this.modules[s];
|
|
if (mod == null)
|
|
throw new CompileError2(this.cur_loc, `could not resolve module "${s}"`);
|
|
return mod;
|
|
}
|
|
visit_verilator_xml(node) {
|
|
}
|
|
visit_package(node) {
|
|
}
|
|
visit_module(node) {
|
|
this.findChildren(node, "var", false).forEach((n) => {
|
|
if (isVarDecl(n.obj)) {
|
|
this.cur_module.vardefs[n.obj.name] = n.obj;
|
|
}
|
|
});
|
|
this.modules[this.cur_module.name] = this.cur_module;
|
|
this.cur_module = null;
|
|
}
|
|
visit_var(node) {
|
|
var name = node.attrs["name"];
|
|
name = this.name2js(name);
|
|
var vardef = {
|
|
$loc: this.parseSourceLocation(node),
|
|
name,
|
|
origName: node.attrs["origName"],
|
|
isInput: node.attrs["dir"] == "input",
|
|
isOutput: node.attrs["dir"] == "output",
|
|
isParam: node.attrs["param"] == "true",
|
|
dtype: null
|
|
};
|
|
this.deferDataType(node, vardef);
|
|
var const_nodes = this.findChildren(node, "const", false);
|
|
if (const_nodes.length) {
|
|
vardef.constValue = const_nodes[0].obj;
|
|
}
|
|
var init_nodes = this.findChildren(node, "initarray", false);
|
|
if (init_nodes.length) {
|
|
vardef.initValue = init_nodes[0].obj;
|
|
}
|
|
return vardef;
|
|
}
|
|
visit_const(node) {
|
|
var name = node.attrs["name"];
|
|
var cvalue = this.parseConstValue(name);
|
|
var constdef = {
|
|
$loc: this.parseSourceLocation(node),
|
|
dtype: null,
|
|
cvalue: typeof cvalue === "number" ? cvalue : null,
|
|
bigvalue: typeof cvalue === "bigint" ? cvalue : null
|
|
};
|
|
this.deferDataType(node, constdef);
|
|
return constdef;
|
|
}
|
|
visit_varref(node) {
|
|
var name = node.attrs["name"];
|
|
name = this.name2js(name);
|
|
var varref = {
|
|
$loc: this.parseSourceLocation(node),
|
|
dtype: null,
|
|
refname: name
|
|
};
|
|
this.deferDataType(node, varref);
|
|
var mod = this.cur_module;
|
|
return varref;
|
|
}
|
|
visit_sentree(node) {
|
|
}
|
|
visit_always(node) {
|
|
var sentree;
|
|
var expr;
|
|
if (node.children.length == 2) {
|
|
sentree = node.children[0].obj;
|
|
expr = node.children[1].obj;
|
|
} else {
|
|
sentree = null;
|
|
expr = node.children[0].obj;
|
|
}
|
|
var always = {
|
|
$loc: this.parseSourceLocation(node),
|
|
blocktype: node.type,
|
|
name: null,
|
|
senlist: sentree,
|
|
exprs: [expr]
|
|
};
|
|
this.cur_module.blocks.push(always);
|
|
return always;
|
|
}
|
|
visit_begin(node) {
|
|
var exprs = [];
|
|
node.children.forEach((n) => exprs.push(n.obj));
|
|
return {
|
|
$loc: this.parseSourceLocation(node),
|
|
blocktype: node.type,
|
|
name: node.attrs["name"],
|
|
exprs
|
|
};
|
|
}
|
|
visit_initarray(node) {
|
|
return this.visit_begin(node);
|
|
}
|
|
visit_inititem(node) {
|
|
this.expectChildren(node, 1, 1);
|
|
return {
|
|
index: parseInt(node.attrs["index"]),
|
|
expr: node.children[0].obj
|
|
};
|
|
}
|
|
visit_cfunc(node) {
|
|
if (this.cur_module == null) {
|
|
return;
|
|
}
|
|
var block = this.visit_begin(node);
|
|
block.exprs = [];
|
|
node.children.forEach((n) => block.exprs.push(n.obj));
|
|
this.cur_module.blocks.push(block);
|
|
return block;
|
|
}
|
|
visit_cuse(node) {
|
|
}
|
|
visit_instance(node) {
|
|
var instance = {
|
|
$loc: this.parseSourceLocation(node),
|
|
name: node.attrs["name"],
|
|
origName: node.attrs["origName"],
|
|
ports: [],
|
|
module: null
|
|
};
|
|
node.children.forEach((child) => {
|
|
instance.ports.push(child.obj);
|
|
});
|
|
this.cur_module.instances.push(instance);
|
|
this.defer(() => {
|
|
instance.module = this.resolveModule(node.attrs["defName"]);
|
|
});
|
|
return instance;
|
|
}
|
|
visit_iface(node) {
|
|
throw new CompileError2(this.cur_loc, `interfaces not supported`);
|
|
}
|
|
visit_intfref(node) {
|
|
throw new CompileError2(this.cur_loc, `interfaces not supported`);
|
|
}
|
|
visit_port(node) {
|
|
this.expectChildren(node, 1, 1);
|
|
var varref = {
|
|
$loc: this.parseSourceLocation(node),
|
|
name: node.attrs["name"],
|
|
expr: node.children[0].obj
|
|
};
|
|
return varref;
|
|
}
|
|
visit_netlist(node) {
|
|
}
|
|
visit_files(node) {
|
|
}
|
|
visit_module_files(node) {
|
|
node.children.forEach((n) => {
|
|
if (n.obj) {
|
|
var file = this.files[n.obj.id];
|
|
if (file)
|
|
file.isModule = true;
|
|
}
|
|
});
|
|
}
|
|
visit_file(node) {
|
|
return this.visit_file_or_module(node, false);
|
|
}
|
|
visit_scope(node) {
|
|
}
|
|
visit_topscope(node) {
|
|
}
|
|
visit_file_or_module(node, isModule) {
|
|
var file = {
|
|
id: node.attrs["id"],
|
|
filename: node.attrs["filename"],
|
|
isModule
|
|
};
|
|
this.files[file.id] = file;
|
|
return file;
|
|
}
|
|
visit_cells(node) {
|
|
this.expectChildren(node, 1, 9999);
|
|
var hier = node.children[0].obj;
|
|
if (hier != null) {
|
|
var hiername = hier.name;
|
|
this.hierarchies[hiername] = hier;
|
|
}
|
|
}
|
|
visit_cell(node) {
|
|
var hier = {
|
|
$loc: this.parseSourceLocation(node),
|
|
name: node.attrs["name"],
|
|
module: null,
|
|
parent: null,
|
|
children: node.children.map((n) => n.obj)
|
|
};
|
|
if (node.children.length > 0)
|
|
throw new CompileError2(this.cur_loc, `multiple non-flattened modules not yet supported`);
|
|
node.children.forEach((n) => n.obj.parent = hier);
|
|
this.defer(() => {
|
|
hier.module = this.resolveModule(node.attrs["submodname"]);
|
|
});
|
|
return hier;
|
|
}
|
|
visit_basicdtype(node) {
|
|
let id = node.attrs["id"];
|
|
var dtype;
|
|
var dtypename = node.attrs["name"];
|
|
switch (dtypename) {
|
|
case "logic":
|
|
case "integer":
|
|
case "bit":
|
|
let dlogic = {
|
|
$loc: this.parseSourceLocation(node),
|
|
left: parseInt(node.attrs["left"] || "0"),
|
|
right: parseInt(node.attrs["right"] || "0"),
|
|
signed: node.attrs["signed"] == "true"
|
|
};
|
|
dtype = dlogic;
|
|
break;
|
|
case "string":
|
|
let dstring = {
|
|
$loc: this.parseSourceLocation(node),
|
|
jstype: "string"
|
|
};
|
|
dtype = dstring;
|
|
break;
|
|
default:
|
|
dtype = this.dtypes[dtypename];
|
|
if (dtype == null) {
|
|
throw new CompileError2(this.cur_loc, `unknown data type ${dtypename}`);
|
|
}
|
|
}
|
|
this.dtypes[id] = dtype;
|
|
return dtype;
|
|
}
|
|
visit_refdtype(node) {
|
|
}
|
|
visit_enumdtype(node) {
|
|
}
|
|
visit_enumitem(node) {
|
|
}
|
|
visit_packarraydtype(node) {
|
|
return this.visit_unpackarraydtype(node);
|
|
}
|
|
visit_memberdtype(node) {
|
|
throw new CompileError2(null, `structs not supported`);
|
|
}
|
|
visit_constdtype(node) {
|
|
}
|
|
visit_paramtypedtype(node) {
|
|
}
|
|
visit_unpackarraydtype(node) {
|
|
let id = node.attrs["id"];
|
|
let sub_dtype_id = node.attrs["sub_dtype_id"];
|
|
let range = node.children[0].obj;
|
|
if (isConstExpr(range.left) && isConstExpr(range.right)) {
|
|
var dtype = {
|
|
$loc: this.parseSourceLocation(node),
|
|
subtype: null,
|
|
low: range.left,
|
|
high: range.right
|
|
};
|
|
this.dtypes[id] = dtype;
|
|
this.defer(() => {
|
|
dtype.subtype = this.dtypes[sub_dtype_id];
|
|
if (!dtype.subtype)
|
|
throw new CompileError2(this.cur_loc, `Unknown data type ${sub_dtype_id} for array`);
|
|
});
|
|
return dtype;
|
|
} else {
|
|
throw new CompileError2(this.cur_loc, `could not parse constant exprs in array`);
|
|
}
|
|
}
|
|
visit_senitem(node) {
|
|
var edgeType = node.attrs["edgeType"];
|
|
if (edgeType != "POS" && edgeType != "NEG")
|
|
throw new CompileError2(this.cur_loc, "POS/NEG required");
|
|
return {
|
|
$loc: this.parseSourceLocation(node),
|
|
edgeType,
|
|
expr: node.obj
|
|
};
|
|
}
|
|
visit_text(node) {
|
|
}
|
|
visit_cstmt(node) {
|
|
}
|
|
visit_cfile(node) {
|
|
}
|
|
visit_typetable(node) {
|
|
}
|
|
visit_constpool(node) {
|
|
}
|
|
visit_comment(node) {
|
|
}
|
|
expectChildren(node, low, high) {
|
|
if (node.children.length < low || node.children.length > high)
|
|
throw new CompileError2(this.cur_loc, `expected between ${low} and ${high} children`);
|
|
}
|
|
__visit_unop(node) {
|
|
this.expectChildren(node, 1, 1);
|
|
var expr = {
|
|
$loc: this.parseSourceLocation(node),
|
|
op: node.type,
|
|
dtype: null,
|
|
left: node.children[0].obj
|
|
};
|
|
this.deferDataType(node, expr);
|
|
return expr;
|
|
}
|
|
visit_extend(node) {
|
|
var unop = this.__visit_unop(node);
|
|
unop.width = parseInt(node.attrs["width"]);
|
|
unop.widthminv = parseInt(node.attrs["widthminv"]);
|
|
if (unop.width != 32)
|
|
throw new CompileError2(this.cur_loc, `extends width ${unop.width} != 32`);
|
|
return unop;
|
|
}
|
|
visit_extends(node) {
|
|
return this.visit_extend(node);
|
|
}
|
|
__visit_binop(node) {
|
|
this.expectChildren(node, 2, 2);
|
|
var expr = {
|
|
$loc: this.parseSourceLocation(node),
|
|
op: node.type,
|
|
dtype: null,
|
|
left: node.children[0].obj,
|
|
right: node.children[1].obj
|
|
};
|
|
this.deferDataType(node, expr);
|
|
return expr;
|
|
}
|
|
visit_if(node) {
|
|
this.expectChildren(node, 2, 3);
|
|
var expr = {
|
|
$loc: this.parseSourceLocation(node),
|
|
op: "if",
|
|
dtype: null,
|
|
cond: node.children[0].obj,
|
|
left: node.children[1].obj,
|
|
right: node.children[2] && node.children[2].obj
|
|
};
|
|
return expr;
|
|
}
|
|
visit_while(node) {
|
|
this.expectChildren(node, 2, 4);
|
|
var expr = {
|
|
$loc: this.parseSourceLocation(node),
|
|
op: "while",
|
|
dtype: null,
|
|
precond: node.children[0].obj,
|
|
loopcond: node.children[1].obj,
|
|
body: node.children[2] && node.children[2].obj,
|
|
inc: node.children[3] && node.children[3].obj
|
|
};
|
|
return expr;
|
|
}
|
|
__visit_triop(node) {
|
|
this.expectChildren(node, 3, 3);
|
|
var expr = {
|
|
$loc: this.parseSourceLocation(node),
|
|
op: node.type,
|
|
dtype: null,
|
|
cond: node.children[0].obj,
|
|
left: node.children[1].obj,
|
|
right: node.children[2].obj
|
|
};
|
|
this.deferDataType(node, expr);
|
|
return expr;
|
|
}
|
|
__visit_func(node) {
|
|
var expr = {
|
|
$loc: this.parseSourceLocation(node),
|
|
dtype: null,
|
|
funcname: node.attrs["func"] || "$" + node.type,
|
|
args: node.children.map((n) => n.obj)
|
|
};
|
|
this.deferDataType(node, expr);
|
|
return expr;
|
|
}
|
|
visit_not(node) {
|
|
return this.__visit_unop(node);
|
|
}
|
|
visit_negate(node) {
|
|
return this.__visit_unop(node);
|
|
}
|
|
visit_redand(node) {
|
|
return this.__visit_unop(node);
|
|
}
|
|
visit_redor(node) {
|
|
return this.__visit_unop(node);
|
|
}
|
|
visit_redxor(node) {
|
|
return this.__visit_unop(node);
|
|
}
|
|
visit_initial(node) {
|
|
return this.__visit_unop(node);
|
|
}
|
|
visit_ccast(node) {
|
|
return this.__visit_unop(node);
|
|
}
|
|
visit_creset(node) {
|
|
return this.__visit_unop(node);
|
|
}
|
|
visit_creturn(node) {
|
|
return this.__visit_unop(node);
|
|
}
|
|
visit_contassign(node) {
|
|
return this.__visit_binop(node);
|
|
}
|
|
visit_assigndly(node) {
|
|
return this.__visit_binop(node);
|
|
}
|
|
visit_assignpre(node) {
|
|
return this.__visit_binop(node);
|
|
}
|
|
visit_assignpost(node) {
|
|
return this.__visit_binop(node);
|
|
}
|
|
visit_assign(node) {
|
|
return this.__visit_binop(node);
|
|
}
|
|
visit_arraysel(node) {
|
|
return this.__visit_binop(node);
|
|
}
|
|
visit_wordsel(node) {
|
|
return this.__visit_binop(node);
|
|
}
|
|
visit_eq(node) {
|
|
return this.__visit_binop(node);
|
|
}
|
|
visit_neq(node) {
|
|
return this.__visit_binop(node);
|
|
}
|
|
visit_lte(node) {
|
|
return this.__visit_binop(node);
|
|
}
|
|
visit_gte(node) {
|
|
return this.__visit_binop(node);
|
|
}
|
|
visit_lt(node) {
|
|
return this.__visit_binop(node);
|
|
}
|
|
visit_gt(node) {
|
|
return this.__visit_binop(node);
|
|
}
|
|
visit_and(node) {
|
|
return this.__visit_binop(node);
|
|
}
|
|
visit_or(node) {
|
|
return this.__visit_binop(node);
|
|
}
|
|
visit_xor(node) {
|
|
return this.__visit_binop(node);
|
|
}
|
|
visit_add(node) {
|
|
return this.__visit_binop(node);
|
|
}
|
|
visit_sub(node) {
|
|
return this.__visit_binop(node);
|
|
}
|
|
visit_concat(node) {
|
|
return this.__visit_binop(node);
|
|
}
|
|
visit_shiftl(node) {
|
|
return this.__visit_binop(node);
|
|
}
|
|
visit_shiftr(node) {
|
|
return this.__visit_binop(node);
|
|
}
|
|
visit_shiftrs(node) {
|
|
return this.__visit_binop(node);
|
|
}
|
|
visit_mul(node) {
|
|
return this.__visit_binop(node);
|
|
}
|
|
visit_div(node) {
|
|
return this.__visit_binop(node);
|
|
}
|
|
visit_moddiv(node) {
|
|
return this.__visit_binop(node);
|
|
}
|
|
visit_muls(node) {
|
|
return this.__visit_binop(node);
|
|
}
|
|
visit_divs(node) {
|
|
return this.__visit_binop(node);
|
|
}
|
|
visit_moddivs(node) {
|
|
return this.__visit_binop(node);
|
|
}
|
|
visit_gts(node) {
|
|
return this.__visit_binop(node);
|
|
}
|
|
visit_lts(node) {
|
|
return this.__visit_binop(node);
|
|
}
|
|
visit_gtes(node) {
|
|
return this.__visit_binop(node);
|
|
}
|
|
visit_ltes(node) {
|
|
return this.__visit_binop(node);
|
|
}
|
|
visit_range(node) {
|
|
return this.__visit_binop(node);
|
|
}
|
|
visit_cond(node) {
|
|
return this.__visit_triop(node);
|
|
}
|
|
visit_condbound(node) {
|
|
return this.__visit_triop(node);
|
|
}
|
|
visit_sel(node) {
|
|
return this.__visit_triop(node);
|
|
}
|
|
visit_changedet(node) {
|
|
if (node.children.length == 0)
|
|
return null;
|
|
else
|
|
return this.__visit_binop(node);
|
|
}
|
|
visit_ccall(node) {
|
|
return this.__visit_func(node);
|
|
}
|
|
visit_finish(node) {
|
|
return this.__visit_func(node);
|
|
}
|
|
visit_stop(node) {
|
|
return this.__visit_func(node);
|
|
}
|
|
visit_rand(node) {
|
|
return this.__visit_func(node);
|
|
}
|
|
visit_time(node) {
|
|
return this.__visit_func(node);
|
|
}
|
|
visit_display(node) {
|
|
return null;
|
|
}
|
|
visit_sformatf(node) {
|
|
return null;
|
|
}
|
|
visit_scopename(node) {
|
|
return null;
|
|
}
|
|
visit_readmem(node) {
|
|
return this.__visit_func(node);
|
|
}
|
|
xml_open(node) {
|
|
this.cur_node = node;
|
|
var method = this[`open_${node.type}`];
|
|
if (method) {
|
|
return method.bind(this)(node);
|
|
}
|
|
}
|
|
xml_close(node) {
|
|
this.cur_node = node;
|
|
var method = this[`visit_${node.type}`];
|
|
if (method) {
|
|
return method.bind(this)(node);
|
|
} else {
|
|
throw new CompileError2(this.cur_loc, `no visitor for ${node.type}`);
|
|
}
|
|
}
|
|
parse(xmls) {
|
|
parseXMLPoorly(xmls, this.xml_open.bind(this), this.xml_close.bind(this));
|
|
this.cur_node = null;
|
|
this.run_deferred();
|
|
}
|
|
};
|
|
|
|
// src/worker/tools/verilog.ts
|
|
function detectModuleName(code) {
|
|
var m = /^\s*module\s+(\w+_top)\b/m.exec(code) || /^\s*module\s+(top|t)\b/m.exec(code) || /^\s*module\s+(\w+)\b/m.exec(code);
|
|
return m ? m[1] : null;
|
|
}
|
|
function detectTopModuleName(code) {
|
|
var topmod = detectModuleName(code) || "top";
|
|
var m = /^\s*module\s+(\w+?_top)/m.exec(code);
|
|
if (m && m[1])
|
|
topmod = m[1];
|
|
return topmod;
|
|
}
|
|
var jsasm_module_top;
|
|
var jsasm_module_output;
|
|
var jsasm_module_key;
|
|
function compileJSASM(asmcode, platform, options, is_inline) {
|
|
var asm = new Assembler(null);
|
|
var includes = [];
|
|
asm.loadJSON = (filename) => {
|
|
var jsontext = getWorkFileAsString(filename);
|
|
if (!jsontext)
|
|
throw Error("could not load " + filename);
|
|
return JSON.parse(jsontext);
|
|
};
|
|
asm.loadInclude = (filename) => {
|
|
if (!filename.startsWith('"') || !filename.endsWith('"'))
|
|
return 'Expected filename in "double quotes"';
|
|
filename = filename.substr(1, filename.length - 2);
|
|
includes.push(filename);
|
|
};
|
|
var loaded_module = false;
|
|
asm.loadModule = (top_module) => {
|
|
loaded_module = true;
|
|
var key = top_module + "/" + includes;
|
|
if (jsasm_module_key != key) {
|
|
jsasm_module_key = key;
|
|
jsasm_module_output = null;
|
|
}
|
|
jsasm_module_top = top_module;
|
|
var main_filename = includes[includes.length - 1];
|
|
var voutput = compileVerilator({ platform, files: includes, path: main_filename, tool: "verilator" });
|
|
if (voutput)
|
|
jsasm_module_output = voutput;
|
|
return null;
|
|
};
|
|
var result = asm.assembleFile(asmcode);
|
|
if (loaded_module && jsasm_module_output) {
|
|
if (jsasm_module_output.errors && jsasm_module_output.errors.length)
|
|
return jsasm_module_output;
|
|
var asmout = result.output;
|
|
result.output = jsasm_module_output.output;
|
|
result.output.program_rom = asmout;
|
|
result.output.program_rom_variable = jsasm_module_top + "$program_rom";
|
|
result.listings = {};
|
|
result.listings[options.path] = { lines: result.lines };
|
|
return result;
|
|
} else {
|
|
return result;
|
|
}
|
|
}
|
|
function compileJSASMStep(step) {
|
|
gatherFiles(step);
|
|
var code = getWorkFileAsString(step.path);
|
|
var platform = step.platform || "verilog";
|
|
return compileJSASM(code, platform, step, false);
|
|
}
|
|
function compileInlineASM(code, platform, options, errors, asmlines) {
|
|
code = code.replace(/__asm\b([\s\S]+?)\b__endasm\b/g, function(s, asmcode, index) {
|
|
var firstline = code.substr(0, index).match(/\n/g).length;
|
|
var asmout = compileJSASM(asmcode, platform, options, true);
|
|
if (asmout.errors && asmout.errors.length) {
|
|
for (var i = 0; i < asmout.errors.length; i++) {
|
|
asmout.errors[i].line += firstline;
|
|
errors.push(asmout.errors[i]);
|
|
}
|
|
return "";
|
|
} else if (asmout.output) {
|
|
let s2 = "";
|
|
var out = asmout.output;
|
|
for (var i = 0; i < out.length; i++) {
|
|
if (i > 0) {
|
|
s2 += ",";
|
|
if ((i & 255) == 0)
|
|
s2 += "\n";
|
|
}
|
|
s2 += 0 | out[i];
|
|
}
|
|
if (asmlines) {
|
|
var al = asmout.lines;
|
|
for (var i = 0; i < al.length; i++) {
|
|
al[i].line += firstline;
|
|
asmlines.push(al[i]);
|
|
}
|
|
}
|
|
return s2;
|
|
}
|
|
});
|
|
return code;
|
|
}
|
|
function compileVerilator(step) {
|
|
loadNative("verilator_bin");
|
|
var platform = step.platform || "verilog";
|
|
var errors = [];
|
|
gatherFiles(step);
|
|
if (staleFiles(step, [xmlPath])) {
|
|
var match_fn = makeErrorMatcher(errors, /%(.+?): (.+?):(\d+)?[:]?\s*(.+)/i, 3, 4, step.path, 2);
|
|
var verilator_mod = emglobal.verilator_bin({
|
|
instantiateWasm: moduleInstFn("verilator_bin"),
|
|
noInitialRun: true,
|
|
noExitRuntime: true,
|
|
print: print_fn,
|
|
printErr: match_fn,
|
|
wasmMemory: getWASMMemory()
|
|
});
|
|
var code = getWorkFileAsString(step.path);
|
|
var topmod = detectTopModuleName(code);
|
|
var FS = verilator_mod.FS;
|
|
var listings = {};
|
|
populateFiles(step, FS, {
|
|
mainFilePath: step.path,
|
|
processFn: (path, code2) => {
|
|
if (typeof code2 === "string") {
|
|
let asmlines = [];
|
|
code2 = compileInlineASM(code2, platform, step, errors, asmlines);
|
|
if (asmlines.length) {
|
|
listings[path] = { lines: asmlines };
|
|
}
|
|
}
|
|
return code2;
|
|
}
|
|
});
|
|
starttime();
|
|
var xmlPath = `obj_dir/V${topmod}.xml`;
|
|
try {
|
|
var args = [
|
|
"--cc",
|
|
"-O3",
|
|
"-DEXT_INLINE_ASM",
|
|
"-DTOPMOD__" + topmod,
|
|
"-D__8BITWORKSHOP__",
|
|
"-Wall",
|
|
"-Wno-DECLFILENAME",
|
|
"-Wno-UNUSED",
|
|
"-Wno-EOFNEWLINE",
|
|
"-Wno-PROCASSWIRE",
|
|
"--x-assign",
|
|
"fast",
|
|
"--noassert",
|
|
"--pins-sc-biguint",
|
|
"--debug-check",
|
|
"--top-module",
|
|
topmod,
|
|
step.path
|
|
];
|
|
execMain(step, verilator_mod, args);
|
|
} catch (e) {
|
|
console.log(e);
|
|
errors.push({ line: 0, msg: "Compiler internal error: " + e });
|
|
}
|
|
endtime("compile");
|
|
errors = errors.filter(function(e) {
|
|
return !/Exiting due to \d+/.exec(e.msg);
|
|
}, errors);
|
|
errors = errors.filter(function(e) {
|
|
return !/Use ["][/][*]/.exec(e.msg);
|
|
}, errors);
|
|
if (errors.length) {
|
|
return { errors };
|
|
}
|
|
starttime();
|
|
var xmlParser = new VerilogXMLParser();
|
|
try {
|
|
var xmlContent = FS.readFile(xmlPath, { encoding: "utf8" });
|
|
var xmlScrubbed = xmlContent.replace(/ fl=".+?" loc=".+?"/g, "");
|
|
putWorkFile(xmlPath, xmlScrubbed);
|
|
if (!anyTargetChanged(step, [xmlPath]))
|
|
return;
|
|
xmlParser.parse(xmlContent);
|
|
} catch (e) {
|
|
console.log(e, e.stack);
|
|
if (e.$loc != null) {
|
|
let $loc = e.$loc;
|
|
errors.push({ msg: "" + e, path: $loc.path, line: $loc.line });
|
|
} else {
|
|
errors.push({ line: 0, msg: "" + e });
|
|
}
|
|
return { errors, listings };
|
|
} finally {
|
|
endtime("parse");
|
|
}
|
|
return {
|
|
output: xmlParser,
|
|
errors,
|
|
listings
|
|
};
|
|
}
|
|
}
|
|
function compileYosys(step) {
|
|
loadNative("yosys");
|
|
var code = step.code;
|
|
var errors = [];
|
|
var match_fn = makeErrorMatcher(errors, /ERROR: (.+?) in line (.+?[.]v):(\d+)[: ]+(.+)/i, 3, 4, step.path);
|
|
starttime();
|
|
var yosys_mod = emglobal.yosys({
|
|
instantiateWasm: moduleInstFn("yosys"),
|
|
noInitialRun: true,
|
|
print: print_fn,
|
|
printErr: match_fn
|
|
});
|
|
endtime("create module");
|
|
var topmod = detectTopModuleName(code);
|
|
var FS = yosys_mod.FS;
|
|
FS.writeFile(topmod + ".v", code);
|
|
starttime();
|
|
try {
|
|
execMain(step, yosys_mod, ["-q", "-o", topmod + ".json", "-S", topmod + ".v"]);
|
|
} catch (e) {
|
|
console.log(e);
|
|
endtime("compile");
|
|
return { errors };
|
|
}
|
|
endtime("compile");
|
|
if (errors.length)
|
|
return { errors };
|
|
try {
|
|
var json_file = FS.readFile(topmod + ".json", { encoding: "utf8" });
|
|
var json = JSON.parse(json_file);
|
|
console.log(json);
|
|
return { output: json, errors };
|
|
} catch (e) {
|
|
console.log(e);
|
|
return { errors };
|
|
}
|
|
}
|
|
function compileSilice(step) {
|
|
loadNative("silice");
|
|
var params = step.params;
|
|
gatherFiles(step, { mainFilePath: "main.ice" });
|
|
var destpath = step.prefix + ".v";
|
|
var errors = [];
|
|
var errfile;
|
|
var errline;
|
|
if (staleFiles(step, [destpath])) {
|
|
var match_fn = (s) => {
|
|
s = s.replaceAll(/\033\[\d+\w/g, "");
|
|
var mf = /file:\s*(\w+)/.exec(s);
|
|
var ml = /line:\s+(\d+)/.exec(s);
|
|
var preproc = /\[preprocessor\] (\d+)\] (.+)/.exec(s);
|
|
if (mf)
|
|
errfile = mf[1];
|
|
else if (ml)
|
|
errline = parseInt(ml[1]);
|
|
else if (preproc) {
|
|
errors.push({ path: step.path, line: parseInt(preproc[1]), msg: preproc[2] });
|
|
} else if (errfile && errline && s.length > 1) {
|
|
if (s.length > 2) {
|
|
errors.push({ path: errfile + ".ice", line: errline, msg: s });
|
|
} else {
|
|
errfile = null;
|
|
errline = null;
|
|
}
|
|
} else
|
|
console.log(s);
|
|
};
|
|
var silice = emglobal.silice({
|
|
instantiateWasm: moduleInstFn("silice"),
|
|
noInitialRun: true,
|
|
print: match_fn,
|
|
printErr: match_fn
|
|
});
|
|
var FS = silice.FS;
|
|
setupFS(FS, "Silice");
|
|
populateFiles(step, FS);
|
|
populateExtraFiles(step, FS, params.extra_compile_files);
|
|
const FWDIR = "/share/frameworks";
|
|
var args = [
|
|
"-D",
|
|
"NTSC=1",
|
|
"--frameworks_dir",
|
|
FWDIR,
|
|
"-f",
|
|
`/8bitworkshop.v`,
|
|
"-o",
|
|
destpath,
|
|
step.path
|
|
];
|
|
execMain(step, silice, args);
|
|
if (errors.length)
|
|
return { errors };
|
|
var vout = FS.readFile(destpath, { encoding: "utf8" });
|
|
putWorkFile(destpath, vout);
|
|
}
|
|
return {
|
|
nexttool: "verilator",
|
|
path: destpath,
|
|
args: [destpath],
|
|
files: [destpath]
|
|
};
|
|
}
|
|
|
|
// src/worker/tools/m6809.ts
|
|
function assembleXASM6809(step) {
|
|
load("xasm6809");
|
|
var alst = "";
|
|
var lasterror = null;
|
|
var errors = [];
|
|
function match_fn(s) {
|
|
alst += s;
|
|
alst += "\n";
|
|
if (lasterror) {
|
|
var line = parseInt(s.slice(0, 5)) || 0;
|
|
errors.push({
|
|
line,
|
|
msg: lasterror
|
|
});
|
|
lasterror = null;
|
|
} else if (s.startsWith("***** ")) {
|
|
lasterror = s.slice(6);
|
|
}
|
|
}
|
|
var Module = emglobal.xasm6809({
|
|
noInitialRun: true,
|
|
print: match_fn,
|
|
printErr: print_fn
|
|
});
|
|
var FS = Module.FS;
|
|
populateFiles(step, FS, {
|
|
mainFilePath: "main.asm"
|
|
});
|
|
var binpath = step.prefix + ".bin";
|
|
var lstpath = step.prefix + ".lst";
|
|
execMain(step, Module, ["-c", "-l", "-s", "-y", "-o=" + binpath, step.path]);
|
|
if (errors.length)
|
|
return { errors };
|
|
var aout = FS.readFile(binpath, { encoding: "binary" });
|
|
if (aout.length == 0) {
|
|
errors.push({ line: 0, msg: "Empty output file" });
|
|
return { errors };
|
|
}
|
|
putWorkFile(binpath, aout);
|
|
putWorkFile(lstpath, alst);
|
|
var symbolmap = {};
|
|
var asmlines = parseListing(alst, /^\s*([0-9]+) .+ ([0-9A-F]+)\s+\[([0-9 ]+)\]\s+([0-9A-F]+) (.*)/i, 1, 2, 4, 3);
|
|
var listings = {};
|
|
listings[step.prefix + ".lst"] = { lines: asmlines, text: alst };
|
|
return {
|
|
output: aout,
|
|
listings,
|
|
errors,
|
|
symbolmap
|
|
};
|
|
}
|
|
function compileCMOC(step) {
|
|
loadNative("cmoc");
|
|
var params = step.params;
|
|
var re_err1 = /^[/]*([^:]*):(\d+): (.+)$/;
|
|
var errors = [];
|
|
var errline = 0;
|
|
function match_fn(s) {
|
|
var matches = re_err1.exec(s);
|
|
if (matches) {
|
|
errors.push({
|
|
line: parseInt(matches[2]),
|
|
msg: matches[3],
|
|
path: matches[1] || step.path
|
|
});
|
|
} else {
|
|
console.log(s);
|
|
}
|
|
}
|
|
gatherFiles(step, { mainFilePath: "main.c" });
|
|
var destpath = step.prefix + ".s";
|
|
if (staleFiles(step, [destpath])) {
|
|
var args = [
|
|
"-S",
|
|
"-Werror",
|
|
"-V",
|
|
"-I/share/include",
|
|
"-I.",
|
|
step.path
|
|
];
|
|
var CMOC = emglobal.cmoc({
|
|
instantiateWasm: moduleInstFn("cmoc"),
|
|
noInitialRun: true,
|
|
print: match_fn,
|
|
printErr: match_fn
|
|
});
|
|
var code = getWorkFileAsString(step.path);
|
|
var preproc = preprocessMCPP(step, null);
|
|
if (preproc.errors) {
|
|
return { errors: preproc.errors };
|
|
} else
|
|
code = preproc.code;
|
|
var FS = CMOC.FS;
|
|
populateFiles(step, FS);
|
|
FS.writeFile(step.path, code);
|
|
fixParamsWithDefines(step.path, params);
|
|
if (params.extra_compile_args) {
|
|
args.unshift.apply(args, params.extra_compile_args);
|
|
}
|
|
execMain(step, CMOC, args);
|
|
if (errors.length)
|
|
return { errors };
|
|
var asmout = FS.readFile(destpath, { encoding: "utf8" });
|
|
if (step.params.set_stack_end)
|
|
asmout = asmout.replace("stack space in bytes", `
|
|
lds #${step.params.set_stack_end}
|
|
`);
|
|
putWorkFile(destpath, asmout);
|
|
}
|
|
return {
|
|
nexttool: "lwasm",
|
|
path: destpath,
|
|
args: [destpath],
|
|
files: [destpath]
|
|
};
|
|
}
|
|
function assembleLWASM(step) {
|
|
loadNative("lwasm");
|
|
var errors = [];
|
|
gatherFiles(step, { mainFilePath: "main.s" });
|
|
var objpath = step.prefix + ".o";
|
|
var lstpath = step.prefix + ".lst";
|
|
const isRaw = step.path.endsWith(".asm");
|
|
if (staleFiles(step, [objpath, lstpath])) {
|
|
var objout, lstout;
|
|
var args = ["-9", "-I/share/asminc", "-o" + objpath, "-l" + lstpath, step.path];
|
|
args.push(isRaw ? "-r" : "--obj");
|
|
var LWASM = emglobal.lwasm({
|
|
instantiateWasm: moduleInstFn("lwasm"),
|
|
noInitialRun: true,
|
|
print: print_fn,
|
|
printErr: msvcErrorMatcher(errors)
|
|
});
|
|
var FS = LWASM.FS;
|
|
populateFiles(step, FS);
|
|
fixParamsWithDefines(step.path, step.params);
|
|
execMain(step, LWASM, args);
|
|
if (errors.length)
|
|
return { errors };
|
|
objout = FS.readFile(objpath, { encoding: "binary" });
|
|
lstout = FS.readFile(lstpath, { encoding: "utf8" });
|
|
putWorkFile(objpath, objout);
|
|
putWorkFile(lstpath, lstout);
|
|
if (isRaw) {
|
|
return {
|
|
output: objout
|
|
};
|
|
}
|
|
}
|
|
return {
|
|
linktool: "lwlink",
|
|
files: [objpath, lstpath],
|
|
args: [objpath]
|
|
};
|
|
}
|
|
function linkLWLINK(step) {
|
|
loadNative("lwlink");
|
|
var params = step.params;
|
|
gatherFiles(step);
|
|
var binpath = "main";
|
|
if (staleFiles(step, [binpath])) {
|
|
var errors = [];
|
|
var LWLINK = emglobal.lwlink({
|
|
instantiateWasm: moduleInstFn("lwlink"),
|
|
noInitialRun: true,
|
|
print: print_fn,
|
|
printErr: function(s2) {
|
|
if (s2.startsWith("Warning:"))
|
|
console.log(s2);
|
|
else
|
|
errors.push({ msg: s2, line: 0 });
|
|
}
|
|
});
|
|
var FS = LWLINK.FS;
|
|
populateFiles(step, FS);
|
|
populateExtraFiles(step, FS, params.extra_link_files);
|
|
var libargs = params.extra_link_args || [];
|
|
var args = [
|
|
"-L.",
|
|
"--entry=program_start",
|
|
"--raw",
|
|
"--output=main",
|
|
"--map=main.map"
|
|
].concat(libargs, step.args);
|
|
console.log(args);
|
|
execMain(step, LWLINK, args);
|
|
if (errors.length)
|
|
return { errors };
|
|
var aout = FS.readFile("main", { encoding: "binary" });
|
|
var mapout = FS.readFile("main.map", { encoding: "utf8" });
|
|
putWorkFile("main", aout);
|
|
putWorkFile("main.map", mapout);
|
|
if (!anyTargetChanged(step, ["main", "main.map"]))
|
|
return;
|
|
var symbolmap = {};
|
|
var segments = [];
|
|
for (var s of mapout.split("\n")) {
|
|
var toks = s.split(" ");
|
|
if (toks[0] == "Symbol:") {
|
|
let ident = toks[1];
|
|
let ofs = parseInt(toks[4], 16);
|
|
if (ident && ofs >= 0 && !ident.startsWith("l_") && !ident.startsWith("funcsize_") && !ident.startsWith("funcend_")) {
|
|
symbolmap[ident] = ofs;
|
|
}
|
|
} else if (toks[0] == "Section:") {
|
|
let seg = toks[1];
|
|
let segstart = parseInt(toks[5], 16);
|
|
let segsize = parseInt(toks[7], 16);
|
|
segments.push({ name: seg, start: segstart, size: segsize });
|
|
}
|
|
}
|
|
const re_segment = /\s*SECTION\s+(\w+)/i;
|
|
const re_function = /\s*([0-9a-f]+).+?(\w+)\s+EQU\s+[*]/i;
|
|
var listings = {};
|
|
for (var fn of step.files) {
|
|
if (fn.endsWith(".lst")) {
|
|
var lstout = FS.readFile(fn, { encoding: "utf8" });
|
|
var asmlines = parseListing(lstout, /^([0-9A-F]+)\s+([0-9A-F]+)\s+[(]\s*(.+?)[)]:(\d+) (.*)/i, 4, 1, 2, 3, re_function, re_segment);
|
|
for (let l of asmlines) {
|
|
l.offset += symbolmap[l.func] || 0;
|
|
}
|
|
var srclines = parseSourceLines(lstout, /Line .+?:(\d+)/i, /^([0-9A-F]{4})/i, re_function, re_segment);
|
|
for (let l of srclines) {
|
|
l.offset += symbolmap[l.func] || 0;
|
|
}
|
|
putWorkFile(fn, lstout);
|
|
lstout = lstout.split("\n").map((l) => l.substring(0, 15) + l.substring(56)).join("\n");
|
|
listings[fn] = {
|
|
asmlines: srclines.length ? asmlines : null,
|
|
lines: srclines.length ? srclines : asmlines,
|
|
text: lstout
|
|
};
|
|
}
|
|
}
|
|
return {
|
|
output: aout,
|
|
listings,
|
|
errors,
|
|
symbolmap,
|
|
segments
|
|
};
|
|
}
|
|
}
|
|
|
|
// src/worker/tools/m6502.ts
|
|
function assembleNESASM(step) {
|
|
loadNative("nesasm");
|
|
var re_filename = /\#\[(\d+)\]\s+(\S+)/;
|
|
var re_insn = /\s+(\d+)\s+([0-9A-F]+):([0-9A-F]+)/;
|
|
var re_error = /\s+(.+)/;
|
|
var errors = [];
|
|
var state = 0;
|
|
var lineno = 0;
|
|
var filename;
|
|
function match_fn(s2) {
|
|
var m2;
|
|
switch (state) {
|
|
case 0:
|
|
m2 = re_filename.exec(s2);
|
|
if (m2) {
|
|
filename = m2[2];
|
|
}
|
|
m2 = re_insn.exec(s2);
|
|
if (m2) {
|
|
lineno = parseInt(m2[1]);
|
|
state = 1;
|
|
}
|
|
break;
|
|
case 1:
|
|
m2 = re_error.exec(s2);
|
|
if (m2) {
|
|
errors.push({ path: filename, line: lineno, msg: m2[1] });
|
|
state = 0;
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
var Module = emglobal.nesasm({
|
|
instantiateWasm: moduleInstFn("nesasm"),
|
|
noInitialRun: true,
|
|
print: match_fn
|
|
});
|
|
var FS = Module.FS;
|
|
populateFiles(step, FS, {
|
|
mainFilePath: "main.a"
|
|
});
|
|
var binpath = step.prefix + ".nes";
|
|
var lstpath = step.prefix + ".lst";
|
|
var sympath = step.prefix + ".fns";
|
|
execMain(step, Module, [step.path, "-s", "-l", "2"]);
|
|
var listings = {};
|
|
try {
|
|
var alst = FS.readFile(lstpath, { "encoding": "utf8" });
|
|
var asmlines = parseListing(alst, /^\s*(\d+)\s+([0-9A-F]+):([0-9A-F]+)\s+([0-9A-F ]+?) (.*)/i, 1, 3, 4);
|
|
putWorkFile(lstpath, alst);
|
|
listings[lstpath] = {
|
|
lines: asmlines,
|
|
text: alst
|
|
};
|
|
} catch (e) {
|
|
}
|
|
if (errors.length) {
|
|
return { errors };
|
|
}
|
|
var aout, asym;
|
|
aout = FS.readFile(binpath);
|
|
try {
|
|
asym = FS.readFile(sympath, { "encoding": "utf8" });
|
|
} catch (e) {
|
|
console.log(e);
|
|
errors.push({ line: 0, msg: "No symbol table generated, maybe missing ENDM or segment overflow?" });
|
|
return { errors };
|
|
}
|
|
putWorkFile(binpath, aout);
|
|
putWorkFile(sympath, asym);
|
|
if (alst)
|
|
putWorkFile(lstpath, alst);
|
|
if (!anyTargetChanged(step, [binpath, sympath]))
|
|
return;
|
|
var symbolmap = {};
|
|
for (var s of asym.split("\n")) {
|
|
if (!s.startsWith(";")) {
|
|
var m = /(\w+)\s+=\s+[$]([0-9A-F]+)/.exec(s);
|
|
if (m) {
|
|
symbolmap[m[1]] = parseInt(m[2], 16);
|
|
}
|
|
}
|
|
}
|
|
return {
|
|
output: aout,
|
|
listings,
|
|
errors,
|
|
symbolmap
|
|
};
|
|
}
|
|
function assembleMerlin32(step) {
|
|
loadNative("merlin32");
|
|
var errors = [];
|
|
var lstfiles = [];
|
|
gatherFiles(step, { mainFilePath: "main.lnk" });
|
|
var objpath = step.prefix + ".bin";
|
|
if (staleFiles(step, [objpath])) {
|
|
var args = ["-v", step.path];
|
|
var merlin32 = emglobal.merlin32({
|
|
instantiateWasm: moduleInstFn("merlin32"),
|
|
noInitialRun: true,
|
|
print: (s) => {
|
|
var m = /\s*=>\s*Creating Output file '(.+?)'/.exec(s);
|
|
if (m) {
|
|
lstfiles.push(m[1]);
|
|
}
|
|
var errpos = s.indexOf("Error");
|
|
if (errpos >= 0) {
|
|
s = s.slice(errpos + 6).trim();
|
|
var mline = /\bline (\d+)\b/.exec(s);
|
|
var mpath = /\bfile '(.+?)'/.exec(s);
|
|
errors.push({
|
|
line: parseInt(mline[1]) || 0,
|
|
msg: s,
|
|
path: mpath[1] || step.path
|
|
});
|
|
}
|
|
},
|
|
printErr: print_fn
|
|
});
|
|
var FS = merlin32.FS;
|
|
populateFiles(step, FS);
|
|
execMain(step, merlin32, args);
|
|
if (errors.length)
|
|
return { errors };
|
|
var errout = null;
|
|
try {
|
|
errout = FS.readFile("error_output.txt", { encoding: "utf8" });
|
|
} catch (e) {
|
|
}
|
|
var objout = FS.readFile(objpath, { encoding: "binary" });
|
|
putWorkFile(objpath, objout);
|
|
if (!anyTargetChanged(step, [objpath]))
|
|
return;
|
|
var symbolmap = {};
|
|
var segments = [];
|
|
var listings = {};
|
|
lstfiles.forEach((lstfn) => {
|
|
var lst = FS.readFile(lstfn, { encoding: "utf8" });
|
|
lst.split("\n").forEach((line) => {
|
|
var toks = line.split(/\s*\|\s*/);
|
|
if (toks && toks[6]) {
|
|
var toks2 = toks[1].split(/\s+/);
|
|
var toks3 = toks[6].split(/[:/]/, 4);
|
|
var path = toks2[1];
|
|
if (path && toks2[2] && toks3[1]) {
|
|
var lstline = {
|
|
line: parseInt(toks2[2]),
|
|
offset: parseInt(toks3[1].trim(), 16),
|
|
insns: toks3[2],
|
|
cycles: null,
|
|
iscode: false
|
|
};
|
|
var lst2 = listings[path];
|
|
if (!lst2)
|
|
listings[path] = lst2 = { lines: [] };
|
|
lst2.lines.push(lstline);
|
|
}
|
|
}
|
|
});
|
|
});
|
|
return {
|
|
output: objout,
|
|
listings,
|
|
errors,
|
|
symbolmap,
|
|
segments
|
|
};
|
|
}
|
|
}
|
|
function compileFastBasic(step) {
|
|
loadNative("fastbasic-int");
|
|
var params = step.params;
|
|
gatherFiles(step, { mainFilePath: "main.fb" });
|
|
var destpath = step.prefix + ".s";
|
|
var errors = [];
|
|
if (staleFiles(step, [destpath])) {
|
|
var fastbasic = emglobal.fastbasic({
|
|
instantiateWasm: moduleInstFn("fastbasic-int"),
|
|
noInitialRun: true,
|
|
print: print_fn,
|
|
printErr: makeErrorMatcher(errors, /(.+?):(\d+):(\d+):\s*(.+)/, 2, 4, step.path, 1)
|
|
});
|
|
var FS = fastbasic.FS;
|
|
populateFiles(step, FS);
|
|
var libfile = "fastbasic-int.lib";
|
|
params.libargs = [libfile];
|
|
params.cfgfile = params.fastbasic_cfgfile;
|
|
params.extra_link_files = [libfile, params.cfgfile];
|
|
var args = [step.path, destpath];
|
|
execMain(step, fastbasic, args);
|
|
if (errors.length)
|
|
return { errors };
|
|
var asmout = FS.readFile(destpath, { encoding: "utf8" });
|
|
putWorkFile(destpath, asmout);
|
|
}
|
|
return {
|
|
nexttool: "ca65",
|
|
path: destpath,
|
|
args: [destpath],
|
|
files: [destpath]
|
|
};
|
|
}
|
|
|
|
// src/worker/tools/z80.ts
|
|
function assembleZMAC(step) {
|
|
loadNative("zmac");
|
|
var hexout, lstout, binout;
|
|
var errors = [];
|
|
var params = step.params;
|
|
gatherFiles(step, { mainFilePath: "main.asm" });
|
|
var lstpath = step.prefix + ".lst";
|
|
var binpath = step.prefix + ".cim";
|
|
if (staleFiles(step, [binpath, lstpath])) {
|
|
var ZMAC = emglobal.zmac({
|
|
instantiateWasm: moduleInstFn("zmac"),
|
|
noInitialRun: true,
|
|
print: print_fn,
|
|
printErr: makeErrorMatcher(errors, /([^( ]+)\s*[(](\d+)[)]\s*:\s*(.+)/, 2, 3, step.path)
|
|
});
|
|
var FS = ZMAC.FS;
|
|
populateFiles(step, FS);
|
|
execMain(step, ZMAC, ["-z", "-c", "--oo", "lst,cim", step.path]);
|
|
if (errors.length) {
|
|
return { errors };
|
|
}
|
|
lstout = FS.readFile("zout/" + lstpath, { encoding: "utf8" });
|
|
binout = FS.readFile("zout/" + binpath, { encoding: "binary" });
|
|
putWorkFile(binpath, binout);
|
|
putWorkFile(lstpath, lstout);
|
|
if (!anyTargetChanged(step, [binpath, lstpath]))
|
|
return;
|
|
var lines = parseListing(lstout, /\s*(\d+):\s*([0-9a-f]+)\s+([0-9a-f]+)\s+(.+)/i, 1, 2, 3);
|
|
var listings = {};
|
|
listings[lstpath] = { lines };
|
|
var symbolmap = {};
|
|
var sympos = lstout.indexOf("Symbol Table:");
|
|
if (sympos > 0) {
|
|
var symout = lstout.slice(sympos + 14);
|
|
symout.split("\n").forEach(function(l) {
|
|
var m = l.match(/(\S+)\s+([= ]*)([0-9a-f]+)/i);
|
|
if (m) {
|
|
symbolmap[m[1]] = parseInt(m[3], 16);
|
|
}
|
|
});
|
|
}
|
|
return {
|
|
output: binout,
|
|
listings,
|
|
errors,
|
|
symbolmap
|
|
};
|
|
}
|
|
}
|
|
|
|
// src/worker/tools/x86.ts
|
|
function compileSmallerC(step) {
|
|
loadNative("smlrc");
|
|
var params = step.params;
|
|
var re_err1 = /^Error in "[/]*(.+)" [(](\d+):(\d+)[)]/;
|
|
var errors = [];
|
|
var errline = 0;
|
|
var errpath = step.path;
|
|
function match_fn(s) {
|
|
var matches = re_err1.exec(s);
|
|
if (matches) {
|
|
errline = parseInt(matches[2]);
|
|
errpath = matches[1];
|
|
} else {
|
|
errors.push({
|
|
line: errline,
|
|
msg: s,
|
|
path: errpath
|
|
});
|
|
}
|
|
}
|
|
gatherFiles(step, { mainFilePath: "main.c" });
|
|
var destpath = step.prefix + ".asm";
|
|
if (staleFiles(step, [destpath])) {
|
|
var args = [
|
|
"-seg16",
|
|
"-no-externs",
|
|
step.path,
|
|
destpath
|
|
];
|
|
var smlrc = emglobal.smlrc({
|
|
instantiateWasm: moduleInstFn("smlrc"),
|
|
noInitialRun: true,
|
|
print: match_fn,
|
|
printErr: match_fn
|
|
});
|
|
var code = getWorkFileAsString(step.path);
|
|
var preproc = preprocessMCPP(step, null);
|
|
if (preproc.errors) {
|
|
return { errors: preproc.errors };
|
|
} else
|
|
code = preproc.code;
|
|
var FS = smlrc.FS;
|
|
populateFiles(step, FS);
|
|
FS.writeFile(step.path, code);
|
|
fixParamsWithDefines(step.path, params);
|
|
if (params.extra_compile_args) {
|
|
args.unshift.apply(args, params.extra_compile_args);
|
|
}
|
|
execMain(step, smlrc, args);
|
|
if (errors.length)
|
|
return { errors };
|
|
var asmout = FS.readFile(destpath, { encoding: "utf8" });
|
|
putWorkFile(destpath, asmout);
|
|
}
|
|
return {
|
|
nexttool: "yasm",
|
|
path: destpath,
|
|
args: [destpath],
|
|
files: [destpath]
|
|
};
|
|
}
|
|
function assembleYASM(step) {
|
|
loadNative("yasm");
|
|
var errors = [];
|
|
gatherFiles(step, { mainFilePath: "main.asm" });
|
|
var objpath = step.prefix + ".exe";
|
|
var lstpath = step.prefix + ".lst";
|
|
var mappath = step.prefix + ".map";
|
|
if (staleFiles(step, [objpath])) {
|
|
var args = [
|
|
"-X",
|
|
"vc",
|
|
"-a",
|
|
"x86",
|
|
"-f",
|
|
"dosexe",
|
|
"-p",
|
|
"nasm",
|
|
"-D",
|
|
"freedos",
|
|
"-o",
|
|
objpath,
|
|
"-l",
|
|
lstpath,
|
|
"--mapfile=" + mappath,
|
|
step.path
|
|
];
|
|
var YASM = emglobal.yasm({
|
|
instantiateWasm: moduleInstFn("yasm"),
|
|
noInitialRun: true,
|
|
print: print_fn,
|
|
printErr: msvcErrorMatcher(errors)
|
|
});
|
|
var FS = YASM.FS;
|
|
populateFiles(step, FS);
|
|
execMain(step, YASM, args);
|
|
if (errors.length)
|
|
return { errors };
|
|
var objout, lstout, mapout;
|
|
objout = FS.readFile(objpath, { encoding: "binary" });
|
|
lstout = FS.readFile(lstpath, { encoding: "utf8" });
|
|
mapout = FS.readFile(mappath, { encoding: "utf8" });
|
|
putWorkFile(objpath, objout);
|
|
putWorkFile(lstpath, lstout);
|
|
if (!anyTargetChanged(step, [objpath]))
|
|
return;
|
|
var symbolmap = {};
|
|
var segments = [];
|
|
var lines = parseListing(lstout, /\s*(\d+)\s+([0-9a-f]+)\s+([0-9a-f]+)\s+(.+)/i, 1, 2, 3);
|
|
var listings = {};
|
|
listings[lstpath] = { lines, text: lstout };
|
|
return {
|
|
output: objout,
|
|
listings,
|
|
errors,
|
|
symbolmap,
|
|
segments
|
|
};
|
|
}
|
|
}
|
|
|
|
// src/worker/tools/arm.ts
|
|
function assembleARMIPS(step) {
|
|
loadNative("armips");
|
|
var errors = [];
|
|
gatherFiles(step, { mainFilePath: "main.asm" });
|
|
var objpath = "main.bin";
|
|
var lstpath = step.prefix + ".lst";
|
|
var sympath = step.prefix + ".sym";
|
|
var error_fn = makeErrorMatcher(errors, /^(.+?)\((\d+)\)\s+(fatal error|error|warning):\s+(.+)/, 2, 4, step.path, 1);
|
|
if (staleFiles(step, [objpath])) {
|
|
var args = [step.path, "-temp", lstpath, "-sym", sympath, "-erroronwarning"];
|
|
var armips = emglobal.armips({
|
|
instantiateWasm: moduleInstFn("armips"),
|
|
noInitialRun: true,
|
|
print: error_fn,
|
|
printErr: error_fn
|
|
});
|
|
var FS = armips.FS;
|
|
var code = getWorkFileAsString(step.path);
|
|
code = `.arm.little :: .create "${objpath}",0 :: ${code}
|
|
.close`;
|
|
putWorkFile(step.path, code);
|
|
populateFiles(step, FS);
|
|
execMain(step, armips, args);
|
|
if (errors.length)
|
|
return { errors };
|
|
var objout = FS.readFile(objpath, { encoding: "binary" });
|
|
putWorkFile(objpath, objout);
|
|
if (!anyTargetChanged(step, [objpath]))
|
|
return;
|
|
var symbolmap = {};
|
|
var segments = [];
|
|
var listings = {};
|
|
var lstout = FS.readFile(lstpath, { encoding: "utf8" });
|
|
var lines = lstout.split(re_crlf);
|
|
var re_asmline = /^([0-9A-F]+) (.+?); [/](.+?) line (\d+)/;
|
|
var lastofs = -1;
|
|
for (var line of lines) {
|
|
var m;
|
|
if (m = re_asmline.exec(line)) {
|
|
var path = m[3];
|
|
var path2 = getPrefix(path) + ".lst";
|
|
var lst = listings[path2];
|
|
if (lst == null) {
|
|
lst = listings[path2] = { lines: [] };
|
|
}
|
|
var ofs = parseInt(m[1], 16);
|
|
if (lastofs == ofs) {
|
|
lst.lines.pop();
|
|
} else if (ofs > lastofs) {
|
|
var lastline = lst.lines[lst.lines.length - 1];
|
|
if (lastline && !lastline.insns) {
|
|
var insns = objout.slice(lastofs, ofs).reverse();
|
|
lastline.insns = Array.from(insns).map((b) => hex(b, 2)).join("");
|
|
}
|
|
}
|
|
lst.lines.push({
|
|
path,
|
|
line: parseInt(m[4]),
|
|
offset: ofs
|
|
});
|
|
lastofs = ofs;
|
|
}
|
|
}
|
|
var symout = FS.readFile(sympath, { encoding: "utf8" });
|
|
var re_symline = /^([0-9A-F]+)\s+(.+)/;
|
|
for (var line of symout.split(re_crlf)) {
|
|
var m;
|
|
if (m = re_symline.exec(line)) {
|
|
symbolmap[m[2]] = parseInt(m[1], 16);
|
|
}
|
|
}
|
|
return {
|
|
output: objout,
|
|
listings,
|
|
errors,
|
|
symbolmap,
|
|
segments
|
|
};
|
|
}
|
|
}
|
|
function assembleVASMARM(step) {
|
|
loadNative("vasmarm_std");
|
|
var re_err1 = /^(fatal error|error|warning)? (\d+) in line (\d+) of "(.+)": (.+)/;
|
|
var re_err2 = /^(fatal error|error|warning)? (\d+): (.+)/;
|
|
var re_undefsym = /symbol <(.+?)>/;
|
|
var errors = [];
|
|
var undefsyms = [];
|
|
function findUndefinedSymbols(line2) {
|
|
undefsyms.forEach((sym) => {
|
|
if (line2.indexOf(sym) >= 0) {
|
|
errors.push({
|
|
path: curpath,
|
|
line: curline,
|
|
msg: "Undefined symbol: " + sym
|
|
});
|
|
}
|
|
});
|
|
}
|
|
function match_fn(s) {
|
|
let matches = re_err1.exec(s);
|
|
if (matches) {
|
|
errors.push({
|
|
line: parseInt(matches[3]),
|
|
path: matches[4],
|
|
msg: matches[5]
|
|
});
|
|
} else {
|
|
matches = re_err2.exec(s);
|
|
if (matches) {
|
|
let m2 = re_undefsym.exec(matches[3]);
|
|
if (m2) {
|
|
undefsyms.push(m2[1]);
|
|
} else {
|
|
errors.push({
|
|
line: 0,
|
|
msg: s
|
|
});
|
|
}
|
|
} else {
|
|
console.log(s);
|
|
}
|
|
}
|
|
}
|
|
gatherFiles(step, { mainFilePath: "main.asm" });
|
|
var objpath = step.prefix + ".bin";
|
|
var lstpath = step.prefix + ".lst";
|
|
if (staleFiles(step, [objpath])) {
|
|
var args = ["-Fbin", "-m7tdmi", "-x", "-wfail", step.path, "-o", objpath, "-L", lstpath];
|
|
var vasm = emglobal.vasm({
|
|
instantiateWasm: moduleInstFn("vasmarm_std"),
|
|
noInitialRun: true,
|
|
print: match_fn,
|
|
printErr: match_fn
|
|
});
|
|
var FS = vasm.FS;
|
|
populateFiles(step, FS);
|
|
execMain(step, vasm, args);
|
|
if (errors.length) {
|
|
return { errors };
|
|
}
|
|
if (undefsyms.length == 0) {
|
|
var objout = FS.readFile(objpath, { encoding: "binary" });
|
|
putWorkFile(objpath, objout);
|
|
if (!anyTargetChanged(step, [objpath]))
|
|
return;
|
|
}
|
|
var lstout = FS.readFile(lstpath, { encoding: "utf8" });
|
|
var symbolmap = {};
|
|
var segments = [];
|
|
var listings = {};
|
|
var re_asmline = /^(\d+):([0-9A-F]+)\s+([0-9A-F ]+)\s+(\d+)([:M])/;
|
|
var re_secline = /^(\d+):\s+"(.+)"/;
|
|
var re_nameline = /^Source:\s+"(.+)"/;
|
|
var re_symline = /^(\w+)\s+(\d+):([0-9A-F]+)/;
|
|
var re_emptyline = /^\s+(\d+)([:M])/;
|
|
var curpath = step.path;
|
|
var curline = 0;
|
|
var sections = {};
|
|
var lines = lstout.split(re_crlf);
|
|
var lstlines = [];
|
|
for (var line of lines) {
|
|
var m;
|
|
if (m = re_secline.exec(line)) {
|
|
sections[m[1]] = m[2];
|
|
} else if (m = re_nameline.exec(line)) {
|
|
curpath = m[1];
|
|
} else if (m = re_symline.exec(line)) {
|
|
symbolmap[m[1]] = parseInt(m[3], 16);
|
|
} else if (m = re_asmline.exec(line)) {
|
|
if (m[5] == ":") {
|
|
curline = parseInt(m[4]);
|
|
} else {
|
|
}
|
|
lstlines.push({
|
|
path: curpath,
|
|
line: curline,
|
|
offset: parseInt(m[2], 16),
|
|
insns: m[3].replaceAll(" ", "")
|
|
});
|
|
findUndefinedSymbols(line);
|
|
} else if (m = re_emptyline.exec(line)) {
|
|
curline = parseInt(m[1]);
|
|
findUndefinedSymbols(line);
|
|
} else {
|
|
}
|
|
}
|
|
listings[lstpath] = { lines: lstlines, text: lstout };
|
|
if (undefsyms.length && errors.length == 0) {
|
|
errors.push({
|
|
line: 0,
|
|
msg: "Undefined symbols: " + undefsyms.join(", ")
|
|
});
|
|
}
|
|
return {
|
|
output: objout,
|
|
listings,
|
|
errors,
|
|
symbolmap,
|
|
segments
|
|
};
|
|
}
|
|
}
|
|
|
|
// src/common/tokenizer.ts
|
|
var CompileError3 = class extends Error {
|
|
constructor(msg, loc) {
|
|
super(msg);
|
|
Object.setPrototypeOf(this, CompileError3.prototype);
|
|
this.$loc = loc;
|
|
}
|
|
};
|
|
function mergeLocs2(a, b) {
|
|
return {
|
|
line: Math.min(a.line, b.line),
|
|
start: Math.min(a.start, b.start),
|
|
end: Math.max(a.end, b.end),
|
|
label: a.label || b.label,
|
|
path: a.path || b.path
|
|
};
|
|
}
|
|
var TokenType2;
|
|
(function(TokenType3) {
|
|
TokenType3["EOF"] = "eof";
|
|
TokenType3["EOL"] = "eol";
|
|
TokenType3["Ident"] = "ident";
|
|
TokenType3["Comment"] = "comment";
|
|
TokenType3["Ignore"] = "ignore";
|
|
TokenType3["CatchAll"] = "catch-all";
|
|
})(TokenType2 || (TokenType2 = {}));
|
|
var CATCH_ALL_RULES = [
|
|
{ type: TokenType2.CatchAll, regex: /.+?/ }
|
|
];
|
|
function re_escape(rule) {
|
|
return `(${rule.regex.source})`;
|
|
}
|
|
var TokenizerRuleSet = class {
|
|
constructor(rules) {
|
|
this.rules = rules.concat(CATCH_ALL_RULES);
|
|
var pattern = this.rules.map(re_escape).join("|");
|
|
this.regex = new RegExp(pattern, "gs");
|
|
}
|
|
};
|
|
var Tokenizer = class {
|
|
constructor() {
|
|
this.errorOnCatchAll = false;
|
|
this.deferred = [];
|
|
this.errors = [];
|
|
this.lineno = 0;
|
|
this.lineindex = [];
|
|
this.tokens = [];
|
|
}
|
|
setTokenRuleSet(ruleset) {
|
|
this.ruleset = ruleset;
|
|
}
|
|
setTokenRules(rules) {
|
|
this.setTokenRuleSet(new TokenizerRuleSet(rules));
|
|
}
|
|
tokenizeFile(contents, path) {
|
|
this.path = path;
|
|
let m;
|
|
let re = /\n|\r\n?/g;
|
|
this.lineindex.push(0);
|
|
while (m = re.exec(contents)) {
|
|
this.lineindex.push(m.index);
|
|
}
|
|
this._tokenize(contents);
|
|
this.eof = { type: TokenType2.EOF, str: "", eol: true, $loc: { path: this.path, line: this.lineno } };
|
|
this.pushToken(this.eof);
|
|
}
|
|
_tokenize(text) {
|
|
let m;
|
|
this.lineno = 0;
|
|
while (m = this.ruleset.regex.exec(text)) {
|
|
let found = false;
|
|
while (m.index >= this.lineindex[this.lineno]) {
|
|
this.lineno++;
|
|
}
|
|
let rules = this.ruleset.rules;
|
|
for (let i = 0; i < rules.length; i++) {
|
|
let s = m[i + 1];
|
|
if (s != null) {
|
|
found = true;
|
|
let col = m.index - (this.lineindex[this.lineno - 1] || -1) - 1;
|
|
let loc = { path: this.path, line: this.lineno, start: col, end: col + s.length };
|
|
let rule = rules[i];
|
|
switch (rule.type) {
|
|
case TokenType2.CatchAll:
|
|
if (this.errorOnCatchAll) {
|
|
this.compileError(`I didn't expect the character "${m[0]}" here.`, loc);
|
|
}
|
|
default:
|
|
this.pushToken({ str: s, type: rule.type, $loc: loc, eol: false });
|
|
break;
|
|
case TokenType2.EOL:
|
|
if (this.tokens.length)
|
|
this.tokens[this.tokens.length - 1].eol = true;
|
|
case TokenType2.Comment:
|
|
case TokenType2.Ignore:
|
|
break;
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
if (!found) {
|
|
this.compileError(`Could not parse token: <<${m[0]}>>`);
|
|
}
|
|
}
|
|
}
|
|
pushToken(token) {
|
|
this.tokens.push(token);
|
|
}
|
|
addError(msg, loc) {
|
|
let tok = this.lasttoken || this.peekToken();
|
|
if (!loc)
|
|
loc = tok.$loc;
|
|
this.errors.push({ path: loc.path, line: loc.line, label: this.curlabel, start: loc.start, end: loc.end, msg });
|
|
}
|
|
internalError() {
|
|
return this.compileError("Internal error.");
|
|
}
|
|
notImplementedError() {
|
|
return this.compileError("Not yet implemented.");
|
|
}
|
|
compileError(msg, loc, loc2) {
|
|
this.addError(msg, loc);
|
|
let e = new CompileError3(msg, loc);
|
|
throw e;
|
|
return e;
|
|
}
|
|
peekToken(lookahead) {
|
|
let tok = this.tokens[lookahead || 0];
|
|
return tok ? tok : this.eof;
|
|
}
|
|
consumeToken() {
|
|
let tok = this.lasttoken = this.tokens.shift() || this.eof;
|
|
return tok;
|
|
}
|
|
ifToken(match) {
|
|
if (this.peekToken().str == match)
|
|
return this.consumeToken();
|
|
}
|
|
expectToken(str, msg) {
|
|
let tok = this.consumeToken();
|
|
let tokstr = tok.str;
|
|
if (str != tokstr) {
|
|
this.compileError(msg || `There should be a "${str}" here.`);
|
|
}
|
|
return tok;
|
|
}
|
|
expectTokens(strlist, msg) {
|
|
let tok = this.consumeToken();
|
|
let tokstr = tok.str;
|
|
if (!strlist.includes(tokstr)) {
|
|
this.compileError(msg || `These keywords are valid here: ${strlist.join(", ")}`);
|
|
}
|
|
return tok;
|
|
}
|
|
parseModifiers(modifiers) {
|
|
let result = {};
|
|
do {
|
|
var tok = this.peekToken();
|
|
if (modifiers.indexOf(tok.str) < 0)
|
|
return result;
|
|
this.consumeToken();
|
|
result[tok.str] = true;
|
|
} while (tok != null);
|
|
}
|
|
expectIdent(msg) {
|
|
let tok = this.consumeToken();
|
|
if (tok.type != TokenType2.Ident)
|
|
this.compileError(msg || `There should be an identifier here.`);
|
|
return tok;
|
|
}
|
|
pushbackToken(tok) {
|
|
this.tokens.unshift(tok);
|
|
}
|
|
isEOF() {
|
|
return this.tokens.length == 0 || this.peekToken().type == "eof";
|
|
}
|
|
expectEOL(msg) {
|
|
let tok = this.consumeToken();
|
|
if (tok.type != TokenType2.EOL)
|
|
this.compileError(msg || `There's too much stuff on this line.`);
|
|
}
|
|
skipBlankLines() {
|
|
this.skipTokenTypes(["eol"]);
|
|
}
|
|
skipTokenTypes(types) {
|
|
while (types.includes(this.peekToken().type))
|
|
this.consumeToken();
|
|
}
|
|
expectTokenTypes(types, msg) {
|
|
let tok = this.consumeToken();
|
|
if (!types.includes(tok.type))
|
|
this.compileError(msg || `There should be a ${types.map((s) => `"${s}"`).join(" or ")} here. not a "${tok.type}".`);
|
|
return tok;
|
|
}
|
|
parseList(parseFunc, delim) {
|
|
var sep;
|
|
var list = [];
|
|
do {
|
|
var el = parseFunc.bind(this)();
|
|
if (el != null)
|
|
list.push(el);
|
|
sep = this.consumeToken();
|
|
} while (sep.str == delim);
|
|
this.pushbackToken(sep);
|
|
return list;
|
|
}
|
|
runDeferred() {
|
|
while (this.deferred.length) {
|
|
this.deferred.shift()();
|
|
}
|
|
}
|
|
};
|
|
|
|
// src/common/ecs/binpack.ts
|
|
var debug = false;
|
|
var BoxPlacement;
|
|
(function(BoxPlacement2) {
|
|
BoxPlacement2[BoxPlacement2["TopLeft"] = 0] = "TopLeft";
|
|
BoxPlacement2[BoxPlacement2["TopRight"] = 1] = "TopRight";
|
|
BoxPlacement2[BoxPlacement2["BottomLeft"] = 2] = "BottomLeft";
|
|
BoxPlacement2[BoxPlacement2["BottomRight"] = 3] = "BottomRight";
|
|
})(BoxPlacement || (BoxPlacement = {}));
|
|
function boxesIntersect(a, b) {
|
|
return !(b.left >= a.right || b.right <= a.left || b.top >= a.bottom || b.bottom <= a.top);
|
|
}
|
|
function boxesContain(a, b) {
|
|
return b.left >= a.left && b.top >= a.top && b.right <= a.right && b.bottom <= a.bottom;
|
|
}
|
|
var Bin = class {
|
|
constructor(binbounds) {
|
|
this.binbounds = binbounds;
|
|
this.boxes = [];
|
|
this.free = [];
|
|
this.extents = { left: 0, top: 0, right: 0, bottom: 0 };
|
|
this.free.push(binbounds);
|
|
}
|
|
getBoxes(bounds, limit, boxes) {
|
|
let result = [];
|
|
if (!boxes)
|
|
boxes = this.boxes;
|
|
for (let box of boxes) {
|
|
if (boxesIntersect(bounds, box)) {
|
|
result.push(box);
|
|
if (result.length >= limit)
|
|
break;
|
|
}
|
|
}
|
|
return result;
|
|
}
|
|
fits(b) {
|
|
if (!boxesContain(this.binbounds, b)) {
|
|
if (debug)
|
|
console.log("out of bounds!", b.left, b.top, b.right, b.bottom);
|
|
return false;
|
|
}
|
|
if (this.getBoxes(b, 1).length > 0) {
|
|
if (debug)
|
|
console.log("intersect!", b.left, b.top, b.right, b.bottom);
|
|
return false;
|
|
}
|
|
return true;
|
|
}
|
|
bestFit(b) {
|
|
let bestscore = 0;
|
|
let best = null;
|
|
for (let f of this.free) {
|
|
if (b.left != null && b.left < f.left)
|
|
continue;
|
|
if (b.left != null && b.left + b.width > f.right)
|
|
continue;
|
|
if (b.top != null && b.top < f.top)
|
|
continue;
|
|
if (b.top != null && b.top + b.height > f.bottom)
|
|
continue;
|
|
let dx = f.right - f.left - b.width;
|
|
let dy = f.bottom - f.top - b.height;
|
|
if (dx >= 0 && dy >= 0) {
|
|
let score = 1 / (1 + dx + dy + f.left * 1e-3);
|
|
if (score > bestscore) {
|
|
best = f;
|
|
bestscore = score;
|
|
if (score == 1)
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
return best;
|
|
}
|
|
anyFit(b) {
|
|
let bestscore = 0;
|
|
let best = null;
|
|
for (let f of this.free) {
|
|
let box = {
|
|
left: b.left != null ? b.left : f.left,
|
|
right: f.left + b.width,
|
|
top: b.top != null ? b.top : f.top,
|
|
bottom: f.top + b.height
|
|
};
|
|
if (this.fits(box)) {
|
|
let score = 1 / (1 + box.left + box.top);
|
|
if (score > bestscore) {
|
|
best = f;
|
|
if (score == 1)
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
return best;
|
|
}
|
|
add(b) {
|
|
if (debug)
|
|
console.log("add", b.left, b.top, b.right, b.bottom);
|
|
if (!this.fits(b)) {
|
|
throw new Error(`bad fit ${b.left} ${b.top} ${b.right} ${b.bottom}`);
|
|
}
|
|
this.boxes.push(b);
|
|
this.extents.right = Math.max(this.extents.right, b.right);
|
|
this.extents.bottom = Math.max(this.extents.bottom, b.bottom);
|
|
for (let p of b.parents) {
|
|
let i = this.free.indexOf(p);
|
|
if (i < 0)
|
|
throw new Error("cannot find parent");
|
|
if (debug)
|
|
console.log("removed", p.left, p.top, p.right, p.bottom);
|
|
this.free.splice(i, 1);
|
|
this.addFree(p.left, p.top, b.left, p.bottom);
|
|
this.addFree(b.right, p.top, p.right, p.bottom);
|
|
this.addFree(b.left, p.top, b.right, b.top);
|
|
this.addFree(b.left, b.bottom, b.right, p.bottom);
|
|
}
|
|
}
|
|
addFree(left, top, right, bottom) {
|
|
if (bottom > top && right > left) {
|
|
let b = { left, top, right, bottom };
|
|
if (debug)
|
|
console.log("free", b.left, b.top, b.right, b.bottom);
|
|
this.free.push(b);
|
|
}
|
|
}
|
|
};
|
|
var Packer = class {
|
|
constructor() {
|
|
this.bins = [];
|
|
this.boxes = [];
|
|
this.defaultPlacement = 0;
|
|
}
|
|
pack() {
|
|
for (let bc of this.boxes) {
|
|
let box = this.bestPlacement(bc);
|
|
if (!box)
|
|
return false;
|
|
box.bin.add(box);
|
|
bc.box = box;
|
|
}
|
|
return true;
|
|
}
|
|
bestPlacement(b) {
|
|
for (let bin of this.bins) {
|
|
let parent = bin.bestFit(b);
|
|
let approx = false;
|
|
if (!parent) {
|
|
parent = bin.anyFit(b);
|
|
approx = true;
|
|
if (debug)
|
|
console.log("anyfit", parent == null ? void 0 : parent.left, parent == null ? void 0 : parent.top);
|
|
}
|
|
if (parent) {
|
|
let place = this.defaultPlacement;
|
|
let box = {
|
|
left: parent.left,
|
|
top: parent.top,
|
|
right: parent.left + b.width,
|
|
bottom: parent.top + b.height
|
|
};
|
|
if (b.left != null) {
|
|
box.left = b.left;
|
|
box.right = b.left + b.width;
|
|
}
|
|
if (b.top != null) {
|
|
box.top = b.top;
|
|
box.bottom = b.top + b.height;
|
|
}
|
|
if (place == 2 || place == 3) {
|
|
let h = box.bottom - box.top;
|
|
box.top = parent.bottom - h;
|
|
box.bottom = parent.bottom;
|
|
}
|
|
if (place == 1 || place == 3) {
|
|
let w = box.right - box.left;
|
|
box.left = parent.right - w;
|
|
box.right = parent.right;
|
|
}
|
|
if (debug)
|
|
console.log("place", b.label, box.left, box.top, box.right, box.bottom, parent == null ? void 0 : parent.left, parent == null ? void 0 : parent.top);
|
|
let parents = [parent];
|
|
if (approx)
|
|
parents = bin.getBoxes(box, 100, bin.free);
|
|
return __spreadValues({ parents, place, bin }, box);
|
|
}
|
|
}
|
|
if (debug)
|
|
console.log("cannot place!", b.left, b.top, b.width, b.height);
|
|
return null;
|
|
}
|
|
toSVG() {
|
|
let s = "";
|
|
let r = { width: 100, height: 70 };
|
|
for (let bin of this.bins) {
|
|
r.width = Math.max(r.width, bin.binbounds.right);
|
|
r.height = Math.max(r.height, bin.binbounds.bottom);
|
|
}
|
|
s += `<svg viewBox="0 0 ${r.width} ${r.height}" xmlns="http://www.w3.org/2000/svg"><style><![CDATA[text {font: 1px sans-serif;}]]></style>`;
|
|
for (let bin of this.bins) {
|
|
let be = bin.extents;
|
|
s += "<g>";
|
|
s += `<rect width="${be.right - be.left}" height="${be.bottom - be.top}" stroke="black" stroke-width="0.5" fill="none"/>`;
|
|
let textx = be.right + 1;
|
|
let texty = 0;
|
|
for (let box of this.boxes) {
|
|
let b = box.box;
|
|
if (b) {
|
|
if (b.bin == bin)
|
|
s += `<rect width="${b.right - b.left}" height="${b.bottom - b.top}" x="${b.left}" y="${b.top}" stroke="black" stroke-width="0.25" fill="#ccc"/>`;
|
|
if (b.top == texty)
|
|
textx += 10;
|
|
else
|
|
textx = be.right + 1;
|
|
texty = b.top;
|
|
if (box.label)
|
|
s += `<text x="${textx}" y="${texty}" height="1">${box.label}</text>`;
|
|
}
|
|
}
|
|
s += "</g>";
|
|
}
|
|
s += `</svg>`;
|
|
return s;
|
|
}
|
|
toSVGUrl() {
|
|
return `data:image/svg+xml;base64,${btoa(this.toSVG())}`;
|
|
}
|
|
};
|
|
|
|
// src/common/ecs/ecs.ts
|
|
var ECSError = class extends Error {
|
|
constructor(msg, obj) {
|
|
super(msg);
|
|
this.$sources = [];
|
|
Object.setPrototypeOf(this, ECSError.prototype);
|
|
if (obj)
|
|
this.$loc = obj.$loc || obj;
|
|
}
|
|
};
|
|
function mksymbol(c, fieldName) {
|
|
return c.name + "_" + fieldName;
|
|
}
|
|
function mkscopesymbol(s, c, fieldName) {
|
|
return s.name + "_" + c.name + "_" + fieldName;
|
|
}
|
|
var SystemStats = class {
|
|
};
|
|
var SELECT_TYPE = ["once", "foreach", "join", "with", "if", "select", "unroll"];
|
|
function isLiteral2(arg) {
|
|
return arg.value != null;
|
|
}
|
|
function isLiteralInt(arg) {
|
|
return isLiteral2(arg) && arg.valtype.dtype == "int";
|
|
}
|
|
function isBinOp2(arg) {
|
|
return arg.op != null && arg.left != null && arg.right != null;
|
|
}
|
|
function isUnOp2(arg) {
|
|
return arg.op != null && arg.expr != null;
|
|
}
|
|
function isBlockStmt(arg) {
|
|
return arg.stmts != null;
|
|
}
|
|
function isInlineCode(arg) {
|
|
return arg.code != null;
|
|
}
|
|
function isQueryExpr(arg) {
|
|
return arg.query != null;
|
|
}
|
|
var Dialect_CA65 = class {
|
|
constructor() {
|
|
this.ASM_ITERATE_EACH_ASC = `
|
|
ldx #0
|
|
@__each:
|
|
{{%code}}
|
|
inx
|
|
cpx #{{%ecount}}
|
|
jne @__each
|
|
@__exit:
|
|
`;
|
|
this.ASM_ITERATE_EACH_DESC = `
|
|
ldx #{{%ecount}}-1
|
|
@__each:
|
|
{{%code}}
|
|
dex
|
|
jpl @__each
|
|
@__exit:
|
|
`;
|
|
this.ASM_ITERATE_JOIN_ASC = `
|
|
ldy #0
|
|
@__each:
|
|
ldx {{%joinfield}},y
|
|
{{%code}}
|
|
iny
|
|
cpy #{{%ecount}}
|
|
jne @__each
|
|
@__exit:
|
|
`;
|
|
this.ASM_ITERATE_JOIN_DESC = `
|
|
ldy #{{%ecount}}-1
|
|
@__each:
|
|
ldx {{%joinfield}},y
|
|
{{%code}}
|
|
dey
|
|
jpl @__each
|
|
@__exit:
|
|
`;
|
|
this.ASM_FILTER_RANGE_LO_X = `
|
|
cpx #{{%xofs}}
|
|
jcc @__skipxlo
|
|
{{%code}}
|
|
@__skipxlo:
|
|
`;
|
|
this.ASM_FILTER_RANGE_HI_X = `
|
|
cpx #{{%xofs}}+{{%ecount}}
|
|
jcs @__skipxhi
|
|
{{%code}}
|
|
@__skipxhi:
|
|
`;
|
|
this.ASM_LOOKUP_REF_X = `
|
|
ldx {{%reffield}}
|
|
{{%code}}
|
|
`;
|
|
this.INIT_FROM_ARRAY = `
|
|
ldy #{{%nbytes}}
|
|
: lda {{%src}}-1,y
|
|
sta {{%dest}}-1,y
|
|
dey
|
|
bne :-
|
|
`;
|
|
}
|
|
comment(s) {
|
|
return `
|
|
;;; ${s}
|
|
`;
|
|
}
|
|
absolute(ident, offset) {
|
|
return this.addOffset(ident, offset || 0);
|
|
}
|
|
addOffset(ident, offset) {
|
|
if (offset > 0)
|
|
return `${ident}+${offset}`;
|
|
if (offset < 0)
|
|
return `${ident}-${-offset}`;
|
|
return ident;
|
|
}
|
|
indexed_x(ident, offset) {
|
|
return this.addOffset(ident, offset) + ",x";
|
|
}
|
|
indexed_y(ident, offset) {
|
|
return this.addOffset(ident, offset) + ",y";
|
|
}
|
|
fieldsymbol(component, field, bitofs) {
|
|
return `${component.name}_${field.name}_b${bitofs}`;
|
|
}
|
|
datasymbol(component, field, eid, bitofs) {
|
|
return `${component.name}_${field.name}_e${eid}_b${bitofs}`;
|
|
}
|
|
debug_file(path) {
|
|
return `.dbg file, "${path}", 0, 0`;
|
|
}
|
|
debug_line(path, line) {
|
|
return `.dbg line, "${path}", ${line}`;
|
|
}
|
|
startScope(name) {
|
|
return `.scope ${name}`;
|
|
}
|
|
endScope(name) {
|
|
return `.endscope
|
|
${this.scopeSymbol(name)} = ${name}::__Start`;
|
|
}
|
|
scopeSymbol(name) {
|
|
return `${name}__Start`;
|
|
}
|
|
align(value) {
|
|
return `.align ${value}`;
|
|
}
|
|
alignSegmentStart() {
|
|
return this.label("__ALIGNORIGIN");
|
|
}
|
|
warningIfPageCrossed(startlabel) {
|
|
return `
|
|
.assert >(${startlabel}) = >(*), error, "${startlabel} crosses a page boundary!"`;
|
|
}
|
|
warningIfMoreThan(bytes, startlabel) {
|
|
return `
|
|
.assert (* - ${startlabel}) <= ${bytes}, error, .sprintf("${startlabel} does not fit in ${bytes} bytes, it took %d!", (* - ${startlabel}))`;
|
|
}
|
|
alignIfLessThan(bytes) {
|
|
return `
|
|
.if <(* - __ALIGNORIGIN) > 256-${bytes}
|
|
.align $100
|
|
.endif`;
|
|
}
|
|
segment(segtype) {
|
|
if (segtype == "bss") {
|
|
return `.zeropage`;
|
|
} else if (segtype == "rodata") {
|
|
return ".rodata";
|
|
} else {
|
|
return `.code`;
|
|
}
|
|
}
|
|
label(sym) {
|
|
return `${sym}:`;
|
|
}
|
|
export(sym) {
|
|
return `.export _${sym} = ${sym}`;
|
|
}
|
|
byte(b) {
|
|
if (b === void 0) {
|
|
return `.res 1`;
|
|
} else if (typeof b === "number") {
|
|
if (b < 0 || b > 255)
|
|
throw new ECSError(`out of range byte ${b}`);
|
|
return `.byte ${b}`;
|
|
} else {
|
|
if (b.bitofs == 0)
|
|
return `.byte <${b.symbol}`;
|
|
else if (b.bitofs == 8)
|
|
return `.byte >${b.symbol}`;
|
|
else
|
|
return `.byte ((${b.symbol} >> ${b.bitofs})&255)`;
|
|
}
|
|
}
|
|
tempLabel(inst) {
|
|
return `${inst.system.name}__${inst.id}__tmp`;
|
|
}
|
|
equate(symbol, value) {
|
|
return `${symbol} = ${value}`;
|
|
}
|
|
define(symbol, value) {
|
|
if (value)
|
|
return `.define ${symbol} ${value}`;
|
|
else
|
|
return `.define ${symbol}`;
|
|
}
|
|
call(symbol) {
|
|
return ` jsr ${symbol}`;
|
|
}
|
|
jump(symbol) {
|
|
return ` jmp ${symbol}`;
|
|
}
|
|
return() {
|
|
return " rts";
|
|
}
|
|
};
|
|
var SourceFileExport = class {
|
|
constructor() {
|
|
this.lines = [];
|
|
}
|
|
line(s) {
|
|
this.text(s);
|
|
}
|
|
text(s) {
|
|
for (let l of s.split("\n"))
|
|
this.lines.push(l);
|
|
}
|
|
toString() {
|
|
return this.lines.join("\n");
|
|
}
|
|
};
|
|
var CodeSegment = class {
|
|
constructor() {
|
|
this.codefrags = [];
|
|
}
|
|
addCodeFragment(code) {
|
|
this.codefrags.push(code);
|
|
}
|
|
dump(file) {
|
|
for (let code of this.codefrags) {
|
|
file.text(code);
|
|
}
|
|
}
|
|
};
|
|
var DataSegment = class {
|
|
constructor() {
|
|
this.symbols = {};
|
|
this.equates = {};
|
|
this.ofs2sym = new Map();
|
|
this.fieldranges = {};
|
|
this.size = 0;
|
|
this.initdata = [];
|
|
}
|
|
allocateBytes(name, bytes) {
|
|
let ofs = this.symbols[name];
|
|
if (ofs == null) {
|
|
ofs = this.size;
|
|
this.declareSymbol(name, ofs);
|
|
this.size += bytes;
|
|
}
|
|
return ofs;
|
|
}
|
|
declareSymbol(name, ofs) {
|
|
var _a;
|
|
this.symbols[name] = ofs;
|
|
if (!this.ofs2sym.has(ofs))
|
|
this.ofs2sym.set(ofs, []);
|
|
(_a = this.ofs2sym.get(ofs)) == null ? void 0 : _a.push(name);
|
|
}
|
|
findExistingInitData(bytes) {
|
|
for (let i = 0; i < this.size - bytes.length; i++) {
|
|
for (var j = 0; j < bytes.length; j++) {
|
|
if (this.initdata[i + j] !== bytes[j])
|
|
break;
|
|
}
|
|
if (j == bytes.length)
|
|
return i;
|
|
}
|
|
return -1;
|
|
}
|
|
allocateInitData(name, bytes) {
|
|
let ofs = this.findExistingInitData(bytes);
|
|
if (ofs >= 0) {
|
|
this.declareSymbol(name, ofs);
|
|
} else {
|
|
ofs = this.allocateBytes(name, bytes.length);
|
|
for (let i = 0; i < bytes.length; i++) {
|
|
this.initdata[ofs + i] = bytes[i];
|
|
}
|
|
}
|
|
}
|
|
dump(file, dialect, doExport) {
|
|
for (let i = 0; i < this.size; i++) {
|
|
let syms = this.ofs2sym.get(i);
|
|
if (syms) {
|
|
for (let sym of syms) {
|
|
if (doExport)
|
|
file.line(dialect.export(sym));
|
|
file.line(dialect.label(sym));
|
|
}
|
|
}
|
|
file.line(dialect.byte(this.initdata[i]));
|
|
}
|
|
for (let [symbol, value] of Object.entries(this.equates)) {
|
|
file.line(dialect.equate(symbol, value));
|
|
}
|
|
}
|
|
getFieldRange(component, fieldName) {
|
|
return this.fieldranges[mksymbol(component, fieldName)];
|
|
}
|
|
getByteOffset(range, access, entityID) {
|
|
if (entityID < range.elo)
|
|
throw new ECSError(`entity ID ${entityID} too low for ${access.symbol}`);
|
|
if (entityID > range.ehi)
|
|
throw new ECSError(`entity ID ${entityID} too high for ${access.symbol}`);
|
|
let ofs = this.symbols[access.symbol];
|
|
if (ofs !== void 0) {
|
|
return ofs + entityID - range.elo;
|
|
}
|
|
throw new ECSError(`cannot find field access for ${access.symbol}`);
|
|
}
|
|
getOriginSymbol() {
|
|
let a = this.ofs2sym.get(0);
|
|
if (!a)
|
|
throw new ECSError("getOriginSymbol(): no symbol at offset 0");
|
|
return a[0];
|
|
}
|
|
};
|
|
var UninitDataSegment = class extends DataSegment {
|
|
};
|
|
var ConstDataSegment = class extends DataSegment {
|
|
};
|
|
function getFieldBits(f) {
|
|
let n = f.hi - f.lo + 1;
|
|
return Math.ceil(Math.log2(n));
|
|
}
|
|
function getFieldLength(f) {
|
|
if (f.dtype == "int") {
|
|
return f.hi - f.lo + 1;
|
|
} else {
|
|
return 1;
|
|
}
|
|
}
|
|
function getPackedFieldSize(f, constValue) {
|
|
if (f.dtype == "int") {
|
|
return getFieldBits(f);
|
|
}
|
|
if (f.dtype == "array" && f.index) {
|
|
return 0;
|
|
}
|
|
if (f.dtype == "array" && constValue != null && Array.isArray(constValue)) {
|
|
return constValue.length * getPackedFieldSize(f.elem);
|
|
}
|
|
if (f.dtype == "ref") {
|
|
return 8;
|
|
}
|
|
return 0;
|
|
}
|
|
var EntitySet = class {
|
|
constructor(scope, query, e) {
|
|
this.scope = scope;
|
|
if (query) {
|
|
if (query.entities) {
|
|
this.entities = query.entities.slice(0);
|
|
} else {
|
|
this.atypes = scope.em.archetypesMatching(query);
|
|
this.entities = scope.entitiesMatching(this.atypes);
|
|
}
|
|
if (query.limit) {
|
|
this.entities = this.entities.slice(0, query.limit);
|
|
}
|
|
} else if (e) {
|
|
this.entities = e;
|
|
} else {
|
|
throw new ECSError("invalid EntitySet constructor");
|
|
}
|
|
if (!this.atypes) {
|
|
let at = new Set();
|
|
for (let e2 of this.entities)
|
|
at.add(e2.etype);
|
|
this.atypes = Array.from(at.values());
|
|
}
|
|
}
|
|
contains(c, f, where) {
|
|
return this.scope.em.singleComponentWithFieldName(this.atypes, f.name, where);
|
|
}
|
|
intersection(qr) {
|
|
let ents = this.entities.filter((e) => qr.entities.includes(e));
|
|
return new EntitySet(this.scope, void 0, ents);
|
|
}
|
|
union(qr) {
|
|
let ents = this.entities.concat(qr.entities);
|
|
let atypes = this.atypes.concat(qr.atypes);
|
|
return new EntitySet(this.scope, void 0, ents);
|
|
}
|
|
isContiguous() {
|
|
if (this.entities.length == 0)
|
|
return true;
|
|
let id = this.entities[0].id;
|
|
for (let i = 1; i < this.entities.length; i++) {
|
|
if (this.entities[i].id != ++id)
|
|
return false;
|
|
}
|
|
return true;
|
|
}
|
|
};
|
|
var IndexRegister = class {
|
|
constructor(scope, eset) {
|
|
this.scope = scope;
|
|
this.elo = 0;
|
|
this.ehi = scope.entities.length - 1;
|
|
this.lo = null;
|
|
this.hi = null;
|
|
if (eset) {
|
|
this.narrowInPlace(eset);
|
|
}
|
|
}
|
|
entityCount() {
|
|
return this.ehi - this.elo + 1;
|
|
}
|
|
clone() {
|
|
return Object.assign(new IndexRegister(this.scope), this);
|
|
}
|
|
narrow(eset, action) {
|
|
let i = this.clone();
|
|
return i.narrowInPlace(eset, action) ? i : null;
|
|
}
|
|
narrowInPlace(eset, action) {
|
|
if (this.scope != eset.scope)
|
|
throw new ECSError(`scope mismatch`, action);
|
|
if (!eset.isContiguous())
|
|
throw new ECSError(`entities are not contiguous`, action);
|
|
if (this.eset) {
|
|
this.eset = this.eset.intersection(eset);
|
|
} else {
|
|
this.eset = eset;
|
|
}
|
|
if (this.eset.entities.length == 0) {
|
|
return false;
|
|
}
|
|
let newelo = this.eset.entities[0].id;
|
|
let newehi = this.eset.entities[this.eset.entities.length - 1].id;
|
|
if (this.lo === null || this.hi === null) {
|
|
this.lo = 0;
|
|
this.hi = newehi - newelo;
|
|
this.elo = newelo;
|
|
this.ehi = newehi;
|
|
} else {
|
|
this.lo += newelo - this.elo;
|
|
this.hi += newehi - this.ehi;
|
|
}
|
|
return true;
|
|
}
|
|
offset() {
|
|
return this.lo || 0;
|
|
}
|
|
};
|
|
var ActionCPUState = class {
|
|
constructor() {
|
|
this.xreg = null;
|
|
this.yreg = null;
|
|
}
|
|
};
|
|
var ActionEval = class {
|
|
constructor(scope, instance, action, eventargs) {
|
|
this.scope = scope;
|
|
this.instance = instance;
|
|
this.action = action;
|
|
this.eventargs = eventargs;
|
|
this.tmplabel = "";
|
|
this.em = scope.em;
|
|
this.dialect = scope.em.dialect;
|
|
this.tmplabel = this.dialect.tempLabel(this.instance);
|
|
this.seq = this.em.seq++;
|
|
this.label = `${this.instance.system.name}__${action.event}__${this.seq}`;
|
|
}
|
|
begin() {
|
|
}
|
|
end() {
|
|
}
|
|
codeToString() {
|
|
let code = this.exprToCode(this.action.expr);
|
|
return code;
|
|
}
|
|
replaceTags(code, action, props) {
|
|
const tag_re = /\{\{(.+?)\}\}/g;
|
|
code = code.replace(tag_re, (entire, group) => {
|
|
let toks = group.split(/\s+/);
|
|
if (toks.length == 0)
|
|
throw new ECSError(`empty command`, action);
|
|
let cmd = group.charAt(0);
|
|
let arg0 = toks[0].substring(1).trim();
|
|
let args = [arg0].concat(toks.slice(1));
|
|
switch (cmd) {
|
|
case "!":
|
|
return this.__emit(args);
|
|
case "$":
|
|
return this.__local(args);
|
|
case "^":
|
|
return this.__use(args);
|
|
case "#":
|
|
return this.__arg(args);
|
|
case "&":
|
|
return this.__eid(args);
|
|
case "<":
|
|
return this.__get([arg0, "0"]);
|
|
case ">":
|
|
return this.__get([arg0, "8"]);
|
|
default:
|
|
let value = props[toks[0]];
|
|
if (value)
|
|
return value;
|
|
let fn = this["__" + toks[0]];
|
|
if (fn)
|
|
return fn.bind(this)(toks.slice(1));
|
|
throw new ECSError(`unrecognized command {{${toks[0]}}}`, action);
|
|
}
|
|
});
|
|
return code;
|
|
}
|
|
replaceLabels(code) {
|
|
const label_re = /@(\w+)\b/g;
|
|
let seq = this.em.seq++;
|
|
let label = `${this.instance.system.name}__${this.action.event}__${seq}`;
|
|
code = code.replace(label_re, (s, a) => `${label}__${a}`);
|
|
return code;
|
|
}
|
|
__get(args) {
|
|
return this.getset(args, false);
|
|
}
|
|
__set(args) {
|
|
return this.getset(args, true);
|
|
}
|
|
getset(args, canwrite) {
|
|
let fieldName = args[0];
|
|
let bitofs = parseInt(args[1] || "0");
|
|
return this.generateCodeForField(fieldName, bitofs, canwrite);
|
|
}
|
|
parseFieldArgs(args) {
|
|
let fieldName = args[0];
|
|
let bitofs = parseInt(args[1] || "0");
|
|
let component = this.em.singleComponentWithFieldName(this.scope.state.working.atypes, fieldName, this.action);
|
|
let field = component.fields.find((f) => f.name == fieldName);
|
|
if (field == null)
|
|
throw new ECSError(`no field named "${fieldName}" in component`, this.action);
|
|
return { component, field, bitofs };
|
|
}
|
|
__base(args) {
|
|
let { component, field, bitofs } = this.parseFieldArgs(args);
|
|
return this.dialect.fieldsymbol(component, field, bitofs);
|
|
}
|
|
__data(args) {
|
|
let { component, field, bitofs } = this.parseFieldArgs(args);
|
|
let entities = this.scope.state.working.entities;
|
|
if (entities.length != 1)
|
|
throw new ECSError(`data operates on exactly one entity`, this.action);
|
|
let eid = entities[0].id;
|
|
return this.dialect.datasymbol(component, field, eid, bitofs);
|
|
}
|
|
__const(args) {
|
|
let { component, field, bitofs } = this.parseFieldArgs(args);
|
|
let entities = this.scope.state.working.entities;
|
|
if (entities.length != 1)
|
|
throw new ECSError(`const operates on exactly one entity`, this.action);
|
|
let constVal = entities[0].consts[mksymbol(component, field.name)];
|
|
if (constVal === void 0)
|
|
throw new ECSError(`field is not constant`, this.action);
|
|
if (typeof constVal !== "number")
|
|
throw new ECSError(`field is not numeric`, this.action);
|
|
return constVal << bitofs;
|
|
}
|
|
__index(args) {
|
|
let ident = args[0];
|
|
let index = parseInt(args[1] || "0");
|
|
let entities = this.scope.state.working.entities;
|
|
if (entities.length == 1) {
|
|
return this.dialect.absolute(ident);
|
|
} else {
|
|
return this.dialect.indexed_x(ident, index);
|
|
}
|
|
}
|
|
__eid(args) {
|
|
let e = this.scope.getEntityByName(args[0] || "?");
|
|
if (!e)
|
|
throw new ECSError(`can't find entity named "${args[0]}"`, this.action);
|
|
return e.id.toString();
|
|
}
|
|
__use(args) {
|
|
return this.scope.includeResource(args[0]);
|
|
}
|
|
__emit(args) {
|
|
let event = args[0];
|
|
let eventargs = args.slice(1);
|
|
try {
|
|
return this.scope.generateCodeForEvent(event, eventargs);
|
|
} catch (e) {
|
|
if (e.$sources)
|
|
e.$sources.push(this.action);
|
|
throw e;
|
|
}
|
|
}
|
|
__local(args) {
|
|
let tempinc = parseInt(args[0]);
|
|
let tempbytes = this.instance.system.tempbytes;
|
|
if (isNaN(tempinc))
|
|
throw new ECSError(`bad temporary offset`, this.action);
|
|
if (!tempbytes)
|
|
throw new ECSError(`this system has no locals`, this.action);
|
|
if (tempinc < 0 || tempinc >= tempbytes)
|
|
throw new ECSError(`this system only has ${tempbytes} locals`, this.action);
|
|
this.scope.updateTempLiveness(this.instance);
|
|
return `${this.tmplabel}+${tempinc}`;
|
|
}
|
|
__arg(args) {
|
|
let argindex = parseInt(args[0] || "0");
|
|
let argvalue = this.eventargs[argindex] || "";
|
|
return argvalue;
|
|
}
|
|
__start(args) {
|
|
let startSymbol = this.dialect.scopeSymbol(args[0]);
|
|
return this.dialect.jump(startSymbol);
|
|
}
|
|
generateCodeForField(fieldName, bitofs, canWrite) {
|
|
var _a, _b, _c, _d;
|
|
const action = this.action;
|
|
const qr = this.scope.state.working;
|
|
var component;
|
|
var baseLookup = false;
|
|
var entityLookup = false;
|
|
let entities;
|
|
if (fieldName.indexOf(".") > 0) {
|
|
let [entname, fname] = fieldName.split(".");
|
|
let ent = this.scope.getEntityByName(entname);
|
|
if (ent == null)
|
|
throw new ECSError(`no entity named "${entname}" in this scope`, action);
|
|
component = this.em.singleComponentWithFieldName([ent.etype], fname, action);
|
|
fieldName = fname;
|
|
entities = [ent];
|
|
entityLookup = true;
|
|
} else if (fieldName.indexOf(":") > 0) {
|
|
let [cname, fname] = fieldName.split(":");
|
|
component = this.em.getComponentByName(cname);
|
|
if (component == null)
|
|
throw new ECSError(`no component named "${cname}"`, action);
|
|
entities = this.scope.state.working.entities;
|
|
fieldName = fname;
|
|
baseLookup = true;
|
|
} else {
|
|
component = this.em.singleComponentWithFieldName(qr.atypes, fieldName, action);
|
|
entities = this.scope.state.working.entities;
|
|
}
|
|
let field = component.fields.find((f) => f.name == fieldName);
|
|
if (field == null)
|
|
throw new ECSError(`no field named "${fieldName}" in component`, action);
|
|
let ident = this.dialect.fieldsymbol(component, field, bitofs);
|
|
let constValues = new Set();
|
|
let isConst = false;
|
|
for (let e of entities) {
|
|
let constVal = e.consts[mksymbol(component, fieldName)];
|
|
if (constVal !== void 0)
|
|
isConst = true;
|
|
constValues.add(constVal);
|
|
}
|
|
if (isConst && canWrite)
|
|
throw new ECSError(`can't write to constant field ${fieldName}`, action);
|
|
if (constValues.size == 1) {
|
|
let value = constValues.values().next().value;
|
|
if (typeof value === "number") {
|
|
return `#${value >> bitofs & 255}`;
|
|
}
|
|
}
|
|
let range = this.scope.getFieldRange(component, field.name);
|
|
if (!range)
|
|
throw new ECSError(`couldn't find field for ${component.name}:${fieldName}, maybe no entities?`);
|
|
if (baseLookup) {
|
|
return this.dialect.absolute(ident);
|
|
} else if (entities.length == 1) {
|
|
let eidofs = entities[0].id - range.elo;
|
|
return this.dialect.absolute(ident, eidofs);
|
|
} else {
|
|
let ir;
|
|
let int;
|
|
let eidofs;
|
|
let xreg = this.scope.state.xreg;
|
|
let yreg = this.scope.state.yreg;
|
|
if (xreg && (int = (_a = xreg.eset) == null ? void 0 : _a.intersection(qr))) {
|
|
ir = xreg.eset;
|
|
eidofs = xreg.elo - range.elo;
|
|
} else if (yreg && (int = (_b = yreg.eset) == null ? void 0 : _b.intersection(qr))) {
|
|
ir = yreg.eset;
|
|
eidofs = yreg.elo - range.elo;
|
|
} else {
|
|
ir = null;
|
|
eidofs = 0;
|
|
}
|
|
if (!ir) {
|
|
throw new ECSError(`no intersection for index register`, action);
|
|
}
|
|
if (ir.entities.length == 0)
|
|
throw new ECSError(`no common entities for index register`, action);
|
|
if (!ir.isContiguous())
|
|
throw new ECSError(`entities in query are not contiguous`, action);
|
|
if (ir == ((_c = this.scope.state.xreg) == null ? void 0 : _c.eset))
|
|
return this.dialect.indexed_x(ident, eidofs);
|
|
if (ir == ((_d = this.scope.state.yreg) == null ? void 0 : _d.eset))
|
|
return this.dialect.indexed_y(ident, eidofs);
|
|
throw new ECSError(`cannot find "${component.name}:${field.name}" in state`, action);
|
|
}
|
|
}
|
|
getJoinField(action, atypes, jtypes) {
|
|
let refs = Array.from(this.scope.iterateArchetypeFields(atypes, (c, f) => f.dtype == "ref"));
|
|
if (refs.length == 0)
|
|
throw new ECSError(`cannot find join fields`, action);
|
|
if (refs.length > 1)
|
|
throw new ECSError(`cannot join multiple fields (${refs.map((r) => r.f.name).join(" ")})`, action);
|
|
return refs[0];
|
|
}
|
|
isSubroutineSized(code) {
|
|
if (code.length > 2e4)
|
|
return false;
|
|
if (code.split("\n ").length >= 4)
|
|
return true;
|
|
return false;
|
|
}
|
|
exprToCode(expr) {
|
|
if (isQueryExpr(expr)) {
|
|
return this.queryExprToCode(expr);
|
|
}
|
|
if (isBlockStmt(expr)) {
|
|
return this.blockStmtToCode(expr);
|
|
}
|
|
if (isInlineCode(expr)) {
|
|
return this.evalInlineCode(expr.code);
|
|
}
|
|
throw new ECSError(`cannot convert expression to code`, expr);
|
|
}
|
|
evalInlineCode(code) {
|
|
let props = this.scope.state.props || {};
|
|
code = this.replaceLabels(code);
|
|
code = this.replaceTags(code, this.action, props);
|
|
return code;
|
|
}
|
|
blockStmtToCode(expr) {
|
|
return expr.stmts.map((node) => this.exprToCode(node)).join("\n");
|
|
}
|
|
queryExprToCode(qexpr) {
|
|
let q = this.startQuery(qexpr);
|
|
const allowEmpty = ["if", "foreach", "join"];
|
|
if (q.working.entities.length == 0 && allowEmpty.includes(qexpr.select)) {
|
|
this.endQuery(q);
|
|
return "";
|
|
} else {
|
|
this.scope.state.working = q.working;
|
|
this.scope.state.props = q.props;
|
|
q.code = this.evalInlineCode(q.code);
|
|
let body = this.blockStmtToCode(qexpr);
|
|
this.endQuery(q);
|
|
body = q.code.replace("%%CODE%%", body);
|
|
return body;
|
|
}
|
|
}
|
|
queryWorkingSet(qexpr) {
|
|
const scope = this.scope;
|
|
const instance = this.instance;
|
|
let select = qexpr.select;
|
|
let q = qexpr.query;
|
|
let qr = new EntitySet(scope, q);
|
|
if (!(qexpr.all || q.entities)) {
|
|
let ir = qr.intersection(scope.state.working);
|
|
if (ir.entities.length || select == "if") {
|
|
qr = ir;
|
|
}
|
|
}
|
|
if (instance.params.refEntity && instance.params.refField) {
|
|
let rf = instance.params.refField;
|
|
if (rf.f.dtype == "ref") {
|
|
let rq = rf.f.query;
|
|
qr = qr.intersection(new EntitySet(scope, rq));
|
|
}
|
|
} else if (instance.params.query) {
|
|
qr = qr.intersection(new EntitySet(scope, instance.params.query));
|
|
}
|
|
return qr;
|
|
}
|
|
updateIndexRegisters(qr, jr, select) {
|
|
const action = this.action;
|
|
const scope = this.scope;
|
|
const instance = this.instance;
|
|
const state = this.scope.state;
|
|
if (qr.entities.length > 1) {
|
|
switch (select) {
|
|
case "once":
|
|
break;
|
|
case "foreach":
|
|
case "unroll":
|
|
if (state.xreg && state.yreg)
|
|
throw new ECSError("no more index registers", action);
|
|
if (state.xreg)
|
|
state.yreg = new IndexRegister(scope, qr);
|
|
else
|
|
state.xreg = new IndexRegister(scope, qr);
|
|
break;
|
|
case "join":
|
|
if (state.xreg || state.yreg)
|
|
throw new ECSError("no free index registers for join", action);
|
|
if (jr)
|
|
state.xreg = new IndexRegister(scope, jr);
|
|
state.yreg = new IndexRegister(scope, qr);
|
|
break;
|
|
case "if":
|
|
case "with":
|
|
if (state.xreg && state.xreg.eset) {
|
|
state.xreg = state.xreg.narrow(qr, action);
|
|
} else if (select == "with") {
|
|
if (instance.params.refEntity && instance.params.refField) {
|
|
if (state.xreg)
|
|
state.xreg.eset = qr;
|
|
else
|
|
state.xreg = new IndexRegister(scope, qr);
|
|
}
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
getCodeAndProps(qexpr, qr, jr, oldState) {
|
|
const entities = qr.entities;
|
|
const select = qexpr.select;
|
|
let code = "%%CODE%%";
|
|
let props = {};
|
|
if (select == "join" && jr) {
|
|
if (qr.entities.length) {
|
|
let joinfield = this.getJoinField(this.action, qr.atypes, jr.atypes);
|
|
code = this.wrapCodeInLoop(code, qexpr, qr.entities, joinfield);
|
|
props["%joinfield"] = this.dialect.fieldsymbol(joinfield.c, joinfield.f, 0);
|
|
}
|
|
}
|
|
let fullEntityCount = qr.entities.length;
|
|
if (select == "with") {
|
|
if (this.instance.params.refEntity && this.instance.params.refField) {
|
|
let re = this.instance.params.refEntity;
|
|
let rf = this.instance.params.refField;
|
|
code = this.wrapCodeInRefLookup(code);
|
|
let range = this.scope.getFieldRange(rf.c, rf.f.name);
|
|
let eidofs = re.id - range.elo;
|
|
props["%reffield"] = `${this.dialect.fieldsymbol(rf.c, rf.f, 0)}+${eidofs}`;
|
|
} else {
|
|
code = this.wrapCodeInFilter(code, qr, oldState, props);
|
|
}
|
|
}
|
|
if (select == "if") {
|
|
code = this.wrapCodeInFilter(code, qr, oldState, props);
|
|
}
|
|
if (select == "foreach" && entities.length > 1) {
|
|
code = this.wrapCodeInLoop(code, qexpr, qr.entities);
|
|
}
|
|
if (select == "unroll" && entities.length > 1) {
|
|
throw new ECSError("unroll is not yet implemented");
|
|
}
|
|
if (entities.length) {
|
|
props["%elo"] = entities[0].id.toString();
|
|
props["%ehi"] = entities[entities.length - 1].id.toString();
|
|
}
|
|
props["%ecount"] = entities.length.toString();
|
|
props["%efullcount"] = fullEntityCount.toString();
|
|
return { code, props };
|
|
}
|
|
startQuery(qexpr) {
|
|
const scope = this.scope;
|
|
const action = this.action;
|
|
const select = qexpr.select;
|
|
const oldState = this.scope.state;
|
|
this.scope.state = Object.assign(new ActionCPUState(), oldState);
|
|
const qr = this.queryWorkingSet(qexpr);
|
|
const jr = qexpr.join && qr.entities.length ? new EntitySet(scope, qexpr.join) : null;
|
|
this.updateIndexRegisters(qr, jr, select);
|
|
const { code, props } = this.getCodeAndProps(qexpr, qr, jr, oldState);
|
|
let working = jr ? qr.union(jr) : qr;
|
|
return { working, oldState, props, code };
|
|
}
|
|
endQuery(q) {
|
|
this.scope.state = q.oldState;
|
|
}
|
|
wrapCodeInLoop(code, qexpr, ents, joinfield) {
|
|
let dir = qexpr.direction;
|
|
let s = dir == "desc" ? this.dialect.ASM_ITERATE_EACH_DESC : this.dialect.ASM_ITERATE_EACH_ASC;
|
|
if (joinfield)
|
|
s = dir == "desc" ? this.dialect.ASM_ITERATE_JOIN_DESC : this.dialect.ASM_ITERATE_JOIN_ASC;
|
|
s = s.replace("{{%code}}", code);
|
|
return s;
|
|
}
|
|
wrapCodeInFilter(code, qr, oldState, props) {
|
|
var _a, _b;
|
|
const ents = qr.entities;
|
|
const ents2 = (_b = (_a = oldState.xreg) == null ? void 0 : _a.eset) == null ? void 0 : _b.entities;
|
|
if (ents && ents.length && ents2) {
|
|
let lo = ents[0].id;
|
|
let hi = ents[ents.length - 1].id;
|
|
let lo2 = ents2[0].id;
|
|
let hi2 = ents2[ents2.length - 1].id;
|
|
if (lo != lo2) {
|
|
code = this.dialect.ASM_FILTER_RANGE_LO_X.replace("{{%code}}", code);
|
|
props["%xofs"] = lo - lo2;
|
|
}
|
|
if (hi != hi2) {
|
|
code = this.dialect.ASM_FILTER_RANGE_HI_X.replace("{{%code}}", code);
|
|
}
|
|
}
|
|
return code;
|
|
}
|
|
wrapCodeInRefLookup(code) {
|
|
code = this.dialect.ASM_LOOKUP_REF_X.replace("{{%code}}", code);
|
|
return code;
|
|
}
|
|
};
|
|
var EventCodeStats = class {
|
|
constructor(inst, action, eventcode) {
|
|
this.inst = inst;
|
|
this.action = action;
|
|
this.eventcode = eventcode;
|
|
this.labels = [];
|
|
this.count = 0;
|
|
}
|
|
};
|
|
var EntityScope = class {
|
|
constructor(em, dialect, name, parent) {
|
|
this.em = em;
|
|
this.dialect = dialect;
|
|
this.name = name;
|
|
this.parent = parent;
|
|
this.childScopes = [];
|
|
this.instances = [];
|
|
this.entities = [];
|
|
this.fieldtypes = {};
|
|
this.sysstats = new Map();
|
|
this.bss = new UninitDataSegment();
|
|
this.rodata = new ConstDataSegment();
|
|
this.code = new CodeSegment();
|
|
this.componentsInScope = new Set();
|
|
this.resources = new Set();
|
|
this.isDemo = false;
|
|
this.filePath = "";
|
|
this.inCritical = 0;
|
|
parent == null ? void 0 : parent.childScopes.push(this);
|
|
this.state = new ActionCPUState();
|
|
this.state.working = new EntitySet(this, void 0, this.entities);
|
|
}
|
|
newEntity(etype, name) {
|
|
if (name && this.getEntityByName(name))
|
|
throw new ECSError(`already an entity named "${name}"`);
|
|
let id = this.entities.length;
|
|
etype = this.em.addArchetype(etype);
|
|
let entity = { id, etype, consts: {}, inits: {} };
|
|
for (let c of etype.components) {
|
|
this.componentsInScope.add(c.name);
|
|
}
|
|
entity.name = name;
|
|
this.entities.push(entity);
|
|
return entity;
|
|
}
|
|
newSystemInstance(inst) {
|
|
if (!inst)
|
|
throw new Error();
|
|
inst.id = this.instances.length + 1;
|
|
this.instances.push(inst);
|
|
this.em.registerSystemEvents(inst.system);
|
|
return inst;
|
|
}
|
|
newSystemInstanceWithDefaults(system) {
|
|
return this.newSystemInstance({ system, params: {}, id: 0 });
|
|
}
|
|
getSystemInstanceNamed(name) {
|
|
return this.instances.find((sys) => sys.system.name == name);
|
|
}
|
|
getEntityByName(name) {
|
|
return this.entities.find((e) => e.name == name);
|
|
}
|
|
*iterateEntityFields(entities) {
|
|
for (let i = 0; i < entities.length; i++) {
|
|
let e = entities[i];
|
|
for (let c of e.etype.components) {
|
|
for (let f of c.fields) {
|
|
yield { i, e, c, f, v: e.consts[mksymbol(c, f.name)] };
|
|
}
|
|
}
|
|
}
|
|
}
|
|
*iterateArchetypeFields(arch, filter) {
|
|
for (let i = 0; i < arch.length; i++) {
|
|
let a = arch[i];
|
|
for (let c of a.components) {
|
|
for (let f of c.fields) {
|
|
if (!filter || filter(c, f))
|
|
yield { i, c, f };
|
|
}
|
|
}
|
|
}
|
|
}
|
|
*iterateChildScopes() {
|
|
for (let scope of this.childScopes) {
|
|
yield scope;
|
|
}
|
|
}
|
|
entitiesMatching(atypes) {
|
|
let result = [];
|
|
for (let e of this.entities) {
|
|
for (let a of atypes) {
|
|
if (e.etype === a) {
|
|
result.push(e);
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
return result;
|
|
}
|
|
hasComponent(ctype) {
|
|
return this.componentsInScope.has(ctype.name);
|
|
}
|
|
buildSegments() {
|
|
let iter = this.iterateEntityFields(this.entities);
|
|
for (var o = iter.next(); o.value; o = iter.next()) {
|
|
let { i, e, c, f, v } = o.value;
|
|
let cfname = mksymbol(c, f.name);
|
|
let ftype = this.fieldtypes[cfname];
|
|
let isConst = ftype == "const";
|
|
let segment = isConst ? this.rodata : this.bss;
|
|
if (v === void 0 && isConst)
|
|
throw new ECSError(`no value for const field ${cfname}`, e);
|
|
let array = segment.fieldranges[cfname];
|
|
if (!array) {
|
|
array = segment.fieldranges[cfname] = { component: c, field: f, elo: i, ehi: i };
|
|
} else {
|
|
array.ehi = i;
|
|
if (array.ehi - array.elo + 1 >= 256)
|
|
throw new ECSError(`too many entities have field ${cfname}, limit is 256`);
|
|
}
|
|
if (!isConst) {
|
|
if (f.dtype == "int" && f.defvalue !== void 0) {
|
|
let ecfname = mkscopesymbol(this, c, f.name);
|
|
if (e.inits[ecfname] == null) {
|
|
this.setInitValue(e, c, f, f.defvalue);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
allocateSegment(segment, alloc, type) {
|
|
let fields = Object.values(segment.fieldranges);
|
|
for (let f of fields) {
|
|
if (this.fieldtypes[mksymbol(f.component, f.field.name)] == type) {
|
|
let rangelen = f.ehi - f.elo + 1;
|
|
let bits = getPackedFieldSize(f.field);
|
|
if (bits == 0)
|
|
bits = 16;
|
|
let bytesperelem = Math.ceil(bits / 8);
|
|
let access = [];
|
|
for (let i = 0; i < bits; i += 8) {
|
|
let symbol = this.dialect.fieldsymbol(f.component, f.field, i);
|
|
access.push({ symbol, bit: i, width: 8 });
|
|
if (alloc) {
|
|
segment.allocateBytes(symbol, rangelen);
|
|
}
|
|
}
|
|
f.access = access;
|
|
}
|
|
}
|
|
}
|
|
allocateROData(segment) {
|
|
let iter = this.iterateEntityFields(this.entities);
|
|
for (var o = iter.next(); o.value; o = iter.next()) {
|
|
let { i, e, c, f, v } = o.value;
|
|
let cfname = mksymbol(c, f.name);
|
|
if (this.fieldtypes[cfname] == "const") {
|
|
let range = segment.fieldranges[cfname];
|
|
let entcount = range ? range.ehi - range.elo + 1 : 0;
|
|
if (v == null && f.dtype == "int")
|
|
v = 0;
|
|
if (v == null && f.dtype == "ref")
|
|
v = 0;
|
|
if (v == null && f.dtype == "array")
|
|
throw new ECSError(`no default value for array ${cfname}`, e);
|
|
if (v instanceof Uint8Array && f.dtype == "array") {
|
|
let ptrlosym = this.dialect.fieldsymbol(c, f, 0);
|
|
let ptrhisym = this.dialect.fieldsymbol(c, f, 8);
|
|
let loofs = segment.allocateBytes(ptrlosym, entcount);
|
|
let hiofs = segment.allocateBytes(ptrhisym, entcount);
|
|
let datasym = this.dialect.datasymbol(c, f, e.id, 0);
|
|
segment.allocateInitData(datasym, v);
|
|
if (f.baseoffset)
|
|
datasym = `(${datasym}+${f.baseoffset})`;
|
|
segment.initdata[loofs + e.id - range.elo] = { symbol: datasym, bitofs: 0 };
|
|
segment.initdata[hiofs + e.id - range.elo] = { symbol: datasym, bitofs: 8 };
|
|
} else if (typeof v === "number") {
|
|
{
|
|
if (!range.access)
|
|
throw new ECSError(`no access for field ${cfname}`);
|
|
for (let a of range.access) {
|
|
segment.allocateBytes(a.symbol, entcount);
|
|
let ofs = segment.getByteOffset(range, a, e.id);
|
|
if (e.id < range.elo)
|
|
throw new ECSError("entity out of range " + c.name + " " + f.name, e);
|
|
if (segment.initdata[ofs] !== void 0)
|
|
throw new ECSError("initdata already set " + ofs), e;
|
|
segment.initdata[ofs] = v >> a.bit & 255;
|
|
}
|
|
}
|
|
} else if (v == null && f.dtype == "array" && f.index) {
|
|
let datasym = this.dialect.datasymbol(c, f, e.id, 0);
|
|
let databytes = getFieldLength(f.index);
|
|
let offset = this.bss.allocateBytes(datasym, databytes);
|
|
let ptrlosym = this.dialect.fieldsymbol(c, f, 0);
|
|
let ptrhisym = this.dialect.fieldsymbol(c, f, 8);
|
|
let loofs = segment.allocateBytes(ptrlosym, entcount);
|
|
let hiofs = segment.allocateBytes(ptrhisym, entcount);
|
|
if (f.baseoffset)
|
|
datasym = `(${datasym}+${f.baseoffset})`;
|
|
segment.initdata[loofs + e.id - range.elo] = { symbol: datasym, bitofs: 0 };
|
|
segment.initdata[hiofs + e.id - range.elo] = { symbol: datasym, bitofs: 8 };
|
|
} else {
|
|
throw new ECSError(`unhandled constant ${e.id}:${cfname} -- ${typeof v}`);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
allocateInitData(segment) {
|
|
if (segment.size == 0)
|
|
return "";
|
|
let initbytes = new Uint8Array(segment.size);
|
|
let iter = this.iterateEntityFields(this.entities);
|
|
for (var o = iter.next(); o.value; o = iter.next()) {
|
|
let { i, e, c, f, v } = o.value;
|
|
let scfname = mkscopesymbol(this, c, f.name);
|
|
let initvalue = e.inits[scfname];
|
|
if (initvalue !== void 0) {
|
|
let range = segment.getFieldRange(c, f.name);
|
|
if (!range)
|
|
throw new ECSError(`no init range for ${scfname}`, e);
|
|
if (!range.access)
|
|
throw new ECSError(`no init range access for ${scfname}`, e);
|
|
if (typeof initvalue === "number") {
|
|
for (let a of range.access) {
|
|
let offset = segment.getByteOffset(range, a, e.id);
|
|
initbytes[offset] = initvalue >> a.bit & (1 << a.width) - 1;
|
|
}
|
|
} else if (initvalue instanceof Uint8Array) {
|
|
let datasym = this.dialect.datasymbol(c, f, e.id, 0);
|
|
let ofs = this.bss.symbols[datasym];
|
|
initbytes.set(initvalue, ofs);
|
|
} else {
|
|
throw new ECSError(`cannot initialize ${scfname} = ${initvalue}`);
|
|
}
|
|
}
|
|
}
|
|
let bufsym = this.name + "__INITDATA";
|
|
let bufofs = this.rodata.allocateInitData(bufsym, initbytes);
|
|
let code = this.dialect.INIT_FROM_ARRAY;
|
|
code = code.replace("{{%nbytes}}", initbytes.length.toString());
|
|
code = code.replace("{{%src}}", bufsym);
|
|
code = code.replace("{{%dest}}", segment.getOriginSymbol());
|
|
return code;
|
|
}
|
|
getFieldRange(c, fn) {
|
|
return this.bss.getFieldRange(c, fn) || this.rodata.getFieldRange(c, fn);
|
|
}
|
|
setConstValue(e, component, field, value) {
|
|
this.setConstInitValue(e, component, field, value, "const");
|
|
}
|
|
setInitValue(e, component, field, value) {
|
|
this.setConstInitValue(e, component, field, value, "init");
|
|
}
|
|
setConstInitValue(e, component, field, value, type) {
|
|
this.checkFieldValue(field, value);
|
|
let fieldName = field.name;
|
|
let cfname = mksymbol(component, fieldName);
|
|
let ecfname = mkscopesymbol(this, component, fieldName);
|
|
if (e.consts[cfname] !== void 0)
|
|
throw new ECSError(`"${fieldName}" is already defined as a constant`, e);
|
|
if (e.inits[ecfname] !== void 0)
|
|
throw new ECSError(`"${fieldName}" is already defined as a variable`, e);
|
|
if (type == "const")
|
|
e.consts[cfname] = value;
|
|
if (type == "init")
|
|
e.inits[ecfname] = value;
|
|
this.fieldtypes[cfname] = type;
|
|
}
|
|
isConstOrInit(component, fieldName) {
|
|
return this.fieldtypes[mksymbol(component, fieldName)];
|
|
}
|
|
getConstValue(entity, fieldName) {
|
|
let component = this.em.singleComponentWithFieldName([entity.etype], fieldName, entity);
|
|
let cfname = mksymbol(component, fieldName);
|
|
return entity.consts[cfname];
|
|
}
|
|
checkFieldValue(field, value) {
|
|
if (field.dtype == "array") {
|
|
if (!(value instanceof Uint8Array))
|
|
throw new ECSError(`This "${field.name}" value should be an array.`);
|
|
} else if (typeof value !== "number") {
|
|
throw new ECSError(`This "${field.name}" ${field.dtype} value should be an number.`);
|
|
} else {
|
|
if (field.dtype == "int") {
|
|
if (value < field.lo || value > field.hi)
|
|
throw new ECSError(`This "${field.name}" value is out of range, should be between ${field.lo} and ${field.hi}.`);
|
|
} else if (field.dtype == "ref") {
|
|
let eset = new EntitySet(this, field.query);
|
|
if (value < 0 || value >= eset.entities.length)
|
|
throw new ECSError(`This "${field.name}" value is out of range for this ref type.`);
|
|
}
|
|
}
|
|
}
|
|
generateCodeForEvent(event, args, codelabel) {
|
|
let systems = this.em.event2systems[event];
|
|
if (!systems || systems.length == 0) {
|
|
console.log(`warning: no system responds to "${event}"`);
|
|
return "";
|
|
}
|
|
this.eventSeq++;
|
|
let code = "";
|
|
if (codelabel) {
|
|
code += this.dialect.label(codelabel) + "\n";
|
|
}
|
|
if (event == "start") {
|
|
code += this.allocateInitData(this.bss);
|
|
}
|
|
let eventCount = 0;
|
|
let instances = this.instances.filter((inst) => systems.includes(inst.system));
|
|
for (let inst of instances) {
|
|
let sys = inst.system;
|
|
for (let action of sys.actions) {
|
|
if (action.event == event) {
|
|
eventCount++;
|
|
let codeeval = new ActionEval(this, inst, action, args || []);
|
|
codeeval.begin();
|
|
if (action.critical)
|
|
this.inCritical++;
|
|
let eventcode = codeeval.codeToString();
|
|
if (action.critical)
|
|
this.inCritical--;
|
|
if (!this.inCritical && codeeval.isSubroutineSized(eventcode)) {
|
|
let normcode = this.normalizeCode(eventcode, action);
|
|
let estats = this.eventCodeStats[normcode];
|
|
if (!estats) {
|
|
estats = this.eventCodeStats[normcode] = new EventCodeStats(inst, action, eventcode);
|
|
}
|
|
estats.labels.push(codeeval.label);
|
|
estats.count++;
|
|
if (action.critical)
|
|
estats.count++;
|
|
}
|
|
let s = "";
|
|
s += this.dialect.comment(`start action ${codeeval.label}`);
|
|
s += eventcode;
|
|
s += this.dialect.comment(`end action ${codeeval.label}`);
|
|
code += s;
|
|
codeeval.end();
|
|
}
|
|
}
|
|
}
|
|
if (eventCount == 0) {
|
|
console.log(`warning: event ${event} not handled`);
|
|
}
|
|
return code;
|
|
}
|
|
normalizeCode(code, action) {
|
|
code = code.replace(/\b(\w+__\w+__)(\d+)__(\w+)\b/g, (z, a, b, c) => a + c);
|
|
return code;
|
|
}
|
|
getSystemStats(inst) {
|
|
let stats = this.sysstats.get(inst);
|
|
if (!stats) {
|
|
stats = new SystemStats();
|
|
this.sysstats.set(inst, stats);
|
|
}
|
|
return stats;
|
|
}
|
|
updateTempLiveness(inst) {
|
|
let stats = this.getSystemStats(inst);
|
|
let n = this.eventSeq;
|
|
if (stats.tempstartseq && stats.tempendseq) {
|
|
stats.tempstartseq = Math.min(stats.tempstartseq, n);
|
|
stats.tempendseq = Math.max(stats.tempendseq, n);
|
|
} else {
|
|
stats.tempstartseq = stats.tempendseq = n;
|
|
}
|
|
}
|
|
includeResource(symbol) {
|
|
this.resources.add(symbol);
|
|
return symbol;
|
|
}
|
|
allocateTempVars() {
|
|
let pack = new Packer();
|
|
let maxTempBytes = 128 - this.bss.size;
|
|
let bssbin = new Bin({ left: 0, top: 0, bottom: this.eventSeq + 1, right: maxTempBytes });
|
|
pack.bins.push(bssbin);
|
|
for (let instance of this.instances) {
|
|
let stats = this.getSystemStats(instance);
|
|
if (instance.system.tempbytes && stats.tempstartseq && stats.tempendseq) {
|
|
let v = {
|
|
inst: instance,
|
|
top: stats.tempstartseq,
|
|
bottom: stats.tempendseq + 1,
|
|
width: instance.system.tempbytes,
|
|
height: stats.tempendseq - stats.tempstartseq + 1,
|
|
label: instance.system.name
|
|
};
|
|
pack.boxes.push(v);
|
|
}
|
|
}
|
|
if (!pack.pack())
|
|
console.log("cannot pack temporary local vars");
|
|
if (bssbin.extents.right > 0) {
|
|
let tempofs = this.bss.allocateBytes("TEMP", bssbin.extents.right);
|
|
for (let b of pack.boxes) {
|
|
let inst = b.inst;
|
|
if (b.box)
|
|
this.bss.declareSymbol(this.dialect.tempLabel(inst), tempofs + b.box.left);
|
|
}
|
|
}
|
|
console.log(pack.toSVGUrl());
|
|
}
|
|
analyzeEntities() {
|
|
this.buildSegments();
|
|
this.allocateSegment(this.bss, true, "init");
|
|
this.allocateSegment(this.bss, true, void 0);
|
|
this.allocateSegment(this.rodata, false, "const");
|
|
this.allocateROData(this.rodata);
|
|
}
|
|
isMainScope() {
|
|
return this.parent == null;
|
|
}
|
|
generateCode() {
|
|
this.eventSeq = 0;
|
|
this.eventCodeStats = {};
|
|
let start;
|
|
let initsys = this.em.getSystemByName("Init");
|
|
if (this.isMainScope() && initsys) {
|
|
this.newSystemInstanceWithDefaults(initsys);
|
|
start = this.generateCodeForEvent("main_init");
|
|
} else {
|
|
start = this.generateCodeForEvent("start");
|
|
}
|
|
start = this.replaceSubroutines(start);
|
|
this.code.addCodeFragment(start);
|
|
for (let sub of Array.from(this.resources.values())) {
|
|
if (!this.getSystemInstanceNamed(sub)) {
|
|
let sys = this.em.getSystemByName(sub);
|
|
if (!sys)
|
|
throw new ECSError(`cannot find resource named "${sub}"`);
|
|
this.newSystemInstanceWithDefaults(sys);
|
|
}
|
|
let code = this.generateCodeForEvent(sub, [], sub);
|
|
this.code.addCodeFragment(code);
|
|
}
|
|
}
|
|
replaceSubroutines(code) {
|
|
let allsubs = [];
|
|
for (let stats of Object.values(this.eventCodeStats)) {
|
|
if (stats.count > 1) {
|
|
if (allsubs.length == 0) {
|
|
allsubs = [
|
|
this.dialect.segment("rodata"),
|
|
this.dialect.alignSegmentStart()
|
|
];
|
|
} else if (stats.action.fitbytes) {
|
|
allsubs.push(this.dialect.alignIfLessThan(stats.action.fitbytes));
|
|
}
|
|
let subcall = this.dialect.call(stats.labels[0]);
|
|
for (let label of stats.labels) {
|
|
let startdelim = this.dialect.comment(`start action ${label}`).trim();
|
|
let enddelim = this.dialect.comment(`end action ${label}`).trim();
|
|
let istart = code.indexOf(startdelim);
|
|
let iend = code.indexOf(enddelim, istart);
|
|
if (istart >= 0 && iend > istart) {
|
|
code = code.substring(0, istart) + subcall + code.substring(iend + enddelim.length);
|
|
}
|
|
}
|
|
let substart = stats.labels[0];
|
|
let sublines = [
|
|
this.dialect.segment("rodata"),
|
|
this.dialect.label(substart),
|
|
stats.eventcode,
|
|
this.dialect.return()
|
|
];
|
|
if (stats.action.critical) {
|
|
sublines.push(this.dialect.warningIfPageCrossed(substart));
|
|
}
|
|
if (stats.action.fitbytes) {
|
|
sublines.push(this.dialect.warningIfMoreThan(stats.action.fitbytes, substart));
|
|
}
|
|
allsubs = allsubs.concat(sublines);
|
|
}
|
|
}
|
|
code += allsubs.join("\n");
|
|
return code;
|
|
}
|
|
showStats() {
|
|
for (let inst of this.instances) {
|
|
console.log(inst.system.name, this.getSystemStats(inst));
|
|
}
|
|
}
|
|
dumpCodeTo(file) {
|
|
let shouldExport = this.instances.length == 0;
|
|
let dialect = this.dialect;
|
|
file.line(dialect.startScope(this.name));
|
|
file.line(dialect.segment("bss"));
|
|
this.bss.dump(file, dialect, shouldExport);
|
|
file.line(dialect.segment("code"));
|
|
this.rodata.dump(file, dialect, shouldExport);
|
|
file.line(dialect.label("__Start"));
|
|
this.code.dump(file);
|
|
for (let subscope of this.childScopes) {
|
|
subscope.dump(file);
|
|
}
|
|
file.line(dialect.endScope(this.name));
|
|
}
|
|
dump(file) {
|
|
this.analyzeEntities();
|
|
this.generateCode();
|
|
this.allocateTempVars();
|
|
this.dumpCodeTo(file);
|
|
}
|
|
};
|
|
var EntityManager = class {
|
|
constructor(dialect) {
|
|
this.dialect = dialect;
|
|
this.archetypes = {};
|
|
this.components = {};
|
|
this.systems = {};
|
|
this.topScopes = {};
|
|
this.event2systems = {};
|
|
this.name2cfpairs = {};
|
|
this.mainPath = "";
|
|
this.imported = {};
|
|
this.seq = 1;
|
|
}
|
|
newScope(name, parent) {
|
|
let existing = this.topScopes[name];
|
|
if (existing && !existing.isDemo)
|
|
throw new ECSError(`scope ${name} already defined`, existing);
|
|
let scope = new EntityScope(this, this.dialect, name, parent);
|
|
if (!parent)
|
|
this.topScopes[name] = scope;
|
|
return scope;
|
|
}
|
|
deferComponent(name) {
|
|
this.components[name] = { name, fields: [] };
|
|
}
|
|
defineComponent(ctype) {
|
|
let existing = this.components[ctype.name];
|
|
if (existing && existing.fields.length > 0)
|
|
throw new ECSError(`component ${ctype.name} already defined`, existing);
|
|
if (existing) {
|
|
existing.fields = ctype.fields;
|
|
ctype = existing;
|
|
}
|
|
for (let field of ctype.fields) {
|
|
let list = this.name2cfpairs[field.name];
|
|
if (!list)
|
|
list = this.name2cfpairs[field.name] = [];
|
|
list.push({ c: ctype, f: field });
|
|
}
|
|
this.components[ctype.name] = ctype;
|
|
return ctype;
|
|
}
|
|
defineSystem(system) {
|
|
let existing = this.systems[system.name];
|
|
if (existing)
|
|
throw new ECSError(`system ${system.name} already defined`, existing);
|
|
return this.systems[system.name] = system;
|
|
}
|
|
registerSystemEvents(system) {
|
|
for (let a of system.actions) {
|
|
let event = a.event;
|
|
let list = this.event2systems[event];
|
|
if (list == null)
|
|
list = this.event2systems[event] = [];
|
|
if (!list.includes(system))
|
|
list.push(system);
|
|
}
|
|
}
|
|
addArchetype(atype) {
|
|
let key = atype.components.map((c) => c.name).join(",");
|
|
if (this.archetypes[key])
|
|
return this.archetypes[key];
|
|
else
|
|
return this.archetypes[key] = atype;
|
|
}
|
|
componentsMatching(q, etype) {
|
|
var _a;
|
|
let list = [];
|
|
for (let c of etype.components) {
|
|
if ((_a = q.exclude) == null ? void 0 : _a.includes(c)) {
|
|
return [];
|
|
}
|
|
if (q.include.length == 0 || q.include.includes(c)) {
|
|
list.push(c);
|
|
}
|
|
}
|
|
return list.length == q.include.length ? list : [];
|
|
}
|
|
archetypesMatching(q) {
|
|
let result = new Set();
|
|
for (let etype of Object.values(this.archetypes)) {
|
|
let cmatch = this.componentsMatching(q, etype);
|
|
if (cmatch.length > 0) {
|
|
result.add(etype);
|
|
}
|
|
}
|
|
return Array.from(result.values());
|
|
}
|
|
componentsWithFieldName(atypes, fieldName) {
|
|
let comps = new Set();
|
|
for (let at of atypes) {
|
|
for (let c of at.components) {
|
|
for (let f of c.fields) {
|
|
if (f.name == fieldName)
|
|
comps.add(c);
|
|
}
|
|
}
|
|
}
|
|
return Array.from(comps);
|
|
}
|
|
getComponentByName(name) {
|
|
return this.components[name];
|
|
}
|
|
getSystemByName(name) {
|
|
return this.systems[name];
|
|
}
|
|
singleComponentWithFieldName(atypes, fieldName, where) {
|
|
let cfpairs = this.name2cfpairs[fieldName];
|
|
if (!cfpairs)
|
|
throw new ECSError(`cannot find field named "${fieldName}"`, where);
|
|
let filtered = cfpairs.filter((cf) => atypes.find((a) => a.components.includes(cf.c)));
|
|
if (filtered.length == 0) {
|
|
throw new ECSError(`cannot find component with field "${fieldName}" in this context`, where);
|
|
}
|
|
if (filtered.length > 1) {
|
|
throw new ECSError(`ambiguous field name "${fieldName}"`, where);
|
|
}
|
|
return filtered[0].c;
|
|
}
|
|
toJSON() {
|
|
return JSON.stringify({
|
|
components: this.components,
|
|
systems: this.systems
|
|
});
|
|
}
|
|
exportToFile(file) {
|
|
for (let event of Object.keys(this.event2systems)) {
|
|
file.line(this.dialect.equate(`EVENT__${event}`, "1"));
|
|
}
|
|
for (let scope of Object.values(this.topScopes)) {
|
|
if (!scope.isDemo || scope.filePath == this.mainPath) {
|
|
scope.dump(file);
|
|
}
|
|
}
|
|
}
|
|
*iterateScopes() {
|
|
for (let scope of Object.values(this.topScopes)) {
|
|
yield scope;
|
|
scope.iterateChildScopes();
|
|
}
|
|
}
|
|
getDebugTree() {
|
|
let scopes = this.topScopes;
|
|
let components = this.components;
|
|
let fields = this.name2cfpairs;
|
|
let systems = this.systems;
|
|
let events = this.event2systems;
|
|
let entities = {};
|
|
for (let scope of Array.from(this.iterateScopes())) {
|
|
for (let e of scope.entities)
|
|
entities[e.name || "#" + e.id.toString()] = e;
|
|
}
|
|
return { scopes, components, fields, systems, events, entities };
|
|
}
|
|
evalExpr(expr, scope) {
|
|
if (isLiteral2(expr))
|
|
return expr;
|
|
if (isBinOp2(expr) || isUnOp2(expr)) {
|
|
var fn = this["evalop__" + expr.op];
|
|
if (!fn)
|
|
throw new ECSError(`no eval function for "${expr.op}"`);
|
|
}
|
|
if (isBinOp2(expr)) {
|
|
expr.left = this.evalExpr(expr.left, scope);
|
|
expr.right = this.evalExpr(expr.right, scope);
|
|
let e = fn(expr.left, expr.right);
|
|
return e || expr;
|
|
}
|
|
if (isUnOp2(expr)) {
|
|
expr.expr = this.evalExpr(expr.expr, scope);
|
|
let e = fn(expr.expr);
|
|
return e || expr;
|
|
}
|
|
return expr;
|
|
}
|
|
evalop__neg(arg) {
|
|
if (isLiteralInt(arg)) {
|
|
let valtype = {
|
|
dtype: "int",
|
|
lo: -arg.valtype.hi,
|
|
hi: arg.valtype.hi
|
|
};
|
|
return { valtype, value: -arg.value };
|
|
}
|
|
}
|
|
evalop__add(left, right) {
|
|
if (isLiteralInt(left) && isLiteralInt(right)) {
|
|
let valtype = {
|
|
dtype: "int",
|
|
lo: left.valtype.lo + right.valtype.lo,
|
|
hi: left.valtype.hi + right.valtype.hi
|
|
};
|
|
return { valtype, value: left.value + right.value };
|
|
}
|
|
}
|
|
evalop__sub(left, right) {
|
|
if (isLiteralInt(left) && isLiteralInt(right)) {
|
|
let valtype = {
|
|
dtype: "int",
|
|
lo: left.valtype.lo - right.valtype.hi,
|
|
hi: left.valtype.hi - right.valtype.lo
|
|
};
|
|
return { valtype, value: left.value - right.value };
|
|
}
|
|
}
|
|
};
|
|
|
|
// src/common/ecs/decoder.ts
|
|
var LineDecoder = class {
|
|
constructor(text) {
|
|
this.curline = 0;
|
|
this.lines = text.split("\n").map((s) => s.trim()).filter((s) => !!s).map((s) => s.split(/\s+/));
|
|
}
|
|
decodeBits(s, n, msbfirst) {
|
|
if (s.length != n)
|
|
throw new ECSError(`Expected ${n} characters`);
|
|
let b = 0;
|
|
for (let i = 0; i < n; i++) {
|
|
let bit;
|
|
let ch = s.charAt(i);
|
|
if (ch == "x" || ch == "X" || ch == "1")
|
|
bit = 1;
|
|
else if (ch == "." || ch == "0")
|
|
bit = 0;
|
|
else
|
|
throw new ECSError("need x or . (or 0 or 1)");
|
|
if (bit) {
|
|
if (msbfirst)
|
|
b |= 1 << n - 1 - i;
|
|
else
|
|
b |= 1 << i;
|
|
}
|
|
}
|
|
return b;
|
|
}
|
|
assertTokens(toks, count) {
|
|
if (toks.length != count)
|
|
throw new ECSError(`Expected ${count} tokens on line.`);
|
|
}
|
|
hex(s) {
|
|
let v = parseInt(s, 16);
|
|
if (isNaN(v))
|
|
throw new ECSError(`Invalid hex value: ${s}`);
|
|
return v;
|
|
}
|
|
getErrorLocation($loc) {
|
|
$loc.line += this.curline + 1;
|
|
return $loc;
|
|
}
|
|
};
|
|
var VCSSpriteDecoder = class extends LineDecoder {
|
|
parse() {
|
|
let height = this.lines.length;
|
|
let bitmapdata = new Uint8Array(height);
|
|
let colormapdata = new Uint8Array(height);
|
|
for (let i = 0; i < height; i++) {
|
|
this.curline = height - 1 - i;
|
|
let toks = this.lines[this.curline];
|
|
this.assertTokens(toks, 2);
|
|
bitmapdata[i] = this.decodeBits(toks[0], 8, true);
|
|
colormapdata[i] = this.hex(toks[1]);
|
|
}
|
|
return {
|
|
properties: {
|
|
bitmapdata,
|
|
colormapdata,
|
|
height: height - 1
|
|
}
|
|
};
|
|
}
|
|
};
|
|
var VCSBitmapDecoder = class extends LineDecoder {
|
|
parse() {
|
|
let height = this.lines.length;
|
|
let bitmapdata = new Uint8Array(height);
|
|
for (let i = 0; i < height; i++) {
|
|
this.curline = height - 1 - i;
|
|
let toks = this.lines[this.curline];
|
|
this.assertTokens(toks, 1);
|
|
bitmapdata[i] = this.decodeBits(toks[0], 8, true);
|
|
}
|
|
return {
|
|
properties: {
|
|
bitmapdata,
|
|
height: height - 1
|
|
}
|
|
};
|
|
}
|
|
};
|
|
var VCSPlayfieldDecoder = class extends LineDecoder {
|
|
parse() {
|
|
let height = this.lines.length;
|
|
let pf = new Uint32Array(height);
|
|
for (let i = 0; i < height; i++) {
|
|
this.curline = height - 1 - i;
|
|
let toks = this.lines[this.curline];
|
|
this.assertTokens(toks, 1);
|
|
let pf0 = this.decodeBits(toks[0].substring(0, 4), 4, false) << 4;
|
|
let pf1 = this.decodeBits(toks[0].substring(4, 12), 8, true);
|
|
let pf2 = this.decodeBits(toks[0].substring(12, 20), 8, false);
|
|
pf[i] = pf0 << 0 | pf1 << 8 | pf2 << 16;
|
|
}
|
|
return {
|
|
properties: {
|
|
pf
|
|
}
|
|
};
|
|
}
|
|
};
|
|
var VCSVersatilePlayfieldDecoder = class extends LineDecoder {
|
|
parse() {
|
|
let height = this.lines.length;
|
|
let data = new Uint8Array(height * 2);
|
|
data.fill(63);
|
|
const regs = [13, 14, 15, 8, 9, 10, 63];
|
|
let prev = [0, 0, 0, 0, 0, 0, 0];
|
|
let cur = [0, 0, 0, 0, 0, 0, 0];
|
|
for (let i = 0; i < height; i++) {
|
|
let dataofs = height * 2 - i * 2;
|
|
this.curline = i;
|
|
let toks = this.lines[this.curline];
|
|
if (toks.length == 2) {
|
|
data[dataofs - 1] = this.hex(toks[0]);
|
|
data[dataofs - 2] = this.hex(toks[1]);
|
|
continue;
|
|
}
|
|
this.assertTokens(toks, 4);
|
|
cur[0] = this.decodeBits(toks[0].substring(0, 4), 4, false) << 4;
|
|
cur[1] = this.decodeBits(toks[0].substring(4, 12), 8, true);
|
|
cur[2] = this.decodeBits(toks[0].substring(12, 20), 8, false);
|
|
if (toks[1] != "..")
|
|
cur[3] = this.hex(toks[1]);
|
|
if (toks[2] != "..")
|
|
cur[4] = this.hex(toks[2]);
|
|
if (toks[3] != "..")
|
|
cur[5] = this.hex(toks[3]);
|
|
let changed = [];
|
|
for (let j = 0; j < cur.length; j++) {
|
|
if (cur[j] != prev[j])
|
|
changed.push(j);
|
|
}
|
|
if (changed.length > 1) {
|
|
console.log(changed, cur, prev);
|
|
throw new ECSError(`More than one register change in line ${i + 1}: [${changed}]`);
|
|
}
|
|
let chgidx = changed.length ? changed[0] : regs.length - 1;
|
|
data[dataofs - 1] = regs[chgidx];
|
|
data[dataofs - 2] = cur[chgidx];
|
|
prev[chgidx] = cur[chgidx];
|
|
}
|
|
return {
|
|
properties: {
|
|
data
|
|
}
|
|
};
|
|
}
|
|
};
|
|
var VCSBitmap48Decoder = class extends LineDecoder {
|
|
parse() {
|
|
let height = this.lines.length;
|
|
let bitmap0 = new Uint8Array(height);
|
|
let bitmap1 = new Uint8Array(height);
|
|
let bitmap2 = new Uint8Array(height);
|
|
let bitmap3 = new Uint8Array(height);
|
|
let bitmap4 = new Uint8Array(height);
|
|
let bitmap5 = new Uint8Array(height);
|
|
for (let i = 0; i < height; i++) {
|
|
this.curline = height - 1 - i;
|
|
let toks = this.lines[this.curline];
|
|
this.assertTokens(toks, 1);
|
|
bitmap0[i] = this.decodeBits(toks[0].slice(0, 8), 8, true);
|
|
bitmap1[i] = this.decodeBits(toks[0].slice(8, 16), 8, true);
|
|
bitmap2[i] = this.decodeBits(toks[0].slice(16, 24), 8, true);
|
|
bitmap3[i] = this.decodeBits(toks[0].slice(24, 32), 8, true);
|
|
bitmap4[i] = this.decodeBits(toks[0].slice(32, 40), 8, true);
|
|
bitmap5[i] = this.decodeBits(toks[0].slice(40, 48), 8, true);
|
|
}
|
|
return {
|
|
properties: {
|
|
bitmap0,
|
|
bitmap1,
|
|
bitmap2,
|
|
bitmap3,
|
|
bitmap4,
|
|
bitmap5,
|
|
height: height - 1
|
|
}
|
|
};
|
|
}
|
|
};
|
|
function newDecoder(name, text) {
|
|
let cons = DECODERS[name];
|
|
if (cons)
|
|
return new cons(text);
|
|
}
|
|
var DECODERS = {
|
|
"vcs_sprite": VCSSpriteDecoder,
|
|
"vcs_bitmap": VCSBitmapDecoder,
|
|
"vcs_playfield": VCSPlayfieldDecoder,
|
|
"vcs_versatile": VCSVersatilePlayfieldDecoder,
|
|
"vcs_bitmap48": VCSBitmap48Decoder
|
|
};
|
|
|
|
// src/common/ecs/compiler.ts
|
|
var ECSTokenType;
|
|
(function(ECSTokenType2) {
|
|
ECSTokenType2["Ellipsis"] = "ellipsis";
|
|
ECSTokenType2["Operator"] = "operator";
|
|
ECSTokenType2["Relational"] = "relational";
|
|
ECSTokenType2["QuotedString"] = "quoted-string";
|
|
ECSTokenType2["Integer"] = "integer";
|
|
ECSTokenType2["CodeFragment"] = "code-fragment";
|
|
ECSTokenType2["Placeholder"] = "placeholder";
|
|
})(ECSTokenType || (ECSTokenType = {}));
|
|
var OPERATORS2 = {
|
|
"IMP": { f: "bimp", p: 4 },
|
|
"EQV": { f: "beqv", p: 5 },
|
|
"XOR": { f: "bxor", p: 6 },
|
|
"OR": { f: "bor", p: 7 },
|
|
"AND": { f: "band", p: 8 },
|
|
"||": { f: "lor", p: 17 },
|
|
"&&": { f: "land", p: 18 },
|
|
"=": { f: "eq", p: 50 },
|
|
"==": { f: "eq", p: 50 },
|
|
"<>": { f: "ne", p: 50 },
|
|
"><": { f: "ne", p: 50 },
|
|
"!=": { f: "ne", p: 50 },
|
|
"#": { f: "ne", p: 50 },
|
|
"<": { f: "lt", p: 50 },
|
|
">": { f: "gt", p: 50 },
|
|
"<=": { f: "le", p: 50 },
|
|
">=": { f: "ge", p: 50 },
|
|
"MIN": { f: "min", p: 75 },
|
|
"MAX": { f: "max", p: 75 },
|
|
"+": { f: "add", p: 100 },
|
|
"-": { f: "sub", p: 100 }
|
|
};
|
|
function getOperator2(op) {
|
|
return OPERATORS2[op];
|
|
}
|
|
function getPrecedence2(tok) {
|
|
switch (tok.type) {
|
|
case ECSTokenType.Operator:
|
|
case ECSTokenType.Relational:
|
|
case TokenType2.Ident:
|
|
let op = getOperator2(tok.str);
|
|
if (op)
|
|
return op.p;
|
|
}
|
|
return -1;
|
|
}
|
|
var ECSCompiler = class extends Tokenizer {
|
|
constructor(em, isMainFile) {
|
|
super();
|
|
this.em = em;
|
|
this.isMainFile = isMainFile;
|
|
this.currentScope = null;
|
|
this.currentContext = null;
|
|
this.includeDebugInfo = false;
|
|
this.setTokenRules([
|
|
{ type: ECSTokenType.Ellipsis, regex: /\.\./ },
|
|
{ type: ECSTokenType.QuotedString, regex: /".*?"/ },
|
|
{ type: ECSTokenType.CodeFragment, regex: /---.*?---/ },
|
|
{ type: ECSTokenType.Integer, regex: /0[xX][A-Fa-f0-9]+/ },
|
|
{ type: ECSTokenType.Integer, regex: /\$[A-Fa-f0-9]+/ },
|
|
{ type: ECSTokenType.Integer, regex: /[%][01]+/ },
|
|
{ type: ECSTokenType.Integer, regex: /\d+/ },
|
|
{ type: ECSTokenType.Relational, regex: /[=<>][=<>]?/ },
|
|
{ type: ECSTokenType.Operator, regex: /[.#,:(){}\[\]\-\+]/ },
|
|
{ type: TokenType2.Ident, regex: /[A-Za-z_][A-Za-z0-9_]*/ },
|
|
{ type: TokenType2.Ignore, regex: /\/\/.*?[\n\r]/ },
|
|
{ type: TokenType2.Ignore, regex: /\/\*.*?\*\// },
|
|
{ type: TokenType2.EOL, regex: /[\n\r]+/ },
|
|
{ type: TokenType2.Ignore, regex: /\s+/ }
|
|
]);
|
|
this.errorOnCatchAll = true;
|
|
}
|
|
annotate(fn) {
|
|
let start = this.peekToken();
|
|
let obj = fn();
|
|
let end = this.lasttoken;
|
|
let $loc = end ? mergeLocs2(start.$loc, end.$loc) : start.$loc;
|
|
if (obj)
|
|
obj.$loc = $loc;
|
|
return obj;
|
|
}
|
|
parseFile(text, path) {
|
|
this.tokenizeFile(text, path);
|
|
while (!this.isEOF()) {
|
|
let top = this.parseTopLevel();
|
|
if (top) {
|
|
let t = top;
|
|
this.annotate(() => t);
|
|
}
|
|
}
|
|
this.runDeferred();
|
|
}
|
|
importFile(path) {
|
|
if (!this.em.imported[path]) {
|
|
let text = this.getImportFile && this.getImportFile(path);
|
|
if (!text)
|
|
this.compileError(`I can't find the import file "${path}".`);
|
|
this.em.imported[path] = true;
|
|
let comp = new ECSCompiler(this.em, false);
|
|
comp.includeDebugInfo = this.includeDebugInfo;
|
|
try {
|
|
comp.parseFile(text, path);
|
|
} catch (e) {
|
|
for (var err of comp.errors)
|
|
this.errors.push(err);
|
|
throw e;
|
|
}
|
|
}
|
|
}
|
|
parseTopLevel() {
|
|
let tok = this.expectTokens(["component", "system", "scope", "resource", "import", "demo", "comment"]);
|
|
if (tok.str == "component") {
|
|
return this.em.defineComponent(this.parseComponentDefinition());
|
|
}
|
|
if (tok.str == "system") {
|
|
return this.em.defineSystem(this.parseSystem());
|
|
}
|
|
if (tok.str == "scope") {
|
|
return this.parseScope();
|
|
}
|
|
if (tok.str == "resource") {
|
|
return this.em.defineSystem(this.parseResource());
|
|
}
|
|
if (tok.str == "import") {
|
|
let tok2 = this.expectTokenTypes([ECSTokenType.QuotedString]);
|
|
let path = tok2.str.substring(1, tok2.str.length - 1);
|
|
return this.importFile(path);
|
|
}
|
|
if (tok.str == "demo") {
|
|
if (this.isMainFile) {
|
|
let scope = this.parseScope();
|
|
scope.isDemo = true;
|
|
this.expectToken("demo");
|
|
return scope;
|
|
} else {
|
|
this.skipDemo();
|
|
return;
|
|
}
|
|
}
|
|
if (tok.str == "comment") {
|
|
this.expectTokenTypes([ECSTokenType.CodeFragment]);
|
|
return;
|
|
}
|
|
this.compileError(`Unexpected top-level keyword: ${tok.str}`);
|
|
}
|
|
skipDemo() {
|
|
var tok;
|
|
while ((tok = this.consumeToken()) && !this.isEOF()) {
|
|
if (tok.str == "end" && this.peekToken().str == "demo") {
|
|
this.consumeToken();
|
|
return;
|
|
}
|
|
}
|
|
throw new ECSError(`Expected "end demo" after a "demo" declaration.`);
|
|
}
|
|
parseComponentDefinition() {
|
|
let name = this.expectIdent().str;
|
|
let fields = [];
|
|
this.em.deferComponent(name);
|
|
while (this.peekToken().str != "end") {
|
|
fields.push(this.parseComponentField());
|
|
}
|
|
this.expectToken("end");
|
|
return { name, fields };
|
|
}
|
|
parseComponentField() {
|
|
let name = this.expectIdent();
|
|
this.expectToken(":", 'I expected either a ":" or "end" here.');
|
|
let type = this.parseDataType();
|
|
return __spreadValues({ name: name.str, $loc: name.$loc }, type);
|
|
}
|
|
parseDataType() {
|
|
if (this.peekToken().type == "integer") {
|
|
let lo = this.parseIntegerConstant();
|
|
this.expectToken("..");
|
|
let hi = this.parseIntegerConstant();
|
|
this.checkLowerLimit(lo, -2147483648, "lower int range");
|
|
this.checkUpperLimit(hi, 2147483647, "upper int range");
|
|
this.checkUpperLimit(hi - lo, 4294967295, "int range");
|
|
this.checkLowerLimit(hi, lo, "int range");
|
|
let defvalue;
|
|
if (this.ifToken("default")) {
|
|
defvalue = this.parseIntegerConstant();
|
|
}
|
|
return { dtype: "int", lo, hi, defvalue };
|
|
}
|
|
if (this.peekToken().str == "[") {
|
|
return { dtype: "ref", query: this.parseQuery() };
|
|
}
|
|
if (this.ifToken("array")) {
|
|
let index = void 0;
|
|
if (this.peekToken().type == ECSTokenType.Integer) {
|
|
index = this.parseDataType();
|
|
}
|
|
this.expectToken("of");
|
|
let elem = this.parseDataType();
|
|
let baseoffset;
|
|
if (this.ifToken("baseoffset")) {
|
|
baseoffset = this.parseIntegerConstant();
|
|
this.checkLowerLimit(baseoffset, -32768, "base offset");
|
|
this.checkUpperLimit(baseoffset, 32767, "base offset");
|
|
}
|
|
return { dtype: "array", index, elem, baseoffset };
|
|
}
|
|
if (this.ifToken("enum")) {
|
|
this.expectToken("[");
|
|
let enumtoks = this.parseList(this.parseEnumIdent, ",");
|
|
this.expectToken("]");
|
|
if (enumtoks.length == 0)
|
|
this.compileError(`must define at least one enum`);
|
|
let lo = 0;
|
|
let hi = enumtoks.length - 1;
|
|
this.checkLowerLimit(hi, 0, "enum count");
|
|
this.checkUpperLimit(hi, 255, "enum count");
|
|
let enums = {};
|
|
for (let i = 0; i <= hi; i++)
|
|
enums[enumtoks[i].str] = i;
|
|
let defvalue;
|
|
if (this.ifToken("default")) {
|
|
defvalue = this.parseIntegerConstant();
|
|
}
|
|
return { dtype: "int", lo, hi, defvalue, enums };
|
|
}
|
|
throw this.compileError(`I expected a data type here.`);
|
|
}
|
|
parseEnumIdent() {
|
|
let tok = this.expectTokenTypes([TokenType2.Ident]);
|
|
return tok;
|
|
}
|
|
parseEnumValue(tok, field) {
|
|
if (!field.enums)
|
|
throw new ECSError(`field is not an enum`);
|
|
let value = field.enums[tok.str];
|
|
if (value == null)
|
|
throw new ECSError(`unknown enum "${tok.str}"`);
|
|
return value;
|
|
}
|
|
parseDataValue(field) {
|
|
var _a, _b;
|
|
let tok = this.peekToken();
|
|
if (tok.type == TokenType2.Ident && field.dtype == "int") {
|
|
return this.parseEnumValue(this.consumeToken(), field);
|
|
}
|
|
if (tok.type == TokenType2.Ident) {
|
|
let entity = (_a = this.currentScope) == null ? void 0 : _a.getEntityByName(tok.str);
|
|
if (!entity)
|
|
this.compileError('no entity named "${tok.str}"');
|
|
else {
|
|
this.consumeToken();
|
|
this.expectToken(".");
|
|
let fieldName = this.expectIdent().str;
|
|
let constValue = (_b = this.currentScope) == null ? void 0 : _b.getConstValue(entity, fieldName);
|
|
if (constValue == null)
|
|
throw new ECSError(`"${fieldName}" is not defined as a constant`, entity);
|
|
else
|
|
return constValue;
|
|
}
|
|
}
|
|
if (tok.str == "[") {
|
|
return new Uint8Array(this.parseDataArray());
|
|
}
|
|
if (tok.str == "#") {
|
|
this.consumeToken();
|
|
let reftype = field.dtype == "ref" ? field : void 0;
|
|
return this.parseEntityForwardRef(reftype);
|
|
}
|
|
return this.parseIntegerConstant();
|
|
}
|
|
parseEntityForwardRef(reftype) {
|
|
let token = this.expectIdent();
|
|
return { reftype, token };
|
|
}
|
|
parseDataArray() {
|
|
this.expectToken("[");
|
|
let arr = this.parseList(this.parseIntegerConstant, ",");
|
|
this.expectToken("]");
|
|
return arr;
|
|
}
|
|
expectInteger() {
|
|
let s = this.consumeToken().str;
|
|
let i;
|
|
if (s.startsWith("$"))
|
|
i = parseInt(s.substring(1), 16);
|
|
else if (s.startsWith("%"))
|
|
i = parseInt(s.substring(1), 2);
|
|
else
|
|
i = parseInt(s);
|
|
if (isNaN(i))
|
|
this.compileError("There should be an integer here.");
|
|
return i;
|
|
}
|
|
parseSystem() {
|
|
let name = this.expectIdent().str;
|
|
let actions = [];
|
|
let system = { name, actions };
|
|
let cmd;
|
|
while ((cmd = this.expectTokens(["on", "locals", "end"]).str) != "end") {
|
|
if (cmd == "on") {
|
|
let action = this.annotate(() => this.parseAction(system));
|
|
actions.push(action);
|
|
} else if (cmd == "locals") {
|
|
system.tempbytes = this.parseIntegerConstant();
|
|
} else {
|
|
this.compileError(`Unexpected system keyword: ${cmd}`);
|
|
}
|
|
}
|
|
return system;
|
|
}
|
|
parseResource() {
|
|
let name = this.expectIdent().str;
|
|
let tempbytes;
|
|
if (this.peekToken().str == "locals") {
|
|
this.consumeToken();
|
|
tempbytes = this.parseIntegerConstant();
|
|
}
|
|
let system = { name, tempbytes, actions: [] };
|
|
let expr = this.annotate(() => this.parseBlockStatement());
|
|
let action = { expr, event: name };
|
|
system.actions.push(action);
|
|
return system;
|
|
}
|
|
parseAction(system) {
|
|
const event = this.expectIdent().str;
|
|
this.expectToken("do");
|
|
let fitbytes = void 0;
|
|
let critical = void 0;
|
|
if (this.ifToken("critical"))
|
|
critical = true;
|
|
if (this.ifToken("fit"))
|
|
fitbytes = this.parseIntegerConstant();
|
|
let expr = this.annotate(() => this.parseBlockStatement());
|
|
let action = { expr, event, fitbytes, critical };
|
|
return action;
|
|
}
|
|
parseQuery() {
|
|
let q = { include: [] };
|
|
let start = this.expectToken("[");
|
|
this.parseList(() => this.parseQueryItem(q), ",");
|
|
this.expectToken("]");
|
|
q.$loc = mergeLocs2(start.$loc, this.lasttoken.$loc);
|
|
return q;
|
|
}
|
|
parseQueryItem(q) {
|
|
let prefix = this.peekToken();
|
|
if (prefix.type != TokenType2.Ident) {
|
|
this.consumeToken();
|
|
}
|
|
if (prefix.type == TokenType2.Ident) {
|
|
let cref = this.parseComponentRef();
|
|
q.include.push(cref);
|
|
} else if (prefix.str == "-") {
|
|
let cref = this.parseComponentRef();
|
|
if (!q.exclude)
|
|
q.exclude = [];
|
|
q.exclude.push(cref);
|
|
} else if (prefix.str == "#") {
|
|
const scope = this.currentScope;
|
|
if (scope == null) {
|
|
throw this.compileError("You can only reference specific entities inside of a scope.");
|
|
}
|
|
let eref = this.parseEntityForwardRef();
|
|
this.deferred.push(() => {
|
|
let refvalue = this.resolveEntityRef(scope, eref);
|
|
if (!q.entities)
|
|
q.entities = [];
|
|
q.entities.push(scope.entities[refvalue]);
|
|
});
|
|
} else {
|
|
this.compileError(`Query components may be preceded only by a '-'.`);
|
|
}
|
|
}
|
|
parseEventName() {
|
|
return this.expectIdent().str;
|
|
}
|
|
parseEventList() {
|
|
return this.parseList(this.parseEventName, ",");
|
|
}
|
|
parseCode() {
|
|
let tok = this.expectTokenTypes([ECSTokenType.CodeFragment]);
|
|
let code = tok.str.substring(3, tok.str.length - 3);
|
|
let lines = code.split("\n");
|
|
if (this.includeDebugInfo)
|
|
this.addDebugInfo(lines, tok.$loc.line);
|
|
code = lines.join("\n");
|
|
return code;
|
|
}
|
|
addDebugInfo(lines, startline) {
|
|
const re = /^\s*(;|\/\/|$)/;
|
|
for (let i = 0; i < lines.length; i++) {
|
|
if (!lines[i].match(re))
|
|
lines[i] = this.em.dialect.debug_line(this.path, startline + i) + "\n" + lines[i];
|
|
}
|
|
}
|
|
parseScope() {
|
|
let name = this.expectIdent().str;
|
|
let scope = this.em.newScope(name, this.currentScope || void 0);
|
|
scope.filePath = this.path;
|
|
this.currentScope = scope;
|
|
let cmd;
|
|
while ((cmd = this.expectTokens(["end", "using", "entity", "scope", "comment", "system"]).str) != "end") {
|
|
if (cmd == "using") {
|
|
this.parseScopeUsing();
|
|
}
|
|
if (cmd == "entity") {
|
|
this.annotate(() => this.parseEntity());
|
|
}
|
|
if (cmd == "scope") {
|
|
this.annotate(() => this.parseScope());
|
|
}
|
|
if (cmd == "comment") {
|
|
this.expectTokenTypes([ECSTokenType.CodeFragment]);
|
|
}
|
|
if (cmd == "system") {
|
|
let sys = this.annotate(() => this.parseSystem());
|
|
this.em.defineSystem(sys);
|
|
this.currentScope.newSystemInstanceWithDefaults(sys);
|
|
}
|
|
}
|
|
this.currentScope = scope.parent || null;
|
|
return scope;
|
|
}
|
|
parseScopeUsing() {
|
|
var _a;
|
|
let instlist = this.parseList(this.parseSystemInstanceRef, ",");
|
|
let params = {};
|
|
if (this.peekToken().str == "with") {
|
|
this.consumeToken();
|
|
params = this.parseSystemInstanceParameters();
|
|
}
|
|
for (let inst of instlist) {
|
|
inst.params = params;
|
|
(_a = this.currentScope) == null ? void 0 : _a.newSystemInstance(inst);
|
|
}
|
|
}
|
|
parseEntity() {
|
|
if (!this.currentScope) {
|
|
throw this.internalError();
|
|
}
|
|
const scope = this.currentScope;
|
|
let entname = "";
|
|
if (this.peekToken().type == TokenType2.Ident) {
|
|
entname = this.expectIdent().str;
|
|
}
|
|
let etype = this.parseEntityArchetype();
|
|
let entity = this.currentScope.newEntity(etype, entname);
|
|
let cmd2;
|
|
while ((cmd2 = this.expectTokens(["const", "init", "var", "decode", "end"]).str) != "end") {
|
|
let cmd = cmd2;
|
|
if (cmd == "var")
|
|
cmd = "init";
|
|
if (cmd == "init" || cmd == "const") {
|
|
this.parseInitConst(cmd, scope, entity);
|
|
} else if (cmd == "decode") {
|
|
this.parseDecode(scope, entity);
|
|
}
|
|
}
|
|
return entity;
|
|
}
|
|
parseInitConst(cmd, scope, entity) {
|
|
let name = this.expectIdent().str;
|
|
let { c, f } = this.getEntityField(entity, name);
|
|
let symtype = scope.isConstOrInit(c, name);
|
|
if (symtype && symtype != cmd)
|
|
this.compileError(`I can't mix const and init values for a given field in a scope.`);
|
|
this.expectToken("=");
|
|
let valueOrRef = this.parseDataValue(f);
|
|
if (valueOrRef.token != null) {
|
|
this.deferred.push(() => {
|
|
this.lasttoken = valueOrRef.token;
|
|
let refvalue = this.resolveEntityRef(scope, valueOrRef);
|
|
if (cmd == "const")
|
|
scope.setConstValue(entity, c, f, refvalue);
|
|
if (cmd == "init")
|
|
scope.setInitValue(entity, c, f, refvalue);
|
|
});
|
|
} else {
|
|
if (cmd == "const")
|
|
scope.setConstValue(entity, c, f, valueOrRef);
|
|
if (cmd == "init")
|
|
scope.setInitValue(entity, c, f, valueOrRef);
|
|
}
|
|
}
|
|
parseDecode(scope, entity) {
|
|
let decoderid = this.expectIdent().str;
|
|
let codetok = this.expectTokenTypes([ECSTokenType.CodeFragment]);
|
|
let code = codetok.str;
|
|
code = code.substring(3, code.length - 3);
|
|
let decoder = newDecoder(decoderid, code);
|
|
if (!decoder) {
|
|
throw this.compileError(`I can't find a "${decoderid}" decoder.`);
|
|
}
|
|
let result;
|
|
try {
|
|
result = decoder.parse();
|
|
} catch (e) {
|
|
throw new ECSError(e.message, decoder.getErrorLocation(codetok.$loc));
|
|
}
|
|
for (let entry of Object.entries(result.properties)) {
|
|
let { c, f } = this.getEntityField(entity, entry[0]);
|
|
scope.setConstValue(entity, c, f, entry[1]);
|
|
}
|
|
}
|
|
getEntityField(e, name) {
|
|
if (!this.currentScope) {
|
|
throw this.internalError();
|
|
}
|
|
let comps = this.em.componentsWithFieldName([e.etype], name);
|
|
if (comps.length == 0)
|
|
this.compileError(`I couldn't find a field named "${name}" for this entity.`);
|
|
if (comps.length > 1)
|
|
this.compileError(`I found more than one field named "${name}" for this entity.`);
|
|
let component = comps[0];
|
|
let field = component.fields.find((f) => f.name == name);
|
|
if (!field) {
|
|
throw this.internalError();
|
|
}
|
|
return { c: component, f: field };
|
|
}
|
|
parseEntityArchetype() {
|
|
this.expectToken("[");
|
|
let components = this.parseList(this.parseComponentRef, ",");
|
|
this.expectToken("]");
|
|
return { components };
|
|
}
|
|
parseComponentRef() {
|
|
let name = this.expectIdent().str;
|
|
let cref = this.em.getComponentByName(name);
|
|
if (!cref)
|
|
this.compileError(`I couldn't find a component named "${name}".`);
|
|
return cref;
|
|
}
|
|
findEntityByName(scope, token) {
|
|
let name = token.str;
|
|
let eref = scope.entities.find((e) => e.name == name);
|
|
if (!eref) {
|
|
throw this.compileError(`I couldn't find an entity named "${name}" in this scope.`, token.$loc);
|
|
}
|
|
return eref;
|
|
}
|
|
resolveEntityRef(scope, ref) {
|
|
let id = this.findEntityByName(scope, ref.token).id;
|
|
if (ref.reftype) {
|
|
let atypes = this.em.archetypesMatching(ref.reftype.query);
|
|
let entities = scope.entitiesMatching(atypes);
|
|
if (entities.length == 0)
|
|
throw this.compileError(`This entity doesn't seem to fit the reference type.`, ref.token.$loc);
|
|
id -= entities[0].id;
|
|
}
|
|
return id;
|
|
}
|
|
parseSystemInstanceRef() {
|
|
let name = this.expectIdent().str;
|
|
let system = this.em.getSystemByName(name);
|
|
if (!system)
|
|
throw this.compileError(`I couldn't find a system named "${name}".`, this.lasttoken.$loc);
|
|
let params = {};
|
|
let inst = { system, params, id: 0 };
|
|
return inst;
|
|
}
|
|
parseSystemInstanceParameters() {
|
|
let scope = this.currentScope;
|
|
if (scope == null)
|
|
throw this.internalError();
|
|
if (this.peekToken().str == "[") {
|
|
return { query: this.parseQuery() };
|
|
}
|
|
this.expectToken("#");
|
|
let entname = this.expectIdent();
|
|
this.expectToken(".");
|
|
let fieldname = this.expectIdent();
|
|
let entity = this.findEntityByName(scope, entname);
|
|
let cf = this.getEntityField(entity, fieldname.str);
|
|
return { refEntity: entity, refField: cf };
|
|
}
|
|
exportToFile(src) {
|
|
this.em.exportToFile(src);
|
|
}
|
|
export() {
|
|
let src = new SourceFileExport();
|
|
src.line(this.em.dialect.debug_file(this.path));
|
|
for (let path of Object.keys(this.em.imported))
|
|
src.line(this.em.dialect.debug_file(path));
|
|
this.exportToFile(src);
|
|
return src.toString();
|
|
}
|
|
checkUpperLimit(value, upper, what) {
|
|
if (value > upper)
|
|
this.compileError(`This ${what} is too high; must be ${upper} or less`);
|
|
}
|
|
checkLowerLimit(value, lower, what) {
|
|
if (value < lower)
|
|
this.compileError(`This ${what} is too low; must be ${lower} or more`);
|
|
}
|
|
parseConstant() {
|
|
let expr = this.parseExpr();
|
|
expr = this.em.evalExpr(expr, this.currentScope);
|
|
if (isLiteral2(expr))
|
|
return expr.value;
|
|
throw this.compileError("This expression is not a constant.");
|
|
}
|
|
parseIntegerConstant() {
|
|
let value = this.parseConstant();
|
|
if (typeof value === "number")
|
|
return value;
|
|
throw this.compileError("This expression is not an integer.");
|
|
}
|
|
parseExpr() {
|
|
var startloc = this.peekToken().$loc;
|
|
var expr = this.parseExpr1(this.parsePrimary(), 0);
|
|
var endloc = this.lasttoken.$loc;
|
|
expr.$loc = mergeLocs2(startloc, endloc);
|
|
return expr;
|
|
}
|
|
parseExpr1(left, minPred) {
|
|
let look = this.peekToken();
|
|
while (getPrecedence2(look) >= minPred) {
|
|
let op = this.consumeToken();
|
|
let right = this.parsePrimary();
|
|
look = this.peekToken();
|
|
while (getPrecedence2(look) > getPrecedence2(op)) {
|
|
right = this.parseExpr1(right, getPrecedence2(look));
|
|
look = this.peekToken();
|
|
}
|
|
var opfn = getOperator2(op.str).f;
|
|
if (op.str == "and")
|
|
opfn = "land";
|
|
if (op.str == "or")
|
|
opfn = "lor";
|
|
var valtype = this.exprTypeForOp(opfn, left, right, op);
|
|
left = { valtype, op: opfn, left, right };
|
|
}
|
|
return left;
|
|
}
|
|
parsePrimary() {
|
|
let tok = this.consumeToken();
|
|
switch (tok.type) {
|
|
case ECSTokenType.Integer:
|
|
this.pushbackToken(tok);
|
|
let value = this.expectInteger();
|
|
let valtype = { dtype: "int", lo: value, hi: value };
|
|
return { valtype, value };
|
|
case TokenType2.Ident:
|
|
if (tok.str == "not") {
|
|
let expr = this.parsePrimary();
|
|
let valtype2 = { dtype: "int", lo: 0, hi: 1 };
|
|
return { valtype: valtype2, op: "lnot", expr };
|
|
} else {
|
|
this.pushbackToken(tok);
|
|
return this.parseVarSubscriptOrFunc();
|
|
}
|
|
case ECSTokenType.Operator:
|
|
if (tok.str == "(") {
|
|
let expr = this.parseExpr();
|
|
this.expectToken(")", `There should be another expression or a ")" here.`);
|
|
return expr;
|
|
} else if (tok.str == "-") {
|
|
let expr = this.parsePrimary();
|
|
let valtype2 = expr.valtype;
|
|
if ((valtype2 == null ? void 0 : valtype2.dtype) == "int") {
|
|
let hi = Math.abs(valtype2.hi);
|
|
let negtype = { dtype: "int", lo: -hi, hi };
|
|
return { valtype: negtype, op: "neg", expr };
|
|
}
|
|
} else if (tok.str == "+") {
|
|
return this.parsePrimary();
|
|
}
|
|
default:
|
|
throw this.compileError(`The expression is incomplete.`);
|
|
}
|
|
}
|
|
parseVarSubscriptOrFunc() {
|
|
var tok = this.consumeToken();
|
|
switch (tok.type) {
|
|
case TokenType2.Ident:
|
|
if (this.ifToken(":")) {
|
|
let ftok = this.consumeToken();
|
|
let component = this.em.getComponentByName(tok.str);
|
|
if (!component)
|
|
throw this.compileError(`A component named "${tok.str}" has not been defined.`);
|
|
let field = component.fields.find((f) => f.name == ftok.str);
|
|
if (!field)
|
|
throw this.compileError(`There is no "${ftok.str}" field in the ${tok.str} component.`);
|
|
if (!this.currentScope)
|
|
throw this.compileError(`This operation only works inside of a scope.`);
|
|
let atypes = this.em.archetypesMatching({ include: [component] });
|
|
let entities = this.currentScope.entitiesMatching(atypes);
|
|
return { entities, field };
|
|
}
|
|
if (this.ifToken(".")) {
|
|
let ftok = this.consumeToken();
|
|
if (!this.currentScope)
|
|
throw this.compileError(`This operation only works inside of a scope.`);
|
|
let entity = this.currentScope.getEntityByName(tok.str);
|
|
if (!entity)
|
|
throw this.compileError(`An entity named "${tok.str}" has not been defined.`);
|
|
let component = this.em.singleComponentWithFieldName([entity.etype], ftok.str, ftok);
|
|
let field = component.fields.find((f) => f.name == ftok.str);
|
|
if (!field)
|
|
throw this.compileError(`There is no "${ftok.str}" field in this entity.`);
|
|
let entities = [entity];
|
|
return { entities, field };
|
|
}
|
|
let args = [];
|
|
if (this.ifToken("(")) {
|
|
args = this.parseExprList();
|
|
this.expectToken(")", `There should be another expression or a ")" here.`);
|
|
}
|
|
var loc = mergeLocs2(tok.$loc, this.lasttoken.$loc);
|
|
var valtype = this.exprTypeForSubscript(tok.str, args, loc);
|
|
return { valtype, name: tok.str, args, $loc: loc };
|
|
default:
|
|
throw this.compileError(`There should be a variable name here.`);
|
|
}
|
|
}
|
|
parseLexpr() {
|
|
var lexpr = this.parseVarSubscriptOrFunc();
|
|
return lexpr;
|
|
}
|
|
exprTypeForOp(fnname, left, right, optok) {
|
|
return { dtype: "int", lo: 0, hi: 255 };
|
|
}
|
|
exprTypeForSubscript(fnname, args, loc) {
|
|
return { dtype: "int", lo: 0, hi: 255 };
|
|
}
|
|
parseLexprList() {
|
|
return this.parseList(this.parseLexpr, ",");
|
|
}
|
|
parseExprList() {
|
|
return this.parseList(this.parseExpr, ",");
|
|
}
|
|
parseBlockStatement() {
|
|
let valtype = { dtype: "int", lo: 0, hi: 0 };
|
|
if (this.peekToken().type == ECSTokenType.CodeFragment) {
|
|
return { valtype, code: this.parseCode() };
|
|
}
|
|
if (this.ifToken("begin")) {
|
|
let stmts = [];
|
|
while (this.peekToken().str != "end") {
|
|
stmts.push(this.annotate(() => this.parseBlockStatement()));
|
|
}
|
|
this.expectToken("end");
|
|
return { valtype, stmts };
|
|
}
|
|
let cmd = this.peekToken();
|
|
if (SELECT_TYPE.includes(cmd.str)) {
|
|
return this.parseQueryStatement();
|
|
}
|
|
throw this.compileError(`There should be a statement or "end" here.`, cmd.$loc);
|
|
}
|
|
parseQueryStatement() {
|
|
const select = this.expectTokens(SELECT_TYPE).str;
|
|
let all = this.ifToken("all") != null;
|
|
let query = void 0;
|
|
let join = void 0;
|
|
if (select == "once") {
|
|
if (this.peekToken().str == "[")
|
|
this.compileError(`A "${select}" action can't include a query.`);
|
|
} else {
|
|
query = this.parseQuery();
|
|
}
|
|
if (select == "join") {
|
|
this.expectToken("with");
|
|
join = this.parseQuery();
|
|
}
|
|
if (this.ifToken("limit")) {
|
|
if (!query) {
|
|
this.compileError(`A "${select}" query can't include a limit.`);
|
|
} else
|
|
query.limit = this.parseIntegerConstant();
|
|
}
|
|
const all_modifiers = ["asc", "desc"];
|
|
const modifiers = this.parseModifiers(all_modifiers);
|
|
let direction = void 0;
|
|
if (modifiers["asc"])
|
|
direction = "asc";
|
|
else if (modifiers["desc"])
|
|
direction = "desc";
|
|
let body = this.annotate(() => this.parseBlockStatement());
|
|
return { select, query, join, direction, all, stmts: [body], loop: select == "foreach" };
|
|
}
|
|
};
|
|
|
|
// src/worker/tools/ecs.ts
|
|
function assembleECS(step) {
|
|
let em = new EntityManager(new Dialect_CA65());
|
|
let compiler = new ECSCompiler(em, true);
|
|
compiler.getImportFile = (path) => {
|
|
return getWorkFileAsString(path);
|
|
};
|
|
gatherFiles(step, { mainFilePath: "main.ecs" });
|
|
if (step.mainfile)
|
|
em.mainPath = step.path;
|
|
var destpath = step.prefix + ".ca65";
|
|
if (staleFiles(step, [destpath])) {
|
|
let code = getWorkFileAsString(step.path);
|
|
fixParamsWithDefines(step.path, step.params);
|
|
try {
|
|
compiler.includeDebugInfo = true;
|
|
compiler.parseFile(code, step.path);
|
|
let outtext = compiler.export().toString();
|
|
putWorkFile(destpath, outtext);
|
|
var listings = {};
|
|
listings[destpath] = { lines: [], text: outtext };
|
|
var debuginfo = compiler.em.getDebugTree();
|
|
} catch (e) {
|
|
if (e instanceof ECSError) {
|
|
compiler.addError(e.message, e.$loc);
|
|
for (let obj of e.$sources) {
|
|
let name = obj.event;
|
|
if (name == "start")
|
|
break;
|
|
compiler.addError(`... ${name}`, obj.$loc);
|
|
}
|
|
return { errors: compiler.errors };
|
|
} else if (e instanceof CompileError3) {
|
|
return { errors: compiler.errors };
|
|
} else {
|
|
throw e;
|
|
}
|
|
}
|
|
return {
|
|
nexttool: "ca65",
|
|
path: destpath,
|
|
args: [destpath],
|
|
files: [destpath].concat(step.files),
|
|
listings,
|
|
debuginfo
|
|
};
|
|
}
|
|
}
|
|
|
|
// src/common/workertypes.ts
|
|
function isUnchanged(result) {
|
|
return "unchanged" in result;
|
|
}
|
|
function isErrorResult(result) {
|
|
return "errors" in result;
|
|
}
|
|
function isOutputResult(result) {
|
|
return "output" in result;
|
|
}
|
|
|
|
// src/worker/tools/remote.ts
|
|
var REMOTE_URL = "http://localhost:3009/build";
|
|
var sessionID = Math.random().toString(36).substring(2, 15) + Math.random().toString(36).substring(2, 15);
|
|
async function buildRemote(step) {
|
|
gatherFiles(step);
|
|
var binpath = "a.out";
|
|
if (staleFiles(step, [binpath])) {
|
|
let updates = [];
|
|
for (var i = 0; i < step.files.length; i++) {
|
|
let path = step.files[i];
|
|
let entry = store.workfs[path];
|
|
let data = typeof entry.data === "string" ? entry.data : btoa(byteArrayToString(entry.data));
|
|
updates.push({ path, data });
|
|
}
|
|
let cmd = { buildStep: step, updates, sessionID };
|
|
console.log("POST", cmd);
|
|
let result = await fetch(REMOTE_URL, {
|
|
method: "POST",
|
|
mode: "cors",
|
|
body: JSON.stringify(cmd),
|
|
headers: {
|
|
"Content-Type": "application/json"
|
|
}
|
|
});
|
|
let json = await result.json();
|
|
if (isUnchanged(json))
|
|
return json;
|
|
if (isErrorResult(json))
|
|
return json;
|
|
if (isOutputResult(json)) {
|
|
json.output = stringToByteArray(atob(json.output));
|
|
return json;
|
|
}
|
|
throw new Error(`Unexpected result from remote build: ${JSON.stringify(json)}`);
|
|
}
|
|
}
|
|
|
|
// src/worker/workermain.ts
|
|
var ENVIRONMENT_IS_WEB = typeof window === "object";
|
|
var ENVIRONMENT_IS_WORKER = typeof importScripts === "function";
|
|
var emglobal = ENVIRONMENT_IS_WORKER ? self : ENVIRONMENT_IS_WEB ? window : global;
|
|
if (!emglobal["require"]) {
|
|
emglobal["require"] = (modpath) => {
|
|
if (modpath.endsWith(".js"))
|
|
modpath = modpath.slice(-3);
|
|
var modname = modpath.split("/").slice(-1)[0];
|
|
var hasNamespace = emglobal[modname] != null;
|
|
console.log("@@@ require", modname, modpath, hasNamespace);
|
|
if (!hasNamespace) {
|
|
exports = {};
|
|
importScripts(`${modpath}.js`);
|
|
}
|
|
if (emglobal[modname] == null) {
|
|
emglobal[modname] = exports;
|
|
}
|
|
return emglobal[modname];
|
|
};
|
|
}
|
|
var _WASM_module_cache = {};
|
|
var CACHE_WASM_MODULES = true;
|
|
var wasmMemory;
|
|
function getWASMMemory() {
|
|
if (wasmMemory == null) {
|
|
wasmMemory = new WebAssembly.Memory({
|
|
"initial": 1024,
|
|
"maximum": 16384
|
|
});
|
|
}
|
|
return wasmMemory;
|
|
}
|
|
function getWASMModule(module_id) {
|
|
var module = _WASM_module_cache[module_id];
|
|
if (!module) {
|
|
starttime();
|
|
module = new WebAssembly.Module(wasmBlob[module_id]);
|
|
if (CACHE_WASM_MODULES) {
|
|
_WASM_module_cache[module_id] = module;
|
|
delete wasmBlob[module_id];
|
|
}
|
|
endtime("module creation " + module_id);
|
|
}
|
|
return module;
|
|
}
|
|
function moduleInstFn(module_id) {
|
|
return function(imports, ri) {
|
|
var mod = getWASMModule(module_id);
|
|
var inst = new WebAssembly.Instance(mod, imports);
|
|
ri(inst);
|
|
return inst.exports;
|
|
};
|
|
}
|
|
var PLATFORM_PARAMS = {
|
|
"vcs": {
|
|
arch: "6502",
|
|
code_start: 4096,
|
|
code_size: 61440,
|
|
data_start: 128,
|
|
data_size: 128,
|
|
wiz_rom_ext: ".a26",
|
|
wiz_inc_dir: "2600",
|
|
cfgfile: "atari2600.cfg",
|
|
libargs: ["crt0.o", "atari2600.lib"],
|
|
extra_link_files: ["crt0.o", "atari2600.cfg"],
|
|
define: ["__ATARI2600__"]
|
|
},
|
|
"mw8080bw": {
|
|
arch: "z80",
|
|
code_start: 0,
|
|
rom_size: 8192,
|
|
data_start: 8192,
|
|
data_size: 1024,
|
|
stack_end: 9216
|
|
},
|
|
"vicdual": {
|
|
arch: "z80",
|
|
code_start: 0,
|
|
rom_size: 16416,
|
|
data_start: 58368,
|
|
data_size: 1024,
|
|
stack_end: 59392
|
|
},
|
|
"galaxian": {
|
|
arch: "z80",
|
|
code_start: 0,
|
|
rom_size: 16384,
|
|
data_start: 16384,
|
|
data_size: 1024,
|
|
stack_end: 18432
|
|
},
|
|
"galaxian-scramble": {
|
|
arch: "z80",
|
|
code_start: 0,
|
|
rom_size: 20512,
|
|
data_start: 16384,
|
|
data_size: 1024,
|
|
stack_end: 18432
|
|
},
|
|
"williams": {
|
|
arch: "6809",
|
|
code_start: 0,
|
|
rom_size: 49152,
|
|
data_start: 38912,
|
|
data_size: 10240,
|
|
stack_end: 49152,
|
|
set_stack_end: 49152,
|
|
extra_link_files: ["williams.scr", "libcmoc-crt-vec.a", "libcmoc-std-vec.a"],
|
|
extra_link_args: ["-swilliams.scr", "-lcmoc-crt-vec", "-lcmoc-std-vec"],
|
|
extra_compile_files: ["assert.h", "cmoc.h", "stdarg.h", "stdlib.h"]
|
|
},
|
|
"williams-defender": {
|
|
arch: "6809",
|
|
code_start: 0,
|
|
rom_size: 49152,
|
|
data_start: 38912,
|
|
data_size: 10240,
|
|
stack_end: 49152
|
|
},
|
|
"williams-z80": {
|
|
arch: "z80",
|
|
code_start: 0,
|
|
rom_size: 38912,
|
|
data_start: 38912,
|
|
data_size: 10240,
|
|
stack_end: 49152
|
|
},
|
|
"vector-z80color": {
|
|
arch: "z80",
|
|
code_start: 0,
|
|
rom_size: 32768,
|
|
data_start: 57344,
|
|
data_size: 8192,
|
|
stack_end: 0
|
|
},
|
|
"vector-ataricolor": {
|
|
arch: "6502",
|
|
define: ["__VECTOR__"],
|
|
cfgfile: "vector-color.cfg",
|
|
libargs: ["crt0.o", "none.lib"],
|
|
extra_link_files: ["crt0.o", "vector-color.cfg"]
|
|
},
|
|
"sound_williams-z80": {
|
|
arch: "z80",
|
|
code_start: 0,
|
|
rom_size: 16384,
|
|
data_start: 16384,
|
|
data_size: 1024,
|
|
stack_end: 32768
|
|
},
|
|
"base_z80": {
|
|
arch: "z80",
|
|
code_start: 0,
|
|
rom_size: 32768,
|
|
data_start: 32768,
|
|
data_size: 32768,
|
|
stack_end: 0
|
|
},
|
|
"coleco": {
|
|
arch: "z80",
|
|
rom_start: 32768,
|
|
code_start: 33024,
|
|
rom_size: 32768,
|
|
data_start: 28672,
|
|
data_size: 1024,
|
|
stack_end: 32768,
|
|
extra_preproc_args: ["-I", "/share/include/coleco", "-D", "CV_CV"],
|
|
extra_link_args: ["-k", "/share/lib/coleco", "-l", "libcv", "-l", "libcvu", "crt0.rel"]
|
|
},
|
|
"msx": {
|
|
arch: "z80",
|
|
rom_start: 16384,
|
|
code_start: 16384,
|
|
rom_size: 32768,
|
|
data_start: 49152,
|
|
data_size: 12288,
|
|
stack_end: 65535,
|
|
extra_link_args: ["crt0-msx.rel"],
|
|
extra_link_files: ["crt0-msx.rel", "crt0-msx.lst"],
|
|
wiz_sys_type: "z80",
|
|
wiz_inc_dir: "msx"
|
|
},
|
|
"msx-libcv": {
|
|
arch: "z80",
|
|
rom_start: 16384,
|
|
code_start: 16384,
|
|
rom_size: 32768,
|
|
data_start: 49152,
|
|
data_size: 12288,
|
|
stack_end: 65535,
|
|
extra_preproc_args: ["-I", ".", "-D", "CV_MSX"],
|
|
extra_link_args: ["-k", ".", "-l", "libcv-msx", "-l", "libcvu-msx", "crt0-msx.rel"],
|
|
extra_link_files: ["libcv-msx.lib", "libcvu-msx.lib", "crt0-msx.rel", "crt0-msx.lst"],
|
|
extra_compile_files: ["cv.h", "cv_graphics.h", "cv_input.h", "cv_sound.h", "cv_support.h", "cvu.h", "cvu_c.h", "cvu_compression.h", "cvu_f.h", "cvu_graphics.h", "cvu_input.h", "cvu_sound.h"]
|
|
},
|
|
"sms-sg1000-libcv": {
|
|
arch: "z80",
|
|
rom_start: 0,
|
|
code_start: 256,
|
|
rom_size: 49152,
|
|
data_start: 49152,
|
|
data_size: 1024,
|
|
stack_end: 57344,
|
|
extra_preproc_args: ["-I", ".", "-D", "CV_SMS"],
|
|
extra_link_args: ["-k", ".", "-l", "libcv-sms", "-l", "libcvu-sms", "crt0-sms.rel"],
|
|
extra_link_files: ["libcv-sms.lib", "libcvu-sms.lib", "crt0-sms.rel", "crt0-sms.lst"],
|
|
extra_compile_files: ["cv.h", "cv_graphics.h", "cv_input.h", "cv_sound.h", "cv_support.h", "cvu.h", "cvu_c.h", "cvu_compression.h", "cvu_f.h", "cvu_graphics.h", "cvu_input.h", "cvu_sound.h"]
|
|
},
|
|
"nes": {
|
|
arch: "6502",
|
|
define: ["__NES__"],
|
|
cfgfile: "neslib2.cfg",
|
|
libargs: [
|
|
"crt0.o",
|
|
"nes.lib",
|
|
"neslib2.lib",
|
|
"-D",
|
|
"NES_MAPPER=0",
|
|
"-D",
|
|
"NES_PRG_BANKS=2",
|
|
"-D",
|
|
"NES_CHR_BANKS=1",
|
|
"-D",
|
|
"NES_MIRRORING=0"
|
|
],
|
|
extra_link_files: ["crt0.o", "neslib2.lib", "neslib2.cfg", "nesbanked.cfg"],
|
|
wiz_rom_ext: ".nes"
|
|
},
|
|
"apple2": {
|
|
arch: "6502",
|
|
define: ["__APPLE2__"],
|
|
cfgfile: "apple2.cfg",
|
|
libargs: ["--lib-path", "/share/target/apple2/drv", "-D", "__EXEHDR__=0", "apple2.lib"],
|
|
__CODE_RUN__: 16384,
|
|
code_start: 2051
|
|
},
|
|
"apple2-e": {
|
|
arch: "6502",
|
|
define: ["__APPLE2__"],
|
|
cfgfile: "apple2.cfg",
|
|
libargs: ["apple2.lib"]
|
|
},
|
|
"atari8-800xl.disk": {
|
|
arch: "6502",
|
|
define: ["__ATARI__"],
|
|
cfgfile: "atari.cfg",
|
|
libargs: ["atari.lib"],
|
|
fastbasic_cfgfile: "fastbasic-cart.cfg"
|
|
},
|
|
"atari8-800xl": {
|
|
arch: "6502",
|
|
define: ["__ATARI__"],
|
|
cfgfile: "atari-cart.cfg",
|
|
libargs: ["atari.lib", "-D", "__CARTFLAGS__=4"],
|
|
fastbasic_cfgfile: "fastbasic-cart.cfg"
|
|
},
|
|
"atari8-800": {
|
|
arch: "6502",
|
|
define: ["__ATARI__"],
|
|
cfgfile: "atari-cart.cfg",
|
|
libargs: ["atari.lib", "-D", "__CARTFLAGS__=4"],
|
|
fastbasic_cfgfile: "fastbasic-cart.cfg"
|
|
},
|
|
"atari8-5200": {
|
|
arch: "6502",
|
|
define: ["__ATARI5200__"],
|
|
cfgfile: "atari5200.cfg",
|
|
libargs: ["atari5200.lib", "-D", "__CARTFLAGS__=255"],
|
|
fastbasic_cfgfile: "fastbasic-cart.cfg"
|
|
},
|
|
"verilog": {
|
|
arch: "verilog",
|
|
extra_compile_files: ["8bitworkshop.v"]
|
|
},
|
|
"astrocade": {
|
|
arch: "z80",
|
|
code_start: 8192,
|
|
rom_size: 8192,
|
|
data_start: 19984,
|
|
data_size: 496,
|
|
stack_end: 20480
|
|
},
|
|
"astrocade-arcade": {
|
|
arch: "z80",
|
|
code_start: 0,
|
|
rom_size: 16384,
|
|
data_start: 32224,
|
|
data_size: 544,
|
|
stack_end: 32768
|
|
},
|
|
"astrocade-bios": {
|
|
arch: "z80",
|
|
code_start: 0,
|
|
rom_size: 8192,
|
|
data_start: 20430,
|
|
data_size: 50,
|
|
stack_end: 20430
|
|
},
|
|
"atari7800": {
|
|
arch: "6502",
|
|
define: ["__ATARI7800__"],
|
|
cfgfile: "atari7800.cfg",
|
|
libargs: ["crt0.o", "none.lib"],
|
|
extra_link_files: ["crt0.o", "atari7800.cfg"]
|
|
},
|
|
"c64": {
|
|
arch: "6502",
|
|
define: ["__CBM__", "__C64__"],
|
|
cfgfile: "c64.cfg",
|
|
libargs: ["c64.lib"]
|
|
},
|
|
"vic20": {
|
|
arch: "6502",
|
|
define: ["__CBM__", "__VIC20__"],
|
|
cfgfile: "vic20.cfg",
|
|
libargs: ["vic20.lib"]
|
|
},
|
|
"kim1": {
|
|
arch: "6502"
|
|
},
|
|
"vectrex": {
|
|
arch: "6809",
|
|
code_start: 0,
|
|
rom_size: 32768,
|
|
data_start: 51328,
|
|
data_size: 896,
|
|
stack_end: 52224,
|
|
extra_compile_files: ["assert.h", "cmoc.h", "stdarg.h", "vectrex.h", "stdlib.h", "bios.h"],
|
|
extra_link_files: ["vectrex.scr", "libcmoc-crt-vec.a", "libcmoc-std-vec.a"],
|
|
extra_compile_args: ["--vectrex"],
|
|
extra_link_args: ["-svectrex.scr", "-lcmoc-crt-vec", "-lcmoc-std-vec"]
|
|
},
|
|
"x86": {
|
|
arch: "x86"
|
|
},
|
|
"zx": {
|
|
arch: "z80",
|
|
code_start: 23755,
|
|
rom_size: 65368 - 23755,
|
|
data_start: 61440,
|
|
data_size: 65024 - 61440,
|
|
stack_end: 65368,
|
|
extra_link_args: ["crt0-zx.rel"],
|
|
extra_link_files: ["crt0-zx.rel", "crt0-zx.lst"]
|
|
},
|
|
"devel-6502": {
|
|
arch: "6502",
|
|
cfgfile: "devel-6502.cfg",
|
|
libargs: ["crt0.o", "none.lib"],
|
|
extra_link_files: ["crt0.o", "devel-6502.cfg"]
|
|
},
|
|
"cpc.rslib": {
|
|
arch: "z80",
|
|
code_start: 16384,
|
|
rom_size: 45312 - 16384,
|
|
data_start: 45312,
|
|
data_size: 45312 - 49152,
|
|
stack_end: 49152,
|
|
extra_compile_files: ["cpcrslib.h"],
|
|
extra_link_args: ["crt0-cpc.rel", "cpcrslib.lib"],
|
|
extra_link_files: ["crt0-cpc.rel", "crt0-cpc.lst", "cpcrslib.lib", "cpcrslib.lst"]
|
|
},
|
|
"cpc": {
|
|
arch: "z80",
|
|
code_start: 16384,
|
|
rom_size: 45312 - 16384,
|
|
data_start: 45312,
|
|
data_size: 45312 - 49152,
|
|
stack_end: 49152,
|
|
extra_compile_files: ["cpctelera.h"],
|
|
extra_link_args: ["crt0-cpc.rel", "cpctelera.lib"],
|
|
extra_link_files: ["crt0-cpc.rel", "crt0-cpc.lst", "cpctelera.lib", "cpctelera.lst"]
|
|
},
|
|
"pce": {
|
|
arch: "huc6280",
|
|
define: ["__PCE__"],
|
|
cfgfile: "pce.cfg",
|
|
libargs: ["pce.lib", "-D", "__CARTSIZE__=0x8000"]
|
|
}
|
|
};
|
|
PLATFORM_PARAMS["sms-sms-libcv"] = PLATFORM_PARAMS["sms-sg1000-libcv"];
|
|
PLATFORM_PARAMS["sms-gg-libcv"] = PLATFORM_PARAMS["sms-sms-libcv"];
|
|
var _t1;
|
|
function starttime() {
|
|
_t1 = new Date();
|
|
}
|
|
function endtime(msg) {
|
|
var _t2 = new Date();
|
|
console.log(msg, _t2.getTime() - _t1.getTime(), "ms");
|
|
}
|
|
var FileWorkingStore = class {
|
|
constructor() {
|
|
this.workfs = {};
|
|
this.workerseq = 0;
|
|
this.reset();
|
|
}
|
|
reset() {
|
|
this.workfs = {};
|
|
this.newVersion();
|
|
}
|
|
currentVersion() {
|
|
return this.workerseq;
|
|
}
|
|
newVersion() {
|
|
let ts = new Date().getTime();
|
|
if (ts <= this.workerseq)
|
|
ts = ++this.workerseq;
|
|
return ts;
|
|
}
|
|
putFile(path, data) {
|
|
var encoding = typeof data === "string" ? "utf8" : "binary";
|
|
var entry = this.workfs[path];
|
|
if (!entry || !compareData(entry.data, data) || entry.encoding != encoding) {
|
|
this.workfs[path] = entry = { path, data, encoding, ts: this.newVersion() };
|
|
console.log("+++", entry.path, entry.encoding, entry.data.length, entry.ts);
|
|
}
|
|
return entry;
|
|
}
|
|
hasFile(path) {
|
|
return this.workfs[path] != null;
|
|
}
|
|
getFileData(path) {
|
|
return this.workfs[path] && this.workfs[path].data;
|
|
}
|
|
getFileAsString(path) {
|
|
let data = this.getFileData(path);
|
|
if (data != null && typeof data !== "string")
|
|
throw new Error(`${path}: expected string`);
|
|
return data;
|
|
}
|
|
getFileEntry(path) {
|
|
return this.workfs[path];
|
|
}
|
|
setItem(key, value) {
|
|
this.items[key] = value;
|
|
}
|
|
};
|
|
var store = new FileWorkingStore();
|
|
function errorResult(msg) {
|
|
return { errors: [{ line: 0, msg }] };
|
|
}
|
|
var Builder = class {
|
|
constructor() {
|
|
this.steps = [];
|
|
this.startseq = 0;
|
|
}
|
|
wasChanged(entry) {
|
|
return entry.ts > this.startseq;
|
|
}
|
|
async executeBuildSteps() {
|
|
this.startseq = store.currentVersion();
|
|
var linkstep = null;
|
|
while (this.steps.length) {
|
|
var step = this.steps.shift();
|
|
var platform = step.platform;
|
|
var [tool, remoteTool] = step.tool.split(":", 2);
|
|
var toolfn = TOOLS[tool];
|
|
if (!toolfn) {
|
|
throw Error(`no tool named "${tool}"`);
|
|
}
|
|
if (remoteTool) {
|
|
step.tool = remoteTool;
|
|
}
|
|
step.params = PLATFORM_PARAMS[getBasePlatform(platform)];
|
|
try {
|
|
step.result = await toolfn(step);
|
|
} catch (e) {
|
|
console.log("EXCEPTION", e, e.stack);
|
|
return errorResult(e + "");
|
|
}
|
|
if (step.result) {
|
|
step.result.params = step.params;
|
|
if (step.debuginfo) {
|
|
let r = step.result;
|
|
if (!r.debuginfo)
|
|
r.debuginfo = {};
|
|
Object.assign(r.debuginfo, step.debuginfo);
|
|
}
|
|
if ("errors" in step.result && step.result.errors.length) {
|
|
applyDefaultErrorPath(step.result.errors, step.path);
|
|
return step.result;
|
|
}
|
|
if ("output" in step.result && step.result.output) {
|
|
return step.result;
|
|
}
|
|
if ("linktool" in step.result) {
|
|
if (linkstep) {
|
|
linkstep.files = linkstep.files.concat(step.result.files);
|
|
linkstep.args = linkstep.args.concat(step.result.args);
|
|
} else {
|
|
linkstep = {
|
|
tool: step.result.linktool,
|
|
platform,
|
|
files: step.result.files,
|
|
args: step.result.args
|
|
};
|
|
}
|
|
linkstep.debuginfo = step.debuginfo;
|
|
}
|
|
if ("nexttool" in step.result) {
|
|
var asmstep = __spreadValues({
|
|
tool: step.result.nexttool,
|
|
platform
|
|
}, step.result);
|
|
this.steps.push(asmstep);
|
|
}
|
|
if (this.steps.length == 0 && linkstep) {
|
|
this.steps.push(linkstep);
|
|
linkstep = null;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
async handleMessage(data) {
|
|
this.steps = [];
|
|
if (data.updates) {
|
|
data.updates.forEach((u) => store.putFile(u.path, u.data));
|
|
}
|
|
if (data.setitems) {
|
|
data.setitems.forEach((i) => store.setItem(i.key, i.value));
|
|
}
|
|
if (data.buildsteps) {
|
|
this.steps.push.apply(this.steps, data.buildsteps);
|
|
}
|
|
if (data.code) {
|
|
this.steps.push(data);
|
|
}
|
|
if (this.steps.length) {
|
|
var result = await this.executeBuildSteps();
|
|
return result ? result : { unchanged: true };
|
|
}
|
|
console.log("Unknown message", data);
|
|
}
|
|
};
|
|
var builder = new Builder();
|
|
function applyDefaultErrorPath(errors, path) {
|
|
if (!path)
|
|
return;
|
|
for (var i = 0; i < errors.length; i++) {
|
|
var err = errors[i];
|
|
if (!err.path && err.line)
|
|
err.path = path;
|
|
}
|
|
}
|
|
function compareData(a, b) {
|
|
if (a.length != b.length)
|
|
return false;
|
|
if (typeof a === "string" && typeof b === "string") {
|
|
return a == b;
|
|
} else {
|
|
for (var i = 0; i < a.length; i++) {
|
|
if (a[i] != b[i])
|
|
return false;
|
|
}
|
|
return true;
|
|
}
|
|
}
|
|
function putWorkFile(path, data) {
|
|
return store.putFile(path, data);
|
|
}
|
|
function getWorkFileAsString(path) {
|
|
return store.getFileAsString(path);
|
|
}
|
|
function populateEntry(fs, path, entry, options) {
|
|
var data = entry.data;
|
|
if (options && options.processFn) {
|
|
data = options.processFn(path, data);
|
|
}
|
|
var toks = path.split("/");
|
|
if (toks.length > 1) {
|
|
for (var i = 0; i < toks.length - 1; i++)
|
|
try {
|
|
fs.mkdir(toks[i]);
|
|
} catch (e) {
|
|
}
|
|
}
|
|
fs.writeFile(path, data, { encoding: entry.encoding });
|
|
var time = new Date(entry.ts);
|
|
fs.utime(path, time, time);
|
|
console.log("<<<", path, entry.data.length);
|
|
}
|
|
function gatherFiles(step, options) {
|
|
var maxts = 0;
|
|
if (step.files) {
|
|
for (var i = 0; i < step.files.length; i++) {
|
|
var path = step.files[i];
|
|
var entry = store.workfs[path];
|
|
if (!entry) {
|
|
throw new Error("No entry for path '" + path + "'");
|
|
} else {
|
|
maxts = Math.max(maxts, entry.ts);
|
|
}
|
|
}
|
|
} else if (step.code) {
|
|
var path = step.path ? step.path : options.mainFilePath;
|
|
if (!path)
|
|
throw Error("need path or mainFilePath");
|
|
var code = step.code;
|
|
var entry = putWorkFile(path, code);
|
|
step.path = path;
|
|
step.files = [path];
|
|
maxts = entry.ts;
|
|
} else if (step.path) {
|
|
var path = step.path;
|
|
var entry = store.workfs[path];
|
|
maxts = entry.ts;
|
|
step.files = [path];
|
|
}
|
|
if (step.path && !step.prefix) {
|
|
step.prefix = getPrefix(step.path);
|
|
}
|
|
step.maxts = maxts;
|
|
return maxts;
|
|
}
|
|
function getPrefix(s) {
|
|
var pos = s.lastIndexOf(".");
|
|
return pos > 0 ? s.substring(0, pos) : s;
|
|
}
|
|
function populateFiles(step, fs, options) {
|
|
gatherFiles(step, options);
|
|
if (!step.files)
|
|
throw Error("call gatherFiles() first");
|
|
for (var i = 0; i < step.files.length; i++) {
|
|
var path = step.files[i];
|
|
populateEntry(fs, path, store.workfs[path], options);
|
|
}
|
|
}
|
|
function populateExtraFiles(step, fs, extrafiles) {
|
|
if (extrafiles) {
|
|
for (var i = 0; i < extrafiles.length; i++) {
|
|
var xfn = extrafiles[i];
|
|
if (store.workfs[xfn]) {
|
|
fs.writeFile(xfn, store.workfs[xfn].data, { encoding: "binary" });
|
|
continue;
|
|
}
|
|
var xpath = "lib/" + getBasePlatform(step.platform) + "/" + xfn;
|
|
var xhr = new XMLHttpRequest();
|
|
xhr.responseType = "arraybuffer";
|
|
xhr.open("GET", PWORKER + xpath, false);
|
|
xhr.send(null);
|
|
if (xhr.response && xhr.status == 200) {
|
|
var data = new Uint8Array(xhr.response);
|
|
fs.writeFile(xfn, data, { encoding: "binary" });
|
|
putWorkFile(xfn, data);
|
|
console.log(":::", xfn, data.length);
|
|
} else {
|
|
throw Error("Could not load extra file " + xpath);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
function staleFiles(step, targets) {
|
|
if (!step.maxts)
|
|
throw Error("call populateFiles() first");
|
|
for (var i = 0; i < targets.length; i++) {
|
|
var entry = store.workfs[targets[i]];
|
|
if (!entry || step.maxts > entry.ts)
|
|
return true;
|
|
}
|
|
console.log("unchanged", step.maxts, targets);
|
|
return false;
|
|
}
|
|
function anyTargetChanged(step, targets) {
|
|
if (!step.maxts)
|
|
throw Error("call populateFiles() first");
|
|
for (var i = 0; i < targets.length; i++) {
|
|
var entry = store.workfs[targets[i]];
|
|
if (!entry || entry.ts > step.maxts)
|
|
return true;
|
|
}
|
|
console.log("unchanged", step.maxts, targets);
|
|
return false;
|
|
}
|
|
function execMain(step, mod, args) {
|
|
starttime();
|
|
var run = mod.callMain || mod.run;
|
|
run(args);
|
|
endtime(step.tool);
|
|
}
|
|
var fsMeta = {};
|
|
var fsBlob = {};
|
|
var wasmBlob = {};
|
|
var PSRC = "../../src/";
|
|
var PWORKER = PSRC + "worker/";
|
|
function loadFilesystem(name) {
|
|
var xhr = new XMLHttpRequest();
|
|
xhr.responseType = "blob";
|
|
xhr.open("GET", PWORKER + "fs/fs" + name + ".data", false);
|
|
xhr.send(null);
|
|
fsBlob[name] = xhr.response;
|
|
xhr = new XMLHttpRequest();
|
|
xhr.responseType = "json";
|
|
xhr.open("GET", PWORKER + "fs/fs" + name + ".js.metadata", false);
|
|
xhr.send(null);
|
|
fsMeta[name] = xhr.response;
|
|
console.log("Loaded " + name + " filesystem", fsMeta[name].files.length, "files", fsBlob[name].size, "bytes");
|
|
}
|
|
var loaded = {};
|
|
function load(modulename, debug2) {
|
|
if (!loaded[modulename]) {
|
|
importScripts(PWORKER + "asmjs/" + modulename + (debug2 ? "." + debug2 + ".js" : ".js"));
|
|
loaded[modulename] = 1;
|
|
}
|
|
}
|
|
function loadWASM(modulename, debug2) {
|
|
if (!loaded[modulename]) {
|
|
importScripts(PWORKER + "wasm/" + modulename + (debug2 ? "." + debug2 + ".js" : ".js"));
|
|
var xhr = new XMLHttpRequest();
|
|
xhr.responseType = "arraybuffer";
|
|
xhr.open("GET", PWORKER + "wasm/" + modulename + ".wasm", false);
|
|
xhr.send(null);
|
|
if (xhr.response) {
|
|
wasmBlob[modulename] = new Uint8Array(xhr.response);
|
|
console.log("Loaded " + modulename + ".wasm (" + wasmBlob[modulename].length + " bytes)");
|
|
loaded[modulename] = 1;
|
|
} else {
|
|
throw Error("Could not load WASM file " + modulename + ".wasm");
|
|
}
|
|
}
|
|
}
|
|
function loadNative(modulename) {
|
|
if (CACHE_WASM_MODULES && typeof WebAssembly === "object") {
|
|
loadWASM(modulename);
|
|
} else {
|
|
load(modulename);
|
|
}
|
|
}
|
|
function setupFS(FS, name) {
|
|
var WORKERFS = FS.filesystems["WORKERFS"];
|
|
if (name === "65-vector")
|
|
name = "65-none";
|
|
if (name === "65-atari7800")
|
|
name = "65-none";
|
|
if (name === "65-devel")
|
|
name = "65-none";
|
|
if (name === "65-vcs")
|
|
name = "65-atari2600";
|
|
if (!fsMeta[name])
|
|
throw Error("No filesystem for '" + name + "'");
|
|
FS.mkdir("/share");
|
|
FS.mount(WORKERFS, {
|
|
packages: [{ metadata: fsMeta[name], blob: fsBlob[name] }]
|
|
}, "/share");
|
|
var reader = WORKERFS.reader;
|
|
var blobcache = {};
|
|
WORKERFS.stream_ops.read = function(stream, buffer, offset, length, position) {
|
|
if (position >= stream.node.size)
|
|
return 0;
|
|
var contents = blobcache[stream.path];
|
|
if (!contents) {
|
|
var ab = reader.readAsArrayBuffer(stream.node.contents);
|
|
contents = blobcache[stream.path] = new Uint8Array(ab);
|
|
}
|
|
if (position + length > contents.length)
|
|
length = contents.length - position;
|
|
for (var i = 0; i < length; i++) {
|
|
buffer[offset + i] = contents[position + i];
|
|
}
|
|
return length;
|
|
};
|
|
}
|
|
var print_fn = function(s) {
|
|
console.log(s);
|
|
};
|
|
var re_msvc = /[/]*([^( ]+)\s*[(](\d+)[)]\s*:\s*(.+?):\s*(.*)/;
|
|
var re_msvc2 = /\s*(at)\s+(\d+)\s*(:)\s*(.*)/;
|
|
function msvcErrorMatcher(errors) {
|
|
return function(s) {
|
|
var matches = re_msvc.exec(s) || re_msvc2.exec(s);
|
|
if (matches) {
|
|
var errline = parseInt(matches[2]);
|
|
errors.push({
|
|
line: errline,
|
|
path: matches[1],
|
|
msg: matches[4]
|
|
});
|
|
} else {
|
|
console.log(s);
|
|
}
|
|
};
|
|
}
|
|
function makeErrorMatcher(errors, regex, iline, imsg, mainpath, ifilename) {
|
|
return function(s) {
|
|
var matches = regex.exec(s);
|
|
if (matches) {
|
|
errors.push({
|
|
line: parseInt(matches[iline]) || 1,
|
|
msg: matches[imsg],
|
|
path: ifilename ? matches[ifilename] : mainpath
|
|
});
|
|
} else {
|
|
console.log("??? " + s);
|
|
}
|
|
};
|
|
}
|
|
function extractErrors(regex, strings, path, iline, imsg, ifilename) {
|
|
var errors = [];
|
|
var matcher = makeErrorMatcher(errors, regex, iline, imsg, path, ifilename);
|
|
for (var i = 0; i < strings.length; i++) {
|
|
matcher(strings[i]);
|
|
}
|
|
return errors;
|
|
}
|
|
var re_crlf = /\r?\n/;
|
|
var re_lineoffset = /\s*(\d+)\s+[%]line\s+(\d+)\+(\d+)\s+(.+)/;
|
|
function parseListing(code, lineMatch, iline, ioffset, iinsns, icycles, funcMatch, segMatch) {
|
|
var lines = [];
|
|
var lineofs = 0;
|
|
var segment = "";
|
|
var func = "";
|
|
var funcbase = 0;
|
|
code.split(re_crlf).forEach((line, lineindex) => {
|
|
let segm = segMatch && segMatch.exec(line);
|
|
if (segm) {
|
|
segment = segm[1];
|
|
}
|
|
let funcm = funcMatch && funcMatch.exec(line);
|
|
if (funcm) {
|
|
funcbase = parseInt(funcm[1], 16);
|
|
func = funcm[2];
|
|
}
|
|
var linem = lineMatch.exec(line);
|
|
if (linem && linem[1]) {
|
|
var linenum = iline < 0 ? lineindex : parseInt(linem[iline]);
|
|
var offset = parseInt(linem[ioffset], 16);
|
|
var insns = linem[iinsns];
|
|
var cycles = icycles ? parseInt(linem[icycles]) : null;
|
|
var iscode = cycles > 0;
|
|
if (insns) {
|
|
lines.push({
|
|
line: linenum + lineofs,
|
|
offset: offset - funcbase,
|
|
insns,
|
|
cycles,
|
|
iscode,
|
|
segment,
|
|
func
|
|
});
|
|
}
|
|
} else {
|
|
let m = re_lineoffset.exec(line);
|
|
if (m) {
|
|
lineofs = parseInt(m[2]) - parseInt(m[1]) - parseInt(m[3]);
|
|
}
|
|
}
|
|
});
|
|
return lines;
|
|
}
|
|
function parseSourceLines(code, lineMatch, offsetMatch, funcMatch, segMatch) {
|
|
var lines = [];
|
|
var lastlinenum = 0;
|
|
var segment = "";
|
|
var func = "";
|
|
var funcbase = 0;
|
|
for (var line of code.split(re_crlf)) {
|
|
let segm = segMatch && segMatch.exec(line);
|
|
if (segm) {
|
|
segment = segm[1];
|
|
}
|
|
let funcm = funcMatch && funcMatch.exec(line);
|
|
if (funcm) {
|
|
funcbase = parseInt(funcm[1], 16);
|
|
func = funcm[2];
|
|
}
|
|
var linem = lineMatch.exec(line);
|
|
if (linem && linem[1]) {
|
|
lastlinenum = parseInt(linem[1]);
|
|
} else if (lastlinenum) {
|
|
var linem = offsetMatch.exec(line);
|
|
if (linem && linem[1]) {
|
|
var offset = parseInt(linem[1], 16);
|
|
lines.push({
|
|
line: lastlinenum,
|
|
offset: offset - funcbase,
|
|
segment,
|
|
func
|
|
});
|
|
lastlinenum = 0;
|
|
}
|
|
}
|
|
}
|
|
return lines;
|
|
}
|
|
function setupStdin(fs, code) {
|
|
var i = 0;
|
|
fs.init(function() {
|
|
return i < code.length ? code.charCodeAt(i++) : null;
|
|
});
|
|
}
|
|
function fixParamsWithDefines(path, params) {
|
|
var libargs = params.libargs;
|
|
if (path && libargs) {
|
|
var code = getWorkFileAsString(path);
|
|
if (code) {
|
|
var oldcfgfile = params.cfgfile;
|
|
var ident2index = {};
|
|
for (var i = 0; i < libargs.length; i++) {
|
|
var toks = libargs[i].split("=");
|
|
if (toks.length == 2) {
|
|
ident2index[toks[0]] = i;
|
|
}
|
|
}
|
|
var re = /^[;]?#define\s+(\w+)\s+(\S+)/gmi;
|
|
var m;
|
|
while (m = re.exec(code)) {
|
|
var ident = m[1];
|
|
var value = m[2];
|
|
var index = ident2index[ident];
|
|
if (index >= 0) {
|
|
libargs[index] = ident + "=" + value;
|
|
console.log("Using libargs", index, libargs[index]);
|
|
if (ident == "NES_MAPPER" && value == "4") {
|
|
params.cfgfile = "nesbanked.cfg";
|
|
console.log("using config file", params.cfgfile);
|
|
}
|
|
} else if (ident == "CFGFILE" && value) {
|
|
params.cfgfile = value;
|
|
} else if (ident == "LIBARGS" && value) {
|
|
params.libargs = value.split(",").filter((s) => {
|
|
return s != "";
|
|
});
|
|
console.log("Using libargs", params.libargs);
|
|
} else if (ident == "CC65_FLAGS" && value) {
|
|
params.extra_compiler_args = value.split(",").filter((s) => {
|
|
return s != "";
|
|
});
|
|
console.log("Using compiler flags", params.extra_compiler_args);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
function makeCPPSafe(s) {
|
|
return s.replace(/[^A-Za-z0-9_]/g, "_");
|
|
}
|
|
function preprocessMCPP(step, filesys) {
|
|
load("mcpp");
|
|
var platform = step.platform;
|
|
var params = PLATFORM_PARAMS[getBasePlatform(platform)];
|
|
if (!params)
|
|
throw Error("Platform not supported: " + platform);
|
|
var errors = [];
|
|
var match_fn = makeErrorMatcher(errors, /<stdin>:(\d+): (.+)/, 1, 2, step.path);
|
|
var MCPP = emglobal.mcpp({
|
|
noInitialRun: true,
|
|
noFSInit: true,
|
|
print: print_fn,
|
|
printErr: match_fn
|
|
});
|
|
var FS = MCPP.FS;
|
|
if (filesys)
|
|
setupFS(FS, filesys);
|
|
populateFiles(step, FS);
|
|
populateExtraFiles(step, FS, params.extra_compile_files);
|
|
var args = [
|
|
"-D",
|
|
"__8BITWORKSHOP__",
|
|
"-D",
|
|
"__SDCC_z80",
|
|
"-D",
|
|
makeCPPSafe(platform.toUpperCase()),
|
|
"-I",
|
|
"/share/include",
|
|
"-Q",
|
|
step.path,
|
|
"main.i"
|
|
];
|
|
if (step.mainfile) {
|
|
args.unshift.apply(args, ["-D", "__MAIN__"]);
|
|
}
|
|
let platform_def = platform.toUpperCase().replaceAll(/[^a-zA-Z0-9]/g, "_");
|
|
args.unshift.apply(args, ["-D", `__PLATFORM_${platform_def}__`]);
|
|
if (params.extra_preproc_args) {
|
|
args.push.apply(args, params.extra_preproc_args);
|
|
}
|
|
execMain(step, MCPP, args);
|
|
if (errors.length)
|
|
return { errors };
|
|
var iout = FS.readFile("main.i", { encoding: "utf8" });
|
|
iout = iout.replace(/^#line /gm, "\n# ");
|
|
try {
|
|
var errout = FS.readFile("mcpp.err", { encoding: "utf8" });
|
|
if (errout.length) {
|
|
var errors = extractErrors(/([^:]+):(\d+): (.+)/, errout.split("\n"), step.path, 2, 3, 1);
|
|
if (errors.length == 0) {
|
|
errors = errorResult(errout).errors;
|
|
}
|
|
return { errors };
|
|
}
|
|
} catch (e) {
|
|
}
|
|
return { code: iout };
|
|
}
|
|
function setupRequireFunction() {
|
|
var exports2 = {};
|
|
exports2["jsdom"] = {
|
|
JSDOM: function(a, b) {
|
|
this.window = {};
|
|
}
|
|
};
|
|
emglobal["require"] = (modname) => {
|
|
console.log("require", modname, exports2[modname] != null);
|
|
return exports2[modname];
|
|
};
|
|
}
|
|
var TOOLS = {
|
|
"dasm": assembleDASM,
|
|
"cc65": compileCC65,
|
|
"ca65": assembleCA65,
|
|
"ld65": linkLD65,
|
|
"sdasz80": assembleSDASZ80,
|
|
"sdldz80": linkSDLDZ80,
|
|
"sdcc": compileSDCC,
|
|
"xasm6809": assembleXASM6809,
|
|
"cmoc": compileCMOC,
|
|
"lwasm": assembleLWASM,
|
|
"lwlink": linkLWLINK,
|
|
"verilator": compileVerilator,
|
|
"yosys": compileYosys,
|
|
"jsasm": compileJSASMStep,
|
|
"zmac": assembleZMAC,
|
|
"nesasm": assembleNESASM,
|
|
"smlrc": compileSmallerC,
|
|
"yasm": assembleYASM,
|
|
"bataribasic": compileBatariBasic,
|
|
"markdown": translateShowdown,
|
|
"inform6": compileInform6,
|
|
"merlin32": assembleMerlin32,
|
|
"fastbasic": compileFastBasic,
|
|
"basic": compileBASIC,
|
|
"silice": compileSilice,
|
|
"wiz": compileWiz,
|
|
"armips": assembleARMIPS,
|
|
"vasmarm": assembleVASMARM,
|
|
"ecs": assembleECS,
|
|
"remote": buildRemote
|
|
};
|
|
var TOOL_PRELOADFS = {
|
|
"cc65-apple2": "65-apple2",
|
|
"ca65-apple2": "65-apple2",
|
|
"cc65-c64": "65-c64",
|
|
"ca65-c64": "65-c64",
|
|
"cc65-vic20": "65-vic20",
|
|
"ca65-vic20": "65-vic20",
|
|
"cc65-nes": "65-nes",
|
|
"ca65-nes": "65-nes",
|
|
"cc65-atari8": "65-atari8",
|
|
"ca65-atari8": "65-atari8",
|
|
"cc65-vector": "65-none",
|
|
"ca65-vector": "65-none",
|
|
"cc65-atari7800": "65-none",
|
|
"ca65-atari7800": "65-none",
|
|
"cc65-devel": "65-none",
|
|
"ca65-devel": "65-none",
|
|
"cc65-vcs": "65-atari2600",
|
|
"ca65-vcs": "65-atari2600",
|
|
"cc65-pce": "65-pce",
|
|
"ca65-pce": "65-pce",
|
|
"sdasz80": "sdcc",
|
|
"sdcc": "sdcc",
|
|
"sccz80": "sccz80",
|
|
"bataribasic": "2600basic",
|
|
"inform6": "inform",
|
|
"fastbasic": "65-atari8",
|
|
"silice": "Silice",
|
|
"wiz": "wiz",
|
|
"ecs-vcs": "65-atari2600",
|
|
"ecs-nes": "65-nes",
|
|
"ecs-c64": "65-c64"
|
|
};
|
|
async function handleMessage(data) {
|
|
if (data.preload) {
|
|
var fs = TOOL_PRELOADFS[data.preload];
|
|
if (!fs && data.platform)
|
|
fs = TOOL_PRELOADFS[data.preload + "-" + getBasePlatform(data.platform)];
|
|
if (!fs && data.platform)
|
|
fs = TOOL_PRELOADFS[data.preload + "-" + getRootBasePlatform(data.platform)];
|
|
if (fs && !fsMeta[fs])
|
|
loadFilesystem(fs);
|
|
return;
|
|
}
|
|
if (data.reset) {
|
|
store.reset();
|
|
return;
|
|
}
|
|
return builder.handleMessage(data);
|
|
}
|
|
if (ENVIRONMENT_IS_WORKER) {
|
|
lastpromise = null;
|
|
onmessage = async function(e) {
|
|
await lastpromise;
|
|
lastpromise = handleMessage(e.data);
|
|
var result = await lastpromise;
|
|
lastpromise = null;
|
|
if (result) {
|
|
try {
|
|
postMessage(result);
|
|
} catch (e2) {
|
|
console.log(e2);
|
|
postMessage(errorResult(`${e2}`));
|
|
}
|
|
}
|
|
};
|
|
}
|
|
var lastpromise;
|
|
})();
|
|
//# sourceMappingURL=bundle.js.map
|