Method restartProcessing

src/gdb.ts:1535–1591

()

        return new Promise<void>((resolve) => {
            const mode: SessionMode = (args === 'reset') ? SessionMode.RESET : SessionMode.RESTART;
            const restartProcessing = () => {
                const commands = [];
                this.args.pvtRestartOrReset = true;
                this.disableSendStoppedEvents = false;
                this.continuing = false;

                if (mode === SessionMode.RESTART) {
                    commands.push(...this.args.preRestartCommands.map(COMMAND_MAP));
                    const restartCommands = this.args.overrideRestartCommands ?
                        this.args.overrideRestartCommands.map(COMMAND_MAP) : this.serverController.restartCommands();
                    commands.push(...restartCommands);
                    commands.push(...this.args.postRestartCommands.map(COMMAND_MAP));
                } else {
                    commands.push(...this.args.preResetCommands.map(COMMAND_MAP));
                    const resetCommands = this.args.overrideResetCommands ? this.args.overrideResetCommands.map(COMMAND_MAP) :
                                          this.args.overrideRestartCommands ? this.args.overrideRestartCommands.map(COMMAND_MAP) :
                                          this.serverController.restartCommands();
                    commands.push(...resetCommands);
                    commands.push(...this.args.postResetCommands.map(COMMAND_MAP));
                }

                let finishCalled = false;
                const callFinish = () => {
                    if (!finishCalled) {
                        finishCalled = true;
                        this.sendDummyStackTrace = false;
                        this.finishStartSequence(mode);
                    }
                };

                // When we restart/reset, some startup sequences will produce a stopped event and some don't. In case such
                // an event is called, consume and return a dummy stacktrace (prevents unnecessary disassembly, multiple requests from VSCode, etc.)
                this.sendDummyStackTrace = true;    // Return dummies until we finish the start sequence
                this.onInternalEvents.once('stack-trace-request', () => {
                    callFinish();
                });

                this.miDebugger.restart(commands).then(async (done) => {
                    if (this.args.chainedConfigurations && this.args.chainedConfigurations.enabled) {
                        setTimeout(() => {      // Maybe this delay should be handled in the front-end
                            this.serverConsoleLog(`Begin ${mode} children`);
                            this.sendEvent(new GenericCustomEvent(`session-${mode}`, args));
                        }, 250);
                    }

                    if (!finishCalled) {
                        // gdb-server never produced any stopped events, so wait a bit to let things settle down
                        // Sometimes gdb sends delayed responses for program status (running, stopped, etc.) changes
                        await new Promise((resolve) => setTimeout(resolve, 100));
                        callFinish();
                    }
                    resolve();
                }, (msg) => {
                    this.sendErrorResponse(response, 6, `Could not restart/reset: ${msg}`);
                    resolve();
                });
            };