/home/martin/src/mimasim/src/mima/mima.h

Go to the documentation of this file.

//$Id: mima.h,v 1.16 2006/10/22 10:43:33 der_martin Exp $
/*
 * mimasim -- a simulator of a minimal microprocessor system
 * Copyright (C) 2006 Martin Grandrath <gr@ndrath.de>
 *
 * This program is free software; you can redistribute it and/or
 * modify it under the terms of the GNU General Public License as
 * published by the Free Software Foundation; either version 2 of the
 * License, or (at your option) any later version.
 *
 * 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, write to the Free Software
 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
 * 02110-1301, USA.
 */

#ifndef MIMA_H
#define MIMA_H

#ifdef HAVE_CONFIG_H
#include <config.h>
#endif

#include <string>
#include <ostream>
#include <map>
#include <vector>
#include <sigc++/sigc++.h>

/*
 * public typedefs
 * ===============
 */
typedef std::map<int, int>                 type_memory_map;
typedef std::map<int, int>::iterator       type_memory_map_iterator;
typedef std::map<int, int>::const_iterator type_memory_map_const_iterator;
typedef std::vector<int>                   type_breakpoint_list;
typedef std::vector<int>::iterator         type_breakpoint_list_iterator;

// declare classes
namespace MimaSim {
     class Mima;
     class Cli;
     class AssConvert;
}

std::ostream& operator<<(std::ostream& os, const MimaSim::Mima& mima);

std::istream& operator>>(std::istream& is, const MimaSim::Mima& mima);

namespace MimaSim {

     enum State {
          RUNNING,
          STOPPED,
          STOPPED_ON_ERR
     };

     enum ConvertError {
          UNKNOWN_MNEMONIC = -1,
          NO_ARG = -2,
          INVALID_ARG = -3
     };


     class Mima
          {
          private:
               struct TermCollect;

               /*
                * signal typedefs
                * ===============
                */
               typedef sigc::signal<void>            type_signal_void;
               typedef sigc::signal<void, int>       type_signal_void_int;
               typedef sigc::signal<void, int, int>  type_signal_void_int_int;
               typedef sigc::signal<void, int, char> type_signal_void_int_char;
               typedef sigc::signal<void, int, bool> type_signal_void_int_bool;
               typedef sigc::signal<void, State>     type_signal_void_state;
               typedef sigc::signal<char, int>       type_signal_char_int;

               typedef sigc::signal<char, int>::accumulated<TermCollect> type_signal_char_int_termcollect;

               /*
                * private classes
                * ===============
                */
               class Counter
                    {
                    private:
                         /*
                          * private attributes
                          * ==================
                          */
                         int m_value;

                    protected:
                         type_signal_void_int m_signal_changed;

                    public:
                         Counter() : m_value(0) {};
                         ~Counter() {};

                         int get() const { return m_value; };

                         int inc();

                         bool reset();

                         type_signal_void_int signal_changed() { return m_signal_changed; };

                    };

               class Register
                    {
                    private:
                         /*
                          * private attributes
                          * ==================
                          */
                         int m_value;

                    protected:
                       type_signal_void_int m_signal_changed;

                    public:
                         Register() : m_value(0) {};
                         ~Register() {};

                         int get() const { return m_value; };

                         bool set(int new_value);

                         int inc();

                         int dec();

                         int shr(int n = 1);

                         type_signal_void_int signal_changed() { return m_signal_changed; };

                    };


               class Memory
                    {
                    private:
                         type_memory_map m_memory;
                         int m_memsize;

                    protected:
                         type_signal_void          m_signal_clear;
                         type_signal_void_int      m_signal_memsize_changed;
                         type_signal_void_int_int  m_signal_value_changed;
                         type_signal_void_int_bool m_signal_breakpoint_changed;

                    public:
                         Memory(int memsize);
                         ~Memory();

                         int get_memsize() const { return m_memsize; };
                         bool set_memsize(int size);
                         int get(int address);
                         bool set(int address, int value);
                         bool toggle_breakpoint(int address);
                         bool get_breakpoint(int address);
                         bool clear();

                         type_memory_map get(int start = 0, int end = -1) const;
                         type_breakpoint_list get_breakpoints(int start = 0, int end = -1) const;

                         type_signal_void          signal_clear()              { return m_signal_clear;              };
                         type_signal_void_int      signal_memsize_changed()    { return m_signal_memsize_changed;    };
                         type_signal_void_int_int  signal_value_changed()      { return m_signal_value_changed;      };
                         type_signal_void_int_bool signal_breakpoint_changed() { return m_signal_breakpoint_changed; };

                    };


               struct TermCollect
               {
                    typedef char result_type;
                    template<typename T_iterator>
                    result_type operator()(T_iterator first, T_iterator last) const
                         {
                              for (; first != last; ++first)
                                   if (*first != '\0') return *first;
                              return '\0';
                         }
               };

               /*
                * private attributes
                * ==================
                */
               Register m_acc;           // accumulator
               Register m_iar;           // instruction address register
               Counter m_counter;        // instruction counter
               Memory m_memory;          // the memory
               State m_state;            // current state
               int m_steps;              // steps to be executed
               bool m_ignore_breakpoint; // prevent mima from stopping when started on a breakpoint
               Cli *m_cli;

          protected:
               /*
                * signals
                * =======
                */
               type_signal_void          m_signal_quit;
               type_signal_void_state    m_signal_state_changed;
               type_signal_void_int_char m_signal_out;
               type_signal_char_int_termcollect      m_signal_in;

               /*
                * protected members
                * =================
                */
               int sign_extend(int arg);

               void increment_iar();

               void decrement_iar();

               void increment_counter();

               void set_state(State state);

          public:
               Mima(int memsize = DEFAULT_MEMSIZE);
               ~Mima();

               /*
                * signal accessors
                * ================
                */
               type_signal_void          signal_quit()                      { return m_signal_quit; };
               type_signal_void          signal_memory_clear()              { return m_memory.signal_clear();              };
               type_signal_void_int      signal_acc_changed()               { return m_acc.signal_changed();               };
               type_signal_void_int      signal_iar_changed()               { return m_iar.signal_changed();               };
               type_signal_void_int      signal_counter_changed()           { return m_counter.signal_changed();           };
               type_signal_void_int      signal_memsize_changed()           { return m_memory.signal_memsize_changed();    };
               type_signal_void_int_int  signal_memory_value_changed()      { return m_memory.signal_value_changed();      };
               type_signal_void_int_char signal_out()                       { return m_signal_out;                         };
               type_signal_char_int_termcollect signal_in()                 { return m_signal_in;                          };
               type_signal_void_int_bool signal_memory_breakpoint_changed() { return m_memory.signal_breakpoint_changed(); };
               type_signal_void_state    signal_state_changed()             { return m_signal_state_changed;               };

               /*
                * public members
                * ==============
                */
               void set_acc(int value);

               void set_iar(int value);

               void set_memsize(int size);

               void set_memory(int address, int value);

               void reset_counter();

               void reset(bool full = false);

               int get_acc() const
                    { return m_acc.get(); };

               int get_iar() const
                    { return m_iar.get(); };

               int get_counter() const
                    { return m_counter.get(); };

               int get_memsize() const
                    { return m_memory.get_memsize(); };

               int get_memory(int address)
                    { return m_memory.get(address); };

               Cli *get_cli()
                    { return m_cli; }


               type_memory_map get_memory_map(int start = 0, int end = -1) const
                    { return m_memory.get(start, end); };

               type_breakpoint_list get_breakpoints() const
                    { return m_memory.get_breakpoints(); };

               bool toggle_breakpoint(int address)
                    { return m_memory.toggle_breakpoint(address); };

               bool get_breakpoint(int address)
                    { return m_memory.get_breakpoint(address); };

               void run(int steps = -1);

               void clock();

               void stop();

               void quit();

          };


     class Cli
          {
          private:
               /*
                * private classes
                * ===============
                */
               class Command
                    {
                    public:
                         Command(char *cmd_str);
                         ~Command();
                         char cmd;
                         int arg1, arg2;
                    };

               /*
                * private attributes
                * ==================
                */
               Mima *m_mima;

          protected:
               /*
                * protected members
                * =================
                */
               std::string step(Command cmd);

               std::string dump_memory(Command cmd);

               std::string set_memory(Command cmd);

               std::string set_acc(Command cmd);

               std::string set_iar(Command cmd);

               std::string dump_state(Command cmd);

               std::string run(Command cmd);

               std::string reset(bool full = false);

               std::string toggle_breakpoint(Command cmd);

               std::string print_help();

          public:
               Cli(Mima *mima) : m_mima(mima) {}
               ~Cli() {}

               /*
                * public members
                * ==============
                */
               const char* execute(char *cmd_str);

          };


     class AssConvert
          {
          private:
               /*
                * private attributes
                * ==================
                */
               Mima *m_mima;

          protected:

          public:
               AssConvert(Mima *_mima);
               ~AssConvert();

               int ass2mem(std::istream& code, int address_start);

               std::istream& mem2ass(int address_start, int len);
          };

}
#endif // MIMA_H

---