MZ is back!

[MS-DOS.git] / v4.0 / src / DOS / MACRO2.ASM

;       SCCSID = @(#)macro2.asm 1.2 85/07/23
TITLE   MACRO2 - Pathname and macro related internal routines
NAME    MACRO2
;
;   TransFCB        written
;   TransPath       written
;   TransPathSet    written
;   TransPathNoSet  Written
;   Canonicalize    written
;   PathSep         written
;   SkipBack        written
;   CopyComponent   written
;   Splice          written
;   $NameTrans      written
;   DriveFromText
;   TextFromDrive
;   PathPref
;   ScanPathChar
;
;   Revision history:
;
;       Created: MZ 4 April 1983
;                MZ 18 April 1983   Make TransFCB handle extended FCBs
;                AR 2 June 1983     Define/Delete macro for NET redir.
;                MZ 3 Nov 83        Fix InitCDS to reset length to 2
;                MZ 4 Nov 83        Fix NetAssign to use STRLEN only
;                MZ 18 Nov 83       Rewrite string processing for subtree
;                                   aliasing.
;                BAS 3 Jan 85       ScanPathChar to search for path separator
;                                   in null terminated string.
;
;   MSDOS performs several types of name translation.  First, we maintain for
;   each valid drive letter the text of the current directory on that drive.
;   For invalid drive letters, there is no current directory so we pretend to
;   be at the root.  A current directory is either the raw local directory
;   (consisting of drive:\path) or a local network directory (consisting of
;   \\machine\path.  There is a limit on the point to which a ..  is allowed.
;
;   Given a path, MSDOS will transform this into a real from-the-root path
;   without .  or ..  entries.  Any component that is > 8.3 is truncated to
;   this and all * are expanded into ?'s.
;
;   The second part of name translation involves subtree aliasing.  A list of
;   subtree pairs is maintained by the external utility SUBST.  The results of
;   the previous 'canonicalization' are then examined to see if any of the
;   subtree pairs is a prefix of the user path.  If so, then this prefix is
;   replaced with the other subtree in the pair.
;
;   A third part involves mapping this "real" path into a "physical" path.  A
;   list of drive/subtree pairs are maintained by the external utility JOIN.
;   The output of the previous translation is examined to see if any of the
;   subtrees in this list are a prefix of the string.  If so, then the prefix
;   is replaced by the appropriate drive letter.  In this manner, we can
;   'mount' one device under another.
;
;   The final form of name translation involves the mapping of a user's
;   logical drive number into the internal physical drive.  This is
;   accomplished by converting the drive number into letter:CON, performing
;   the above translation and then converting the character back into a drive
;   number.
;
;   curdir_list     STRUC
;   curdir_text     DB      DIRSTRLEN DUP (?) ; text of assignment and curdir
;   curdir_flags    DW      ?               ; various flags
;   curdir_devptr   DD      ?               ; local pointer to DPB or net device
;   curdir_ID       DW      ?               ; cluster of current dir (net ID)
;                   DW      ?
;   curdir_end      DW      ?               ; end of assignment
;   curdir_list     ENDS
;   curdir_netID    EQU     DWORD PTR curdir_ID
;   ;Flag word masks
;   curdir_isnet    EQU     1000000000000000B
;   curdir_inuse    EQU     0100000000000000B
;
;
;   There are two main entry points:  TransPath and TransFCB.  TransPath will
;   take a path and form the real text of the pathname with all .  and ..
;   removed.  TransFCB will translate an FCB into a path and then invoke
;   TransPath.
;
;   Implementation note:  CURDIR_End field points to the point in the text
;   string where the user may back up to via ..  It is the location of a
;   separator character.  For the root, it points at the leading /.  For net
;   assignments it points at the end (nul) of the initial assignment:
;   A:/     \\foo\bar       \\foo\bar\blech\bozo
;     ^              ^               ^
; A: -> d: /path/ path/ text
;
;   A000  version 4.00  Jan. 1988

.xlist
;
; get the appropriate segment definitions
;
include dosseg.asm

CODE    SEGMENT BYTE PUBLIC  'CODE'
        ASSUME  SS:DOSGroup,CS:DOSGroup

.xcref
INCLUDE DOSSYM.INC
INCLUDE DEVSYM.INC
.cref
.list
.sall

Installed = TRUE

        I_need  Splices,BYTE            ; TRUE => splices are being done.
        I_need  WFP_Start,WORD          ; pointer to beginning of expansion
        I_need  Curr_Dir_End,WORD       ; offset to end of current dir
        I_need  ThisCDS,DWORD           ; pointer to CDS used
        I_need  ThisDPB,DWORD           ; pointer to DPB used
        I_need  NAME1,11                ; Parse output of NameTrans
        I_need  OpenBuf,128             ; ususal destination of strings
        I_need  ExtFCB,BYTE             ; flag for extended FCBs
        I_need  Sattrib,BYTE            ; attribute of search
        I_need  fSplice,BYTE            ; TRUE => do splice after canonicalize
        I_need  fSharing,BYTE           ; TRUE => no redirection allowed
        I_Need  NoSetDir,BYTE           ; TRUE => syscall is interested in
                                        ; entry, not contents.  We splice only
                                        ; inexact matches
        I_Need  cMeta,BYTE              ; count of meta chars in path
        I_Need  Temp_Var,WORD           ;AN000; variable for temporary use 3/31/KK
        I_Need  DOS34_FLAG,WORD         ;AN000; variable for dos34
        I_Need  NO_FILTER_PATH,DWORD    ;AN000; pointer to orignal path
Table   SEGMENT
        EXTRN   CharType:BYTE
Table   ENDS

BREAK <TransFCB - convert an FCB into a path, doing substitution>

;
;   TransFCB - Copy an FCB from DS:DX into a reserved area doing all of the
;       gritty substitution.
;
;   Inputs:     DS:DX - pointer to FCB
;               ES:DI - point to destination
;   Outputs:    Carry Set - invalid path in final map
;               Carry Clear - FCB has been mapped into ES:DI
;                   Sattrib is set from possibly extended FCB
;                   ExtFCB set if extended FCB found
;   Registers modified: most

Procedure   TransFCB,NEAR
        ASSUME  CS:DOSGroup,DS:NOTHING,ES:NOTHING,SS:DOSGroup
PUBLIC MACRO001S,MACRO001E
MACRO001S:
        LocalVar    FCBTmp,15
MACRO001E:
        Enter
        Context ES                      ; get DOSGroup addressability
        SaveReg <ES,DI>                 ; save away final destination
        LEA     DI,FCBTmp               ; point to FCB temp area
        MOV     [ExtFCB],0              ; no extended FCB found
        MOV     [Sattrib],0             ; default search attributes
        invoke  GetExtended             ; get FCB, extended or not
        JZ      GetDrive                ; not an extended FCB, get drive
        MOV     AL,[SI-1]               ; get attributes
        MOV     [SAttrib],AL            ; store search attributes
        MOV     [ExtFCB],-1             ; signal extended FCB
GetDrive:
        LODSB                           ; get drive byte
        invoke  GetThisDrv
        jc      BadPack
        CALL    TextFromDrive           ; convert 0-based drive to text
;
; Scan the source to see if there are any illegal chars
;
        MOV     BX,OFFSET DOSGroup:CharType
 IF  DBCS                               ;AN000;
;----------------------------- Start of DBCS 2/13/KK
        SaveReg <SI>                    ;AN000;; back over name, ext
        MOV     CX,8                    ;AN000;; 8 chars in main part of name
FCBScan:LODSB                           ;AN000;; get a byte
        invoke  testkanj                ;AN000;
        jz      notkanj2                ;AN000;
        DEC     CX                      ;AN000;
        JCXZ    VolidChck               ;AN000;; Kanji half char screw up
        LODSB                           ;AN000;; second kanji byte
        jmp     short Nextch            ;AN000;
VolidChck:                              ;AN000;
        TEST    [SAttrib],attr_volume_id ;AN000;; volume id ?
        JZ      Badpack                  ;AN000;; no, error
        OR      [DOS34_FLAG],DBCS_VOLID  ;AN000;; no, error
        DEC     CX                       ;AN000;; cx=-1
        INC     SI                       ;AN000;; next char
        JMP     SHORT FCBScango          ;AN000;
notkanj2:                                ;AN000;
        XLAT    ES:CharType              ;AN000;;get bits
        TEST    AL,fFCB                  ;AN000;
        JZ      BadPack                  ;AN000;
NextCh:                                  ;AN000;
        LOOP    FCBScan                  ;AN000;
FCBScango:                               ;AN000;
        ADD     CX,3                    ;AN000;; Three chars in extension
FCBScanE:                               ;AN000;
        LODSB                           ;AN000;
        invoke  testkanj                ;AN000;
        jz      notkanj3                ;AN000;
        DEC     CX                      ;AN000;
        JCXZ    BadPack                 ;AN000;; Kanji half char problem
        LODSB                           ;AN000;; second kanji byte
        jmp     short NextChE           ;AN000;
notkanj3:                               ;AN000;
        XLAT    ES:CharType             ;AN000;; get bits
        TEST    AL,fFCB                 ;AN000;
        JZ      BadPack                 ;AN000;
NextChE:                                ;AN000;
        LOOP    FCBScanE                ;AN000;
;----------------------------- End of DBCS 2/13/KK
 ELSE

        MOV     CX,11
        SaveReg <SI>                    ; back over name, ext
FCBScan:LODSB                           ; get a byte
        XLAT    ES:CharType             ; get bits
        TEST    AL,fFCB
        JZ      BadPack
NextCh: LOOP    FCBScan
 ENDIF
        RestoreReg  <SI>
        MOV     BX,DI
        invoke  PackName                ; crunch the path
        RestoreReg  <DI,ES>             ; get original destination
        Context DS                      ; get DS addressability
        LEA     SI,FCBTmp               ; point at new pathname
        CMP     BYTE PTR [BX],0
        JZ      BadPack
        SaveReg <BP>
        CALL    TransPathSet            ; convert the path
        RestoreReg  <BP>
        JNC     FCBRet                  ; bye with transPath error code
BadPack:
        STC
        MOV     AL,error_path_not_found
FCBRet: Leave
        return
EndProc TransFCB,NoCheck

BREAK <TransPath - copy a path, do string sub and put in current dir>

;
;   TransPath - copy a path from DS:SI to ES:DI, performing component string
;       substitution, insertion of current directory and fixing .  and ..
;       entries.  Perform splicing.  Allow input string to match splice
;       exactly.
;
;   TransPathSet - Same as above except No splicing is performed if input path
;       matches splice.
;
;   TransPathNoSet - No splicing/local using is performed at all.
;
;   The following anomalous behaviour is required:
;
;       Drive letters on devices are ignored.  (set up DummyCDS)
;       Paths on devices are ignored. (truncate to 0-length)
;       Raw net I/O sets ThisCDS => NULL.
;       fSharing => dummyCDS and no subst/splice.  Only canonicalize.
;
;   Other behaviour:
;
;       ThisCDS set up.
;       FatRead done on local CDS.
;       ValidateCDS done on local CDS.
;
;   Brief flowchart:
;
;       if fSharing then
;           set up DummyCDS (ThisCDS)
;           canonicalize (sets cMeta)
;           splice
;           fatRead
;           return
;       if \\ or d:\\ lead then
;           set up null CDS (ThisCDS)
;           canonicalize (sets cMeta)
;           return
;       if device then
;           set up dummyCDS (ThisCDS)
;           canonicalize (sets cMeta)
;           return
;       if file then
;           getCDS (sets (ThisCDS) from name)
;           validateCDS (may reset current dir)
;           Copy current dir
;           canonicalize (set cMeta)
;           splice
;           generate correct CDS (ThisCDS)
;           if local then
;               fatread
;           return
;
;   Inputs:     DS:SI - point to ASCIZ string path
;               DI - point to buffer in DOSGroup
;   Outputs:    Carry Set - invalid path specification: too many .., bad
;                   syntax, etc. or user FAILed to I 24.
;               WFP_Start - points to beginning of buffer
;               Curr_Dir_End - points to end of current dir in path
;               DS - DOSGroup
;   Registers modified: most

Procedure   TransPath,NEAR
        ASSUME  CS:DOSGroup,DS:NOTHING,ES:NOTHING,SS:DOSGroup
        XOR     AL,AL
        JMP     SHORT SetSplice
        Entry   TransPathSet
        MOV     AL,-1
SetSplice:
        MOV     NoSetDir,AL             ;   NoSetDir = !fExact;
        MOV     AL,-1
        Entry   TransPathNoSet
        MOV     WORD PTR [NO_FILTER_PATH],SI   ;AN000;;IFS. save old path for IFS
        MOV     WORD PTR [NO_FILTER_PATH+2],DS ;AN000;;IFS.

        MOV     fSplice,AL              ;   fSplice = TRUE;
        MOV     cMeta,-1
        MOV     WFP_Start,DI
        MOV     Curr_Dir_End,-1         ; crack from start
        Context ES
        LEA     BP,[DI+TEMPLEN]         ; end of buffer
;
; if this is through the server dos call, fsharing is set.  We set up a
; dummy cds and let the operation go.
;
        TEST    fSharing,-1             ; if no sharing
        JZ      CheckUNC                ; skip to UNC check
;
; ES:DI point to buffer
;
        CALL    DriveFromText           ; get drive and advance DS:SI
        invoke  GetThisDrv              ; Set ThisCDS and convert to 0-based
        jc      NoPath
        CALL    TextFromDrive           ; drop in new
        LEA     BX,[DI+1]               ; backup limit
        CALL    Canonicalize            ; copy and canonicalize
        retc                            ; errors
;
; Perform splices for net guys.
;
        Context DS
        MOV     SI,wfp_Start            ; point to name
        TEST    fSplice,-1
        JZ      NoServerSplice
        CALL    Splice
NoServerSplice:
        Context DS                      ; for FATREAD
        LES     DI,ThisCDS              ; for fatread
        EnterCrit   critDisk
        Invoke  FatRead_CDS
        LeaveCrit   critDisk
NoPath:
        MOV     AL,error_path_not_found ; Set up for possible bad path error
        return                          ; any errors are in Carry flag
        ASSUME  DS:NOTHING
;
; Let the network decide if the name is for a spooled device.  It will map
; the name if so.
;
CheckUnc:
        MOV     WORD PTR ThisCDS,-1     ; NULL thisCDS
        CallInstall NetSpoolCheck,multNet,35
        JNC     UNCDone
;
; At this point the name is either a UNC-style name (prefixed with two leading
; \\s) or is a local file/device.  Remember that if a net-spooled device was
; input, then the name has been changed to the remote spooler by the above net
; call.  Also, there may be a drive in front of the \\.
;
NO_CHECK:
        CALL    DriveFromText           ; eat drive letter
        PUSH    AX                      ; save it
        MOV     AX,WORD PTR [SI]        ; get first two bytes of path
        Invoke  PathChrCmp              ; convert to normal form
        XCHG    AH,AL                   ; swap for second byte
        Invoke  PathChrCmp              ; convert to normal form
        JNZ     CheckDevice             ; not a path char
        CMP     AH,AL                   ; are they same?
        JNZ     CheckDevice             ; nope
;
; We have a UNC request.  We must copy the string up to the beginning of the
; local machine root path
;

        POP     AX
        MOVSW                           ; get the lead \\
UNCCpy: LODSB                           ; get a byte
 IF  DBCS                               ;AN000;
;----------------------------- Start of DBCS 2/23/KK
        invoke  testkanj                ;AN000;
        jz      notkanj1                ;AN000;
        STOSB                           ;AN000;
        LODSB                           ;AN000;
        OR      AL,AL                   ;AN000;
        JZ      UNCTerm                 ;AN000;; Ignore half kanji error for now
        STOSB                           ;AN000;
        jmp     UNCCpy                  ;AN000;
notkanj1:                               ;AN000;
;----------------------------- End of DBCS 2/23/KK
 ENDIF                                  ;AN000;
        invoke  UCase                   ;AN000;; convert the char
        OR      AL,AL
        JZ      UNCTerm                 ; end of string.  All done.
        Invoke  PathChrCmp              ; is it a path char?
        MOV     BX,DI                   ; backup position
        STOSB
        JNZ     UNCCpy                  ; no, go copy
        CALL    Canonicalize            ; wham (and set cMeta)
UNCDone:
        Context DS
 IF  DBCS
;----------------------------- Start of DBCS 2/23/KK
        retc                            ;AN000; Return if error from Canonicalize

; Although Cononicalize has done lots of good things for us it may also have
; done e5 to 05 conversion on the fisrt char following a path sep char which is
; not wanted on a UNC request as this should be left for the remote station.
; The simplest thing to do is check for such conversions and convert them back
; again.
; This check loop is also called from the DoFile section of TransPath if the
; file is a remote file. Entry point when called is TP_check05 with the
; inputs/outputs as follows;
;       Inputs : ES:DI = Buffer to check for re-conversion
;       Outputs: None
;       Used   : DI,AX


        MOV     DI,WFP_start            ;AN000;; ES:DI points to converted string
TP_check05:                             ;AN000;
        MOV     AL,BYTE PTR ES:[DI]     ;AN000;; Get character from path
        OR      AL,AL                   ;AN000;; End of null terminated path?
        JZ      TP_end05                ;AN000;; Finished, CF =0 from OR (ret success)
        invoke  testkanj                ;AN000;; Kanji lead character?
        JZ      TP_notK                 ;AN000;; Check for path seperator if not
        INC     DI                      ;AN000;; Bypass Kanji second byte
        JMP     TP_nxt05                ;AN000;; Go to check next character
TP_notK:                                ;AN000;
        invoke  PathChrCmp              ;AN000;; Is it a path seperator char?
        JNZ     TP_nxt05                ;AN000;; Check next character if not
        CMP     BYTE PTR ES:[DI+1],05   ;AN000;; 05 following path sep char?
        JNZ     TP_nxt05                ;AN000;; Check next character if not
        MOV     BYTE PTR ES:[DI+1],0E5h ;AN000;; Convert 05 back to E5
TP_nxt05:                               ;AN000;
        INC     DI                      ;AN000;; Point to next char in path
        JMP     TP_check05              ;AN000;; Test all chars in path
TP_end05:
;----------------------------- End of DBCS 2/23/KK
 ENDIF                                  ;AN000;
        return                          ; return error code

        ASSUME  DS:NOTHING
UNCTerm:
        STOSB                           ;AN000;
        JMP     UNCDone                 ;AN000;

CheckDevice:
;
; Check DS:SI for device.  First eat any path stuff
;
        POP     AX                      ; retrieve drive info
        CMP     BYTE PTR DS:[SI],0      ; check for null file
        JNZ     CheckPath
        MOV     AL,error_file_not_found ; bad file error
        STC                             ; signal error on null input
        RETURN                          ; bye!
CheckPath:
        SaveReg <AX,BP>                 ; save drive number
        Invoke  CheckThisDevice         ; snoop for device
        RestoreReg  <BP,AX>             ; get drive letter back
        JNC     DoFile                  ; yes we have a file.
;
; We have a device.  AX has drive letter.  At this point we may fake a CDS ala
; sharing DOS call.  We know by getting here that we are NOT in a sharing DOS
; call.
;
        MOV     fSharing,-1             ; simulate sharing dos call
        invoke  GetThisDrv              ; set ThisCDS and init DUMMYCDS
        MOV     fSharing,0              ;
;
; Now that we have noted that we have a device, we put it into a form that
; getpath can understand.  Normally getpath requires d:\ to begin the input
; string.  We relax this to state that if the d:\ is present then the path
; may be a file.  If D:/ (note the forward slash) is present then we have
; a device.
;
        CALL    TextFromDrive
        MOV     AL,'/'                  ; path sep.
        STOSB
        invoke  StrCpy                  ; move remainder of string
        CLC                             ; everything OK.
        Context DS                      ; remainder of OK stuff
        return
;
; We have a file.  Get the raw CDS.
;
DoFile:
        ASSUME  DS:NOTHING
        invoke  GetVisDrv               ; get proper CDS
        MOV     AL,error_path_not_found ; Set up for possible bad file error
        retc                            ; CARRY set -> bogus drive/spliced
;
; ThisCDS has correct CDS.  DS:SI advanced to point to beginning of path/file.
; Make sure that CDS has valid directory; ValidateCDS requires a temp buffer
; Use the one that we are going to use (ES:DI).
;
        SaveReg <DS,SI,ES,DI>           ; save all string pointers.
        invoke  ValidateCDS             ; poke CDS amd make everything OK
        RestoreReg <DI,ES,SI,DS>        ; get back pointers
        MOV     AL,error_path_not_found ; Set up for possible bad path error
        retc                            ; someone failed an operation
;
; ThisCDS points to correct CDS.  It contains the correct text of the
; current directory.  Copy it in.
;
        SaveReg <DS,SI>
        LDS     SI,ThisCDS              ; point to CDS
        MOV     BX,DI                   ; point to destination
        ADD     BX,[SI].curdir_end      ; point to backup limit
;       LEA     SI,[SI].curdir_text     ; point to text
        LEA     BP,[DI+TEMPLEN]         ; regenerate end of buffer
 IF  DBCS                               ;AN000;
;------------------------ Start of DBCS 2/13/KK
Kcpylp:                                 ;AN000;
        LODSB                           ;AN000;
        invoke  TestKanj                ;AN000;
        jz      Notkanjf                ;AN000;
        STOSB                           ;AN000;
        MOVSB                           ;AN000;
        CMP     BYTE PTR [SI],0         ;AN000;
        JNZ     Kcpylp                  ;AN000;
        MOV     AL, '\'                 ;AN000;
        STOSB                           ;AN000;
        JMP     SHORT GetOrig           ;AN000;
Notkanjf:                               ;AN000;
        STOSB                           ;AN000;
        OR      AL,AL                   ;AN000;
        JNZ     Kcpylp                  ;AN000;
        DEC     DI                      ;AN000;; point to NUL byte

;------------------------ End of DBCS 2/13/KK
 ELSE                                   ;AN000;
        invoke  FStrCpy                 ; copy string.  ES:DI point to end
        DEC     DI                      ; point to NUL byte
 ENDIF                                  ;AN000;
;
; Make sure that there is a path char at end.
;
        MOV     AL,'\'
        CMP     ES:[DI-1],AL
        JZ      GetOrig
        STOSB
;
; Now get original string.
;
GetOrig:
        DEC     DI                      ; point to path char
        RestoreReg  <SI,DS>
;
; BX points to the end of the root part of the CDS (at where a path char
; should be) .  Now, we decide whether we use this root or extend it with the
; current directory.  See if the input string begins with a leading \
;
        CALL    PathSep                 ; is DS:SI a path sep?
        JNZ     PathAssure              ; no, DI is correct. Assure a path char
        OR      AL,AL                   ; end of string?
        JZ      DoCanon                 ; yes, skip.
;
; The string does begin with a \.  Reset the beginning of the canonicalization
; to this root.  Make sure that there is a path char there and advance the
; source string over all leading \'s.
;
        MOV     DI,BX                   ; back up to root point.
SkipPath:
        LODSB
        invoke PathChrCmp
        JZ      SkipPath
        DEC     SI
        OR      AL,AL
        JZ      DoCanon
;
; DS:SI start at some file name.  ES:DI points at some path char.  Drop one in
; for yucks.
;
PathAssure:
        MOV     AL,'\'
        STOSB
;
; ES:DI point to the correct spot for canonicalization to begin.
; BP is the max extent to advance DI
; BX is the backup limit for ..
;
DoCanon:
        CALL    Canonicalize            ; wham.
        retc                            ; badly formatted path.
 IF  DBCS                               ;AN000;
;--------------------- Start of DBCS 2/13/KK
; Although Cononicalize has done lots of good things for us it may also have
; done e5 to 05 conversion on the fisrt char following a path sep char which is
; not wanted if this a remote file as this should be left for the remote
; station. Check for a leading \\ in the path buffer and call TP_check05 to
; reconvert if found.

        MOV     DI,WFP_start            ;AN000;; ES:DI points to string
        MOV     AX,WORD PTR ES:[DI]     ;AN000;; Get leading 2 chars from path buffer
        invoke  PathChrCmp              ;AN000;; First char a path char?
        JNZ     TP_notremote            ;AN000;; Not remote if not.
        invoke  PathChrCmp              ;AN000;; Second char a path char?
        JNZ     TP_notremote            ;AN000;; Not remote if not
        CALL    TP_check05              ;AN000;; Remote so convert 05 back to e5
TP_notremote:                           ;AN000;
;--------------------- End of DBCS 2/13/KK
 ENDIF
;
; The string has been moved to ES:DI.  Reset world to DOS context, pointers
; to wfp_start and do string substitution.  BP is still the max position in
; buffer.
;
        Context DS
        MOV     DI,wfp_start            ; DS:SI point to string
        LDS     SI,ThisCDS              ; point to CDS
        ASSUME  DS:NOTHING
;       LEA     SI,[SI].curdir_text     ; point to text
        CALL    PathPref                ; is there a prefix?
        JNZ     DoSplice                ; no, do splice
;
; We have a match. Check to see if we ended in a path char.
;
 IF  DBCS                               ;AN000;
;---------------------------- Start of DBCS 2/13/KK
        PUSH    BX                      ;AN000;
        MOV     BX,SI                   ;AN000;
        MOV     SI,WORD PTR ThisCDS     ;AN000;; point to CDS
LOOKDUAL:                               ;AN000;
        MOV     AL,BYTE PTR [SI]        ;AN000;
        invoke  TESTKANJ                ;AN000;
        JZ      ONEINC                  ;AN000;
        INC     SI                      ;AN000;
        INC     SI                      ;AN000;
        CMP     SI,BX                   ;AN000;
        JB      LOOKDUAL                ;AN000;
        POP     BX                      ;AN000;; Last char was KANJI, don't look back
        JMP     SHORT Pathline          ;AN000;;  for path sep, there isn't one.
                                        ;AN000;
ONEINC:                                 ;AN000;
        INC     SI                      ;AN000;
        CMP     SI,BX                   ;AN000;
        JB      LOOKDUAL                ;AN000;
        POP     BX                      ;AN000;
;------------------------ End of DBCS 2/13/KK
 ENDIF                                  ;AN000;
        MOV     AL,DS:[SI-1]            ; last char to match
        Invoke  PathChrCmp              ; did we end on a path char? (root)
        JZ      DoSplice                ; yes, no current dir here.
Pathline:                               ; 2/13/KK
        CMP     BYTE PTR ES:[DI],0      ; end at NUL?
        JZ      DoSplice
        INC     DI                      ; point to after current path char
        MOV     Curr_Dir_End,DI         ; point to correct spot
;
; Splice the result.
;
DoSplice:
        Context DS                      ; back to DOSGROUP
        MOV     SI,wfp_Start            ; point to beginning of string
        XOR     CX,CX
        TEST    fSplice,-1
        JZ      SkipSplice
        CALL    Splice                  ; replaces in place.
SkipSplice:
        ASSUME  DS:NOTHING
;
; The final thing is to assure ourselves that a FATREAD is done on the local
; device.
;
        Context DS
        LES     DI,ThisCDS              ; point to correct drive
        TEST    ES:[DI].curdir_flags,curdir_isnet
        retnz                           ; net, no fatread necessary
        JCXZ    Done
        EnterCrit   critDisk
        invoke  FatRead_CDS
        LeaveCrit   critDisk
        MOV     AL,error_path_not_found ; Set up for possible bad path error
Done:   return                          ; any errors in carry flag.
EndProc TransPath

BREAK <Canonicalize - copy a path and remove . and .. entries>

;
;   Canonicalize - copy path removing . and .. entries.
;
;   Inputs:     DS:SI - point to ASCIZ string path
;               ES:DI - point to buffer
;               BX - backup limit (offset from ES) points to slash
;               BP - end of buffer
;   Outputs:    Carry Set - invalid path specification: too many .., bad
;                   syntax, etc.
;               Carry Clear -
;                   DS:DI - advanced to end of string
;                   ES:DI - advanced to end of canonicalized form after nul
;   Registers modified: AX CX DX (in addition to those above)

Procedure Canonicalize,NEAR
        ASSUME  CS:DOSGroup,DS:NOTHING,ES:NOTHING,SS:DOSGroup
;
; We copy all leading path separators.
;
        LODSB                           ;   while (PathChr (*s))
        Invoke  PathChrCmp
 IF  DBCS
        JNZ     CanonDec0               ; 2/19/KK
 ELSE
        JNZ     CanonDec
 ENDIF
        CMP     DI,BP                   ;       if (d > dlim)
        JAE     CanonBad                ;           goto error;
        STOSB
        JMP     Canonicalize            ;           *d++ = *s++;
 IF  DBCS                               ;AN000;
CanonDec0:                              ;AN000; 2/19/KK
;       mov     cs:Temp_Var,di          ;AN000; 3/31/KK
 ENDIF                                  ;AN000;
CanonDec:
        DEC     SI
;
; Main canonicalization loop.  We come here with DS:SI pointing to a textual
; component (no leading path separators) and ES:DI being the destination
; buffer.
;
CanonLoop:
;
; If we are at the end of the source string, then we need to check to see that
; a potential drive specifier is correctly terminated with a path sep char.
; Otherwise, do nothing
;
        XOR     AX,AX
        CMP     [SI],AL                 ;       if (*s == 0) {
        JNZ     DoComponent
 IF  DBCS                               ;AN000;
        call    chk_last_colon          ;AN000; 2/18/KK
 ELSE                                   ;AN000;
        CMP     BYTE PTR ES:[DI-1],':'  ;           if (d[-1] == ':')
 ENDIF                                  ;AN000;
        JNZ     DoTerminate
        MOV     AL,'\'                  ;               *d++ = '\';
        STOSB
        MOV     AL,AH
DoTerminate:
        STOSB                           ;           *d++ = 0;
        CLC                             ;           return (0);
        return
 IF  DBCS                               ;AN000;
;---------------- Start of DBCS 2/18/KK
chk_last_colon  proc                    ;AN000;
        push    si                      ;AN000;
        push    ax                      ;AN000;
        push    bx                      ;AN000;
        mov     si,[WFP_START]          ;AN000;;PTM. for cd ..  use beginning of buf
        cmp     si,di                   ;AN000;; no data stored ?
        jb      CLC02                   ;AN000;;PTM. for cd ..
        inc     si                      ;AN000;; make NZ flag
        JMP     SHORT CLC09             ;AN000;
CLC02:                                  ;AN000;
        mov     bx,di                   ;AN000;
        dec     bx                      ;AN000;
CLC_lop:                                ;AN000;
        cmp     si,bx                   ;AN000;
        jb      CLC00                   ;AN000;
        jne     CLC09                   ;AN000;
CLC01:                                  ;AN000;
        CMP     BYTE PTR ES:[DI-1],':'  ;AN000;;           if (d[-1] == ':')
        jmp     CLC09                   ;AN000;
CLC00:                                  ;AN000;
        mov     al,es:[si]              ;AN000;
        inc     si                      ;AN000;
        invoke  testkanj                ;AN000;
        je      CLC_lop                 ;AN000;
        inc     si                      ;AN000;
        jmp     CLC_lop                 ;AN000;
CLC09:                                  ;AN000;
        pop     bx                      ;AN000;
        pop     ax                      ;AN000;
        pop     si                      ;AN000;
        ret                             ;AN000;
chk_last_colon  endp                    ;AN000;
;---------------- Endt of DBCS 2/18/KK
 ENDIF                                  ;AN000;

CanonBad:
        CALL    ScanPathChar            ; check for path chars in rest of string
        MOV     AL,error_path_not_found ; Set up for bad path error
        JZ      PathEnc                 ; path character encountered in string
        MOV     AL,error_file_not_found ; Set bad file error
PathEnc:
        STC
        return
;
; We have a textual component that we must copy.  We uppercase it and truncate
; it to 8.3
;
DoComponent:                            ;           }
        CALL    CopyComponent           ;       if (!CopyComponent (s, d))
        retc                            ;           return (-1);
;
; We special case the . and .. cases.  These will be backed up.
;
        CMP     WORD PTR ES:[DI],'.' + (0 SHL 8)
        JZ      Skip1
        CMP     WORD PTR ES:[DI],'..'
        JNZ     CanonNormal
        DEC     DI                      ;           d--;
Skip1:  CALL    SkipBack                ;           SkipBack ();
        MOV     AL,error_path_not_found ; Set up for possible bad path error
        retc
        JMP     CanonPath               ;           }
;
; We have a normal path.  Advance destination pointer over it.
;
CanonNormal:                            ;       else
        ADD     DI,CX                   ;           d += ct;
;
; We have successfully copied a component.  We are now pointing at a path
; sep char or are pointing at a nul or are pointing at something else.
; If we point at something else, then we have an error.
;
CanonPath:
        CALL    PathSep
        JNZ     CanonBad                ; something else...
;
; Copy the first path char we see.
;
        LODSB                           ; get the char
        Invoke  PathChrCmp              ; is it path char?
        JNZ     CanonDec                ; no, go test for nul
        CMP     DI,BP                   ; beyond buffer end?
        JAE     CanonBad                ; yep, error.
        STOSB                           ; copy the one byte
;
; Skip all remaining path chars
;
CanonPathLoop:
        LODSB                           ; get next byte
        Invoke  PathChrCmp              ; path char again?
        JZ      CanonPathLoop           ; yep, grab another
        DEC     SI                      ; back up
        JMP     CanonLoop               ; go copy component
EndProc Canonicalize

BREAK <PathSep - determine if char is a path separator>

;
;   PathSep - look at DS:SI and see if char is / \ or NUL
;   Inputs:     DS:SI - point to a char
;   Outputs:    AL has char from DS:SI (/ => \)
;               Zero set if AL is / \ or NUL
;               Zero reset otherwise
;   Registers modified: AL

Procedure   PathSep,NEAR
        ASSUME  CS:DOSGroup,DS:NOTHING,ES:NOTHING,SS:DOSGroup
        MOV     AL,[SI]                 ; get the character
        entry   PathSepGotCh            ; already have character
        OR      AL,AL                   ; test for zero
        retz                            ; return if equal to zero (NUL)
        invoke  PathChrCmp              ; check for path character
        return                          ; and return HIS determination
EndProc PathSep

BREAK <SkipBack - move backwards to a path separator>

;
;   SkipBack - look at ES:DI and backup until it points to a / \
;   Inputs:     ES:DI - point to a char
;               BX has current directory back up limit (point to a / \)
;   Outputs:    ES:DI backed up to point to a path char
;               AL has char from output ES:DI (path sep if carry clear)
;               Carry set if illegal backup
;               Carry Clear if ok
;   Registers modified: DI,AL

Procedure   SkipBack,NEAR
        ASSUME  CS:DOSGroup,DS:NOTHING,ES:NOTHING,SS:DOSGroup
 IF  DBCS                      ;AN000;
;-------------------------- Start of DBCS 2/13/KK
        PUSH    DS              ;AN000;
        PUSH    SI              ;AN000;
        PUSH    CX              ;AN000;
        PUSH    ES              ;AN000;
        POP     DS              ;AN000;
        MOV     SI,BX           ;AN000;; DS:SI -> start of ES:DI string
        MOV     CX,DI           ;AN000;; Limit of forward scan is input DI
        MOV     AL,[SI]         ;AN000;
        invoke  PathChrCmp      ;AN000;
        JNZ     SkipBadP        ;AN000;; Backup limit MUST be path char
        CMP     DI,BX           ;AN000;
        JBE     SkipBadP        ;AN000;
        MOV     DI,BX           ;AN000;; Init backup point to backup limit
Skiplp:                         ;AN000;
        CMP     SI,CX           ;AN000;
        JAE     SkipOK          ;AN000;; Done, DI is correct backup point
        LODSB                   ;AN000;
        invoke  Testkanj        ;AN000;
        jz      Notkanjv        ;AN000;
        lodsb                   ;AN000;; Skip over second kanji byte
        JMP     Skiplp          ;AN000;
NotKanjv:                       ;AN000;
        invoke  PathChrCmp      ;AN000;
        JNZ     Skiplp          ;AN000;; New backup point
        MOV     DI,SI           ;AN000;; DI point to path sep
        DEC     DI              ;AN000;
        jmp     Skiplp          ;AN000;
SkipOK:                         ;AN000;
        MOV     AL,ES:[DI]      ;AN000;; Set output AL
        CLC                     ;AN000;; return (0);
        POP     CX              ;AN000;
        POP     SI              ;AN000;
        POP     DS              ;AN000;
        return                  ;AN000;
                                ;AN000;
SkipBadP:                       ;AN000;
        POP     CX              ;AN000;
        POP     SI              ;AN000;
        POP     DS              ;AN000;
;-------------------------- End of DBCS 2/13/KK
 ELSE                           ;AN000;
        CMP     DI,BX                   ;   while (TRUE) {
        JB      SkipBad                 ;       if (d < dlim)
        DEC     DI                      ;           goto err;
        MOV     AL,ES:[DI]              ;       if (pathchr (*--d))
        invoke  PathChrCmp              ;           break;
        JNZ     SkipBack                ;       }
        CLC                             ;   return (0);
        return                          ;
 ENDIF                                  ;AN000;
SkipBad:                                ;err:
        MOV     AL,error_path_not_found ; bad path error
        STC                             ;   return (-1);
        return                          ;
EndProc SkipBack

Break <CopyComponent - copy out a file path component>

;
;   CopyComponent - copy a file component from a path string (DS:SI) into ES:DI
;
;   Inputs:     DS:SI - source path
;               ES:DI - destination
;               ES:BP - end of buffer
;   Outputs:    Carry Set - too long
;               Carry Clear - DS:SI moved past component
;                   CX has length of destination
;   Registers modified: AX,CX,DX

Procedure   CopyComponent,NEAR
        ASSUME  CS:DOSGroup,DS:NOTHING,ES:NOTHING,SS:DOSGroup
CopyBP      EQU     WORD PTR [BP]
CopyD       EQU     DWORD PTR [BP+2]
CopyDoff    EQU     WORD PTR [BP+2]
CopyS       EQU     DWORD PTR [BP+6]
CopySoff    EQU     WORD PTR [BP+6]
CopyTemp    EQU     BYTE PTR [BP+10]
        SUB     SP,14                   ; room for temp buffer
        SaveReg <DS,SI,ES,DI,BP>
        MOV     BP,SP
        MOV     AH,'.'
        LODSB
        STOSB
        CMP     AL,AH                   ;   if ((*d++=*s++) == '.') {
        JNZ     NormalComp
        CALL    PathSep                 ;       if (!pathsep(*s))
        JZ      NulTerm
TryTwoDot:
        LODSB                           ;           if ((*d++=*s++) != '.'
        STOSB
        CMP     AL,AH
        JNZ     CopyBad
        CALL    PathSep
        JNZ     CopyBad                 ;               || !pathsep (*s))
NulTerm:                                ;               return -1;
        XOR     AL,AL                   ;       *d++ = 0;
        STOSB
        MOV     CopySoff,SI
        JMP     SHORT GoodRet           ;       }
NormalComp:                             ;   else {
        MOV     SI,CopySoff
        Invoke  NameTrans               ;       s = NameTrans (s, Name1);
        CMP     SI,CopySOff             ;       if (s == CopySOff)
        JZ      CopyBad                 ;           return (-1);
        TEST    fSharing,-1             ;       if (!fSharing) {
        JNZ     DoPack
        AND     DL,1                    ;           cMeta += fMeta;
        ADD     cMeta,DL                ;           if (cMeta > 0)
        JG      CopyBad                 ;               return (-1);
        JNZ     DoPack                  ;           else
        OR      DL,DL                   ;           if (cMeta == 0 && fMeta == 0)
        JZ      CopyBadPath             ;               return (-1);
DoPack:                                 ;           }
        MOV     CopySoff,SI
        Context DS
        MOV     SI,OFFSET DOSGroup:NAME1
        LEA     DI,CopyTemp
        SaveReg <DI>
        Invoke  PackName                ;       PackName (Name1, temp);
        RestoreReg  <DI>
        Invoke  StrLen                  ;       if (strlen(temp)+d > bp)
        DEC     CX
        ADD     CX,CopyDoff
        CMP     CX,CopyBP
        JAE     CopyBad                 ;           return (-1);
        MOV     SI,DI                   ;       strcpy (d, temp);
        LES     DI,CopyD
        Invoke  FStrCpy
GoodRet:                                ;       }
        CLC
        JMP     SHORT CopyEnd           ;   return 0;
CopyBad:
        STC
        CALL    ScanPathChar            ; check for path chars in rest of string
        MOV     AL,error_file_not_found ; Set up for bad file error
        JNZ     CopyEnd
CopyBadPath:
        STC
        MOV     AL,error_path_not_found ; Set bad path error
CopyEnd:
        RestoreReg  <BP,DI,ES,SI,DS>
        LAHF
        ADD     SP,14                   ; reclaim temp buffer
        Invoke  Strlen
        DEC     CX
        SAHF
        return
EndProc CopyComponent,NoCheck

Break <Splice - pseudo mount by string substitution>

;
;   Splice - take a string and substitute a prefix if one exists.  Change
;       ThisCDS to point to physical drive CDS.
;   Inputs:     DS:SI point to string
;               NoSetDir = TRUE => exact matches with splice fail
;   Outputs:    DS:SI points to thisCDS
;               ES:DI points to DPB
;               String at DS:SI may be reduced in length by removing prefix
;               and substituting drive letter.
;               CX = 0 If no splice done
;               CX <> 0 otherwise
;               ThisCDS points to proper CDS if spliced, otherwise it is
;                   left alone
;               ThisDPB points to proper DPB
;   Registers modified: DS:SI, ES:DI, BX,AX,CX

Procedure   Splice,NEAR
        ASSUME  CS:DOSGroup,DS:NOTHING,ES:NOTHING,SS:DOSGroup
        TEST    Splices,-1
        JZ      AllDone
        SaveReg <<WORD PTR ThisCDS>,<WORD PTR ThisCDS+2>>   ; TmpCDS = ThisCDS
        SaveReg <DS,SI>
        RestoreReg <DI,ES>
        XOR     AX,AX                   ;   for (i=1; s = GetCDSFromDrv (i); i++)
SpliceScan:
        invoke  GetCDSFromDrv
        JC      SpliceDone
        INC     AL
        TEST    [SI.curdir_flags],curdir_splice
        JZ      SpliceScan              ;       if ( Spliced (i) ) {
        SaveReg <DI>
        CALL    PathPref                ;           if (!PathPref (s, d))
        JZ      SpliceFound             ;
SpliceSkip:
        RestoreReg  <DI>
        JMP     SpliceScan              ;               continue;
SpliceFound:
        CMP     BYTE PTR ES:[DI],0      ;           if (*s || NoSetDir) {
        JNZ     SpliceDo
        TEST    NoSetDir,-1
        JNZ     SpliceSkip
SpliceDo:
        MOV     SI,DI                   ;               p = src + strlen (p);
        SaveReg <ES>
        RestoreReg  <DS,DI>
        CALL    TextFromDrive1          ;               src = TextFromDrive1(src,i);
        MOV     AX,Curr_Dir_End
        OR      AX,AX
        JS      NoPoke
        ADD     AX,DI                   ;               curdirend += src-p;
        SUB     AX,SI
        MOV     Curr_Dir_End,AX
NoPoke:
        CMP     BYTE PTR [SI],0         ;               if (*p)
        JNZ     SpliceCopy              ;                   *src++ = '\\';
        MOV     AL,"\"
        STOSB
SpliceCopy:                             ;               strcpy (src, p);
        invoke  FStrCpy
        ADD     SP,4                    ; throw away saved stuff
        OR      CL,1                    ; signal splice done.
        JMP     SHORT DoSet             ;               return;
SpliceDone:                             ;               }
        ASSUME  DS:NOTHING              ;   ThisCDS = TmpCDS;
        RestoreReg  <<WORD PTR ThisCDS+2>,<WORD PTR ThisCDS>>
AllDone:
        XOR     CX,CX
DoSet:
        LDS     SI,ThisCDS              ;   ThisDPB = ThisCDS->devptr;
        LES     DI,[SI].curdir_devptr
        MOV     WORD PTR ThisDPB,DI
        MOV     WORD PTR ThisDPB+2,ES
        return
EndProc Splice

Break <$NameTrans - partially process a name>

;
;   $NameTrans - allow users to see what names get mapped to.  This call
;   performs only string substitution and canonicalization, not splicing.  Due
;   to Transpath playing games with devices, we need to insure that the output
;   has drive letter and :  in it.
;
;   Inputs:     DS:SI - source string for translation
;               ES:DI - pointer to buffer
;   Outputs:
;       Carry Clear
;               Buffer at ES:DI is filled in with data
;               ES:DI point byte after nul byte at end of dest string in buffer
;       Carry Set
;               AX = error_path_not_found
;   Registers modified: all

Procedure   $NameTrans,Near
        ASSUME  CS:DOSGroup,DS:NOTHING,ES:NOTHING,SS:DOSGroup
        SaveReg <DS,SI,ES,DI>
        MOV     DI,OFFSET DOSGroup:OpenBuf
        CALL    TransPath               ; to translation (everything)
        RestoreReg  <DI,ES,SI,DS>
        JNC     TransOK
        transfer    SYS_Ret_Err
TransOK:
        MOV     SI,OFFSET DOSGroup:OpenBuf
        Context DS
GotText:
        Invoke  FStrCpy
        Transfer    SYS_Ret_OK
EndProc $NameTrans

Break   <DriveFromText - return drive number from a text string>

;
;   DriveFromText - examine DS:SI and remove a drive letter, advancing the
;   pointer.
;
;   Inputs:     DS:SI point to a text string
;   Outputs:    AL has drive number
;               DS:SI advanced
;   Registers modified: AX,SI.

Procedure   DriveFromText,NEAR
        ASSUME  CS:DOSGroup,DS:NOTHING,ES:NOTHING,SS:NOTHING
        XOR     AL,AL                   ;       drive = 0;
        CMP     BYTE PTR [SI],0         ;       if (*s &&
        retz
        CMP     BYTE PTR [SI+1],':'     ;           s[1] == ':') {
        retnz
 IF  DBCS                               ;AN000;
;--------------------- Start of DBCS 2/18/KK
        push    ax                     ;AN000;
        mov     al,[si]                ;AN000;
        invoke  testkanj               ;AN000;
        pop     ax                     ;AN000;
        retnz                          ;AN000;
;--------------------- End of DBCS 2/18/KK
 ENDIF                                 ;AN000;
        LODSW                           ;           drive = (*s | 020) - 'a'+1;
        OR      AL,020h
        SUB     AL,'a'-1                ;           s += 2;
        retnz
        MOV     AL,-1                   ; nuke AL...
        return                          ;           }
EndProc DriveFromText

Break   <TextFromDrive - convert a drive number to a text string>

;
;   TextFromDrive - turn AL into a drive letter: and put it at es:di with
;   trailing :. TextFromDrive1 takes a 1-based number.
;
;   Inputs:     AL has 0-based drive number
;   Outputs:    ES:DI advanced
;   Registers modified: AX

Procedure TextFromDrive,NEAR
        ASSUME  CS:DOSGroup,DS:NOTHING,ES:NOTHING,SS:NOTHING
        INC     AL
        Entry   TextFromDrive1
        ADD     AL,'A'-1                ;   *d++ = drive-1+'A';
        MOV     AH,":"                  ;   strcat (d, ":");
        STOSW
        return
EndProc TextFromDrive

Break   <PathPref - see if one path is a prefix of another>

;
;   PathPref - compare DS:SI with ES:DI to see if one is the prefix of the
;   other.  Remember that only at a pathchar break are we allowed to have a
;   prefix: A:\ and A:\FOO
;
;   Inputs:     DS:SI potential prefix
;               ES:DI string
;   Outputs:    Zero set => prefix found
;                   DI/SI advanced past matching part
;               Zero reset => no prefix, DS/SI garbage
;   Registers modified: CX

Procedure   PathPref,NEAR
        Invoke  DStrLen                 ; get length
        DEC     CX                      ; do not include nul byte
 IF  DBCS                               ;AN000;
;----------------------- Start of DBCS 2/13/KK
        SaveReg <AX>                    ;AN000;; save char register
CmpLp:                                  ;AN000;
        MOV     AL,[SI]                 ;AN000;
        invoke  Testkanj                ;AN000;
        jz      NotKanj9                ;AN000;
        CMPSW                           ;AN000;
        JNZ     Prefix                  ;AN000;
        DEC     CX                      ;AN000;
        LOOP    CmpLp                   ;AN000;
        JMP     SHORT NotSep            ;AN000;
NotKanj9:                               ;AN000;
        CMPSB                           ;AN000;
        JNZ     Prefix                  ;AN000;
        LOOP    CmpLp                   ;AN000;
;----------------------- End of DBCS 2/13/KK
 ELSE                                   ;AN000;
        REPZ    CMPSB                   ; compare
        retnz                           ; if NZ then return NZ
        SaveReg <AX>                    ; save char register
 ENDIF                                  ;AN000;
        MOV     AL,[SI-1]               ; get last byte to match
        Invoke  PathChrCmp              ; is it a path char (Root!)
        JZ      Prefix                  ; yes, match root (I hope)
NotSep:                                 ; 2/13/KK
        MOV     AL,ES:[DI]              ; get next char to match
        CALL    PathSepGotCh            ; was it a pathchar?
Prefix:
        RestoreReg  <AX>                ; get back original
        return
EndProc PathPref

Break   <ScanPathChar - see if there is a path character in a string>

;
;     ScanPathChar - search through the string (pointed to by DS:SI) for
;     a path separator.
;
;     Input:    DS:SI target string (null terminated)
;     Output:   Zero set => path separator encountered in string
;               Zero clear => null encountered
;     Registers modified: SI

Procedure     ScanPathChar,NEAR
        LODSB                           ; fetch a character
 IF  DBCS                               ;AN000;
        invoke  TestKanj                ;AN000;; 2/13/KK
        jz      NotKanjr                ;AN000;; 2/13/KK
        LODSB                           ;AN000;; 2/13/KK
        OR      AL,AL                   ;AN000;; 2/13/KK  3/31/removed
        JNZ     ScanPathChar            ;AN000;; 2/13/KK  3/31/removed
        INC     AL                      ;AN000;; 2/13/KK
        return                          ;AN000;; 2/13/KK
                                        ;AN000;
NotKanjr:                               ;AN000;; 2/13/KK
 ENDIF                                  ;AN000;
        call    PathSepGotCh
        JNZ     ScanPathChar            ; not \, / or NUL => go back for more
        invoke  PathChrCmp              ; path separator?
        return
EndProc       ScanPathChar

CODE ends
END