Subversion Repositories riscv_vhdl

/**

 * @file

 * @copyright  Copyright 2016 GNSS Sensor Ltd. All right reserved.

 * @author     Sergey Khabarov - sergeykhbr@gmail.com

 * @brief      Memory Editor area.

 */

#include "MemArea.h"

#include "moc_MemArea.h"

#include <memory>

#include <string.h>

#include <QtWidgets/QBoxLayout>

#include <QtWidgets/QLabel>

namespace debugger {

MemArea::MemArea(IGui *gui, QWidget *parent, uint64_t addr, uint64_t sz)

    : QPlainTextEdit(parent) {

    igui_ = gui;

    reqAddr_ = addr;

    reqBytes_ = sz;

    cmdRead_.make_string("read 0x80000000 20");

    data_.make_data(0);

    tmpBuf_.make_data(1024);

    dataText_.make_string("");

    waitingResponse_ = false;

    clear();

    QFont font("Courier");

    font.setStyleHint(QFont::Monospace);

    font.setPointSize(8);

    font.setFixedPitch(true);

    setFont(font);

    QFontMetrics fm(font);

    setMinimumWidth(20 + fm.width(tr("[0011223344556677]: 11 22 33 44 55 66 77 88 ")));

    ensureCursorVisible();

    connect(this, SIGNAL(signalUpdateData()), this, SLOT(slotUpdateData()));

    slotUpdateByTimer();

}

MemArea::~MemArea() {

    igui_->removeFromQueue(static_cast<IGuiCmdHandler *>(this));

}

void MemArea::slotAddressChanged(AttributeType *cmd) {

    reqAddr_ = (*cmd)[0u].to_uint64();

    reqBytes_ = static_cast<unsigned>((*cmd)[1].to_int());

}

void MemArea::slotUpdateByTimer() {

    char tstr[128];

    if (waitingResponse_) {

        waitingResponse_ = true;

    }

    RISCV_sprintf(tstr, sizeof(tstr), "read 0x%08" RV_PRI64 "x %d",

                                        reqAddr_, reqBytes_);

    cmdRead_.make_string(tstr);

    reqAddrZ_ = reqAddr_;

    reqBytesZ_ = reqBytes_;

    igui_->registerCommand(static_cast<IGuiCmdHandler *>(this),

                            &cmdRead_, true);

}

void MemArea::slotUpdateData() {

    moveCursor(QTextCursor::End);

    moveCursor(QTextCursor::Start, QTextCursor::KeepAnchor);

    QTextCursor cursor = textCursor();

    cursor.insertText(tr(dataText_.to_string()));

    update();

}

void MemArea::handleResponse(AttributeType *req, AttributeType *resp) {

    bool changed = false;

    waitingResponse_ = false;

    if (resp->is_nil()) {

        return;

    }

    if (resp->size() != data_.size()) {

        changed = true;

    } else {

        for (unsigned i = 0; i < resp->size(); i++) {

            if ((*resp)(i) != data_(i)) {

                changed = true;

                break;

            }

        }

    }

    if (!changed) {

        return;

    }

    data_ = *resp;

    to_string(reqAddrZ_, data_.size(), &dataText_);

    emit signalUpdateData();

}

void MemArea::to_string(uint64_t addr, unsigned bytes, AttributeType *out) {

    const uint64_t MSK64 = 0x7ull;

    uint64_t addr_start, addr_end, inv_i;

    addr_start = addr & ~MSK64;

    addr_end = (addr + bytes + 7) & ~MSK64;

    /** Each 8 bytes of data requires 44 bytes in string [addr]: .. ..

        Let it be 64 bytes per 8 bytes of data

     */

    if (tmpBuf_.size() < 8 * data_.size()) {

        tmpBuf_.make_data(8 * data_.size());

    }

    int strsz = 0;

    int  bufsz = tmpBuf_.size();

    char *strbuf = reinterpret_cast<char *>(tmpBuf_.data());

    for (uint64_t i = addr_start; i < addr_end; i++) {

        if ((i & MSK64) == 0) {

            // Output address:

            strsz += RISCV_sprintf(&strbuf[strsz], bufsz - strsz,

                                "[%016" RV_PRI64 "x]: ", i);

        }

        inv_i = (i & ~MSK64) | (MSK64 - (i & MSK64));

        if ((addr <= inv_i) && (inv_i < (addr + bytes))) {

            strsz += RISCV_sprintf(&strbuf[strsz], bufsz - strsz,

                                    " %02x", data_(inv_i - addr));

        } else {

            strsz += RISCV_sprintf(&strbuf[strsz], bufsz - strsz, " ..");

        }

        if ((i & MSK64) == MSK64) {

            strsz += RISCV_sprintf(&strbuf[strsz], bufsz - strsz, "\n");

        }

    }

    out->make_string(strbuf);

}

}  // namespace debugger