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

Diff for /np2/statsave.c between versions 1.43 and 1.52

version 1.43, 2005/02/07 14:46:07 version 1.52, 2011/01/15 18:04:42
Line 61  enum { Line 61  enum {
         STATFLAG_CGW,          STATFLAG_CGW,
 #endif  #endif
         STATFLAG_COM,          STATFLAG_COM,
         STATFLAG_DISK,  
         STATFLAG_DMA,          STATFLAG_DMA,
         STATFLAG_EGC,          STATFLAG_EGC,
         STATFLAG_EPSON,          STATFLAG_EPSON,
         STATFLAG_EVT,          STATFLAG_EVT,
         STATFLAG_EXT,          STATFLAG_EXT,
           STATFLAG_FDD,
         STATFLAG_FM,          STATFLAG_FM,
         STATFLAG_GIJ,          STATFLAG_GIJ,
 #if defined(SUPPORT_HOSTDRV)  #if defined(SUPPORT_HOSTDRV)
         STATFLAG_HDRV,          STATFLAG_HDRV,
 #endif  #endif
         STATFLAG_MEM          STATFLAG_MEM,
           STATFLAG_SXSI
 };  };
   
 typedef struct {  typedef struct {
Line 96  extern COMMNG cm_mpu98; Line 97  extern COMMNG cm_mpu98;
 extern  COMMNG  cm_rs232c;  extern  COMMNG  cm_rs232c;
   
 typedef struct {  typedef struct {
         char    *buf;          OEMCHAR *buf;
         int             remain;          int             remain;
 } ERR_BUF;  } ERR_BUF;
   
   
 // ----  // ----
   
 // 関数ポインタを intに変更。  
 static BOOL proc2num(void *func, const PROCTBL *tbl, int size) {  
   
         int             i;  
   
         for (i=0; i<size; i++) {  
                 if (*(long *)func == (long)tbl->proc) {  
                         *(long *)func = (long)tbl->id;  
                         return(SUCCESS);  
                 }  
                 tbl++;  
         }  
         return(FAILURE);  
 }  
   
 static BOOL num2proc(void *func, const PROCTBL *tbl, int size) {  
   
         int             i;  
   
         for (i=0; i<size; i++) {  
                 if (*(long *)func == (long)tbl->id) {  
                         *(long *)func = (long)tbl->proc;  
                         return(SUCCESS);  
                 }  
                 tbl++;  
         }  
         return(FAILURE);  
 }  
   
   
 // ----  
   
 enum {  enum {
         SFFILEH_WRITE   = 0x0001,          SFFILEH_WRITE   = 0x0001,
         SFFILEH_BLOCK   = 0x0002,          SFFILEH_BLOCK   = 0x0002,
Line 149  typedef struct { Line 118  typedef struct {
         NP2FHDR         f;          NP2FHDR         f;
 } _SFFILEH, *SFFILEH;  } _SFFILEH, *SFFILEH;
   
 static SFFILEH statflag_open(const char *filename, char *err, int errlen) {  static SFFILEH statflag_open(const OEMCHAR *filename, OEMCHAR *err, int errlen) {
   
         FILEH   fh;          FILEH   fh;
         SFFILEH ret;          SFFILEH ret;
Line 261  sfr_err: Line 230  sfr_err:
         return(STATFLAG_FAILURE);          return(STATFLAG_FAILURE);
 }  }
   
 static SFFILEH statflag_create(const char *filename) {  static SFFILEH statflag_create(const OEMCHAR *filename) {
   
         SFFILEH ret;          SFFILEH ret;
         FILEH   fh;          FILEH   fh;
Line 355  static void statflag_close(SFFILEH sffh) Line 324  static void statflag_close(SFFILEH sffh)
         }          }
 }  }
   
 void statflag_seterr(STFLAGH sfh, const char *str) {  void statflag_seterr(STFLAGH sfh, const OEMCHAR *str) {
   
         if ((sfh) && (sfh->errlen)) {          if ((sfh) && (sfh->errlen)) {
                 milstr_ncat(sfh->err, str, sfh->errlen);                  milstr_ncat(sfh->err, str, sfh->errlen);
Line 364  void statflag_seterr(STFLAGH sfh, const  Line 333  void statflag_seterr(STFLAGH sfh, const 
 }  }
   
   
   // ---- function
   
   // 関数ポインタを intに変更。
   static BRESULT proc2num(void *func, const PROCTBL *tbl, int size) {
   
           int             i;
   
           for (i=0; i<size; i++) {
                   if (*(long *)func == (long)tbl->proc) {
                           *(long *)func = (long)tbl->id;
                           return(SUCCESS);
                   }
                   tbl++;
           }
           return(FAILURE);
   }
   
   static BRESULT num2proc(void *func, const PROCTBL *tbl, int size) {
   
           int             i;
   
           for (i=0; i<size; i++) {
                   if (*(long *)func == (long)tbl->id) {
                           *(long *)func = (long)tbl->proc;
                           return(SUCCESS);
                   }
                   tbl++;
           }
           return(FAILURE);
   }
   
   
   // ---- file
   
   typedef struct {
           OEMCHAR path[MAX_PATH];
           UINT    ftype;
           int             readonly;
           DOSDATE date;
           DOSTIME time;
   } STATPATH;
   
   static const OEMCHAR str_updated[] = OEMTEXT("%s: updated");
   static const OEMCHAR str_notfound[] = OEMTEXT("%s: not found");
   
   static int statflag_writepath(STFLAGH sfh, const OEMCHAR *path,
                                                                                                   UINT ftype, int readonly) {
   
           STATPATH        sp;
           FILEH           fh;
   
           ZeroMemory(&sp, sizeof(sp));
           if ((path) && (path[0])) {
                   file_cpyname(sp.path, path, NELEMENTS(sp.path));
                   sp.ftype = ftype;
                   sp.readonly = readonly;
                   fh = file_open_rb(path);
                   if (fh != FILEH_INVALID) {
                           file_getdatetime(fh, &sp.date, &sp.time);
                           file_close(fh);
                   }
           }
           return(statflag_write(sfh, &sp, sizeof(sp)));
   }
   
   static int statflag_checkpath(STFLAGH sfh, const OEMCHAR *dvname) {
   
           int                     ret;
           STATPATH        sp;
           FILEH           fh;
           OEMCHAR         buf[256];
           DOSDATE         dosdate;
           DOSTIME         dostime;
   
           ret = statflag_read(sfh, &sp, sizeof(sp));
           if (sp.path[0]) {
                   fh = file_open_rb(sp.path);
                   if (fh != FILEH_INVALID) {
                           file_getdatetime(fh, &dosdate, &dostime);
                           file_close(fh);
                           if ((memcmp(&sp.date, &dosdate, sizeof(dosdate))) ||
                                   (memcmp(&sp.time, &dostime, sizeof(dostime)))) {
                                   ret |= STATFLAG_DISKCHG;
                                   OEMSPRINTF(buf, str_updated, dvname);
                                   statflag_seterr(sfh, buf);
                           }
                   }
                   else {
                           ret |= STATFLAG_DISKCHG;
                           OEMSPRINTF(buf, str_notfound, dvname);
                           statflag_seterr(sfh, buf);
                   }
           }
           return(ret);
   }
   
   
 // ---- common  // ---- common
   
 static int flagsave_common(STFLAGH sfh, const SFENTRY *tbl) {  static int flagsave_common(STFLAGH sfh, const SFENTRY *tbl) {
Line 826  static int flagload_fm(STFLAGH sfh, cons Line 892  static int flagload_fm(STFLAGH sfh, cons
         OPNKEY  opnkey;          OPNKEY  opnkey;
   
         ret = statflag_read(sfh, &usesound, sizeof(usesound));          ret = statflag_read(sfh, &usesound, sizeof(usesound));
         fmboard_reset(usesound);          fmboard_reset(&np2cfg, usesound);
   
         switch(usesound) {          switch(usesound) {
                 case 0x01:                  case 0x01:
Line 925  static int flagload_fm(STFLAGH sfh, cons Line 991  static int flagload_fm(STFLAGH sfh, cons
 #endif  #endif
   
   
 // ---- disk  // ---- fdd
   
 typedef struct {  
         char    path[MAX_PATH];  
         int             readonly;  
         DOSDATE date;  
         DOSTIME time;  
 } STATDISK;  
   
 static const char str_fddx[] = "FDD%u";  static const OEMCHAR str_fddx[] = OEMTEXT("FDD%u");
 static const char str_sasix[] = "SASI%u";  
 static const char str_scsix[] = "SCSI%u";  
 static const char str_updated[] = "%s: updated";  
 static const char str_notfound[] = "%s: not found";  
   
 static int disksave(STFLAGH sfh, const char *path, int readonly) {  static int flagsave_fdd(STFLAGH sfh, const SFENTRY *tbl) {
   
         STATDISK        st;          int                     ret;
         FILEH           fh;          UINT8           i;
   const OEMCHAR   *path;
           UINT            ftype;
           int                     ro;
   
         ZeroMemory(&st, sizeof(st));          ret = STATFLAG_SUCCESS;
         if ((path) && (path[0])) {          for (i=0; i<4; i++) {
                 file_cpyname(st.path, path, sizeof(st.path));                  path = fdd_getfileex(i, &ftype, &ro);
                 st.readonly = readonly;                  ret |= statflag_writepath(sfh, path, ftype, ro);
                 fh = file_open_rb(path);  
                 if (fh != FILEH_INVALID) {  
                         file_getdatetime(fh, &st.date, &st.time);  
                         file_close(fh);  
                 }  
         }          }
         return(statflag_write(sfh, &st, sizeof(st)));          (void)tbl;
           return(ret);
 }  }
   
 static int flagsave_disk(STFLAGH sfh, const SFENTRY *tbl) {  static int flagcheck_fdd(STFLAGH sfh, const SFENTRY *tbl) {
   
         int             ret;          int             ret;
         UINT8   i;          int             i;
           OEMCHAR buf[8];
   
         sxsi_flash();  
         ret = STATFLAG_SUCCESS;          ret = STATFLAG_SUCCESS;
         for (i=0; i<4; i++) {          for (i=0; i<4; i++) {
                 ret |= disksave(sfh, fdd_diskname(i), fdd_diskprotect(i));                  OEMSPRINTF(buf, str_fddx, i+1);
         }                  ret |= statflag_checkpath(sfh, buf);
         for (i=0x00; i<0x02; i++) {  
                 ret |= disksave(sfh, sxsi_getname(i), 0);  
         }  
         for (i=0x20; i<0x24; i++) {  
                 ret |= disksave(sfh, sxsi_getname(i), 0);  
         }          }
         (void)tbl;          (void)tbl;
         return(ret);          return(ret);
 }  }
   
 static int diskcheck(STFLAGH sfh, const char *name) {  static int flagload_fdd(STFLAGH sfh, const SFENTRY *tbl) {
   
         int                     ret;          int                     ret;
         FILEH           fh;          UINT8           i;
         STATDISK        st;          STATPATH        sp;
         char            buf[256];  
         DOSDATE         date;          ret = STATFLAG_SUCCESS;
         DOSTIME         time;          for (i=0; i<4; i++) {
                   ret |= statflag_read(sfh, &sp, sizeof(sp));
         ret = statflag_read(sfh, &st, sizeof(st));                  if (sp.path[0]) {
         if (st.path[0]) {                          fdd_set(i, sp.path, sp.ftype, sp.readonly);
                 fh = file_open_rb(st.path);  
                 if (fh != FILEH_INVALID) {  
                         file_getdatetime(fh, &date, &time);  
                         file_close(fh);  
                         if ((memcmp(&st.date, &date, sizeof(date))) ||  
                                 (memcmp(&st.time, &time, sizeof(time)))) {  
                                 ret |= STATFLAG_DISKCHG;  
                                 SPRINTF(buf, str_updated, name);  
                                 statflag_seterr(sfh, buf);  
                         }  
                 }  
                 else {  
                         ret |= STATFLAG_DISKCHG;  
                         SPRINTF(buf, str_notfound, name);  
                         statflag_seterr(sfh, buf);  
                 }                  }
         }          }
           (void)tbl;
         return(ret);          return(ret);
 }  }
   
 static int flagcheck_disk(STFLAGH sfh, const SFENTRY *tbl) {  
   
         int             ret;  // ---- sxsi
         int             i;  
         char    buf[8];  
   
         ret = 0;  typedef struct {
         for (i=0; i<4; i++) {          UINT8   ide[4];
                 SPRINTF(buf, str_fddx, i+1);          UINT8   scsi[8];
                 ret |= diskcheck(sfh, buf);  } SXSIDEVS;
   
   static const OEMCHAR str_sasix[] = OEMTEXT("SASI%u");
   static const OEMCHAR str_scsix[] = OEMTEXT("SCSI%u");
   
   static int flagsave_sxsi(STFLAGH sfh, const SFENTRY *tbl) {
   
           int                     ret;
           UINT            i;
           SXSIDEVS        sds;
   const OEMCHAR   *path;
   
           sxsi_allflash();
           ret = STATFLAG_SUCCESS;
           for (i=0; i<NELEMENTS(sds.ide); i++) {
                   sds.ide[i] = sxsi_getdevtype((REG8)i);
         }          }
         sxsi_flash();          for (i=0; i<NELEMENTS(sds.scsi); i++) {
         for (i=0; i<2; i++) {                  sds.scsi[i] = sxsi_getdevtype((REG8)(i + 0x20));
                 SPRINTF(buf, str_sasix, i+1);  
                 ret |= diskcheck(sfh, buf);  
         }          }
         for (i=0; i<4; i++) {          ret = statflag_write(sfh, &sds, sizeof(sds));
                 SPRINTF(buf, str_scsix, i);          for (i=0; i<NELEMENTS(sds.ide); i++) {
                 ret |= diskcheck(sfh, buf);                  if (sds.ide[i] != SXSIDEV_NC) {
                           path = sxsi_getfilename((REG8)i);
                           ret |= statflag_writepath(sfh, path, FTYPE_NONE, 0);
                   }
           }
           for (i=0; i<NELEMENTS(sds.scsi); i++) {
                   if (sds.scsi[i] != SXSIDEV_NC) {
                           path = sxsi_getfilename((REG8)(i + 0x20));
                           ret |= statflag_writepath(sfh, path, FTYPE_NONE, 0);
                   }
         }          }
         (void)tbl;          (void)tbl;
         return(ret);          return(ret);
 }  }
   
 static int flagload_disk(STFLAGH sfh, const SFENTRY *tbl) {  static int flagcheck_sxsi(STFLAGH sfh, const SFENTRY *tbl) {
   
         int                     ret;          int                     ret;
         UINT8           i;          SXSIDEVS        sds;
         STATDISK        st;          UINT            i;
           OEMCHAR         buf[8];
   
         ret = 0;          sxsi_allflash();
         for (i=0; i<4; i++) {          ret = statflag_read(sfh, &sds, sizeof(sds));
                 ret |= statflag_read(sfh, &st, sizeof(st));          for (i=0; i<NELEMENTS(sds.ide); i++) {
                 if (st.path[0]) {                  if (sds.ide[i] != SXSIDEV_NC) {
                         fdd_set(i, st.path, FTYPE_NONE, st.readonly);                          OEMSPRINTF(buf, str_sasix, i+1);
                           ret |= statflag_checkpath(sfh, buf);
                 }                  }
         }          }
         for (i=0x00; i<0x02; i++) {          for (i=0; i<NELEMENTS(sds.scsi); i++) {
                 ret |= statflag_read(sfh, &st, sizeof(st));                  if (sds.scsi[i] != SXSIDEV_NC) {
                 if (st.path[0]) {                          OEMSPRINTF(buf, str_scsix, i);
                         sxsi_hddopen(i, st.path);                          ret |= statflag_checkpath(sfh, buf);
                   }
           }
           (void)tbl;
           return(ret);
   }
   
   static int flagload_sxsi(STFLAGH sfh, const SFENTRY *tbl) {
   
           int                     ret;
           SXSIDEVS        sds;
           UINT            i;
           REG8            drv;
           STATPATH        sp;
   
           ret = statflag_read(sfh, &sds, sizeof(sds));
           if (ret != STATFLAG_SUCCESS) {
                   return(ret);
           }
           for (i=0; i<NELEMENTS(sds.ide); i++) {
                   drv = (REG8)i;
                   sxsi_setdevtype(drv, sds.ide[i]);
                   if (sds.ide[i] != SXSIDEV_NC) {
                           ret |= statflag_read(sfh, &sp, sizeof(sp));
                           sxsi_devopen(drv, sp.path);
                 }                  }
         }          }
         for (i=0x20; i<0x24; i++) {          for (i=0; i<NELEMENTS(sds.scsi); i++) {
                 ret |= statflag_read(sfh, &st, sizeof(st));                  drv = (REG8)(i + 0x20);
                 if (st.path[0]) {                  sxsi_setdevtype(drv, sds.scsi[i]);
                         sxsi_hddopen(i, st.path);                  if (sds.scsi[i] != SXSIDEV_NC) {
                           ret |= statflag_read(sfh, &sp, sizeof(sp));
                           sxsi_devopen(drv, sp.path);
                 }                  }
         }          }
         (void)tbl;          (void)tbl;
Line 1173  static int flagcheck_veronly(STFLAGH sfh Line 1255  static int flagcheck_veronly(STFLAGH sfh
   
 // ----  // ----
   
 int statsave_save(const char *filename) {  int statsave_save(const OEMCHAR *filename) {
   
         SFFILEH         sffh;          SFFILEH         sffh;
         int                     ret;          int                     ret;
Line 1206  const SFENTRY *tblterm; Line 1288  const SFENTRY *tblterm;
                                 ret |= flagsave_com(&sffh->sfh, tbl);                                  ret |= flagsave_com(&sffh->sfh, tbl);
                                 break;                                  break;
   
                         case STATFLAG_DISK:  
                                 ret |= flagsave_disk(&sffh->sfh, tbl);  
                                 break;  
   
                         case STATFLAG_DMA:                          case STATFLAG_DMA:
                                 ret |= flagsave_dma(&sffh->sfh, tbl);                                  ret |= flagsave_dma(&sffh->sfh, tbl);
                                 break;                                  break;
Line 1230  const SFENTRY *tblterm; Line 1308  const SFENTRY *tblterm;
                                 ret |= flagsave_ext(&sffh->sfh, tbl);                                  ret |= flagsave_ext(&sffh->sfh, tbl);
                                 break;                                  break;
   
                           case STATFLAG_FDD:
                                   ret |= flagsave_fdd(&sffh->sfh, tbl);
                                   break;
   
 #if !defined(DISABLE_SOUND)  #if !defined(DISABLE_SOUND)
                         case STATFLAG_FM:                          case STATFLAG_FM:
                                 ret |= flagsave_fm(&sffh->sfh, tbl);                                  ret |= flagsave_fm(&sffh->sfh, tbl);
Line 1249  const SFENTRY *tblterm; Line 1331  const SFENTRY *tblterm;
                         case STATFLAG_MEM:                          case STATFLAG_MEM:
                                 ret |= flagsave_mem(&sffh->sfh, tbl);                                  ret |= flagsave_mem(&sffh->sfh, tbl);
                                 break;                                  break;
   
                           case STATFLAG_SXSI:
                                   ret |= flagsave_sxsi(&sffh->sfh, tbl);
                                   break;
                 }                  }
                 tbl++;                  tbl++;
         }          }
Line 1256  const SFENTRY *tblterm; Line 1342  const SFENTRY *tblterm;
         return(ret);          return(ret);
 }  }
   
 int statsave_check(const char *filename, char *buf, int size) {  int statsave_check(const OEMCHAR *filename, OEMCHAR *buf, int size) {
   
         SFFILEH         sffh;          SFFILEH         sffh;
         int                     ret;          int                     ret;
Line 1311  const SFENTRY *tblterm; Line 1397  const SFENTRY *tblterm;
                                         ret |= flagcheck_veronly(&sffh->sfh, tbl);                                          ret |= flagcheck_veronly(&sffh->sfh, tbl);
                                         break;                                          break;
   
                                 case STATFLAG_DISK:                                  case STATFLAG_FDD:
                                         ret |= flagcheck_disk(&sffh->sfh, tbl);                                          ret |= flagcheck_fdd(&sffh->sfh, tbl);
                                           break;
   
                                   case STATFLAG_SXSI:
                                           ret |= flagcheck_sxsi(&sffh->sfh, tbl);
                                         break;                                          break;
   
                                 default:                                  default:
Line 1328  const SFENTRY *tblterm; Line 1418  const SFENTRY *tblterm;
         return(ret);          return(ret);
 }  }
   
 int statsave_load(const char *filename) {  int statsave_load(const OEMCHAR *filename) {
   
         SFFILEH         sffh;          SFFILEH         sffh;
         int                     ret;          int                     ret;
Line 1353  const SFENTRY *tblterm; Line 1443  const SFENTRY *tblterm;
         rs232c_midipanic();          rs232c_midipanic();
         mpu98ii_midipanic();          mpu98ii_midipanic();
         pc9861k_midipanic();          pc9861k_midipanic();
         sxsi_trash();          sxsi_alltrash();
   
         ret |= flagload_common(&sffh->sfh, np2tbl);          ret |= flagload_common(&sffh->sfh, np2tbl);
   
Line 1366  const SFENTRY *tblterm; Line 1456  const SFENTRY *tblterm;
         sound_reset();          sound_reset();
         fddmtrsnd_bind();          fddmtrsnd_bind();
   
         iocore_reset();                                                         // サウンドでpicを呼ぶので…          iocore_reset(&np2cfg);                                                  // サウンドでpicを呼ぶので…
         cbuscore_reset();          cbuscore_reset(&np2cfg);
         fmboard_reset(pccore.sound);          fmboard_reset(&np2cfg, pccore.sound);
   
         done = FALSE;          done = FALSE;
         while((!done) && (ret != STATFLAG_FAILURE)) {          while((!done) && (ret != STATFLAG_FAILURE)) {
Line 1401  const SFENTRY *tblterm; Line 1491  const SFENTRY *tblterm;
                                         ret |= flagload_com(&sffh->sfh, tbl);                                          ret |= flagload_com(&sffh->sfh, tbl);
                                         break;                                          break;
   
                                 case STATFLAG_DISK:  
                                         ret |= flagload_disk(&sffh->sfh, tbl);  
                                         break;  
   
                                 case STATFLAG_DMA:                                  case STATFLAG_DMA:
                                         ret |= flagload_dma(&sffh->sfh, tbl);                                          ret |= flagload_dma(&sffh->sfh, tbl);
                                         break;                                          break;
Line 1425  const SFENTRY *tblterm; Line 1511  const SFENTRY *tblterm;
                                         ret |= flagload_ext(&sffh->sfh, tbl);                                          ret |= flagload_ext(&sffh->sfh, tbl);
                                         break;                                          break;
   
                                   case STATFLAG_FDD:
                                           ret |= flagload_fdd(&sffh->sfh, tbl);
                                           break;
   
 #if !defined(DISABLE_SOUND)  #if !defined(DISABLE_SOUND)
                                 case STATFLAG_FM:                                  case STATFLAG_FM:
                                         ret |= flagload_fm(&sffh->sfh, tbl);                                          ret |= flagload_fm(&sffh->sfh, tbl);
Line 1445  const SFENTRY *tblterm; Line 1535  const SFENTRY *tblterm;
                                         ret |= flagload_mem(&sffh->sfh, tbl);                                          ret |= flagload_mem(&sffh->sfh, tbl);
                                         break;                                          break;
   
                                   case STATFLAG_SXSI:
                                           ret |= flagload_sxsi(&sffh->sfh, tbl);
                                           break;
   
                                 default:                                  default:
                                         ret |= STATFLAG_WARNING;                                          ret |= STATFLAG_WARNING;
                                         break;                                          break;
Line 1457  const SFENTRY *tblterm; Line 1551  const SFENTRY *tblterm;
         statflag_close(sffh);          statflag_close(sffh);
   
         // I/O作り直し          // I/O作り直し
         i286_memorymap((pccore.model & PCMODEL_EPSON)?1:0);          MEMM_ARCH((pccore.model & PCMODEL_EPSON)?1:0);
         iocore_build();          iocore_build();
         iocore_bind();          iocore_bind();
         cbuscore_bind();          cbuscore_bind();
Line 1474  const SFENTRY *tblterm; Line 1568  const SFENTRY *tblterm;
         FONTPTR_LOW = fontrom + cgwindow.low;          FONTPTR_LOW = fontrom + cgwindow.low;
         FONTPTR_HIGH = fontrom + cgwindow.high;          FONTPTR_HIGH = fontrom + cgwindow.high;
 #endif  #endif
         i286_vram_dispatch(vramop.operate);          MEMM_VRAM(vramop.operate);
           fddmtr_reset();
         soundmng_play();          soundmng_play();
   
         return(ret);          return(ret);
Removed from v.1.43  
changed lines
  Added in v.1.52

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