; IfsDirKey.asm -- Directory CompareKey and EntryLength procedures
; handed to B-tree package
; Copyright Xerox Corporation 1981, 1982
; Last modified May 11, 1982 6:06 PM by Taft
.ent DirCompareKey, DirEntryLength
.bext IFSError
; The following must agree with the FD structure in IfsDirs.decl and
; the DR structure in IfsFiles.decl.
FD.lenBodyString = 6. ; left byte of this word
FD.version = 7.
FD.dr = 8.
DR.header = 0.
DR.pathName = 6.
drHeaderMask = 171600
drLengthMask = 177
.dmr GetNextChar = 66400
.srel
DirCompareKey: .DirCompareKey
DirEntryLength: .DirEntryLength
.nrel
; DirCompareKey(fd, record)
; Returns -1 if fd (key) is less than record, 0 if equal, 1 if greater.
; Note: this procedure is not reentrant.
.DirCompareKey:
sta 3 1 2
sta 0 2 2 ; fd
sta 1 3 2 ; record
; Set up CSD (character stream descriptor) for fd (key)
mov 0 3 ; fd
lda 0 FD.lenBodyString 3 ; number of key characters to examine
lda 1 c177400 ; left byte of this word
ands 1 0
subzr 1 1 ; 100000B
add 1 0 ; begin at right-hand byte
lda 3 FD.dr 3
lda 1 cDR.pathName
add 3 1 ; address of string in key
lda 3 csdKey
snz 3 3 ; CSD pointers already set up?
jsr SetupCSDs ; no, do so first
sta 0 0 3
sta 1 1 3
; Set up CSD for record
lda 3 3 2 ; record
lda 0 DR.header 3 ; minimal check that this is really a DR
lda 1 cdrHeaderMask
and# 0 1 szr
jmp BadDR
lda 0 DR.pathName 3 ; extract string length
lda 1 c177400
ands 1 0
subzr 1 1 ; 100000B
add 1 0 ; begin at right-hand byte
lda 1 cDR.pathName
add 3 1 ; address of string in record
lda 3 csdRecord
sta 0 0 3
sta 1 1 3
; DirCompareKey (cont'd)
; Compare characters in the "<dir>name!" portion
CompareBodyLoop:
lda 0 csdKey
GetNextChar 140 ; get char from key, convert to upper case
jmp KeyExhausted
mov 1 3
lda 0 csdRecord
GetNextChar 140 ; get char from record, convert to upper case
jmp RetGr ; exhausted: key is greater than record
sne 1 3
jmp CompareBodyLoop ; equal, continue comparing
; First mismatch. If all remaining characters of the record are digits
; then the record body is an initial substring of the key and we declare
; the key to be greater. Otherwise we return the result of comparing
; the mismatching character codes. Note that the only possible effect
; of looking at the rest of the record is to return "greater" where we
; otherwise would return "less". But if keyChar > recChar anyway, then
; just say so now without bothering to check.
slt 3 1
jmp RetGr
CheckDigitsLoop:
lda 0 cDigit0 ; recChar a digit?
sub 0 1
lda 0 d10
sltu 1 0
jmp RetLs ; no, key is less than record
lda 0 csdRecord
GetNextChar 0 ; get next char from record
jmp RetGr ; exhausted: key is greater than record
jmp CheckDigitsLoop
; Key is exhausted before record: bodies seem to match.
; Now parse the version string in the directory entry and compare the
; key version number to it. If a non-digit is encountered then the
; key body is an initial substring of the record and is therefore "less".
KeyExhausted:
mkzero 3 3 ; init parsed version
ParseVersionLoop:
lda 0 csdRecord
GetNextChar 0 ; get next char from record
jmp VersionExhausted ; exhausted: go compare version numbers
lda 0 cDigit0 ; recChar a digit?
sub 0 1
lda 0 d10
sltu 1 0
jmp RetLs ; no, key is less than record
mov 3 0 ; yes, multiply parsed version by 10
addzl 3 3
addzl 0 3
add 1 3 ; add in new digit
jmp ParseVersionLoop
; Reached end of version number. Compare key version to it.
VersionExhausted:
mov 3 1
lda 3 2 2 ; fd
lda 0 FD.version 3
sne 0 1
jmp RetEq
sltu 0 1
RetGr: mkone 0 0 skp ; key > record, return 1
RetLs: mkminusone 0 0 ; key < record, return -1
lda 3 1 2
jmp 1 3
RetEq: mkzero 0 0 ; key = record, return 0
lda 3 1 2
jmp 1 3
; Internal procedure to set up csdRecord and csdKey.
; Returns with AC3 = csdKey.
; Does not disturb other ACs.
SetupCSDs:
sta 3 csdBlk
jsr AfterCSDs
csdBlk: .blk 5
AfterCSDs:
skeven 3 3 ; force CSDs to be even
inc 3 3
sta 3 csdRecord
inc 3 3
inc 3 3
sta 3 csdKey
jmp @csdBlk
csdKey: .blk 1
csdRecord: .blk 1
c177400: 177400
cDigit0: 60
d10: 10.
cDR.pathName: DR.pathName
; DirEntryLength(record)
; returns the record's length.
.DirEntryLength:
sta 0 2 2
lda 0 @2 2
lda 1 cdrHeaderMask ; Check for valid DR
and# 1 0 szr ; Unused bits must be zero
jmp BadDRx
lda 1 cdrLengthMask ; Extract length -- must be nonzero
and 1 0 snr
jmp BadDRx
jmp 1 3
BadDRx: sta 3 1 2
BadDR: lda 0 2 2
lda 1 3 2
jsr @370
6
77400
lda 0 .ecBadDR
jsrii lvIFSError ; IFSError(ecBadDR)
2
cdrHeaderMask: drHeaderMask
cdrLengthMask: drLengthMask
.ecBadDR: 120.
lvIFSError: IFSError
.end
// The following procedures are equivalent to the ones in this module:
//----------------------------------------------------------------------------
let DirCompareKey(fd, record) = valof
//----------------------------------------------------------------------------
// The CompareKeyRoutine passed to the B-Tree package.
// Compares the key "fd" with the pathName portion of
// the directory entry "record", returning -1, 0, or 1 if the
// key is respectively less than, equal to, or greater than the entry.
[
if (record>>DR.header & drHeaderMask) ne 0 then IFSError(ecBadDR)
// First, compare chars in the "<dir>name!" (string) portion
let key = fd>>FD.dr
let lenRecStr = record>>DR.pathName.length
for i = 1 to fd>>FD.lenBodyString do
[
// If we run off the end of the record then the key is greater.
if i gr lenRecStr resultis 1
let keyChar = key>>DR.pathName.char↑i
let recChar = record>>DR.pathName.char↑i
if keyChar ne recChar then
[
// Lower-case alphabetics collate with upper-case
if keyChar ge $a & keyChar le $z then keyChar = keyChar-($a-$A)
if recChar ge $a & recChar le $z then recChar = recChar-($a-$A)
if keyChar ne recChar then
[
// Definitely a mismatch. If all remaining characters of the
// record are digits then the record body is an initial substring
// of the key and we declare the key to be greater. Otherwise we
// return the result of comparing the mismatching character codes.
// Note that the only possible effect of looking at the rest of the
// record is to return "greater" where we otherwise would return
// "less". But if keyChar > recChar anyway, then just say so now
// without bothering to check.
if keyChar ls recChar then
for j = i to lenRecStr do
[
let digit = record>>DR.pathName.char↑j - $0
if digit ls 0 % digit gr 9 resultis -1
]
resultis 1
]
]
]
// Bodies equal, now parse the version string in the directory
// entry and compare the key version number to it.
// If a non-digit is encountered then the key body is an initial substring
// of the record and we return "less than".
let version = 0
for i = fd>>FD.lenBodyString+1 to lenRecStr do
[
let digit = record>>DR.pathName.char↑i - $0
if digit ls 0 % digit gr 9 resultis -1 //non-digit encountered
version = 10*version+digit
]
resultis Usc(fd>>FD.version, version)
]
//----------------------------------------------------------------------------
and DirEntryLength(record) = valof
//----------------------------------------------------------------------------
[
let length = record>>DR.length
if (record>>DR.header & drHeaderMask) ne 0 % length eq 0 then
IFSError(ecBadDR)
resultis length
]