        page    60,150
        title   NJMOVE - Nifty James' MOVE Utility
        subttl  (C) 1989 Blaszczak

;
; Nifty James' Famous Move Utility
; Version 1.00 of 16 January 1989
; (C) Copyright 1989 By Mike Blaszczak
;

;
; This file is written for the Microsoft Macro Assembler,
; Version 5.10 or higher.  The program will not properly
; operate under any DOS version less than 2.00, but will
; work with any PC-DOS or MS-DOS Versions 2.00 and above.
; This is an .EXE file, and should not be run through
; EXE2BIN.  The executable file should be packed, or the
; LINK option /EXEPACK should be used.
;


; ----------------------------------------------------------------------------
;       ASCII Equates

eos     equ     000h            ; end-of-string character
bell    equ     007h            ; bell beeper
bs      equ     008h            ; back-space
tab     equ     009h            ; tab
lf      equ     00Ah            ; line-feed character
cr      equ     00Dh            ; carriage return
ctrlz   equ     01Ah            ; control zee (aka, EOF)
eof     equ     ctrlz
space   equ     020h            ; blank space


; ----------------------------------------------------------------------------
;       DOS Function Calls and constants

INTDOS  equ     021h

STDIN   equ     0               ; standard output file handle
STDOUT  equ     1               ; standard input file handle

NormalAttrib    equ     000h            ; normal attribute byte (nothing set)
SubDirAttrib    equ     010h            ; attribute for a directory

PutChar equ     002h            ; put character to stdout
GetChar equ     007h            ; get char from stdin, with no echo
GetDefDisk      equ     019h            ; get current default disk drive
SetDTA  equ     01Ah            ; set the DOS DTA address
FreeSpace       equ     036h            ; get disk free space
CreateHandle    equ     03Ch            ; create a file handle
OpenHandle      equ     03Dh            ; open a file handle
CloseHandle     equ     03Eh            ; close a file handle
ReadHandle      equ     03Fh            ; read from a file or device
WriteHandle     equ     040h            ; write to a file or device
DeleteFile      equ     041h            ; delete a file name
GetAttrib       equ     04300h          ; get file attributes
SetAttrib       equ     04301h          ; set file attributes
IOCTL   equ     044h            ; I/O control/status call
GetDefDir       equ     047h            ; get current default directory
Terminate       equ     04Ch            ; terminate this program
FindFirst       equ     04Eh            ; find first file matching wildcard
FindNext        equ     04Fh            ; find next file matching wildcard
RenameFile      equ     056h            ; rename a file
GetDateTime     equ     05700h          ; get date or time
SetDateTime     equ     05701h          ; set date or time
NormalizePath   equ     060h            ; normalize pathname
GetPSP  equ     062h            ; get the programs PSP

; note that NormalizePath is an undocumented call.  DS:SI points to a
; path specification which may contain a drive specifier.  ES:DI points
; to a buffer for the normalized pathname.  The file simply fixes the
; "." and ".." references in the file, making the pathname as short as
; possible.  This expansion is simply used so the user knows *exactly*
; where the file is coming from.  Microsoft, in their infinite (heh)
; wisdom (hah) did not document this very useful function call.


; ----------------------------------------------------------------------------
;       ERRORLEVEL values that we return

ERR_None        equ     0               ; none!
ERR_Usage       equ     1               ; problem on command line
ERR_NotFound    equ     2               ; file not found
ERR_BadFile     equ     3               ; given a device, or an unparsable
ERR_CopyProblem equ     4               ; problem while copying
ERR_Renaming    equ     5               ; problem while renaming


; These are the data structures used in this program.  The first is used
; internally to describe the way a file name is broken down into its
; components.

FileDriveLen    equ     3
FilePathLen     equ     65
FileNameLen     equ     9
FileExtLen      equ     5

FileNameS       struc
drive   db      FileDriveLen dup(?)     ; drive         B:
path    db      FilePathLen  dup(?)     ; path          \bin\booger
fname   db      FileNameLen  dup(?)     ; filename      njmove
fext    db      FileExtLen   dup(?)     ; extension     asm
FileNameS       ends


; This data structure is the one that DOS uses to store the DTA.  When
; we call FINDFIRST and FINDNEXT, this information will be set up to contain
; the rest of the file that we are moving.

DOSDTAS struc
_dta_reserved   db      21 dup (?)      ; reserved space
dta_attribute   db      ?               ; attribute byte
dta_time        dw      ?               ; file modification time
dta_date        dw      ?               ; file modification date
dta_size        dd      ?               ; file size (doubleword!)
dta_fname       db      13 dup (?)      ; file name (ASCIIZ)
DOSDTAS ends


; ============================================================================
        .model  small
        .stack  0100h           ; get a *real* stack


; ============================================================================
; Our data area follows.  This data area contains both initialized and
; uninitialized data.

        .data

Banner  db      "Nifty James' Famous Move Utility",cr,lf
        db      "Version 1.00 of 16 January 1989",cr,lf
        db      "(C)Copyright 1989 by Mike Blaszczak",cr,lf
        db      lf,eos

NoSpace db      "NJMOVE: Destination device ran out of space"
CRLFSet db      cr,lf,eos

NoSelf  db      "NJMOVE: A File can not be moved into itself"
        db      cr,lf,eos

CantWrite       db      "NJMOVE: Couldn't write to destination device"
        db      cr,lf,eos

CantRead        db      "NJMOVE: Couldn't read from source device"
        db      cr,lf,eos

CantSDevice     db      "NJMOVE: Can't move from a device"
        db      cr,lf,eos

CantDDevice     db      "NJMOVE: Can't move to a device"
        db      cr,lf,eos

BadSource       db      "NJMOVE: Bad Source File Specification"
        db      cr,lf,eos

BadDest db      "NJMOVE: Bad Destination File Specification"
        db      cr,lf,eos

CouldntRename   db      "NJMOVE: Could not perform rename operation"
        db      cr,lf,eos

NameCollide     db      "NJMOVE: File naming collision; file already exists"
        db      cr,lf,eos

CouldntDIR      db      "NJMOVE: Couldn't get default directory of drive "
        db      eos

NoMatches       db      "NJMOVE: No files matched ",eos

UAborted        db      cr,lf,"NJMOVE: User Aborted",cr,lf,lf,eos

Usage   db      "Usage:",cr,lf
        db      tab,"NJMOVE <source> <dest> [/C]",cr,lf
        db      lf
        db      tab,"<source>",tab,"source file name",cr,lf
        db      tab,"<dest>",tab,tab,"destination file name",cr,lf
        db      tab,tab," both file names may "
        db      "contain wildcards",cr,lf
        db      tab,"[/C]",tab,"specifies optional confirmation"
        db      cr,lf,lf,eos

MovingMess      db      "Moving ",eos
MoveCMess       db      "Move ",eos

CopyingMess     db      "Copying ",eos
CopyCMess       db      "Copy ",eos

ToMess  db      " to ",eos

BackSlash       db      "\",eos

DotStar db      "."
Star    db      "*",eos

ConfirmPrompt   db      "? [No] ",eos


confirmmode     db      0               ; set if the /C was to be found
copymode        db      0               ; set to one if we must copy
                                ;  from disk to disk instead of
                                ;  just renaming the files
        even

sourcespec      dw      0               ; source file specification
destspec        dw      0               ; destination spec

sourcewildf     db      0               ; set if sourcef has wildcard name
sourcewilde     db      0               ; set if sourcef has wildcard ext
sourcehase      db      0               ; set if sourcef has extension
sourcef FileNameS <>            ; source description
sourcefile      db      64 dup (0)      ; total file name

destwildf       db      0               ; set if destf has wildcard name
destwilde       db      0               ; set if destf has wildcard ext
desthase        db      0               ; set if destf has extension
destf   FileNameS <>            ; destination description
destfile        db      64 dup (0)      ; total file name

mydta   DOSDTAS <>              ; a place for DOS to store its stuff
                                ; during FINDFIRST + FINDNEXT

; These variables are used by the copyfile procedure

sourceh dw      ?               ; handle for source file
desth   dw      ?               ; destination file handle

; ----------------------------------------------------------------------------
; These areas are all data buffers that are not initialized, generally.

        even

argvectors      dw      64 dup (0)      ; pointers to each argumnet
argcount        dw      0               ; count of arguments
argbuff db      128 dup (0)     ; buffer to hold args for DS access

CopyBufferLen   equ     16384
copybuffer      db      CopyBufferLen dup (?)
                                ; this buffer is used while copying

temppath        db      FilePathLen dup(?)
                                ; area used by check4path and
                                ; normalizepath

fixedpath       db      FilePathLen dup(?)
                                ; area used by normalize path, too.

; This area is used by the confirm procedure

confirmreply    db      ?


; ============================================================================
; This is the program code.  The execution of the program starts at the
; very first instruction here.

        .code

        ; first, put the banner of our program on the screen

        mov     ax,@data
        mov     ds,ax
        mov     si,offset Banner
        call    putstr

        ; set the DTA to point to our area

        mov     ah,SetDTA
        mov     dx,offset mydta
        int     INTDOS

        ; then, parse the command line

        call    parseline

        ; convert all of the arguments to upper case

        mov     ax,@data
        mov     ds,ax

        mov     di,offset argvectors

arguploop:      mov     si,[di]         ; get the next arg
        add     di,2

        and     si,si           ; is it 0000?
        je      doneargup

        call    strupr
        jmp     short arguploop

doneargup:
        ; then, find the source file and dest file (maybe),
        ; and check for options, too


        mov     di,offset argvectors
checkargsloop:
        mov     si,[di]         ; get the next arg
        add     di,2

        and     si,si           ; end of list?
        je      donecheckargs

        mov     al,[si]         ; nope!  check it
        cmp     al,'/'
        je      gotoption
        cmp     al,'-'
        jne     notoption

gotoption:      inc     si              ; get the next character of option
        mov     al,[si]
        cmp     al,'C'          ; confirm?
        jne     showusage       ; nope! error!

        mov     al,1
        mov     confirmmode,al  ; confirmation mode
        jmp     short checkargsloop

notoption:      mov     ax,sourcespec   ; do we have a source file?
        and     ax,ax
        jne     gotsource

        mov     sourcespec,si   ; nope!  this is our new source spec
        jmp     short checkargsloop

gotsource:      mov     ax,destspec     ; how about a dest?
        and     ax,ax
        jne     showusage

        mov     destspec,si     ; nope!  this is the dest spec
        jmp     short checkargsloop

        ; now, see if we have enough arugments
donecheckargs:
        mov     ax,argcount     ; did we get any args?
        and     ax,ax
        jne     noshowusage     ; if not, we must

showusage:
        mov     si,offset Usage ; display the usage
        call    putstr
        mov     ah,Terminate    ; and then
        mov     al,ERR_Usage    ; terminate with error status
        call    exit

noshowusage:
        cmp     ax,1
        ja      gotdest         ; was there a destination filespec?

nogotdest:
        mov     si,offset Star  ; nope. asume dest filespec was
        mov     di,offset destf.fname   ; *.*
        call    strcpy
        mov     si,offset DotStar
        mov     di,offset destf.fext
        call    strcpy
        jmp     short destsetup

gotdest:        ; yes!  call splitfilename to handle
        mov     si,destspec     ; the parse of the filename
        mov     di,offset destf ; into the destf area
        call    splitfilename

destsetup:
        ; before we goof with anything, see if the
        ; destination has a file extension

        mov     si,offset destf.fext
        call    strlen
        and     cx,cx           ; something there?
        je      destno

        mov     al,1
        mov     desthase,al     ; yes! flag it!


destno: mov     si,offset destf.drive
        call    strlen          ; was there a drive name given?
        and     cx,cx
        jne     gotdestdrive

        mov     ah,GetDefDisk           ; nope-get default from DOS
        int     INTDOS
        add     al,'A'                  ; make it ASCII
        mov     [si],al
        inc     si                      ; store it
        mov     byte ptr [si],':'       ; add a colon
        inc     si
        mov     byte ptr [si],eos       ; and a zilcher

gotdestdrive:
        mov     si,offset destf.path
        call    strlen          ; was there a file path?
        and     cx,cx
        jne     gotdestpath

        ; put the default file path into the destf area
        ; first, put a backslash in there

        mov     di,offset destf.path
        mov     si,offset BackSlash
        call    strcpy

        ; then ask DOS to put the default path into the
        ; copybuffer area

        mov     si,offset copybuffer
        mov     ah,GetDefDir
        mov     dl,[destf.drive]        ; whats the drive?
        sub     dl,('A'-1)
        int     INTDOS
        jnc     nodestdirproblem

        call    newline                 ; print error message
        mov     si,offset CouldntDIR
        call    putstr
        add     dl,('A'-1)              ; for that drive
        mov     ah,PutChar
        int     INTDOS
        call    newline
        mov     al,ERR_BadFile
        call    exit

nodestdirproblem:       ; now, concatenate it together.  we will end up with
        ; \path\place

        mov     si,offset copybuffer
        mov     di,offset destf.path
        call    strcat

        ; if the path is not just \, add a trailing \ to it

        mov     si,offset copybuffer
        call    strlen
        cmp     cx,1
        jb      gotdestpath

        mov     di,offset destf.path
        mov     si,offset BackSlash
        call    strcat

gotdestpath:
        ; now, we'll see if the filename is there

        mov     si,offset destf.fname
        call    strlen
        mov     bx,cx

        mov     si,offset destf.fext
        call    strlen          ; now, cx = strlen(fext)
                                ;   and bx = strlen(fname)

        and     cx,cx           ; is cx zero?
        je      destnoproblem

        and     bx,bx
        jne     destnoproblem

        ; we've found that there is no filename but there is an extension.
        ; that's not too good.

        mov     si,offset BadDest
        call    putstr
        mov     al,ERR_BadFile
        call    exit

destnoproblem:
        and     bx,bx           ; does filename exist?
        jne     desthasfn

        mov     si,offset Star  ; nope ... copy a star there
        mov     di,offset destf.fname
        call    strcpy

desthasfn:
        and     cx,cx           ; okay, does the extension exist
        jne     destfixed

        mov     si,offset DotStar; nope, copy ".*" into it
        mov     di,offset destf.fext
        call    strcpy

destfixed:
        ; now, check to see if there's a wildcard in the filename
        mov     si,offset destf.fname
        mov     ah,'?'
        call    strchr
        and     ax,ax           ; is it?
        jne     desthaswildf

        mov     si,offset destf.fname
        mov     ah,'*'          ; how about a star?
        call    strchr
        and     ax,ax
        je      destnowildf

desthaswildf:
        mov     al,1
        mov     destwildf,al    ; set the flag

destnowildf:
        ; see if the destination extension has a wildcard
        mov     si,offset destf.fext
        mov     ah,'?'
        call    strchr
        and     ax,ax           ; is it?
        jne     desthaswilde

        mov     si,offset destf.fext
        mov     ah,'*'
        call    strchr
        and     ax,ax
        je      destdone

desthaswilde:
        mov     al,1
        mov     destwilde,al

destdone:       ; normalize the path for the destf

        mov     si,offset destf
        call    normpath

        ; does the filename have a wildcard?

        mov     al,destwildf
        and     al,al
        jne     destcompleted

        ; does it have an extension?

        mov     al,desthase
        and     al,al
        jne     destcompleted

        ; if not, check to see if the filename is a directory

        mov     si,offset destf
        call    check4dir
        and     ax,ax           ; did it work?
        je      destcompleted

        mov     destwilde,al    ; yes! extension and filename
        mov     destwildf,al    ; are wildcards now

destcompleted:  ; the destination file is all set up!
        ; now, we can parse the source file name

        mov     si,sourcespec
        mov     di,offset sourcef
        call    splitfilename

        ; before we touch anything, see if we were given
        ; a file extension

        mov     si,offset sourcef.fext
        call    strlen
        and     cx,cx           ; anything there?
        je      sourceno

        mov     al,1
        mov     sourcehase,al   ; yes! flag it


sourceno:       ; check 'n' see if there is a drive there

        mov     si,offset sourcef.drive
        call    strlen
        and     cx,cx
        jne     gotsourcedrive

        mov     ah,GetDefDisk           ; nope-get default from DOS
        int     INTDOS
        add     al,'A'
        mov     [si],al
        inc     si
        mov     byte ptr [si],':'       ; and store a colon after it
        inc     si
        mov     byte ptr [si],eos       ; and a zilcher around it

gotsourcedrive:
        mov     si,offset sourcef.path
        call    strlen          ; was there a file path?
        and     cx,cx
        jne     gotsourcepath

        ; put the default file path into the sourcef area
        ; first, put a backslash in there

        mov     si,offset BackSlash
        mov     di,offset sourcef.path
        call    strcpy

        ; then ask DOS to put the default path into the
        ; copy buffer area

        mov     si,offset copybuffer
        mov     ah,GetDefDir
        mov     dl,[sourcef.drive]      ; whats the drive?
        sub     dl,('A'-1)      ; make into A=1, B=2 ... for DOS
        int     INTDOS
        jnc     nosourcedirprob

        call    newline                 ; print error message
        mov     si,offset CouldntDIR
        call    putstr
        add     dl,('A'-1)              ; for that drive
        mov     ah,PutChar
        int     INTDOS
        call    newline
        mov     al,ERR_BadFile
        call    exit

nosourcedirprob:        ; now, concatenate it togethre

        mov     si,offset copybuffer
        mov     di,offset sourcef.path
        call    strcat

        ; if the path is not just \, add a trailing \ to it
        mov     si,offset copybuffer
        call    strlen
        cmp     cx,1
        jb      gotsourcepath

        mov     di,offset sourcef.path
        mov     si,offset BackSlash
        call    strcat

gotsourcepath:
        ; make sure there's a filename, even if its a wildcard.
        ; check that it was a valid filename, too.

        mov     si,offset sourcef.fname
        call    strlen
        mov     bx,cx

        mov     si,offset sourcef.fext
        call    strlen          ; now, cx = strlen(fext)
                                ;       and bx = strlen(fname)

        and     cx,cx
        je      sourcenoproblem

        and     bx,bx
        jne     sourcenoproblem

        ; we've found that there is no filename but there is an extension
        ; that's not good

        mov     si,offset BadSource
        call    putstr
        mov     al,ERR_BadFile
        call    exit

sourcenoproblem:
        and     bx,bx           ; does filename exist?
        jne     sourcehasf

        mov     si,offset Star  ; nope ... copy a astar in there
        mov     di,offset sourcef.fname
        call    strcpy

sourcehasf:
        and     cx,cx           ; does extension exist?
        jne     sourcedone
        mov     si,offset DotStar
        mov     di,offset sourcef.fext
        call    strcpy

        ; now, check to see if there's a wildcard in the filename
        mov     si,offset sourcef.fname
        mov     ah,'?'
        call    strchr
        and     ax,ax           ; is it?
        jne     sourcehaswildf

        mov     si,offset sourcef.fname
        mov     ah,'*'          ; how about a star?
        call    strchr
        and     ax,ax
        je      sourcenowildf

sourcehaswildf:
        mov     al,1
        mov     sourcewildf,al  ; set the flag

sourcenowildf:
        ; see if the sourceination extension has a wildcard
        mov     si,offset sourcef.fext
        mov     ah,'?'
        call    strchr
        and     ax,ax           ; is it?
        jne     sourcehaswilde

        mov     si,offset sourcef.fext
        mov     ah,'*'
        call    strchr
        and     ax,ax
        je      sourcedone

sourcehaswilde:
        mov     al,1
        mov     sourcewilde,al

sourcedone:     ; last, normalize the source file path

        mov     si,offset sourcef
        call    normpath

        mov     al,sourcewildf
        and     al,al
        jne     sourcecompleted

        mov     al,sourcehase
        and     al,al
        jne     sourcecompleted

        mov     si,offset sourcef
        call    check4dir
        and     ax,ax           ; did it work?
        je      sourcecompleted

        mov     sourcewildf,al  ; yes! filename and
        mov     sourcewilde,al  ; extension are now wildcards!


sourcecompleted:        ; filenames are all set!
        ; okay, almost there!  check to see if the drives
        ; are the same.  if they are, we're renaming.  if
        ; they're not, we're copying and deleting.

        mov     si,offset sourcef.drive
        mov     al,[si]
        mov     si,offset destf.drive
        cmp     al,[si]
        je      workhorse

        mov     al,1            ; set copying flag
        mov     copymode,al

        ; right! everything is ready.  we'll make the source
        ; file name into something meaningful

workhorse:      mov     si,offset sourcef
        mov     di,offset sourcefile
        call    makefilename

        ; just for kicks, we'll try to open that file.

        mov     ah,OpenHandle
        mov     al,0
        mov     dx,offset sourcefile
        int     INTDOS

        jc      dothefindfirst

        mov     bx,ax
        mov     ah,IOCTL
        mov     al,0            ; see if it is a device
        int     INTDOS

        and     dx,0080h        ; check ISDEV bit
        je      notdevice

deviceblowout:  mov     si,offset CantSDevice
        call    putstr
        mov     ax,ERR_BadFile
        call    exit


notdevice:      mov     ah,CloseHandle
        int     INTDOS


        ; we'll try to find the first matching file

dothefindfirst: mov     ah,FindFirst
        mov     dx,offset sourcefile
        xor     cx,cx
        int     INTDOS

        jnc     foundone

notfound:       mov     si,offset NoMatches
        call    putstr
        mov     si,offset sourcefile
        call    putstr
        call    newline
        mov     ax,ERR_NotFound
        call    exit

        ; this loop is the main thing.  we've called findfirst,
        ; and the dta block is set up with the file we found.
        ; we'll figure out the destination file name, and
        ; then move or copy the file.

        ; at the bottom of the loop, we'll call findnext and
        ; see if there are more matching files.  if its there,
        ; we can loop back here and process that next file.

foundone:       mov     si,offset mydta
        mov     di,offset sourcef
        call    popfound
        mov     si,offset sourcef
        mov     di,offset sourcefile
        call    makefilename

        ; if the source filename has a wildcard *and* the
        ; dest filename has a wild card, copy source filename
        ; into the destination filename

        mov     al,destwildf
        and     al,al
        je      notwildf

        mov     si,offset sourcef.fname
        mov     di,offset destf.fname
        call    strcpy


notwildf:       ; if the source file extension has a wildcard,  and
        ; the destination extension has a wildcard, copy
        ; the source extension into the destination extension

        mov     al,destwilde
        and     al,al
        je      notwilde

        mov     si,offset sourcef.fext
        mov     di,offset destf.fext
        call    strcpy


notwilde:       ; create the destination file into an ASCIIZ string

        mov     si,offset destf
        mov     di,offset destfile
        call    makefilename

        ; print a message for what we are going to do

        mov     al,copymode
        mov     ah,confirmmode

        and     al,al
        je      wearemoving

        mov     si,offset CopyingMess   ; we're copying

        and     ah,ah
        je      printsource             ; without confirmation

        mov     si,offset CopyCMess
        jne     printsource

wearemoving:    mov     si,offset MovingMess    ; we're moving
        and     ah,ah
        je      printsource             ; without confirmation?

        mov     si,offset MoveCMess


printsource:    call    putstr

        ; either
        ;   "Moving sourcefile to destfile"
        ; or
        ;   "Copying sourcefile to destfile"

        mov     si,offset sourcefile
        call    putstr

whereto:        ; print " to "

        mov     si,offset ToMess
        call    putstr

        mov     si,offset destfile
        call    putstr


        ; before we actually do it, call confirmation, if need be

        and     ah,ah
        jne     askfirst        ; no confirmation

        call    newline
        jmp     short goahead

askfirst:       call    getyesno        ; do confirmation
        call    newline

        cmp     ax,0            ; no?
        je      loopbottom      ; skip it, then

        cmp     ax,1            ; yes?
        je      goahead         ; go right ahead

        xor     ax,ax           ; all of them!
        mov     confirmmode,al  ; (forget about confirming)

        ; actually do it

goahead:        mov     al,copymode
        and     al,al
        jne     doacopy

doamove:
        mov     dx,offset sourcefile
        mov     di,offset destfile
        mov     ah,RenameFile
        int     INTDOS
        jnc     loopbottom

        ; decide which error happened.  AX=0005 is bad name,
        ; anything else is different.

        mov     bx,ax
        mov     al,ERR_Renaming

        mov     si,offset NameCollide
        cmp     bx,5
        je      renamingcollision

        mov     si,offset CouldntRename

renamingcollision:      call    newline
        call    putstr
        mov     ah,ERR_Renaming
        call    exit

doacopy:        call    copyfile

loopbottom:     mov     ah,FindNext
        int     INTDOS
        jc      cleanexit       ; relative jnc out of range
        jmp     foundone




cleanexit:
        mov     al,ERR_None     ; return with no error
        call    exit



; ============================================================================
; These subroutines are used by the programs' main routine


; ----------------------------------------------------------------------------
; exit
; On entry, AL contains the error level that the program should return.
;
; This routine will terminate to DOS.  It does no housekeeping functions.

exit    proc    near

        mov     ah,Terminate    ; make a Terminate call
        int     INTDOS

exit    endp


; ----------------------------------------------------------------------------
; strlen
; On entry, DS:SI points to a string.
;
; On return, CX will contain the length of the string.

strlen  proc    near

        push    ax
        push    si

        xor     cx,cx           ; zero the length count

sl_c:   mov     al,[si]         ; get a character
        inc     si
        inc     cx              ; increment pointer and count
        and     al,al           ; is it end of string?
        jne     sl_c            ;  loop back if it isn't

        dec     cx              ; adjust the count down

        pop     si
        pop     ax
        ret

strlen  endp



; ----------------------------------------------------------------------------
; newline
; This routine prints a carriage return and a linefeed.  We will destroy
; no registers.


newline proc    near

        push    si
        push    ds              ; save the DS:SI
        push    ax

        mov     ax,@data
        mov     ds,ax
        mov     si,offset CRLFSet
        call    putstr

        pop     ax              ; restore the registers
        pop     ds
        pop     si
        ret

newline endp


; ----------------------------------------------------------------------------
; putstr
; On entry, DS:SI points to a string.
;
; This routine prints the passed string to STDOUT, and does nothing else.
; The string is not altered in any way.

putstr  proc    near

        push    dx
        push    cx
        push    bx
        push    ax              ; save the regs we use
        push    si

        xor     cx,cx           ; zero the length count

ps_l:   mov     al,[si]         ; get a character
        inc     si
        inc     cx              ; increment pointer and count
        and     al,al           ; is it end of string?
        jne     ps_l            ;  loop back if it isn't

        dec     cx              ; adjust the count down

        mov     ah,WriteHandle  ; ask DOS to write to the stdout
        mov     bx,STDOUT

        pop     si              ; restore the SI
        mov     dx,si           ; and put it into dx for DOS
        int     INTDOS

        pop     ax
        pop     bx
        pop     cx
        pop     dx
        ret

putstr  endp


; ----------------------------------------------------------------------------
; strcat
; On entry, DS:SI points to the concatenant, and ES:DI points to the
; concatenand:
;
;       DS:SI -> "Have Antlers"
;       ES:DI -> "Mooses "
;       call    strcat
;       ES:DI -> "Mooses Have Antlers"


strcat  proc    near

        push    ax
        push    si              ; save the registers
        push    di

        ; first, find the end

sc_next:        mov     al,es:[di]      ; get the char
        inc     di
        and     al,al           ; is it zilcher?
        jne     sc_next         ; nope ... keep looping

        dec     di              ; point to the zilcher

        ; now, we can just call strcpy to move the concatenant
        ; over the end of the concatenand.

        call    strcpy

        pop     di
        pop     si
        pop     ax

        ret
strcat  endp


; ----------------------------------------------------------------------------
; strcpy
; On entry, DS:SI points to a string and ES:DI points to storage space.
;
; This routine will copy the string from DS:SI to ES:DI.

strcpy  proc    near

        push    di              ; save the registers we use
        push    si
        push    ax

sc_nextc:       mov     al,[si]         ; get another character
        inc     si
        mov     es:[di],al      ; store it
        inc     di

        and     al,al           ; if that was the 0 character, quit
        jne     sc_nextc        ; else keep working on the string

        pop     ax              ; restore the registers we used
        pop     si
        pop     di
        ret
strcpy  endp


; ----------------------------------------------------------------------------
; strchr
; On entry, DS:SI points to a string, and ah contains a character to match.
; The routine will work forward through the string until it finds the end
; of the string or matches the character.  On return, AX will be 0000 if
; there was no match, or DS:AX will point to the character in the string
; if the character wasn't found.

strchr  proc    near

        push    si              ; save si

strchrnc:       mov     al,[si]         ; get a character
        inc     si              ; and increment pointer
        cmp     al,ah           ; is it a match?
        je      strchrhit

        and     al,al           ; nope.  was it '\0'?
        jne     strchrnc        ; if not, go do more

        xor     ax,ax           ; yes, the string ended
        je      strchrexit      ; so make AX null for failure

strchrhit:      mov     ax,si           ; got the character!
        dec     ax              ; put pointer into ax

strchrexit:     pop     si              ; restore si
        ret                     ; and go home

strchr  endp


; ----------------------------------------------------------------------------
; strrchr
; On entry, DS:SI points to a string, and ah contains a character to match.
; The routine will step backward, starting at the end of the string, and
; work until it finds a match.  If the program makes it through the whole
; string without finding the character, it will return with AX set to 0000.
; Otherwise, DS:AX points the the last occurrence of the character in the
; string.


strrchr proc    near

        push    cx              ; save the registers we use
        push    si
        xor     cx,cx           ; zero cx since we use it to count

strrchrfe:      mov     al,[si]         ; get the next character
        inc     si              ; increment the pointer
        inc     cx              ; increment the count of chars
        and     al,al           ; is this the end of the string?
        jne     strrchrfe

        cmp     cx,0            ; is the string empty?
        je      strrchrfail     ; if so, automatic failure

strrchrloop:    dec     si              ; point to the null
        mov     al,[si]         ; is that the character?
        cmp     ah,al
        je      strrchrhit      ; if so, we've hit!
        dec     cx
        jne     strrchrloop     ; if not, loop more

strrchrfail:    xor     ax,ax
        je      strrchrexit     ; return AX as 0000

strrchrhit:     mov     ax,si           ; got the character! move pointer
                                ; into ax

strrchrexit:    pop     si
        pop     cx
        ret

strrchr endp


; ----------------------------------------------------------------------------
; strupr
; On entry, DS:SI points to a string and ES:DI points to storage space.
;
; This routine will convert the entire content of the string to uppercase.
; It won't alter any registers, nor will it change non-alphabetic characters
; in the str.


strupr  proc    near

        cld
        push    ax
        push    si

struprloop:     lodsb                   ; get the next character
        and     al,al           ; is it zilcho?
        je      struprdone

        cmp     al,'a'          ; is it less than 'a'?
        jl      struprloop      ; yep ... keep looping

        cmp     al,'z'          ; is it bigger than 'z'?
        jg      struprloop      ; yes; don't modify it

        sub     al,('a' - 'A')
        mov     [si-1],al       ; restore that character
        jmp     short struprloop

struprdone:     pop     si
        pop     ax
        ret

strupr  endp


; ----------------------------------------------------------------------------
; parseline
; This routine tries to parse the command line.  It sets up the variables
; in the data segment (argcount and arglist), as well as copying the
; information into a local area in the data segment.  The routine will
; not preserve any of the registers it uses.

parseline       proc    near

        mov     ah,GetPSP       ; get the PSP from DOS
        int     INTDOS

        mov     ds,bx           ; move the PSP into ds
        mov     si,0081h        ; address the command line

        xor     dx,dx
        mov     dl,[si-1]       ; get the length of the line
        add     dl,081h

        mov     ax,@data        ; now, set up ES to point to our
        mov     es,ax           ; own data areas
        mov     di,offset argbuff


nextarg:
eatwhite:
        mov     al,[si]
        inc     si              ; get the next character

        cmp     al,space        ; is it a space?
        je      eatwhite
        cmp     al,tab          ; or a tab?
        je      eatwhite        ; yes ... skip over it

        dec     si              ; point si at the first non-white
        push    si              ; and save a copy of it for later

eatarg: mov     al,[si]         ; get the last character
        inc     si
        cmp     al,space        ; is it a whitespace?
        jle     gotarg
        jmp     short eatarg    ; nope... keep skipping

gotarg:
        dec     si
        mov     byte ptr [si],0 ; make the argument a string

        pop     ax              ; get the pointer to this arg

        xchg    ax,si           ; put si into DS:SI

        call    strcpy          ; store in our data segment

        call    strlen          ; get the length of the string
        push    cx              ; save it

        xchg    si,ax

        and     cx,cx           ; if this string has no length,
        je      added           ;  don't add it to the table

        ; here, DS:AX points to the end of the string and
        ; ES:DI points to the place where the string was stored.
        ; DS:SI still points to the beginning of the string.

add2table:      mov     ax,es:argcount
        shl     ax,1            ; get offset into array
        add     ax,offset argvectors
        xchg    ax,si
        mov     es:[si],di      ; store the offset of this arg
        xchg    si,ax

        inc     es:argcount     ; increment the count of args

added:
        ; adjust ES:DI

        pop     cx
        add     di,cx           ; get the length and fix it in
        inc     di              ; make DS:SI point to the next
        inc     si              ; free spot

        ; see if we are done

        cmp     dx,si
        ja      nextarg

wearedone:
        ret
parseline       endp


; ----------------------------------------------------------------------------
; splitfilename
; this procedure accepts ds:si as a pointer to a full file name.  it also
; expects that es:di points to a FileNameS.  The routine will copy
; information from the full file name into the FileNameS structure.

splitfilename   proc    near

        push    cx
        push    si              ; save the regs we use
        push    di

        ; to get started, check to see if there's a drivespec

        mov     al,[si+1]       ; is there a colon for the
        cmp     al,':'          ; second character?
        jne     sfn_nodrive     ; nope! don't worry about it

sfn_gotdrive:   mov     es:[di+1].drive,al      ; store the colon
        mov     al,[si]                 ; get the drive letter
        mov     es:[di].drive,al
        add     di,2            ; make es:di point after it
        add     si,2            ; and make si point after drive


sfn_nodrive:    ; since there's no drive spec, just zero the drive.

        xor     ax,ax
        mov     es:[di].drive,al ; stick it


sfn_drivedone:  ; now that drive is done, point es:di to the path

        pop     di              ; point to the path area
        push    di
        add     di,path

        ; see if there was a path in the filename we got

        mov     al,[si]         ; get the first char
        cmp     al,'.'
        jne     sfn_notrelpath
        je      sfn_hasrelpath


sfn_notrelpath: mov     ah,'\'          ; the path character
        call    strchr

        and     ax,ax           ; is AX == 0000?
        jne     sfn_haspath

sfn_hasrelpath: mov     ax,si           ; yes -- point to the start of
                                ; the string

sfn_haspath:    ; there's a path!  now, try to find the *last*
        ; character of the path.

        mov     dx,ax           ; save AX for now
        mov     ah,'\'
        call    strrchr         ; find the last '\'
        xchg    ax,dx

        and     dx,dx
        jne     sfn_hasend

        ; hmph!  there is no '\', either way you look
        ; does the path begin with '.'?

        cmp     byte ptr [si],'.'
        jne     sfn_nopath      ; nope!  no path name
                                ; yes!  relative path name!


sfn_relpath:    call    strlen          ; if no '\', point to end of
        mov     dx,si           ;   string
        add     dx,cx

        cmp     ax,dx           ; is our end and start equal?
        je      sfn_nopath      ; no path here, mon!

        ; now, copy the string from DS:AX to DS:DX into ES:DI.

sfn_hasend:     mov     si,ax           ; start with ax
        mov     cx,FilePathLen-2

sfn_movepath:   mov     al,[si]
        inc     si              ; get this character
        mov     es:[di],al      ; and store it in path
        inc     di

        dec     cx              ; decrement max char count.
        jne     sfn_movingpath  ; if too many, truncate

        mov     al,'\'
        mov     es:[di],al      ; truncate with a backslash
        inc     di
        mov     si,dx           ; update the pointer so's it
        inc     si              ; points to the filename now
        jmp     short sfn_movedpath

sfn_movingpath:
        cmp     dx,si           ; is si>dx?  (work to dx)
        jae     sfn_movepath    ; no ... keep looping

sfn_movedpath:
sfn_nopath:     xor     ax,ax           ; set up the ax so we can
        mov     es:[di],al      ; store a null in .path area

        ; now, we have the path done.  mess with moving
        ; the file name and the extension. DS:SI already
        ; points to the file name.

sfn_pathdone:   pop     di              ; make es:di point to filename
        push    di
        add     di,fname

        mov     cx,FileNameLen

sfn_movefn:     mov     al,[si]         ; get the next character
        cmp     al,'.'          ; end of filename?
        je      sfn_gotext

        dec     cx              ; too many characters?
        jne     sfn_moveingfn   ; yep!  truncate.

        mov     al,0
        mov     es:[di],al      ; terminate the filename
sfn_blowoff:    mov     al,[si]         ; skip ahead until we find eos or
        cmp     al,'.'          ; a period
        je      sfn_gotext
        inc     si
        and     al,al           ; is it a zilcher?
        jne     sfn_blowoff
        je      sfn_movedfn

sfn_moveingfn:
        mov     es:[di],al      ; store this character
        inc     si
        inc     di
        and     al,al           ; did we just write an eos?
        jne     sfn_movefn

sfn_movedfn:    xor     ax,ax
        pop     di              ; make addressing to strucutre
        push    di
        mov     es:[di].fext,al
        jmp     short sfn_exit  ; and split this joint

sfn_gotext:     mov     ah,0            ; write an end-of-string for
        mov     es:[di],ah      ; the filename, first

        mov     cx,FileExtLen

        pop     di
        push    di
        add     di,fext         ; make es:di point to filename

sfn_moveext:    mov     es:[di],al      ; store the character
        inc     si
        inc     di              ; increment the pointers
        and     al,al           ; did we just write a '\0'?
        je      sfn_exit

        cmp     cx,0            ; is it zero yet?
        jne     snf_movingext

        mov     al,0
        dec     di
        mov     es:[di],al
        jmp     short sfn_exit

snf_movingext:  dec     cx
        mov     al,[si]         ; get next character
        jmp     short sfn_moveext

sfn_exit:
        ; on the way out, we will check to see if the path
        ; name was a relative file.  if so, we will make
        ; sure a slash is appended to it.

        pop     di
        push    di
        add     di,path

        mov     al,[di]
        cmp     al,'.'          ; not a relative, no problem
        jne     sfn_nofix

        ; fix relative path

        mov     si,di
        call    strlen
        add     si,cx
        dec     si              ; point to last character
        mov     al,[si]         ; get that character
        cmp     al,'\'          ; slash?
        je      sfn_nofix       ;   no problem

        inc     si              ; make it a slash
        mov     byte ptr [si],'\'
        inc     si
        mov     byte ptr [si],eos

sfn_nofix:      ; restore the regs we saved
        pop     di
        pop     si
        pop     cx
        ret
splitfilename   endp


; ----------------------------------------------------------------------------
; makefilename
; On entry, DS:SI points to a FileNameS, and ES:DI points to a storage
; buffer for a file name.  The routine will string all of the elements
; of the strucutre together to make a real full file name.

makefilename    proc    near

        push    ax
        push    si
        push    di
        mov     ax,si           ; put base pointer into ax

        ; first copy the drive specifier

        mov     si,ax
        add     si,drive        ; copy the drive
        call    strcpy

        ; then concatenate the path

        mov     si,ax
        add     si,path
        call    strcat

        ; then concatenate the filename

        mov     si,ax
        add     si,fname
        call    strcat

        ; now concatenate the extension

        mov     si,ax
        add     si,fext
        call    strcat

        ; that's all!

        pop     di
        pop     si      ; restore the registers and return home
        pop     ax
        ret
makefilename    endp


; ----------------------------------------------------------------------------
; popfound
; This routine accepts a pointer to a DOSDTAS in DS:DI, and a pointer to
; a FileNameS in ES:DI.  It takes the filename and extension fields from
; the DOSDTAS and puts them into the fname and fext portions of the
; FileNameS structure.

popfound        proc

        push    ax
        push    cx
        push    dx
        push    si      ; save the regs we use
        push    di

        mov     dx,si           ; and make a copy of the parms
        mov     cx,di           ; to easily address the structs

        ; first, work on moving the filename

        mov     si,dx
        add     si,dta_fname

        mov     di,cx
        add     di,fname

popfoundf:      mov     al,[si]         ; get this char
        cmp     al,'.'          ; period yet?
        je      popfounde
        mov     es:[di],al      ; store it

        and     al,al           ; is it a zilcher?
        jne     popfoundfing

        mov     di,cx           ; yep!  zilch out extension too
        add     di,fext
        mov     es:[di],al
        jmp     short popfounddone


popfoundfing:   inc     di
        inc     si
        jmp     short popfoundf ; loop for more

popfounde:      mov     ah,0
        mov     es:[di],ah      ; terminate the filename with 0
        mov     di,cx

        add     di,fext         ; point to the extension

popfoundw:      mov     es:[di],al
        inc     di
        inc     si
        and     al,al           ; is it zero?
        je      popfounddone    ; yes, quit!
        mov     al,[si]         ;(get next char)
        jne     popfoundw       ; nope ... keep working

popfounddone:
        pop     di
        pop     si              ; restore registers
        pop     dx
        pop     cx
        pop     ax
        ret
popfound        endp


; ----------------------------------------------------------------------------
; copyfile
; this procedure completely copies a file.  it copies the file in
; sourcefile to the file in destfile.  If there is an error during
; the copy, the destfile is automatically deleted and the program
; terminates via exit.  If the copy is successful, the source file
; is deleted.  The dest file will inherit the same file time and
; date stamp as the source file.

copyfile        proc    near

        ; first, try to open the dest file for reading

        mov     ah,OpenHandle           ; open the
        mov     dx,offset destfile      ; dest for
        mov     al,0                    ; reading
        int     INTDOS
        jc      cf_nameokay

        ; we could read the source file!  the file already
        ; exists, so we must abort.

        mov     bx,ax
        mov     ah,CloseHandle          ; close the handle and
        call    newline
        mov     si,offset NameCollide   ; print an error!
        call    putstr
        mov     ah,ERR_CopyProblem
        call    exit

cf_nameokay:    ; try to open the source file

        mov     ah,OpenHandle           ; open the
        mov     dx,offset sourcefile    ; source for
        mov     al,0                    ; for reading
        int     INTDOS

        ; was there an error?

        jnc     cf_noopenerr

cf_cantread:    call    newline                 ; couldn't open; print
        mov     si,offset CantRead      ; an error message
        call    putstr
        mov     ah,ERR_CopyProblem
        call    exit                    ; and terminate

cf_noopenerr:   mov     sourceh,ax              ; save the handle

        mov     ah,CreateHandle         ; open
        mov     dx,offset destfile      ; desination
        xor     cx,cx                   ; no attribute
        int     INTDOS

        jnc     cf_nowriteopen

cf_cantwrite:   call    newline                 ; couldn't write; print
        mov     si,offset CantWrite     ; an error message
        call    putstr
        mov     ah,ERR_CopyProblem
        call    exit                    ; and terminate!

cf_nowriteopen: mov     desth,ax

cf_nextbunch:   mov     ah,ReadHandle           ; read
        mov     cx,CopyBufferLen        ; all we can
        mov     bx,sourceh              ; from the source
        mov     dx,offset copybuffer    ; into the buffer
        int     INTDOS

        jnc     cf_canread              ; no read error?

        mov     dx,offset destfile      ; delete the dest file
        mov     ah,DeleteFile
        int     INTDOS
        jmp     short cf_cantread       ; print error and quit

cf_canread:
        and     ax,ax                   ; (Was it zero?)
        je      cf_closeup              ; yes! go close the files

        mov     cx,ax                   ; take what we read
        mov     ah,WriteHandle          ; and write it
        mov     dx,offset copybuffer    ; from the buffer
        mov     bx,desth                ; to the destination
        int     INTDOS

        jnc     cf_canwrite             ; write error!

        mov     dx,offset destfile      ; delete the dest file
        mov     ah,DeleteFile
        int     INTDOS
        jmp     short cf_cantwrite      ; print error and quit

cf_canwrite:
        cmp     cx,ax                   ; did we write 'em all?
        jne     cf_cantwrite            ; no?  that's a problem!
        je      cf_nextbunch

cf_closeup:
        mov     ax,GetDateTime          ; get the date
        mov     bx,sourceh              ; from the source file
        int     INTDOS

        mov     ax,SetDateTime          ; set the date
        mov     bx,desth                ; to the dest file
        int     INTDOS

        mov     bx,desth                ; close dest file
        mov     ah,CloseHandle
        int     INTDOS

        mov     bx,sourceh              ; close source file
        mov     ah,CloseHandle
        int     INTDOS

        ;       get the source file's attribute byte

        mov     dx,offset sourcefile
        mov     ax,GetAttrib
        int     INTDOS

        ;       set the dest file's attribute byte

        mov     dx,offset destfile
        mov     ax,SetAttrib            ; CX is already set
        or      cx,020h                 ; but set archive bit
        int     INTDOS

        ;       set the source file's attribute byte to normal

        mov     dx,offset sourcefile
        mov     ax,SetAttrib
        mov     cx,NormalAttrib         ; reset source file
                                        ; so we can now
        mov     dx,offset sourcefile    ; delete the source file
        mov     ah,DeleteFile
        int     INTDOS

        ret
copyfile        endp


; ----------------------------------------------------------------------------
; getyesno
; This procedure prints a yes/no prompt on the screen and gets an answer.
; the routine accepts "y", "1", and "t" as affirmative responses.  the
; routine accepts "n", "0", and "f" as negative responses.  If the routine
; is given an affirmative response, it will return AX as 0001.  If it is
; given a negative reply, it will send back 0000 in AX.  If the routine
; receives "a" in reply to its prompt, it will return a 0002 in AX.

getyesno        proc    near

        mov     si,offset ConfirmPrompt ; print prompt
        call    putstr

gyn_delete:     xor     ax,ax
        mov     confirmreply,al

gyn_loop:       mov     ah,GetChar      ; get one character
        int     INTDOS
        cmp     al,'a'
        jl      gyn_noup
        cmp     al,'z'
        jg      gyn_noup

        sub     al,('a'-'A')    ; make it uppercase

gyn_noup:       mov     ah,confirmreply
        and     ah,ah
        jne     gyn_checkcr     ; we got a letter, is this one
                                ; a carriage return?

        cmp     al,cr           ; carriage return?
        je      gyn_negative    ; yep, default is no!

        cmp     al,ctrlz        ; control zee?
        jne     gyn_notzee

        ; if CTRL+Z is pressed, we must quit here.

        mov     si,offset UAborted
        call    putstr          ; make a message about it
        mov     al,ERR_None     ; exit with no errors
        call    exit

gyn_notzee:     cmp     al,space        ; is this character lower than ' '?
        jle     gyn_loop        ; yep, ignore it

        cmp     al,'Y'          ; filter out unwanted chars
        je      gyn_okay        ;

        cmp     al,'N'
        je      gyn_okay

        cmp     al,'A'
        je      gyn_okay

        cmp     al,'0'
        je      gyn_okay

        cmp     al,'1'
        je      gyn_okay

        cmp     al,'T'
        je      gyn_okay

        cmp     al,'F'
        jne     gyn_loop

gyn_okay:
        mov     confirmreply,al ; store the character

        mov     ah,PutChar      ; and echo it to the screen
        mov     dl,al
        int     INTDOS
        jmp     short gyn_loop  ; go loop back for more

gyn_checkcr:    cmp     al,cr           ; is this one a carriage return?
        je      gyn_replied     ; yes! process the reply

        cmp     al,bs           ; is this one a backspace?
        jne     gyn_loop        ; no! bad char, ignore it

        mov     ah,PutChar      ; put a backspace
        mov     dl,bs
        int     INTDOS

        mov     ah,PutChar      ; put a space to whiteout
        mov     dl,space        ; the character typed
        int     INTDOS

        mov     ah,PutChar      ; and another BS to fix cursor
        mov     dl,bs
        int     INTDOS

        jmp     gyn_delete

gyn_replied:    mov     al,confirmreply ; get the reply, and decide what
                                ;       to do

        cmp     al,'A'
        je      gyn_everything

        cmp     al,'0'
        je      gyn_negative
        cmp     al,'F'
        je      gyn_negative
        cmp     al,'N'
        je      gyn_negative

        cmp     al,'Y'
        je      gyn_affirm
        cmp     al,'1'
        je      gyn_affirm
        cmp     al,'T'
        je      gyn_affirm
        jmp     gyn_loop        ; somehow a bad char got in


gyn_everything: mov     ax,2            ; reply "all"
        ret

gyn_negative:   mov     ax,0            ; negative reply
        ret

gyn_affirm:     mov     ax,1            ; affirmative reply
        ret

getyesno        endp


; ----------------------------------------------------------------------------
; check4dir
; this routine accepts DI as a pointer to a FileNameS.  It will check
; to see if the file name section of the file name is actually a directory.
; if it is, it will move the file name to the end of the path field and
; make the file name null.  if not, it simply returns without changing
; the structure.  We have to do this because DOS won't understand us if
; we specify a subdirectory without tacking \*.* onto the end of it.
; If we end up changing anything, AX is set to one.  If not, AX is zilch.
;

check4dir       proc    near

        push    si              ; save the pointer

        mov     di,offset temppath
        call    strcpy          ; move drive to temppath

        mov     di,offset temppath
        add     si,path         ; get the path
        call    strcat

        mov     di,offset temppath
        pop     si
        push    si
        add     si,fname
        call    strcat          ; and finally add the filename

        mov     ah,FindFirst
        mov     dx,offset temppath
        mov     cx,SubDirAttrib ; get directories only
        int     INTDOS
        jnc     c4d_worked

        ; return with al set to zero to indicate that
        ; we didn't change the filename

        xor     ax,ax           ; make a zilcher out of ax
        pop     si
        ret

        ; it *is* a subdir!
        ; concatenate the file to the path


c4d_worked:     pop     si
        push    si
        mov     di,si
        add     di,path
        add     si,fname
        call    strcat          ; add filename to path

        mov     si,offset BackSlash
        call    strcat          ; add backslash to path

        mov     si,offset Star  ; put a star into the filename
        pop     di
        push    di
        add     di,fname
        call    strcpy

        mov     si,offset DotStar
        pop     di
        push    di
        add     di,fext         ; and a ".*" into extension
        call    strcpy

c4d_end:        mov     ax,1            ; ax=1, success!
        pop     si              ; pop register and return!
        ret
check4dir       endp


; ----------------------------------------------------------------------------
; normpath
; this proc accepts a pointer to a FileNameS in DS:SI.  The proc will
; call DOS to have it normalize the path -- this simply means that the
; procedure will resolve any relative (ie, including "." or "..")
; file path references.  Note that the function call used here is
; undocumented.

normpath        proc    near

        push    di              ; save the registers
        push    si


        mov     di,offset temppath
        call    strcpy          ; copy drive and path to
        add     si,path         ; a temporary area
        call    strcat

        mov     ah,NormalizePath
        mov     si,offset temppath
        mov     di,offset fixedpath
        int     INTDOS

        pop     si
        mov     di,si           ; copy the path back
        add     di,path
        mov     si,(offset fixedpath)+2
        call    strcpy

        pop     di              ; restore
        ret                     ; and return
normpath        endp


; ----------------------------------------------------------------------------
; That's a wrap.  Written under the influence of Tom Petty, Rush, and REM.

        end

