.title k11rtd wildcard directory lookup for RT11 .ident /2.17/ ; 18-Jun-84 16:33:01 Brian Nelson ; ; ; Copyright (C) 1984 Change Software, Inc .sbttl local data offsets and definitions .mcall .csispc ,.dstat ,.fetch ,.lookup,.readw ,.close ,.cstat .psect .include /IN:K11MAC.MAC/ .psect .enabl gbl topmem = 50 errbyt = 52 tent = 400 ; status for a tentative file empty = 1000 ; status for an empty entry perm = 2000 ; status bit for a permanent file endseg = 4000 ; end of a segment bits ;; star = 134745 ; from .csispc for a '*' (rt11/rsts) star = 132500 ; from .csispc for a '*' (real RT11) .psect rtdir ,rw,d,lcl,rel,con hd$blk = 1 ; vbn of the home block hd$fir = 724 ; offset into home block for first block hd$vol = 730 ; RT11A and seven spaces usually hd$sys = 760 ; always DECRT11A outlun: .word 0 dirbuf: .blkb 2000 ; 2 block buffer for directory segments name1: .blkb 12 name2: .blkb 12 .save .psect rtdir1 ,rw,d,gbl,rel,con contex: .word 0 ; current file number hd.fir: .word 0 ; block number of first entry itsopen:.word 0 time: .word 0,45 .restore junk: .blkb 20 ; information from the directory header h$nseg = 0 ; offset for segment count in buffer h$next = 2 ; offset for next block link h$max = 4 ; offset for highest segment in use h$ext = 6 ; offset for number of extra words h$blk = 10 ; offset for first block # of data h.nseg: .blkw 1 ; number of segments in the directory h.next: .blkw 1 ; link to the next directory segment h.max: .blkw 1 ; max segment actually in use h.ext: .blkw 1 ; number of extra words per entry h.blk: .blkw 1 ; data block number for the segment ; information from the current directoty entry f.stat = 0 ; entry status word f.nam = 2 ; all three words of the name+type f.nam1 = 2 ; first three rad50 characters of name f.nam2 = 4 ; last three rad50 characters of name f.type = 6 ; all three rad50 characters of type f.len = 10 ; file size f.misc = 12 ; we don't care about this stuff f.date = 14 ; creation date .save .psect rtdir1 ,rw,d,gbl,rel,con dirsiz: .blkw 1 ; total size of a directory entry filnam: .blkw 4 ; the .csispc parsed filename+type resnam: .blkw 4 ; the name we found .restore .psect .psect $code lookup::save ; save all the temps please copyz 2(r5) ,6(r5) ; return the passed name for starters tst @4(r5) ; new call sequence today? bne 10$ ; no clr context ; yes, flag so clr h.max ; also init a flag .close #lun.sr ; close the old device up also clr r0 ; no errors please clr itsopen ; device is no longer open 10$: .if ne ,0 .ift mov 2(r5) ,r1 ; get pointer to source filespec 20$: tstb @r1 ; scan for a '*' in the filename beq 30$ ; none, all done cmpb (r1)+ ,#'* ; any wildcarding today ? bne 20$ ; not yet, keep looking br 40$ ; found at least one wildcard character 30$: clr r0 ; assume no errors yet tst @4(r5) ; no wildcarding, already been here? beq 35$ ; no, just exit then mov #er$nmf ,r0 ; been here once and no wildcards 35$: inc @4(r5) ; fix context for the next call br 100$ ; exit with 'no more files' .endc 40$: tst itsopen ; need to open it up bne 50$ ; no, already established a context call opndev ; get the disk opened up please tst r0 ; any errors ? bne 100$ ; yes, we will have to die then mov sp ,itsopen ; device is open for next call 50$: call getnth ; lookup the next one please tst r0 ; errors ? bne 90$ ; no inc @4(r5) ; return correct context br 100$ 90$: mov r0 ,-(sp) ; yes, close the device please .close #lun.sr ; close the device up on errors clr context ; insure current context is cleared clr itsopen ; insure we do an open next time mov (sp)+ ,r0 ; restore the error code now 100$: unsave ; pop temps and exit please return ; return any errors in r0 .sbttl print directory listing dodir:: save ; save these please mov 2(r5) ,outlun 10$: mov @r5 ,-(sp) mov #1 ,-(sp) mov sp ,r5 call .dodir cmp (sp)+ ,(sp)+ 100$: unsave clr r0 return .dodir: tst itsopen ; need to open it up beq 10$ ; yes .close #lun.sr ; please close up shop first clr itsopen ; say it's closed now 10$: call opndev ; get the disk opened up please tst r0 ; any errors ? bne 100$ ; yes, we will have to die then mov sp ,itsopen ; device is open for next call 50$: call pridir ; lookup the next one please tst r0 ; errors ? beq 50$ ; no 90$: mov r0 ,-(sp) ; yes, close the device please .close #lun.sr ; close the device up on errors clr itsopen ; insure we do an open next time mov (sp)+ ,r0 ; restore the error code now 100$: return ; return any errors in r0 .sbttl open the disk up to search the directory opndev: sub #20. ,sp ; allocate buffer for the mov sp ,r2 ; device status call sub #40.*2 ,sp ; allocate a buffer for the mov sp ,r1 ; .csispc data 1$: mov #defdir ,r3 ; insert default device name scan #': ,2(r5) ; check for a device already there tst r0 ; well ? bne 6$ ; yep. don't try to put one in please 5$: movb (r3)+ ,@r1 ; copy it beq 6$ ; all done inc r1 ; not null, next please br 5$ ; 6$: mov 2(r5) ,r0 ; string address 10$: movb (r0)+ ,(r1)+ ; copy it to the csi buffer bne 10$ ; until a null byte is found. dec r1 ; get back to the last character cmpb -1(r1) ,#': ; is the just just a device only? bne 15$ ; no movb #'* ,(r1)+ ; yes, insert *.* movb #'. ,(r1)+ ; yes, insert *.* movb #'* ,(r1)+ ; yes, insert *.* 15$: movb #'= ,(r1)+ ; fake an output filespec here clrb @r1 ; and .asciz mov sp ,r1 ; reset pointer (also saving sp) .csispc r1,#defext,r1 ; and try to parse the name mov r1 ,sp ; restore from any switches bcs 80$ ; oops calls fetch ,<@r1> ; try to get the thing loaded tst r0 ; well ? bne 120$ ; no, exit with mapped error 20$: tst @r1 ; a specific device name ? bne 30$ ; yes mov #^RDK ,@r1 ; no, stuff DK: into it then 30$: mov r1 ,r0 ; copy the pointer to .csispc results mov #filnam ,r2 ; and save the results mov (r0)+ ,(r2)+ ; copy the device spec first of all mov @r0 ,(r2)+ ; copy the first 3 rad50 of filename bne 40$ ; something was indeed there mov #star ,-2(r2) ; nothing, convert to wilcard 40$: clr (r0)+ ; and clear any filenames please mov @r0 ,(r2)+ ; copy the last 3 rad50 of filename clr (r0)+ ; and clear any filenames please mov @r0 ,(r2)+ ; copy the 3 rad50 of filetype bne 50$ ; something was passed for filetype mov #star ,-2(r2) ; nothing there, stuff a wilcard in 50$: clr (r0)+ ; and clear any filetypes please clr (r0)+ ; to be sure .lookup #rtwork,#lun.sr,r1 ; open the file for input bcs 100$ ; can not find it clr r0 ; no errors br 120$ ; and exit 60$: mov #dsterr ,r1 br 110$ 80$: mov #csierr ,r1 ; .csispc error mapping br 110$ ; get the correct error now 90$: mov #feterr ,r1 ; .fetch error codes br 110$ 100$: mov #lokerr ,r1 ; .lookup error mapping br 110$ 110$: movb @#errbyt,r0 ; get the error code now asl r0 ; times 2 for indexing into error map add r0 ,r1 ; now map the rt11 error into a fake mov @r1 ,r0 ; of a rms11 error 120$: add #<40.*2>+20.,sp ; pop all the tiny buffers now. return ; and get out .save .psect rtdir defext: .word 0 .word 0 .word 0 .word 0 .restore .sbttl read the home block in please gethom: .readw #rtwork,#lun.sr,#dirbuf,#400,#hd$blk bcs 90$ ; it failed, bye mov #dirbuf ,r0 ; point to the buffer now mov hd$fir(r0),hd.fir ; get the first directory block number add #hd$sys ,r0 ; point to the volume ident cmpb (r0)+ ,#'D&137 ; error if not rt11 volume bne 80$ ; oops cmpb (r0)+ ,#'E&137 ; error if not rt11 volume bne 80$ ; oops cmpb (r0)+ ,#'C&137 ; error if not rt11 volume bne 80$ ; oops cmpb (r0)+ ,#'R&137 ; error if not rt11 volume bne 80$ ; oops cmpb (r0)+ ,#'T&137 ; error if not rt11 volume bne 80$ ; oops cmpb (r0)+ ,#'1 ; error if not rt11 volume bne 80$ ; oops cmpb (r0)+ ,#'1 ; error if not rt11 volume bne 80$ ; oops clr r0 ; no errors br 100$ ; and exit 80$: mov #er$vol ,r0 ; return an error code and exit br 100$ ; bye 90$: movb @#errbyt,r0 ; get the error code asl r0 ; times two mov reaerr(r0),r0 ; map it into a unique global error 100$: return ; bye gethdr: .readw #rtwork,#lun.sr,#dirbuf,#1000,r1 bcs 90$ ; it failed, bye mov #dirbuf ,r0 ; point to the buffer now mov h$nseg(r0),h.nseg ; get the total segment count now asl h$next(r0) ; segments are two blocks in length beq 5$ ; no more segments if zero add #4 ,h$next(r0) ; and at last, the offset 5$: mov h$next(r0),h.next ; get the link to the next one tst h.max ; already set up ? bne 10$ ; yes, don't touch it please mov h$max(r0) ,h.max ; get the maximum segment in use 10$: mov h$ext(r0) ,h.ext ; get the extra words per dir entry mov h$blk(r0) ,h.blk ; and the starting block for data mov #7*2 ,dirsiz ; the default entry size add h$ext(r0),dirsiz ; plus extra bytes per entry clr r0 ; no errors br 100$ ; and exit 90$: movb @#errbyt,r0 ; get the error code asl r0 ; times two mov reaerr(r0),r0 ; map it into a unique global error 100$: return ; bye .sbttl print the directory out pridir: save ; save temps call gethom ; read in the home block tst r0 ; did it work ? bne 100$ ; no, exit with the error please mov hd.fir ,r1 ; get this directory entry 10$: tst r1 ; end of the directory list ? beq 90$ ; yes, return 'no more files' please call gethdr ; the the first directory header tst r0 ; did this work out ? bne 100$ ; no, return mapped error code please mov #dirbuf ,r3 ; point to the directory buffer add #5*2 ,r3 ; skip past the header information 20$: bit #endseg ,f.stat(r3) ; end of this segment ? bne 80$ ; yes, try the next one please bit #perm ,f.stat(r3) ; is this a real file ? beq 70$ ; no, skip it please call match ; see if the file matches up tst r0 ; well ? beq 70$ ; no, try again please mov #junk ,r2 ; a local buffer to use call convert ; convert to asciz mov #junk ,-(sp) ; push the buffer address call 110$ ; dump it please deccvt f.len(r3),#junk ; convert size to decimal clrb junk+6 ; insure .asciz please mov #junk ,-(sp) ; push the buffer address call 110$ ; and do it mov #210$ ,-(sp) ; push buffer call 110$ ; dump it mov f.date(r3),r0 ; a real date today? bne 60$ ; yes dec r0 ; no, force 00-xxx-00 60$: calls cvtdat ,<#junk,r0>,nogbl; and convert the date mov #junk ,-(sp) ; same again call 110$ ; mov #200$ ,-(sp) ; call 110$ ; 70$: add dirsiz ,r3 ; skip to the next entry please br 20$ ; and check this one out please 80$: mov h.next ,r1 ; end of segment, check the next one br 10$ ; simple to do 90$: mov #er$nmf ,r0 100$: unsave ; pop temps and exit return 110$: save ; save registers mov 12(sp) ,r3 ; get the buffer address tst outlun ; output to disk or terminal beq 150$ ; tt: strlen r3 ; disk, get the buffer size mov r0 ,r2 ; save it please beq 190$ ; nothing to do 120$: movb (r3)+ ,r0 ; get the next character mov outlun ,r1 ; set the lun up also call putcr0 ; dump the character sob r2 ,120$ ; and get the next one br 190$ ; exit 150$: .print r3 ; output to tt: 190$: unsave ; pop registers and exit mov (sp)+ ,(sp) ; move return address up and exit return ; bye 200$: .byte 15,12,0 210$: .byte 40,40,40,0 .even .sbttl get the next entry matching a possibly wildcarded name getnth: save ; save temps clr r4 ; counter for number of matches call gethom ; read in the home block tst r0 ; did it work ? bne 100$ ; no, exit with the error please mov hd.fir ,r1 ; get this directory entry 10$: tst r1 ; end of the directory list ? beq 90$ ; yes, return 'no more files' please call gethdr ; the the first directory header tst r0 ; did this work out ? bne 100$ ; no, return mapped error code please mov #dirbuf ,r3 ; point to the directory buffer add #5*2 ,r3 ; skip past the header information 20$: bit #endseg ,f.stat(r3) ; end of this segment ? bne 80$ ; yes, try the next one please bit #perm ,f.stat(r3) ; is this a real file ? beq 70$ ; no, skip it please call match ; see if the file matches up tst r0 ; well ? beq 70$ ; no, try again please cmp r4 ,context ; a match here ? bne 50$ ; no, try again please mov 6(r5) ,r2 ; a buffer to convert into call convert ; convert to asciz mov r2 ,r0 ; not get rid off ALL spaces in the name 30$: tstb @r0 ; end of the string yet ? beq 40$ ; yes cmpb @r0 ,#40 ; if it's a space, then ignore it beq 35$ ; skip it please movb @r0 ,(r2)+ ; not a space, please copy it then 35$: inc r0 ; point to the next character now br 30$ ; and check the next character please 40$: clrb @r2 ; insure returned string is .asciz clr r0 ; success inc context ; next one next time please br 100$ ; bye 50$: inc r4 ; matches := succ( matches ) br 70$ ; next try please 70$: add dirsiz ,r3 ; skip to the next entry please br 20$ ; and check this one out please 80$: mov h.next ,r1 ; end of segment, check the next one br 10$ ; simple to do 90$: mov #er$nmf ,r0 100$: unsave ; pop temps and exit return .sbttl convert current directory entry to asciz ; input: r2 buffer for the result ; r3 current directory entry pointer convert:mov r2 ,-(sp) ; save the passed pointer to a buffer calls rdtoa , ; convert the device name please cmpb @r2 ,#40 ; a space for device name ? bne 10$ ; no movb #'D&137 ,@r2 ; yes, stuff 'DK' in please movb #'K&137 ,1(r2) ; simple to do 10$: add #2 ,r2 ; skip past it and insert a ':' cmpb @r2 ,#40 ; a space (no unit number?) beq 20$ ; no tstb (r2)+ ; a real unit, skip over number 20$: movb #': ,(r2)+ ; yes, get DD: format of device name calls rdtoa ,; convert first 3 filename to ascii add #3 ,r2 ; and skip over those three characters calls rdtoa ,; now get the rest of the filename add #3 ,r2 ; point to place a dot into the name movb #'. ,(r2)+ ; a dot calls rdtoa ,; get the filetype at last clrb 3(r2) ; and insure .asciz please mov (sp)+ ,r2 ; pop the pointer and exit return ; bye .if ne ,0 .ift match: cmp filnam+2,#star ; wilcard for the filename ? beq 10$ ; yes, only need to check on filetype cmp filnam+2,f.nam1(r3) ; no wildcard in name, check for bne 90$ ; match on both words of filename cmp filnam+4,f.nam2(r3) ; well ? bne 90$ ; no match 10$: cmp filnam+6,#star ; check the filetype for wildcards beq 20$ ; a match, return success cmp filnam+6,f.type(r3) ; no wildcard, check for exact match bne 90$ ; failure, exit 20$: mov sp ,r0 ; success, return r0 <> 0 br 100$ ; bye 90$: clr r0 ; failure 100$: return ; and exit at last .endc percent = 131574 wildc = '. match: save ; we may need these here mov filnam+2,rtwork+0 ; copy the name and type please mov filnam+4,rtwork+2 ; copy the name and type please mov filnam+6,rtwork+4 ; copy the name and type please cmp rtwork ,#star ; if we parsed a star, convert it bne 20$ ; into '%%%%%%' for the filename mov #percent,rtwork+0 ; do it mov #percent,rtwork+2 20$: cmp rtwork+4,#star ; if we had a * for the filetype bne 30$ ; then convert it into a '.%%%' mov #percent,rtwork+4 30$: mov #name1 ,r1 ; was not a simple pattern so convert mov #rtwork ,r2 ; both names back to ascii and check mov #3 ,r0 ; for individual character wildcarding 40$: calls rdtoa , ; convert the patter filename back add #3 ,r1 ; increment the pointer by 3 characters sob r0 ,40$ ; next please mov #name2 ,r1 ; a buffer for the file we just found mov r3 ,r2 ; on the disk. Now get the address of add #f.nam1 ,r2 ; the name and filetype and convert this mov #3 ,r0 ; to ascii in a loop 50$: calls rdtoa , ; convert add #3 ,r1 ; next please sob r0 ,50$ 60$: mov #11 ,r0 ; the loop count for scanning mov #name1 ,r1 ; the pattern mov #name2 ,r2 ; the current filename on disk 70$: cmpb @r1 ,(r2)+ ; if they match, no problem beq 80$ ; simply check the next character cmpb @r1 ,#wildc ; check for the converted % bne 90$ ; match failure 80$: inc r1 ; sob r0 ,70$ ; match so far, check the next ones mov sp ,r0 ; flag success and exit br 100$ ; bye 90$: clr r0 ; failure, exit 100$: unsave return ; and exit at last .sbttl ascdat convert to ascii date for RT11 .mcall .date ; input: @r5 output buffer address ; 2(r5) value of date, zero implies current ; ; I certainly could use my ASH and DIV macros, but may as ; well do it this way for future possibilities. ; ; N O T E : This is a LOCAL copy of ASCDAT so I can overlay ; the real ACSDAT oppossing this overlay. cvtdat: save ; save these please mov @r5 ,r1 ; the result address cmp 2(r5) ,#-1 ; if -1, then return 00-XXX-00 bne 5$ ; no copyz #310$ ,r1 ; yes, then exit br 100$ ; bye 5$: mov 2(r5) ,r0 ; get the date desired please bne 10$ ; it's ok .date ; zero, assume todays date then 10$: bic #100000 ,r0 ; undefined mov r0 ,r3 ; copy the date asr r3 ; /2 asr r3 ; /2 again asr r3 ; ditto asr r3 ; sigh asr r3 ; at last bic #^C37 ,r3 ; the date, at last call 200$ ; convert it mov r0 ,r3 ; get the date once again please swab r3 ; get the month to bits 2..7 asr r3 ; /2 asr r3 ; /2 again bic #^C17 ,r3 ; get rid of the unwanted bits now dec r3 ; convert to 0..11 asl r3 ; convert to word offset asl r3 ; quad offset add #300$ ,r3 ; the address of the text movb #'- ,(r1)+ ; copy it over please movb (r3)+ ,(r1)+ ; three characters please movb (r3)+ ,(r1)+ ; three characters please movb (r3)+ ,(r1)+ ; three characters please movb #'- ,(r1)+ ; copy it over please mov r0 ,r3 ; copy the date bic #^C37 ,r3 ; the year, at last add #110 ,r3 ; plus the bias please call 200$ ; convert clrb @r1 ; .asciz and exit 100$: unsave return 200$: clr r2 ; subtract 10 a few times 210$: inc r2 ; high digit number sub #12 ,r3 ; until we get a negative number tst r3 ; done yet ? bge 210$ ; no dec r2 ; yes add #12 ,r3 ; correct it please add #'0 ,r2 ; and copy the day number please add #'0 ,r3 ; simple movb r2 ,(r1)+ ; copy it movb r3 ,(r1)+ ; copy it return 300$: .ascii /Jan Feb Mar Apr May Jun Jul Aug Sep Oct Nov Dec / 310$: .asciz /00-XXX-00/ .even .end