Method parseAsmForClass

lib/compilers/java.ts:340–457

(javapOut: string)

    }

    parseAsmForClass(javapOut: string) {
        const textsBeforeMethod: string[] = [];
        const methods: {instructions: any[]; startLine?: number}[] = [];
        // javap output puts `    Code:` after every signature. (Line will not be shown to user)
        // We use this to find the individual methods.
        // Before the first `Code:` occurrence, there is the method signature as well as the name of the class.
        // Subsequent matches are always followed by lists of assembly instructions as well as line info mappings

        // Regex idea: make sure `Code:` is the only thing on the line. Also consume trailing line ending!
        const [classNameAndFirstMethodSignature, ...codeAndLineNumberTables] = javapOut.split(/^\s+Code:\s*$\r?\n/m);
        textsBeforeMethod.push(classNameAndFirstMethodSignature.trimEnd()); // possible trailing \r on windows

        for (const codeAndLineNumberTable of codeAndLineNumberTables) {
            const method = {
                instructions: [],
            } as (typeof methods)[0];
            methods.push(method);

            for (const codeLineCandidate of utils.splitLines(codeAndLineNumberTable)) {
                // Match
                //       1: invokespecial #1                  // Method java/lang/Object."<init>":()V
                // Or match lines inside inside a lookupswitch instruction like:
                //         8: <code>
                //        -1: <code>
                //   default: <code>
                const match = codeLineCandidate.match(/\s+([\d-]+|default): (.*)/);
                if (match) {
                    const instrOffset = Number.parseInt(match[1], 10);
                    method.instructions.push({
                        instrOffset: instrOffset,
                        // Should an instruction ever not be followed by a line number table,
                        // it might contain a trailing \r on Windows -> trim it, otherwise this would not be necessary
                        text: codeLineCandidate.trimEnd(),
                    });
                } else {
                    // Attempt to match the closing } of a lookupswitch. If we don't include the closing bracket, then
                    // the brackets will be misaligned, and it may be confusing to read.
                    const isClosingCurlyBrace = codeLineCandidate.match(/\s+}/);
                    if (isClosingCurlyBrace) {
                        // Put closing curly brace in asm output
                        method.instructions.push({
                            text: codeLineCandidate.trimEnd(),
                        });
                        continue;
                    }
                    break;
                }
            }

            const lineRegex = /line\s*(\d+):\s*(\d+)/g;
            let m;
            let currentInstr = 0;
            let currentSourceLine = -1;
            let lastIndex = -1;
            do {
                m = lineRegex.exec(codeAndLineNumberTable);
                if (m) {
                    // If exec doesn't find a match anymore, lineRegex.lastIndex will be reset to 0