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

Diff for /xmil/statsave.c between versions 1.6 and 1.7

version 1.6, 2004/08/18 15:42:28 version 1.7, 2005/02/04 06:42:07
Line 340  static int flagload_common(STFLAGH sfh,  Line 340  static int flagload_common(STFLAGH sfh, 
 // ---- event  // ---- event
   
 typedef struct {  typedef struct {
           UINT32  next;
         SINT32  clock;          SINT32  clock;
         SINT32  base;          SINT32  baseclock;
         UINT32  param;  
         UINT32  proc;          UINT32  proc;
 } NEVTITEM;  } NEVTITEM;
   
 typedef struct {  typedef struct {
         UINT    readys;          NEVTITEM        item[NEVENT_MAXEVENTS];
         UINT    events;          UINT32          first;
         UINT32  ready[NEVENT_MAXEVENTS];  
         UINT32  event[NEVENT_MAXEVENTS];  
 } NEVTSAVE;  } NEVTSAVE;
   
 static UINT32 evt2id(UINT evt) {  static UINT32 evt2id(NEVENTITEM next) {
   
         UINT    i;          if (next == NEVENTITEM_NONE) {
                   return((UINT32)-2);
         for (i=0; i<sizeof(evtnum)/sizeof(ENUMTBL); i++) {          }
                 if (evtnum[i].evt == evt) {          else if (next == NEVENTITEM_TERM) {
                         return(evtnum[i].id);                  return((UINT32)-1);
                 }          }
           else {
                   return(next - nevent.item);
         }          }
         return(0);  
 }  }
   
 static int nevent_write(STFLAGH sfh, const _NEVENTITEM *ne) {  static NEVENTITEM id2evt(UINT32 n) {
   
         NEVTITEM        nit;  
   
         nit.clock = ne->clock;          if (n == (UINT32)-2) {
         nit.base = ne->baseclock;                  return(NEVENTITEM_NONE);
         nit.proc = proc2id((INTPTR)ne->proc, evtproc, NELEMENTS(evtproc));          }
         nit.param = ne->param;          else if (n == (UINT32)-1) {
         return(statflag_write(sfh, &nit, sizeof(nit)));                  return(NEVENTITEM_TERM);
           }
           else if (n < NEVENT_MAXEVENTS) {
                   return(nevent.item + n);
           }
           else {
                   // error!
                   return(NEVENTITEM_TERM);
           }
 }  }
   
 static int flagsave_evt(STFLAGH sfh, const SFENTRY *tbl) {  static int flagsave_evt(STFLAGH sfh, const SFENTRY *tbl) {
   
         NEVTSAVE        nevt;          NEVTSAVE        nevt;
         UINT            i;          UINT            i;
         UINT32          id;  
         UINT            eventid[NEVENT_MAXEVENTS];  
         int                     ret;  
   
         ZeroMemory(&nevt, sizeof(nevt));  
         for (i=0; i<nevent.readyevents; i++) {  
                 id = evt2id(nevent.level[i]);  
                 if (id) {  
                         nevt.ready[nevt.readys++] = id;  
                 }  
         }  
         for (i=0; i<NEVENT_MAXEVENTS; i++) {          for (i=0; i<NEVENT_MAXEVENTS; i++) {
                 id = evt2id(i);                  nevt.item[i].next = evt2id(nevent.item[i].next);
                 if (id) {                  nevt.item[i].clock = nevent.item[i].clock;
                         eventid[i] = i;                  nevt.item[i].baseclock = nevent.item[i].baseclock;
                         nevt.event[nevt.events++] = id;                  nevt.item[i].proc = proc2id((INTPTR)nevent.item[i].proc,
                 }                                                                                                  evtproc, NELEMENTS(evtproc));
         }  
         ret = statflag_write(sfh, &nevt, sizeof(nevt));  
         for (i=0; i<nevt.events; i++) {  
                 ret |= nevent_write(sfh, nevent.item + eventid[i]);  
         }          }
           nevt.first = evt2id(nevent.first);
         (void)tbl;          (void)tbl;
         return(ret);          return(statflag_write(sfh, &nevt, sizeof(nevt)));
 }  
   
 static UINT id2evt(UINT32 id) {  
   
         UINT    i;  
   
         for (i=0; i<sizeof(evtnum)/sizeof(ENUMTBL); i++) {  
                 if (evtnum[i].id == id) {  
                         return(evtnum[i].evt);  
                 }  
         }  
         return(NEVENT_MAXEVENTS);  
 }  
   
 static int nevent_read(STFLAGH sfh, UINT32 id) {  
   
         int                     ret;  
         NEVTITEM        nit;  
         UINT            evt;  
         _NEVENTITEM     *ne;  
   
         ret = statflag_read(sfh, &nit, sizeof(nit));  
         evt = id2evt(id);  
         if (evt >= NEVENT_MAXEVENTS) {  
                 return(STATFLAG_FAILURE);  
         }  
         ne = nevent.item + evt;  
         ne->clock = nit.clock;  
         ne->baseclock = nit.base;  
         ne->proc = (NEVENTCB)id2proc(nit.proc, evtproc, NELEMENTS(evtproc));  
         ne->param = nit.param;  
         return(ret);  
 }  }
   
 static int flagload_evt(STFLAGH sfh, const SFENTRY *tbl) {  static int flagload_evt(STFLAGH sfh, const SFENTRY *tbl) {
   
         int                     ret;  
         NEVTSAVE        nevt;          NEVTSAVE        nevt;
           int                     ret;
         UINT            i;          UINT            i;
         UINT            evt;  
         UINT            readyevents;  
   
         ret = statflag_read(sfh, &nevt, sizeof(nevt));          ret = statflag_read(sfh, &nevt, sizeof(nevt));
   
         readyevents = 0;          for (i=0; i<NEVENT_MAXEVENTS; i++) {
         for (i=0; i<nevt.readys; i++) {                  nevent.item[i].next = id2evt(nevt.item[i].next);
                 evt = id2evt(nevt.ready[i]);                  nevent.item[i].clock = nevt.item[i].clock;
                 if (evt < NEVENT_MAXEVENTS) {                  nevent.item[i].baseclock = nevt.item[i].baseclock;
                         nevent.level[readyevents++] = evt;                  nevent.item[i].proc = (NEVENTCB)id2proc(nevt.item[i].proc,
                 }                                                                                                  evtproc, NELEMENTS(evtproc));
         }  
         nevent.readyevents = readyevents;  
         for (i=0; i<nevt.events; i++) {  
                 ret |= nevent_read(sfh, nevt.event[i]);  
         }          }
           nevent.first = id2evt(nevt.first);
         (void)tbl;          (void)tbl;
         return(ret);          return(ret);
 }  }
Removed from v.1.6  
changed lines
  Added in v.1.7

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