Enhance traceserver argument parsing scheme

Author: GregSavin

src/argparse.ts

@@ -0,0 +1,97 @@
+class ArgExtractor {
+    argsStr: string;
+    index: number;
+
+    constructor(argsStr: string) {
+        this.argsStr = argsStr;
+        this.index = 0;
+        this.skipWhitespace();
+    }
+
+    isEos(): boolean {
+        const result = this.index >= this.argsStr.length;
+        return result;
+    }
+
+    private isWhitespace(ch: string) {
+        const result = /\s/g.test(ch);
+        return result;
+    }
+
+    private consumeChar(): void {
+        this.index++;
+    }
+
+    private peekChar(): string {
+        return this.argsStr[this.index];
+    }
+
+    private nextChar(): string {
+        return this.argsStr[this.index++];
+    }
+
+    private skipWhitespace(): void {
+        let char = this.peekChar();
+        while (this.index < this.argsStr.length && this.isWhitespace(char)) {
+            this.consumeChar();
+            char = this.peekChar();
+        }
+    }
+
+    next(): string {
+        let arg = '';
+        let inQuotedString = false;
+
+        const handleWhitespace = (char: string): boolean => {
+            if (inQuotedString) {
+                arg = arg.concat(char);
+                return false;
+            } else {
+                this.skipWhitespace();
+                return true;
+            }
+        };
+
+        const handleDoubleQuote = () => {
+            if (inQuotedString) {
+                const peek = this.peekChar();
+                if (peek == '"') {
+                    // literal quote
+                    this.consumeChar();
+                    arg = arg.concat(peek);
+                } else {
+                    // end of quotation; just consume character without adding literally to arg
+                    inQuotedString = false;                    
+                }
+            } else {
+                // open double quotation
+                inQuotedString = true;
+            }
+        };
+
+        while (!this.isEos()) {
+            const char = this.nextChar();
+            if (this.isWhitespace(char)) {
+                if (handleWhitespace(char)) {
+                    break;
+                }
+            } else if (char == '"') {
+                handleDoubleQuote();
+            } else {
+                // some other character other than whitespace or quotes or escape character; include in arg and continue
+                arg = arg.concat(char);
+            }
+        }
+        return arg;
+    }
+}
+
+export function parseArgs(argsStr: string): string[] {
+    const extractor = new ArgExtractor(argsStr);
+    const result = [];
+    while (!extractor.isEos()) {
+        const arg = extractor.next();
+        result.push(arg);
+    }
+    return result;
+}

src/test/suite/argparse.test.ts

@@ -0,0 +1,34 @@
+import * as assert from 'assert';
+import * as vscode from 'vscode';
+import * as argparse from '../../argparse';
+
+suite('Argument Parser Test Suite', () => {
+    vscode.window.showInformationMessage('Start argument parser tests.');
+
+    const prefix = 'Argument parser should be able to handle argument strings ';
+
+    test(prefix + 'that do not use quoting', () => {
+        const args = argparse.parseArgs('-vmargs -Dsome.property=value_without_spaces');
+        assert.deepEqual(args, ['-vmargs', '-Dsome.property=value_without_spaces']);
+    });
+
+    test(prefix + 'that have extra whitespace between arguments', () => {
+        const args = argparse.parseArgs('   -vmargs    -Dsome.property=value_without_spaces \t  ');
+        assert.deepEqual(args, ['-vmargs', '-Dsome.property=value_without_spaces']);
+    });
+
+    test(prefix + 'that use quoting', () => {
+        const args = argparse.parseArgs('   -vmargs    -Dsome.property="value with spaces" \t  ');
+        assert.deepEqual(args, ['-vmargs', '-Dsome.property=value with spaces']);
+    });
+
+    test(prefix + 'that use quotes with embedded literal quotes (using a sequence of 2 consecutive quotes)', () => {
+        const args = argparse.parseArgs('   -vmargs    -Dsome.property="""in literal quotes""" \t  ');
+        assert.deepEqual(args, ['-vmargs', '-Dsome.property="in literal quotes"']);
+    });
+
+    test(prefix + 'recognize non-nested consecutive quotes as an empty string', () => {
+        const parsed = argparse.parseArgs('empty_value=""');
+        assert.deepEqual(parsed, ['empty_value=']);
+    });
+});

src/test/suite/trace-server.test.ts

@@ -16,7 +16,7 @@ suite('TraceServer Test Suite', () => {
 
     test(prefix + 'arguments', () => {
         const args = server.getArgs_test(from);
-        assert.deepEqual(args, ['']);
+        assert.deepEqual(args, []);
     });
 
     test(prefix + 'url', () => {

src/trace-server.ts

@@ -2,6 +2,7 @@ import { ChildProcess, spawn } from 'child_process';
 import { TspClient } from 'tsp-typescript-client/lib/protocol/tsp-client';
 import treeKill from 'tree-kill';
 import * as vscode from 'vscode';
+import { parseArgs } from './argparse';
 
 // Based on github.com/eclipse-cdt-cloud/vscode-trace-extension/blob/master/vscode-trace-extension/package.json
 // -for naming consistency purposes across sibling extensions/settings:
@@ -122,7 +123,7 @@ export class TraceServer {
         if (!args) {
             args = '';
         }
-        return args.split(' ');
+        return parseArgs(args);
     }
     getArgs_test = this.getArgs;