WebSVN – SvarDOS – Diff – /tree/trunk/dosdisk.c

   findData->dwReserved1 = 0;
+}
 HANDLE FindFirstFile(const char *pathname, struct WIN32_FIND_DATA *findData)
+{
-  char path[1024];
+  static char path[1024];
   HANDLE hnd;
   short cflag = 0;  /* used to indicate if findfirst is succesful or not */
   /* verify findData is valid */
   if (findData == NULL)
   memset(findData, 0, sizeof(struct WIN32_FIND_DATA));
   /* First try DOS LFN (0x714E) findfirst, going to old (0x4E) if error */
   if (LFN_Enable_Flag)
+  {
+    unsigned short attr = searchAttr;
+    unsigned short varax = 0xffff;
+    unsigned short finddata_seg = FP_SEG(findData);
+    unsigned short finddata_off = FP_OFF(findData);
+    unsigned char cf = 1;
+    unsigned short pathname_seg = FP_SEG(pathname);
+    unsigned short pathname_off = FP_OFF(pathname);
     hnd->flag = FINDFILELFN;
-    asm {
+    _asm {
+      push ax
+      push bx
+      push cx
+      push dx
-      STC                          //; In case not supported
+      push es
-      PUSH SI                      //; Ensure borlands registers unmodified
+      push si
-      PUSH DI
+      push di
+      stc                          //; In case not supported
-      MOV SI, 1                    //; same format as when old style used, set to 0 for 64bit value
+      mov si, 1                    //; same format as when old style used, set to 0 for 64bit value
-      MOV AX, DS                   //; Set address of findData into ES:DI
+      mov di, finddata_off         //; Set address of findData into ES:DI
-      MOV ES, AX
-      MOV DI, [findData]
+      mov es, finddata_seg
-      MOV AX, 714Eh                //; LFN version of FindFirst
+      mov ax, 0x714E               //; LFN version of FindFirst
+      mov cx, attr
-      MOV DX, [pathname]           //; Load DS:DX with pointer to path for Findfirt
+      mov dx, pathname_off         //; Load DS:DX with pointer to path for Findfirst
-    }
+      push ds
-    _CX = searchAttr;
+      mov ds, pathname_seg
-    asm {
-      INT 21h                      //; Execute interrupt
+      int 0x21                     //; Execute interrupt
+      pop ds
-      POP DI                       //; Restore DI
+      jc lfnerror
+      mov cf, 0
+      mov varax, ax
+      lfnerror:
+      pop di
+      pop si
+      pop es
+      pop dx
+      pop cx
+      pop bx
+      pop ax
+    }
+    if (cf == 0) {
-      POP SI                       //; Restore SI
+      hnd->fhnd.handle = varax;  /* store handle finally :) */
-      JC lfnerror
+      return hnd;
+    }
-    hnd->fhnd.handle = _AX;  /* store handle finally :) */
-    return hnd;
-lfnerror:
     /* AX is supposed to contain 7100h if function not supported, else real error */
     /* However, FreeDOS returns AX = 1 = Invalid function number instead.         */
-    if ((_AX != 0x7100) && (_AX != 0x0001))
+    if ((varax != 0x7100) && (varax != 0x0001)) {
-    {
       free(hnd);
       return INVALID_HANDLE_VALUE;
+    }
+  }
+  {
   int eos = strlen(path) - 1;
   if ((path[eos] == '*') && (path[eos - 1] == '\\')) strcat(path, ".*");
+  }
+  {
+    unsigned short ffdta_seg, ffdta_off;
+    unsigned short path_seg, path_off;
+    unsigned short sattr = searchAttr;
+    ffdta_seg = FP_SEG((*hnd).fhnd.ffdtaptr);
+    ffdta_off = FP_OFF((*hnd).fhnd.ffdtaptr);
+    path_seg = FP_SEG(path);
+    path_off = FP_OFF(path);
-  asm {
+  _asm {
+    push ax
+    push bx
+    push cx
+    push dx
+    push es
-    MOV AH, 2Fh                    //; Get Current DTA
+    mov ah, 0x2F                   //; Get Current DTA
-    INT 21h                        //; Execute interrupt, returned in ES:BX
+    int 0x21                       //; Execute interrupt, returned in ES:BX
-    PUSH BX                        //; Store its Offset, then Segment
+    push bx                        //; Store its Offset, then Segment
-    PUSH ES
+    push es
-    MOV AH, 1Ah                    //; Set Current DTA to our buffer, DS:DX
+    mov ah, 0x1A                   //; Set Current DTA to our buffer, DS:DX
- }
-    _DX = (WORD)(*hnd).fhnd.ffdtaptr;   //; Load our buffer for new DTA.
+    mov dx, ffdta_off
- asm {
+    push ds
+    mov ds, ffdta_seg
-    INT 21h                        //; Execute interrupt
+    int 0x21                       //; Execute interrupt
+    pop ds
-    MOV AX, 4E00h                  //; Actual findfirst call
+    mov ax, 0x4E00                 //; Actual findfirst call
+    mov cx, sattr
-    LEA DX, path                   //; Load DS:DX with pointer to path for Findfirt
+    mov dx, path_off               //; Load DS:DX with pointer to path for Findfirt
-  }
+    push ds
-    _CX = searchAttr;
+    mov ds, path_seg
-  asm {
-    INT 21h                        //; Execute interrupt
+    int 0x21                       //; Execute interrupt
+    pop ds
-    JNC success                    //; If carry is not set then succesful
+    jnc success                    //; If carry is not set then succesful
-    MOV [cflag], AX                //; Set flag with error.
+    mov [cflag], ax                //; Set flag with error.
-  }
 success:
-  asm {
-    MOV AH, 1Ah               //; Set Current DTA back to original, DS:DX
+    mov ah, 0x1A              //; Set Current DTA back to original, DS:DX
-    MOV DX, DS                //; Store DS, must be preserved
+    mov dx, ds                //; Store DS, must be preserved
-    POP DS                    //; Popping ES into DS since thats where we need it.
+    pop ds                    //; Popping ES into DS since thats where we need it.
-    POP BX                    //; Now DS:BX points to original DTA
+    pop bx                    //; Now DS:BX points to original DTA
-    INT 21h                   //; Execute interrupt to restore.
+    int 0x21                  //; Execute interrupt to restore.
-    MOV DS, DX                //; Restore DS
+    mov ds, dx                //; Restore DS
+    pop es
+    pop dx
+    pop cx
+    pop bx
+    pop ax
+  }
+  }
   if (cflag)
+  {
     free(hnd->fhnd.ffdtaptr);
   memset(findData, 0, sizeof(struct WIN32_FIND_DATA));
   /* Flag indicate if using LFN DOS (0x714F) or not */
   if (hnd->flag == FINDFILELFN)
+  {
-    _BX = hnd->fhnd.handle;        //; Move the Handle returned by previous findfirst into BX
+    unsigned short handle = hnd->fhnd.handle;
+    unsigned char cf = 0;
-    asm {
+    _asm {
+      push ax
+      push bx
+      push cx
+      push dx
+      push es
+      push si
+      push di
-      STC                          //; In case not supported
+      mov bx, handle               //; Move the Handle returned by prev findfirst into BX
-      PUSH SI                      //; Ensure borlands registers unmodified
+      stc                          //; In case not supported
-      PUSH DI
-      MOV SI, 1                    //; same format as when old style used, set to 0 for 64bit value
+      mov si, 1                    //; same format as when old style used, set to 0 for 64bit value
-      MOV AX, DS                   //; Set address of findData into ES:DI
+      mov ax, ds                   //; Set address of findData into ES:DI
-      MOV ES, AX
+      mov es, ax
-      MOV DI, [findData]
+      mov di, [findData]
-      MOV AX, 714Fh                //; LFN version of FindNext
+      mov ax, 0x714F               //; LFN version of FindNext
-      INT 21h                      //; Execute interrupt
+      int 0x21                     //; Execute interrupt
-      POP DI                       //; Restore DI
+      jnc DONE
-      POP SI                       //; Restore SI
+      mov cf, 1
+      DONE:
+      pop di
+      pop si
-      JC lfnerror
+      pop es
+      pop dx
+      pop cx
+      pop bx
+      pop ax
+    }
-    return 1;   /* success */
+    if (cf == 0) return 1;   /* success */
-lfnerror:
     return 0;   /* Any errors here, no other option but to return error/no more files */
-  }
-  else  /* Use DOS (0x4F) findnext, returning if error */
+  } else { /* Use DOS (0x4F) findnext, returning if error */
+    unsigned short dta_seg = FP_SEG((*hnd).fhnd.ffdtaptr);
+    unsigned short dta_off = FP_OFF((*hnd).fhnd.ffdtaptr);
-  {
+    _asm {
+      push ax
+      push bx
+      push cx
+      push dx
-    asm {
+      push es
-      MOV AH, 2Fh                   //; Get Current DTA
+      mov ah, 0x2F                  //; Get Current DTA
-      INT 21h                       //; Execute interrupt, returned in ES:BX
+      int 0x21                      //; Execute interrupt, returned in ES:BX
-      PUSH BX                       //; Store its Offset, then Segment
+      push bx                       //; Store its Offset, then Segment
-      PUSH ES
+      push es
-    }
-    _DX = (WORD)(*hnd).fhnd.ffdtaptr;    //; Load our buffer for new DTA.
+      mov ax, 0x1A00                //; Set Current DTA to our buffer, DS:DX
+      mov dx, dta_off
-    asm {
+      push ds
-      MOV AX, 1A00h                 //; Set Current DTA to our buffer, DS:DX
+      mov ds, dta_seg
-      INT 21h                       //; Execute interrupt
+      int 0x21                      //; Execute interrupt
+      pop ds
-      MOV AX, 4F00h                 //; Actual findnext call
+      mov ax, 0x4F00                //; Actual findnext call
-      INT 21h                       //; Execute interrupt
+      int 0x21                      //; Execute interrupt
       JNC success                   //; If carry is not set then succesful
-      MOV [cflag], AX               //; Set flag with error.
+      mov [cflag], ax               //; Set flag with error.
-    }
 success:
-    asm {
-      MOV AH, 1Ah                   //; Set Current DTA back to original, DS:DX
+      mov ah, 0x1A                  //; Set Current DTA back to original, DS:DX
-      MOV DX, DS                    //; Store DS, must be preserved
+      MOV dx, ds                    //; Store DS, must be preserved
-      POP DS                        //; Popping ES into DS since thats where we need it.
+      pop ds                        //; Popping ES into DS since thats where we need it.
-      POP BX                        //; Now DS:BX points to original DTA
+      pop bx                        //; Now DS:BX points to original DTA
-      INT 21h                       //; Execute interrupt to restore.
+      int 0x21                      //; Execute interrupt to restore.
-      MOV DS, DX                    //; Restore DS
+      mov ds, dx                    //; Restore DS
+      pop es
+      pop dx
+      pop cx
+      pop bx
+      pop ax
+    }
-  if (cflag)
-    return 0;
+  if (cflag) return 0;
   /* copy its results over */
   copyFileData(findData, hnd->fhnd.ffdtaptr);
   return 1;
         free(hnd->fhnd.ffdtaptr);
       hnd->fhnd.ffdtaptr = NULL;
+    }
     else /* must call LFN findclose */
+    {
-      _BX = hnd->fhnd.handle;     /* Move handle returned from findfirst into BX */
+      unsigned short handle = hnd->fhnd.handle;
-      asm {
+      _asm {
+        push ax
+        push bx
+        mov bx, handle            /* Move handle returned from findfirst into BX */
-        STC
+        stc
-        MOV AX, 71A1h
+        mov ax, 0x71A1
-        INT 21h                   /* carry set on error */
+        int 0x21                  /* carry set on error */
+        pop bx
+        pop ax
+      }
       hnd->fhnd.handle = 0;
+    }
     free(hnd);                    /* Free memory used for the handle itself */
 /* returns zero on failure, if lpRootPathName is NULL or "" we use current
  * default drive. */
 int GetVolumeInformation(const char *lpRootPathName, char *lpVolumeNameBuffer,
   DWORD nVolumeNameSize, DWORD *lpVolumeSerialNumber) {
-  /* File info for getting  Volume Label (using directory entry) */
-  struct FFDTA finfo;
   /* Using DOS interrupt to get serial number */
-  struct media_info
+  struct media_info {
-  {
     short dummy;
     DWORD serial;
     char volume[11];
     short ftype[8];
   } media;
    * 2 = LFN api unsupported (tentative failure)
    */
   int cflag=2;
   /* validate root path to obtain info on, NULL or "" means use current */
-  if ((lpRootPathName == NULL) || (*lpRootPathName == '\0'))
+  if ((lpRootPathName == NULL) || (*lpRootPathName == '\0')) {
-  {
     /* Assume if NULL user wants current drive, eg C:\ */
-    asm {
+    _asm {
+      push ax
+      push bx
-      MOV AH, 19h             //; Get Current Default Drive
+      mov ah, 0x19            //; Get Current Default Drive
-      INT 21h                 //; returned in AL, 0=A, 1=B,...
+      int 0x21                //; returned in AL, 0=A, 1=B,...
-      LEA BX, pathname        //; load pointer to our buffer
+      lea bx, pathname        //; load pointer to our buffer
-      ADD AL, 'A'             //; Convert #returned to a letter
+      add al, 'A'             //; Convert #returned to a letter
-      MOV [BX], AL            //; Store drive letter
+      mov [bx], al            //; Store drive letter
-      INC BX                  //; point to next character
+      inc bx                  //; point to next character
-      MOV BYTE PTR [BX], ':'  //; Store the colon
+      mov byte ptr [bx], ':'  //; Store the colon
-      INC BX
+      inc bx
-      MOV BYTE PTR [BX], '\'  //; and the \ (this gets converted correctly as a single \
+      mov byte ptr [bx], '\'  //; this gets converted correctly as a single bkslsh
-      INC BX
+      inc bx
-      MOV BYTE PTR [BX], 0    //; Most importantly the '\0' terminator
+      mov byte ptr [bx], 0    //; Most importantly the '\0' terminator
+      pop bx
+      pop ax
+    }
   } else {
     strcpy(pathname, lpRootPathName);
+  }
   /* Flag indicate if using LFN DOS or not */
   if (LFN_Enable_Flag)
+  {
-    asm {
+    _asm {
+      push ax
+      push bx
+      push cx
+      push dx
+      push es
+      push di
-      MOV AX, 71A0h            //; LFN GetVolumeInformation
+      mov ax, 0x71A0           //; LFN GetVolumeInformation
-      PUSH DI                  //; Preserve DI for borland
-      MOV DX, DS               //; Load buffer for file system name into ES:DI
+      mov dx, ds               //; Load buffer for file system name into ES:DI
-      MOV ES, DX
+      MOV es, dx
-      LEA DI, fsystem
+      lea di, fsystem
-      MOV CX, 32               //; size of ES:DI buffer
+      mov cx, 32               //; size of ES:DI buffer
-      LEA DX, pathname         //; Load root name into DS:DX
+      lea dx, pathname         //; Load root name into DS:DX
-      STC                      //; in case LFN api unsupported
+      stc                      //; in case LFN api unsupported
-      INT 21h
+      int 0x21
-      POP DI                   //; restore Borland's register
+      jc getvolerror           //; on any error skip storing any info
-      JC getvolerror           //; on any error skip storing any info
+      mov cflag, 0             //; indicate no error
-    }
+      jmp endgetvol
     /* store stuff
-	    BX = file system flags (see #01783)
+       BX = file system flags (see #01783)
-	    CX = maximum length of file name [usually 255]
+       CX = maximum length of file name [usually 255]
-	    DX = maximum length of path [usually 260]
+       DX = maximum length of path [usually 260]
-	    fsystem buffer filled (ASCIZ, e.g. "FAT","NTFS","CDFS")
+       fsystem buffer filled (ASCIZ, e.g. "FAT","NTFS","CDFS")
     */
-    cflag = 0;                 //; indicate no error
-    goto endgetvol;
 getvolerror:
-    asm {
-      CMP AX, 7100h            //; see if real error or unsupported
+      cmp ax, 0x7100           //; see if real error or unsupported
-      JE endgetvol             //; if so skip ahead
+      je endgetvol             //; if so skip ahead
-      CMP AX, 0001h            //; FreeDOS returns AX = 1 = Invalid function number
+      cmp ax, 0x0001           //; FreeDOS returns AX = 1 = Invalid function number
-      JE endgetvol
+      je endgetvol
-    }
-    cflag = 1;                 //; indicate failure
+      mov cflag, 1             //; indicate failure
 endgetvol:
+      pop di
+      pop es
+      pop dx
+      pop cx
+      pop bx
+      pop ax
+    }
+  }
   if (cflag != 1)  /* if no error validating volume info or LFN getVolInfo unsupported */
+  {
     /* if a drive, test if valid, get volume, and possibly serial # */
-    if (pathname[1] == ':')
+    if (pathname[1] == ':') {
+      struct FFDTA finfo;
+      unsigned short attr_seg = FP_SEG(finfo.ff_attr);
+      unsigned short attr_off = FP_OFF(finfo.ff_attr);
+      unsigned short finfo_seg = FP_SEG(&finfo);
+      unsigned short finfo_off = FP_OFF(&finfo);
+      unsigned short pathname_seg = FP_SEG(pathname);
+      unsigned short pathname_off = FP_OFF(pathname);
-    {
       /* assume these calls will succeed, change on an error */
       cflag = 0;
       /* get path ending in \*.*, */
       if (pathname[strlen(pathname)-1] != '\\')
 	strcat(pathname, "*.*");
       /* Search for volume using old findfirst, as LFN version (NT5 DOS box) does
        * not recognize FILE_ATTRIBUTE_LABEL = 0x0008 as label attribute.
        */
-      asm {
+      _asm {
+        push ax
+        push bx
+        push cx
+        push dx
+        push es
-	MOV AH, 2Fh               //; Get Current DTA
+        mov ah, 0x2F              //; Get Current DTA
-	INT 21h                   //; Execute interrupt, returned in ES:BX
+        int 0x21                  //; Execute interrupt, returned in ES:BX
-	PUSH BX                   //; Store its Offset, then Segment
+        push bx                   //; Store its Offset, then Segment
-	PUSH ES
+        push es
-	MOV AH, 1Ah               //; Set Current DTA to our buffer, DS:DX
+        mov ah, 0x1A              //; Set Current DTA to our buffer, DS:DX
-	LEA DX, finfo       	    //; Load our buffer for new DTA.
+        mov dx, finfo_off         //; Load our buffer for new DTA.
+        push ds
+        mov ds, finfo_seg
-	INT 21h                   //; Execute interrupt
+        int 0x21                  //; Execute interrupt
+        pop ds
-	MOV AX, 4E00h             //; Actual findfirst call
+        mov ax, 0x4E00            //; Actual findfirst call
+        mov cx, FILE_ATTRIBUTE_LABEL
-	LEA DX, pathname          //; Load DS:DX with pointer to modified RootPath for Findfirt
+        mov dx, pathname_off      //; Load DS:DX with pointer to modified RootPath for Findfirt
+        push ds
-	MOV CX, FILE_ATTRIBUTE_LABEL
+        mov ds, pathname_seg
-	INT 21h                   //; Execute interrupt, Carry set on error, unset on success
+        int 0x21                  //; Execute interrupt, Carry set on error, unset on success
+        pop ds
-	JNC success               //; If carry is not set then succesful
+        jnc success               //; If carry is not set then succesful
-	MOV [cflag], AX           //; Set flag with error.
+        mov [cflag], ax           //; Set flag with error.
-	JMP cleanup               //; Restore DTA
+        jmp cleanup               //; Restore DTA
-      }
 success:                        //; True volume entry only has volume attribute set [MS' LFNspec]
-      asm {                     //;     But they may also have archive bit set!!!
+        mov bx, attr_off
+        push es
-	LEA BX, finfo.ff_attr   //; Load address of file's attributes returned by findfirst/next
+        mov es, attr_seg
-	MOV AL, BYTE PTR [BX]     //; Looking for a BYTE that is FILE_ATTRIBUTE_LABEL only
+        mov al, [es:bx]              //; Looking for a BYTE that is FILE_ATTRIBUTE_LABEL only
+        pop es
-      AND AL, 0xDF              //; Ignore Archive bit
+        and al, 0xDF              //; Ignore Archive bit
-	CMP AL, FILE_ATTRIBUTE_LABEL
+        cmp al, FILE_ATTRIBUTE_LABEL
-	JE cleanup                //; They match, so should be true volume entry.
+        je cleanup                //; They match, so should be true volume entry.
-	MOV AX, 4F00h             //; Otherwise keep looking (findnext)
+        mov ax, 0x4F00            //; Otherwise keep looking (findnext)
-	INT 21h                   //; Execute interrupt
+        int 0x21                  //; Execute interrupt
-	JNC success               //; If carry is not set then succesful
+        jnc success               //; If carry is not set then succesful
-	MOV [cflag], AX           //; Set flag with error.
+        mov [cflag], ax           //; Set flag with error.
-      }
 cleanup:
-      asm {
-	MOV AH, 1Ah               //; Set Current DTA back to original, DS:DX
+        mov ah, 0x1A              //; Set Current DTA back to original, DS:DX
-	MOV DX, DS                //; Store DS, must be preserved
+        mov dx, ds                //; Store DS, must be preserved
-	POP DS                    //; Popping ES into DS since thats where we need it.
+        pop ds                    //; Popping ES into DS since thats where we need it.
-	POP BX                    //; Now DS:BX points to original DTA
+        pop bx                    //; Now DS:BX points to original DTA
-	INT 21h                   //; Execute interrupt to restore.
+        int 0x21                  //; Execute interrupt to restore.
-	MOV DS, DX                //; Restore DS
+        mov ds, dx                //; Restore DS
+        pop es
+        pop dx
+        pop cx
+        pop bx
+        pop ax
+      }
       /* copy over volume label, if buffer given */
       if (lpVolumeNameBuffer != NULL)
+      {
 	if (cflag != 0)    /* error or no label */
         cflag = 0;       /* so assume valid drive  */
       /* Get Serial Number, only supports drives mapped to letters */
       media.serial = 0;         /* set to 0, stays 0 on an error */
+      {
+        unsigned short media_off = FP_OFF(&media);
+        unsigned short media_seg = FP_SEG(&media);
-      _BX = (pathname[0] & '\xDF') - 'A' + 1; /* Clear BH, drive in BL */
+        unsigned char drv = (pathname[0] & 0xDF) - 'A' + 1;
-      asm {
+      _asm {
+        push ax
+        push bx
+        push cx
+        push dx
+        xor bh, bh
-        LEA DX, media           //; DS:DX pointer to media structure
+        mov bl, drv             //; Clear BH, drive in BL
-        MOV CX, 0866h           //; CH=disk drive, CL=Get Serial #
+        mov cx, 0x0866          //; CH=disk drive, CL=Get Serial #
-        MOV AX, 440Dh           //; Generic IOCTL
+        mov ax, 0x440D          //; Generic IOCTL
+        mov dx, media_off       //; DS:DX pointer to media structure
+        push ds
+        mov ds, media_seg
-        INT 21h
+        int 0x21
+        pop ds
+        pop dx
+        pop cx
+        pop bx
+        pop ax
+      }
+      }
 /***************** Replaced with 'documented' version of Get Serial Number *********************/
       /* NT2000pro does NOT set or clear the carry for int21h subfunction 6900h
        *   if an error occurs, it leaves media unchanged.
     segread(&s);                      /* load with current segment values     */
     s.ds = FP_SEG(pathname);          /* get Segment of our filename pointer  */
     r.x.cflag = 1;                    /* should be set when unsupported ***   */
-    asm stc;                          /* but clib usually ignores on entry    */
+    _asm stc;                          /* but clib usually ignores on entry    */
     /* Actually perform the call, carry should be set on error or unuspported */
     intdosx(&r, &r, &s);         /* Clib function to invoke DOS int21h call   */
     if (!r.x.cflag)              /* if carry not set then cx has desired info */

Subversion Repositories SvarDOS

(root)/tree/trunk/dosdisk.c – Rev 2042 → 2044