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

Diff for /np2/generic/hostdrv.c between versions 1.11 and 1.17

version 1.11, 2004/01/26 14:49:14 version 1.17, 2005/05/13 06:19:48
Line 66  static void fetch_if4dos(void) { Line 66  static void fetch_if4dos(void) {
         REG16   seg;          REG16   seg;
         IF4DOS  if4dos;          IF4DOS  if4dos;
   
         off = i286_memoryread_w(IF4DOSPTR_ADDR);          off = MEML_READ16(IF4DOSPTR_SEG, IF4DOSPTR_OFF + 0);
         seg = i286_memoryread_w(IF4DOSPTR_ADDR + 2);          seg = MEML_READ16(IF4DOSPTR_SEG, IF4DOSPTR_OFF + 2);
         i286_memstr_read(seg, off, &if4dos, sizeof(if4dos));          MEML_READSTR(seg, off, &if4dos, sizeof(if4dos));
         hostdrv.stat.drive_no = if4dos.drive_no;          hostdrv.stat.drive_no = if4dos.drive_no;
         hostdrv.stat.dosver_major = if4dos.dosver_major;          hostdrv.stat.dosver_major = if4dos.dosver_major;
         hostdrv.stat.dosver_minor = if4dos.dosver_minor;          hostdrv.stat.dosver_minor = if4dos.dosver_minor;
Line 83  static void fetch_if4dos(void) { Line 83  static void fetch_if4dos(void) {
   
 static void fetch_intr_regs(INTRST is) {  static void fetch_intr_regs(INTRST is) {
   
         i286_memstr_read(CPU_SS, CPU_BP, &is->r, sizeof(is->r));          MEML_READSTR(CPU_SS, CPU_BP, &is->r, sizeof(is->r));
 }  }
   
 static void store_intr_regs(INTRST is) {  static void store_intr_regs(INTRST is) {
   
         i286_memstr_write(CPU_SS, CPU_BP, &is->r, sizeof(is->r));          MEML_WRITESTR(CPU_SS, CPU_BP, &is->r, sizeof(is->r));
 }  }
   
   
Line 98  static void fetch_sda_currcds(SDACDS sc) Line 98  static void fetch_sda_currcds(SDACDS sc)
         REG16   seg;          REG16   seg;
   
         if (hostdrv.stat.dosver_major == 3) {          if (hostdrv.stat.dosver_major == 3) {
                 i286_memstr_read(hostdrv.stat.sda_seg, hostdrv.stat.sda_off,                  MEML_READSTR(hostdrv.stat.sda_seg, hostdrv.stat.sda_off,
                                                                                 &sc->ver3.sda, sizeof(sc->ver3.sda));                                                                                  &sc->ver3.sda, sizeof(sc->ver3.sda));
                 off = LOADINTELWORD(sc->ver3.sda.cdsptr.off);                  off = LOADINTELWORD(sc->ver3.sda.cdsptr.off);
                 seg = LOADINTELWORD(sc->ver3.sda.cdsptr.seg);                  seg = LOADINTELWORD(sc->ver3.sda.cdsptr.seg);
                 i286_memstr_read(seg, off, &sc->ver3.cds, sizeof(sc->ver3.cds));                  MEML_READSTR(seg, off, &sc->ver3.cds, sizeof(sc->ver3.cds));
         }          }
         else {          else {
                 i286_memstr_read(hostdrv.stat.sda_seg, hostdrv.stat.sda_off,                  MEML_READSTR(hostdrv.stat.sda_seg, hostdrv.stat.sda_off,
                                                                                 &sc->ver4.sda, sizeof(sc->ver4.sda));                                                                                  &sc->ver4.sda, sizeof(sc->ver4.sda));
                 off = LOADINTELWORD(sc->ver4.sda.cdsptr.off);                  off = LOADINTELWORD(sc->ver4.sda.cdsptr.off);
                 seg = LOADINTELWORD(sc->ver4.sda.cdsptr.seg);                  seg = LOADINTELWORD(sc->ver4.sda.cdsptr.seg);
                 i286_memstr_read(seg, off, &sc->ver4.cds, sizeof(sc->ver4.cds));                  MEML_READSTR(seg, off, &sc->ver4.cds, sizeof(sc->ver4.cds));
         }          }
 }  }
   
Line 119  static void store_sda_currcds(SDACDS sc) Line 119  static void store_sda_currcds(SDACDS sc)
         REG16   seg;          REG16   seg;
   
         if (hostdrv.stat.dosver_major == 3) {          if (hostdrv.stat.dosver_major == 3) {
                 i286_memstr_write(hostdrv.stat.sda_seg, hostdrv.stat.sda_off,                  MEML_WRITESTR(hostdrv.stat.sda_seg, hostdrv.stat.sda_off,
                                                                                 &sc->ver3.sda, sizeof(sc->ver3.sda));                                                                                  &sc->ver3.sda, sizeof(sc->ver3.sda));
                 off = LOADINTELWORD(sc->ver3.sda.cdsptr.off);                  off = LOADINTELWORD(sc->ver3.sda.cdsptr.off);
                 seg = LOADINTELWORD(sc->ver3.sda.cdsptr.seg);                  seg = LOADINTELWORD(sc->ver3.sda.cdsptr.seg);
                 i286_memstr_write(seg, off, &sc->ver3.cds, sizeof(sc->ver3.cds));                  MEML_WRITESTR(seg, off, &sc->ver3.cds, sizeof(sc->ver3.cds));
         }          }
         else {          else {
                 i286_memstr_write(hostdrv.stat.sda_seg, hostdrv.stat.sda_off,                  MEML_WRITESTR(hostdrv.stat.sda_seg, hostdrv.stat.sda_off,
                                                                                 &sc->ver4.sda, sizeof(sc->ver4.sda));                                                                                  &sc->ver4.sda, sizeof(sc->ver4.sda));
                 off = LOADINTELWORD(sc->ver4.sda.cdsptr.off);                  off = LOADINTELWORD(sc->ver4.sda.cdsptr.off);
                 seg = LOADINTELWORD(sc->ver4.sda.cdsptr.seg);                  seg = LOADINTELWORD(sc->ver4.sda.cdsptr.seg);
                 i286_memstr_write(seg, off, &sc->ver4.cds, sizeof(sc->ver4.cds));                  MEML_WRITESTR(seg, off, &sc->ver4.cds, sizeof(sc->ver4.cds));
         }          }
 }  }
   
Line 142  static void fetch_sft(INTRST is, SFTREC  Line 142  static void fetch_sft(INTRST is, SFTREC 
   
         off = LOADINTELWORD(is->r.w.di);          off = LOADINTELWORD(is->r.w.di);
         seg = LOADINTELWORD(is->r.w.es);          seg = LOADINTELWORD(is->r.w.es);
         i286_memstr_read(seg, off, sft, sizeof(_SFTREC));          MEML_READSTR(seg, off, sft, sizeof(_SFTREC));
 }  }
   
 static void store_sft(INTRST is, SFTREC sft) {  static void store_sft(INTRST is, SFTREC sft) {
Line 152  static void store_sft(INTRST is, SFTREC  Line 152  static void store_sft(INTRST is, SFTREC 
   
         off = LOADINTELWORD(is->r.w.di);          off = LOADINTELWORD(is->r.w.di);
         seg = LOADINTELWORD(is->r.w.es);          seg = LOADINTELWORD(is->r.w.es);
         i286_memstr_write(seg, off, sft, sizeof(_SFTREC));          MEML_WRITESTR(seg, off, sft, sizeof(_SFTREC));
 }  }
   
   
Line 242  static void init_sft(SFTREC sft) { Line 242  static void init_sft(SFTREC sft) {
         else {          else {
                 sft->open_mode[0] &= 0x0f;                  sft->open_mode[0] &= 0x0f;
         }          }
         sft->dev_info_word[0] = (BYTE)(0x40 | hostdrv.stat.drive_no);          sft->dev_info_word[0] = (UINT8)(0x40 | hostdrv.stat.drive_no);
         sft->dev_info_word[1] = 0x80;          sft->dev_info_word[1] = 0x80;
         STOREINTELDWORD(sft->dev_drvr_ptr, 0);          STOREINTELDWORD(sft->dev_drvr_ptr, 0);
         STOREINTELDWORD(sft->file_pos, 0);          STOREINTELDWORD(sft->file_pos, 0);
Line 343  static BOOL read_data(UINT num, UINT32 p Line 343  static BOOL read_data(UINT num, UINT32 p
   
         HDRVFILE        hdf;          HDRVFILE        hdf;
         FILEH           fh;          FILEH           fh;
         BYTE            work[1024];          UINT8           work[1024];
         UINT            r;          UINT            r;
   
         hdf = (HDRVFILE)listarray_getitem(hostdrv.fhdl, num);          hdf = (HDRVFILE)listarray_getitem(hostdrv.fhdl, num);
Line 359  static BOOL read_data(UINT num, UINT32 p Line 359  static BOOL read_data(UINT num, UINT32 p
                 if (file_read(fh, work, r) != r) {                  if (file_read(fh, work, r) != r) {
                         return(FAILURE);                          return(FAILURE);
                 }                  }
                 i286_memstr_write(seg, off, work, r);                  MEML_WRITESTR(seg, off, work, r);
                 off += r;                  off += r;
                 size -= r;                  size -= r;
         }          }
Line 370  static BOOL write_data(UINT num, UINT32  Line 370  static BOOL write_data(UINT num, UINT32 
   
         HDRVFILE        hdf;          HDRVFILE        hdf;
         FILEH           fh;          FILEH           fh;
         BYTE            work[1024];          UINT8           work[1024];
         UINT            r;          UINT            r;
   
         hdf = (HDRVFILE)listarray_getitem(hostdrv.fhdl, num);          hdf = (HDRVFILE)listarray_getitem(hostdrv.fhdl, num);
Line 387  static BOOL write_data(UINT num, UINT32  Line 387  static BOOL write_data(UINT num, UINT32 
         else {          else {
                 do {                  do {
                         r = min(size, sizeof(work));                          r = min(size, sizeof(work));
                         i286_memstr_read(seg, off, work, r);                          MEML_READSTR(seg, off, work, r);
                         if (file_write(fh, work, r) != r) {                          if (file_write(fh, work, r) != r) {
                                 return(FAILURE);                                  return(FAILURE);
                         }                          }
Line 697  static void set_fileattr(INTRST intrst)  Line 697  static void set_fileattr(INTRST intrst) 
                 fail(intrst, ERR_ACCESSDENIED);                  fail(intrst, ERR_ACCESSDENIED);
                 return;                  return;
         }          }
         attr = i286_memword_read(CPU_SS, CPU_BP + sizeof(IF4INTR)) & 0x37;          attr = MEML_READ16(CPU_SS, CPU_BP + sizeof(IF4INTR)) & 0x37;
   
         // 成功したことにする...          // 成功したことにする...
         succeed(intrst);          succeed(intrst);
Line 970  static void do_redir(INTRST intrst) { Line 970  static void do_redir(INTRST intrst) {
         if (pathishostdrv(intrst, &sc) != SUCCESS) {          if (pathishostdrv(intrst, &sc) != SUCCESS) {
                 return;                  return;
         }          }
         mode = i286_memword_read(CPU_SS, CPU_BP + sizeof(IF4INTR));          mode = MEML_READ16(CPU_SS, CPU_BP + sizeof(IF4INTR));
         TRACEOUT(("do_redir: %.4x", mode));          TRACEOUT(("do_redir: %.4x", mode));
         switch(mode) {          switch(mode) {
                 case 0x5f02:                  case 0x5f02:
Line 979  static void do_redir(INTRST intrst) { Line 979  static void do_redir(INTRST intrst) {
                                 fail(intrst, 0x12);                                  fail(intrst, 0x12);
                                 return;                                  return;
                         }                          }
                         i286_memword_write(CPU_DS, CPU_BX + 2, 4);                          MEML_WRITE16(CPU_DS, CPU_BX + 2, 4);
                         i286_memword_write(CPU_DS, CPU_BX + 4, 1);                          MEML_WRITE16(CPU_DS, CPU_BX + 4, 1);
 //                      STOREINTELWORD(intrst->r.w.bx, 4);  
 //                      STOREINTELWORD(intrst->r.w.cx, 1);  
                         tmp[0] = (char)('A' + hostdrv.stat.drive_no);                          tmp[0] = (char)('A' + hostdrv.stat.drive_no);
                         tmp[1] = ':';                          tmp[1] = ':';
                         tmp[2] = '\0';                          tmp[2] = '\0';
                         i286_memstr_write(LOADINTELWORD(intrst->r.w.ds),                          MEML_WRITESTR(LOADINTELWORD(intrst->r.w.ds),
                                                         LOADINTELWORD(intrst->r.w.si), tmp, 3);                                                          LOADINTELWORD(intrst->r.w.si), tmp, 3);
                         i286_memstr_write(LOADINTELWORD(intrst->r.w.es),                          MEML_WRITESTR(LOADINTELWORD(intrst->r.w.es),
                                                         LOADINTELWORD(intrst->r.w.di),                                                          LOADINTELWORD(intrst->r.w.di),
                                                         ROOTPATH, ROOTPATH_SIZE + 1);                                                          ROOTPATH, ROOTPATH_SIZE + 1);
                         break;                          break;
Line 1296  void hostdrv_intr(const void *arg1, long Line 1294  void hostdrv_intr(const void *arg1, long
   
         TRACEOUT(("hostdrv: AL=%.2x", intrst.r.b.al));          TRACEOUT(("hostdrv: AL=%.2x", intrst.r.b.al));
   
         if ((intrst.r.b.al >= sizeof(intr_func) / sizeof(HDINTRFN)) ||          if ((intrst.r.b.al >= NELEMENTS(intr_func)) ||
                 (intr_func[intrst.r.b.al] == NULL)) {                  (intr_func[intrst.r.b.al] == NULL)) {
                 return;                  return;
         }          }
Line 1321  typedef struct { Line 1319  typedef struct {
   
 static BOOL fhdl_wr(void *vpItem, void *vpArg) {  static BOOL fhdl_wr(void *vpItem, void *vpArg) {
   
         char    *p;          OEMCHAR *p;
         UINT    len;          UINT    len;
   
         p = ((HDRVFILE)vpItem)->path;          p = ((HDRVFILE)vpItem)->path;
         len = strlen(p);          len = OEMSTRLEN(p);
         statflag_write((STFLAGH)vpArg, &len, sizeof(len));          statflag_write((STFLAGH)vpArg, &len, sizeof(len));
         if (len) {          if (len) {
                 if (len < sizeof(MAX_PATH)) {                  if (len < MAX_PATH) {
                         ZeroMemory(p + len, sizeof(MAX_PATH) - len);                          ZeroMemory(p + len, (MAX_PATH - len) * sizeof(OEMCHAR));
                 }                  }
                 statflag_write((STFLAGH)vpArg, vpItem, sizeof(_HDRVFILE));                  statflag_write((STFLAGH)vpArg, vpItem, sizeof(_HDRVFILE));
         }          }
Line 1338  static BOOL fhdl_wr(void *vpItem, void * Line 1336  static BOOL fhdl_wr(void *vpItem, void *
   
 static BOOL flist_wr(void *vpItem, void *vpArg) {  static BOOL flist_wr(void *vpItem, void *vpArg) {
   
         char    *p;          OEMCHAR *p;
         int             len;          int             len;
   
         p = ((HDRVLST)vpItem)->realname;          p = ((HDRVLST)vpItem)->realname;
         len = strlen(p);          len = OEMSTRLEN(p);
         if (len < sizeof(MAX_PATH)) {          if (len < MAX_PATH) {
                 ZeroMemory(p + len, sizeof(MAX_PATH) - len);                  ZeroMemory(p + len, (MAX_PATH - len) * sizeof(OEMCHAR));
         }          }
         statflag_write((STFLAGH)vpArg, vpItem, sizeof(_HDRVLST));          statflag_write((STFLAGH)vpArg, vpItem, sizeof(_HDRVLST));
         return(FALSE);          return(FALSE);
Removed from v.1.11  
changed lines
  Added in v.1.17

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