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

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

version 1.19, 2003/12/08 00:55:30 version 1.25, 2004/01/05 09:31:24
Line 5 Line 5
 #include        "soundmng.h"  #include        "soundmng.h"
 #include        "timemng.h"  #include        "timemng.h"
 #include        "cpucore.h"  #include        "cpucore.h"
 #include        "memory.h"  
 #include        "pccore.h"  #include        "pccore.h"
 #include        "iocore.h"  #include        "iocore.h"
 #include        "cbuscore.h"  #include        "cbuscore.h"
Line 56  typedef struct { Line 55  typedef struct {
 enum {  enum {
         NP2FLAG_BIN                     = 0,          NP2FLAG_BIN                     = 0,
         NP2FLAG_TERM,          NP2FLAG_TERM,
   #if defined(CGWND_FONTPTR)
           NP2FLAG_CGW,
   #endif
         NP2FLAG_CLOCK,          NP2FLAG_CLOCK,
         NP2FLAG_COM,          NP2FLAG_COM,
         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 450  static int flagload_ext(NP2FFILE f, cons Line 453  static int flagload_ext(NP2FFILE f, cons
 }  }
   
   
   // ---- cg window
   
   #if defined(CGWND_FONTPTR)
   static int flagsave_cgwnd(NP2FFILE f, const STENTRY *t) {
   
           int                     ret;
           _CGWINDOW       cgwnd;
   
           cgwnd = cgwindow;
           cgwnd.fontlow -= (long)fontrom;
           cgwnd.fonthigh -= (long)fontrom;
           ret = flagsave_create(f, t);
           if (ret != NP2FLAG_FAILURE) {
                   ret |= flagsave_save(f, &cgwindow, sizeof(cgwindow));
                   ret |= flagsave_close(f);
           }
           return(ret);
   }
   
   static int flagload_cgwnd(NP2FFILE f, const STENTRY *t) {
   
           int             ret;
   
           ret = flagload_load(f, &cgwindow, sizeof(cgwindow));
           cgwindow.fontlow += (long)fontrom;
           cgwindow.fonthigh += (long)fontrom;
           (void)t;
           return(ret);
   }
   #endif
   
   
 // ---- dma  // ---- dma
   
 static int flagsave_dma(NP2FFILE f, const STENTRY *t) {  static int flagsave_dma(NP2FFILE f, const STENTRY *t) {
Line 460  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 482  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 531  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 1267  const STENTRY *tblterm; Line 1333  const STENTRY *tblterm;
                                 ret |= flagsave_term(&f, tbl);                                  ret |= flagsave_term(&f, tbl);
                                 break;                                  break;
   
   #if defined(CGWND_FONTPTR)
                           case NP2FLAG_CGW:
                                   ret |= flagsave_cgwnd(&f, tbl);
                                   break;
   #endif
   
                         case NP2FLAG_COM:                          case NP2FLAG_COM:
                                 ret |= flagsave_com(&f, tbl);                                  ret |= flagsave_com(&f, tbl);
                                 break;                                  break;
Line 1283  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 1349  const STENTRY *tblterm; Line 1425  const STENTRY *tblterm;
                         if (tbl < tblterm) {                          if (tbl < tblterm) {
                                 switch(tbl->type) {                                  switch(tbl->type) {
                                         case NP2FLAG_BIN:                                          case NP2FLAG_BIN:
   #if defined(CGWND_FONTPTR)
                                           case NP2FLAG_CGW:
   #endif
                                         case NP2FLAG_CLOCK:                                          case NP2FLAG_CLOCK:
                                         case NP2FLAG_MEM:                                          case NP2FLAG_MEM:
                                                 ret |= flagcheck_versize(&f, tbl, &e);                                                  ret |= flagcheck_versize(&f, tbl, &e);
Line 1361  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 1434  const STENTRY *tblterm; Line 1514  const STENTRY *tblterm;
                                         done = TRUE;                                          done = TRUE;
                                         break;                                          break;
   
   #if defined(CGWND_FONTPTR)
                                   case NP2FLAG_CGW:
                                           ret |= flagload_cgwnd(&f, tbl);
                                           break;
   #endif
   
                                 case NP2FLAG_CLOCK:                                  case NP2FLAG_CLOCK:
                                         ret |= flagload_clock(&f, tbl);                                          ret |= flagload_clock(&f, tbl);
                                         break;                                          break;
Line 1454  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;
Line 1487  const STENTRY *tblterm; Line 1577  const STENTRY *tblterm;
         flagclose(&f);          flagclose(&f);
   
         // I/O作り直し          // I/O作り直し
           i286_memorymap((pc.model & PCMODEL_EPSON)?1:0);
         iocore_build();          iocore_build();
         iocore_bind();          iocore_bind();
         cbuscore_bind();          cbuscore_bind();
Line 1499  const STENTRY *tblterm; Line 1590  const STENTRY *tblterm;
         gdcs.palchange = GDCSCRN_REDRAW;          gdcs.palchange = GDCSCRN_REDRAW;
         tramflag.renewal = 1;          tramflag.renewal = 1;
         cgwindow.writable |= 0x80;          cgwindow.writable |= 0x80;
   #if defined(CPUSTRUC_FONTPTR)
           FONTPTR_LOW = fontrom + cgwindow.low;
           FONTPTR_HIGH = fontrom + cgwindow.high;
   #endif
         i286_vram_dispatch(vramop.operate);          i286_vram_dispatch(vramop.operate);
         soundmng_play();          soundmng_play();
   
Removed from v.1.19  
changed lines
  Added in v.1.25

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