Debugger.cpp

#include <getopt.h>
#include <limits.h>
#include <string.h>

#include <cstdlib>
#include <fstream>
#include <iostream>
#include <iterator>
#include <string>

#include "FilePosition.hpp"
#include "Line.hpp"
#include "Tu4Command.hpp"
#include "Tu4Runner.hpp"
#include "exception.hpp"
#include "globals.hpp"
#include "trie.hpp"
#include "utils.hpp"

const char* preview =
    "OST program debugger\n"
    "Usage: ostdb <program name .tu4> [OPTIONS]\n"
    "input: 'run <input line>' to start debug\n"
    "(for line breakpoints support program must be compiled with -g flag)\n"
    "input: 'step' or empty line to do step and show file state\n"
    "input: 'step -n [number]' to do 'n' steps and show file state\n"
    "input: 'go' to start stepping loop until program's end or breakpoint "
    "occured\n"
    "input: 'b -q <state number>' to set breakpoint on <state number>(from "
    "0) "
    "state\n"
    "input: 'b -l <line number>' to set breakpoint on <line number>(from "
    "1) "
    "line\n"
    "input: 'restart' to restart current loadded program with new starting "
    "line\n"
    "input: 'help' show this message\n";

enum class Command { NONE, RUN, STEP, GO, B, HELP, RESTART };

impl::Trie<Command> initCommands() {
    impl::Trie<Command> trie;
    trie.add("run", Command::RUN);
    trie.add("step", Command::STEP);
    trie.add("go", Command::GO);
    trie.add("b", Command::B);
    trie.add("help", Command::HELP);
    trie.add("restart", Command::RESTART);

    return trie;
}

struct FileData {
    std::ifstream file;
    SIZE_T nColumn = 0;
    SIZE_T nLine = std::numeric_limits<SIZE_T>::max();
};
void printState(const tu4run::Tu4Runner<SIZE_T, char>& runner) {
    static std::map<std::string, FileData> filesData;

    auto command = runner.nextCommand();
    auto debugInfo = command.debugBreakpoint();
    if (globals::debugMode && !debugInfo.has_value()) {
        logger::debug() << "No debug information in line: "
                        << (strfast() << command).bump() << std::endl;
        return;
    }
    if (globals::debugMode) {
        const std::string& fileName =
            FilePosition::fileCodesBimap()[debugInfo.value().fileCode];
        std::string line;

        const std::pair<row_t, column_t> begin = debugInfo.value().begin,
                                         end = debugInfo.value().end,
                                         *position = &begin;
        if (runner.terminated()) position = &end;

        if (!filesData.contains(fileName)) filesData[fileName] = FileData{};
        FileData& fdata = filesData[fileName];

        if (fdata.nLine > position->first) {
            if (!fdata.file.is_open())
                fdata.file.open(fileName);
            else {
                fdata.file.clear();
                fdata.file.seekg(0);
            }
            fdata.nLine = 1;
        }

        while (!fdata.file.eof() && fdata.nLine <= position->first) {
            std::getline(fdata.file, line);
            ++fdata.nLine;
        }

        for (auto& c : line)
            if (c == '\t') c = ' ';

        std::cout << fdata.nLine - 1 << " :" << line << std::endl;
        std::cout << fdata.nLine - 1 << " :";
        if (!runner.terminated())
            for (SIZE_T i = 0; i + 1 < position->second; ++i) std::cout << " ";
        SIZE_T endIndex = (begin.first == end.first ? end.second : line.size());
        for (SIZE_T i = position->second; i < endIndex; ++i) std::cout << "^";
        std::cout << std::endl;
    }
    std::cout << "command: " << command << std::endl;
}

static std::string fileName = "";

class Manager {
    impl::Trie<Command> commands_;
    std::unique_ptr<tu4run::Tu4Runner<SIZE_T, char>> runner_ = nullptr;
    tu4run::Tu4RunnerBreakpoints breakpoints_;
    std::vector<std::string> usedFileNames_;

    void restart() {
        if (!runner_) {
            logger::warning()
                << "Setup runner by 'run' command before reseting it";
            return;
        }

        std::string line;
        std::cout << "Input line: ";
        std::getline(std::cin, line);
        (*runner_).reset(tu4run::Line<char>{line});
    }

    void run(std::string line) {
        auto runnerInitData = tu4run::initRunnerWithBreakpoints(fileName, line);
        runner_ = std::move(runnerInitData.runner);
        breakpoints_ = runnerInitData.breakpoints;
        usedFileNames_ = runnerInitData.fileNames;
    }

    void step(SIZE_T n = 1) {
        while (n-- >= 1 && !runner_->terminated()) runner_->step();
    }

    void go() {
        try {
            runner_->loop();
            if (runner_->terminated())
                std::cout << "End" << std::endl;
            else
                std::cout << "Stop at breakpoint" << std::endl;
        } catch (error::Tu4RunError<>& e) {
            logger::error() << e.what();
            std::cout << "Forsing restart via error while executing\n";
            restart();
        }
    }

    void addBreakpointState(SIZE_T q) { breakpoints_.stateBreakpoints->add(q); }

    void addBreakpointLine(SIZE_T nLine) {
        if (!globals::debugMode) {
            std::cout << "Line breakpoints only allowed when program compiled "
                         "in debug mode(-g)\n"
                      << "Not this case\n";
            return;
        }
        std::cout << "Choose file name in which set line breakpoint:\n";
        for (SIZE_T i = 0; i < usedFileNames_.size(); ++i)
            std::cout << i << ") " << usedFileNames_[i] << '\n';
        SIZE_T findex;
        std::cout << "Enter file number: ";
        std::cin >> findex;

        SIZE_T fileCode =
            FilePosition::fileCodesBimap()[usedFileNames_.at(findex)];

        if (!breakpoints_.lineBreakpoints->contains(fileCode))
            (*breakpoints_.lineBreakpoints)[fileCode] = {};

        if (nLine > 0) (*breakpoints_.lineBreakpoints)[fileCode].add(nLine);
    }

    void processLine_impl(const std::list<std::string>& words) {
        if (words.size() == 0) {
            if (!runner_) return;
            if (!runner_->terminated()) runner_->step();
            return;
        }

        std::string line;
        auto word = std::begin(words);
        Command command = commands_.find(*word).value_or(Command::NONE);
        ++word;

        switch (command) {
            case Command::NONE:
                std::cout << "Error: undefined command: " << *word << std::endl;
                break;
            case Command::RUN:
                if (words.size() < 2) {
                    logger::warning() << "Error: no input line given";
                    return;
                }
                line = *( word++ );
                for (; word != std::end(words); ++word) {
                    line += " " + *word;
                }
                run(line);
                break;
            case Command::STEP:
                if (words.size() > 2 && *(++word) == "-n")
                    step(atoll(std::next(word)->c_str()));
                else
                    step(1);
                break;
            case Command::GO:
                go();
                break;
            case Command::B:
                ++word;
                if (word == std::end(words)) {
                    std::cout << "Add -q or -l flag to set type of breakpoint"
                              << std::endl;
                    break;
                }
                if (*word == "-q") {
                    addBreakpointState(atoll(std::next(word)->c_str()));
                } else if (*word == "-l") {
                    SIZE_T nLine = atoll(std::next(word)->c_str());
                    addBreakpointLine(nLine);
                } else {
                    std::cout << "Warning: unrecognized breakpoints type. "
                                 "Awaited -q or "
                                 "-l. Given: "
                              << *word << std::endl;
                }
                break;
            case Command::RESTART:
                restart();
                break;
            default:
                std::cout << "Warning: command not supported: " << *word
                          << std::endl;
        }
    }

   public:
    Manager() : commands_(initCommands()) {}

    void processLine(const std::string& commandLine) {
        auto words = split(commandLine);
        processLine_impl(words);

        if (runner_) {
            std::cout << runner_->line();
            printState(*runner_);
        }
    }
};

void parseCommandArgs(int argc, char* argw[]) {
    SIZE_T nopts = 3;
    option* options = new option[nopts]{
        {.name = "use-binary-format", .has_arg = 0, .flag = NULL, .val = 'b'},
        {.name = "help", .has_arg = 0, .flag = NULL, .val = 'h'}};
    memset(&options[nopts - 1], 0, sizeof(option));

    int arg, longindex;
    while ((arg = getopt_long(argc, argw, "bh", options, &longindex)) != -1) {
        switch (arg) {
            case '?':
                logger::warning()
                    << "Unrecognized option: " << optarg << std::endl;
                break;
            case 'b':
                globals::useBinaryFormat = true;
                logger::info() << "Binary format to loading enabled";
                break;
            case 'h':
                std::cout << "flags b and h. see ost -h for details" << '\n';
                exit(0);
                break;
            default:
                logger::warning()
                    << "Given option: [" << char(arg) << "] can't be processed";
        }
    }
    delete[] options;
}

int main(int argc, char* argw[]) {
    globals::debugMode = true;
    if (argc < 2) {
        std::cerr << "No file name given!\n";
        return 1;
    }
    fileName = argw[1];
    logger::info() << "Loading file: " << fileName << "\n\n";
    parseCommandArgs(argc, argw);
    Manager manager;
    std::cout << preview;
    std::string line;

    while (!std::cin.eof()) {
        std::getline(std::cin, line);
        if (line == "help") {
            std::cout << preview;
            continue;
        }

        manager.processLine(line);
    }

    return 0;
}