Method setDataBreakpointsRequest

src/gdb.ts:2240–2301

(
        r: DebugProtocol.SetDataBreakpointsResponse,
        a: DebugProtocol.SetDataBreakpointsArguments)

    }

    protected setDataBreakpointsRequest(
        r: DebugProtocol.SetDataBreakpointsResponse,
        a: DebugProtocol.SetDataBreakpointsArguments): Promise<void> {
        const doit = (
            response: DebugProtocol.SetDataBreakpointsResponse,
            args: DebugProtocol.SetDataBreakpointsArguments,
            pendContinue: PendingContinue): Promise<void> => {
            return new Promise<void>(async (resolve) => {
                const createBreakpoints = async () => {
                    try {
                        const currentBreakpoints = Array.from(this.dataBreakpointMap.keys());
                        this.dataBreakpointMap.clear();

                        await this.miDebugger.removeBreakpoints(currentBreakpoints);

                        const all: Array<Promise<OurDataBreakpoint | MIError>> = [];

                        args.breakpoints.forEach((brk) => {
                            const bkp: OurDataBreakpoint = { ...brk };
                            all.push(this.miDebugger.addDataBreakPoint(bkp).catch((err: MIError) => err));
                        });

                        const brkpoints = await Promise.all(all);

                        response.body = {
                            breakpoints: brkpoints.map((bp) => {
                                if (bp instanceof MIError) {
                                    /* Failed breakpoints should be reported with
                                     * verified: false, so they can be greyed out
                                     * in the UI. The attached message will be
                                     * presented as a tooltip.
                                     */
                                    return {
                                        verified: false,
                                        message: bp.message
                                    } as DebugProtocol.Breakpoint;
                                }

                                this.dataBreakpointMap.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);
            });