canola/debugger/gnome.cc

Go to the documentation of this file.

//
// canola - canon canola 1614p emulator
// Copyright (C) 2011, 2012 Peter Miller
//
// This program is free software; you can redistribute it and/or modify
// it under the terms of the GNU General Public License, version 3, as
// published by the Free Software Foundation.
//
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
// General Public License for more details.
//
// You should have received a copy of the GNU General Public License along
// with this program. If not, see <http://www.gnu.org/licenses/>.
//

#include <lib/config.h>
#include <libexplain/fopen.h>

#include <lib/std_string_printf.h>

#include <canola/debugger/gnome.h>


debugger_gnome::~debugger_gnome()
{
}


static void
mono(Gtk::TextView &w)
{
    w.set_editable(false);

    Pango::FontDescription fdesc;
    fdesc.set_family("monospace");
    w.override_font(fdesc);

    // create a "red" tag so that we can use it later
    Glib::RefPtr<Gtk::TextTag> tp =
        w.get_buffer()->create_tag("red");
    tp->property_foreground().set_value("red");
}


debugger_gnome::debugger_gnome() :
    x_reg_name("X Register:"),
    y_reg_name("Y Register:"),
    address_name("Address:"),
    address_value(Gtk::Adjustment::create(1, 1, 240, 1)),
    address_value_changed_signal_enable(false),
    address_value_changed_signal_instance(),
    opcode_name("Opcode:"),
    mstate_name("State:")
{
    const int spacing = 20;

    left_panel.set_row_spacings(1);

    for (int j = 0; j < 14; ++j)
    {
        std::string text = std_string_printf("Memory %d:", j + 1);
        memory_name[j].set_text(text);
    }

    left_panel.attach(address_name,  0, 1, 0, 1);
    left_panel.attach(address_value, 1, 2, 0, 1);
    address_name.set_alignment(Gtk::ALIGN_START);
    address_value.set_wrap();
    address_value.set_numeric();
    address_value.signal_value_changed().connect
    (
        sigc::mem_fun(*this, &debugger_gnome::on_address_value_changed)
    );

    left_panel.attach(opcode_name,   0, 1, 1, 2);
    left_panel.attach(opcode_value,  1, 2, 1, 2);
    opcode_name.set_alignment(Gtk::ALIGN_START);
    mono(opcode_value);
    opcode_value.set_size_request(100, -1);

    left_panel.attach(x_reg_name,    0, 1, 2, 3);
    left_panel.attach(x_reg_value,   1, 2, 2, 3);
    mono(x_reg_value);
    x_reg_name.set_alignment(Gtk::ALIGN_START);

    left_panel.attach(y_reg_name,    0, 1, 3, 4);
    left_panel.attach(y_reg_value,   1, 2, 3, 4);
    mono(y_reg_value);
    y_reg_name.set_alignment(Gtk::ALIGN_START);

    left_panel.attach(mstate_name,   0, 1, 4, 5);
    left_panel.attach(mstate_value,  1, 2, 4, 5);
    mono(mstate_value);
    mstate_name.set_alignment(Gtk::ALIGN_START);

    for (int j = 0; j < 14; ++j)
    {
        left_panel.attach(memory_name[j],  0, 1, 5 + j, 6 + j);
        left_panel.attach(memory_value[j], 1, 2, 5 + j, 6 + j);
        mono(memory_value[j]);
        memory_name[j].set_alignment(Gtk::ALIGN_START);
    }
    mono(source_code);
    source_code_scroller.add(source_code);
    source_code_scroller.set_policy(Gtk::POLICY_AUTOMATIC,
        Gtk::POLICY_AUTOMATIC);
    source_code_frame.add(source_code_scroller);

    pack_start(left_panel, Gtk::PACK_SHRINK);
    pack_start(source_code_frame);
    set_spacing(spacing);

    set_border_width(spacing);
    show_all_children();

    address_value_changed_signal_enable = true;
}


static void
red_number(Gtk::TextView &tv, const std::string &text)
{
    tv.get_buffer()->set_text("");
    tv.get_buffer()->insert_with_tag(tv.get_buffer()->end(), text, "red");
}


static void
black_number(Gtk::TextView &tv, const std::string &text)
{
    tv.get_buffer()->set_text(text);
}


static void
textview_number(Gtk::TextView &tv, const number &value)
{
    if (value.sign() < 0)
        red_number(tv, value.to_string());
    else
        black_number(tv, value.to_string());
}


void
debugger_gnome::display_x_register(const number &value)
{
    textview_number(x_reg_value, value);
}


void
debugger_gnome::display_y_register(const number &value)
{
    textview_number(y_reg_value, value);
}


void
debugger_gnome::display_memory(int num, const number &value)
{
    assert(num >= 1);
    assert(num <= 14);
    if (value == 0)
        memory_value[num - 1].get_buffer()->set_text("");
    else
        textview_number(memory_value[num - 1], value);
}


void
debugger_gnome::display_address(int n)
{
    address_value_changed_signal_enable = false;
    address_value.set_range((n ? 1 : 0), 240);
    address_value.set_value(n);
    address_value.update();  // needed?
    address_value_changed_signal_enable = true;
}


void
debugger_gnome::on_address_value_changed(void)
{
    if (address_value_changed_signal_enable)
    {
        int n = address_value.get_value_as_int();
        address_value_changed_signal_instance.emit(n);
    }
}


debugger_gnome::address_value_changed_signal_t &
debugger_gnome::address_value_changed_signal(void)
{
    return address_value_changed_signal_instance;
}


void
debugger_gnome::display_opcode(opcode_t op)
{
    std::string text = opcode_raw_name(op);
    if (opcode_valid(op))
        black_number(opcode_value, text + " " + ::opcode_name(op));
    else
        red_number(opcode_value, text);
}


static std::string
basename(const std::string &filename)
{
    const char *slash = strrchr(filename.c_str(), '/');
    if (!slash)
        return filename;
    return std::string(slash + 1);
}


void
debugger_gnome::display_location(const location::pointer &loc)
{
    if (!loc)
        return;
    if (filename != loc->get_filename())
    {
        // Maybe we could use a tabbed window and display more than one
        // source file, as needed.  Could happen if they use include
        // files (e.g. for standard subroutines).  However, experience
        // says this isn't a huge problem (the files are tiny compared
        // to modern source files).
        filename = loc->get_filename();
        Glib::RefPtr<Gtk::TextBuffer> tb = source_code.get_buffer();
        tb->set_text("");

        // read the entire contents of the file into the source code text view
        FILE *fp = fopen(filename.c_str(), "r");
        if (!fp)
        {
            tb->set_text(explain_fopen(filename.c_str(), "r"));
            return;
        }

        for (;;)
        {
            char buffer[4096];
            size_t n = fread(buffer, 1, sizeof(buffer), fp);
            if (!n)
                break;
            tb->insert(tb->end(), buffer, buffer + n);
        }
        fclose(fp);
    }

    {
        std::string num = std_string_printf(": %d", loc->get_line_number());
        source_code_frame.set_label(basename(loc->get_filename()) + num);
    }

    // highlight the text
    Glib::RefPtr<Gtk::TextBuffer> tb = source_code.get_buffer();
    Gtk::TextIter lo = tb->get_iter_at_offset(loc->get_start());
    Gtk::TextIter hi = tb->get_iter_at_offset(loc->get_end());
    tb->place_cursor(hi);
    tb->select_range(lo, hi);

    // scroll the highlighted text onto the display
    source_code.scroll_to(lo);
}


void
debugger_gnome::display_mstate(const char *text)
{
    mstate_value.get_buffer()->set_text(text);
}