There are 2 other files named scn.mac in the archive. Click here to see a list.
title PASSCN - SCAN interface for PASCAL programs
;Note: This file is a prototype. Some tables and routines will need
;to be changed to fit your application. Hopefully the file is self-
;page 1 of this file contains the two routines ISCAN and TSCAN, which
;actually scan the command line. These routines are more or less the
;same for all applications. Only some table entries change, as shown
;below. The things you will want to change are put near the beginning
;of the page.
;page 2 of this file contains prototypes for routines to actually open
;the files. These routines should be written by the user. There will
;need to be one routine for each file to be openned. Note that the
;examples supplied here are sufficiently general that normally you will
;only need to delete unwanted code (as the examples have all possible
;bells and whistles) and change a few SIXBIT constants for default
;names, extensions, etc. Again, the routines you need to worry about
;have been put at the beginning of the page
;page 3 of this file contains prototypes for routines that use WILD.
;You may safely delete page 3 (except the END statement) if you don't
;intend to use WILD. If you use only things on page 3, the example
;routines (OPENIN and OPENOU) may be deleted from page 2, but the
;various low level routines on page 2 are also used by the WILD
.lklen==20 ;length of our extended lookup/enter blocks
FILPTR= 0 ;LH = FUNNY BUSINESS IF WE ARE DOING STRING I/O:
; BIT 0 IS ALWAYS ON FOR STRING I/O
; REST OF WORD IS LMAX FOR THE ARRAY
;FOR A FILE, LH=ERROR CODE IF REWRITE/RESET FAILS
FILEOF= 1 ;input: 0 = normal state
; 1 = eof or error - no more data in file (some
; errors will allow reading to continue, and
; thus will NOT set FILEOF)
;output:1 = normal state
; 0 = error (but program will abort so this will
; never show up)
FILSTA=11 ; .+0 FOR FILESTATUS
FILDEV=12 ; .+1 FOR DEVICE
FILBFP=13 ; .+2 FOR POINTER TO BUFFERHEADER
FILBFH=26 ;BUFFER HEADER
FILBTP=27 ;BYTE POINTER
FILBTC=30 ;BYTE COUNT IN BUFFER
FILLNR=31 ;IF ASCII MODE - LINENR IN ASCIICHARACTERS
FILCNT=32 ;LH= if non-text file: neg. number of words in comp.
; if text file: zero
;test sign bit of this loc to see if an ASCII file
;RH= ADDRESS OF FIRST WORD IN COMPONENT
FILCMP=33 ;FIRST WORD OF COMPONENT
;here begin the magic blocks that you may want to edit
comnds: sixbit /FOO/ ;table of monitor commands this program processes
iblk: iowd 2,comnds ;length of comnds list, comnds
xwd %cclsw##,'FOO' ;RH=name of CCL or tmpcore file
retblk:: ;tscan returns a pointer to this block. Your PASCAL
;program will consider it a record with an entry for each
;possible switch. There should be one entry here for
asw: exp 0 ;These values don't matter
bsw: exp 0
csw: exp 0
define swtchs< ;This is the definition of the switches. It uses macros
;from SCNMAC. We will not document them here.
clrans: ;This routine will be called before scanning each line. It
;should usually set all the switch values to -1, which is a
;special value that SCAN uses as a code to indicate that nothing
;has been typed yet. You should see to it that there is a
;SETOM for each location in retblk, unless you are dealing with
;wierd switch types. (Some should be set to 0 instead.)
setzm firsti ;from here we do reinitialing that you needn't
setzm firsto ;understand
defans: ;This routine is called after all switch values have been scanned.
;It should check all of the locations in retblk. If any is still
;-1, it should be given a default value (unless you like -1).
;Note that PASCAL assumes that Booleans are 0 for false, 1 for true.
seto t0, ;t0 gets -1, as it will be compared to the switches
movei t1,1 ;t1 gets 1, for ease in setting things to 1
camn t0,asw ;is asw still -1?
setzm asw ;yes - default it to 0
camn t0,bsw ;is bsw still -1?
movem t1,bsw ;yes - default it to 1
came t0,csw ;is csw still -1?
jrst .+3 ;no - skip defaulting
movei reg,100 ;yes -default it to 100 octal
;This ends the section that most users will need to redefine. There
;are also a couple of things in tblk and oblk that you might want to
;play with, but probably not.
doscan(passw) ;defines symbols passwx - a macro in SCNMAC
tblk: iowd passwl,passwn
exp -1 ;or sixbit /name/ to define file name for /HELP
;-1 to use name of prog from GETTAB
exp 0 ;allows only one output file spec.
;use exp 1b18 to allow .gt. 1
;but if you turn on 1b18, it will require a =
oblk: iowd passwl,passwn
exp -1 ;as above
exp 0 ;or sixbit /option/ to define SWITCH.INI line
;0 to use name of progm from GETTAB
;Must be done once only, before doing tscan, etc. Returns index in
;comnds for monitor command typed, if any.
iscan:: movsi t1,2 ;length of block
movem t1,1(p) ;returned value goes in 1(p) for PASCAL
;Must be done once for each command line. Returns pointer to a
;record containing values of switches. retblkptr must be defined
;as ^retblk, where retblk is a record (not packed) whose definition
;matches the structure of retblk, above.
;File names are put in scan blocks, which are put in one contiguous
;part of the HEAP (i.e. NEW is used to allocate the space. Thus
;to save on core, you should do mark and release at the beginning
;and end of the main loop of your program.
;You must not do release and expect the scan blocks to still be there!!
;FSCAN will not known that you have done that, and as likely as not
;will return garbage.
tscan:: setzm firsti ;sign that no input file spec seen
setzm firsto ;ditto, output
move t1,.jbff## ;we put scan blocks at .jbff, temporarily, so
movem t1,oldff ; we will want to restore old .jbff at the end, to
; return that space
movsi t1,10 ;length of tblk
movsi t1,5 ;length of oblk
pushj p,defans ;user's routine to give default values for switches
;that are still -1
;We now have the scan blocks at .jbff. We want to move them to the heap, so
;That the space is recoverable (by release). Then we restore the original
;.jbff, which reclaims the temporary storage (though we don't release the
;core -- sorry, folks)
move t1,firsti ;skip to noin if no input blocks to move
move reg,lasti ;reg _ length of input blocks
addi reg,.fxlen ; we now have addr of end of last block+1
sub reg,t1 ; now have length
push p,reg ;new will lose this, and we want it for later
pushj p,new## ;get space of this length on heap
;reg is set to first location of the block
pop p,t1 ;length of block
addi t1,-1(reg) ;t1 _last location in block on heap
hrl reg,firsti ;reg _ firsti,,first location in heap
hrrzm reg,firsti;update firsti to point into heap
blt reg,(t1) ;now blt from .jbff area to heap
subi t1,.fxlen-1;t1 _ begin. of last block (in heap)
hrrzm t1,lasti ;that becomes new lasti
noin: move t1,firsto ;now we to the same for output blocks, if any
noout: move t1,oldff ;restore .jbff, since finished with temp storage
movei t1,retblk ;this is return pointer for PASCAL caller
setzm wptr ;tell wild we are restarting
;allin and allout are called by .tscan when it needs a place to put a
;scan block. They return the address in t1, length in reg. They just
;put it at .jbff and update .jbff. If this should overlap the heap,
;the NEW above will catch it, since .jbff is properly updated.
allin: move t1,.jbff## ;next location to use
skipn firsti ;see if firsti set up
movem t1,firsti ;no - do so
movem t1,lasti ;this is last input so far
;from here on we have common code for allin and allout
allall: move t0,t1 ;compute location for next time
addi t0,.fxlen ;length of a scan block
subi t0,1 ;end of this block
camg t0,.jbrel##;see if memory exists
jrst all1 ;yes
core t0, ;no - get it
all1: movei reg,.fxlen ;length of block
;t1 already has its address
allout: move t1,.jbff## ;as above, but for output
jrst allall ;now go to common section
wptr: z ;pointer to scan block currently in use by WILD
;The following routine is an example of a routine to open an input
;file. It supplies defaults for anything that is missing (except
;the path - SCAN defaults that to your default path, which seems to
;be what one wants). If the user does not type an extension, we
;first try the default extension. If there is no such file, we then
;try a null extension. We call ANALYS, so an appropriate error
;message is printed if the lookup fails. However the user must still
;examine EOF and realize that he will have to ask for another command
;line if EOF is true, since that means there was no such file.
; (NB: If the file exists but is empty, i.e. is of zero length,
;EOF will still be set initially. If it is desired to be able to
;handle zero-length files, the implicit get should be surpressed,
;as explained below. Then EOF will be set if and only if the file
;does not exist. However then the user will have to do an explicit
;GET after checking EOF.)
;The file will appear in REG
openin::movei t1,1 ;This specifies the first file spec on
;the input side. -1 is the first spec on
;the output side.
pushj p,getscn ;returns addr of scan block in t1
jrst noinsp ;no input spec typed
move t0,.fxmod(t1) ;word of useful bits from the scan block
;Delete the following code if you don't want to define a default device.
;If you delete it SCAN will supply DSK for you
move reg1,[sixbit /DEFDEV/] ;default device
tlne t0,(fx.ndv) ;user supplied no device?
movem reg1,.fxdev(t1) ;yes - use our default
;Delete the following if you don't want to define a default file name.
move reg1,[sixbit /DEFNAM/] ;default file name
skipe .fxnam(t1) ;user supplied name?
jrst .+3 ;yes - use his
movem reg1,.fxnam(t1) ;no - use ours
setom .fxnmm(t1) ;and specify no wildcards in it
;Delete the following if you don't want to define a default extension.
hrloi reg1,'DEF' ;default extension - no wildcards
tlne t0,(fx.nul) ;user typed one?
movem reg1,.fxext(t1) ;no - use ours
;The following code should always be present.
movei reg1,0 ;I/O mode - use this for ASCII, 16 for binary
setzm xbloc1+1 ;clear extended lookup block
move reg1,[xwd xbloc1+1,xbloc1+2]
movei reg1,xbloc1 ;address of extended lookup block for this file
pushj p,initfi ;t1 - addr of scan block
jrst oiwld ;reg - addr of file control block
;reg1 - addr of extended lookup block
;sets up the lookup block and file control block according to
;the file spec in the scan block
agn: setzb reg1,reg2 ;here we set up the args for the PASCAL open
setz reg3, ;use seto reg3, to surpress implicit GET
movei reg5,4 ;number of I/O buffers. Typically you will
;use 0 - which gives you default number
;The following push's and pop's are needed only if you want to retry with
;null extension if defaulted extension is not found. (See below.)
pushj p,resetf## ;Use resetf,rewrit, or update as appropriate
skipn fileof(reg) ;Did we find the file?
popj p, ;yes - return
;The following code analyses the error and retries with a null extension
;under the following conditions: (1) The user did not supply an extension
;(2) We did supply a default extension. If you don't default the extension
;all you need at this point is
; pjrst analys##
;Which will print an error message and return to the user.
hlrz t0,(reg) ;get the error code
skipn t0 ;something other than file not found?
skipn filext(reg) ;or null extension used (i.e. 2nd time around)
pjrst analys## ;just print message and return
move t0,.fxmod(t1) ;get bits from scan block
tlnn t0,(fx.nul) ;user defaulted extension?
pjrst analys## ;no - no need to retry
setzm filext(reg) ;yes - try null extension
oiwld: ;here if input spec has wild cards in it
outstr [asciz /
? Wild card in input file spec
noinsp: ;here if no input spec typed
outstr [asciz /
? No input file spec given
oierr: movni t0,10
movem t0,fileof(reg) ;set EOF so the user knows it failed
xbloc1: exp .lklen ;length of the extended lookup block
block .lklen ;the block itself
;The following routine is for openning a file whose defaults come from
;another file spec. Typcially this would be an output file. Note that
;this is appropriate for the output file of a compiler, etc., where
;wild is not used. If wild cards appear in the file specs, a different
;routine using the secondary wildcard logic (which is in WILD) should
;be used. Note that I do not show how to default the path or the device
;from the input, as this is not normally done in this context. To do
;it correctly would require using the PATH. UUO on the input channel
;to get the path, and getting the logical device from the input lookup
;block. Again, the user should check EOF after calling this function
;to see whether it worked. (For an output file, EOF will be true
;if it worked.) We print the error message if it fails, but the
;user will have to see that another command line is gotten.
;the address of the file control block will be in REG
openou::movni t1,1 ;first file on the output side
pushj p,getscn ;returns scanblock addr in t1
jrst defblk ;no spec typed - use default
gotdef: move t0,.fxmod(t1) ;get bits from scan block
;Delete the following code if you don't want to default the device
move reg1,[sixbit /DEFDEV/] ;default device
tlne t0,(fx.ndv) ;did he supply one?
movem reg1,.fxdev(t1) ;no - use default
;Delete the following code if you don't want to default the file name
move reg1,xbloc1+.rbnam ;input file name
;following two instructions needed only if you don't
;default the input name.
skipn reg1 ;is there one?
move reg1,[sixbit /DEFNAM/] ;no - use fixed default
skipe .fxnam(t1) ;user supplied output file name?
jrst .+3 ;yes - use it
movem reg1,.fxnam(t1) ;no - use default
setom .fxnmm(t1) ;and note that no wildcards
;Delete the following code if you don't want to default the extension
;Usually you will use only one of the following two methods of
hllo reg1,xbloc1+.rbext ;input file extension finally used
tlnn reg1,777777 ;is there any?
hrloi reg1,'DEF' ;no - use fixed default
tlne t0,(fx.nul) ;user supplied output file extension?
movem reg1,.fxext(t1) ;no - use default
;Delete the following code if you don't want to default the protection.
;This code uses the protection of the input file as the default. To
;use a fixed default, replace it with
; movei reg1,055 ;default protection.
;or movei reg1,0 for the system default protection (the usual case)
ldb reg1,[point 9,xbloc1+.rbprv,8] ;input file protection
move t0,.fxmom(t1) ;bits from output file spec scan block
trne t0,fx.pro ;protection specified?
jrst .+4 ;yes - use his
dpb reg1,[point 9,.fxmod(t1),35] ;no - use default
dpb reg1,[point 9,.fxmom(t1),35] ;and show we did so
;Delete the following code if you don't want to default the version
;number. To use a fixed default, use move reg1,[xxx] instead of
;the first instruction below
move reg1,xbloc1+.rbver ;use input version number as default
move t0,.fxver(t1) ;look at user's specified version no.
camn t0,[-1] ;did he set it?
movem reg1,.fxver(t1) ;no - use this one
;Delete the following code if you don't want to default the estimated
;file length from the length of the input. Actually this is a fairly
;unusual thing to do, though SOS does it.
move reg1,xbloc1+.rbsiz ;use input length as estimate
skipge .fxest(t1) ;unless user specified one
;The following code should always be used
movei reg1,0 ;mode - 0 for ascii, 16 for binary
setzm xbloc2+1 ;clear enter block
move reg1,[xwd xbloc2+1,xbloc2+2]
pushj p,initfi ;set up xtended enter block etc.
jrst oowld ;wild card in the spec - can't handle it
ldb reg3,[point 9,filpro(reg),8] ;or movei reg3 protection if
;want to used a fixed value
movei reg5,4 ;number of buffers. Usually use 0,
;which gives default
pushj p,rewrit## ;or resetf or update
pjrst analys ;print error if any and return to user
oowld: outstr [asciz /
? Wildcard in output file spec
setzm fileof(reg) ;set error indicator
defblk: ;here if no output spec typed. Use default scan block
move t0,[xwd nulpro,nulblk]
nulblk: block .fxlen
nulpro: sixbit /nul/ ;prototype for the default block
repeat 10,<exp -1>
xbloc2: exp .lklen ;length of block
;The following routines are used by the code above. You will not
;need to modify them (or even understand them).
getscn: ;serial number of file spec in t1. +n for nth input spec
;-n for nth output spec. Return addr of scan block in t1.
;skip return if find the specified file spec
;non-skip return if not enough typed (or t1=0)
;t0=last block user typed
;t1=counter for how many spec's . Count down to 0
;reg=spec being looked at now
cain t1,0 ;0 is illegal
jumpge t1,getin ;see if input or output
move reg,firsto ;here for output
getin: move reg,firsti ;here for input
getio: movm t1,t1 ;turn t1 into positive count
soje t1,getgot ;if 1, want the first spec
getlop: camn reg,t0 ;need another spec
jrst nospec ;this is last - not enough
addi reg,.fxlen ;go to next one
move reg1,.fxmod(reg) ;look at funny bits in the new spec
tlne reg1,(fx.trm) ;is it 'and', etc.?
jrst getlop ;yes - it doesn't count as a new spec
sojg t1,getlop ;got new spec - go for more if counter isn't to zero
getgot: move t1,reg ;have desired spec - get it in return reg
pop p,reg ;and restore ac's
aos (p) ;good retur
nospec: pop p,reg1 ;return if no such spec
pop p,reg ;may be error, or may just use a default
initfi: ;reg=addr of PASCAL file control block
;t1=addr of scan block
;reg1=addr of lookup/enter block
;sets up PASCAL file control block and lookup block
;given a scan block that has been defaulted
;skip return if successful
;non-skip return if not (means there were wildcards
; in the file spec)
aos (p) ;assume successful return
hrli t1,.fxlen ;length of scan block
movei reg,filsta(reg) ;open block
hrl reg1,(reg1) ;length of lookup/enter block
movei reg2,pathbl ;place to put path
pushj p,.stopb## ;converts scan block
sos -3(p) ;wildcards in file spec
;alternate entry to put stuff from the lookup block into
;the PASCAL file control block. Used when WILD has done
;the main conversion. Always returns non-skip.
cvblk: move t0,.rbnam(reg1) ;move other stuff from lookup block into
movem t0,filnam(reg) ; file control block
move t0,.rbppn(reg1) ;ppn or path pointer
caie t0,0 ;if zero
tlne t0,777777 ;or non-zero LH
jrst cvblk1 ;then it's simple
addi t0,2 ;else pointer - here is path
hrl t0,t0 ;now make it the source
hrri t0,filppn(reg) ;here is where path goes
blt t0,filppn+5(reg) ;now move it
cvblk1: movem t0,filppn(reg) ;if simple ppn, put it there
setzm filppn+1(reg) ;and clear next so no SFD's
pathbl: block 9
;The routine WILDIN is an example of a procedure for handling
;a list of files with wildcards and looking them all up. Each time
;you call WILDIN it will open a new file. It will return TRUE as
;long as there was another file. FALSE means you have come to the
;end of the list. Note that a return of TRUE does not necessarily
;mean that the lookup succeeded. You must still check EOF to be
;sure of that. However, if there was any trouble this routine has
;already printed an error message, so in most cases you just go on
;to the next file. There is little defaulting done in this routine.
;The only change you are likely to want to make is to modify it
;to read only one file spec instead of the whole input side, but even
;that doesn't seem likely. If you want a default device other than
;DSK:, you can mimic the code from OPENIN, above. Also, you will have
;to change a movei near the beginning if you want some I/O mode other
;than 0, and the stuff near the RESETF if you want other options for
;the RESET. (Note that here I specify 4 buffers. You may prefer to
;use zero, which gives the monitor default.)
;The file will appear in reg
wildin::move t1,firsti ;wild needs to know which scan blocks to use
;here we will say all on the input side
jumpe t1,widon ;none - treat it as an empty list
;alternatively, if you wanted just one file spec, you would use
; movei t1,1 ;first file spec on the input side
; pushj p,getscn
; jrst widon
; movem t1,wfirst ;addr of scan block for that file spec
; setzm wlast ;a zero means use just one file spec
hrlm t1,wblk+1 ;tell WILD where the OPEN block is
push p,reg ;because of loop below
wiagn: pop p,reg
movei t1,0 ;I/O mode
movem t1,filsta(reg) ;put it in the open block - must be done
setzm wxblk+1 ;clear lookup block
move t1,[xwd wxblk+1,wxblk+2]
move t1,[xwd 5,wblk] ;each time, as WILD may change it
jrst widon-1 ;here if no more files
movei reg1,wxblk ;extended lookup block
pushj p,cvblk ;puts the info WILD set up in the PASCAL file
setzb reg1,reg2 ;now we set up for the RESET
setz reg3, ;use seto reg3, to suppress the implicit GET
movei reg5,4 ;number of buffers - 0 for default
pushj p,resetf## ;open and lookup the file
skipe fileof(reg) ;worked?
jrst wilker ;no - analyse the error
pushj p,.chktm## ;yes - see if OK with /SINCE, etc.
jrst wiagn ;no - try the next one
setom 1(p) ;yes - successful return
wilker: hlrz t0,(reg) ;here if RESET failed. Get cause
movei t1,analys## ;The default error analyzer
cain t0,^D101 ;open failed
movei t1,e.dfo## ;WILD's open failure printer
caige t0,^D100 ;lookup failed
movei t1,e.dfl## ;WILD's lookup failure printer
setom 1(p) ;Successful return (there was a file)
pop p,reg ;entry for when reg was saved
widon: setzm 1(p) ;here when no more files - return false
setom fileof(reg) ;and set end of file
wblk: xwd wfirst,wlast
xwd .fxlen,.lklen ;length of lookup block below
wxblk: exp .lklen ;extended lookup block
;The following is a routine for handling "secondary" files, i.e. files
;whose names are a function of the input file name. For example in
;the command *.doc=*.rno the .doc file is secondary to the .rno files.
;For each .rno file we produce a (hopefully) different .doc file.
;Thus this routine takes two inputs: The file spec for the secondary
;file (*.doc in this case) and that for the primary file that is to be
;the source of the names. Note that this routine is connected to the
;one above directly, in that it knows about the lookup block that WILDIN
;uses. It would not really be necessary to do any defaulting here, but
;most people don't like the way WILD handles wildcards in secondary files.
;One is accustomed to saying DSKB:=*.sai. This turns into DSKB:*.*=*.sai,
;which gives an error message because there are more wildcards on the
;left than on the right. As a convenience, I supply a defaulter below
;that simply copies the input spec into the output when no file name or
;extension is given. I also tell you how to supply a default extension
;for the output, which is useful in many applications. You can tell
;whether this routine succeeded by looking at EOF. It will be true
;(since this is for output) if the thing succeeds. An error message
;will be printed if anything goes wrong.
;the primary file will be in reg1, secondary in reg1. Note that it is
;the secondary that is actually being openned. The primary is merely
;the source of defaults.
wildou::movni t1,1 ;use the first spec on the output side
pushj p,getscn ;returns addr of scan block in t1
movei t1,nulpro ;if none there, use default block
;The following code establishes various defaults. It may be completely
;skipped if you like. The thing just below with the BLT should be used
;if any defaulting is done, so that the original scan block is not
;changed, but rather a copy is used.
hrl t1,t1 ;source of copy
hrri t1,nulblk ;this is an empty place to copy it to
blt t1,nulblk+.fxlen-1 ;now copy it
movei t1,nulblk ;now we use the copy
move reg1,wptr ;this is the scan block currently being
;used by wild, and is the source for
;some of the defaults.
move t0,.fxmod(t1) ;the usual word of bits from scan block
;delete the following if you don't want to default the device
move reg2,[sixbit /DEFDEV/]
tlne t0,(fx.ndv) ;did he specify device?
movem reg2,.fxdev(t1) ;no - use default
;delete the following if you don't want to copy the input spec as default
;for name. Of course you could also have a fixed default name as with
;OPENOU above, but you normally wouldn't use wild to handle that.
skipe .fxnam(t1) ;name specified?
jrst .+5 ;yes - use it
move reg2,.fxnam(reg1) ;no - copy from input scan block
move reg2,.fxnmm(reg1) ;mask word
;delete the following if you don't want to copy the input spec as default
tlnn t0,(fx.nul) ;extension specified?
jrst .+5 ;yes - use it
move reg2,.fxext(reg1) ;input spec
skipn reg2 ;is it null?
hrlzi reg2,'* ' ;yes - must use this on output to match
;or to use a fixed default extension you would use the following code
; hrloi reg2,'DEF'
; tlne t0,(fx.nul)
; movem reg2,.fxext(t1)
;delete the following if you don't want to use the input version number
move reg2,wxblk+.rbver ;version no. of input file
move t0,.fxver(t1) ;his version no. spec
camn t0,[-1] ;default?
movem reg2,.fxver(t1) ;yes - use input instead
;delete the following if you don't want to use the input length as an
;estimate of the output file length. This is fairly unusual.
move reg2,wxblk+.rbsiz ;input file length
skipge .fxest(t1) ;specified anything?
movem reg2,.fxest(t1) ;no - use default
;The code following here is always used, whether defaulting or not.
movem t1,sfirst ;addr of secondary scan block
pop p,reg1 ;restore the PASCAL file block for pri. file
movei t0,0 ;I/O mode - this is ASCII
hrrm t0,sblk+1 ;store addr of OPEN block for WILD
setzm sxblk+1 ;clear enter block
move t1,[xwd sxblk+1,sxblk+2]
move t1,[xwd 4,sblk]
push p,filbfp(reg) ;.scwld zeros this for us - nice, huh?
pushj p,.scwld## ;does all the wild card fixups
jrst woerr ;couldn't convert names somehow
movei reg1,sxblk ;now we convert to PASCAL file block
setzb reg1,reg2 ;prepare for REWRITE
ldb reg3,[point 9,filpro(reg),8] ;or movei reg3,0 for monitor default
movei reg5,4 ;no. of buffers. 0 for monitor default
skipe fileof(reg) ;did it work?
popj p, ;yes
hlrz t0,(reg) ;no - find cause
cain t0,^D101 ;OPEN failed
pjrst e.sco## ;wild's open failure printer
caige t0,^D100 ;ENTER failed
pjrst e.scl## ;wild lookup failure printer
pjrst analys## ;otherwise use normal printer
woerr: pop p,reg ;here if problem with wildcards
setzm fileof(reg) ;tell him it didn't work
sblk: xwd wptr,sfirst
xwd 0,.lklen ;length of lookup blocks
sxblk: exp .lklen ;extended enter block
;Here follows a routine to print the name of the last file used
;on the TTY:. Note that it is potentially usable to print any
;file spec you might want to, just by changing a couple of
;instructions at the beginning. Also, should you need the name
;in a string, you could open a file on the string with strset,
;and then redefine SCANs character output routine to use
;PUTCH. This can be done by calling .TYOCH## See the SCAN
typein::hrl t1,wptr ;source is the current block being
;used by WILD. This could be any
hrri t1,nulblk ;a convenient working space
movei reg,wxblk ;this is the lookup block being used
;by WILD. It could be any lookup
;block, so long as it was used with
;the SCAN block loaded above.
skipn t1,.rbdev(reg) ;get real device
jrst .+7 ;none - use what we have
movem t1,dcblk ;this is physical name - get logical
move t0,[xwd 5,dcblk] ;using dskchr
movem t1,dcblk+4 ;not a disk - use what we have
skipe t1,.rbnam(reg) ;get real name found
movem t1,.fxnam+nulblk ;and use it
hllz t1,.rbext(reg) ;get real extension
move t1,.rbppn(reg) ;see if we have a better PPN
movem t1,.fxdir+nulblk ;yes - use it
setom .fxdir+1+nulblk ;say no wildcards
movei t1,nulblk ;arg for routine
pjrst .tfblk## ;part of SCAN
dcblk: block 5 ;block for dskchr