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

Diff for /np2/statsave.c between versions 1.17 and 1.26

version 1.17, 2003/11/15 07:10:02 version 1.26, 2004/01/08 16:29:56
Line 4 Line 4
 #include        "scrnmng.h"  #include        "scrnmng.h"
 #include        "soundmng.h"  #include        "soundmng.h"
 #include        "timemng.h"  #include        "timemng.h"
 #include        "i286.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_DISK,
         NP2FLAG_DMA,          NP2FLAG_DMA,
         NP2FLAG_EGC,          NP2FLAG_EGC,
         NP2FLAG_EXT,          NP2FLAG_EPSON,
         NP2FLAG_EVT,          NP2FLAG_EVT,
         NP2FLAG_GIJ,          NP2FLAG_EXT,
         NP2FLAG_FM,          NP2FLAG_FM,
         NP2FLAG_COM,          NP2FLAG_GIJ,
         NP2FLAG_DISK          NP2FLAG_MEM
 };  };
   
 typedef struct {  typedef struct {
Line 337  static int flagsave_term(NP2FFILE f, con Line 341  static int flagsave_term(NP2FFILE f, con
 }  }
   
   
 // ----  // ---- common
   
 static int flagsave_common(NP2FFILE f, const STENTRY *t) {  static int flagsave_common(NP2FFILE f, const STENTRY *t) {
   
Line 357  static int flagload_common(NP2FFILE f, c Line 361  static int flagload_common(NP2FFILE f, c
 }  }
   
   
 // -----  // ----- clock
   
 static int flagload_clock(NP2FFILE f, const STENTRY *t) {  static int flagload_clock(NP2FFILE f, const STENTRY *t) {
   
Line 370  static int flagload_clock(NP2FFILE f, co Line 374  static int flagload_clock(NP2FFILE f, co
 }  }
   
   
 // -----  // ---- memory
   
   static int flagsave_mem(NP2FFILE f, const STENTRY *t) {
   
           int             ret;
   
           ret = flagsave_create(f, t);
           if (ret != NP2FLAG_FAILURE) {
                   ret |= flagsave_save(f, mem, 0x110000);
                   ret |= flagsave_save(f, mem + VRAM1_B, 0x18000);
                   ret |= flagsave_save(f, mem + VRAM1_E, 0x8000);
                   ret |= flagsave_close(f);
           }
           return(ret);
   }
   
   static int flagload_mem(NP2FFILE f, const STENTRY *t) {
   
           int             ret;
   
           ret = flagload_load(f, mem, 0x110000);
           ret |= flagload_load(f, mem + VRAM1_B, 0x18000);
           ret |= flagload_load(f, mem + VRAM1_E, 0x8000);
           (void)t;
           return(ret);
   }
   
   
   // ---- ext memory
   
   static int flagsave_ext(NP2FFILE f, const STENTRY *t) {
   
           int             ret;
   
           ret = flagsave_create(f, t);
           if (ret != NP2FLAG_FAILURE) {
                   ret |= flagsave_save(f, &extmem, sizeof(extmem));
                   if (CPU_EXTMEM) {
                           ret |= flagsave_save(f, CPU_EXTMEM, CPU_EXTMEMSIZE);
                   }
                   ret |= flagsave_close(f);
           }
           return(ret);
   }
   
   static int flagload_ext(NP2FFILE f, const STENTRY *t) {
   
           int             ret;
           int             i;
           UINT    pagemax = 0;
   
           ret = flagload_load(f, &extmem, sizeof(extmem));
           if (extmem.maxmem) {
                   if (extmem.maxmem > (13+1)) {
                           extmem.maxmem = (13+1);
                   }
                   if (!extmemmng_realloc(extmem.maxmem - 1)) {
                           pagemax = (extmem.maxmem - 1) << 8;
                           if (CPU_EXTMEM) {
                                   ret |= flagload_load(f, CPU_EXTMEM, CPU_EXTMEMSIZE);
                           }
                   }
                   else {
                           extmem.maxmem = 0;
                   }
           }
           for (i=0; i<4; i++) {
                   if (extmem.page[i] < pagemax) {
                           extmem.pageptr[i] = CPU_EXTMEM + (extmem.page[i] << 12);
                   }
                   else {
                           extmem.pageptr[i] = mem + 0xc0000 + (i << 14);
                   }
           }
           (void)t;
           return(ret);
   }
   
   
   // ---- 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
   
 static int flagsave_dma(NP2FFILE f, const STENTRY *t) {  static int flagsave_dma(NP2FFILE f, const STENTRY *t) {
   
Line 380  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 402  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 420  static int flagload_dma(NP2FFILE f, cons Line 535  static int flagload_dma(NP2FFILE f, cons
 }  }
   
   
 // -----  // ---- egc
   
 static int flagsave_egc(NP2FFILE f, const STENTRY *t) {  static int flagsave_egc(NP2FFILE f, const STENTRY *t) {
   
Line 451  static int flagload_egc(NP2FFILE f, cons Line 566  static int flagload_egc(NP2FFILE f, cons
 }  }
   
   
 // -----  // ---- epson
   
 static int flagsave_ext(NP2FFILE f, const STENTRY *t) {  static int flagsave_epson(NP2FFILE f, const STENTRY *t) {
   
         int             ret;          int             ret;
   
           if (!(pc.model & PCMODEL_EPSON)) {
                   return(NP2FLAG_SUCCESS);
           }
         ret = flagsave_create(f, t);          ret = flagsave_create(f, t);
         if (ret != NP2FLAG_FAILURE) {          if (ret != NP2FLAG_FAILURE) {
                 ret |= flagsave_save(f, &extmem, sizeof(extmem));                  ret |= flagsave_save(f, &epsonio, sizeof(epsonio));
                 if (extmemmng_size) {                  ret |= flagsave_save(f, mem + 0x1c0000, 0x8000);
                         ret |= flagsave_save(f, extmemmng_ptr, extmemmng_size);                  ret |= flagsave_save(f, mem + 0x1e8000, 0x18000);
                 }  
                 ret |= flagsave_close(f);                  ret |= flagsave_close(f);
         }          }
         return(ret);          return(ret);
 }  }
   
 static int flagload_ext(NP2FFILE f, const STENTRY *t) {  static int flagload_epson(NP2FFILE f, const STENTRY *t) {
   
         int             ret;          int             ret;
         int             i;  
         UINT    pagemax = 0;  
   
         ret = flagload_load(f, &extmem, sizeof(extmem));          ret = flagload_load(f, &epsonio, sizeof(epsonio));
         if (extmem.maxmem) {          ret |= flagload_load(f, mem + 0x1c0000, 0x8000);
                 if (extmem.maxmem > (13+1)) {          ret |= flagload_load(f, mem + 0x1e8000, 0x18000);
                         extmem.maxmem = (13+1);  
                 }  
                 if (!extmemmng_realloc(extmem.maxmem - 1)) {  
                         pagemax = (extmem.maxmem - 1) << 8;  
                         if (extmemmng_size) {  
                                 ret |= flagload_load(f, extmemmng_ptr, extmemmng_size);  
                         }  
                 }  
                 else {  
                         extmem.maxmem = 0;  
                 }  
         }  
         for (i=0; i<4; i++) {  
                 if (extmem.page[i] < pagemax) {  
                         extmem.pageptr[i] = extmemmng_ptr + (extmem.page[i] << 12);  
                 }  
                 else {  
                         extmem.pageptr[i] = mem + 0xc0000 + (i << 14);  
                 }  
         }  
         (void)t;          (void)t;
         return(ret);          return(ret);
 }  }
   
   
 // -----  // ---- event
   
 typedef struct {  typedef struct {
         UINT            readyevents;          UINT            readyevents;
Line 615  static int flagload_evt(NP2FFILE f, cons Line 710  static int flagload_evt(NP2FFILE f, cons
 }  }
   
   
 // ----  // ---- gaiji
   
 static int flagsave_gij(NP2FFILE f, const STENTRY *t) {  static int flagsave_gij(NP2FFILE f, const STENTRY *t) {
   
Line 658  static int flagload_gij(NP2FFILE f, cons Line 753  static int flagload_gij(NP2FFILE f, cons
 }  }
   
   
 // -----  // ---- FM
   
 enum {  enum {
         FLAG_MG                 = 0x0001,          FLAG_MG                 = 0x0001,
Line 1092  static int flagload_disk(NP2FFILE f, con Line 1187  static int flagload_disk(NP2FFILE f, con
 }  }
   
   
 // -----  // ---- com
   
 static int flagsave_com(NP2FFILE f, const STENTRY *t) {  static int flagsave_com(NP2FFILE f, const STENTRY *t) {
   
Line 1218  int statsave_save(const char *filename)  Line 1313  int statsave_save(const char *filename) 
   
         _NP2FFILE       f;          _NP2FFILE       f;
         int                     ret;          int                     ret;
         UINT            i;  const STENTRY   *tbl;
   const STENTRY   *tblterm;
   
         ret = flagcreate(&f, filename);          ret = flagcreate(&f, filename);
         if (ret == NP2FLAG_FAILURE) {          if (ret == NP2FLAG_FAILURE) {
                 return(ret);                  return(ret);
         }          }
         for (i=0; i<sizeof(np2tbl)/sizeof(STENTRY); i++) {          tbl = np2tbl;
                 switch(np2tbl[i].type) {          tblterm = tbl + (sizeof(np2tbl)/sizeof(STENTRY));
           while(tbl < tblterm) {
                   switch(tbl->type) {
                         case NP2FLAG_BIN:                          case NP2FLAG_BIN:
                         case NP2FLAG_CLOCK:                          case NP2FLAG_CLOCK:
                                 ret |= flagsave_common(&f, &np2tbl[i]);                                  ret |= flagsave_common(&f, tbl);
                                 break;                                  break;
   
                         case NP2FLAG_TERM:                          case NP2FLAG_TERM:
                                 ret |= flagsave_term(&f, &np2tbl[i]);                                  ret |= flagsave_term(&f, tbl);
                                   break;
   
   #if defined(CGWND_FONTPTR)
                           case NP2FLAG_CGW:
                                   ret |= flagsave_cgwnd(&f, tbl);
                                   break;
   #endif
   
                           case NP2FLAG_COM:
                                   ret |= flagsave_com(&f, tbl);
                                   break;
   
                           case NP2FLAG_DISK:
                                   ret |= flagsave_disk(&f, tbl);
                                 break;                                  break;
   
                         case NP2FLAG_DMA:                          case NP2FLAG_DMA:
                                 ret |= flagsave_dma(&f, &np2tbl[i]);                                  ret |= flagsave_dma(&f, tbl);
                                 break;                                  break;
   
                         case NP2FLAG_EGC:                          case NP2FLAG_EGC:
                                 ret |= flagsave_egc(&f, &np2tbl[i]);                                  ret |= flagsave_egc(&f, tbl);
                                 break;                                  break;
   
                         case NP2FLAG_EXT:                          case NP2FLAG_EPSON:
                                 ret |= flagsave_ext(&f, &np2tbl[i]);                                  ret |= flagsave_epson(&f, tbl);
                                 break;                                  break;
   
                         case NP2FLAG_EVT:                          case NP2FLAG_EVT:
                                 ret |= flagsave_evt(&f, &np2tbl[i]);                                  ret |= flagsave_evt(&f, tbl);
                                 break;                                  break;
   
                         case NP2FLAG_GIJ:                          case NP2FLAG_EXT:
                                 ret |= flagsave_gij(&f, &np2tbl[i]);                                  ret |= flagsave_ext(&f, tbl);
                                 break;                                  break;
   
                         case NP2FLAG_FM:                          case NP2FLAG_FM:
                                 ret |= flagsave_fm(&f, &np2tbl[i]);                                  ret |= flagsave_fm(&f, tbl);
                                 break;                                  break;
   
                         case NP2FLAG_DISK:                          case NP2FLAG_GIJ:
                                 ret |= flagsave_disk(&f, &np2tbl[i]);                                  ret |= flagsave_gij(&f, tbl);
                                 break;                                  break;
   
                         case NP2FLAG_COM:                          case NP2FLAG_MEM:
                                 ret |= flagsave_com(&f, &np2tbl[i]);                                  ret |= flagsave_mem(&f, tbl);
                                 break;                                  break;
                 }                  }
                   tbl++;
         }          }
         flagclose(&f);          flagclose(&f);
         return(ret);          return(ret);
Line 1274  int statsave_save(const char *filename)  Line 1387  int statsave_save(const char *filename) 
   
 int statsave_check(const char *filename, char *buf, int size) {  int statsave_check(const char *filename, char *buf, int size) {
   
           ERR_BUF         e;
         _NP2FFILE       f;          _NP2FFILE       f;
         int                     ret;          int                     ret;
         UINT            i;  
         BOOL            done;          BOOL            done;
         ERR_BUF         e;  const STENTRY   *tbl;
   const STENTRY   *tblterm;
   
         e.buf = buf;          e.buf = buf;
         e.remain = size;          e.remain = size;
Line 1300  int statsave_check(const char *filename, Line 1414  int statsave_check(const char *filename,
                         ret |= flagload_create(&f);                          ret |= flagload_create(&f);
                         CopyMemory(index, f.p.index, sizeof(f.p.index));                          CopyMemory(index, f.p.index, sizeof(f.p.index));
                         index[10] = 0;                          index[10] = 0;
                         for (i=0; i<sizeof(np2tbl)/sizeof(STENTRY); i++) {                          tbl = np2tbl;
                                 if (!strcmp(index, np2tbl[i].index)) {                          tblterm = tbl + (sizeof(np2tbl)/sizeof(STENTRY));
                           while(tbl < tblterm) {
                                   if (!strcmp(index, tbl->index)) {
                                         break;                                          break;
                                 }                                  }
                                   tbl++;
                         }                          }
                         if (i < (sizeof(np2tbl)/sizeof(STENTRY))) {                          if (tbl < tblterm) {
                                 switch(np2tbl[i].type) {                                  switch(tbl->type) {
                                         case NP2FLAG_BIN:                                          case NP2FLAG_BIN:
   #if defined(CGWND_FONTPTR)
                                           case NP2FLAG_CGW:
   #endif
                                         case NP2FLAG_CLOCK:                                          case NP2FLAG_CLOCK:
                                                 ret |= flagcheck_versize(&f, &np2tbl[i], &e);                                          case NP2FLAG_MEM:
                                                   ret |= flagcheck_versize(&f, tbl, &e);
                                                 break;                                                  break;
   
                                         case NP2FLAG_TERM:                                          case NP2FLAG_TERM:
                                                 done = TRUE;                                                  done = TRUE;
                                                 break;                                                  break;
   
                                           case NP2FLAG_COM:
                                         case NP2FLAG_DMA:                                          case NP2FLAG_DMA:
                                         case NP2FLAG_EGC:                                          case NP2FLAG_EGC:
                                         case NP2FLAG_EXT:                                          case NP2FLAG_EPSON:
                                         case NP2FLAG_EVT:                                          case NP2FLAG_EVT:
                                           case NP2FLAG_EXT:
                                         case NP2FLAG_GIJ:                                          case NP2FLAG_GIJ:
                                         case NP2FLAG_COM:                                          case NP2FLAG_FM:
                                                 ret |= flagcheck_veronly(&f, &np2tbl[i], &e);                                                  ret |= flagcheck_veronly(&f, tbl, &e);
                                                 break;                                                  break;
   
                                         case NP2FLAG_DISK:                                          case NP2FLAG_DISK:
                                                 ret |= flagcheck_disk(&f, &np2tbl[i], &e);                                                  ret |= flagcheck_disk(&f, tbl, &e);
                                                 break;  
   
                                         case NP2FLAG_FM:                                                        // ver0.31  
                                                 break;                                                  break;
   
                                         default:                                          default:
Line 1354  int statsave_load(const char *filename)  Line 1474  int statsave_load(const char *filename) 
   
         _NP2FFILE       f;          _NP2FFILE       f;
         int                     ret;          int                     ret;
         UINT            i;  
         BOOL            done;          BOOL            done;
   const STENTRY   *tbl;
   const STENTRY   *tblterm;
   
         ret = flagopen(&f, filename, NULL);          ret = flagopen(&f, filename, NULL);
         if (ret == NP2FLAG_FAILURE) {          if (ret == NP2FLAG_FAILURE) {
Line 1367  int statsave_load(const char *filename)  Line 1488  int statsave_load(const char *filename) 
         mpu98ii_midipanic();          mpu98ii_midipanic();
         pc9861k_midipanic();          pc9861k_midipanic();
         sound_reset();          sound_reset();
   #if defined(SUPPORT_WAVEMIX)
           wavemix_bind();
   #endif
         fmboard_reset(0);          fmboard_reset(0);
   
         done = FALSE;          done = FALSE;
Line 1375  int statsave_load(const char *filename)  Line 1499  int statsave_load(const char *filename) 
                 ret |= flagload_create(&f);                  ret |= flagload_create(&f);
                 CopyMemory(index, f.p.index, sizeof(f.p.index));                  CopyMemory(index, f.p.index, sizeof(f.p.index));
                 index[10] = 0;                  index[10] = 0;
                 for (i=0; i<sizeof(np2tbl)/sizeof(STENTRY); i++) {                  tbl = np2tbl;
                         if (!strcmp(index, np2tbl[i].index)) {                  tblterm = tbl + (sizeof(np2tbl)/sizeof(STENTRY));
                   while(tbl < tblterm) {
                           if (!strcmp(index, tbl->index)) {
                                 break;                                  break;
                         }                          }
                           tbl++;
                 }                  }
                 if (i < (sizeof(np2tbl)/sizeof(STENTRY))) {                  if (tbl < tblterm) {
                         switch(np2tbl[i].type) {                          switch(tbl->type) {
                                 case NP2FLAG_BIN:                                  case NP2FLAG_BIN:
                                         ret |= flagload_common(&f, &np2tbl[i]);                                          ret |= flagload_common(&f, tbl);
                                         break;                                          break;
   
                                 case NP2FLAG_TERM:                                  case NP2FLAG_TERM:
                                         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, &np2tbl[i]);                                          ret |= flagload_clock(&f, tbl);
                                           break;
   
                                   case NP2FLAG_COM:
                                           ret |= flagload_com(&f, tbl);
                                           break;
   
                                   case NP2FLAG_DISK:
                                           ret |= flagload_disk(&f, tbl);
                                         break;                                          break;
   
                                 case NP2FLAG_DMA:                                  case NP2FLAG_DMA:
                                         ret |= flagload_dma(&f, &np2tbl[i]);                                          ret |= flagload_dma(&f, tbl);
                                         break;                                          break;
   
                                 case NP2FLAG_EGC:                                  case NP2FLAG_EGC:
                                         ret |= flagload_egc(&f, &np2tbl[i]);                                          ret |= flagload_egc(&f, tbl);
                                         break;                                          break;
   
                                 case NP2FLAG_EXT:                                  case NP2FLAG_EPSON:
                                         ret |= flagload_ext(&f, &np2tbl[i]);                                          ret |= flagload_epson(&f, tbl);
                                         break;                                          break;
   
                                 case NP2FLAG_EVT:                                  case NP2FLAG_EVT:
                                         ret |= flagload_evt(&f, &np2tbl[i]);                                          ret |= flagload_evt(&f, tbl);
                                         break;                                          break;
   
                                 case NP2FLAG_GIJ:                                  case NP2FLAG_EXT:
                                         ret |= flagload_gij(&f, &np2tbl[i]);                                          ret |= flagload_ext(&f, tbl);
                                         break;                                          break;
   
                                 case NP2FLAG_FM:                                  case NP2FLAG_FM:
                                         ret |= flagload_fm(&f, &np2tbl[i]);                                          ret |= flagload_fm(&f, tbl);
                                         break;                                          break;
   
                                 case NP2FLAG_DISK:                                  case NP2FLAG_GIJ:
                                         ret |= flagload_disk(&f, &np2tbl[i]);                                          ret |= flagload_gij(&f, tbl);
                                         break;                                          break;
   
                                 case NP2FLAG_COM:                                  case NP2FLAG_MEM:
                                         ret |= flagload_com(&f, &np2tbl[i]);                                          ret |= flagload_mem(&f, tbl);
                                         break;                                          break;
   
                                 default:                                  default:
Line 1439  int statsave_load(const char *filename)  Line 1580  int statsave_load(const char *filename) 
         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 1451  int statsave_load(const char *filename)  Line 1593  int statsave_load(const char *filename) 
         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.17  
changed lines
  Added in v.1.26

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