test_calculator/calculator/test.cc

Go to the documentation of this file.

//
// canola - canon canola 1614p emulator
// Copyright (C) 2011 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/output.h>
#include <libexplain/printf.h>
#include <libexplain/putchar.h>

#include <lib/std_string_printf.h>

#include <test_calculator/calculator/test.h>


calculator_test::~calculator_test()
{
}


calculator_test::calculator_test()
{
}


calculator::pointer
calculator_test::create(void)
{
    return pointer(new calculator_test());
}


void
calculator_test::derived_print(const display &value)
{
    class cursor_t
    {
    public:
        cursor_t() : icol(1), ocol(1) { };

        void
        putch(char c)
        {
            if (c == ' ')
                ++icol;
            else
            {
                while (ocol < icol)
                {
                    putchar(' ');
                    ++ocol;
                }
                putchar(c);
                ++icol;
                ocol = icol;
            }
        }

        void
        putstr(const char *s)
        {
            for (;;)
            {
                char c = *s++;
                if (!c)
                    return;
                putch(c);
            }
        }

        void
        set_column(int n)
        {
            assert(n > 17);
            if (n > icol)
                icol = n;
        }

        void
        putch(int col, char c)
        {
            set_column(col);
            putch(c);
        }

        void
        putstr(int col, const char *s)
        {
            set_column(col);
            putstr(s);
        }
    private:
        int icol;
        int ocol;
    };
    cursor_t cursor;

    for (int dignum = 15; dignum >= 0; --dignum)
    {
        const display::tube_t &tube = value.tubes[dignum];
        if (tube.digit >= 10)
            cursor.putch(' ');
        else
            cursor.putch('0' + tube.digit);
        if (tube.dot)
            cursor.putch('.');
    }
    if (value.negative)
    {
        cursor.set_column(18);
        cursor.putch('-');
    }
    switch (value.column18)
    {
    case display::column18_blank:
        break;

    case display::column18_minus:
        if (!value.negative)
            cursor.putch(18, '-');
        break;

    case display::column18_ce:
        cursor.putstr(18, "CE");
        break;

    case display::column18_cm:
        cursor.putstr(18, "CM");
        break;

    case display::column18_e:
        cursor.putch(18, 'E');
        break;

    case display::column18_fj:
        cursor.putstr(18, "FJ");
        break;

    case display::column18_ej:
        cursor.putstr(18, "EJ");
        break;

    case display::column18_uj:
        cursor.putstr(18, "UJ");
        break;

    case display::column18_mj:
        cursor.putstr(18, "MJ");
        break;

    case display::column18_sj:
        cursor.putstr(18, "SJ");
        break;

    case display::column18_rv:
        cursor.putstr(18, "RV");
        break;

    case display::column18_sfj:
        cursor.putstr(18, "SFJ");
        break;

    case display::column18_suj:
        cursor.putstr(18, "SUJ");
        break;

    case display::column18_srj:
        cursor.putstr(18, "SRJ");
        break;

    case display::column18_right:
        cursor.putstr(18, "\u2192");
        break;

    case display::column18_cs:
        cursor.putstr(18, "CS");
        break;

    default:
        break;
    }
    switch (value.column19)
    {
    case display::column19_blank:
        break;

    case display::column19_plus_equals:
        cursor.putstr(19, "+=");
        break;

    case display::column19_minus_equals:
        cursor.putstr(19, "-=");
        break;

    case display::column19_times:
        cursor.putstr(19, "\u00D7");
        break;

    case display::column19_divide:
        cursor.putstr(19, "\u00F7");
        break;

    case display::column19_sqrt:
        cursor.putstr(19, "\u221A");
        break;

    case display::column19_m_plus:
        cursor.putstr(19, "M+");
        break;

    case display::column19_m_minus:
        cursor.putstr(19, "M-");
        break;

    case display::column19_rm:
        cursor.putstr(19, "RM");
        break;

    case display::column19_sm:
        cursor.putstr(19, "SM");
        break;

    case display::column19_print:
        cursor.putstr(19, "\u25CA");
        break;

    default:
        break;
    }
    switch (value.column20)
    {
    case display::column20_blank:
        break;

    case display::column20_n1:
        cursor.putch(20, '1');
        break;

    case display::column20_fd:
        cursor.putstr(20, "FD");
        break;

    case display::column20_round_up:
        cursor.putstr(20, "\u2191");
        break;

    case display::column20_round_off:
        cursor.putstr(20, "5/4");
        break;

    case display::column20_round_down:
        cursor.putstr(20, "\u2193");
        break;

    case display::column20_dot:
        cursor.putstr(20, ".");
        break;

    default:
        break;
    }
    switch (value.column21)
    {
    case display::column21_blank:
        break;

    case display::column21_n0:
    case display::column21_n1:
    case display::column21_n2:
    case display::column21_n3:
    case display::column21_n4:
    case display::column21_n5:
    case display::column21_n6:
    case display::column21_n7:
    case display::column21_n8:
    case display::column21_n9:
        cursor.putch(21, '0' + value.column21 - display::column21_n0);
        break;

    default:
        break;
    }
    explain_putchar_or_die('\n');
}


void
calculator_test::derived_feed(void)
{
    explain_putchar_or_die('\n');
}


void
calculator_test::on_error_v(const char *fmt, va_list ap)
{
    std::string text = std_string_printf_v(fmt, ap);
    explain_output_error_and_die("%s", text.c_str());
}


void
calculator_test::run(void)
{
    // finish running any program
    for (;;)
    {
        if (printer_finished_event_expected())
            printer_finished_event();
        else if (clock_tick_expected())
            clock_tick_event();
        else
            break;
    }
}


void
calculator_test::derived_off(void)
{
    exit(0);
}


void
calculator_test::derived_update_display(const display &)
{
}


void
calculator_test::clock_tick_start_running(void)
{
}


void
calculator_test::printer_timer_start_running(void)
{
}


void
calculator_test::on_opcode(opcode_t op, const location::pointer &where)
{
    calculator::on_opcode(op, where);

    // they could have "pressed" START
    // let it run for a few thousand instructions
    for (int j = 0; j < 5000; ++j)
    {
        if (printer_finished_event_expected())
            printer_finished_event();
        else if (clock_tick_expected())
            clock_tick_event();
        else
            break;
    }
}