Method setInstructionBreakpointsRequest

src/gdb.ts:2132–2188

(
        r: DebugProtocol.SetInstructionBreakpointsResponse,
        a: DebugProtocol.SetInstructionBreakpointsArguments, request?: DebugProtocol.Request)

    }

    protected setInstructionBreakpointsRequest(
        r: DebugProtocol.SetInstructionBreakpointsResponse,
        a: DebugProtocol.SetInstructionBreakpointsArguments, request?: DebugProtocol.Request): Promise<void> {
        const doit = (
            response: DebugProtocol.SetInstructionBreakpointsResponse,
            args: DebugProtocol.SetInstructionBreakpointsArguments,
            pendContinue: PendingContinue): Promise<void> => {
            return new Promise<void>(async (resolve) => {
                const createBreakpoints = async () => {
                    try {
                        const currentBreakpoints = Array.from(this.instrBreakpointMap.keys());
                        this.instrBreakpointMap.clear();

                        await this.miDebugger.removeBreakpoints(currentBreakpoints);

                        const all: Array<Promise<OurInstructionBreakpoint | MIError>> = [];
                        args.breakpoints.forEach((brk) => {
                            const addr = parseInt(brk.instructionReference) + brk.offset || 0;
                            const bpt: OurInstructionBreakpoint = { ...brk, number: -1, address: addr };
                            all.push(this.miDebugger.addInstrBreakPoint(bpt).catch((err: MIError) => err));
                        });

                        const brkpoints = await Promise.all(all);

                        response.body = {
                            breakpoints: brkpoints.map((bp) => {
                                if (bp instanceof MIError) {
                                    return {
                                        verified: false,
                                        message: bp.message
                                    } as DebugProtocol.Breakpoint;
                                }

                                this.instrBreakpointMap.set(bp.number, bp);
                                return {
                                    id: bp.number,
                                    verified: true
                                };
                            })
                        };

                        this.sendResponse(response);
                    }
                    catch (msg) {
                        this.sendErrorResponse(response, 9, msg.toString());
                    }

                    this.continueIfNoMore(pendContinue);
                    resolve();
                };

                await this.doPauseExecContinue(createBreakpoints, pendContinue);
            });
        };

        return this.allBreakPointsQ.add(doit, r, a);
    }