Source/cmDebuggerAdapter.cxx - third_party/cmake - Git at Google

 /* Distributed under the OSI-approved BSD 3-Clause License.  See accompanying
    file Copyright.txt or https://cmake.org/licensing for details.  */

 #include "cmConfigure.h" // IWYU pragma: keep

 #include "cmDebuggerAdapter.h"

 #include <algorithm>
 #include <climits>
 #include <condition_variable>
 #include <cstdint>
 #include <functional>
 #include <iostream>
 #include <stdexcept>
 #include <utility>

 #include <cm/memory>
 #include <cm/optional>

 #include <cm3p/cppdap/io.h> // IWYU pragma: keep
 #include <cm3p/cppdap/protocol.h>
 #include <cm3p/cppdap/session.h>

 #include "cmDebuggerBreakpointManager.h"
 #include "cmDebuggerExceptionManager.h"
 #include "cmDebuggerProtocol.h"
 #include "cmDebuggerSourceBreakpoint.h" // IWYU pragma: keep
 #include "cmDebuggerStackFrame.h"
 #include "cmDebuggerThread.h"
 #include "cmDebuggerThreadManager.h"
 #include "cmListFileCache.h"
 #include "cmMakefile.h"
 #include "cmValue.h"
 #include "cmVersionConfig.h"
 #include <cmcppdap/include/dap/optional.h>
 #include <cmcppdap/include/dap/types.h>

 namespace cmDebugger {

 // Event provides a basic wait and signal synchronization primitive.
 class SyncEvent
 {
 public:
   // Wait() blocks until the event is fired.
   void Wait()
   {
     std::unique_lock<std::mutex> lock(Mutex);
     Cv.wait(lock, [&] { return Fired; });
   }

   // Fire() sets signals the event, and unblocks any calls to Wait().
   void Fire()
   {
     std::unique_lock<std::mutex> lock(Mutex);
     Fired = true;
     Cv.notify_all();
   }

 private:
   std::mutex Mutex;
   std::condition_variable Cv;
   bool Fired = false;
 };

 class Semaphore
 {
 public:
   Semaphore(int count_ = 0)
     : Count(count_)
   {
   }

   inline void Notify()
   {
     std::unique_lock<std::mutex> lock(Mutex);
     Count++;
     // notify the waiting thread
     Cv.notify_one();
   }

   inline void Wait()
   {
     std::unique_lock<std::mutex> lock(Mutex);
     while (Count == 0) {
       // wait on the mutex until notify is called
       Cv.wait(lock);
     }
     Count--;
   }

 private:
   std::mutex Mutex;
   std::condition_variable Cv;
   int Count;
 };

 cmDebuggerAdapter::cmDebuggerAdapter(
   std::shared_ptr<cmDebuggerConnection> connection,
   std::string const& dapLogPath)
   : cmDebuggerAdapter(std::move(connection),
                       dapLogPath.empty()
                         ? cm::nullopt
                         : cm::optional<std::shared_ptr<dap::Writer>>(
                             dap::file(dapLogPath.c_str())))
 {
 }

 cmDebuggerAdapter::cmDebuggerAdapter(
   std::shared_ptr<cmDebuggerConnection> connection,
   cm::optional<std::shared_ptr<dap::Writer>> logger)
   : Connection(std::move(connection))
   , SessionActive(true)
   , DisconnectEvent(cm::make_unique<SyncEvent>())
   , ConfigurationDoneEvent(cm::make_unique<SyncEvent>())
   , ContinueSem(cm::make_unique<Semaphore>())
   , ThreadManager(cm::make_unique<cmDebuggerThreadManager>())
 {
   if (logger.has_value()) {
     SessionLog = std::move(logger.value());
   }
   ClearStepRequests();

   Session = dap::Session::create();
   BreakpointManager =
     cm::make_unique<cmDebuggerBreakpointManager>(Session.get());
   ExceptionManager =
     cm::make_unique<cmDebuggerExceptionManager>(Session.get());

   // Handle errors reported by the Session. These errors include protocol
   // parsing errors and receiving messages with no handler.
   Session->onError([this](const char* msg) {
     if (SessionLog) {
       dap::writef(SessionLog, "dap::Session error: %s\n", msg);
     }

     std::cout << "[CMake Debugger] DAP session error: " << msg << std::endl;

     BreakpointManager->ClearAll();
     ExceptionManager->ClearAll();
     ClearStepRequests();
     ContinueSem->Notify();
     DisconnectEvent->Fire();
     SessionActive.store(false);
   });

   // https://microsoft.github.io/debug-adapter-protocol/specification#Requests_Initialize
   Session->registerHandler([this](const dap::CMakeInitializeRequest& req) {
     SupportsVariableType = req.supportsVariableType.value(false);
     dap::CMakeInitializeResponse response;
     response.supportsConfigurationDoneRequest = true;
     response.cmakeVersion.major = CMake_VERSION_MAJOR;
     response.cmakeVersion.minor = CMake_VERSION_MINOR;
     response.cmakeVersion.patch = CMake_VERSION_PATCH;
     response.cmakeVersion.full = CMake_VERSION;
     ExceptionManager->HandleInitializeRequest(response);
     return response;
   });

   // https://microsoft.github.io/debug-adapter-protocol/specification#Events_Initialized
   Session->registerSentHandler(
     [&](const dap::ResponseOrError<dap::CMakeInitializeResponse>&) {
       Session->send(dap::InitializedEvent());
     });

   // https://microsoft.github.io/debug-adapter-protocol/specification#Requests_Threads
   Session->registerHandler([this](const dap::ThreadsRequest& req) {
     (void)req;
     std::unique_lock<std::mutex> lock(Mutex);
     dap::ThreadsResponse response;

     // If a client requests threads during shutdown (like after receiving the
     // thread exited event), DefaultThread won't be set.
     if (DefaultThread) {
       dap::Thread thread;
       thread.id = DefaultThread->GetId();
       thread.name = DefaultThread->GetName();
       response.threads.push_back(thread);
     }

     return response;
   });

   // https://microsoft.github.io/debug-adapter-protocol/specification#Requests_StackTrace
   Session->registerHandler([this](const dap::StackTraceRequest& request)
                              -> dap::ResponseOrError<dap::StackTraceResponse> {
     std::unique_lock<std::mutex> lock(Mutex);

     cm::optional<dap::StackTraceResponse> response =
       ThreadManager->GetThreadStackTraceResponse(request.threadId);
     if (response.has_value()) {
       return response.value();
     }

     return dap::Error("Unknown threadId '%d'", int(request.threadId));
   });

   // https://microsoft.github.io/debug-adapter-protocol/specification#Requests_Scopes
   Session->registerHandler([this](const dap::ScopesRequest& request)
                              -> dap::ResponseOrError<dap::ScopesResponse> {
     std::unique_lock<std::mutex> lock(Mutex);
     return DefaultThread->GetScopesResponse(request.frameId,
                                             SupportsVariableType);
   });

   // https://microsoft.github.io/debug-adapter-protocol/specification#Requests_Variables
   Session->registerHandler([this](const dap::VariablesRequest& request)
                              -> dap::ResponseOrError<dap::VariablesResponse> {
     return DefaultThread->GetVariablesResponse(request);
   });

   // https://microsoft.github.io/debug-adapter-protocol/specification#Requests_Pause
   Session->registerHandler([this](const dap::PauseRequest& req) {
     (void)req;
     PauseRequest.store(true);
     return dap::PauseResponse();
   });

   // https://microsoft.github.io/debug-adapter-protocol/specification#Requests_Continue
   Session->registerHandler([this](const dap::ContinueRequest& req) {
     (void)req;
     ContinueSem->Notify();
     return dap::ContinueResponse();
   });

   // https://microsoft.github.io/debug-adapter-protocol/specification#Requests_Next
   Session->registerHandler([this](const dap::NextRequest& req) {
     (void)req;
     NextStepFrom.store(DefaultThread->GetStackFrameSize());
     ContinueSem->Notify();
     return dap::NextResponse();
   });

   // https://microsoft.github.io/debug-adapter-protocol/specification#Requests_StepIn
   Session->registerHandler([this](const dap::StepInRequest& req) {
     (void)req;
     // This would stop after stepped in, single line stepped or stepped out.
     StepInRequest.store(true);
     ContinueSem->Notify();
     return dap::StepInResponse();
   });

   // https://microsoft.github.io/debug-adapter-protocol/specification#Requests_StepOut
   Session->registerHandler([this](const dap::StepOutRequest& req) {
     (void)req;
     StepOutDepth.store(DefaultThread->GetStackFrameSize() - 1);
     ContinueSem->Notify();
     return dap::StepOutResponse();
   });

   // https://microsoft.github.io/debug-adapter-protocol/specification#Requests_Launch
   Session->registerHandler([](const dap::LaunchRequest& req) {
     (void)req;
     return dap::LaunchResponse();
   });

   // Handler for disconnect requests
   Session->registerHandler([this](const dap::DisconnectRequest& request) {
     (void)request;
     BreakpointManager->ClearAll();
     ExceptionManager->ClearAll();
     ClearStepRequests();
     ContinueSem->Notify();
     DisconnectEvent->Fire();
     SessionActive.store(false);
     return dap::DisconnectResponse();
   });

   Session->registerHandler([this](const dap::EvaluateRequest& request) {
     dap::EvaluateResponse response;
     if (request.frameId.has_value()) {
       std::shared_ptr<cmDebuggerStackFrame> frame =
         DefaultThread->GetStackFrame(request.frameId.value());

       auto var = frame->GetMakefile()->GetDefinition(request.expression);
       if (var) {
         response.type = "string";
         response.result = var;
         return response;
       }
     }

     return response;
   });

   // The ConfigurationDone request is made by the client once all configuration
   // requests have been made.
   // https://microsoft.github.io/debug-adapter-protocol/specification#Requests_ConfigurationDone
   Session->registerHandler([this](const dap::ConfigurationDoneRequest& req) {
     (void)req;
     ConfigurationDoneEvent->Fire();
     return dap::ConfigurationDoneResponse();
   });

   std::string errorMessage;
   if (!Connection->StartListening(errorMessage)) {
     throw std::runtime_error(errorMessage);
   }

   // Connect to the client. Write a well-known message to stdout so that
   // clients know it is safe to attempt to connect.
   std::cout << "Waiting for debugger client to connect..." << std::endl;
   Connection->WaitForConnection();
   std::cout << "Debugger client connected." << std::endl;

   if (SessionLog) {
     Session->connect(spy(Connection->GetReader(), SessionLog),
                      spy(Connection->GetWriter(), SessionLog));
   } else {
     Session->connect(Connection->GetReader(), Connection->GetWriter());
   }

   // Start the processing thread.
   SessionThread = std::thread([this] {
     while (SessionActive.load()) {
       if (auto payload = Session->getPayload()) {
         payload();
       }
     }
   });

   ConfigurationDoneEvent->Wait();

   DefaultThread = ThreadManager->StartThread("CMake script");
   dap::ThreadEvent threadEvent;
   threadEvent.reason = "started";
   threadEvent.threadId = DefaultThread->GetId();
   Session->send(threadEvent);
 }

 cmDebuggerAdapter::~cmDebuggerAdapter()
 {
   if (SessionThread.joinable()) {
     SessionThread.join();
   }

   Session.reset(nullptr);

   if (SessionLog) {
     SessionLog->close();
   }
 }

 void cmDebuggerAdapter::ReportExitCode(int exitCode)
 {
   ThreadManager->EndThread(DefaultThread);
   dap::ThreadEvent threadEvent;
   threadEvent.reason = "exited";
   threadEvent.threadId = DefaultThread->GetId();
   DefaultThread.reset();

   dap::ExitedEvent exitEvent;
   exitEvent.exitCode = exitCode;

   dap::TerminatedEvent terminatedEvent;

   if (SessionActive.load()) {
     Session->send(threadEvent);
     Session->send(exitEvent);
     Session->send(terminatedEvent);
   }

   // Wait until disconnected or error.
   DisconnectEvent->Wait();
 }

 void cmDebuggerAdapter::OnFileParsedSuccessfully(
   std::string const& sourcePath,
   std::vector<cmListFileFunction> const& functions)
 {
   BreakpointManager->SourceFileLoaded(sourcePath, functions);
 }

 void cmDebuggerAdapter::OnBeginFunctionCall(cmMakefile* mf,
                                             std::string const& sourcePath,
                                             cmListFileFunction const& lff)
 {
   std::unique_lock<std::mutex> lock(Mutex);
   DefaultThread->PushStackFrame(mf, sourcePath, lff);

   if (lff.Line() == 0) {
     // File just loaded, continue to first valid function call.
     return;
   }

   auto hits = BreakpointManager->GetBreakpoints(sourcePath, lff.Line());
   lock.unlock();

   bool waitSem = false;
   dap::StoppedEvent stoppedEvent;
   stoppedEvent.allThreadsStopped = true;
   stoppedEvent.threadId = DefaultThread->GetId();
   if (!hits.empty()) {
     ClearStepRequests();
     waitSem = true;

     dap::array<dap::integer> hitBreakpoints;
     hitBreakpoints.resize(hits.size());
     std::transform(hits.begin(), hits.end(), hitBreakpoints.begin(),
                    [&](const int64_t& id) { return dap::integer(id); });
     stoppedEvent.reason = "breakpoint";
     stoppedEvent.hitBreakpointIds = hitBreakpoints;
   }

   if (long(DefaultThread->GetStackFrameSize()) <= NextStepFrom.load() ||
       StepInRequest.load() ||
       long(DefaultThread->GetStackFrameSize()) <= StepOutDepth.load()) {
     ClearStepRequests();
     waitSem = true;

     stoppedEvent.reason = "step";
   }

   if (PauseRequest.load()) {
     ClearStepRequests();
     waitSem = true;

     stoppedEvent.reason = "pause";
   }

   if (waitSem) {
     Session->send(stoppedEvent);
     ContinueSem->Wait();
   }
 }

 void cmDebuggerAdapter::OnEndFunctionCall()
 {
   DefaultThread->PopStackFrame();
 }

 static std::shared_ptr<cmListFileFunction> listFileFunction;

 void cmDebuggerAdapter::OnBeginFileParse(cmMakefile* mf,
                                          std::string const& sourcePath)
 {
   std::unique_lock<std::mutex> lock(Mutex);

   listFileFunction = std::make_shared<cmListFileFunction>(
     sourcePath, 0, 0, std::vector<cmListFileArgument>());
   DefaultThread->PushStackFrame(mf, sourcePath, *listFileFunction);
 }

 void cmDebuggerAdapter::OnEndFileParse()
 {
   DefaultThread->PopStackFrame();
   listFileFunction = nullptr;
 }

 void cmDebuggerAdapter::OnMessageOutput(MessageType t, std::string const& text)
 {
   cm::optional<dap::StoppedEvent> stoppedEvent =
     ExceptionManager->RaiseExceptionIfAny(t, text);
   if (stoppedEvent.has_value()) {
     stoppedEvent->threadId = DefaultThread->GetId();
     Session->send(*stoppedEvent);
     ContinueSem->Wait();
   }
 }

 void cmDebuggerAdapter::ClearStepRequests()
 {
   NextStepFrom.store(INT_MIN);
   StepInRequest.store(false);
   StepOutDepth.store(INT_MIN);
   PauseRequest.store(false);
 }

 } // namespace cmDebugger
	/* Distributed under the OSI-approved BSD 3-Clause License. See accompanying
	file Copyright.txt or https://cmake.org/licensing for details. */

	#include "cmConfigure.h" // IWYU pragma: keep

	#include "cmDebuggerAdapter.h"

	#include <algorithm>
	#include <climits>
	#include <condition_variable>
	#include <cstdint>
	#include <functional>
	#include <iostream>
	#include <stdexcept>
	#include <utility>

	#include <cm/memory>
	#include <cm/optional>

	#include <cm3p/cppdap/io.h> // IWYU pragma: keep
	#include <cm3p/cppdap/protocol.h>
	#include <cm3p/cppdap/session.h>

	#include "cmDebuggerBreakpointManager.h"
	#include "cmDebuggerExceptionManager.h"
	#include "cmDebuggerProtocol.h"
	#include "cmDebuggerSourceBreakpoint.h" // IWYU pragma: keep
	#include "cmDebuggerStackFrame.h"
	#include "cmDebuggerThread.h"
	#include "cmDebuggerThreadManager.h"
	#include "cmListFileCache.h"
	#include "cmMakefile.h"
	#include "cmValue.h"
	#include "cmVersionConfig.h"
	#include <cmcppdap/include/dap/optional.h>
	#include <cmcppdap/include/dap/types.h>

	namespace cmDebugger {

	// Event provides a basic wait and signal synchronization primitive.
	class SyncEvent
	{
	public:
	// Wait() blocks until the event is fired.
	void Wait()
	{
	std::unique_lock<std::mutex> lock(Mutex);
	Cv.wait(lock, [&] { return Fired; });
	}

	// Fire() sets signals the event, and unblocks any calls to Wait().
	void Fire()
	{
	std::unique_lock<std::mutex> lock(Mutex);
	Fired = true;
	Cv.notify_all();
	}

	private:
	std::mutex Mutex;
	std::condition_variable Cv;
	bool Fired = false;
	};

	class Semaphore
	{
	public:
	Semaphore(int count_ = 0)
	: Count(count_)
	{
	}

	inline void Notify()
	{
	std::unique_lock<std::mutex> lock(Mutex);
	Count++;
	// notify the waiting thread
	Cv.notify_one();
	}

	inline void Wait()
	{
	std::unique_lock<std::mutex> lock(Mutex);
	while (Count == 0) {
	// wait on the mutex until notify is called
	Cv.wait(lock);
	}
	Count--;
	}

	private:
	std::mutex Mutex;
	std::condition_variable Cv;
	int Count;
	};

	cmDebuggerAdapter::cmDebuggerAdapter(
	std::shared_ptr<cmDebuggerConnection> connection,
	std::string const& dapLogPath)
	: cmDebuggerAdapter(std::move(connection),
	dapLogPath.empty()
	? cm::nullopt
	: cm::optional<std::shared_ptr<dap::Writer>>(
	dap::file(dapLogPath.c_str())))
	{
	}

	cmDebuggerAdapter::cmDebuggerAdapter(
	std::shared_ptr<cmDebuggerConnection> connection,
	cm::optional<std::shared_ptr<dap::Writer>> logger)
	: Connection(std::move(connection))
	, SessionActive(true)
	, DisconnectEvent(cm::make_unique<SyncEvent>())
	, ConfigurationDoneEvent(cm::make_unique<SyncEvent>())
	, ContinueSem(cm::make_unique<Semaphore>())
	, ThreadManager(cm::make_unique<cmDebuggerThreadManager>())
	{
	if (logger.has_value()) {
	SessionLog = std::move(logger.value());
	}
	ClearStepRequests();

	Session = dap::Session::create();
	BreakpointManager =
	cm::make_unique<cmDebuggerBreakpointManager>(Session.get());
	ExceptionManager =
	cm::make_unique<cmDebuggerExceptionManager>(Session.get());

	// Handle errors reported by the Session. These errors include protocol
	// parsing errors and receiving messages with no handler.
	Session->onError([this](const char* msg) {
	if (SessionLog) {
	dap::writef(SessionLog, "dap::Session error: %s\n", msg);
	}

	std::cout << "[CMake Debugger] DAP session error: " << msg << std::endl;

	BreakpointManager->ClearAll();
	ExceptionManager->ClearAll();
	ClearStepRequests();
	ContinueSem->Notify();
	DisconnectEvent->Fire();
	SessionActive.store(false);
	});

	// https://microsoft.github.io/debug-adapter-protocol/specification#Requests_Initialize
	Session->registerHandler([this](const dap::CMakeInitializeRequest& req) {
	SupportsVariableType = req.supportsVariableType.value(false);
	dap::CMakeInitializeResponse response;
	response.supportsConfigurationDoneRequest = true;
	response.cmakeVersion.major = CMake_VERSION_MAJOR;
	response.cmakeVersion.minor = CMake_VERSION_MINOR;
	response.cmakeVersion.patch = CMake_VERSION_PATCH;
	response.cmakeVersion.full = CMake_VERSION;
	ExceptionManager->HandleInitializeRequest(response);
	return response;
	});

	// https://microsoft.github.io/debug-adapter-protocol/specification#Events_Initialized
	Session->registerSentHandler(
	[&](const dap::ResponseOrError<dap::CMakeInitializeResponse>&) {
	Session->send(dap::InitializedEvent());
	});

	// https://microsoft.github.io/debug-adapter-protocol/specification#Requests_Threads
	Session->registerHandler([this](const dap::ThreadsRequest& req) {
	(void)req;
	std::unique_lock<std::mutex> lock(Mutex);
	dap::ThreadsResponse response;

	// If a client requests threads during shutdown (like after receiving the
	// thread exited event), DefaultThread won't be set.
	if (DefaultThread) {
	dap::Thread thread;
	thread.id = DefaultThread->GetId();
	thread.name = DefaultThread->GetName();
	response.threads.push_back(thread);
	}

	return response;
	});

	// https://microsoft.github.io/debug-adapter-protocol/specification#Requests_StackTrace
	Session->registerHandler([this](const dap::StackTraceRequest& request)
	-> dap::ResponseOrError<dap::StackTraceResponse> {
	std::unique_lock<std::mutex> lock(Mutex);

	cm::optional<dap::StackTraceResponse> response =
	ThreadManager->GetThreadStackTraceResponse(request.threadId);
	if (response.has_value()) {
	return response.value();
	}

	return dap::Error("Unknown threadId '%d'", int(request.threadId));
	});

	// https://microsoft.github.io/debug-adapter-protocol/specification#Requests_Scopes
	Session->registerHandler([this](const dap::ScopesRequest& request)
	-> dap::ResponseOrError<dap::ScopesResponse> {
	std::unique_lock<std::mutex> lock(Mutex);
	return DefaultThread->GetScopesResponse(request.frameId,
	SupportsVariableType);
	});

	// https://microsoft.github.io/debug-adapter-protocol/specification#Requests_Variables
	Session->registerHandler([this](const dap::VariablesRequest& request)
	-> dap::ResponseOrError<dap::VariablesResponse> {
	return DefaultThread->GetVariablesResponse(request);
	});

	// https://microsoft.github.io/debug-adapter-protocol/specification#Requests_Pause
	Session->registerHandler([this](const dap::PauseRequest& req) {
	(void)req;
	PauseRequest.store(true);
	return dap::PauseResponse();
	});

	// https://microsoft.github.io/debug-adapter-protocol/specification#Requests_Continue
	Session->registerHandler([this](const dap::ContinueRequest& req) {
	(void)req;
	ContinueSem->Notify();
	return dap::ContinueResponse();
	});

	// https://microsoft.github.io/debug-adapter-protocol/specification#Requests_Next
	Session->registerHandler([this](const dap::NextRequest& req) {
	(void)req;
	NextStepFrom.store(DefaultThread->GetStackFrameSize());
	ContinueSem->Notify();
	return dap::NextResponse();
	});

	// https://microsoft.github.io/debug-adapter-protocol/specification#Requests_StepIn
	Session->registerHandler([this](const dap::StepInRequest& req) {
	(void)req;
	// This would stop after stepped in, single line stepped or stepped out.
	StepInRequest.store(true);
	ContinueSem->Notify();
	return dap::StepInResponse();
	});

	// https://microsoft.github.io/debug-adapter-protocol/specification#Requests_StepOut
	Session->registerHandler([this](const dap::StepOutRequest& req) {
	(void)req;
	StepOutDepth.store(DefaultThread->GetStackFrameSize() - 1);
	ContinueSem->Notify();
	return dap::StepOutResponse();
	});

	// https://microsoft.github.io/debug-adapter-protocol/specification#Requests_Launch
	Session->registerHandler([](const dap::LaunchRequest& req) {
	(void)req;
	return dap::LaunchResponse();
	});

	// Handler for disconnect requests
	Session->registerHandler([this](const dap::DisconnectRequest& request) {
	(void)request;
	BreakpointManager->ClearAll();
	ExceptionManager->ClearAll();
	ClearStepRequests();
	ContinueSem->Notify();
	DisconnectEvent->Fire();
	SessionActive.store(false);
	return dap::DisconnectResponse();
	});

	Session->registerHandler([this](const dap::EvaluateRequest& request) {
	dap::EvaluateResponse response;
	if (request.frameId.has_value()) {
	std::shared_ptr<cmDebuggerStackFrame> frame =
	DefaultThread->GetStackFrame(request.frameId.value());

	auto var = frame->GetMakefile()->GetDefinition(request.expression);
	if (var) {
	response.type = "string";
	response.result = var;
	return response;
	}
	}

	return response;
	});

	// The ConfigurationDone request is made by the client once all configuration
	// requests have been made.
	// https://microsoft.github.io/debug-adapter-protocol/specification#Requests_ConfigurationDone
	Session->registerHandler([this](const dap::ConfigurationDoneRequest& req) {
	(void)req;
	ConfigurationDoneEvent->Fire();
	return dap::ConfigurationDoneResponse();
	});

	std::string errorMessage;
	if (!Connection->StartListening(errorMessage)) {
	throw std::runtime_error(errorMessage);
	}

	// Connect to the client. Write a well-known message to stdout so that
	// clients know it is safe to attempt to connect.
	std::cout << "Waiting for debugger client to connect..." << std::endl;
	Connection->WaitForConnection();
	std::cout << "Debugger client connected." << std::endl;

	if (SessionLog) {
	Session->connect(spy(Connection->GetReader(), SessionLog),
	spy(Connection->GetWriter(), SessionLog));
	} else {
	Session->connect(Connection->GetReader(), Connection->GetWriter());
	}

	// Start the processing thread.
	SessionThread = std::thread([this] {
	while (SessionActive.load()) {
	if (auto payload = Session->getPayload()) {
	payload();
	}
	}
	});

	ConfigurationDoneEvent->Wait();

	DefaultThread = ThreadManager->StartThread("CMake script");
	dap::ThreadEvent threadEvent;
	threadEvent.reason = "started";
	threadEvent.threadId = DefaultThread->GetId();
	Session->send(threadEvent);
	}

	cmDebuggerAdapter::~cmDebuggerAdapter()
	{
	if (SessionThread.joinable()) {
	SessionThread.join();
	}

	Session.reset(nullptr);

	if (SessionLog) {
	SessionLog->close();
	}
	}

	void cmDebuggerAdapter::ReportExitCode(int exitCode)
	{
	ThreadManager->EndThread(DefaultThread);
	dap::ThreadEvent threadEvent;
	threadEvent.reason = "exited";
	threadEvent.threadId = DefaultThread->GetId();
	DefaultThread.reset();

	dap::ExitedEvent exitEvent;
	exitEvent.exitCode = exitCode;

	dap::TerminatedEvent terminatedEvent;

	if (SessionActive.load()) {
	Session->send(threadEvent);
	Session->send(exitEvent);
	Session->send(terminatedEvent);
	}

	// Wait until disconnected or error.
	DisconnectEvent->Wait();
	}

	void cmDebuggerAdapter::OnFileParsedSuccessfully(
	std::string const& sourcePath,
	std::vector<cmListFileFunction> const& functions)
	{
	BreakpointManager->SourceFileLoaded(sourcePath, functions);
	}

	void cmDebuggerAdapter::OnBeginFunctionCall(cmMakefile* mf,
	std::string const& sourcePath,
	cmListFileFunction const& lff)
	{
	std::unique_lock<std::mutex> lock(Mutex);
	DefaultThread->PushStackFrame(mf, sourcePath, lff);

	if (lff.Line() == 0) {
	// File just loaded, continue to first valid function call.
	return;
	}

	auto hits = BreakpointManager->GetBreakpoints(sourcePath, lff.Line());
	lock.unlock();

	bool waitSem = false;
	dap::StoppedEvent stoppedEvent;
	stoppedEvent.allThreadsStopped = true;
	stoppedEvent.threadId = DefaultThread->GetId();
	if (!hits.empty()) {
	ClearStepRequests();
	waitSem = true;

	dap::array<dap::integer> hitBreakpoints;
	hitBreakpoints.resize(hits.size());
	std::transform(hits.begin(), hits.end(), hitBreakpoints.begin(),
	[&](const int64_t& id) { return dap::integer(id); });
	stoppedEvent.reason = "breakpoint";
	stoppedEvent.hitBreakpointIds = hitBreakpoints;
	}

	if (long(DefaultThread->GetStackFrameSize()) <= NextStepFrom.load() \|\|
	StepInRequest.load() \|\|
	long(DefaultThread->GetStackFrameSize()) <= StepOutDepth.load()) {
	ClearStepRequests();
	waitSem = true;

	stoppedEvent.reason = "step";
	}

	if (PauseRequest.load()) {
	ClearStepRequests();
	waitSem = true;

	stoppedEvent.reason = "pause";
	}

	if (waitSem) {
	Session->send(stoppedEvent);
	ContinueSem->Wait();
	}
	}

	void cmDebuggerAdapter::OnEndFunctionCall()
	{
	DefaultThread->PopStackFrame();
	}

	static std::shared_ptr<cmListFileFunction> listFileFunction;

	void cmDebuggerAdapter::OnBeginFileParse(cmMakefile* mf,
	std::string const& sourcePath)
	{
	std::unique_lock<std::mutex> lock(Mutex);

	listFileFunction = std::make_shared<cmListFileFunction>(
	sourcePath, 0, 0, std::vector<cmListFileArgument>());
	DefaultThread->PushStackFrame(mf, sourcePath, *listFileFunction);
	}

	void cmDebuggerAdapter::OnEndFileParse()
	{
	DefaultThread->PopStackFrame();
	listFileFunction = nullptr;
	}

	void cmDebuggerAdapter::OnMessageOutput(MessageType t, std::string const& text)
	{
	cm::optional<dap::StoppedEvent> stoppedEvent =
	ExceptionManager->RaiseExceptionIfAny(t, text);
	if (stoppedEvent.has_value()) {
	stoppedEvent->threadId = DefaultThread->GetId();
	Session->send(*stoppedEvent);
	ContinueSem->Wait();
	}
	}

	void cmDebuggerAdapter::ClearStepRequests()
	{
	NextStepFrom.store(INT_MIN);
	StepInRequest.store(false);
	StepOutDepth.store(INT_MIN);
	PauseRequest.store(false);
	}

	} // namespace cmDebugger