🍻 impl msdos player

xsro · xsro · commit c8b4b889b262 · 2021-10-29T10:31:13.000+08:00
diff --git a/package.json b/package.json
@@ -144,7 +144,7 @@
                 "TD ${filename}.exe"
               ]
             },
-            "MASM": {
+            "MASM-v6.11": {
               "baseBundle": "<built-in>/MASM-v6.11.jsdos",
               "before": [
                 "set PATH=C:\\MASM"
@@ -159,6 +159,22 @@
                 "link ${filename}.OBJ;",
                 ">debug ${filename}.exe"
               ]
+            },
+            "MASM-v5.00": {
+              "baseBundle": "<built-in>/MASM-v5.00.jsdos",
+              "before": [
+                "set PATH=C:\\MASM"
+              ],
+              "run": [
+                "masm ${file};",
+                "link ${filename};",
+                ">${filename}"
+              ],
+              "debug": [
+                "masm ${file};",
+                "link ${filename}.OBJ;",
+                ">debug ${filename}.exe"
+              ]
             }
           }
         },
diff --git a/src/ASM/main.ts b/src/ASM/main.ts
@@ -66,6 +66,9 @@ export async function activate(context: vscode.ExtensionContext) {
         );
         const bundle = await fs.readFile(bundlePath);
 
+        const timeStamp = new Date().getTime().toString();
+        const logFilename = timeStamp.substr(timeStamp.length - 5, 8) + '.log'.toUpperCase();
+
         let result = "<should-not-return>";
         const uri = vscode.Uri.joinPath(seperateSpaceFolder, ("test" + path.extname(_uri.fsPath)).toUpperCase());
         await fs.copy(_uri, uri);
@@ -79,8 +82,6 @@ export async function activate(context: vscode.ExtensionContext) {
                 'd:',
                 ...action.before
             ];
-            const timeStamp = new Date().getTime().toString();
-            const logFilename = timeStamp.substr(timeStamp.length - 5, 8) + '.log'.toUpperCase();
             const logUri = vscode.Uri.joinPath(assemblyToolsFolder, logFilename);
             if (nodefs.existsSync(logUri.fsPath)) {
                 await fs.delete(logUri);
@@ -174,8 +175,53 @@ export async function activate(context: vscode.ExtensionContext) {
         }
 
         if (conf.extConf.emulator === conf.DosEmulatorType.msdos) {
-            const t = api.msdosPlayer();
-            t.show();
+            const terminal = api.msdosPlayer();
+
+            terminal.show();
+            api.dosbox.fromBundle(bundle, assemblyToolsFolder);
+            action.before.forEach(
+                val => {
+                    (terminal as vscode.Terminal).sendText(val.replace('C:', assemblyToolsFolder.fsPath));
+                }
+            );
+            if (type === actionType.open) {
+                terminal.sendText(`cd "${vscode.Uri.joinPath(_uri, '..').fsPath}"`);
+            }
+            else {
+                terminal.sendText(`cd "${folder.fsPath}"`);
+                function cb(val: string) {
+                    const r = val
+                        .replace("${file}", fileInfo.base)
+                        .replace("${filename}", fileInfo.name);
+                    if (val.startsWith('>')) {
+                        return r.replace(">", "");
+                    } else {
+                        return r + `>> ${logFilename} \n type ${logFilename}`;
+                    }
+                }
+                if (type === actionType.run) {
+                    action.run.map(cb).forEach(val => (terminal as vscode.Terminal).sendText(val));
+                }
+                if (type === actionType.debug) {
+                    action.debug.map(cb).forEach(val => (terminal as vscode.Terminal).sendText(val));
+                }
+                const logUri = vscode.Uri.joinPath(folder, logFilename);
+                const [hook, promise] = messageCollector();
+                nodefs.watchFile(logUri.fsPath, () => {
+                    try {
+                        if (nodefs.existsSync(logUri.fsPath)) {
+                            const text = nodefs.readFileSync(logUri.fsPath, { encoding: 'utf-8' });
+                            hook(text);
+                        }
+                    }
+                    catch (e) {
+                        console.error(e);
+                    }
+                });
+                //terminal.sendText('exit', true);
+                result = await promise;
+            }
+
         }
 
         const diagnose = diag.process(result, doc, conf.extConf.asmType);
diff --git a/src/ASM/statusBar.ts b/src/ASM/statusBar.ts
@@ -11,15 +11,17 @@ const emu = [
 ];
 
 const asm = [
-    conf.Assembler.MASM,
+    conf.Assembler['MASM-v5.00'],
+    conf.Assembler['MASM-v6.11'],
     conf.Assembler.TASM
 ];
 
 const iterms: string[] = [];
 for (const e of emu) {
     for (const a of asm) {
-        if (a === conf.Assembler.TASM && e === conf.DosEmulatorType.msdos) {
-            continue;
+        if (e === conf.DosEmulatorType.msdos) {
+            if (a === conf.Assembler.TASM || a === conf.Assembler['MASM-v6.11'])
+                continue;
         }
         iterms.push(e + '\t' + a);
     }
diff --git a/src/ASM/vscode-dosbox.ts b/src/ASM/vscode-dosbox.ts
@@ -38,13 +38,21 @@ export interface Dosbox {
 }
 
 export interface Jsdos {
-    jszip: Jszip,
     /**
      * set the jsdos bundle to use
+     * 
+     * @deprecated use jszip
      * @param bundle the Uint8Array data of the jsdos bundle or its Uri
      * @param updateConf use the conf file in the bundle
      */
     setBundle(bundle: vscode.Uri | Uint8Array, updateConf?: boolean): void,
+    /**
+     * the [jszip object](https://stuk.github.io/jszip/)
+     * 
+     * change this to change the bundle's data, 
+     * the extension call it to generate bundle data
+     */
+    jszip: Jszip;
     updateConf(section: string, key: string, value: string | number | boolean): boolean,
     updateAutoexec(context: string[]): void,
     /**
@@ -71,7 +79,6 @@ export interface API {
      * @see https://github.com/js-dos/emulators
      */
     emulators: Emulators;
-
     /**
      * run Jsdos in ExtensionHost or Webview
      */
@@ -80,17 +87,21 @@ export interface API {
     /**
      * run DOSBox via child_process
      */
-    dosbox: Dosbox
-    ;
+    dosbox: Dosbox;
     /**
      * run DOSBox-x via child_process
      */
     dosboxX: Dosbox;
+
     /**
      * run msdos player via cmd.exe
      * 
      * @returns a terminal to control
      */
-    msdosPlayer: () => vscode.Terminal;
+    msdosPlayer(msdosArgs?: string[], command?: string): vscode.Terminal;
+    /**path of the packed msdos player */
+    msdosPath: string,
+    /**path of the packed command.com file */
+    commandPath: string
 
 }
diff --git a/src/diagnose/main.ts b/src/diagnose/main.ts
@@ -68,7 +68,8 @@ export class AssemblerMessageDiagnose {
             case Assembler.TASM:
                 diag = tasmDiagnose(AsmMsg, doc, this._tasmCollection);
                 break;
-            case Assembler.MASM:
+            case Assembler['MASM-v5.00']:
+            case Assembler['MASM-v6.11']:
                 diag = masmDiagnose(AsmMsg, doc, this._masmCollection);
                 break;
             default:
diff --git a/src/diagnose/messageCollector.ts b/src/diagnose/messageCollector.ts
@@ -16,6 +16,11 @@ export function messageCollector(): [(msg: string) => void, Promise<string>] {
                 resolve(re[1]);
                 resolve = undefined;
             }
+            re = allmsg.match(/Microsoft \(R\) Macro Assembler Version 5.00([\s\S]*)Microsoft \(R\) Overlay Linker  Version 3.60/);
+            if (re && re[1] && resolve) {
+                resolve(re[1]);
+                resolve = undefined;
+            }
         }
         ,
         new Promise<string>(
diff --git a/src/test/suite/ASM.test.ts b/src/test/suite/ASM.test.ts
@@ -15,7 +15,8 @@ const samplesUri = vscode.Uri.joinPath(vscode.Uri.file(__dirname), '../../../sam
 suite('Extension Test Suite', function () {
 	vscode.window.showInformationMessage('Start all tests.');
 	const MASMorTASM = [
-		Assembler.MASM,
+		Assembler['MASM-v5.00'],
+		Assembler['MASM-v6.11'],
 		Assembler.TASM,
 	];
 	const emulator: DosEmulatorType[] = [
diff --git a/src/test/suite/msdos.test.ts b/src/test/suite/msdos.test.ts
@@ -0,0 +1,48 @@
+import * as assert from 'assert';
+
+// You can import and use all API from the 'vscode' module
+// as well as import your extension to test it
+import * as vscode from 'vscode';
+import { AsmResult } from '../../ASM/main';
+import { DosEmulatorType, Assembler } from '../../utils/configuration';
+// import * as myExtension from '../../extension';
+
+const samplesUri = vscode.Uri.joinPath(vscode.Uri.file(__dirname), '../../../samples/');
+
+suite('Extension Test Suite', () => {
+    const file = '3中文路径hasError.asm';
+    const emu = DosEmulatorType.msdos;
+    const asm = Assembler['MASM-v5.00'];
+    const shouldErr = 1;
+
+    test(`test file ${file} in ${emu} use ${asm} want should ${shouldErr} error`,
+        async function () {
+            if (process.platform !== 'win32') {
+                this.skip();
+            }
+            this.timeout('60s');
+            this.slow('20s');
+
+            //open test file. NOTE: the extension will be activated when open .asm file
+            const samplefile = vscode.Uri.joinPath(samplesUri, file);
+
+            //update settings
+            await vscode.workspace.getConfiguration('masmtasm').update("dosbox.run", "exit");
+            await vscode.workspace.getConfiguration('masmtasm').update("ASM.emulator", emu);
+            await vscode.workspace.getConfiguration('masmtasm').update("ASM.assembler", asm);
+
+            //assert the extension activated and command contributed
+            const vscodecmds = await vscode.commands.getCommands(true);
+            const cmd = 'masm-tasm.runASM';
+            if (!vscodecmds.includes(cmd)) {
+                await vscode.extensions.getExtension('xsro.masm-tasm')?.activate();
+            }
+            const vscodecmds2 = await vscode.commands.getCommands(true);
+            assert.ok(vscodecmds2.includes(cmd));
+
+            //assert message processed
+            const _result = await vscode.commands.executeCommand(cmd, samplefile);
+            const { message, error } = _result as AsmResult;
+            assert.strictEqual(error, shouldErr, message);
+        });
+});
diff --git a/src/utils/configuration.ts b/src/utils/configuration.ts
@@ -3,6 +3,8 @@
  * - TASM: including tasm.exe,tlink.exe,TD.exe
  */
 export enum Assembler {
+    'MASM-v6.11' = 'MASM-v6.11',
+    'MASM-v5.00' = 'MASM-v5.00',
     MASM = 'MASM',
     TASM = 'TASM'
 }
@@ -25,6 +27,9 @@ import * as vscode from 'vscode';
 class ExtensionConfiguration {
     public get asmType(): Assembler {
         const asmType: Assembler | undefined = vscode.workspace.getConfiguration('masmtasm').get('ASM.assembler');
+        if (asmType === 'MASM') {
+            return Assembler['MASM-v6.11'];
+        }
         return asmType ? asmType : Assembler.TASM;
     }
     public get emulator(): DosEmulatorType {

Original file line number	Diff line number	Diff line change
`@@ -16,6 +16,11 @@ export function messageCollector(): [(msg: string) => void, Promise<string>] {`
`16`	`16`	`resolve(re[1]);`
`17`	`17`	`resolve = undefined;`
`18`	`18`	`}`
	`19`	`+ re = allmsg.match(/Microsoft \(R\) Macro Assembler Version 5.00([\s\S]*)Microsoft \(R\) Overlay Linker Version 3.60/);`
	`20`	`+ if (re && re[1] && resolve) {`
	`21`	`+ resolve(re[1]);`
	`22`	`+ resolve = undefined;`
	`23`	`+ }`
`19`	`24`	`}`
`20`	`25`	`,`
`21`	`26`	`new Promise<string>(`