lib/calculator.h

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/>.
//

#ifndef LIB_CALCULATOR_H
#define LIB_CALCULATOR_H

#include <lib/ac/stdarg.h>
#include <boost/shared_ptr.hpp>
#include <list>
#include <map>
#include <string>

#include <lib/display.h>
#include <lib/format_printf.h>
#include <lib/interpose.h>
#include <lib/location.h>
#include <lib/number.h>
#include <lib/opcode.h>
#include <lib/precision_and_rounding.h>
#include <lib/sizeof.h>

class debugger; // forward
class program_card_functor; // forward

class calculator
{
public:
    typedef boost::shared_ptr<calculator> pointer;

    virtual ~calculator();

    virtual void on_opcode(opcode_t op, const location::pointer &where);

    void on_opcode_lrn(opcode_t op, const location::pointer &where);

    void on_opcode_ope(opcode_t op, const location::pointer &where);

    void on_opcode_pro_che(opcode_t op, const location::pointer &where);

    void on_opcode_ope_che(opcode_t op, const location::pointer &where);

    void on_error(const char *fmt, ...)
                                                            FORMAT_PRINTF(2, 3);

    virtual void on_error_v(const char *fmt, va_list ap)
                                                        FORMAT_PRINTF(2, 0) = 0;

    virtual void run(void) = 0;

    enum program_mode_t
    {
        program_mode_learn,

        program_mode_operation,

        program_mode_program_check,

        program_mode_operation_check,
    };

    program_mode_t program_mode_get(void);

    void program_mode_set(program_mode_t pm);

    enum program_selector_t
    {
        program_selector_i_ii,
        program_selector_i,
        program_selector_ii
    };

    program_selector_t program_selector_get(void) const;

    void program_selector_set(program_selector_t ps);

    void precision_and_rounding_set(const precision_and_rounding &value);

    const precision_and_rounding &precision_and_rounding_get(void) const;

    void clear_program(void);

    bool load_program(const std::string &filename, bool binary);

    void save_program_as(const std::string &filename, bool binary);

    void accumulate_mode_set(bool value);

    void constant_mode_set(bool value);

    void program_card_walk(program_card_functor &f) const;

    virtual void property(const std::string &name, const std::string &value);

    static const char *program_mode_name(program_mode_t pm);

    bool strict_memory_number_checking_required(void) const;

    void strict_memory_number_checking_set(bool);

    bool save_memories_as_program(const std::string &filename);

protected:
    calculator();

    void update_display(void);

    void clock_tick_event(void);

    bool clock_tick_expected(void) const;

    virtual void clock_tick_start_running(void) = 0;

    void printer_finished_event(void);

    bool printer_finished_event_expected(void) const;

    typedef boost::shared_ptr<debugger> debugger_pointer;

    void update_debugger(debugger &where);

    void set_address(int n);

    bool get_step(int addr, unsigned char &op, location::pointer &where) const;

private:
    virtual void derived_print(const display &value) = 0;

    virtual void derived_feed(void) = 0;

    virtual void derived_off(void) = 0;

    virtual void derived_update_display(const display &value) = 0;

    virtual void printer_timer_start_running(void) = 0;

    bool accumulate_mode_get(void) const;

    enum mstate_t
    {
        mstate_reset,
        mstate_lhs_digits_before_dot,
        mstate_lhs_digits_after_dot,
        mstate_lhs_complete,
        mstate_mul,
        mstate_mul_digits_before_dot,
        mstate_mul_digits_after_dot,
        mstate_mul_complete,
    };

    static const char *mstate_name(mstate_t s);

    mstate_t mstate;

    precision_and_rounding precro_front_panel;

    precision_and_rounding precro_current;

    number x_register;

    number y_register;

    number memory[16];

    program_selector_t program_selector;

    unsigned char address;

    unsigned char programme[256];

    location::pointer programme_location[SIZEOF(programme)];

    program_mode_t program_mode;

    interpose::pointer interpose_by_program_mode[4];

    enum deferred_action_t
    {
        deferred_action_none,
        deferred_action_multiplication,
        deferred_action_division,
    };

    deferred_action_t deferred_action;

    void update_display_lrn(void);

    void calculate_display_lrn(display &disp, int addr, int op);

    void update_display_ope(void);

    enum clock_tick_mode_t
    {
        clock_tick_mode_disabled,
        clock_tick_mode_running,
        clock_tick_mode_entry,
        clock_tick_mode_sj,
        clock_tick_mode_ej,
    };

    clock_tick_mode_t clock_tick_mode;

    bool printer_delay_active;

    unsigned char next_opcode(void);

    unsigned find_flag_jump(unsigned char label);

    unsigned wrap_address(unsigned addr) const;

    void update_display_lamps(display &value);

    void execute_one_instruction(void);

    void program_print(void);

    bool accumulate_mode;

    std::list<unsigned> call_stack;

    unsigned find_subroutine_flag_jump(unsigned char label);

    location::pointer next_location(void) const;

    bool constant_mode;

    deferred_action_t constant_mode_action;

    number constant_mode_rhs;

    void constant_mode_eval(bool neg);

    void non_constant_mode_eval(bool neg);

    void eval(bool neg);

    void eval_mul(bool neg);

    typedef std::map<std::string, std::string> properties_t;

    properties_t properties;

    std::string get_property(const std::string &name,
        const std::string &dflt = "") const;

    bool get_bool_property(const std::string &name, bool dflt = false) const;

    bool have_property(const std::string &name) const;

    void maybe_accumulate(void);

    bool strict_memory_number_checking;

    int number_of_keys_since_ej;

    calculator(const calculator &);

    calculator &operator=(const calculator &);
};

// vim: set ts=8 sw=4 et :
#endif // LIB_CALCULATOR_H