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

Diff for /np2/fdd/newdisk.c between versions 1.6 and 1.12

version 1.6, 2004/01/27 07:24:25 version 1.12, 2005/02/12 12:13:57
Line 1 Line 1
 #include        "compiler.h"  #include        "compiler.h"
   #if defined(OSLANG_UTF8) || defined(OSLANG_UCS2)
   #include        "oemtext.h"
   #endif
 #include        "dosio.h"  #include        "dosio.h"
 #include        "newdisk.h"  #include        "newdisk.h"
 #include        "fddfile.h"  #include        "fddfile.h"
Line 8 Line 11
   
 // ---- fdd  // ---- fdd
   
 void newdisk_fdd(const char *fname, REG8 type, const char *label) {  void newdisk_fdd(const OEMCHAR *fname, REG8 type, const OEMCHAR *label) {
   
         _D88HEAD        d88head;          _D88HEAD        d88head;
         FILEH           fh;          FILEH           fh;
   
         ZeroMemory(&d88head, sizeof(d88head));          ZeroMemory(&d88head, sizeof(d88head));
         STOREINTELDWORD(d88head.fd_size, sizeof(d88head));          STOREINTELDWORD(d88head.fd_size, sizeof(d88head));
   #if defined(OSLANG_UTF8) || defined(OSLANG_UCS2)
           oemtext_oemtosjis((char *)d88head.fd_name, sizeof(d88head.fd_name),
                                                                                                                           label, (UINT)-1);
   #else
         milstr_ncpy((char *)d88head.fd_name, label, sizeof(d88head.fd_name));          milstr_ncpy((char *)d88head.fd_name, label, sizeof(d88head.fd_name));
   #endif
         d88head.fd_type = type;          d88head.fd_type = type;
         fh = file_create(fname);          fh = file_create(fname);
         if (fh != FILEH_INVALID) {          if (fh != FILEH_INVALID) {
Line 29  void newdisk_fdd(const char *fname, REG8 Line 37  void newdisk_fdd(const char *fname, REG8
   
 static BOOL writezero(FILEH fh, UINT size) {  static BOOL writezero(FILEH fh, UINT size) {
   
         BYTE    work[256];          UINT8   work[256];
         UINT    wsize;          UINT    wsize;
   
         ZeroMemory(work, sizeof(work));          ZeroMemory(work, sizeof(work));
Line 43  static BOOL writezero(FILEH fh, UINT siz Line 51  static BOOL writezero(FILEH fh, UINT siz
         return(SUCCESS);          return(SUCCESS);
 }  }
   
 static void writehddipl(FILEH fh, UINT ssize) {  static BOOL writehddipl(FILEH fh, UINT ssize, UINT32 tsize) {
   
         BYTE    work[1024];          UINT8   work[1024];
           UINT    size;
   
         ZeroMemory(work, sizeof(work));          ZeroMemory(work, sizeof(work));
         CopyMemory(work, hdddiskboot, sizeof(hdddiskboot));          CopyMemory(work, hdddiskboot, sizeof(hdddiskboot));
Line 53  static void writehddipl(FILEH fh, UINT s Line 62  static void writehddipl(FILEH fh, UINT s
                 work[ssize - 2] = 0x55;                  work[ssize - 2] = 0x55;
                 work[ssize - 1] = 0xaa;                  work[ssize - 1] = 0xaa;
         }          }
         file_write(fh, work, sizeof(work));          if (file_write(fh, work, sizeof(work)) != sizeof(work)) {
                   return(FAILURE);
           }
           if (tsize > sizeof(work)) {
                   tsize -= sizeof(work);
                   ZeroMemory(work, sizeof(work));
                   while(tsize) {
                           size = min(tsize, sizeof(work));
                           tsize -= size;
                           if (file_write(fh, work, size) != size) {
                                   return(FAILURE);
                           }
                   }
           }
           return(SUCCESS);
 }  }
   
 void newdisk_thd(const char *fname, UINT hddsize) {  void newdisk_thd(const OEMCHAR *fname, UINT hddsize) {
   
         FILEH   fh;          FILEH   fh;
         BYTE    work[256];          UINT8   work[256];
         UINT    size;          UINT    size;
           BOOL    r;
   
         if ((fname == NULL) || (hddsize < 5) || (hddsize > 256)) {          if ((fname == NULL) || (hddsize < 5) || (hddsize > 256)) {
                 return;                  goto ndthd_err;
         }          }
         fh = file_create(fname);          fh = file_create(fname);
         if (fh != FILEH_INVALID) {          if (fh == FILEH_INVALID) {
                 ZeroMemory(work, 256);                  goto ndthd_err;
                 size = hddsize * 15;          }
                 STOREINTELWORD(work, size);          ZeroMemory(work, 256);
                 file_write(fh, work, 256);          size = hddsize * 15;
                 writehddipl(fh, 256);          STOREINTELWORD(work, size);
                 file_close(fh);          r = (file_write(fh, work, 256) != 256);
           r |= writehddipl(fh, 256, 0);
           file_close(fh);
           if (r) {
                   file_delete(fname);
         }          }
   
   ndthd_err:
           return;
 }  }
   
 void newdisk_nhd(const char *fname, UINT hddsize) {  void newdisk_nhd(const OEMCHAR *fname, UINT hddsize) {
   
         FILEH   fh;          FILEH   fh;
         NHDHDR  nhd;          NHDHDR  nhd;
         UINT    tmp;          UINT    size;
           BOOL    r;
   
         if ((fname == NULL) || (hddsize < 5) || (hddsize > 512)) {          if ((fname == NULL) || (hddsize < 5) || (hddsize > 512)) {
                 return;                  goto ndnhd_err;
         }          }
         fh = file_create(fname);          fh = file_create(fname);
         if (fh != FILEH_INVALID) {          if (fh == FILEH_INVALID) {
                 ZeroMemory(&nhd, sizeof(nhd));                  goto ndnhd_err;
                 CopyMemory(&nhd.sig, sig_nhd, 15);          }
                 STOREINTELDWORD(nhd.headersize, sizeof(nhd));          ZeroMemory(&nhd, sizeof(nhd));
                 tmp = hddsize * 16;          CopyMemory(&nhd.sig, sig_nhd, 15);
                 STOREINTELDWORD(nhd.cylinders, tmp);          STOREINTELDWORD(nhd.headersize, sizeof(nhd));
                 STOREINTELWORD(nhd.surfaces, 8);          size = hddsize * 15;
                 STOREINTELWORD(nhd.sectors, 32);          STOREINTELDWORD(nhd.cylinders, size);
                 STOREINTELWORD(nhd.sectorsize, 256);          STOREINTELWORD(nhd.surfaces, 8);
                 file_write(fh, &nhd, sizeof(nhd));          STOREINTELWORD(nhd.sectors, 17);
                 writehddipl(fh, 256);          STOREINTELWORD(nhd.sectorsize, 512);
                 file_close(fh);          r = (file_write(fh, &nhd, sizeof(nhd)) != sizeof(nhd));
           r |= writehddipl(fh, 512, size * 8 * 17 * 512);
           file_close(fh);
           if (r) {
                   file_delete(fname);
         }          }
   
   ndnhd_err:
           return;
 }  }
   
 // hddtype = 0:5MB / 1:10MB / 2:15MB / 3:20MB / 5:30MB / 6:40MB  // hddtype = 0:5MB / 1:10MB / 2:15MB / 3:20MB / 5:30MB / 6:40MB
 void newdisk_hdi(const char *fname, UINT hddtype) {  void newdisk_hdi(const OEMCHAR *fname, UINT hddtype) {
   
 const SASIHDD   *sasi;  const SASIHDD   *sasi;
         FILEH           fh;          FILEH           fh;
         HDIHDR          hdi;          HDIHDR          hdi;
         UINT32          tmp;          UINT32          size;
           BOOL            r;
   
         hddtype &= 7;          hddtype &= 7;
         if ((fname == NULL) || (hddtype == 7)) {          if ((fname == NULL) || (hddtype == 7)) {
                 return;                  goto ndhdi_err;
         }          }
         sasi = sasihdd + hddtype;          sasi = sasihdd + hddtype;
         fh = file_create(fname);          fh = file_create(fname);
         if (fh != FILEH_INVALID) {          if (fh == FILEH_INVALID) {
                 ZeroMemory(&hdi, sizeof(hdi));                  goto ndhdi_err;
                 tmp = 256 * sasi->sectors * sasi->surfaces * sasi->cylinders;          }
 //              STOREINTELDWORD(hdi.hddtype, 0);                                // ???          ZeroMemory(&hdi, sizeof(hdi));
                 STOREINTELDWORD(hdi.headersize, 4096);          size = 256 * sasi->sectors * sasi->surfaces * sasi->cylinders;
                 STOREINTELDWORD(hdi.hddsize, tmp);  //      STOREINTELDWORD(hdi.hddtype, 0);
                 STOREINTELDWORD(hdi.sectorsize, 256);          STOREINTELDWORD(hdi.headersize, 4096);
                 STOREINTELDWORD(hdi.sectors, sasi->sectors);          STOREINTELDWORD(hdi.hddsize, size);
                 STOREINTELDWORD(hdi.surfaces, sasi->surfaces);          STOREINTELDWORD(hdi.sectorsize, 256);
                 STOREINTELDWORD(hdi.cylinders, sasi->cylinders);          STOREINTELDWORD(hdi.sectors, sasi->sectors);
                 file_write(fh, &hdi, sizeof(hdi));          STOREINTELDWORD(hdi.surfaces, sasi->surfaces);
                 writezero(fh, 4096 - sizeof(hdi));          STOREINTELDWORD(hdi.cylinders, sasi->cylinders);
                 writehddipl(fh, 256);          r = (file_write(fh, &hdi, sizeof(hdi)) != sizeof(hdi));
                 file_close(fh);          r |= writezero(fh, 4096 - sizeof(hdi));
           r |= writehddipl(fh, 256, size);
           file_close(fh);
           if (r) {
                   file_delete(fname);
         }          }
   
   ndhdi_err:
           return;
 }  }
   
 void newdisk_vhd(const char *fname, UINT hddsize) {  void newdisk_vhd(const OEMCHAR *fname, UINT hddsize) {
   
         FILEH   fh;          FILEH   fh;
         VHDHDR  vhd;          VHDHDR  vhd;
         UINT    tmp;          UINT    tmp;
           BOOL    r;
   
         if ((fname == NULL) || (hddsize < 2) || (hddsize > 512)) {          if ((fname == NULL) || (hddsize < 2) || (hddsize > 512)) {
                 return;                  goto ndvhd_err;
         }          }
         fh = file_create(fname);          fh = file_create(fname);
         if (fh != FILEH_INVALID) {          if (fh == FILEH_INVALID) {
                 ZeroMemory(&vhd, sizeof(vhd));                  goto ndvhd_err;
                 CopyMemory(&vhd.sig, sig_vhd, 7);  
                 STOREINTELWORD(vhd.mbsize, (UINT16)hddsize);  
                 STOREINTELWORD(vhd.sectorsize, 256);  
                 vhd.sectors = 32;  
                 vhd.surfaces = 8;  
                 tmp = hddsize * 16;             // = * 1024 * 1024 / (8 * 32 * 256);  
                 STOREINTELWORD(vhd.cylinders, (UINT16)tmp);  
                 tmp *= 8 * 32;  
                 STOREINTELDWORD(vhd.totals, tmp);  
                 file_write(fh, &vhd, sizeof(vhd));  
                 writehddipl(fh, 256);  
                 file_close(fh);  
         }          }
           ZeroMemory(&vhd, sizeof(vhd));
           CopyMemory(&vhd.sig, sig_vhd, 7);
           STOREINTELWORD(vhd.mbsize, (UINT16)hddsize);
           STOREINTELWORD(vhd.sectorsize, 256);
           vhd.sectors = 32;
           vhd.surfaces = 8;
           tmp = hddsize * 16;             // = * 1024 * 1024 / (8 * 32 * 256);
           STOREINTELWORD(vhd.cylinders, (UINT16)tmp);
           tmp *= 8 * 32;
           STOREINTELDWORD(vhd.totals, tmp);
           r = (file_write(fh, &vhd, sizeof(vhd)) != sizeof(vhd));
           r |= writehddipl(fh, 256, 0);
           file_close(fh);
           if (r) {
                   file_delete(fname);
           }
   
   ndvhd_err:
           return;
 }  }
   
Removed from v.1.6  
changed lines
  Added in v.1.12

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