[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.8

version 1.6, 2004/08/18 15:42:28 version 1.8, 2008/06/02 20:07:30
Line 15 Line 15
 #include        "palettes.h"  #include        "palettes.h"
 #include        "makescrn.h"  #include        "makescrn.h"
 #include        "sound.h"  #include        "sound.h"
 // #include     "sndctrl.h"  
 // #include     "font.h"  
 #include        "fddfile.h"  #include        "fddfile.h"
 // #include     "fdd_mtr.h"  
   
   
 #if defined(MACOS)  #if defined(MACOS)
 #define CRCONST         str_cr  #define CRCONST         str_cr
Line 64  typedef struct { Line 60  typedef struct {
 #include "statsave.tbl"  #include "statsave.tbl"
   
   
 // ----  /* ---- */
   
 // 関数ポインタを intに変更。  /* 関数ポインタを intに変更。 */
 static UINT32 proc2id(INTPTR func, const PROCTBL *tbl, UINT count) {  static UINT32 proc2id(INTPTR func, const PROCTBL *tbl, UINT count) {
   
         while(count) {          while(count) {
Line 92  static INTPTR id2proc(UINT32 id, const P Line 88  static INTPTR id2proc(UINT32 id, const P
 }  }
   
   
 // ----  /* ---- */
   
 enum {  enum {
         SFFILEH_WRITE   = 0x0001,          SFFILEH_WRITE   = 0x0001,
Line 324  void statflag_seterr(STFLAGH sfh, const  Line 320  void statflag_seterr(STFLAGH sfh, const 
 }  }
   
   
 // ---- common  /* common */
   
 static int flagsave_common(STFLAGH sfh, const SFENTRY *tbl) {  static int flagsave_common(STFLAGH sfh, const SFENTRY *tbl) {
   
Line 337  static int flagload_common(STFLAGH sfh,  Line 333  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;  
   
         for (i=0; i<sizeof(evtnum)/sizeof(ENUMTBL); i++) {          if (next == NEVENTITEM_NONE) {
                 if (evtnum[i].evt == evt) {                  return((UINT32)-2);
                         return(evtnum[i].id);          }
                 }          else if (next == NEVENTITEM_TERM) {
                   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);
 }  }
   
   
 // ---- disk  /* disk */
   
 typedef struct {  typedef struct {
         OEMCHAR fname[MAX_PATH];          OEMCHAR fname[MAX_PATH];
Line 574  static int flagload_disk(STFLAGH sfh, co Line 525  static int flagload_disk(STFLAGH sfh, co
 }  }
   
   
 // ----  /* checker */
   
 static int flagcheck_versize(STFLAGH sfh, const SFENTRY *tbl) {  static int flagcheck_versize(STFLAGH sfh, const SFENTRY *tbl) {
   
Line 593  static int flagcheck_veronly(STFLAGH sfh Line 544  static int flagcheck_veronly(STFLAGH sfh
 }  }
   
   
 // ----  /* interface */
   
 int statsave_save(const OEMCHAR *filename) {  int statsave_save(const OEMCHAR *filename) {
   
Line 701  const SFENTRY *tblterm; Line 652  const SFENTRY *tblterm;
                 return(STATFLAG_FAILURE);                  return(STATFLAG_FAILURE);
         }          }
   
         // PCCORE read!          /* PCCORE read! */
         ret = statflag_readsection(sffh);          ret = statflag_readsection(sffh);
         if ((ret != STATFLAG_SUCCESS) ||          if ((ret != STATFLAG_SUCCESS) ||
                 (memcmp(sffh->sfh.hdr.index, xmiltbl[0].index, 10))) {                  (memcmp(sffh->sfh.hdr.index, xmiltbl[0].index, 10))) {
Removed from v.1.6  
changed lines
  Added in v.1.8

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