git.gag.com Git - debian/cc1111/blob - sim/ucsim/sim.src/obsolete.h

   1 /*
   2 class cl_mem: public cl_guiobj
   3 {
   4 public:
   5   char *addr_format, *data_format;
   6   ulong mask;
   7   enum mem_class type;
   8   char *class_name;
   9   union {
  10     void *mem;
  11     uchar *umem8;
  12   };
  13   //class cl_memloc_coll *read_locs, *write_locs;
  14   t_addr size;
  15   int width; // in bits
  16   class cl_uc *uc;
  17   t_addr dump_finished;
  18
  19 public:
  20   cl_mem(enum mem_class atype, char *aclass_name, t_addr asize, int awidth,
  21          class cl_uc *auc);
  22   virtual ~cl_mem(void);
  23   virtual int init(void);
  24   virtual char *id_string(void);
  25   virtual int get_cell_flag(t_addr //addr
  26                             ) { return(CELL_NORMAL); }
  27   virtual bool get_cell_flag(t_addr //addr
  28                              , int //flag
  29                              )
  30   { return(DD_FALSE); }
  31   virtual void set_cell_flag(t_addr addr, bool set_to, int flag) {}
  32
  33   virtual t_mem read(t_addr addr);
  34   virtual t_mem read(t_addr addr, enum hw_cath //skip
  35                      ) {return(read(addr));}
  36   virtual t_mem get(t_addr addr);
  37   virtual t_mem write(t_addr addr, t_mem val);
  38   virtual void set(t_addr addr, t_mem val);
  39   virtual void set_bit1(t_addr addr, t_mem bits);
  40   virtual void set_bit0(t_addr addr, t_mem bits);
  41   virtual void write_bit1(t_addr addr, t_mem bits) { set_bit1(addr, bits); }
  42   virtual void write_bit0(t_addr addr, t_mem bits) { set_bit0(addr, bits); }
  43   virtual t_mem add(t_addr addr, long what);
  44   virtual t_mem wadd(t_addr addr, long what) { return(add(addr, what)); }
  45   virtual t_addr dump(t_addr start, t_addr stop, int bpl,
  46                       class cl_console_base *con);
  47   virtual t_addr dump(class cl_console_base *con);
  48   virtual bool search_next(bool case_sensitive,
  49                            t_mem *array, int len, t_addr *addr);
  50
  51   virtual class cl_cell *get_cell(t_addr addr) {return(0);}
  52   virtual class cl_cell *register_hw(t_addr addr, class cl_hw *hw, int *ith,
  53                                      bool announce)
  54   { return(0); }
  55   virtual void set_brk(t_addr //addr
  56                        , class cl_brk *//brk
  57                        ) {}
  58   virtual void del_brk(t_addr addr, class cl_brk *brk) {}
  59 #ifdef STATISTIC
  60   virtual unsigned long get_nuof_reads(void) {return(0);}
  61   virtual unsigned long get_nuof_writes(void) {return(0);}
  62   virtual void set_nuof_reads(unsigned long value) {}
  63   virtual void set_nuof_writes(unsigned long value) {}
  64 #endif
  65 };
  66 */
  67
  68 /*
  69 class cl_mapped_cell: public cl_cell
  70 {
  71 protected:
  72   class cl_cell *real_cell;
  73 public:
  74   cl_mapped_cell(class cl_cell *realcell);
  75   virtual ~cl_mapped_cell(void);
  76
  77   virtual t_mem read(void);
  78   virtual t_mem read(enum hw_cath skip);
  79   virtual t_mem get(void);
  80   virtual t_mem write(t_mem val);
  81   virtual t_mem set(t_mem val);
  82   virtual t_mem add(long what);
  83   virtual t_mem wadd(long what);
  84
  85   virtual void set_bit1(t_mem bits);
  86   virtual void set_bit0(t_mem bits);
  87
  88   virtual class cl_cell *add_hw(class cl_hw *hw, int *ith);
  89   virtual class cl_hw *get_hw(int ith);
  90   virtual class cl_event_handler *get_event_handler(void);
  91 };
  92 */
  93
  94
  95 class cl_m: public cl_memory
  96 {
  97 protected:
  98   class cl_cell **array;
  99   class cl_cell *dummy;
 100   t_addr bus_mask;
 101 public:
 102   //t_addr size;
 103   enum mem_class type;
 104
 105 public:
 106   cl_m(enum mem_class atype, char *aclass_name, t_addr asize, int awidth,
 107        class cl_uc *auc);
 108   cl_m(t_addr asize, int awidth);
 109   virtual ~cl_m(void);
 110   virtual int init(void);
 111   virtual char *id_string(void);
 112
 113   virtual int get_cell_flag(t_addr addr);
 114   virtual bool get_cell_flag(t_addr addr, int flag);
 115   virtual void set_cell_flag(t_addr addr, bool set_to, int flag);
 116
 117   virtual t_mem read(t_addr addr);
 118   virtual t_mem read(t_addr addr, enum hw_cath skip);
 119   virtual t_mem get(t_addr addr);
 120   virtual t_mem write(t_addr addr, t_mem val);
 121   virtual void set(t_addr addr, t_mem val);
 122   virtual class cl_cell *get_cell(t_addr addr);
 123
 124   virtual void set_bit1(t_addr addr, t_mem bits);
 125   virtual void set_bit0(t_addr addr, t_mem bits);
 126   virtual void write_bit1(t_addr addr, t_mem bits);
 127   virtual void write_bit0(t_addr addr, t_mem bits);
 128   virtual t_mem add(t_addr addr, long what);
 129   virtual t_mem wadd(t_addr addr, long what);
 130
 131   virtual bool search_next(bool case_sensitive,
 132                            t_mem *array, int len, t_addr *addr);
 133
 134   virtual class cl_cell *register_hw(t_addr addr, class cl_hw *hw, int *ith,
 135                                      bool announce);
 136   virtual void set_brk(t_addr addr, class cl_brk *brk);
 137   virtual void del_brk(t_addr addr, class cl_brk *brk);
 138
 139 #ifdef STATISTIC
 140   virtual unsigned long get_nuof_reads(void);
 141   virtual unsigned long get_nuof_writes(void);
 142   virtual void set_nuof_reads(unsigned long value);
 143   virtual void set_nuof_writes(unsigned long value);
 144 #endif
 145 };
 146
 147
 148 class cl_normal_cell: public cl_cell
 149 {
 150 public:
 151   t_mem data;
 152   TYPE_UBYTE type;      // See CELL_XXXX
 153   //protected:
 154
 155 public:
 156   cl_normal_cell(uchar awidth);
 157   //virtual void destroy(void) {}
 158
 159   virtual TYPE_UBYTE get_type(void) { return(type); }
 160   virtual void set_type(TYPE_UBYTE what) { type= what; }
 161
 162   virtual t_mem read(void) {
 163 #ifdef STATISTIC
 164     nuof_reads++;
 165 #endif
 166     return(data);
 167   }
 168   virtual t_mem read(enum hw_cath skip) { return(data); }
 169   virtual t_mem get(void)  { return(data); }
 170   virtual t_mem write(t_mem val) {
 171     data= val & mask;
 172 #ifdef STATISTIC
 173     nuof_writes++;
 174 #endif
 175     return(data);
 176   }
 177   virtual t_mem set(t_mem val) { return(data= val & mask); }
 178   virtual t_mem add(long what);
 179   virtual t_mem wadd(long what);
 180
 181   virtual void set_bit1(t_mem bits);
 182   virtual void set_bit0(t_mem bits);
 183
 184   virtual class cl_cell *add_hw(class cl_hw *hw, int *ith)
 185   { return(0); }
 186   virtual class cl_hw *get_hw(int ith) { return(0); }
 187   //virtual class cl_brk *get_brk(void) { return(0); }
 188   virtual class cl_event_handler *get_event_handler(void) { return(0); }
 189 };
 190
 191 class cl_registered_cell: public cl_memory_cell
 192 {
 193 public:
 194   //class cl_list *hws;
 195   class cl_hw **hardwares;
 196   int nuof_hws;
 197 public:
 198   cl_registered_cell(uchar awidth);
 199   virtual ~cl_registered_cell(void);
 200   //virtual void destroy(void);
 201
 202   virtual t_mem read(void);
 203   virtual t_mem read(enum hw_cath skip);
 204   virtual t_mem write(t_mem val);
 205
 206   virtual class cl_cell *add_hw(class cl_hw *hw, int *ith);
 207   virtual class cl_hw *get_hw(int ith);
 208 };
 209
 210 class cl_event_cell: public cl_normal_cell
 211 {
 212 protected:
 213   class cl_event_handler *eh;
 214 public:
 215   cl_event_cell(uchar awidth, class cl_uc *auc);
 216   virtual ~cl_event_cell(void);
 217
 218   virtual t_mem read(void);
 219   virtual t_mem write(t_mem val);
 220   //virtual void event(void);
 221
 222   //virtual class cl_brk *get_brk(void) { return(brk); }
 223   virtual class cl_event_handler *get_event_handler(void) { return(eh); }
 224 };
 225
 226 class cl_ev_reg_cell: public cl_registered_cell
 227 {
 228 protected:
 229   class cl_event_handler *eh;
 230 public:
 231   cl_ev_reg_cell(uchar awidth, class cl_uc *auc);
 232   virtual ~cl_ev_reg_cell(void);
 233
 234   virtual t_mem read(void);
 235   virtual t_mem write(t_mem val);
 236   //virtual void event(void);
 237
 238   //virtual class cl_brk *get_brk(void) { return(brk); }
 239   virtual class cl_event_handler *get_event_handler(void) { return(eh); }
 240 };
 241
 242 /*
 243  * 2nd version memory system
 244  */
 245 class cl_cell: public cl_base
 246 {
 247 public:
 248   cl_cell(void);
 249 public:
 250
 251   virtual t_mem read(void)= 0;
 252   virtual t_mem read(enum hw_cath skip)=0;
 253   virtual t_mem get(void)=0;
 254   virtual t_mem write(t_mem val)=0;
 255   virtual t_mem set(t_mem val)=0;
 256   virtual t_mem add(long what)=0;
 257   virtual t_mem wadd(long what)=0;
 258
 259   virtual void set_bit1(t_mem bits)=0;
 260   virtual void set_bit0(t_mem bits)=0;
 261
 262   virtual class cl_cell *add_hw(class cl_hw *hw, int *ith)=0;
 263   virtual class cl_hw *get_hw(int ith)=0;
 264   virtual class cl_event_handler *get_event_handler(void)=0;
 265 };
 266
 267 /*
 268  */
 269 class cl_event_handler: public cl_base
 270 {
 271 public:
 272   class cl_list *read_bps, *write_bps;
 273   class cl_uc *uc;
 274 public:
 275   cl_event_handler(class cl_uc *auc);
 276   virtual ~cl_event_handler(void);
 277
 278   virtual void write(void);
 279   virtual void read(void);
 280
 281   virtual int add_bp(class cl_brk *bp);
 282   virtual int copy_from(class cl_event_handler *eh);
 283   virtual bool del_bp(class cl_brk *bp);
 284 };
 285
 286