lib/calculator/execute_one_instruction.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/stdio.h>
#include <lib/calculator.h>

// #define OPCODE_DEBUG 1


void
calculator::execute_one_instruction(void)
{
    //
    // <question>
    // How many instructions are executed per second?
    // </question>
    //
    // <question>
    // Do all instructions execute at the same speed?
    // We already know that PRINT (420ms) and FEED (290ms) take longer
    // than other opcodes.
    // </question>
    //
    location::pointer where = next_location();
    opcode_t op = (opcode_t)next_opcode();
#ifdef OPCODE_DEBUG
    fprintf(stderr, "%s: %d: addr %d, op '%s'\n", __FILE__,
        __LINE__, address - 1, opcode_name(op).c_str());
#endif
    assert(op < 128);
    switch (op)
    {
    case opcode_zero:
        if (address == wrap_address(0) + 1)
        {
            on_error("no program to execute");
            clock_tick_mode = clock_tick_mode_disabled;
            address = 0;
            break;
        }

        //
        // <question>
        // Does opcode $000 mean "goto 1" or does opcode $000 mean "skip 1"?
        // <p>
        // How to tell the difference:<br>
        // If I use the program bank selector switch, put a program in
        // bank I and a second program in bank II, then set the program
        // bank selector switch to I+II.  When the program is executed,
        // at the end of bank I (hitting a $000 opcode) does it goto
        // address 1, or does it execute the first opcode in bank II?
        // </question>
        //
        // Here we assume it means the first, rather than the second.
        //
        address = 0;
        break;

    case opcode_plus_equals:
    case opcode_minus_equals:
    case opcode_mul:
    case opcode_div:
    case opcode_sqrt:
        execute_as_normal:
        on_opcode_ope(op, where);
        break;

    case opcode_ent:
#if 1
        switch (mstate)
        {
        case mstate_reset:
            break;

        case mstate_lhs_digits_before_dot:
        case mstate_lhs_digits_after_dot:
            mstate = mstate_lhs_complete;
            break;

        case mstate_lhs_complete:
        case mstate_mul:
            break;

        case mstate_mul_digits_before_dot:
        case mstate_mul_digits_after_dot:
            mstate = mstate_mul_complete;
            break;

        case mstate_mul_complete:
            break;

        default:
            break;
        }
#endif
        clock_tick_mode = clock_tick_mode_entry;
        number_of_keys_since_ej = 0;
        break;

    case opcode_sj:
        clock_tick_mode = clock_tick_mode_sj;
        // Note: we have yet to read the jump flag byte.
        number_of_keys_since_ej = 0;
        break;

    case opcode_ej:
        clock_tick_mode = clock_tick_mode_ej;
        // Note: we have yet to read the jump flag byte.
        // <question>
        // If we have [2] [EJ] {flag} in a program, and execution
        // reaches the EJ opcode, does pressing [3] display "3" or "23"
        // or something else?
        // </question>
        number_of_keys_since_ej = 0;
        break;

    case opcode_mj:
        {
            unsigned char label = next_opcode();
            if (x_register < 0)
                address = find_flag_jump(label);
        }
        break;

    case opcode_uj:
        address = find_flag_jump(next_opcode());
        break;

    case opcode_fj:
        next_opcode();
        break;

    case opcode_suj:
        {
            // <question>
            // How deep is the subroutine call stack?
            // Or, to ask it another way, can you nest SUJ calls?
            // </question>
            unsigned char label = next_opcode();
            call_stack.push_back(address);
            address = find_subroutine_flag_jump(label);
        }
        break;

    case opcode_sfj:
        // Question: What happens when you SUJ to a non-existent SFJ?
        next_opcode();
        break;

    case opcode_srj:
        // Question: What happens when you SRJ but no subroutine was called?
        if (call_stack.empty())
        {
            on_error("returning from subroutine that was not called");
            clock_tick_mode = clock_tick_mode_disabled;
            break;
        }
        address = call_stack.back();
        call_stack.pop_back();
        break;

    case opcode_m1:
    case opcode_m2:
    case opcode_m3:
    case opcode_m4:
    case opcode_m5:
    case opcode_m6:
    case opcode_m7:
    case opcode_m8:
    case opcode_m9:
    case opcode_m10:
    case opcode_m11:
    case opcode_m12:
    case opcode_m13:
    case opcode_m14:
    case opcode_mm1:
    case opcode_mm2:
    case opcode_sm3:
    case opcode_sm4:
    case opcode_sm5:
    case opcode_sm6:
    case opcode_sm7:
    case opcode_sm8:
    case opcode_sm9:
    case opcode_sm10:
    case opcode_sm11:
    case opcode_sm12:
    case opcode_sm13:
    case opcode_sm14:
    case opcode_rm1:
    case opcode_rm2:
    case opcode_rm3:
    case opcode_rm4:
    case opcode_rm5:
    case opcode_rm6:
    case opcode_rm7:
    case opcode_rm8:
    case opcode_rm9:
    case opcode_rm10:
    case opcode_rm11:
    case opcode_rm12:
    case opcode_rm13:
    case opcode_rm14:
    case opcode_clear_indicator:
    case opcode_cm1:
    case opcode_cm2:
    case opcode_cm3:
    case opcode_cm4:
    case opcode_cm5:
    case opcode_cm6:
    case opcode_cm7:
    case opcode_cm8:
    case opcode_cm9:
    case opcode_cm10:
    case opcode_cm11:
    case opcode_cm12:
    case opcode_cm13:
    case opcode_cm14:
    case opcode_dot:
    case opcode_rv:
    case opcode_right:
    case opcode_chg_sign:
        goto execute_as_normal;

    case opcode_round_down:
        // FIXME: should we issue a warning if it isn't a number?
        // i.e. 0x70..0x7E
        precro_current =
            precision_and_rounding
            (
                next_opcode() & 15,
                precision_and_rounding::round_down
            );
        break;

    case opcode_round_off:
        // FIXME: should we issue a warning if it isn't a number?
        // i.e. 0x70..0x7E
        precro_current =
            precision_and_rounding
            (
                next_opcode() & 15,
                precision_and_rounding::round_off
            );
        break;

    case opcode_round_up:
        // FIXME: should we issue a warning if it isn't a number?
        // i.e. 0x70..0x7E
        precro_current =
            precision_and_rounding
            (
                next_opcode() & 15,
                precision_and_rounding::round_up
            );
        break;

    case opcode_print:
        {
            display value = x_register.get_display();
            value.set_opcode(op);
            update_display_lamps(value);
            derived_print(value);
        }
        break;

    case opcode_fd:
        derived_feed();
        break;

    case opcode_n0:
    case opcode_n1:
    case opcode_n2:
    case opcode_n3:
    case opcode_n4:
    case opcode_n5:
    case opcode_n6:
    case opcode_n7:
    case opcode_n8:
    case opcode_n9:
        goto execute_as_normal;

    case opcode_n10:
    case opcode_n11:
    case opcode_n12:
    case opcode_n13:
    case opcode_n14:
        // These opcodes cause an automatic overflow,
        // but we let on_opcode_ope generate the overflow.
        goto execute_as_normal;

    default:
        on_error("%03d '%s' can not be executed", address - 1,
            opcode_name(op).c_str());
        clock_tick_mode = clock_tick_mode_disabled;
        break;

    case opcode_extended_c:
    case opcode_extended_start:
    case opcode_extended_m3_tilde:
    case opcode_extended_sm3_tilde:
    case opcode_extended_rm3_tilde:
    case opcode_extended_cm3_tilde:
    case opcode_extended_off:
    case opcode_extended_program_print:
    case opcode_extended_display_print:
    case opcode_extended_paper_feed:
    case opcode_extended_rounding_switch_up:
    case opcode_extended_rounding_switch_off:
    case opcode_extended_rounding_switch_down:
    case opcode_extended_decimal_point_selector_0:
    case opcode_extended_decimal_point_selector_1:
    case opcode_extended_decimal_point_selector_2:
    case opcode_extended_decimal_point_selector_3:
    case opcode_extended_decimal_point_selector_4:
    case opcode_extended_decimal_point_selector_5:
    case opcode_extended_decimal_point_selector_6:
    case opcode_extended_decimal_point_selector_7:
    case opcode_extended_decimal_point_selector_8:
    case opcode_extended_decimal_point_selector_9:
    case opcode_extended_decimal_point_selector_10:
    case opcode_extended_decimal_point_selector_11:
    case opcode_extended_decimal_point_selector_12:
    case opcode_extended_decimal_point_selector_float:
    case opcode_extended_goto_000:
    case opcode_extended_goto_001:
    case opcode_extended_goto_002:
    case opcode_extended_goto_003:
    case opcode_extended_goto_004:
    case opcode_extended_goto_005:
    case opcode_extended_goto_006:
    case opcode_extended_goto_007:
    case opcode_extended_goto_008:
    case opcode_extended_goto_009:
    case opcode_extended_goto_010:
    case opcode_extended_goto_011:
    case opcode_extended_goto_012:
    case opcode_extended_goto_013:
    case opcode_extended_goto_014:
    case opcode_extended_goto_015:
    case opcode_extended_goto_100:
    case opcode_extended_goto_101:
    case opcode_extended_goto_102:
    case opcode_extended_goto_103:
    case opcode_extended_goto_104:
    case opcode_extended_goto_105:
    case opcode_extended_goto_106:
    case opcode_extended_goto_107:
    case opcode_extended_goto_108:
    case opcode_extended_goto_109:
    case opcode_extended_goto_110:
    case opcode_extended_goto_111:
    case opcode_extended_goto_112:
    case opcode_extended_goto_113:
    case opcode_extended_goto_114:
    case opcode_extended_goto_115:
    case opcode_extended_goto_200:
    case opcode_extended_goto_201:
    case opcode_extended_goto_202:
    case opcode_extended_goto_203:
    case opcode_extended_goto_204:
    case opcode_extended_goto_205:
    case opcode_extended_goto_206:
    case opcode_extended_goto_207:
    case opcode_extended_goto_208:
    case opcode_extended_goto_209:
    case opcode_extended_goto_210:
    case opcode_extended_goto_211:
    case opcode_extended_goto_212:
    case opcode_extended_goto_213:
    case opcode_extended_goto_214:
    case opcode_extended_goto_215:
    case opcode_extended_goto_300:
    case opcode_extended_goto_301:
    case opcode_extended_goto_302:
    case opcode_extended_goto_303:
    case opcode_extended_goto_304:
    case opcode_extended_goto_305:
    case opcode_extended_goto_306:
    case opcode_extended_goto_307:
    case opcode_extended_goto_308:
    case opcode_extended_goto_309:
    case opcode_extended_goto_310:
    case opcode_extended_goto_311:
    case opcode_extended_goto_312:
    case opcode_extended_goto_313:
    case opcode_extended_goto_314:
    case opcode_extended_goto_315:
    case opcode_extended_goto_400:
    case opcode_extended_goto_401:
    case opcode_extended_goto_402:
    case opcode_extended_goto_403:
    case opcode_extended_goto_404:
    case opcode_extended_goto_405:
    case opcode_extended_goto_406:
    case opcode_extended_goto_407:
    case opcode_extended_goto_408:
    case opcode_extended_goto_409:
    case opcode_extended_goto_410:
    case opcode_extended_goto_411:
    case opcode_extended_goto_412:
    case opcode_extended_goto_413:
    case opcode_extended_goto_414:
    case opcode_extended_goto_415:
    case opcode_extended_goto_500:
    case opcode_extended_goto_501:
    case opcode_extended_goto_502:
    case opcode_extended_goto_503:
    case opcode_extended_goto_504:
    case opcode_extended_goto_505:
    case opcode_extended_goto_506:
    case opcode_extended_goto_507:
    case opcode_extended_goto_508:
    case opcode_extended_goto_509:
    case opcode_extended_goto_510:
    case opcode_extended_goto_511:
    case opcode_extended_goto_512:
    case opcode_extended_goto_513:
    case opcode_extended_goto_514:
    case opcode_extended_goto_515:
    case opcode_extended_goto_600:
    case opcode_extended_goto_601:
    case opcode_extended_goto_602:
    case opcode_extended_goto_603:
    case opcode_extended_goto_604:
    case opcode_extended_goto_605:
    case opcode_extended_goto_606:
    case opcode_extended_goto_607:
    case opcode_extended_goto_608:
    case opcode_extended_goto_609:
    case opcode_extended_goto_610:
    case opcode_extended_goto_611:
    case opcode_extended_goto_612:
    case opcode_extended_goto_613:
    case opcode_extended_goto_614:
    case opcode_extended_goto_615:
    case opcode_extended_goto_700:
    case opcode_extended_goto_701:
    case opcode_extended_goto_702:
    case opcode_extended_goto_703:
    case opcode_extended_goto_704:
    case opcode_extended_goto_705:
    case opcode_extended_goto_706:
    case opcode_extended_goto_707:
    case opcode_extended_goto_708:
    case opcode_extended_goto_709:
    case opcode_extended_goto_710:
    case opcode_extended_goto_711:
    case opcode_extended_goto_712:
    case opcode_extended_goto_713:
    case opcode_extended_goto_714:
    case opcode_extended_goto_715:
        assert(!"can't happen");
        break;
    }
#ifdef OPCODE_DEBUG
    fprintf(stderr, "%s: %d: x = %.18Lg\n", __FILE__, __LINE__,
        x_register.get_floating());
#endif
}