@markw65/monkeyc-optimizer 1.1.13 → 1.1.15

package/build/src/logger.d.ts

@@ -0,0 +1,4 @@
+export declare function logger(module: string, level: number, message: unknown): void;
+export declare function wouldLog(module: string, level: number): boolean;
+export declare function log(message: unknown): void;
+export declare function setLogger(log: (message: string) => void): void;

package/build/src/optimizer-types.d.ts

@@ -39,7 +39,9 @@ export declare type BuildConfig = {
     trustDeclaredTypes?: boolean;
     minimizeLocals?: boolean;
     minimizeModules?: boolean;
+    postBuildOptimizer?: boolean;
     singleUseCopyProp?: boolean;
+    iterateOptimizer?: boolean;
     covarianceWarnings?: boolean;
     checkTypes?: DiagnosticType | "OFF";
 };

package/build/src/optimizer.d.ts

@@ -20,6 +20,11 @@ export declare function isErrorWithLocation(e: Error): e is ErrorWithLocation;
 declare global {
     var lastModifiedSource: number;
 }
+/**
+ * @param {BuildConfig} options
+ * @returns {Promise<BuildConfig>}
+ */
+export declare function getConfig(options: BuildConfig): Promise<BuildConfig>;
 /**
  *
  * WARNING WARNING WARNING WARNING WARNING WARNING

package/build/src/readprg/bytecode.d.ts

@@ -0,0 +1,57 @@
+/// <reference types="node" />
+import * as crypto from "node:crypto";
+import { xmlUtil } from "../sdk-util";
+import { ExceptionEntry, ExceptionsMap } from "./exceptions";
+import { LineNumber } from "./linenum";
+import { Bytecode, Opcodes } from "./opcodes";
+import { SymbolTable } from "./symbols";
+export declare const enum SectionKinds {
+    TEXT = -1059145026,
+    DATA = -629491010,
+    SYMBOLS = 1461170197,
+    LINENUM = -1059161423,
+    EXCEPTIONS = 248410373,
+    SIGNATURE = -507453934,
+    STORE_SIG = 20833
+}
+export declare type SectionInfo = {
+    offset: number;
+    length: number;
+    view: DataView;
+};
+export declare type Logger = (module: string, level: number, message: string) => void;
+export declare type Context = {
+    filepath: string;
+    sections: Record<number, SectionInfo>;
+    symbolTable: SymbolTable;
+    lineTable: Map<number, LineNumber>;
+    exceptionsMap: ExceptionsMap;
+    bytecodes: Bytecode[];
+    key?: crypto.KeyObject;
+    debugXml: xmlUtil.Document;
+};
+export declare type Block = {
+    offset: number;
+    bytecodes: Bytecode[];
+    try?: ExceptionEntry[];
+    next?: number;
+    taken?: number;
+    preds?: Set<number>;
+};
+export declare type FuncEntry = {
+    name?: string;
+    offset: number;
+    blocks: Map<number, Block>;
+};
+export declare function offsetToString(offset: number): string;
+export declare function fixSectionSize(section: SectionKinds, sections: Context["sections"], newSize: number): void;
+export declare function optimizeBytecode(context: Context): void;
+export declare function printFunction(func: FuncEntry, context: Context | null): void;
+export declare function blockToString(block: Block, context: Context | null): string;
+export declare function bytecodeToString(bytecode: Bytecode, symbolTable: SymbolTable | null | undefined): string;
+export declare function findFunctions({ bytecodes, symbolTable, exceptionsMap, }: Context): Map<number, FuncEntry>;
+export declare function makeArgless(bc: Bytecode, op: Opcodes): void;
+export declare function equalBlocks(b1: Block, b2: Block): boolean;
+export declare function removePred(func: FuncEntry, target: number, pred: number): void;
+export declare function addPred(func: FuncEntry, target: number, pred: number): void;
+export declare function redirect(func: FuncEntry, block: Block, from: number, to: number): boolean;

package/build/src/readprg/data.d.ts

@@ -0,0 +1,4 @@
+import { Context } from "./bytecode";
+import { SymbolTable } from "./symbols";
+export declare function parseData(view: DataView, symbols: SymbolTable): void;
+export declare function fixupData(context: Context, offsetMap: Map<number, number>): void;

package/build/src/readprg/dce.d.ts

@@ -0,0 +1,2 @@
+import { FuncEntry, Context } from "./bytecode";
+export declare function localDCE(func: FuncEntry, context: Context): boolean;

package/build/src/readprg/emit.d.ts

@@ -0,0 +1,12 @@
+import { Context, FuncEntry } from "./bytecode";
+import { LineNumber } from "./linenum";
+export declare type LocalsMap = Map<number, {
+    startPc: number;
+    endPc: number;
+}>;
+export declare type UpdateInfo = {
+    offsetMap: Map<number, number>;
+    localsMap: Map<FuncEntry, LocalsMap>;
+    lineMap: LineNumber[];
+};
+export declare function emitFunc(func: FuncEntry, view: DataView, start: number, updateInfo: UpdateInfo, context: Context): number;

package/build/src/readprg/exceptions.d.ts

@@ -0,0 +1,9 @@
+import { Context } from "./bytecode";
+export declare type ExceptionEntry = {
+    tryStart: number;
+    tryEnd: number;
+    handler: number;
+};
+export declare type ExceptionsMap = Map<number, ExceptionEntry[]>;
+export declare function parseExceptions(view: DataView): ExceptionsMap;
+export declare function fixupExceptions(context: Context, offsetMap: Map<number, number>): void;

package/build/src/readprg/linenum.d.ts

@@ -0,0 +1,29 @@
+import { xmlUtil } from "../sdk-util";
+import { Context } from "./bytecode";
+import { UpdateInfo } from "./emit";
+interface BaseLineNumber {
+    pc: number;
+    file?: number | undefined;
+    fileStr?: string | undefined;
+    symbol?: number | undefined;
+    symbolStr?: string | undefined;
+    line: number;
+}
+interface LineNumberSym extends BaseLineNumber {
+    file: number;
+    symbol: number;
+    fileStr?: undefined;
+    symbolStr?: undefined;
+}
+interface LineNumberStr extends BaseLineNumber {
+    file?: undefined;
+    symbol?: undefined;
+    fileStr: string;
+    symbolStr: string;
+    parent?: string | undefined;
+    id: number;
+}
+export declare type LineNumber = LineNumberStr | LineNumberSym;
+export declare function parseLineNum(view: DataView, debugXml: xmlUtil.Document): Map<number, LineNumber>;
+export declare function fixupLineNum(context: Context, updateInfo: UpdateInfo): void;
+export {};

package/build/src/readprg/opcodes.d.ts

@@ -0,0 +1,263 @@
+import { LineNumber } from "./linenum";
+export declare enum Opcodes {
+    nop = 0,
+    incsp = 1,
+    popv = 2,
+    addv = 3,
+    subv = 4,
+    mulv = 5,
+    divv = 6,
+    andv = 7,
+    orv = 8,
+    modv = 9,
+    shlv = 10,
+    shrv = 11,
+    xorv = 12,
+    getv = 13,
+    putv = 14,
+    invokem = 15,
+    agetv = 16,
+    aputv = 17,
+    lgetv = 18,
+    lputv = 19,
+    newa = 20,
+    newc = 21,
+    return = 22,
+    ret = 23,
+    news = 24,
+    goto = 25,
+    eq = 26,
+    lt = 27,
+    lte = 28,
+    gt = 29,
+    gte = 30,
+    ne = 31,
+    isnull = 32,
+    isa = 33,
+    canhazplz = 34,
+    jsr = 35,
+    ts = 36,
+    ipush = 37,
+    fpush = 38,
+    spush = 39,
+    bt = 40,
+    bf = 41,
+    frpush = 42,
+    bpush = 43,
+    npush = 44,
+    invv = 45,
+    dup = 46,
+    newd = 47,
+    getm = 48,
+    lpush = 49,
+    dpush = 50,
+    throw = 51,
+    cpush = 52,
+    argc = 53,
+    newba = 54
+}
+interface BaseOpcode {
+    op: Opcodes;
+    offset: number;
+    size: number;
+    lineNum?: LineNumber;
+    arg?: unknown;
+}
+export interface Incsp extends BaseOpcode {
+    op: Opcodes.incsp;
+    arg: number;
+}
+export interface Argless extends BaseOpcode {
+    arg?: never;
+}
+export interface ByteArg extends BaseOpcode {
+    arg: number;
+}
+export interface ShortArg extends BaseOpcode {
+    arg: number;
+}
+export interface WordArg extends BaseOpcode {
+    arg: number;
+}
+export interface FloatArg extends BaseOpcode {
+    arg: number;
+}
+export interface LongArg extends BaseOpcode {
+    arg: bigint;
+}
+export interface DoubleArg extends BaseOpcode {
+    arg: number;
+}
+export interface Nop extends Argless {
+    op: Opcodes.nop;
+}
+export interface Popv extends Argless {
+    op: Opcodes.popv;
+}
+export interface Addv extends Argless {
+    op: Opcodes.addv;
+}
+export interface Subv extends Argless {
+    op: Opcodes.subv;
+}
+export interface Mulv extends Argless {
+    op: Opcodes.mulv;
+}
+export interface Divv extends Argless {
+    op: Opcodes.divv;
+}
+export interface Andv extends Argless {
+    op: Opcodes.andv;
+}
+export interface Orv extends Argless {
+    op: Opcodes.orv;
+}
+export interface Modv extends Argless {
+    op: Opcodes.modv;
+}
+export interface Shlv extends ByteArg {
+    op: Opcodes.shlv;
+}
+export interface Shrv extends ByteArg {
+    op: Opcodes.shrv;
+}
+export interface Xorv extends Argless {
+    op: Opcodes.xorv;
+}
+export interface Getv extends Argless {
+    op: Opcodes.getv;
+}
+export interface Putv extends Argless {
+    op: Opcodes.putv;
+}
+export interface Invokem extends ByteArg {
+    op: Opcodes.invokem;
+}
+export interface Agetv extends Argless {
+    op: Opcodes.agetv;
+}
+export interface Aputv extends Argless {
+    op: Opcodes.aputv;
+}
+export interface Lgetv extends ByteArg {
+    op: Opcodes.lgetv;
+}
+export interface Lputv extends ByteArg {
+    op: Opcodes.lputv;
+}
+export interface Newa extends Argless {
+    op: Opcodes.newa;
+}
+export interface Newc extends Argless {
+    op: Opcodes.newc;
+}
+export interface Return extends Argless {
+    op: Opcodes.return;
+}
+export interface Ret extends Argless {
+    op: Opcodes.ret;
+}
+export interface News extends WordArg {
+    op: Opcodes.news;
+}
+export interface Goto extends ShortArg {
+    op: Opcodes.goto;
+}
+export interface Bt extends ShortArg {
+    op: Opcodes.bt;
+}
+export interface Bf extends ShortArg {
+    op: Opcodes.bf;
+}
+export interface Jsr extends ShortArg {
+    op: Opcodes.jsr;
+}
+export interface Eq extends Argless {
+    op: Opcodes.eq;
+}
+export interface Lt extends Argless {
+    op: Opcodes.lt;
+}
+export interface Lte extends Argless {
+    op: Opcodes.lte;
+}
+export interface Gt extends Argless {
+    op: Opcodes.gt;
+}
+export interface Gte extends Argless {
+    op: Opcodes.gte;
+}
+export interface Ne extends Argless {
+    op: Opcodes.ne;
+}
+export interface Isnull extends Argless {
+    op: Opcodes.isnull;
+}
+export interface Isa extends Argless {
+    op: Opcodes.isa;
+}
+export interface Canhazplz extends Argless {
+    op: Opcodes.canhazplz;
+}
+export interface Ts extends Argless {
+    op: Opcodes.ts;
+}
+export interface Ipush extends WordArg {
+    op: Opcodes.ipush;
+}
+export interface Fpush extends FloatArg {
+    op: Opcodes.fpush;
+}
+export interface Spush extends WordArg {
+    op: Opcodes.spush;
+}
+export interface Frpush extends Argless {
+    op: Opcodes.frpush;
+}
+export interface Bpush extends ByteArg {
+    op: Opcodes.bpush;
+}
+export interface Npush extends Argless {
+    op: Opcodes.npush;
+}
+export interface Invv extends Argless {
+    op: Opcodes.invv;
+}
+export interface Dup extends ByteArg {
+    op: Opcodes.dup;
+}
+export interface Newd extends Argless {
+    op: Opcodes.newd;
+}
+export interface Getm extends Argless {
+    op: Opcodes.getm;
+}
+export interface Lpush extends LongArg {
+    op: Opcodes.lpush;
+}
+export interface Dpush extends DoubleArg {
+    op: Opcodes.dpush;
+}
+export interface Throw extends Argless {
+    op: Opcodes.throw;
+}
+export interface Cpush extends WordArg {
+    op: Opcodes.cpush;
+}
+export interface Newba extends Argless {
+    op: Opcodes.newba;
+}
+export interface Argc extends ByteArg {
+    op: Opcodes.argc;
+}
+export declare type Bytecode = Nop | Incsp | Popv | Addv | Subv | Mulv | Divv | Andv | Orv | Modv | Shlv | Shrv | Xorv | Getv | Putv | Invokem | Agetv | Aputv | Lgetv | Lputv | Newa | Newc | Return | Ret | News | Goto | Eq | Lt | Lte | Gt | Gte | Ne | Isnull | Isa | Canhazplz | Jsr | Ts | Ipush | Fpush | Spush | Bt | Bf | Frpush | Bpush | Npush | Invv | Dup | Newd | Getm | Lpush | Dpush | Throw | Cpush | Argc | Newba;
+export declare function parseCode(view: DataView, lineTable: Map<number, LineNumber>): Bytecode[];
+export declare function opcodeSize(op: Opcodes): 1 | 2 | 3 | 5 | 9;
+export declare function emitBytecode(bytecode: Bytecode, view: DataView, offset: number, linktable: Map<number, number>): number;
+export declare function getOpInfo(bytecode: Bytecode): {
+    pop: number;
+    push: number;
+};
+export declare function isBoolOp(op: Opcodes): boolean;
+export declare function isCondBranch(op: Opcodes): boolean;
+export {};

package/build/src/readprg/optimize.d.ts

@@ -0,0 +1,3 @@
+import { Context, FuncEntry } from "./bytecode";
+export declare function optimizeFunc(func: FuncEntry, context: Context): void;
+export declare function cleanCfg(func: FuncEntry, context: Context): void;

package/build/src/readprg/sharing.d.ts

@@ -0,0 +1,2 @@
+import { Context, FuncEntry } from "./bytecode";
+export declare function blockSharing(func: FuncEntry, context: Context): boolean;

package/build/src/readprg/signer.d.ts

@@ -0,0 +1,8 @@
+/// <reference types="node" />
+/// <reference types="node" />
+import * as crypto from "node:crypto";
+import { Context } from "./bytecode";
+export declare function getPrgSignature(context: Context): Buffer | undefined;
+export declare function getDevKey(file: string): Promise<crypto.KeyObject>;
+export declare function signatureFromContext(context: Context): Buffer | null;
+export declare function signView(key: crypto.KeyObject, view: DataView): Buffer;

package/build/src/readprg/symbols.d.ts

@@ -0,0 +1,18 @@
+/// <reference types="node" />
+import { xmlUtil } from "../sdk-util";
+export declare class SymbolTable {
+    symbolToLabelMap: Map<number, number>;
+    symbols: Map<number, {
+        str: string;
+        label: string;
+    }>;
+    methods: Map<number, {
+        name: string;
+        id: number | null;
+    }>;
+    decoder: import("util").TextDecoder;
+    parseSymbolTable(view: DataView): number;
+    parse(view: DataView): void;
+    parseXml(debugXml: xmlUtil.Document): void;
+    parseSymbol(view: DataView, offset: number, current: number): number;
+}

package/build/src/readprg.d.ts

@@ -1,5 +1,21 @@
-export declare enum SectionKinds {
-    TEXT = -1059145026,
-    DATA = -629491010
-}
-export declare function readPrg(path: string): Promise<Record<number, number>>;
+/// <reference types="node" />
+/// <reference types="node" />
+import * as crypto from "node:crypto";
+import { SectionInfo } from "./readprg/bytecode";
+import { xmlUtil } from "./sdk-util";
+export declare function readPrg(path: string): Promise<{
+    [k: string]: number;
+}>;
+export declare function readPrgFromFile(prg: string): Promise<{
+    view: DataView;
+    sections: Record<number, SectionInfo>;
+}>;
+export declare function readPrgWithOffsets(view: DataView): {
+    view: DataView;
+    sections: Record<number, SectionInfo>;
+};
+export declare function optimizeProgram(filepath: string, devKey?: string | undefined, output?: string): Promise<unknown>;
+export declare function optimizeProgramBuffer(filepath: string, view: DataView, debugXml: xmlUtil.Document, key: crypto.KeyObject | undefined): {
+    signature: Buffer | undefined;
+    buffer: Buffer;
+};

package/build/src/sdk-util.d.ts

@@ -1,4 +1,5 @@
-export { readPrg, SectionKinds } from "./readprg";
+export { readPrg, optimizeProgram, readPrgWithOffsets } from "./readprg";
+export { SectionKinds } from "./readprg/bytecode";
 export * as xmlUtil from "./xml-util";
 export declare const isWin: boolean;
 export declare const appSupport: string;

package/build/src/util.d.ts

@@ -1,4 +1,5 @@
 import * as glob from "fast-glob";
+export { logger, log, wouldLog } from "./logger";
 export declare function globa(pattern: string, options?: glob.Options & {
     mark?: boolean;
 }): Promise<Array<string>>;

package/build/src/xml-util.d.ts

@@ -124,8 +124,8 @@ export interface Prolog extends BaseNode {
 interface XmlDecl extends BaseNode {
     type: "xmldecl";
     version: "1.0";
-    encoding?: string[];
-    standalone?: string[];
+    encoding?: string;
+    standalone?: string;
 }
 export declare class Document {
     prolog: Prolog | null;

package/build/util.cjs

@@ -1,4 +1,4 @@
-0 && (module.exports = {copyRecursiveAsNeeded,every,first_modified,forEach,globSome,globa,last_modified,map,popcount,promiseAll,pushUnique,readByLine,reduce,sameArrays,some,spawnByLine});
+0 && (module.exports = {copyRecursiveAsNeeded,every,first_modified,forEach,globSome,globa,last_modified,log,logger,map,popcount,promiseAll,pushUnique,readByLine,reduce,sameArrays,some,spawnByLine,wouldLog});
 /******/ (() => { // webpackBootstrap
 /******/ 	var __webpack_modules__ = ({
 
@@ -7719,6 +7719,8 @@ __webpack_require__.d(__webpack_exports__, {
   "globSome": () => (/* binding */ globSome),
   "globa": () => (/* binding */ globa),
   "last_modified": () => (/* binding */ last_modified),
+  "log": () => (/* reexport */ log),
+  "logger": () => (/* reexport */ logger),
   "map": () => (/* binding */ map),
   "popcount": () => (/* binding */ popcount),
   "promiseAll": () => (/* binding */ promiseAll),
@@ -7727,7 +7729,8 @@ __webpack_require__.d(__webpack_exports__, {
   "reduce": () => (/* binding */ reduce),
   "sameArrays": () => (/* binding */ sameArrays),
   "some": () => (/* binding */ some),
-  "spawnByLine": () => (/* binding */ spawnByLine)
+  "spawnByLine": () => (/* binding */ spawnByLine),
+  "wouldLog": () => (/* reexport */ wouldLog)
 });
 
 ;// CONCATENATED MODULE: external "child_process"
@@ -7742,6 +7745,48 @@ var out = __webpack_require__(3294);
 var external_path_ = __webpack_require__(1423);
 ;// CONCATENATED MODULE: external "readline"
 const external_readline_namespaceObject = require("readline");
+;// CONCATENATED MODULE: ./src/logger.ts
+let loggerSettings = null;
+let theLogger = console.log;
+function logger(module, level, message) {
+    if (wouldLog(module, level)) {
+        log(message);
+    }
+}
+function wouldLog(module, level) {
+    if (!loggerSettings) {
+        loggerSettings = getLoggerSettings();
+    }
+    return (loggerSettings.get(module) ?? 0) >= level;
+}
+function log(message) {
+    if (theLogger === console.log) {
+        theLogger(message);
+    }
+    else {
+        theLogger(`${message}`);
+    }
+}
+function setLogger(log) {
+    theLogger = log;
+}
+function getLoggerSettings() {
+    const ls = new Map();
+    const settings = process.env["MC_LOGGER"];
+    if (settings) {
+        settings.split(";").forEach((setting) => {
+            const results = setting.split(/[:=]/, 2);
+            if (results.length === 1) {
+                ls.set(results[0], 1);
+            }
+            else {
+                ls.set(results[0], Number(results[1]));
+            }
+        });
+    }
+    return ls;
+}
+
 ;// CONCATENATED MODULE: ./src/util.ts
 
 
@@ -7753,6 +7798,7 @@ const external_readline_namespaceObject = require("readline");
 // recognize global.lastModifiedSource.
 // @ts-ignore
 __webpack_require__.g["lastModifiedSource" + ""] = 0;
+
 function globa(pattern, options) {
     if (options?.mark) {
         options.markDirectories = true;

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@markw65/monkeyc-optimizer",
   "type": "module",
-  "version": "1.1.13",
+  "version": "1.1.15",
   "description": "Source to source optimizer for Garmin Monkey C code",
   "main": "build/optimizer.cjs",
   "types": "build/src/optimizer.d.ts",
@@ -23,9 +23,9 @@
     "prepack": "webpack --mode production",
     "test": "npm run test-mocha && npm run test-optimized && npm run test-unopt && npm run test-remote && npm run test-remote-tests",
     "test-mocha": "npx mocha --timeout 999999 build/mocha.cjs",
-    "test-remote": "node ./test/test.js --product=pick-one --github",
-    "test-remote-tests": "node ./test/test.js --product=pick-one --run-tests --github",
-    "test-optimized": "node test/test.js --typeCheckLevel Strict --run-tests --product=fenix5 --product=fr235 --jungle ./test/OptimizerTests/monkey.jungle",
+    "test-remote": "node ./test/test.js --showInfo --postOptimize --product=pick-one --github",
+    "test-remote-tests": "node ./test/test.js --showInfo --postOptimize --product=pick-one --run-tests --github",
+    "test-optimized": "node test/test.js --showInfo --postOptimize --typeCheckLevel Strict --run-tests --product=fenix5 --product=fr235 --jungle ./test/OptimizerTests/monkey.jungle",
     "test-unopt": "node test/test.js --typeCheckLevel Strict --skipOptimization --run-tests --product=fenix5 --product=fr235 --jungle ./test/OptimizerTests/monkey.jungle",
     "test-garmin-opt": "node test/test.js --typeCheckLevel Strict --skipOptimization --garminOptLevel=2 --run-tests --product=fenix5 --product=fr235 --jungle ./test/OptimizerTests/monkey.jungle",
     "eslint": "npx eslint ."
@@ -48,6 +48,8 @@
     "@types/mocha": "^10.0.1",
     "@types/prettier": "^2.6.1",
     "@types/priorityqueuejs": "^1.0.1",
+    "@types/yauzl": "^2.10.0",
+    "@types/yazl": "^2.4.2",
     "@typescript-eslint/eslint-plugin": "^5.28.0",
     "@typescript-eslint/parser": "^5.28.0",
     "chai": "^4.3.7",
@@ -62,7 +64,9 @@
     "ts-loader": "^9.3.0",
     "typescript": "^4.6.4",
     "webpack": "^5.72.0",
-    "webpack-cli": "^4.9.2"
+    "webpack-cli": "^4.9.2",
+    "yauzl": "^2.10.0",
+    "yazl": "^2.5.1"
   },
   "repository": {
     "type": "git",

package/build/src/type-flow/mimimize-modules.d.ts

@@ -1,3 +0,0 @@
-import { mctree } from "@markw65/prettier-plugin-monkeyc";
-import { ProgramStateAnalysis } from "../optimizer-types";
-export declare function minimizeModules(ast: mctree.Program, state: ProgramStateAnalysis): void;