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

Diff for /np2/statsave.c between versions 1.23 and 1.25

version 1.23, 2003/12/28 08:05:18 version 1.25, 2004/01/05 09:31:24
Line 63  enum { Line 63  enum {
         NP2FLAG_DISK,          NP2FLAG_DISK,
         NP2FLAG_DMA,          NP2FLAG_DMA,
         NP2FLAG_EGC,          NP2FLAG_EGC,
           NP2FLAG_EPSON,
         NP2FLAG_EVT,          NP2FLAG_EVT,
         NP2FLAG_EXT,          NP2FLAG_EXT,
         NP2FLAG_FM,          NP2FLAG_FM,
Line 494  static int flagsave_dma(NP2FFILE f, cons Line 495  static int flagsave_dma(NP2FFILE f, cons
   
         dmabak = dmac;          dmabak = dmac;
         for (i=0; i<4; i++) {          for (i=0; i<4; i++) {
                 if ((PROC2NUM(dmabak.dmach[i].outproc, dmaproc)) ||                  if ((PROC2NUM(dmabak.dmach[i].proc.outproc, dmaproc)) ||
                         (PROC2NUM(dmabak.dmach[i].inproc, dmaproc)) ||                          (PROC2NUM(dmabak.dmach[i].proc.inproc, dmaproc)) ||
                         (PROC2NUM(dmabak.dmach[i].extproc, dmaproc))) {                          (PROC2NUM(dmabak.dmach[i].proc.extproc, dmaproc))) {
                         return(NP2FLAG_FAILURE);                          return(NP2FLAG_FAILURE);
                 }                  }
         }          }
Line 516  static int flagload_dma(NP2FFILE f, cons Line 517  static int flagload_dma(NP2FFILE f, cons
         ret = flagload_load(f, &dmac, sizeof(dmac));          ret = flagload_load(f, &dmac, sizeof(dmac));
   
         for (i=0; i<4; i++) {          for (i=0; i<4; i++) {
                 if (NUM2PROC(dmac.dmach[i].outproc, dmaproc)) {                  if (NUM2PROC(dmac.dmach[i].proc.outproc, dmaproc)) {
                         dmac.dmach[i].outproc = dma_dummyout;                          dmac.dmach[i].proc.outproc = dma_dummyout;
                         ret |= NP2FLAG_WARNING;                          ret |= NP2FLAG_WARNING;
                 }                  }
                 if (NUM2PROC(dmac.dmach[i].inproc, dmaproc)) {                  if (NUM2PROC(dmac.dmach[i].proc.inproc, dmaproc)) {
                         dmac.dmach[i].inproc = dma_dummyin;                          dmac.dmach[i].proc.inproc = dma_dummyin;
                         ret |= NP2FLAG_WARNING;                          ret |= NP2FLAG_WARNING;
                 }                  }
                 if (NUM2PROC(dmac.dmach[i].extproc, dmaproc)) {                  if (NUM2PROC(dmac.dmach[i].proc.extproc, dmaproc)) {
                         dmac.dmach[i].extproc = dma_dummyproc;                          dmac.dmach[i].proc.extproc = dma_dummyproc;
                         ret |= NP2FLAG_WARNING;                          ret |= NP2FLAG_WARNING;
                 }                  }
         }          }
Line 565  static int flagload_egc(NP2FFILE f, cons Line 566  static int flagload_egc(NP2FFILE f, cons
 }  }
   
   
   // ---- epson
   
   static int flagsave_epson(NP2FFILE f, const STENTRY *t) {
   
           int             ret;
   
           if (!(pc.model & PCMODEL_EPSON)) {
                   return(NP2FLAG_SUCCESS);
           }
           ret = flagsave_create(f, t);
           if (ret != NP2FLAG_FAILURE) {
                   ret |= flagsave_save(f, &epsonio, sizeof(epsonio));
                   ret |= flagsave_save(f, mem + 0x1c0000, 0x8000);
                   ret |= flagsave_save(f, mem + 0x1e8000, 0x18000);
                   ret |= flagsave_close(f);
           }
           return(ret);
   }
   
   static int flagload_epson(NP2FFILE f, const STENTRY *t) {
   
           int             ret;
   
           ret = flagload_load(f, &epsonio, sizeof(epsonio));
           ret |= flagload_load(f, mem + 0x1c0000, 0x8000);
           ret |= flagload_load(f, mem + 0x1e8000, 0x18000);
           (void)t;
           return(ret);
   }
   
   
 // ---- event  // ---- event
   
 typedef struct {  typedef struct {
Line 1323  const STENTRY *tblterm; Line 1355  const STENTRY *tblterm;
                                 ret |= flagsave_egc(&f, tbl);                                  ret |= flagsave_egc(&f, tbl);
                                 break;                                  break;
   
                           case NP2FLAG_EPSON:
                                   ret |= flagsave_epson(&f, tbl);
                                   break;
   
                         case NP2FLAG_EVT:                          case NP2FLAG_EVT:
                                 ret |= flagsave_evt(&f, tbl);                                  ret |= flagsave_evt(&f, tbl);
                                 break;                                  break;
Line 1404  const STENTRY *tblterm; Line 1440  const STENTRY *tblterm;
                                         case NP2FLAG_COM:                                          case NP2FLAG_COM:
                                         case NP2FLAG_DMA:                                          case NP2FLAG_DMA:
                                         case NP2FLAG_EGC:                                          case NP2FLAG_EGC:
                                           case NP2FLAG_EPSON:
                                         case NP2FLAG_EVT:                                          case NP2FLAG_EVT:
                                         case NP2FLAG_EXT:                                          case NP2FLAG_EXT:
                                         case NP2FLAG_GIJ:                                          case NP2FLAG_GIJ:
Line 1503  const STENTRY *tblterm; Line 1540  const STENTRY *tblterm;
                                         ret |= flagload_egc(&f, tbl);                                          ret |= flagload_egc(&f, tbl);
                                         break;                                          break;
   
                                   case NP2FLAG_EPSON:
                                           ret |= flagload_epson(&f, tbl);
                                           break;
   
                                 case NP2FLAG_EVT:                                  case NP2FLAG_EVT:
                                         ret |= flagload_evt(&f, tbl);                                          ret |= flagload_evt(&f, tbl);
                                         break;                                          break;
Removed from v.1.23  
changed lines
  Added in v.1.25

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