@microtronics/studio-cli 0.6.1 → 0.8.0

package/out/dlo/compiler.js

@@ -0,0 +1,312 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DloCompiler = void 0;
+exports.uriToMemFsPath = uriToMemFsPath;
+exports.generateConfigFile = generateConfigFile;
+const preCompiler_1 = require("./preCompiler");
+const vscode_uri_1 = require("vscode-uri");
+const manifest_1 = require("../manifest");
+const defaultFiles_1 = require("../defaultFiles");
+const dependencies_1 = require("../dependencies");
+const iconv = __importStar(require("iconv-lite"));
+const helper_1 = require("../helper");
+var convertBlobToStringArray = helper_1.Helper.convertBlobToStringArray;
+const DLO_MODULE = require('./dlocc.js');
+class DloCompiler {
+    preCompiler = new preCompiler_1.DloPreCompiler();
+    dloCC;
+    stdout = [];
+    stderr = [];
+    constructor() {
+        this.dloCC = null;
+    }
+    async initDloCC(noExit = false) {
+        this.stdout.length = 0;
+        this.stderr.length = 0;
+        this.dloCC = await DLO_MODULE({
+            noExitRuntime: noExit,
+            print: (data) => {
+                console.log(data);
+                this.stdout.push(data);
+            },
+            printErr: (err) => {
+                console.error(err);
+                this.stderr.push(err);
+                this.stdout.push(err);
+            }
+        });
+    }
+    get MEMFS() {
+        return this.dloCC.FS;
+    }
+    async compile(cwd, fs) {
+        const manifest = await manifest_1.Manifest.read(cwd, fs);
+        await this.initDloCC();
+        const precompilerDiagnostics = await this.persistDloFiles(cwd, fs, manifest);
+        const mainFile = vscode_uri_1.Utils.joinPath(cwd, manifest.dlo?.mainFile || defaultFiles_1.DefaultFiles.filePaths.dlo.mainDLO);
+        const options = [];
+        // todo only add cfg file to options if not already set!
+        const configFilePath = vscode_uri_1.Utils.joinPath(cwd, defaultFiles_1.DefaultFiles.filePaths.studio.auto.dlo.cfg);
+        options.push(...(await this.readConfigFile(fs, configFilePath)));
+        if (this.preCompiler.pragmaDynamicFlag) {
+            options.push(this.preCompiler.pragmaDynamicFlag);
+        }
+        let exitCode = 0;
+        try {
+            exitCode = await this.dloCC.callMain([uriToMemFsPath(mainFile), ...options]);
+            // compiler doesn't have any errors
+            if (exitCode === 0) {
+                await this.persistGeneratedFiles(cwd, fs, mainFile);
+            }
+        }
+        catch (e) {
+            console.error(e);
+        }
+        return {
+            code: exitCode,
+            stdout: this.stdout,
+            stderr: this.stderr,
+            diagnostics: [...precompilerDiagnostics, ...this.parseWarningsAndErrors(this.stderr, mainFile)]
+        };
+    }
+    async persistGeneratedFiles(cwd, fs, mainFile) {
+        const baseName = vscode_uri_1.Utils.basename(mainFile).split('.')[0];
+        const possibleFiles = this.MEMFS.readdir('/');
+        for (const fileName of possibleFiles) {
+            if (fileName.startsWith(baseName)) {
+                const blob = this.MEMFS.readFile(fileName);
+                const distPath = vscode_uri_1.Utils.joinPath(cwd, defaultFiles_1.DefaultFiles.filePaths.dist.dloPath, fileName);
+                await fs.writeFile(distPath, blob);
+            }
+        }
+    }
+    async readConfigFile(fs, configPath) {
+        if (await fs.stat(configPath)) {
+            const content = await fs.readFile(configPath);
+            return convertBlobToStringArray(content);
+        }
+        else {
+            return [];
+        }
+    }
+    /**
+     * Search for all dlo files and persist it to the MEMFS
+     * @param cwd
+     * @param fs
+     * @param manifest
+     * @private
+     */
+    async persistDloFiles(cwd, fs, manifest) {
+        const files = await fs.findFiles(cwd, '**/*.{dlo,inc}');
+        const precompilerDiagnostics = [];
+        // add dlo.cfg file to the file list
+        for (const file of files) {
+            if (await fs.stat(file)) {
+                const content = await fs.readFile(file);
+                const stringBlob = convertBlobToStringArray(content);
+                const diagnostics = await this.memFSwriteFile(cwd, manifest, file, stringBlob);
+                precompilerDiagnostics.push(...diagnostics);
+            }
+        }
+        return precompilerDiagnostics;
+    }
+    /**
+     * Precompile the given file and pass it to the MEMFS
+     * @param cwd
+     * @param manifest
+     * @param file
+     * @param stringBlob
+     */
+    async memFSwriteFile(cwd, manifest, file, stringBlob) {
+        const precompilerDiagnostics = [];
+        const preCompiled = await this.preCompiler.preCompileDloFile(cwd, manifest, file, stringBlob);
+        precompilerDiagnostics.push(...preCompiled.diagnostics);
+        this.memFSmkdir(file);
+        this.MEMFS.writeFile(uriToMemFsPath(file), iconv.encode(preCompiled.data, 'cp1252'));
+        return precompilerDiagnostics;
+    }
+    /**
+     * Move a file within the MEMFS
+     * @param oldUri
+     * @param newUri
+     */
+    async memFSmove(oldUri, newUri) {
+        try {
+            this.memFSmkdir(newUri);
+            this.MEMFS.rename(uriToMemFsPath(oldUri), uriToMemFsPath(newUri));
+        }
+        catch (e) {
+            console.error('memFSmove', e);
+        }
+    }
+    /**
+     * Remove a file from the MEMFS
+     * @param uri
+     */
+    async memFSunlink(uri) {
+        try {
+            this.MEMFS.unlink(uriToMemFsPath(uri));
+        }
+        catch (e) {
+            console.error('memFSunlink', e);
+        }
+    }
+    memFSmkdir(uri) {
+        const split = uriToMemFsPath(vscode_uri_1.Utils.dirname(uri)).split('/');
+        let dirname = '';
+        split.forEach(folder => {
+            if (!folder) {
+                return;
+            }
+            try {
+                dirname += `${folder}/`;
+                if (!this.memFSstat(dirname)) {
+                    this.MEMFS.mkdir(dirname);
+                }
+            }
+            catch (e) {
+                console.error('memFSmkdir', e);
+            }
+        });
+    }
+    memFSstat(dirname) {
+        try {
+            this.MEMFS.stat(dirname);
+            return true;
+        }
+        catch (e) {
+            return false;
+        }
+    }
+    parseWarningsAndErrors(stderr, relatedFile) {
+        const compilerDiagnostics = [];
+        const messages = stderr.filter(line => !!line.trim());
+        for (const message of messages) {
+            if ((message.includes('Assertion failed:') || message.includes('Compilation aborted.')) && relatedFile) {
+                compilerDiagnostics.push({
+                    file: relatedFile,
+                    level: 'error',
+                    line: 0,
+                    message: message
+                });
+                continue;
+            }
+            // regular error/warning - such as:
+            // 		C:\Users\aai\rmstudio\apmparts\dlo-pawn\stdlib\rm-dde.inc(392) : error 036: empty statement
+            // 		main.p(138) : warning 203: symbol is never used: "log_str"
+            //		main.p(6) : fatal error 100: cannot read from file: "oTests/module_t"
+            const i0 = message.indexOf(' : ');
+            const i1 = message.indexOf(': ', i0 + 3);
+            const fileNameAndLineNumber = message.substring(0, i0).trim();
+            const levelAndCode = message.substring(i0 + 3, i1).trim();
+            const msg = message.substring(i1 + 2).trim();
+            // ignore lines which do not contain err/warn msg (or are empty)
+            if (!fileNameAndLineNumber || !levelAndCode || !msg) {
+                continue;
+            }
+            const [fileName, lineNumber] = fileNameAndLineNumber.split(/[()(-)]/);
+            const decodeLevelAndCode = levelAndCode.split(' ');
+            const level = decodeLevelAndCode[decodeLevelAndCode.length - 2]; //lvl is always the second last
+            let posix = fileName.replace(/\\/g, '/');
+            if (posix.startsWith('/')) {
+                posix = posix.substring(1);
+            }
+            compilerDiagnostics.push({
+                file: vscode_uri_1.URI.parse(`file:///${posix}`),
+                level,
+                line: Number(lineNumber) - 1,
+                message: msg
+            });
+        }
+        return compilerDiagnostics;
+    }
+    //Symbol Compiler handling
+    /**
+     * Get a symbol compiler instance
+     */
+    async getSymbolCompiler() {
+        // generate a none exiting wasm compiler runtime as main filesystem
+        if (!this.dloCC) {
+            await this.initDloCC(true);
+        }
+        const compilerLog = {
+            stdout: [],
+            stderr: []
+        };
+        const dloSymbol = await DLO_MODULE({
+            noExitRuntime: false,
+            print: (data) => {
+                compilerLog.stdout.push(data);
+            },
+            printErr: (err) => {
+                compilerLog.stderr.push(err);
+            }
+        });
+        // mount the main filesystem
+        dloSymbol.FS.mkdir('/baseDir');
+        dloSymbol.FS.mount(dloSymbol.PROXYFS, {
+            root: '/',
+            fs: this.dloCC.FS
+        }, '/baseDir');
+        dloSymbol.FS.chdir('baseDir');
+        return {
+            compiler: dloSymbol,
+            print: compilerLog
+        };
+    }
+}
+exports.DloCompiler = DloCompiler;
+function uriToMemFsPath(path) {
+    return path.fsPath.replace(/\\/g, '/');
+}
+/**
+ * Generates the DLO .cfg file for the dlo compiler
+ * @param cwd
+ * @param fs
+ * @param manifest
+ */
+async function generateConfigFile(cwd, fs, manifest) {
+    const compileOptions = [
+        '-M', //map output for pawndbg to generate link map
+        '-v2' // verbosity of stdout -> 0=quiet, 1=normal, 2=code/data/stack usage report
+    ];
+    const defaultIncPath = vscode_uri_1.Utils.joinPath(cwd, defaultFiles_1.DefaultFiles.filePaths.studio.auto.dlo.defaultInc);
+    compileOptions.push(`-p${uriToMemFsPath(defaultIncPath)}`);
+    const dloLibs = await dependencies_1.Dependencies.getDloDependencies(cwd, fs);
+    for (const dloLib of dloLibs) {
+        const dirName = vscode_uri_1.Utils.dirname(dloLib.path);
+        compileOptions.push(`-i${uriToMemFsPath(dirName)}`);
+    }
+    const dloConfiguration = manifest.dlo;
+    if (dloConfiguration) {
+        compileOptions.push(...dloConfiguration.compileOptions);
+    }
+    return {
+        path: vscode_uri_1.Utils.joinPath(cwd, defaultFiles_1.DefaultFiles.filePaths.studio.auto.dlo.cfg),
+        data: compileOptions.join('\n')
+    };
+}
+//# sourceMappingURL=compiler.js.map

package/out/dlo/dlo.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"dlo.d.ts","sourceRoot":"","sources":["../../src/dlo/dlo.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,gBAAgB,EAAE,MAAM,iBAAiB,CAAC;AACnD,OAAO,EAAE,cAAc,EAAE,MAAM,eAAe,CAAC;AAC/C,OAAO,EAAE,OAAO,EAAE,MAAM,OAAO,CAAC;AAEhC,OAAO,EAAE,WAAW,EAAsB,cAAc,EAAE,MAAM,YAAY,CAAC;AAC7E,OAAO,EAAE,GAAG,EAAE,MAAM,YAAY,CAAC;AAGjC,yBAAiB,GAAG,CAAC;IACb,MAAM,aAAa,yBAAmB,CAAC;IAC9C,KAAY,aAAa,GAAG,gBAAgB,CAAC;IAEtC,MAAM,WAAW,uBAAiB,CAAC;IAC1C,KAAY,WAAW,GAAG,cAAc,CAAC;IAEzC;;OAEG;IACI,MAAM,QAAQ,oBAAc,CAAC;IACpC,KAAY,QAAQ,GAAG,WAAW,CAAC;IAE5B,MAAM,UAAU,uBAAiB,CAAC;IAEzC;;;;OAIG;IACH,SAAsB,eAAe,CAAC,GAAG,EAAE,GAAG,EAAE,EAAE,EAAE,OAAO,iBAK1D;CACD"}

package/out/dlo/dlo.js

@@ -0,0 +1,31 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DLO = void 0;
+const fileSequencer_1 = require("./fileSequencer");
+const preCompiler_1 = require("./preCompiler");
+const manifest_1 = require("../manifest");
+const compiler_1 = require("./compiler");
+const defaultFiles_1 = require("../defaultFiles");
+var DLO;
+(function (DLO) {
+    DLO.FileSequencer = fileSequencer_1.DloFileSequencer;
+    DLO.PreCompiler = preCompiler_1.DloPreCompiler;
+    /**
+     * The DLO Compiler
+     */
+    DLO.Compiler = compiler_1.DloCompiler;
+    DLO.uriToMemFs = compiler_1.uriToMemFsPath;
+    /**
+     * Generate the dlo.cfg file and write it to the .studio/auto/dlo directory
+     * @param cwd
+     * @param fs
+     */
+    async function exportDloConfig(cwd, fs) {
+        const manifest = await manifest_1.Manifest.read(cwd, fs);
+        const cfgData = await (0, compiler_1.generateConfigFile)(cwd, fs, manifest);
+        await fs.writeFile(cfgData.path, cfgData.data);
+        console.log('Generated', defaultFiles_1.DefaultFiles.filePaths.studio.auto.dlo.cfg);
+    }
+    DLO.exportDloConfig = exportDloConfig;
+})(DLO || (exports.DLO = DLO = {}));
+//# sourceMappingURL=dlo.js.map

package/out/dlo/dlocc.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"dlocc.d.ts","sourceRoot":"","sources":["../../src/dlo/dlocc.js"],"names":[],"mappings":";AAGQ,sDAgiHN"}