#ifndef SIM_MEMCL_HEADER
#define SIM_MEMCL_HEADER
+
+// prj
#include "stypes.h"
#include "pobjcl.h"
+// gui.src
#include "guiobjcl.h"
class cl_mem;
+class cl_event_handler;
+
+
+// Cell types
+#define CELL_NORMAL 0x00 /* Nothing special */
+#define CELL_HW_READ 0x01 /* Hw handles read */
+#define CELL_HW_WRITE 0x02 /* Hw catches write */
+#define CELL_INST 0x04 /* Marked as instruction */
+#define CELL_FETCH_BRK 0x08 /* Fetch breakpoint */
+#define CELL_READ_BRK 0x10 /* Read event breakpoint */
+#define CELL_WRITE_BRK 0x20 /* Write event breakpoint */
+
+#define CELL_GENERAL (CELL_NORMAL|CELL_INST|CELL_FETCH_BRK)
+
+
+class cl_cell: public cl_base
+{
+public:
+ cl_cell(void): cl_base() {}
+public:
+ virtual TYPE_UBYTE get_type(void)= 0;
+ virtual void set_type(TYPE_UBYTE what)= 0;
+ virtual t_mem get_mask(void)= 0;
+
+ virtual t_mem read(void)=0 ;
+ virtual t_mem read(enum hw_cath /*skip*/)=0;
+ virtual t_mem get(void)=0;
+ virtual t_mem write(t_mem val)=0;
+ virtual t_mem set(t_mem val)=0;
+ virtual t_mem add(long what)=0;
+ virtual t_mem wadd(long what)=0;
+
+ virtual void set_bit1(t_mem bits)=0;
+ virtual void set_bit0(t_mem bits)=0;
+
+ virtual class cl_cell *add_hw(class cl_hw */*hw*/, int */*ith*/)=0;
+ virtual class cl_hw *get_hw(int ith)=0;
+ virtual class cl_event_handler *get_event_handler(void)=0;
+};
+
+class cl_normal_cell: public cl_cell
+{
+public:
+ t_mem data;
+ TYPE_UBYTE type; // See CELL_XXXX
+ //protected:
+ t_mem mask;
+ uchar width;
+
+public:
+ cl_normal_cell(uchar awidth);
+ //virtual void destroy(void) {}
+
+ virtual TYPE_UBYTE get_type(void) { return(type); }
+ virtual void set_type(TYPE_UBYTE what) { type= what; }
+ virtual t_mem get_mask(void) { return(mask); }
+
+ virtual t_mem read(void) { return(data); }
+ virtual t_mem read(enum hw_cath /*skip*/) { return(data); }
+ virtual t_mem get(void) { return(data); }
+ virtual t_mem write(t_mem val) { data= val & mask; return(data); }
+ virtual t_mem set(t_mem val) { return(data= val & mask); }
+ virtual t_mem add(long what);
+ virtual t_mem wadd(long what);
+
+ virtual void set_bit1(t_mem bits);
+ virtual void set_bit0(t_mem bits);
+
+ virtual class cl_cell *add_hw(class cl_hw */*hw*/, int */*ith*/)
+ { return(0); }
+ virtual class cl_hw *get_hw(int ith) { return(0); }
+ //virtual class cl_brk *get_brk(void) { return(0); }
+ virtual class cl_event_handler *get_event_handler(void) { return(0); }
+};
+
/* Memory location handled specially by a hw element */
-class cl_memloc: public cl_base
+/*class cl_memloc: public cl_base
{
public:
t_addr address;
public:
cl_memloc(t_addr addr);
- ~cl_memloc(void);
+ virtual ~cl_memloc(void);
virtual ulong read(class cl_mem *mem);
virtual void write(class cl_mem *mem, t_addr addr, t_mem *val);
-};
+};*/
-class cl_memloc_coll: public cl_sorted_list
+/*class cl_memloc_coll: public cl_sorted_list
{
public:
cl_memloc_coll(void);
virtual int compare(void *key1, void *key2);
class cl_memloc *get_loc(t_addr address);
-};
+};*/
/* Memory */
void *mem;
uchar *umem8;
};
- class cl_memloc_coll *read_locs, *write_locs;
+ //class cl_memloc_coll *read_locs, *write_locs;
+ class cl_uc *uc;
t_addr dump_finished;
public:
- cl_mem(enum mem_class atype, char *aclass_name, t_addr asize, int awidth);
- ~cl_mem(void);
+ cl_mem(enum mem_class atype, char *aclass_name, t_addr asize, int awidth,
+ class cl_uc *auc);
+ virtual ~cl_mem(void);
virtual int init(void);
virtual char *id_string(void);
+ virtual int get_cell_flag(t_addr /*addr*/) { return(CELL_NORMAL); }
+ virtual bool get_cell_flag(t_addr /*addr*/, int /*flag*/)
+ { return(DD_FALSE); }
+ virtual void set_cell_flag(t_addr addr, bool set_to, int flag) {}
virtual t_mem read(t_addr addr);
+ virtual t_mem read(t_addr addr, enum hw_cath /*skip*/) {return(read(addr));}
virtual t_mem get(t_addr addr);
- virtual void write(t_addr addr, t_mem *val);
+ virtual t_mem write(t_addr addr, t_mem val);
virtual void set(t_addr addr, t_mem val);
virtual void set_bit1(t_addr addr, t_mem bits);
virtual void set_bit0(t_addr addr, t_mem bits);
+ virtual void write_bit1(t_addr addr, t_mem bits) { set_bit1(addr, bits); }
+ virtual void write_bit0(t_addr addr, t_mem bits) { set_bit0(addr, bits); }
virtual t_mem add(t_addr addr, long what);
+ virtual t_mem wadd(t_addr addr, long what) { return(add(addr, what)); }
virtual t_addr dump(t_addr start, t_addr stop, int bpl,
class cl_console *con);
virtual t_addr dump(class cl_console *con);
virtual bool search_next(bool case_sensitive,
t_mem *array, int len, t_addr *addr);
+
+ virtual class cl_cell *get_cell(t_addr addr) {return(0);}
+ virtual class cl_cell *register_hw(t_addr addr, class cl_hw *hw, int *ith,
+ bool announce)
+ { return(0); }
+ virtual void set_brk(t_addr /*addr*/, class cl_brk */*brk*/) {}
+ virtual void del_brk(t_addr addr, class cl_brk *brk) {}
};
/* Spec for CODE */
-class cl_bitmap: public cl_base
+/*class cl_bitmap: public cl_base
{
public:
uchar *map;
int size;
public:
cl_bitmap(t_addr asize);
- ~cl_bitmap(void);
+ virtual ~cl_bitmap(void);
virtual void set(t_addr pos);
virtual void clear(t_addr pos);
virtual bool get(t_addr pos);
class cl_bitmap *bp_map;
class cl_bitmap *inst_map;
public:
+<<<<<<< memcl.h
cl_rom(t_addr asize, int awidth);
~cl_rom(void);
};
/* New type */
+=======
+ cl_rom(t_addr asize, int awidth, class cl_uc *auc);
+ virtual ~cl_rom(void);
+};*/
+
+/*
+ * New type of memory simulation
+ */
+>>>>>>> 1.4.2.2
+<<<<<<< memcl.h
class cl_cell: public cl_base
{
public:
t_mem data;
+=======
+class cl_registered_cell: public cl_normal_cell
+{
+public:
+ //class cl_list *hws;
+ class cl_hw **hardwares;
+ int nuof_hws;
+public:
+ cl_registered_cell(uchar awidth);
+ virtual ~cl_registered_cell(void);
+ //virtual void destroy(void);
+
+ virtual t_mem read(void);
+ virtual t_mem read(enum hw_cath skip);
+ virtual t_mem write(t_mem val);
+
+ virtual class cl_cell *add_hw(class cl_hw *hw, int *ith);
+ virtual class cl_hw *get_hw(int ith);
+};
+
+class cl_event_handler: public cl_base
+{
+public:
+ class cl_list *read_bps, *write_bps;
+ class cl_uc *uc;
+public:
+ cl_event_handler(class cl_uc *auc);
+ virtual ~cl_event_handler(void);
+
+ virtual void write(void);
+ virtual void read(void);
+
+ virtual int add_bp(class cl_brk *bp);
+ virtual int copy_from(class cl_event_handler *eh);
+ virtual bool del_bp(class cl_brk *bp);
+};
+
+class cl_event_cell: public cl_normal_cell
+{
+>>>>>>> 1.4.2.2
protected:
- t_mem mask;
+ class cl_event_handler *eh;
+public:
+ cl_event_cell(uchar awidth, class cl_uc *auc);
+ virtual ~cl_event_cell(void);
+ virtual t_mem read(void);
+ virtual t_mem write(t_mem val);
+ //virtual void event(void);
+
+ //virtual class cl_brk *get_brk(void) { return(brk); }
+ virtual class cl_event_handler *get_event_handler(void) { return(eh); }
+};
+
+class cl_ev_reg_cell: public cl_registered_cell
+{
+protected:
+ class cl_event_handler *eh;
public:
- cl_cell(int awidth);
- virtual t_mem read(void) { return(data); }
- virtual t_mem get(void) { return(data); }
- virtual void write(t_mem *val) { data= *val= (*val & mask); }
- virtual void set(t_mem val) { data= val & mask; }
+ cl_ev_reg_cell(uchar awidth, class cl_uc *auc);
+ virtual ~cl_ev_reg_cell(void);
+
+ virtual t_mem read(void);
+ virtual t_mem write(t_mem val);
+ //virtual void event(void);
+
+ //virtual class cl_brk *get_brk(void) { return(brk); }
+ virtual class cl_event_handler *get_event_handler(void) { return(eh); }
};
-class cl_registered_cell: public cl_cell
+class cl_mapped_cell: public cl_cell
{
protected:
- class cl_list *hws;
- class cl_hw *hardwares;
- int nuof_hws;
+ class cl_cell *real_cell;
public:
- cl_registered_cell(int awidth);
- ~cl_registered_cell(void);
+ cl_mapped_cell(class cl_cell *realcell);
+ virtual ~cl_mapped_cell(void);
+
virtual t_mem read(void);
- virtual void write(t_mem *val);
+ virtual t_mem read(enum hw_cath skip);
+ virtual t_mem get(void);
+ virtual t_mem write(t_mem val);
+ virtual t_mem set(t_mem val);
+ virtual t_mem add(long what);
+ virtual t_mem wadd(long what);
+
+ virtual void set_bit1(t_mem bits);
+ virtual void set_bit0(t_mem bits);
+
+ virtual class cl_cell *add_hw(class cl_hw *hw, int *ith);
+ virtual class cl_hw *get_hw(int ith);
+ virtual class cl_event_handler *get_event_handler(void);
};
class cl_m: public cl_mem
{
protected:
class cl_cell **array;
+ class cl_cell *dummy;
+ t_addr bus_mask;
public:
- t_addr size;
- int width;
+ //t_addr size;
+ //int width;
public:
+ cl_m(enum mem_class atype, char *aclass_name, t_addr asize, int awidth,
+ class cl_uc *auc);
cl_m(t_addr asize, int awidth);
- ~cl_m(void);
+ virtual ~cl_m(void);
+ virtual void err_inv_addr(t_addr addr);
+ virtual int get_cell_flag(t_addr addr);
+ virtual bool get_cell_flag(t_addr addr, int flag);
+ virtual void set_cell_flag(t_addr addr, bool set_to, int flag);
+
virtual t_mem read(t_addr addr);
+ virtual t_mem read(t_addr addr, enum hw_cath skip);
virtual t_mem get(t_addr addr);
- virtual void write(t_addr addr, t_mem *val);
+ virtual t_mem write(t_addr addr, t_mem val);
virtual void set(t_addr addr, t_mem val);
+ virtual class cl_cell *get_cell(t_addr addr);
+
+ virtual void set_bit1(t_addr addr, t_mem bits);
+ virtual void set_bit0(t_addr addr, t_mem bits);
+ virtual void write_bit1(t_addr addr, t_mem bits);
+ virtual void write_bit0(t_addr addr, t_mem bits);
+ virtual t_mem add(t_addr addr, long what);
+ virtual t_mem wadd(t_addr addr, long what);
+
+ virtual class cl_cell *register_hw(t_addr addr, class cl_hw *hw, int *ith,
+ bool announce);
+ virtual void set_brk(t_addr addr, class cl_brk *brk);
+ virtual void del_brk(t_addr addr, class cl_brk *brk);
+};
+
+
+#include "errorcl.h"
+
+/*
+ * Errors in memory handling
+ */
+
+class cl_err_inv_addr: public cl_error
+{
+protected:
+ class cl_mem *mem;
+ t_addr addr;
+public:
+ cl_err_inv_addr(class cl_mem *amem, t_addr aaddr);
+ virtual void print(class cl_commander *c);
};
projects / fw / sdcc / blobdiff