DebugAdapter.hpp

浏览该文件的文档.

#pragma once
 
#include "common/Export.h"
#include "devtools/Debugger.hpp"
 
#include <atomic>
#include <cstdint>
#include <memory>
#include <mutex>
#include <string>
#include <unordered_map>
#include <vector>
 
#include <Poco/SharedPtr.h>
 
namespace Poco::Net {
class ServerSocket;
class StreamSocket;
}
 
namespace Poco::JSON {
class Object;
}
 
namespace eve::dev {
 
class EVENGINE_API_FOUNDATION DebugAdapter {
public:
    static DebugAdapter& instance();
 
    DebugAdapter(const DebugAdapter&)            = delete;
    DebugAdapter& operator=(const DebugAdapter&) = delete;
 
    int  listen(uint16_t port);
    void stop();
    bool isListening() const { return listening_.load(); }
    int  port() const { return port_.load(); }
    bool hasClient() const { return hasClient_.load(); }
 
    void setSourceRoot(std::string root);
    const std::string& sourceRoot() const { return sourceRoot_; }
    void registerSource(std::string name, std::string content);
 
    void poll();
 
    bool isConfigured() const { return configured_; }
 
    bool waitUntilConfigured(int timeoutMs = 15000);
 
    void notifyStopped(PauseReason reason, const SourceLoc& loc,
                       const std::string& description = {});
    void notifyContinued();
    void notifyTerminated();
    const std::string& lastException() const { return lastException_; }
 
private:
    // Defined in .cpp so unique_ptr<incomplete Poco sockets> is legal on MSVC.
    DebugAdapter();
    ~DebugAdapter();
 
    void acceptNonBlocking();
    void readAndDispatch();
    bool sendMessage(const std::string& json);
    void handleRequest(const std::string& json);
    std::string makeResponse(int seq, int requestSeq, const std::string& command, bool ok,
                             const std::string& bodyJson, const std::string& message = {});
    std::string makeEvent(const std::string& event, const std::string& bodyJson);
    static std::string reasonString(PauseReason r);
    std::string resolveSourcePath(std::string source) const;
    void rememberSourcePath(const std::string& path);
    void discoverEngineScriptAliases();
    void handleBreakpointEvent(int id, const std::string& source, int line, bool verified);
    int varRefForFrame(int frameId);
    int allocVarRef(int kind, int frame, std::vector<std::string> path);
    Poco::SharedPtr<Poco::JSON::Object> makeSourceObject(const std::string& source) const;
 
    struct VarScope {
        int kind = 0;  // 0 = locals, 1 = globals
        int frame = 0;
        std::vector<std::string> path;
    };
 
    std::atomic<bool> listening_{false};
    std::atomic<bool> hasClient_{false};
    std::atomic<int>  port_{0};
    std::atomic<int>  seq_{1};
    std::recursive_mutex ioMu_;
    std::unique_ptr<Poco::Net::ServerSocket> server_;
    std::unique_ptr<Poco::Net::StreamSocket> client_;
    std::string       recvBuf_;
    std::string       sourceRoot_;
    std::unordered_map<std::string, std::string> sourceAliases_;
    bool              configured_ = false;
    bool              stopOnEntry_ = false;
    int               varRefLocals_ = 1;
    int               varRefWatches_ = 2;
    int               varRefGlobals_ = 5000;
    int               varRefFrameBase_ = 1000;
    int               nextVarRef_ = 10000;
    std::vector<VariableInfo> varCache_;
    std::unordered_map<int, VarScope> varScopes_;
    std::string       lastException_;
    std::unordered_map<std::string, std::string> sourceContents_;
    std::unordered_map<int, std::string> sourceRefContents_;
};
 
}  // namespace eve::dev