lib/calculator/on_opcode_ope.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>


void
calculator::maybe_accumulate(void)
{
    if (accumulate_mode)
    {
        memory[1] += x_register;
        precro_current.apply(memory[1]);
        if (memory[1].has_overflowed())
        {
            // Question: Does program execution stop if M1 overflows?
            clock_tick_mode = clock_tick_mode_disabled;
            // x_register = number::infinity();
            on_error("Memory 1 has overflowed");
        }
    }
}


void
calculator::constant_mode_eval(bool neg)
{
    // Instruction Manual, p. 10
    switch (constant_mode_action)
    {
    default:
        assert(!"unknown deferred action");
    case deferred_action_none:
        x_register = 0;
        clock_tick_mode = clock_tick_mode_disabled;
        on_error
        (
            "No constant operation has been supplied.  You need to "
            "perform at least one multiplication or division first."
        );
        break;

    case deferred_action_multiplication:
        x_register *= constant_mode_rhs;
        break;

    case deferred_action_division:
        if (constant_mode_rhs == 0)
        {
            x_register = number::infinity();
            clock_tick_mode = clock_tick_mode_disabled;
            on_error("Division by zero");
        }
        else
        {
            x_register /= constant_mode_rhs;
        }
        break;
    }
    if (neg)
        x_register = -x_register;
}


void
calculator::non_constant_mode_eval(bool neg)
{
    if (neg)
        x_register = y_register - x_register;
    else
        x_register += y_register;
}


void
calculator::eval(bool neg)
{
    if (constant_mode)
        constant_mode_eval(neg);
    else
        non_constant_mode_eval(neg);
}


void
calculator::eval_mul(bool neg)
{
    switch (deferred_action)
    {
    default:
        assert(!"unkown deferred action");
        break;

    case deferred_action_none:
        assert(!"this isn't supposed to happen");
        break;

    case deferred_action_multiplication:
        if (constant_mode)
        {
            // Instruction Manual, p. 10
            //
            // Yes, we are supposed to use the Y register, I checked.  Making
            // this asymmetric with division seems harder to implement, and
            // harder for the user to remember.
            // I wonder why they did it that way?
            constant_mode_rhs = y_register;
            constant_mode_action = deferred_action;
            // Question: Is the K constant negative when you use [-=] ?
            // ...probably not, considering the example on p. 32.
        }
        if (y_register == 0)
        {
            // Instruction Manual, p. 29.
            //
            // "Note: the operation a x b += RV recalls b instead of a,
            // only when a is zero."
            y_register = x_register;
            x_register = 0;
        }
        else
        {
            x_register *= y_register;
        }
        if (x_register.has_overflowed())
            clock_tick_mode = clock_tick_mode_disabled;
        else if (neg)
            x_register = -x_register;
        break;

    case deferred_action_division:
        if (constant_mode)
        {
            // Instruction Manual, p. 10
            constant_mode_rhs = x_register;
            constant_mode_action = deferred_action;
            // Question: What does "[K] 2 [X] 3 [-=] 5 [+=]" display?
        }
        if (x_register == 0)
        {
            x_register = number::infinity();
            clock_tick_mode = clock_tick_mode_disabled;
            on_error("Division by zero");
        }
        else
        {
            x_register = y_register / x_register;
            if (x_register.has_overflowed())
                clock_tick_mode = clock_tick_mode_disabled;
            else if (neg)
                x_register = -x_register;
        }
        break;
    }
}


void
calculator::on_opcode_ope(opcode_t op, const location::pointer &)
{
    bool neg = false;
    if (op < 128)
        ++number_of_keys_since_ej;
    switch (op)
    {
    case opcode_zero:
        assert(!"this isn't supposed to be possible");
        break;

    case opcode_plus_equals:
        plus_equals:
        switch (mstate)
        {
        default:
            assert(!"not supposed to happen");

        case mstate_reset:
            // Example: [C] [+=]
            // Example: [RM1] [2] [+=] [+=]
            eval(neg);
            // The example on p.30 of the Instruction Manual is
            // accurate.  The [AM1] key only applies to multiply and
            // divide, but not addition nor subtraction.
            maybe_accumulate();
            // <question>
            // When in AM1 mode, is the x-register rounded before or
            // after adding it to M1?
            // </question>
            break;

        case mstate_lhs_digits_before_dot:
            // Example: [C] [5] [+=]
            // Example: [RM1] [2] [+=]
            eval(neg);
            maybe_accumulate();
            break;

        case mstate_lhs_digits_after_dot:
            // Example: [C] [.] [5] [+=]
            // Example: [RM1] [.] [2] [+=]
            eval(neg);
            maybe_accumulate();
            break;

        case mstate_lhs_complete:
            // Example: [C] [RM9] [+=]
            // Example: [C] [2] [sqrt] [+=]
            // Example: [RM1] [RM2] [+=]
            eval(neg);
            maybe_accumulate();
            break;

        case mstate_mul:
            // Example: [C] [4] [mul] [+=]
            // Example: "[C] [5] [+=] [7] [X] [+=]" displays 49
            // Example: "[C] [5] [+=] [7] [X] [+=] [RV]" displays 7
            //
            // Example: "[RM1] [X] [RM2] [RM9] [+=]" displays 21
            // when m1=2 m2=3 m9=7
        case mstate_mul_digits_before_dot:
            // Example: [4] [mul] [5] [+=]
        case mstate_mul_digits_after_dot:
            // Example: [4] [mul] [.] [5] [+=]
        case mstate_mul_complete:
            // Example: [4] [mul] [RM1] [+=]
            eval_mul(neg);
#if 1
            // The examples on p.25 says this *does* happen.
            // Question: Do the examples on Instruction Mananual p.25 work?
            maybe_accumulate();
#else
            // The example on p.30 says this does *not* happen.
            // The p.30 example is confirmed as accurate.
            //
            // Is there something subtlely different in those examples
            // that I'm missing?
#endif
            break;
        }

        // Do any rounding required.
        precro_current.apply(x_register);
        precro_current = precro_front_panel;

        deferred_action = deferred_action_none;
        mstate = mstate_reset;
        break;

    case opcode_minus_equals:
        neg = true;
        // Example: "[K] [2] [x] [3] [-=] [4] [+=]" displays 8
        // If it is negative, then [-=] is sugar for [CS] [+=]
        // and the neg local vaiable is not required.
        goto plus_equals;

    case opcode_mul:
        // See Instruction Manual, p. 21, for example.
        switch (mstate)
        {
        default:
            assert(!"unknown mstate");

        case mstate_reset:
            // Example: [C] [1] [+=] [2] [+=] [X]
            y_register = x_register;
            mstate = mstate_mul;
            break;

        case mstate_lhs_digits_before_dot:
            // Example: [C] [7] [X]
            // Example: [C] [RM1] [2] [X]
            y_register = x_register;
            mstate = mstate_mul;
            break;

        case mstate_lhs_digits_after_dot:
            // Example: [C] [.] [7] [X]
            // Example: [C] [RM1] [.] [2] [X]
            y_register = x_register;
            mstate = mstate_mul;
            break;

        case mstate_lhs_complete:
            // Example: [RM1] [X]
            // Example: [C] [RM1] [RM2] [X]
            y_register = x_register;
            mstate = mstate_mul;
            break;

        case mstate_mul:
            // Example: [C] [3] [div] [X]
            // Calculator Instruction Manual, p. 22
            // sort-of changing our mind
            deferred_action = deferred_action_multiplication;
            break;

        case mstate_mul_digits_before_dot:
            // Example: [C] [2] [X] [3] [X]
        case mstate_mul_digits_after_dot:
            // Example: [C] [2] [X] [.] [3] [X]
        case mstate_mul_complete:
            // Example: [C] [2] [X] [RM9] [X]
            switch (deferred_action)
            {
            default:
                assert(!"unknown deferred action");
                break;

            case deferred_action_none:
                assert(!"not supposed to happen");
                break;

            case deferred_action_multiplication:
                x_register *= y_register;

                if (x_register.has_overflowed())
                    clock_tick_mode = clock_tick_mode_disabled;
                break;

            case deferred_action_division:
                if (x_register == 0)
                {
                    x_register = number::infinity();
                    clock_tick_mode = clock_tick_mode_disabled;
                    on_error("Division by zero");
                }
                else
                {
                    // Note: we do not adjust decimal places yet
                    // Instruction Manual, p. 22
                    x_register = y_register / x_register;

                    if (x_register.has_overflowed())
                        clock_tick_mode = clock_tick_mode_disabled;
                }
            }
            // no rounding here
            y_register = x_register;
            mstate = mstate_mul;
            break;
        }
        deferred_action = deferred_action_multiplication;
        break;

    case opcode_div:
        switch (mstate)
        {
        default:
            assert(!"unknown mstate");

        case mstate_reset:
            // Example: [C] [1] [+=] [2] [+=] [div]
            y_register = x_register;
            mstate = mstate_mul;
            break;

        case mstate_lhs_digits_before_dot:
            // Example: [C] [7] [div]
            // Example: [C] [RM1] [2] [div]
            y_register = x_register;
            mstate = mstate_mul;
            break;

        case mstate_lhs_digits_after_dot:
            // Example: [C] [.] [7] [div]
            // Example: [C] [RM1] [.] [2] [div]
            y_register = x_register;
            mstate = mstate_mul;
            break;

        case mstate_lhs_complete:
            // Example: [RM1] [div]
            // Example: [C] [RM1] [RM2] [div]
            y_register = x_register;
            mstate = mstate_mul;
            break;

        case mstate_mul:
            // Example: [C] [3] [X] [div]
            // Calculator Instruction Manual, p. 22
            // sort-of changing our mind
            deferred_action = deferred_action_division;
            break;

        case mstate_mul_digits_before_dot:
            // Example: [C] [2] [X] [3] [div]
        case mstate_mul_digits_after_dot:
            // Example: [C] [2] [X] [.] [3] [div]
        case mstate_mul_complete:
            // Example: [C] [2] [X] [RM9] [div]
            switch (deferred_action)
            {
            default:
                assert(!"unknown deferred action");
                break;

            case deferred_action_none:
                assert(!"not supposed to happen");
                break;

            case deferred_action_multiplication:
                x_register *= y_register;
                if (x_register.has_overflowed())
                    clock_tick_mode = clock_tick_mode_disabled;
                break;

            case deferred_action_division:
                if (x_register == 0)
                {
                    x_register = number::infinity();
                    clock_tick_mode = clock_tick_mode_disabled;
                    on_error("Division by zero");
                }
                else
                {
                    // Note: we do not adjust decimal places yet
                    // Instruction Manual, p. 22
                    x_register = y_register / x_register;

                    if (x_register.has_overflowed())
                        clock_tick_mode = clock_tick_mode_disabled;
                }
                break;
            }
            // no rounding here
            y_register = x_register;
            mstate = mstate_mul;
            break;
        }
        deferred_action = deferred_action_division;
        break;

    case opcode_sqrt:
        // This is tricky.  Does sqrt also set y_register to zero? one?
        switch (mstate)
        {
        case mstate_reset:
            // Example: [1] [+=] [2] [+=] [sqrt]
            mstate = mstate_lhs_complete;
            break;

        case mstate_lhs_digits_before_dot:
            // Example: [C] [2] [sqrt]
            // Example: [RM2] [3] [sqrt]
            mstate = mstate_lhs_complete;
            break;

        case mstate_lhs_digits_after_dot:
            // Example: [C] [.] [2] [sqrt]
            // Example: [RM2] [.] [3] [sqrt]
            mstate = mstate_lhs_complete;
            break;

        case mstate_lhs_complete:
            // Example: [C] [RM2] [sqrt]
            // Example: [RM2] [RM9] [sqrt]
            mstate = mstate_lhs_complete;
            break;

        case mstate_mul:
            // Example: [7] [X] [sqrt]
            //
            // Example:
            //     Canola in the Classroom, p.10
            //     [CI] 2.7 [X] [sqrt] [+=] displays 1.643167672515492
            //     ...it is as if the [X] never happened
            //     how can this be right?
            //
            // Example: "[C] 1 [+=] 9 [x] [sqrt] [+=]" displays 3
            // Wow, that's weird.  Either
            // (a) the deferred [X] was discarded, and y_register set to zero,
            // (b) the deferred [X] was retained, and y_register set to 1.
            // Either way, it sure looks like [sqrt] messes with y_register.
            //
            // Question: What does "[C] 2 [sqrt] [RV]" display?
            // Question: What does "[C] 3 [+M1] [C] [RM1] 2 [sqrt] [RV]" dispay?
            //
            mstate = mstate_lhs_complete;
            break;

        case mstate_mul_digits_before_dot:
            // Example: [2] [X] [3] [sqrt]
            mstate = mstate_lhs_complete;
            break;

        case mstate_mul_digits_after_dot:
            // Example: [2] [X] [.] [3] [sqrt]
            mstate = mstate_lhs_complete;
            break;

        case mstate_mul_complete:
            // Example: [2] [X] [RM9] [sqrt]
            mstate = mstate_lhs_complete;
            break;

        default:
            assert(!"unknown mstate");
        }

        // Instruction Manual, p. 24
        x_register = x_register.sqrt();
#if 1
        // Example: "7 +M1 +M1 C 2 X 3 sqrt RM1 +=" displays 15.73205...
        // Thus, we see that the deferred multiply is reset by [sqrt].
        y_register = 0;
        deferred_action = deferred_action_none;
#else
        y_register = 1;
#endif
        // Question: Does the [sqrt] key clear the K constant?
        // This seems likely, as it will need all 3 registers for the
        // calculation... which is why it nukes y_register.

        // The sqrt operation ignores the rounding switch.
        // Where did I see that in the Manual?
        //
        // It also has some error in more than one of the least significant
        // digits, which may explain why it ignores the rounding switch.
        //
        precro_current.apply(x_register);
        precro_current = precro_front_panel;
        break;

    case opcode_ent:
        not_valid_here:
        on_error
        (
            "'%s' is not valid in Program Mode %s",
            opcode_name(op).c_str(),
            program_mode_name(program_mode)
        );
        // stop the clock
        clock_tick_mode = clock_tick_mode_disabled;
        break;

    case opcode_sj:
        switch (clock_tick_mode)
        {
        case clock_tick_mode_sj:
            address = find_flag_jump(next_opcode());
            clock_tick_mode = clock_tick_mode_running;
            clock_tick_start_running();
            break;

        case clock_tick_mode_entry:
            // See instruction manual, p. 49.
            // Weird.
            address = 0;
            clock_tick_mode = clock_tick_mode_running;
            clock_tick_start_running();
            break;

        case clock_tick_mode_disabled:
        case clock_tick_mode_running:
        case clock_tick_mode_ej:
        default:
            // Example: [SJ] is ignored in OPE mode.
            goto not_valid_here;
        }
        break;

    case opcode_ej:
    case opcode_mj:
        // These are taken care of in calculator::execute_one_instruction().
        goto not_valid_here;

    case opcode_uj:
        // This is taken care of in interpose_stateful
        //
        // <question>
        // In OPE mode, with a program running, what happens when the UJ
        // key is pressed?  I've seen suggestions that this will halt
        // execution.  Does execution stop immediately, or does it wait
        // for the second key?
        // </question>
        goto not_valid_here;

    case opcode_fj:
    case opcode_suj:
    case opcode_sfj:
    case opcode_srj:
        // These are taken care of in calculator::execute_one_instruction().
        goto not_valid_here;

    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:
        // Example: "[1] [2] [+M1] [3]" displays 3
        // Example: "[1] [2] [+M1] [3] [RV]" displays 12
        {
            unsigned n = op - (opcode_m1 - 1);
            memory[n] += x_register;
            if (memory[n].has_overflowed())
            {
                // Question: Does program executuion stop if [+M9] overflows?
                // Question: Does program executuion stop if [-M2] overflows?
                clock_tick_mode = clock_tick_mode_disabled;
                // x_register = number::infinity();
                on_error("Memory %d has overflowed", n);
            }
            switch (mstate)
            {
            case mstate_reset:
                // Example: [C] [RM1] [RM2] [+=] [+M1]
                mstate = mstate_lhs_complete;
                break;

            case mstate_lhs_digits_before_dot:
                // Example: [C] 1 [+M1]
                // Example: [RM2] 2 [+M1]
                mstate = mstate_lhs_complete;
                break;

            case mstate_lhs_digits_after_dot:
                // Example: [C] 1.2 [+M1]
                //
                // Example: [RM2] .3 [+M1]
                // Question: What does "1 m2 m2 c rm2 .3 m1 2 +=" display?
                //    if 2.3, we are OK
                //    if 0.32, we shouldn't have changed state
                mstate = mstate_lhs_complete;
                break;

            case mstate_lhs_complete:
                // Example: [C] 2 [sqrt] [+M1]
                // Example: [RM2] [RM9] [+M1]
                break;

            case mstate_mul:
                // Example: 5 [x] [+M1]
                // Example: "[5] [x] [m1] [2] [+=]" displays 10
                break;

            case mstate_mul_digits_before_dot:
                // Example: 5 [x] 6 [+M1]
                // Example: "[5] [x] [6] [m1] [2] [+=]" displays 12
                mstate = mstate_mul_complete;
                break;

            case mstate_mul_digits_after_dot:
                // Example: 5 [x] 0.6 [+M1]
                // Example: "5 [x] 0.6 [+M1] 2 [+=]" displays 1.2
                mstate = mstate_mul_complete;
                break;

            case mstate_mul_complete:
                // Example: 5 [x] 2 [sqrt] [+M1]
                break;

            default:
                assert(!"unknown mstate");
                break;
            }
        }
        break;

    case opcode_mm1:
    case opcode_mm2:
        // Example: "[1] [2] [-M1] [3]" displays 3
        {
            unsigned n = op - (opcode_mm1 - 1);
            memory[n] -= x_register;
            if (memory[n].has_overflowed())
            {
                clock_tick_mode = clock_tick_mode_disabled;
                // x_register = number::infinity();
                on_error("Memory %d has overflowed", n);
            }
            switch (mstate)
            {
            case mstate_reset:
                // Example: [C] 3 [+=] 2 [+=] [-M1]
                mstate = mstate_lhs_complete;
                // The alternative is to leave it in mstate_reset,
                // the two are indistinguishable, afaict.
                break;

            case mstate_lhs_digits_before_dot:
                // Example: [C] 2 [-M1]
                // Example: [RM2] 2 [-M1]
                // Example: "[CM2] [RM2] 2 [-M2] 3 [+=]" displays 5
                mstate = mstate_lhs_complete;
                break;

            case mstate_lhs_digits_after_dot:
                // Example: [C] .2 [-M1]
                // Example: "[c] [.] [2] [-M1] [3] [+=]" displays 3.2
                // Example: [RM2] .3 [-M1]
                // Example: "[CM2] [RM2] .3 [-M2] 4 [+=]" displays 4.3
                mstate = mstate_lhs_complete;
                break;

            case mstate_lhs_complete:
                // Example: [C] 2 [sqrt] [-M1]
                // Example: [RM2] [RM9] [-M1]
                break;

            case mstate_mul:
                // Example: 5 [x] [-M1]
                // Question: What does [5] [x] [-m1] [3] [+=] display?
                //     If 15, we are ok.
                break;

            case mstate_mul_digits_before_dot:
                // Example: 5 [x] 6 [-M1]
                // Example: "[5] [x] [6] [mm2] [2] [+=]" displays 12
                mstate = mstate_mul_complete;
                break;

            case mstate_mul_digits_after_dot:
                // Example: 5 [x] 0.6 [-M1]
                // Example: "[5] [x] [.] [6] [mm2] [2] [+=]" displays 1.2
                mstate = mstate_mul_complete;
                break;

            case mstate_mul_complete:
                // Example: 5 [x] 2 [sqrt] [-M1]
                break;

            default:
                assert(!"unknown mstate");
                break;
            }
        }
        break;

    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:
        // Question: What does [1] [2] [SM9] [3] display?
        {
            unsigned n = op - (opcode_sm3 - 3);
            memory[n] = x_register;
            if (memory[n].has_overflowed())
            {
                clock_tick_mode = clock_tick_mode_disabled;
                // x_register = number::infinity();
                on_error("Memory %d has overflowed", n);
            }
            switch (mstate)
            {
            case mstate_reset:
                // Example: [C] 3 [+=] 2 [+=] [SM9]
                mstate = mstate_lhs_complete;
                break;

            case mstate_lhs_digits_before_dot:
                // Example: [C] 2 [SM9]
                // Question: What does "[C] [2] [SM5] [4]" display?
                // Example: [RM2] 2 [SM9]
                mstate = mstate_lhs_complete;
                break;

            case mstate_lhs_digits_after_dot:
                // Example: [C] .2 [SM9]
                // Example: [RM2] .3 [SM9]
                // Question: What does "[RM2] .3 [SM9] 4" display?
                mstate = mstate_lhs_complete;
                break;

            case mstate_lhs_complete:
                // Example: [C] [2] [sqrt] [SM9]
                // Question: What does "[C] [2] [sqrt] [SM9] [3]" display?
                // Example: [RM2] [RM9] [SM4]
                break;

            case mstate_mul:
                // Example: 5 [x] [SM9]
                mstate = mstate_mul_complete;
                break;

            case mstate_mul_digits_before_dot:
                // Example: 5 [x] 6 [SM9]
                // Question: What does "5 [x] 6 [SM9] [7] [+=]" display?
                mstate = mstate_mul_complete;
                break;

            case mstate_mul_digits_after_dot:
                // Example: 5 [x] 0.6 [SM9]
                // Question: What does "5 [x] 0.6 [SM9] 7 [+=]" display?
                mstate = mstate_mul_complete;
                break;

            case mstate_mul_complete:
                // Example: 5 [x] 2 [sqrt] [SM9]
                // Question: What does "5 [x] 2 [sqrt] [SM9] 7 [+=]" display?
                break;

            default:
                assert(!"unknown mstate");
                break;
            }
        }
        break;

    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:
        switch (mstate)
        {
        case mstate_reset:
            // Example: [C] [2] [+=] [3] [+=] [RM1]
            mstate = mstate_lhs_complete;
            break;

        case mstate_lhs_digits_before_dot:
            // Example: [C] [1] [+=] [2] [RM1]
            // Example: "7 [+M1] [c] 1 [+=] 2 [RM1] [+=]" displays 9
            // Example: [RM1] [2] [RM9]
            // Question: What does "3 +M1 C 5 SM9 c RM1 2 RM9 +=" display?
            mstate = mstate_lhs_complete;
            break;

        case mstate_lhs_digits_after_dot:
            // Example: [C] [.] [2] [RM1]
            // Example: "7 [+M1] [C] 1 [+=] .2 [RM1] [+=]" displays 7.2
            // Example: [RM1] [.] [2] [RM9]
            // Question: What does "3 +M1 C 5 SM9 C RM1 .2 RM9 +=" display?
            mstate = mstate_lhs_complete;
            break;

        case mstate_lhs_complete:
            // Example: [C] [RM1] [RM2]
            //
            // FIXME: Instruction Manual reference?  While this is
            // implied by the Instruction Manual, I don't expect it to
            // be explicitly stated anywhere.
            //
            // Example: "[7] [+M1] [C] 13 [RM1] [RV]" displays 13
            // Example: [RM1] [RM2] [RM9]
            break;

        case mstate_mul:
            // Example: [2] [X] [RM1]
            mstate = mstate_mul_complete;
            break;

        case mstate_mul_digits_before_dot:
            // Example: [2] [X] [3] [RM1]
            // Example: "7 [+M1] [+M1] [C] 2 [X] 3 [RM1] [+=]" displays 42
            mstate = mstate_mul_complete;
            break;

        case mstate_mul_digits_after_dot:
            // Example: [2] [X] [.] [3] [RM1]
            // Example: "7 [+M1] [+M1] [C] 2 [X] .3 [RM1] [+=]" displays 4.2
            mstate = mstate_mul_complete;
            break;

        case mstate_mul_complete:
            // Example: [2] [X] [3] [sqrt] [RM1]
            // Example: "7 +M1 +M1 C 2 X 3 sqrt RM1 +=" displays 15.73205...
            // Thus, we see that the deferred multiply is reset by [sqrt].
            mstate = mstate_mul_complete;
            break;

        default:
            assert(!"unknown mstate");
            break;
        }
        y_register = x_register;
        x_register = memory[op - (opcode_rm1 - 1)];
        break;

    case opcode_clear_indicator:
        switch (mstate)
        {
        case mstate_reset:
            // Example: [C] [3] [+=] [CI]
            // Example: "c 3 += ci 4 +=" displays 4
            // Example: "c 3 += ci 4 rv" displays 0
            //
            // This is a tough case.  There are several possibilities:
#if 0
            // 1. Do nothing.  We are already at a place that will
            //    start a new number.  This probably doesn't match
            //    expectations.
            break;
#endif
#if 0
            // 2. Pretend a zero has been pressed.  This means copying
            //    x_register to y_register, as pressing zero would.
            //    This makes the best sense arithmetically, a best
            //    preserves the "I entered the wrong number" concept.
            y_register = x_register;
            x_register = 0;
            mstate = mstate_lhs_digits_before_dot;
            break;
#endif
            // 3. Zero the x_register, but don't copy x_register to
            //    y_register.  This is truly stupid (a) which is likely
            //    for silicon of this era, and (b) actually matches some
            //    implied uses cases in the documentation where using
            //    [CI] in the right place *effectively* clears both
            //    x_register and y_register, in this case by having the
            //    next digit pressed tranfer zero into the y_register.
            x_register = 0;
            break;

        case mstate_lhs_digits_before_dot:
            // Example: [C] [3] [+=] [4] [CI]
            //
            // The difficulty here (and the next 2 cases) is that if we go back
            // to mstate_reset it will cause the x_register to be copied to the
            // y_register *again* which will give the wrong answer when [+=] is
            // subsequently pressed.
            //
            // Example: [RM1] [2] [CI]
            // Example: "[RM1] [2] [CI]" displays 0
            x_register = 0;

            // Example: "[RM1] [2] [CI] [3] [+=]" displays 3
            //
            // Well, I *think* this is what this example means.
            mstate = mstate_lhs_complete;
            // Question: What does "7 [M1] [C] [RM1] [2] [CI] [3] [RV]" display?
            //
            // <question>
            // What does "7 [M1] [C] [RM1] [2] [CI] [3] [RV] [RV]" display?
            // </question>
            break;

        case mstate_lhs_digits_after_dot:
            // Example: [C] [3] [+=] [.] [4] [CI]
            // Example: [RM1] [.] [2] [CI]
            x_register = 0;
            mstate = mstate_lhs_complete;
            break;

        case mstate_lhs_complete:
            // Example: [C] [3] [+=] [2] [sqrt] [CI]
            // Example: [RM1] [2] [sqrt] [CI]
            // Example: "[RM1] [2] [sqrt] [CI]" displays 0
            // Example: "[RM1] [2] [sqrt] [CI] [3] [+=]" displays 3
            x_register = 0;
            break;

        case mstate_mul:
            // Example: [C] [2] [X] [CI]
            x_register = 0;
            break;

        case mstate_mul_digits_before_dot:
            // Example: [C] [2] [X] [3] [CI]
            // Example: "12 [x] 34 [ci]" displays 0
            // Question: What does "12 [x] 34 [ci] 56 [+=]" display?
            x_register = 0;
            mstate = mstate_mul;
            break;

        case mstate_mul_digits_after_dot:
            // Example: [C] [2] [X] [.] [3] [CI]
            // Example: "[C] [2] [X] [.] [3] [CI] 4" displays 4
            // Question: What does "[C] [2] [X] [.] [3] [CI] 4 [RV]" display?
            x_register = 0;
            mstate = mstate_mul;
            break;

        case mstate_mul_complete:
            // Example: [C] [2] [X] [RM9] [CI]
            x_register = 0;
            mstate = mstate_mul;
            break;

        default:
            assert(!"unknown mstate");
            break;
        }
        break;

    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:
        // Example: "[1] [2] [CM1] [3]" displays 123
        memory[op - (opcode_cm1 - 1)] = 0;
        break;

    case opcode_dot:
        switch (mstate)
        {
        case mstate_reset:
            // Example: [C] [.] entering a fraction
            y_register = x_register;
            x_register = 0;
            mstate = mstate_lhs_digits_after_dot;
            break;

        case mstate_lhs_digits_before_dot:
            // Example: [C] [2] [.]
            // Example: [RM1] [RM2] [2] [.]
            mstate = mstate_lhs_digits_after_dot;
            break;

        case mstate_lhs_digits_after_dot:
            // Example: [C] [2] [.] [3] [.]
            // Example: [RM1] [RM2] [2] [.] [3] [.]
            // This *has* been confirmed by a real 1614P.
            // Just move the decimal point to the rigth hand side.
            x_register.insert_dot();
            break;

        case mstate_lhs_complete:
            // Example: [RM1] [.] entering a fraction
            // Example: [RM1] [RM2] [.] entering a fraction
            y_register = x_register;
            x_register = 0;
            mstate = mstate_lhs_digits_after_dot;
            break;

        case mstate_mul:
            // Example: [RM1] [X] [.] entering a fraction
            x_register = 0;
            mstate = mstate_mul_digits_after_dot;
            break;

        case mstate_mul_digits_before_dot:
            // Example: [RM1] [2] [.]
            mstate = mstate_mul_digits_after_dot;
            break;

        case mstate_mul_digits_after_dot:
            // Example: 7 [x] [.] [2] [.]
            // This *has* been confirmed by a real 1614P.
            // Just move the decimal point to the rigth hand side.
            x_register.insert_dot();
            break;

        case mstate_mul_complete:
            // Example: [2] [X] [3] [sqrt] [.]
            // Example: "[2] [X] [3] [sqrt] [.] [2] [RV]" displays 1.732...
            y_register = x_register;
            x_register = 0;
            mstate = mstate_mul_digits_after_dot;
            break;

        default:
            assert(!"unknown mstate");
            break;
        }
        break;

    case opcode_rv:
        {
            number temp = x_register;
            x_register = y_register;
            y_register = temp;

            switch (mstate)
            {
            case mstate_reset:
                // Example: [C] 1 [+=] 2 [+=] [RV]
                mstate = mstate_lhs_complete;
                break;

            case mstate_lhs_digits_before_dot:
                // Example: [C] [1] [+=] [2] [RV]
                // Example: [RM1] 2 [RV]
                mstate = mstate_lhs_complete;
                break;

            case mstate_lhs_digits_after_dot:
                // Example: [C] [1] [+=] [2] [.] [1] [RV]
                // Example: [RM1] .3 [RV]
                mstate = mstate_lhs_complete;
                break;

            case mstate_lhs_complete:
                // Example:[C] 1 [+=] [RM1] [RV]
                // Example: [RM1] [RM2] [RV]
                break;

            case mstate_mul:
                // Example: [c] [2] [div] [RV]
                mstate = mstate_mul_complete;
                break;

            case mstate_mul_digits_before_dot:
                // Example: [RM1] 2 [div] 3 [RV]
                mstate = mstate_mul_complete;
                break;

            case mstate_mul_digits_after_dot:
                // Example: [RM1] 2 [div] .3 [RV]
                mstate = mstate_mul_complete;
                break;

            case mstate_mul_complete:
                // Example: [2] [X] [3] [sqrt] [RV]
                break;

            default:
                assert(!"unknown mstate");
                break;
            }
        }
        break;

    case opcode_right:
        // Confirmed by an actial 1614P:
        //
        //     123.45 "->" 123.4 "->" 123. "->" 12. "3" 12.3
        //
        // This example shows the state machine does NOT change any
        // "after dot" states into "before dot" states.
        x_register.right_shift();
        break;

    case opcode_chg_sign:
        // This has no effect on the mstate.
        // This was confirmed by using an actual 1614P.
        x_register = -x_register;
        break;

    case opcode_round_down:
    case opcode_round_off:
    case opcode_round_up:
    case opcode_print:
    case opcode_fd:
        // These are taken care of in calculator::execute_one_instruction().
        goto not_valid_here;

    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:
        switch (mstate)
        {
        default:
            assert(!"unknown mstate");
        case mstate_reset:
            // Example: [C] [1]
            y_register = x_register;
            x_register = 0;
            mstate = mstate_lhs_digits_before_dot;
            // fall through...

        case mstate_lhs_digits_before_dot:
            // Example: [C] [1] [2]
            // Example: [RM1] [2] [3]
            x_register.insert_digit_before_dot(op - opcode_n0);
            break;

        case mstate_lhs_digits_after_dot:
            // Example: [C] [1] [.]
            // Example: [RM1] [2] [.] [3]
            x_register.insert_digit_after_dot(op - opcode_n0);
            break;

        case mstate_lhs_complete:
            // Example: [9] [sqrt] [8]
            // Example: "[C] [9] [sqrt] [8] [+=]" displays 11
            // Example: [RM1] [RM2] [3]
            y_register = x_register;
            x_register = 0;
            x_register.insert_digit_before_dot(op - opcode_n0);
            mstate = mstate_lhs_digits_before_dot;
            break;

        case mstate_mul:
            // Example: [3] [X] [2]
            x_register = 0;
            mstate = mstate_mul_digits_before_dot;
            x_register.insert_digit_before_dot(op - opcode_n0);
            break;

        case mstate_mul_digits_before_dot:
            // Example: [3] [X] [2] [1]
            x_register.insert_digit_before_dot(op - opcode_n0);
            break;

        case mstate_mul_digits_after_dot:
            // Example: [3] [X] [.] [1]
            x_register.insert_digit_after_dot(op - opcode_n0);
            break;

        case mstate_mul_complete:
            // Example: "[3] [X] [2] [m1] [7] +=" displays 14
            y_register = x_register;
            x_register = 0;
            x_register.insert_digit_before_dot(op - opcode_n0);
            mstate = mstate_mul_digits_before_dot;
            // i.e. don't forget the [X], but the left hand side shifts down
            break;
        }
        if (x_register.has_overflowed())
        {
            clock_tick_mode = clock_tick_mode_disabled;
            on_error("Too many digits in number");
        }
        break;

    case opcode_n10:
    case opcode_n11:
    case opcode_n12:
    case opcode_n13:
    case opcode_n14:
        // These opcodes cause an immediate overflow.
        // This has been confirmed by a real 1614P.
        x_register = number::infinity();
        clock_tick_mode = clock_tick_mode_disabled;
        on_error("'%s' is not a valid numeric digit",  opcode_name(op).c_str());
        break;

    case opcode_extended_c:
        x_register = 0;
        y_register = 0;
        mstate = mstate_reset;
        deferred_action = deferred_action_none;
        address = 0;
        clock_tick_mode = clock_tick_mode_disabled;
        call_stack.clear();

        // Note: The [C] key clears the [K] constant value.
        constant_mode_action = deferred_action_none;
        constant_mode_rhs = 0;

        // Note: the [C] key does NOT clear overflowed memory locations.
        break;

    case opcode_extended_start:
        start:
        switch (clock_tick_mode)
        {
        case clock_tick_mode_disabled:
            clock_tick_mode = clock_tick_mode_running;
            clock_tick_start_running();
            break;

        case clock_tick_mode_running:
        default:
            // ignore
            break;

        case clock_tick_mode_entry:
            clock_tick_mode = clock_tick_mode_running;
            switch (mstate)
            {
            default:
                assert(!"unknown mstate");

            case mstate_reset:
                break;

            case mstate_lhs_digits_before_dot:
                mstate = mstate_lhs_complete;
                goto start_key_implies_print;

            case mstate_lhs_digits_after_dot:
                mstate = mstate_lhs_complete;
                goto start_key_implies_print;

            case mstate_lhs_complete:
                mstate = mstate_lhs_complete;
                // See the Printer Unit Instruction Manual, p. 11
                //
                // FIXME: It isn't that simple, see the Instruction manual,
                // p. 45.  It would appear that any calculation performed also
                // counts as entry for the purposes of "entry".
                start_key_implies_print:
                derived_print(x_register.get_display());
                break;

            case mstate_mul:
                break;

            case mstate_mul_digits_before_dot:
                mstate = mstate_mul_complete;
                goto start_key_implies_print;

            case mstate_mul_digits_after_dot:
                mstate = mstate_mul_complete;
                goto start_key_implies_print;

            case mstate_mul_complete:
                mstate = mstate_mul_complete;
                goto start_key_implies_print;
            }
            clock_tick_start_running();
            break;

        case clock_tick_mode_sj:
            next_opcode();
            clock_tick_mode = clock_tick_mode_running;
            clock_tick_start_running();
            break;

        case clock_tick_mode_ej:
            {
                unsigned char label = next_opcode();
                if (number_of_keys_since_ej > 0)
                {
                    // Make sure on_opcode_ope_che() matches this code.
                    derived_print(x_register.get_display());
                    address = find_flag_jump(label);
                    // <question>
                    // Does the ENT opcode terminate numeric entry, or
                    // can add digits?
                    // </question>
                    //
                    // <question>
                    // Does the EJ opcode terminate numeric entry, or
                    // can add digits?
                    // </question>
                }
                clock_tick_mode = clock_tick_mode_running;
                clock_tick_start_running();
            }
            break;
        }
        break;

    case opcode_extended_m3_tilde:
    case opcode_extended_sm3_tilde:
    case opcode_extended_rm3_tilde:
    case opcode_extended_cm3_tilde:
        goto not_valid_here;

    case opcode_extended_off:
        derived_off();
        break;

    case opcode_extended_program_print:
        program_print();
        break;

    case opcode_extended_display_print:
        // Question: What does "[1] [.] [2] [DrintDisp] [3]" do?
        derived_print(x_register.get_display());
        break;

    case opcode_extended_paper_feed:
        derived_feed();
        break;

    case opcode_extended_rounding_switch_up:
        precision_and_rounding_set
        (
            precision_and_rounding
            (
                precision_and_rounding_get().get_precision(),
                precision_and_rounding::round_up
            )
        );
        break;

    case opcode_extended_rounding_switch_off:
        precision_and_rounding_set
        (
            precision_and_rounding
            (
                precision_and_rounding_get().get_precision(),
                precision_and_rounding::round_off
            )
        );
        break;

    case opcode_extended_rounding_switch_down:
        precision_and_rounding_set
        (
            precision_and_rounding
            (
                precision_and_rounding_get().get_precision(),
                precision_and_rounding::round_down
            )
        );
        break;

    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:
        precision_and_rounding_set
        (
            precision_and_rounding
            (
                op - opcode_extended_decimal_point_selector_0,
                precision_and_rounding_get().get_rounding()
            )
        );
        break;

    case opcode_extended_decimal_point_selector_float:
        precision_and_rounding_set
        (
            precision_and_rounding
            (
                -1,
                precision_and_rounding_get().get_rounding()
            )
        );
        break;

    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:
        {
            int flag = op - opcode_extended_goto_000;
            address = find_flag_jump(flag);
            goto start;
        }

    default:
        on_error("%s: %d: undefined 0x%02X opcode", __FILE__, __LINE__, op);
        // stop the clock
        clock_tick_mode = clock_tick_mode_disabled;
        break;
    }
    if (x_register.has_overflowed())
    {
        // stop the clock
        clock_tick_mode = clock_tick_mode_disabled;
    }
}