lib/calculator.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/ac/math.h>
#include <lib/ac/stdio.h>
#include <lib/ac/string.h>
#include <libexplain/output.h>

#include <lib/calculator.h>
#include <lib/interpose/learn.h>
#include <lib/interpose/ope.h>
#include <lib/interpose/ope_che.h>
#include <lib/interpose/pro_che.h>
#include <lib/interpose/stateful.h>


calculator::~calculator()
{
}


calculator::calculator() :
    mstate(mstate_reset),
    x_register(),
    y_register(),
    program_selector(program_selector_i_ii),
    address(0),
    program_mode(program_mode_operation),
    deferred_action(deferred_action_none),
    clock_tick_mode(clock_tick_mode_disabled),
    printer_delay_active(false),
    accumulate_mode(false),
    constant_mode(false),
    constant_mode_action(deferred_action_none),
    strict_memory_number_checking(true),
    number_of_keys_since_ej(0)
{
    interpose_by_program_mode[program_mode_learn] =
        interpose_stateful::create(interpose_learn::create(this));
    interpose_by_program_mode[program_mode_operation] =
        interpose_stateful::create(interpose_ope::create(this), true);
    interpose_by_program_mode[program_mode_program_check] =
        interpose_stateful::create(interpose_pro_che::create(this));
    interpose_by_program_mode[program_mode_operation_check] =
        interpose_stateful::create(interpose_ope_che::create(this), true);

    memset(programme, 0, sizeof(programme));
}


const char *
calculator::mstate_name(mstate_t ms)
{
    switch (ms)
    {
    case mstate_reset:
        return "mstate_reset";

    case mstate_lhs_digits_before_dot:
        return "mstate_lhs_digits_before_dot";

    case mstate_lhs_digits_after_dot:
        return "mstate_lhs_digits_after_dot";

    case mstate_lhs_complete:
        return "mstate_lhs_complete";

    case mstate_mul:
        return "mstate_mul";

    case mstate_mul_digits_before_dot:
        return "mstate_mul_digits_before_dot";

    case mstate_mul_digits_after_dot:
        return "mstate_mul_digits_after_dot";

    case mstate_mul_complete:
        return "mstate_mul_complete";

    default:
        return "???";
    }
}


const char *
calculator::program_mode_name(program_mode_t os)
{
    switch (os)
    {
    case program_mode_learn:
        return "LRN";

    case program_mode_operation:
        return "OPE";

    case program_mode_program_check:
        return "PRO CHE";

    case program_mode_operation_check:
        return "OPE CHE";

    default:
        return "unknown";
    }
}


calculator::program_selector_t
calculator::program_selector_get(void)
    const
{
    return program_selector;
}


void
calculator::program_selector_set(program_selector_t ps)
{
    program_selector = ps;
    switch (program_selector)
    {
    default:
    case program_selector_i_ii:
        break;

    case program_selector_i:
        // <question>
        // In LRN mode, with the Program Selector Switch is set to "I+II",
        // if the display address is more than 121, what happends if the
        // Program Selector Switch is set to "I"?  Does the address change?
        // If so, to what?
        // </question>
        if (address > 120)
            address = 0;
        break;

    case program_selector_ii:
        // <question>
        // In LRN mode, with the Program Selector Switch is set to "I+II",
        // if the display address is less than 120, what happends if the
        // Program Selector Switch is set to "II"?  Does the address change?
        // If so, to what?
        // </question>
        if (address < 121)
            address = 0;
        break;
    }
    update_display();
}


void
calculator::on_error(const char *fmt, ...)
{
    va_list ap;
    va_start(ap, fmt);
    on_error_v(fmt, ap);
    va_end(ap);
}


void
calculator::program_mode_set(program_mode_t pm)
{
    if (program_mode == pm)
        return;
    program_mode = pm;
    switch (program_mode)
    {
    case program_mode_learn:
        break;

    case program_mode_operation:
        // See the Instruction Manual, p. 45
        address = 0;
        x_register = 0;
        y_register = 0;
        mstate = mstate_reset;
        break;

    case program_mode_program_check:
        break;

    case program_mode_operation_check:
        address = 0;
        x_register = 0;
        y_register = 0;
        mstate = mstate_reset;
        break;

    default:
        assert(!"this is strange");
        break;
    }
    update_display();
}


calculator::program_mode_t
calculator::program_mode_get(void)
{
    return program_mode;
}


void
calculator::on_opcode(opcode_t op, const location::pointer &where)
{
    assert(interpose_by_program_mode[program_mode]);
    interpose_by_program_mode[program_mode]->on_opcode(op, where);
    update_display();
}


unsigned
calculator::wrap_address(unsigned addr)
    const
{
    switch (program_selector)
    {
    case program_selector_i_ii:
    default:
        if (addr < 1 || addr > 240)
            return 1;
        break;

    case program_selector_i:
        if (addr < 1 || addr > 120)
            return 1;
        break;

    case program_selector_ii:
        if (addr < 121 || addr > 240)
            return 121;
        break;
    }
    return addr;
}


unsigned char
calculator::next_opcode(void)
{
    if (!address)
        address = wrap_address(address);
    // FIXME: skip NUL bytes, but avoid infinite loop when programme is empty.
    unsigned char op = programme[address];
    address = wrap_address(address + 1);
    return op;
}


location::pointer
calculator::next_location(void)
    const
{
    int addr = address;
    if (!addr)
        addr = wrap_address(addr);
    return programme_location[addr];
}


unsigned
calculator::find_flag_jump(unsigned char label)
{
    // Question: If executing in bank II, does UJ find FJ in bank I?
    //
    // The Instruction Manual seems to say this, p. 54:
    //
    //     "Consequently, where two programs A and B are simultaneously
    //     stored, care should be exercised to avoid using a receiver
    //     (Flag for Jump) identical to that of program A stored in I
    //     position, when makeing program B which is to be stored in II
    //     position."
    //
    // FIXME: The physical calculator really did look for labels this
    // way, but it had a slow clock speed for this.  We should think
    // about emulating that delay.
    //
    unsigned lo = 1;
    unsigned hi = 240;

    //
    // Instruction Manual, p. 54, says:
    //
    //     "A jump is accomplished to the smallest step as viewed from
    //     the 1st step regardless of the linear sequence of steps or
    //     specifications such as the Program Selector Switch."
    //
    // Which makes this code a bit suspect, because it DOES honor the
    // Program Selector Switch.
    //
    // Question: does UJ ignore the Program Select Switch when looking for FJ?
    //
    switch (program_selector)
    {
    case program_selector_i_ii:
    default:
        break;

    case program_selector_i:
        hi = 120;
        break;

    case program_selector_ii:
        lo = 121;
        break;
    }

    //
    // <question>
    // When searching for a FJ label, how many steps can it scan per
    // second?  The Instruction Manual says distant jumps are slower,
    // but how much slower?
    // </question>
    //
    for (unsigned n = lo; n <= hi; ++n)
    {
        if (programme[n] == opcode_fj && programme[n + 1] == label)
        {
            // Instruction Manual, p. 54, use the first flag you find.
            return (n + 2);
        }
    }

    //
    // It does no exist.  The Instruction Manual, p.53, says to treat
    // this as a jump to the first instruction.
    //
    // We will issue a warning, just to be friendly-like.
    //
    on_error
    (
        "flag jump %s not found, destination address %d used by default",
        opcode_raw_name((opcode_t)label).c_str(),
        lo
    );
    return lo;
}


unsigned
calculator::find_subroutine_flag_jump(unsigned char label)
{
    // FIXME: The physical calculator really did look for labels this
    // way, but it had a slow clock speed for this.  We should think
    // about emulating that delay.
    unsigned lo = 1;
    unsigned hi = 240;
    switch (program_selector)
    {
    case program_selector_i_ii:
    default:
        break;

    case program_selector_i:
        hi = 120;
        break;

    case program_selector_ii:
        lo = 121;
        break;
    }
    for (unsigned n = lo; n <= hi; ++n)
    {
        if (programme[n] == opcode_sfj && programme[n + 1] == label)
        {
            return (n + 2);
        }
    }

    //
    // It does no exist.  The manual (somewhere) says to treat this as a
    // jump to the first instruction.
    //
    // We will issue a warning, just to be friendly-like.
    //
    on_error
    (
        "subroutine flag jump %s not found, destination address %d used "
            "by default",
        opcode_raw_name((opcode_t)label).c_str(),
        lo
    );
    return lo;
}


void
calculator::clock_tick_event(void)
{
    //
    // If the printer has yet to finish printing the last line it was
    // given to print, we can't proceed.
    //
    if (printer_delay_active)
        return;

    switch (program_mode)
    {
    case program_mode_learn:
        // ignore
        clock_tick_mode = clock_tick_mode_disabled;
        break;

    case program_mode_operation:
        switch (clock_tick_mode)
        {
        case clock_tick_mode_disabled:
            break;

        case clock_tick_mode_running:
            execute_one_instruction();
            break;

        case clock_tick_mode_entry:
        case clock_tick_mode_sj:
        case clock_tick_mode_ej:
        default:
            break;
        }
        update_display();
        break;

    case program_mode_program_check:
    case program_mode_operation_check:
    default:
        clock_tick_mode = clock_tick_mode_disabled;
        break;
    }
}


bool
calculator::clock_tick_expected(void)
    const
{
    return (clock_tick_mode == clock_tick_mode_running);
}


void
calculator::precision_and_rounding_set(const precision_and_rounding &value)
{
    precro_front_panel = value;
    precro_current = value;
}


const precision_and_rounding &
calculator::precision_and_rounding_get(void)
    const
{
    return precro_front_panel;
}


bool
calculator::printer_finished_event_expected(void)
    const
{
    return printer_delay_active;
}


void
calculator::printer_finished_event(void)
{
    printer_delay_active = false;
}


bool
calculator::accumulate_mode_get(void)
    const
{
    return accumulate_mode;
}


void
calculator::accumulate_mode_set(bool value)
{
    accumulate_mode = value;
}


void
calculator::constant_mode_set(bool value)
{
    constant_mode = value;
}


static std::string
downcase(const std::string &text)
{
    std::string result;
    const char *s = text.c_str();
    for (;;)
    {
        unsigned char c = *s++;
        if (!c)
            return result;
        if (isupper(c))
            c = tolower(c);
        result += c;
    }
}


void
calculator::property(const std::string &name, const std::string &value)
{
    properties.insert(properties_t::value_type(downcase(name), value));
}


bool
calculator::strict_memory_number_checking_required(void)
    const
{
    return strict_memory_number_checking;
}


void
calculator::strict_memory_number_checking_set(bool value)
{
    strict_memory_number_checking = value;
}


// vim: set ts=8 sw=4 et :