Method setFunctionBreakPointsRequest

src/gdb.ts:1920–1991

(
        r: DebugProtocol.SetFunctionBreakpointsResponse,
        a: DebugProtocol.SetFunctionBreakpointsArguments)

        DebugProtocol.SetInstructionBreakpointsArguments |
        DebugProtocol.SetDataBreakpointsArguments>();
    protected setFunctionBreakPointsRequest(
        r: DebugProtocol.SetFunctionBreakpointsResponse,
        a: DebugProtocol.SetFunctionBreakpointsArguments): Promise<void> {
        const doit = (
            response: DebugProtocol.SetFunctionBreakpointsResponse,
            args: DebugProtocol.SetFunctionBreakpointsArguments,
            pendContinue: PendingContinue): Promise<void> => {
            return new Promise(async (resolve) => {
                const createBreakpoints = async () => {
                    try {
                        await this.miDebugger.removeBreakpoints(this.functionBreakpoints);
                        this.functionBreakpoints = [];

                        const all = new Array<Promise<OurSourceBreakpoint | MIError>>();
                        args.breakpoints.forEach((brk) => {
                            const arg: OurSourceBreakpoint = {
                                ...brk,
                                raw: brk.name,
                                file: undefined,
                                line: undefined
                            };
                            all.push(this.miDebugger.addBreakPoint(arg).catch((err: MIError) => err));
                        });

                        const breakpoints = await Promise.all(all);
                        const finalBrks: DebugProtocol.Breakpoint[] = breakpoints.map(
                            (brkp) => {
                                if (brkp instanceof MIError) {
                                    /* Failed breakpoints should be reported with
                                     * verified: false, so they can be greyed out
                                     * in the UI.
                                     */
                                    return {
                                        verified: false,
                                        message: brkp.message
                                    };
                                }

                                this.functionBreakpoints.push(brkp.number);

                                return {
                                    source: {
                                        path: brkp.file,
                                        name: brkp.raw
                                    },
                                    line: brkp.line,
                                    instructionReference: brkp.address,
                                    id: brkp.number,
                                    verified: true
                                } as DebugProtocol.Breakpoint;
                            }
                        );

                        response.body = {
                            breakpoints: finalBrks
                        };
                        this.sendResponse(response);
                    }