Subversion Repositories riscv_vhdl

/*

 *  Copyright 2018 Sergey Khabarov, sergeykhbr@gmail.com

 *

 *  Licensed under the Apache License, Version 2.0 (the "License");

 *  you may not use this file except in compliance with the License.

 *  You may obtain a copy of the License at

 *

 *      http://www.apache.org/licenses/LICENSE-2.0

 *

 *  Unless required by applicable law or agreed to in writing, software

 *  distributed under the License is distributed on an "AS IS" BASIS,

 *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.

 *  See the License for the specific language governing permissions and

 *  limitations under the License.

 */

#include <string.h>

#include "autocompleter.h"

#include "coreservices/ithread.h"

namespace debugger {

/** Class registration in the Core */

REGISTER_CLASS(AutoCompleter)

AutoCompleter::AutoCompleter(const char *name)

    : IService(name) {

    registerInterface(static_cast<IAutoComplete *>(this));

    registerAttribute("History", &history_);

    registerAttribute("HistorySize", &history_size_);

    registerAttribute("SocInfo", &socInfo_);

    socInfo_.make_string("");

    history_.make_list(0);

    history_size_.make_int64(4);

    history_idx_ = 0;

    cmdLine_ = "";

    carretPos_ = 0;

}

AutoCompleter::~AutoCompleter() {

}

void AutoCompleter::postinitService() {

    history_idx_ = history_.size();

}

bool AutoCompleter::processKey(uint32_t qt_key,

                                AttributeType *cmd,

                                AttributeType *cursor) {

    bool add_symbol = false;

    bool isNewLine = false;

    bool set_history_end = true;

    if (!cursor->is_list() || cursor->size() != 2) {

        cursor->make_list(2);

        (*cursor)[0u].make_int64(0);

        (*cursor)[1].make_int64(0);

    }

    switch (qt_key) {

    case KB_Up:

        set_history_end = false;

        if (history_idx_ == history_.size()) {

            unfinshedLine_ = cmdLine_;

        }

        if (history_idx_ > 0) {

            history_idx_--;

        }

        cmdLine_ = std::string(history_[history_idx_].to_string());

        break;

    case KB_Down:

        set_history_end = false;

        if (history_idx_ == (history_.size() - 1)) {

            history_idx_++;

            cmdLine_ = unfinshedLine_;

        } else if (history_idx_ < (history_.size() - 1)) {

            history_idx_++;

            cmdLine_ = std::string(history_[history_idx_].to_string());

        }

        break;

    case KB_Left:

        if (carretPos_ < cmdLine_.size()) {

            carretPos_++;

        }

        break;

    case KB_Right:

        if (carretPos_ > 0) {

            carretPos_--;

        }

        break;

    case KB_Backspace:// 1. Backspace button:

        if (cmdLine_.size() && carretPos_ == 0) {

            cmdLine_.erase(cmdLine_.size() - 1);

        } else if (cmdLine_.size() && carretPos_ < cmdLine_.size()) {

            std::string t1 = cmdLine_.substr(0, cmdLine_.size() - carretPos_ - 1);

            cmdLine_ = t1 + cmdLine_.substr(cmdLine_.size() - carretPos_, carretPos_);

        }

        break;

    case KB_Return:// 2. Enter button:

        isNewLine = true;

        break;

    case 0:

        break;

    case KB_Shift:

    case KB_Control:

    case KB_Alt:

        break;

    case KB_Dot:

        qt_key = '.';

        add_symbol = true;

        break;

    default:

        add_symbol = true;

    }

    if (add_symbol) {

        if (carretPos_ == 0) {

            cmdLine_ += static_cast<uint8_t>(qt_key);

        } else if (carretPos_ == cmdLine_.size()) {

            std::string t1;

            t1 += static_cast<uint8_t>(qt_key);

            cmdLine_ = t1 + cmdLine_;

        } else {

            std::string t1 = cmdLine_.substr(0, cmdLine_.size() - carretPos_);

            t1 += static_cast<uint8_t>(qt_key);

            cmdLine_ = t1 + cmdLine_.substr(cmdLine_.size() - carretPos_, carretPos_);

        }

    }

    cmd->make_string(cmdLine_.c_str());

    if (isNewLine) {

        if (cmdLine_.size()) {

            addToHistory(cmdLine_.c_str());

            cmdLine_.clear();

        }

        carretPos_ = 0;

    }

    (*cursor)[0u].make_int64(carretPos_);

    (*cursor)[1].make_int64(carretPos_);

    if (set_history_end) {

        history_idx_ = history_.size();

    }

    return isNewLine;

}

void AutoCompleter::addToHistory(const char *cmd) {

    unsigned found = history_.size();

    for (unsigned i = 0; i < history_.size(); i++) {

        if (strcmp(cmd, history_[i].to_string()) == 0) {

            found = i;

            break;

        }

    }

    if (found  ==  history_.size()) {

        AttributeType t1;

        t1.make_string(cmd);

        history_.add_to_list(&t1);

        unsigned min_size = static_cast<unsigned>(history_size_.to_int64());

        if (history_.size() >= 2*min_size) {

            history_.trim_list(0, min_size);

        }

    } else if (found < (history_.size() - 1)) {

        history_.swap_list_item(found, history_.size() - 1);

    }

    history_idx_ = history_.size();

}

}  // namespace debugger