GdbResponse.h

#ifndef ROSE_BinaryAnalysis_Debugger_GdbResponse_H
#define ROSE_BinaryAnalysis_Debugger_GdbResponse_H
#include <featureTests.h>
#ifdef ROSE_ENABLE_DEBUGGER_GDB
#include <Rose/BinaryAnalysis/Debugger/Exception.h>
 
#include <Rose/Yaml.h>
 
namespace Rose {
namespace BinaryAnalysis {
namespace Debugger {
 
class GdbResponse {
 
    // Token types from the lexical analyzer
    enum TokenType {
        TOK_EOF,                                        // end of file
        TOK_LEFT,                                       // '{' or '['
        TOK_RIGHT,                                      // '}' or ']'
        TOK_DIGITS,                                     // sequence of digits
        TOK_SYMBOL,                                     // sequence of letters
        TOK_STRING,                                     // C-style string literal
        TOK_GDB,                                        // the string "(gdb)"
        TOK_OTHER                                       // anything else
    };
 
    // One token from the GDB MI output langauge
    class Token {
        friend class TokenStream;
        TokenType type_ = TOK_EOF;
        size_t begin_ = 0;
        size_t end_ = 0;
 
    public:
        Token();
        Token(TokenType, size_t begin, size_t end);
 
        TokenType type() const;
        size_t begin() const;
        size_t end() const;
        size_t size() const;
    };
 
    // Lexical analysis and the resulting sequence of tokens.
    class TokenStream {
        std::string content_;
        size_t at_ = 0;
        std::vector<Token> tokens_;
 
    public:
        explicit TokenStream(const std::string &sentence)
            : content_(sentence) {}
 
        const Token& operator[](size_t lookahead);
        void consume(size_t n = 1);
        std::string lexeme(size_t lookahead) const;
        const std::string& content() const;
 
    private:
        void makeNextToken();
    };
 
public:
    enum class ResultClass { DONE, RUNNING, CONNECTED, ERROR, EXIT, UNSPECIFIED };
 
    enum class AsyncClass {
        STOPPED,
        RUNNING,
        THREAD_GROUP_ADDED,
        THREAD_GROUP_STARTED,
        THREAD_GROUP_EXITED,
        THREAD_CREATED,
        THREAD_EXITED,
        BREAKPOINT_MODIFIED,
        OTHER,
        UNSPECIFIED
    };
 
    struct ResultRecord {
        ResultClass rclass = ResultClass::UNSPECIFIED;  
        Yaml::Node results;                             
        explicit operator bool() const {
            return rclass != ResultClass::UNSPECIFIED;
        }
    };
 
    struct AsyncRecord {
        AsyncClass aclass = AsyncClass::UNSPECIFIED;    
        Yaml::Node results;                             
        explicit operator bool() const {
            return aclass != AsyncClass::UNSPECIFIED;
        }
    };
 
public:
    std::string raw;                                    
    bool atEnd = false;                                 
    std::string token;                                  
    ResultRecord result;                                
    AsyncRecord exec;                                   
    AsyncRecord status;                                 
    AsyncRecord notify;                                 
    std::string console;                                
    std::string target;                                 
    std::string log;                                    
public:
    static GdbResponse parse(const std::string &line);
 
    void print(std::ostream&) const;
 
private:
    // Construct an exception for a syntax error with information about the error and where it occurs.
    static Exception syntaxError(std::string mesg, TokenStream&, size_t);
 
    // Parsers
    static void parseResultRecord(TokenStream&, GdbResponse&);
    static std::pair<AsyncClass, Yaml::Node> parseAsyncOutput(TokenStream&);
    static void parseExecAsyncOutput(TokenStream&, GdbResponse&);
    static void parseStatusAsyncOutput(TokenStream&, GdbResponse&);
    static void parseNotifyAsyncOutput(TokenStream&, GdbResponse&);
    static void parseConsoleStreamOutput(TokenStream&, GdbResponse&);
    static void parseTargetStreamOutput(TokenStream&, GdbResponse&);
    static void parseLogStreamOutput(TokenStream&, GdbResponse&);
    static std::pair<std::string, Yaml::Node> parseResult(TokenStream&);
    static Yaml::Node parseValue(TokenStream&);
 
    // Returns indented YAML unparsed from the specified node tree.
    static std::string nodeToString(const Yaml::Node&, const std::string&);
};
 
std::ostream& operator<<(std::ostream&, const GdbResponse&);
 
} // namespace
} // namespace
} // namespace
 
#endif
#endif