[BACK]Return to nevent.c CVS log [TXT] [DIR] Up to [RetroPC.NET] / xmil

Diff for /xmil/nevent.c between versions 1.2 and 1.5

version 1.2, 2004/08/11 16:09:04 version 1.5, 2008/06/02 20:07:30
Line 9 Line 9
   
 void nevent_allreset(void) {  void nevent_allreset(void) {
   
           UINT    i;
   
         ZeroMemory(&nevent, sizeof(nevent));          ZeroMemory(&nevent, sizeof(nevent));
           nevent.first = NEVENTITEM_TERM;
           for (i=0; i<NEVENT_MAXEVENTS; i++) {
                   nevent.item[i].next = NEVENTITEM_NONE;
           }
 }  }
   
 void nevent_progress(void) {  void nevent_progress(void) {
   
         SINT32          nextbase;  
         UINT            eventnum;  
         UINT            waitevents;  
         UINT            i;  
         UINT            curid;  
         NEVENTITEM      item;          NEVENTITEM      item;
         UINT            waitlevel[NEVENT_MAXEVENTS];          NEVENTITEM      itemnext;
           NEVENTITEM      *witem;
           NEVENTITEM      waititem[NEVENT_MAXEVENTS];
           SINT32          nextbase;
           NEVENTITEM      *wi;
   
         CPU_CLOCK += CPU_BASECLOCK;          CPU_CLOCK += CPU_BASECLOCK;
   
         nextbase = NEVENT_MAXCLOCK;          item = nevent.first;
         eventnum = 0;          witem = waititem;
         waitevents = 0;          while(item != NEVENTITEM_TERM) {
         for (i=0; i<nevent.readyevents; i++) {  
                 curid = nevent.level[i];  
                 item = nevent.item + curid;  
                 item->clock -= CPU_BASECLOCK;                  item->clock -= CPU_BASECLOCK;
                 if (item->clock > 0) {                  if (item->clock > 0) {
                         // イベント待ち中                          break;
                         nevent.level[eventnum++] = curid;  
                         if (nextbase >= item->clock) {  
                                 nextbase = item->clock;  
                         }  
                 }  
                 else {  
                         waitlevel[waitevents++] = curid;  
 //                      TRACEOUT(("event = %x", curid));  
                 }                  }
                   *witem++ = item;
                   itemnext = item->next;
                   item->next = NEVENTITEM_NONE;
                   item = itemnext;
           }
           nevent.first = item;
           if (item != NEVENTITEM_TERM) {
                   nextbase = item->clock;
                   item = item->next;
                   while(item != NEVENTITEM_TERM) {
                           item->clock -= CPU_BASECLOCK;
                           item = item->next;
                   }
           }
           else {
                   nextbase = NEVENT_MAXCLOCK;
         }          }
         nevent.readyevents = eventnum;  
         CPU_BASECLOCK = nextbase;          CPU_BASECLOCK = nextbase;
         CPU_REMCLOCK += nextbase;          CPU_REMCLOCK += nextbase;
 //      TRACEOUT(("nextbase = %d (%d)", nextbase, CPU_REMCLOCK));          /* TRACEOUT(("nextbase = %d (%d)", nextbase, CPU_REMCLOCK)); */
   
         // イベント発生          /* イベント発生 */
         for (i=0; i<waitevents; i++) {          wi = waititem;
                 curid = waitlevel[i];          while(wi < witem) {
                 item = nevent.item + curid;                  item = *wi++;
                 if (item->proc != NULL) {                  if (item->proc != NULL) {
                         item->proc(curid);                          item->proc(item - nevent.item);
                 }                  }
         }          }
 }  }
   
 void nevent_reset(UINT id) {  void nevent_reset(UINT id) {
   
         UINT    i;          NEVENTITEM      item;
           NEVENTITEM      *back;
           NEVENTITEM      cur;
   
         // 現在進行してるイベントを検索          item = nevent.item + id;
         for (i=0; i<nevent.readyevents; i++) {          if (item->next != NEVENTITEM_NONE) {
                 if (nevent.level[i] == id) {                  back = &nevent.first;
                         break;                  cur = *back;
                 }                  while(cur != item) {
         }                          __ASSERT(cur != NEVENTITEM_NONE);
         // イベントは存在した？                          __ASSERT(cur != NEVENTITEM_TERM);
         if (i < nevent.readyevents) {                          back = &cur->next;
                 // 存在していたら削る                          cur = *back;
                 nevent.readyevents--;  
                 for (; i<nevent.readyevents; i++) {  
                         nevent.level[i] = nevent.level[i+1];  
                 }                  }
                   *back = cur->next;
                   cur->next = NEVENTITEM_NONE;
         }          }
 }  }
   
Line 82  void nevent_set(UINT id, SINT32 eventclo Line 92  void nevent_set(UINT id, SINT32 eventclo
   
         SINT32          clock;          SINT32          clock;
         NEVENTITEM      item;          NEVENTITEM      item;
         UINT            eventid;          NEVENTITEM      *back;
         UINT            i;          NEVENTITEM      n;
           NEVENTITEM      p;
   
         TRACEOUT(("event %d - %xclocks", id, eventclock));          /* TRACEOUT(("event %d - %xclocks", id, eventclock)); */
   
         clock = CPU_BASECLOCK - CPU_REMCLOCK;          clock = CPU_BASECLOCK - CPU_REMCLOCK;
         item = nevent.item + id;          item = nevent.item + id;
   
         item->baseclock = eventclock;          item->baseclock = eventclock;
         item->proc = proc;          item->proc = proc;
         if (absolute) {          if (absolute) {
Line 98  void nevent_set(UINT id, SINT32 eventclo Line 110  void nevent_set(UINT id, SINT32 eventclo
                 item->clock += eventclock;                  item->clock += eventclock;
         }          }
   
         // イベントの削除          if (item->next != NEVENTITEM_NONE) {
         nevent_reset(id);                  back = &nevent.first;
                   n = *back;
         // イベントの挿入位置の検索                  while(n != item) {
         for (eventid=0; eventid<nevent.readyevents; eventid++) {                          __ASSERT(n != NEVENTITEM_NONE);
                 if (item->clock < nevent.item[nevent.level[eventid]].clock) {                          __ASSERT(n != NEVENTITEM_TERM);
                         break;                          back = &n->next;
                 }                          n = *back;
         }                  }
                   *back = n->next;
         // イベントの挿入                  n->next = NEVENTITEM_NONE;
         for (i=nevent.readyevents; i>eventid; i--) {          }
                 nevent.level[i] = nevent.level[i-1];  
         }          n = nevent.first;
         nevent.level[eventid] = id;          if ((n == NEVENTITEM_TERM) || (item->clock < n->clock)) {
         nevent.readyevents++;                  item->next = n;
                   nevent.first = item;
         // もし最短イベントだったら...  
         if (eventid == 0) {  
                 clock = CPU_BASECLOCK;                  clock = CPU_BASECLOCK;
                 if (item->clock > 0) {                  if (item->clock > 0) {
                         clock -= item->clock;                          clock -= item->clock;
                 }                  }
                 CPU_BASECLOCK -= clock;                  CPU_BASECLOCK -= clock;
                 CPU_REMCLOCK -= clock;                  CPU_REMCLOCK -= clock;
 //              TRACEOUT(("reset nextbase -%d (%d)", clock, CPU_REMCLOCK));                  /* TRACEOUT(("reset nextbase -%d (%d)", clock, CPU_REMCLOCK)); */
           }
           else {
                   p = n->next;
                   while((p != NEVENTITEM_TERM) && (item->clock >= p->clock)) {
                           n = p;
                           p = n->next;
                   }
                   item->next = p;
                   n->next = item;
         }          }
 }  }
   
Line 137  void nevent_repeat(UINT id) { Line 156  void nevent_repeat(UINT id) {
   
 void nevent_setbyms(UINT id, SINT32 ms, NEVENTCB proc, BRESULT absolute) {  void nevent_setbyms(UINT id, SINT32 ms, NEVENTCB proc, BRESULT absolute) {
   
         nevent_set(id, (pccore.realclock / 1000) * ms, proc, absolute);          SINT32  clock;
   
   #if defined(FIX_Z80A)
           clock = (2000000 * 2 / 1000) * ms;
   #else
           clock = (pccore.realclock / 1000) * ms;
   #endif
           nevent_set(id, clock, proc, absolute);
 }  }
   
 BRESULT nevent_iswork(UINT id) {  BRESULT nevent_iswork(UINT id) {
   
         UINT    i;          NEVENTITEM      item;
   
         // 現在進行してるイベントを検索          item = nevent.item + id;
         for (i=0; i<nevent.readyevents; i++) {          if (item->next != NEVENTITEM_NONE) {
                 if (nevent.level[i] == id) {                  return(TRUE);
                         return(TRUE);          }
                 }          else {
                   return(FALSE);
         }          }
         return(FALSE);  
 }  }
   
 SINT32 nevent_getwork(UINT id) {  SINT32 nevent_getwork(UINT id) {
   
         UINT    i;          NEVENTITEM      item;
   
         // 現在進行してるイベントを検索          item = nevent.item + id;
         for (i=0; i<nevent.readyevents; i++) {          if (item->next != NEVENTITEM_NONE) {
                 if (nevent.level[i] == id) {                  return(item->baseclock -
                         return(nevent.item[id].baseclock -                                                           (item->clock - (CPU_BASECLOCK - CPU_REMCLOCK)));
                                 (nevent.item[id].clock - (CPU_BASECLOCK - CPU_REMCLOCK)));          }
                 }          else {
                   return(-1);
         }          }
         return(-1);  
 }  }
   
 SINT32 nevent_getremain(UINT id) {  SINT32 nevent_getremain(UINT id) {
   
         UINT    i;          NEVENTITEM      item;
   
         // 現在進行してるイベントを検索          item = nevent.item + id;
         for (i=0; i<nevent.readyevents; i++) {          if (item->next != NEVENTITEM_NONE) {
                 if (nevent.level[i] == id) {                  return(item->clock - (CPU_BASECLOCK - CPU_REMCLOCK));
                         return(nevent.item[id].clock - (CPU_BASECLOCK - CPU_REMCLOCK));          }
                 }          else {
                   return(-1);
         }          }
         return(-1);  
 }  }
   
 void nevent_forceexit(void) {  void nevent_forceexit(void) {
Removed from v.1.2  
changed lines
  Added in v.1.5

RetroPC.NET-CVS <cvs@retropc.net>