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

   1 /*
   2  * Memory location handled specially by a hw element
   3  */
   4
   5 /*cl_memloc::cl_memloc(t_addr addr):
   6   cl_base()
   7 {
   8   address= addr;
   9   hws= new cl_list(2, 2);
  10   hws->init();
  11 }*/
  12
  13 /*cl_memloc::~cl_memloc(void)
  14 {
  15   hws->disconn_all();
  16   delete hws;
  17 }*/
  18
  19 /*ulong
  20 cl_memloc::read(class cl_mem *mem)
  21 {
  22   uchar ret= 0;
  23   class cl_hw *hw;
  24
  25   if (!hws ||
  26       hws->count == 0)
  27     return(ret);
  28   if ((hw= (class cl_hw *)(hws->at(0))))
  29     ret= hw->read(mem, address);
  30   return(ret);
  31 }*/
  32
  33 /*void
  34 cl_memloc::write(class cl_mem *mem, t_addr addr, t_mem *val)
  35 {
  36   class cl_hw *hw;
  37   int i;
  38
  39   if (!hws)
  40     return;
  41   for (i= 0; i < hws->count; i++)
  42     {
  43       hw= (class cl_hw *)hws->at(0);
  44       hw->write(mem, addr, val);
  45     }
  46 }*/
  47
  48
  49 /* Sorted collection of memory locations */
  50
  51 /*cl_memloc_coll::cl_memloc_coll(void):
  52   cl_sorted_list(2, 2)
  53 {
  54   Duplicates= DD_FALSE;
  55 }*/
  56
  57 /*void *
  58 cl_memloc_coll::key_of(void *item)
  59 {
  60   return(&(((class cl_memloc *)item)->address));
  61 }*/
  62
  63 /*int
  64 cl_memloc_coll::compare(void *key1, void *key2)
  65 {
  66   if (*(long*)key1 > *(long*)key2)
  67     return(1);
  68   else
  69     if (*(long*)key1 < *(long*)key2)
  70       return(-1);
  71     else
  72       return(0);
  73 }*/
  74
  75 /*class cl_memloc *
  76 cl_memloc_coll::get_loc(t_addr address)
  77 {
  78   t_index i;
  79
  80   if (search(&address, i))
  81     return((class cl_memloc*)(at(i)));
  82   return(0);
  83 }*/
  84
  85
  86 /*
  87  * Memory
  88  ******************************************************************************
  89  */
  90
  91 /*
  92  * Bitmap
  93  */
  94
  95 /*cl_bitmap::cl_bitmap(t_addr asize):
  96   cl_base()
  97 {
  98   map= (uchar*)malloc(size= asize/(8*SIZEOF_CHAR));
  99   memset(map, 0, size);
 100 }
 101
 102 cl_bitmap::~cl_bitmap(void)
 103 {
 104   free(map);
 105 }
 106
 107 void
 108 cl_bitmap::set(t_addr pos)
 109 {
 110   int i;
 111
 112   if ((i= pos/(8*SIZEOF_CHAR)) < size)
 113     map[i]|= (1 << (pos & ((8*SIZEOF_CHAR)-1)));
 114 }
 115
 116 void
 117 cl_bitmap::clear(t_addr pos)
 118 {
 119   int i;
 120
 121   if ((i= pos/(8*SIZEOF_CHAR)) < size)
 122     map[i]&= ~(1 << (pos & ((8*SIZEOF_CHAR)-1)));
 123 }
 124
 125 bool
 126 cl_bitmap::get(t_addr pos)
 127 {
 128   return(map[pos/(8*SIZEOF_CHAR)] & (1 << (pos & ((8*SIZEOF_CHAR)-1))));
 129 }
 130
 131 bool
 132 cl_bitmap::empty(void)
 133 {
 134   int i;
 135
 136   for (i= 0; i < size && map[i] == 0; i++) ;
 137   return(i == size);
 138 }*/
 139
 140 /*
 141  * Special memory for code (ROM)
 142  */
 143
 144 /*cl_rom::cl_rom(t_addr asize, int awidth, class cl_uc *auc):
 145   cl_mem(MEM_ROM, get_id_string(mem_classes, MEM_ROM), asize, awidth, auc)
 146 {
 147   bp_map= new cl_bitmap(asize);
 148   inst_map= new cl_bitmap(asize);
 149 }
 150
 151 cl_rom::~cl_rom(void)
 152 {
 153   delete bp_map;
 154   delete inst_map;
 155 }*/
 156
 157
 158 cl_mem::cl_mem(enum mem_class atype, char *aclass_name,
 159                t_addr asize, int awidth, class cl_uc *auc):
 160   cl_guiobj()
 161 {
 162   int i;
 163
 164   uc= auc;
 165   type= atype;
 166   class_name= aclass_name;
 167   width= awidth;
 168   size= asize;
 169   mem= 0;
 170   for (i= width, mask= 0; i; i--)
 171     mask= (mask<<1) | 1;
 172   if (width == 0 ||
 173       size == 0)
 174     mem= 0;
 175   else if (width <= 8)
 176     mem= (TYPE_UBYTE *)malloc(size);
 177   else if (width <= 16)
 178     mem= (TYPE_UWORD *)malloc(size*sizeof(TYPE_WORD));
 179   else
 180     mem= (TYPE_UDWORD *)malloc(size*sizeof(TYPE_DWORD));
 181   //read_locs= new cl_memloc_coll();
 182   //write_locs= new cl_memloc_coll();
 183   dump_finished= 0;
 184   addr_format= data_format= 0;
 185 }
 186
 187 cl_mem::~cl_mem(void)
 188 {
 189   if (mem)
 190     free(mem);
 191   if (addr_format)
 192     free(addr_format);
 193   if (data_format)
 194     free(data_format);
 195   //delete read_locs;
 196   //delete write_locs;
 197 }
 198
 199 int
 200 cl_mem::init(void)
 201 {
 202   t_addr i;
 203
 204   addr_format= (char *)malloc(10);
 205   sprintf(addr_format, "0x%%0%dx",
 206           size-1<=0xf?1:
 207           (size-1<=0xff?2:
 208            (size-1<=0xfff?3:
 209             (size-1<=0xffff?4:
 210              (size-1<=0xfffff?5:
 211               (size-1<=0xffffff?6:12))))));
 212   data_format= (char *)malloc(10);
 213   sprintf(data_format, "%%0%dx", width/4+((width%4)?1:0));
 214
 215   for (i= 0; i < size; i++)
 216     set(i, (type==MEM_ROM)?(-1):0);
 217   return(0);
 218 }
 219
 220 char *
 221 cl_mem::id_string(void)
 222 {
 223   char *s= get_id_string(mem_ids, type);
 224
 225   return(s?s:(char*)"NONE");
 226 }
 227
 228 t_mem
 229 cl_mem::read(t_addr addr)
 230 {
 231   //class cl_memloc *loc;
 232
 233   if (addr >= size)
 234     {
 235       //FIXME
 236       fprintf(stderr, "Address 0x%06"_A_"x is over 0x%06"_A_"x\n", addr, size);
 237       return(0);
 238     }
 239   /*if ((loc= read_locs->get_loc(addr)))
 240     return(loc->read(this));*/
 241   if (width <= 8)
 242     return((((TYPE_UBYTE*)mem)[addr])&mask);
 243   else if (width <= 16)
 244     return((((TYPE_UWORD*)mem)[addr])&mask);
 245   else
 246     return((((TYPE_UDWORD*)mem)[addr])&mask);
 247 }
 248
 249 t_mem
 250 cl_mem::get(t_addr addr)
 251 {
 252   if (addr >= size)
 253     return(0);
 254   if (width <= 8)
 255     return((((TYPE_UBYTE*)mem)[addr])&mask);
 256   else if (width <= 16)
 257     return((((TYPE_UWORD*)mem)[addr])&mask);
 258   else
 259     return((((TYPE_UDWORD*)mem)[addr])&mask);
 260 }
 261
 262
 263 /*
 264  * Modify memory location
 265  */
 266
 267 /* Write calls callbacks of HW elements */
 268
 269 t_mem
 270 cl_mem::write(t_addr addr, t_mem val)
 271 {
 272   /*  class cl_memloc *loc;
 273
 274   if (addr >= size)
 275     return;
 276   if ((loc= write_locs->get_loc(addr)))
 277     loc->write(this, addr, val);
 278   if (width <= 8)
 279     ((TYPE_UBYTE*)mem)[addr]= (*val)&mask;
 280   else if (width <= 16)
 281     ((TYPE_UWORD*)mem)[addr]= (*val)&mask;
 282   else
 283   ((TYPE_UDWORD*)mem)[addr]= (*val)&mask;*/
 284   fprintf(stderr, "FIXME cl_mem::write(0x%06"_A_"x, 0x%04"_M_"x)\n",
 285           addr, val);
 286   return(0);
 287 }
 288
 289 /* Set doesn't call callbacks */
 290
 291 void
 292 cl_mem::set(t_addr addr, t_mem val)
 293 {
 294   if (addr >= size)
 295     return;
 296   if (width <= 8)
 297     ((TYPE_UBYTE*)mem)[addr]= val&mask;
 298   else if (width <= 16)
 299     ((TYPE_UWORD*)mem)[addr]= val&mask;
 300   else
 301     ((TYPE_UDWORD*)mem)[addr]= val&mask;
 302 }
 303
 304 t_mem
 305 cl_mem::add(t_addr addr, long what)
 306 {
 307   if (addr >= size)
 308     return(0);
 309   if (width <= 8)
 310     {
 311       ((TYPE_UBYTE*)mem)[addr]= ((TYPE_UBYTE*)mem)[addr] + what;
 312       return(((TYPE_UBYTE*)mem)[addr]);
 313     }
 314   else if (width <= 16)
 315     {
 316       ((TYPE_UWORD*)mem)[addr]= ((TYPE_UWORD*)mem)[addr] + what;
 317       return(((TYPE_UWORD*)mem)[addr]);
 318     }
 319   else
 320     {
 321       ((TYPE_UDWORD*)mem)[addr]= ((TYPE_UDWORD*)mem)[addr] + what;
 322       return(((TYPE_UDWORD*)mem)[addr]);
 323     }
 324 }
 325
 326 t_addr
 327 cl_mem::dump(t_addr start, t_addr stop, int bpl, class cl_console_base *con)
 328 {
 329   int i;
 330
 331   while ((start <= stop) &&
 332          (start < size))
 333     {
 334       con->dd_printf(addr_format, start); con->dd_printf(" ");
 335       for (i= 0;
 336            (i < bpl) &&
 337              (start+i < size) &&
 338              (start+i <= stop);
 339            i++)
 340         {
 341           con->dd_printf(data_format, /*read*/get(start+i)); con->dd_printf(" ");
 342         }
 343       while (i < bpl)
 344         {
 345           int j;
 346           j= width/4 + ((width%4)?1:0) + 1;
 347           while (j)
 348             {
 349               con->dd_printf(" ");
 350               j--;
 351             }
 352           i++;
 353         }
 354       for (i= 0; (i < bpl) &&
 355              (start+i < size) &&
 356              (start+i <= stop);
 357            i++)
 358         {
 359           long c= get(start+i);
 360           con->dd_printf("%c", isprint(255&c)?(255&c):'.');
 361           if (width > 8)
 362             con->dd_printf("%c", isprint(255&(c>>8))?(255&(c>>8)):'.');
 363           if (width > 16)
 364             con->dd_printf("%c", isprint(255&(c>>16))?(255&(c>>16)):'.');
 365           if (width > 24)
 366             con->dd_printf("%c", isprint(255&(c>>24))?(255&(c>>24)):'.');
 367         }
 368       con->dd_printf("\n");
 369       dump_finished= start+i;
 370       start+= bpl;
 371     }
 372   return(dump_finished);
 373 }
 374
 375 t_addr
 376 cl_mem::dump(class cl_console_base *con)
 377 {
 378   return(dump(dump_finished, dump_finished+10*8-1, 8, con));
 379 }
 380
 381
 382
 383 /*
 384  */
 385 /*
 386 cl_mapped_cell::cl_mapped_cell(class cl_cell *realcell)
 387 {
 388   real_cell= realcell;
 389 }
 390
 391 cl_mapped_cell::~cl_mapped_cell(void)
 392 {}
 393
 394 t_mem
 395 cl_mapped_cell::read(void)
 396 {
 397   return(real_cell->read());
 398 }
 399
 400 t_mem
 401 cl_mapped_cell::read(enum hw_cath skip)
 402 {
 403   return(real_cell->read(skip));
 404 }
 405
 406 t_mem
 407 cl_mapped_cell::get(void)
 408 {
 409   return(real_cell->get());
 410 }
 411
 412 t_mem
 413 cl_mapped_cell::write(t_mem val)
 414 {
 415   return(real_cell->write(val));
 416 }
 417
 418 t_mem
 419 cl_mapped_cell::set(t_mem val)
 420 {
 421   return(real_cell->set(val));
 422 }
 423
 424 t_mem
 425 cl_mapped_cell::add(long what)
 426 {
 427   return(real_cell->add(what));
 428 }
 429
 430 t_mem
 431 cl_mapped_cell::wadd(long what)
 432 {
 433   return(real_cell->wadd(what));
 434 }
 435
 436 void
 437 cl_mapped_cell::set_bit1(t_mem bits)
 438 {
 439   return(real_cell->set_bit1(bits));
 440 }
 441
 442 void
 443 cl_mapped_cell::set_bit0(t_mem bits)
 444 {
 445   return(real_cell->set_bit0(bits));
 446 }
 447
 448 class cl_cell *
 449 cl_mapped_cell::add_hw(class cl_hw *hw, int *ith)
 450 {
 451   return(real_cell->add_hw(hw, ith));
 452 }
 453
 454 class cl_hw *
 455 cl_mapped_cell::get_hw(int ith)
 456 {
 457   return(real_cell->get_hw(ith));
 458 }
 459
 460 class cl_event_handler *
 461 cl_mapped_cell::get_event_handler(void)
 462 {
 463   return(real_cell->get_event_handler());
 464 }
 465 */
 466
 467 /*
 468  */
 469
 470 cl_m::cl_m(enum mem_class atype, char *aclass_name, t_addr asize, int awidth,
 471            class cl_uc *auc):
 472   cl_memory(aclass_name, asize, awidth)
 473   //cl_mem(atype, aclass_name, 0, awidth, auc)
 474 {
 475   t_addr a;
 476
 477   //size= asize;
 478   width= awidth;
 479   set_name(aclass_name);
 480   uc= auc;
 481   type= atype;
 482
 483   array= (class cl_cell **)calloc(size, sizeof(class cl_cell *));
 484   for (a= 0; a < size; a++)
 485     array[a]= new cl_normal_cell(width);
 486   bus_mask= 0;
 487   t_addr i;
 488   for (i= 1; i < size; i<<=1)
 489     bus_mask= (bus_mask<<1)|1;
 490   dummy= new cl_normal_cell(width);
 491   //mk_cell(size, 0);
 492 }
 493
 494 cl_m::~cl_m(void)
 495 {
 496   t_addr a;
 497
 498   for (a= 0; a < size; a++)
 499     delete array[a];
 500   free(array);
 501   delete dummy;
 502 }
 503
 504 int
 505 cl_m::init(void)
 506 {
 507   t_addr i;
 508
 509   cl_memory::init();
 510
 511   for (i= 0; i < size; i++)
 512     set(i, (type==MEM_ROM)?(-1):0);
 513   return(0);
 514 }
 515
 516 char *
 517 cl_m::id_string(void)
 518 {
 519   char *s= get_id_string(mem_ids, type);
 520
 521   return(s?s:(char*)"NONE");
 522 }
 523
 524 /*void
 525 cl_m::mk_cell(t_addr addr, class cl_cell *cell)
 526 {
 527   if (!cell)
 528     cell= new cl_cell(width);
 529   class cl_cell *p;
 530   if (addr >= size)
 531     p= dummy;
 532   else
 533     p= array[addr];
 534   if (p == 0)
 535     {
 536       p= (class cl_cell *)calloc(1, sizeof(*cell));
 537     }
 538   else
 539     {
 540       p->destroy();
 541       p= (class cl_cell *)realloc(p, sizeof(cell));
 542     }
 543   memcpy(p, cell, sizeof(*cell));
 544   cell->destroy();
 545   delete cell;
 546 }*/
 547
 548 t_mem
 549 cl_m::read(t_addr addr)
 550 {
 551   //addr&= bus_mask;
 552   if (addr >= size)
 553     {
 554       err_inv_addr(addr);
 555       return(dummy->read());
 556     }
 557   return(array[addr]->read());
 558 }
 559
 560 t_mem
 561 cl_m::read(t_addr addr, enum hw_cath skip)
 562 {
 563   //addr&= bus_mask;
 564   if (addr >= size)
 565     {
 566       err_inv_addr(addr);
 567       return(dummy->read(skip));
 568     }
 569   return(array[addr]->read(skip));
 570 }
 571
 572 t_mem
 573 cl_m::get(t_addr addr)
 574 {
 575   addr&= bus_mask;
 576   if (addr >= size)
 577     {
 578       err_inv_addr(addr);
 579       return(dummy->get());
 580     }
 581   return(array[addr]->get());
 582 }
 583
 584 t_mem
 585 cl_m::write(t_addr addr, t_mem val)
 586 {
 587   //addr&= bus_mask;
 588   if (addr >= size)
 589     {
 590       err_inv_addr(addr);
 591       return(dummy->write(val));
 592     }
 593   return(array[addr]->write(val));
 594 }
 595
 596 void
 597 cl_m::set(t_addr addr, t_mem val)
 598 {
 599   if (addr >= size)
 600     {
 601       err_inv_addr(addr);
 602       //addr&= bus_mask;
 603       dummy->set(val);
 604       return;
 605     }
 606   //addr&= bus_mask;
 607   array[addr]->set(val);
 608 }
 609
 610 class cl_cell *
 611 cl_m::get_cell(t_addr addr)
 612 {
 613   //addr&= bus_mask;
 614   if (addr >= size)
 615     {
 616       err_inv_addr(addr);
 617       return(dummy);
 618     }
 619   return(array[addr]);
 620 }
 621
 622
 623 /* Set or clear bits, without callbacks */
 624
 625 void
 626 cl_m::set_bit1(t_addr addr, t_mem bits)
 627 {
 628   class cl_cell *cell;
 629
 630   addr&= bus_mask;
 631   if (addr >= size)
 632     {
 633       err_inv_addr(addr);
 634       cell= dummy;
 635     }
 636   else
 637     cell= array[addr];
 638   bits&= cell->get_mask();
 639   cell->set(cell->get() | bits);
 640 }
 641
 642 void
 643 cl_m::write_bit1(t_addr addr, t_mem bits)
 644 {
 645   class cl_cell *cell;
 646
 647   addr&= bus_mask;
 648   if (addr >= size)
 649     {
 650       err_inv_addr(addr);
 651       cell= dummy;
 652     }
 653   else
 654     cell= array[addr];
 655   bits&= cell->get_mask();
 656   cell->write(cell->get() | bits);
 657 }
 658
 659 void
 660 cl_m::set_bit0(t_addr addr, t_mem bits)
 661 {
 662   class cl_cell *cell;
 663
 664   addr&= bus_mask;
 665   if (addr >= size)
 666     {
 667       err_inv_addr(addr);
 668       cell= dummy;
 669     }
 670   else
 671     cell= array[addr];
 672   bits&= cell->get_mask();
 673   cell->set(cell->get() & ~bits);
 674 }
 675
 676 void
 677 cl_m::write_bit0(t_addr addr, t_mem bits)
 678 {
 679   class cl_cell *cell;
 680
 681   addr&= bus_mask;
 682   if (addr >= size)
 683     {
 684       err_inv_addr(addr);
 685       cell =dummy;
 686     }
 687   else
 688     cell= array[addr];
 689   bits&= cell->get_mask();
 690   cell->write(cell->get() & ~bits);
 691 }
 692
 693 t_mem
 694 cl_m::add(t_addr addr, long what)
 695 {
 696   addr&= bus_mask;
 697   if (addr >= size)
 698     {
 699       err_inv_addr(addr);
 700       return(dummy->add(what));
 701     }
 702   return(array[addr]->add(what));
 703 }
 704
 705 t_mem
 706 cl_m::wadd(t_addr addr, long what)
 707 {
 708   addr&= bus_mask;
 709   if (addr >= size)
 710     {
 711       err_inv_addr(addr);
 712       return(dummy->wadd(what));
 713     }
 714   return(array[addr]->wadd(what));
 715 }
 716
 717 bool
 718 cl_m::search_next(bool case_sensitive, t_mem *array, int len, t_addr *addr)
 719 {
 720   t_addr a;
 721   int i;
 722   bool found;
 723
 724   if (addr == NULL)
 725     a= 0;
 726   else
 727     a= *addr;
 728
 729   if (a+len > size)
 730     return(DD_FALSE);
 731
 732   found= DD_FALSE;
 733   while (!found &&
 734          a+len <= size)
 735     {
 736       bool match= DD_TRUE;
 737       for (i= 0; i < len && match; i++)
 738         {
 739           t_mem d1, d2;
 740           d1= get(a+i);
 741           d2= array[i];
 742           if (!case_sensitive)
 743             {
 744               if (/*d1 < 128*/isalpha(d1))
 745                 d1= toupper(d1);
 746               if (/*d2 < 128*/isalpha(d2))
 747                 d2= toupper(d2);
 748             }
 749           match= d1 == d2;
 750         }
 751       found= match;
 752       if (!found)
 753         a++;
 754     }
 755
 756   if (addr)
 757     *addr= a;
 758   return(found);
 759 }
 760
 761 class cl_cell *
 762 cl_m::register_hw(t_addr addr, class cl_hw *hw, int *ith, bool announce)
 763 {
 764   class cl_cell *cell, *nc;
 765
 766   addr&= bus_mask;
 767   if (addr >= size)
 768     cell= dummy;
 769   else
 770     cell= array[addr];
 771
 772   if (cell->get_type() & (CELL_HW_READ | CELL_HW_WRITE))
 773     {
 774       /* Already registered */
 775       return(cell->add_hw(hw, ith));
 776     }
 777   else if (cell->get_type() & (CELL_READ_BRK | CELL_WRITE_BRK))
 778     {
 779       /* Event break is set on it, now register hw */
 780       nc= new cl_ev_reg_cell(width, uc);
 781       nc->set(cell->get());
 782       nc->set_type(nc->get_type() &
 783                    ~(CELL_GENERAL|CELL_READ_BRK|CELL_WRITE_BRK));
 784       nc->set_type(nc->get_type() | (cell->get_type() & CELL_GENERAL));
 785       class cl_event_handler *eh= nc->get_event_handler();
 786       if (eh)
 787         nc->set_type(nc->get_type() | eh->copy_from(cell->get_event_handler()));
 788       nc->add_hw(hw, ith);
 789     }
 790   else
 791     {
 792       /* Normal cell, register hw */
 793       nc= new cl_registered_cell(width);
 794       nc->set(cell->get());
 795       nc->set_type(nc->get_type() & ~CELL_GENERAL);
 796       nc->set_type(nc->get_type() | (cell->get_type() & CELL_GENERAL));
 797       nc->add_hw(hw, ith);
 798     }
 799
 800   if (addr >= size)
 801     {
 802       delete dummy;
 803       dummy= nc;
 804     }
 805   else
 806     {
 807       delete array[addr];
 808       array[addr]= nc;
 809     }
 810   if (announce)
 811     uc->sim->/*app->*/mem_cell_changed(this, addr);
 812   return(nc);
 813 }
 814
 815 void
 816 cl_m::set_brk(t_addr addr, class cl_brk *brk)
 817 {
 818   class cl_cell *cell, *nc;
 819   char e= '_';
 820
 821   addr&= bus_mask;
 822   if (addr >= size)
 823     cell= dummy;
 824   else
 825     cell= array[addr];
 826
 827   switch (brk->get_event())
 828     {
 829     case brkWRITE: case brkWXRAM: case brkWIRAM: case brkWSFR:
 830       e= 'W';
 831       break;
 832     case brkREAD: case brkRXRAM: case brkRCODE: case brkRIRAM: case brkRSFR:
 833       e= 'R';
 834       break;
 835     case brkNONE:
 836       set_cell_flag(addr, DD_TRUE, CELL_FETCH_BRK);
 837       return;
 838       break;
 839     default: e= '.'; break;
 840     }
 841
 842   if (cell->get_type() & (CELL_HW_READ | CELL_HW_WRITE))
 843     {
 844       /* Hw is registered on it, now set event break */
 845       nc= new cl_ev_reg_cell(width, uc);
 846       nc->set(cell->get());
 847       nc->set_type(nc->get_type() & ~CELL_GENERAL);
 848       nc->set_type(nc->get_type() | (cell->get_type() & CELL_GENERAL));
 849       int i= 0;
 850       class cl_hw *hw;
 851       while ((hw= cell->get_hw(i)) != 0)
 852         {
 853           nc->add_hw(hw, 0);
 854           i++;
 855         }
 856       if (((class cl_registered_cell *)cell)->hardwares)
 857         {
 858           free(((class cl_registered_cell *)cell)->hardwares);
 859           ((class cl_registered_cell *)cell)->hardwares= 0;
 860         }
 861       class cl_event_handler *eh;
 862       if ((eh= nc->get_event_handler()))
 863         nc->set_type(nc->get_type() | eh->add_bp(brk));
 864     }
 865   else if (cell->get_type() & (CELL_READ_BRK | CELL_WRITE_BRK))
 866     {
 867       /* Break is already set on it */
 868       class cl_event_handler *eh;
 869       if ((eh= cell->get_event_handler()))
 870         cell->set_type(cell->get_type() | eh->add_bp(brk));
 871       return;
 872     }
 873   else
 874     {
 875       /* Normal cell, set event break */
 876       nc= new cl_event_cell(width, uc);
 877       nc->set(cell->get());
 878       nc->set_type(nc->get_type() & ~CELL_GENERAL);
 879       nc->set_type(nc->get_type() | (cell->get_type() & CELL_GENERAL));
 880       class cl_event_handler *eh;
 881       if ((eh= nc->get_event_handler()))
 882         nc->set_type(nc->get_type() | eh->add_bp(brk));
 883     }
 884
 885   if (addr >= size)
 886     {
 887       delete dummy;
 888       dummy= nc;
 889     }
 890   else
 891     {
 892       delete array[addr];
 893       array[addr]= nc;
 894     }
 895   uc->sim->/*app->*/mem_cell_changed(this, addr);
 896 }
 897
 898 void
 899 cl_m::del_brk(t_addr addr, class cl_brk *brk)
 900 {
 901   class cl_cell *cell, *nc;
 902   char e= '_';
 903
 904   addr&= bus_mask;
 905   if (addr >= size)
 906     cell= dummy;
 907   else
 908     cell= array[addr];
 909
 910   switch (brk->get_event())
 911     {
 912     case brkWRITE: case brkWXRAM: case brkWIRAM: case brkWSFR: e= 'W'; break;
 913     case brkREAD: case brkRXRAM: case brkRCODE: case brkRIRAM: case brkRSFR:
 914       e= 'R';
 915       break;
 916     case brkNONE:
 917       set_cell_flag(addr, DD_FALSE, CELL_FETCH_BRK);
 918       return;
 919       break;
 920     default: e= '.'; break;
 921     }
 922
 923   if (cell->get_type() & (CELL_HW_READ | CELL_HW_WRITE))
 924     {
 925       /* Hw is registered on it, delete event break */
 926       class cl_event_handler *eh;
 927       int t= CELL_NORMAL;
 928       if ((eh= cell->get_event_handler()))
 929         t= eh->del_bp(brk);
 930       if (t & (CELL_READ_BRK|CELL_WRITE_BRK))
 931         {
 932           cell->set_type(cell->get_type() & ~(CELL_READ_BRK|CELL_WRITE_BRK));
 933           cell->set_type(cell->get_type() | t);
 934           return;
 935         }
 936       nc= new cl_registered_cell(width);
 937       nc->set(cell->get());
 938       nc->set_type(cell->get_type() & ~CELL_GENERAL);
 939       nc->set_type(cell->get_type() | (cell->get_type() & CELL_GENERAL));
 940       int i= 0;
 941       class cl_hw *hw;
 942       while ((hw= cell->get_hw(i)) != 0)
 943         {
 944           nc->add_hw(hw, 0);
 945           i++;
 946         }
 947       if (((class cl_registered_cell *)cell)->hardwares)
 948         free(((class cl_registered_cell *)cell)->hardwares);
 949     }
 950   else if (cell->get_type() & (CELL_READ_BRK | CELL_WRITE_BRK))
 951     {
 952       /* Break already set on it, delete brk */
 953       class cl_event_handler *eh;
 954       int t= CELL_NORMAL;
 955       if ((eh= cell->get_event_handler()))
 956         t= eh->del_bp(brk);
 957       if (t & (CELL_READ_BRK|CELL_WRITE_BRK))
 958         {
 959           cell->set_type(cell->get_type() & ~(CELL_READ_BRK|CELL_WRITE_BRK));
 960           cell->set_type(cell->get_type() | t);
 961           return;
 962         }
 963       nc= new cl_normal_cell(width);
 964       nc->set(cell->get());
 965       nc->set_type(cell->get_type() & ~CELL_GENERAL);
 966       nc->set_type(cell->get_type() | (cell->get_type() & CELL_GENERAL));
 967       return;
 968     }
 969   else
 970     {
 971       /* Normal cell */
 972       return;
 973     }
 974
 975   if (addr >= size)
 976     {
 977       delete dummy;
 978       dummy= nc;
 979     }
 980   else
 981     {
 982       delete array[addr];
 983       array[addr]= nc;
 984     }
 985   uc->sim->/*app->*/mem_cell_changed(this, addr);
 986 }
 987
 988
 989 #ifdef STATISTIC
 990 unsigned long
 991 cl_m::get_nuof_reads(void)
 992 {
 993   unsigned long res= 0;
 994   t_addr i;
 995   for (i= 0; i < size; i++)
 996     res+= array[i]->nuof_reads;
 997   return(res);
 998 }
 999
1000 unsigned long
1001 cl_m::get_nuof_writes(void)
1002 {
1003   unsigned long res= 0;
1004   t_addr i;
1005   for (i= 0; i < size; i++)
1006     res+= array[i]->nuof_writes;
1007   return(res);
1008 }
1009
1010 void
1011 cl_m::set_nuof_reads(unsigned long value)
1012 {
1013   t_addr i;
1014   for (i= 0; i < size; i++)
1015     array[i]->nuof_reads= value;
1016   dummy->nuof_reads= value;
1017 }
1018
1019 void
1020 cl_m::set_nuof_writes(unsigned long value)
1021 {
1022   t_addr i;
1023   for (i= 0; i < size; i++)
1024     array[i]->nuof_writes= value;
1025   dummy->nuof_writes= value;
1026 }
1027 #endif
1028
1029
1030 cl_normal_cell::cl_normal_cell(uchar awidth):
1031   cl_cell()
1032 {
1033   type= CELL_NORMAL;
1034   data= 0;
1035   mask= 1;
1036   width= awidth;
1037   for (--awidth; awidth; awidth--)
1038     {
1039       mask<<= 1;
1040       mask|= 1;
1041     }
1042 }
1043
1044 t_mem
1045 cl_normal_cell::add(long what)
1046 {
1047   t_mem d;
1048
1049   if (width <= 8)
1050     d= TYPE_BYTE(data) + what;
1051   else if (width <= 16)
1052     d= TYPE_WORD(data) + what;
1053   else
1054     d= TYPE_DWORD(data) + what;
1055   return(data= d & mask);
1056 }
1057
1058 t_mem
1059 cl_normal_cell::wadd(long what)
1060 {
1061   t_mem d;
1062
1063   if (width <= 8)
1064     d= TYPE_BYTE(data) + what;
1065   else if (width <= 16)
1066     d= TYPE_WORD(data) + what;
1067   else
1068     d= TYPE_DWORD(data) + what;
1069   return(write(d));
1070 }
1071
1072 void
1073 cl_normal_cell::set_bit1(t_mem bits)
1074 {
1075   bits&= mask;
1076   data|= bits;
1077 }
1078
1079 void
1080 cl_normal_cell::set_bit0(t_mem bits)
1081 {
1082   bits&= mask;
1083   data&= ~bits;
1084 }
1085
1086
1087 /*
1088  */
1089
1090 cl_registered_cell::cl_registered_cell(uchar awidth):
1091   cl_normal_cell(awidth)
1092 {
1093   type= CELL_HW_READ | CELL_HW_WRITE;
1094   //hws= new cl_list(1, 1);
1095   hardwares= 0;
1096   nuof_hws= 0;
1097 }
1098
1099 cl_registered_cell::~cl_registered_cell(void)
1100 {
1101   if (hardwares)
1102     free(hardwares);
1103 }
1104
1105 /*void
1106 cl_registered_cell::destroy(void)
1107 {
1108   hardwares= 0;
1109   nuof_hws= 0;
1110 }*/
1111
1112 t_mem
1113 cl_registered_cell::read(void)
1114 {
1115   int i;
1116   t_mem d= data;
1117
1118   if (nuof_hws)
1119     for (i= 0; i < nuof_hws; i++)
1120       {
1121         d= hardwares[i]->read(this);
1122         ;
1123       }
1124 #ifdef STATISTIC
1125   nuof_reads++;
1126 #endif
1127   return(d & mask);
1128 }
1129
1130 t_mem
1131 cl_registered_cell::read(enum hw_cath skip)
1132 {
1133   int i;
1134   t_mem d= data;
1135
1136   if (nuof_hws)
1137     for (i= 0; i < nuof_hws; i++)
1138       {
1139         if ((skip & hardwares[i]->cathegory) == 0)
1140           d= hardwares[i]->read(this);
1141         ;
1142       }
1143 #ifdef STATISTIC
1144   nuof_reads++;
1145 #endif
1146   return(d & mask);
1147 }
1148
1149 t_mem
1150 cl_registered_cell::write(t_mem val)
1151 {
1152   int i;
1153
1154   val&= mask;
1155   if (nuof_hws)
1156     for (i= 0; i < nuof_hws; i++)
1157       {
1158         hardwares[i]->write(this, &val);
1159         ;
1160       }
1161 #ifdef STATISTIC
1162   nuof_writes++;
1163 #endif
1164   return(data= val & mask);
1165 }
1166
1167 class cl_cell *
1168 cl_registered_cell::add_hw(class cl_hw *hw, int *ith)
1169 {
1170   if (!hw)
1171     {
1172       /* Whatta hell!? */
1173       return(0);
1174     }
1175   if (!hardwares)
1176     hardwares= (class cl_hw **)malloc(sizeof(class cl_hw *));
1177   else
1178     hardwares= (class cl_hw **)realloc(hardwares,
1179                                        sizeof(class c_hw *) * (nuof_hws+1));
1180   hardwares[nuof_hws]= hw;
1181   nuof_hws++;
1182   if (ith)
1183     *ith= nuof_hws-1;
1184   return(this);
1185 }
1186
1187 class cl_hw *
1188 cl_registered_cell::get_hw(int ith)
1189 {
1190   if (ith >= nuof_hws)
1191     return(0);
1192   return(hardwares[ith]);
1193 }
1194
1195
1196 /*
1197  */
1198
1199 cl_event_cell::cl_event_cell(uchar awidth, class cl_uc *auc):
1200   cl_normal_cell(awidth)
1201 {
1202   eh= new cl_event_handler(auc);
1203 }
1204
1205 cl_event_cell::~cl_event_cell(void)
1206 {
1207   delete eh;
1208 }
1209
1210 t_mem
1211 cl_event_cell::read(void)
1212 {
1213   if (type & CELL_READ_BRK)
1214     eh->read();
1215   return(cl_normal_cell::read());
1216 }
1217
1218 t_mem
1219 cl_event_cell::write(t_mem val)
1220 {
1221   if (type & CELL_WRITE_BRK)
1222     eh->write();
1223   return(cl_normal_cell::write(val));
1224 }
1225
1226
1227 /*
1228  */
1229
1230 cl_ev_reg_cell::cl_ev_reg_cell(uchar awidth, class cl_uc *auc):
1231   cl_registered_cell(awidth)
1232 {
1233   eh= new cl_event_handler(auc);
1234 }
1235
1236 cl_ev_reg_cell::~cl_ev_reg_cell(void)
1237 {}
1238
1239 t_mem
1240 cl_ev_reg_cell::read(void)
1241 {
1242   if (type & CELL_READ_BRK)
1243     eh->read();
1244   return(cl_registered_cell::read());
1245 }
1246
1247 t_mem
1248 cl_ev_reg_cell::write(t_mem val)
1249 {
1250   if (type & CELL_WRITE_BRK)
1251     eh->write();
1252   return(cl_registered_cell::write(val));
1253 }
1254
1255
1256 /*
1257  */
1258
1259 cl_event_handler::cl_event_handler(class cl_uc *auc):
1260   cl_base()
1261 {
1262   uc= auc;
1263   read_bps= new cl_list(1, 1);
1264   write_bps= new cl_list(1, 1);
1265 }
1266
1267 cl_event_handler::~cl_event_handler(void)
1268 {
1269   read_bps->disconn_all();
1270   write_bps->disconn_all();
1271   delete read_bps;
1272   delete write_bps;
1273 }
1274
1275 void
1276 cl_event_handler::write(void)
1277 {
1278   int i;
1279
1280   for (i= 0; i < write_bps->count; i++)
1281     {
1282       class cl_brk *bp= (class cl_brk *)(write_bps->at(i));
1283       uc->events->add(bp);
1284     }
1285 }
1286
1287 void
1288 cl_event_handler::read(void)
1289 {
1290   int i;
1291
1292   for (i= 0; i < read_bps->count; i++)
1293     {
1294       class cl_brk *bp= (class cl_brk *)(read_bps->at(i));
1295       uc->events->add(bp);
1296     }
1297 }
1298
1299 int
1300 cl_event_handler::add_bp(class cl_brk *bp)
1301 {
1302   int t= CELL_NORMAL;
1303
1304   if (!bp)
1305     return(CELL_NORMAL);
1306   switch (bp->get_event())
1307     {
1308     case brkWRITE: case brkWXRAM: case brkWIRAM: case brkWSFR:
1309       t|= CELL_WRITE_BRK;
1310       write_bps->add(bp);
1311       break;
1312     case brkREAD: case brkRXRAM: case brkRCODE: case brkRIRAM: case brkRSFR:
1313       t|= CELL_READ_BRK;
1314       read_bps->add(bp);
1315       break;
1316     default:
1317       t|= CELL_READ_BRK | CELL_WRITE_BRK;
1318       read_bps->add(bp);
1319       write_bps->add(bp);
1320       break;
1321     }
1322   return(t);
1323 }
1324
1325 int
1326 cl_event_handler::copy_from(class cl_event_handler *eh)
1327 {
1328   int i, t= CELL_NORMAL;
1329
1330   if (!eh)
1331     return(t);
1332   for (i= 0; i < eh->read_bps->count; i++)
1333     {
1334       class cl_brk *bp= (class cl_brk *)(eh->read_bps->at(i));
1335       t|= add_bp(bp);
1336     }
1337   for (i= 0; i < eh->write_bps->count; i++)
1338     {
1339       class cl_brk *bp= (class cl_brk *)(eh->write_bps->at(i));
1340       t|= add_bp(bp);
1341     }
1342   return(t);
1343 }
1344
1345 int
1346 cl_event_handler::del_bp(class cl_brk *bp)
1347 {
1348   int t= CELL_NORMAL;
1349
1350   write_bps->disconn(bp);
1351   read_bps->disconn(bp);
1352   if (write_bps->count)
1353     t|= CELL_WRITE_BRK;
1354   if (read_bps->count)
1355     t|= CELL_READ_BRK;
1356   return(t);
1357 }
1358
1359