Method setBreakPointsRequest

src/gdb.ts:2013–2130

(
        r: DebugProtocol.SetBreakpointsResponse,
        a: DebugProtocol.SetBreakpointsArguments)

    }

    protected setBreakPointsRequest(
        r: DebugProtocol.SetBreakpointsResponse,
        a: DebugProtocol.SetBreakpointsArguments): Promise<void> {
        const doit = (
            response: DebugProtocol.SetBreakpointsResponse,
            args: DebugProtocol.SetBreakpointsArguments,
            pendContinue: PendingContinue): Promise<void> => {
            return new Promise(async (resolve) => {
                const createBreakpoints = async () => {
                    const currentBreakpoints = (this.breakpointMap.get(args.source.path) || []).map((bp) => bp.number);

                    try {
                        await this.miDebugger.removeBreakpoints(currentBreakpoints);
                        for (const old of currentBreakpoints) {
                            this.breakpointById.delete(old);
                        }
                        this.breakpointMap.set(args.source.path, []);

                        const all: Array<Promise<OurSourceBreakpoint | MIError>> = [];
                        const sourcepath = decodeURIComponent(args.source.path);

                        if (sourcepath.startsWith('disassembly:/')) {
                            let sidx = 13;
                            if (sourcepath.startsWith('disassembly:///')) { sidx = 15; }
                            const path = sourcepath.substring(sidx, sourcepath.length - 6); // Account for protocol and extension
                            const parts = path.split(':::');
                            let func: string;
                            let file: string;

                            if (parts.length === 2) {
                                func = parts[1];
                                file = parts[0];
                            }
                            else {
                                func = parts[0];
                            }

                            const symbol: SymbolInformation = await this.disassember.getDisassemblyForFunction(func, file);

                            if (symbol) {
                                args.breakpoints.forEach((brk) => {
                                    if (brk.line <= symbol.instructions.length) {
                                        const line = symbol.instructions[brk.line - 1];
                                        const arg: OurSourceBreakpoint = {
                                            ...brk,
                                            file: args.source.path,
                                            raw: line.address
                                        };
                                        all.push(this.miDebugger.addBreakPoint(arg).catch((err: MIError) => err));
                                    } else {
                                        all.push(
                                            Promise.resolve(
                                                new MIError(
                                                    `${func} only contains ${symbol.instructions.length} instructions`,
                                                    'Set breakpoint'
                                                )
                                            )
                                        );