home *** CD-ROM | disk | FTP | other *** search
/ ftp.barnyard.co.uk / 2015.02.ftp.barnyard.co.uk.tar / ftp.barnyard.co.uk / cpm / walnut-creek-CDROM / CPM / BDOS / NOVADOSI.LBR / NVDS-4.ZZ0 / NVDS-4.Z80
Text File  |  2000-06-30  |  16KB  |  580 lines
  1. ;
  2. ; Write sequential
  3. ;
  4. cmnd21:    call    seldrv            ; Select drive from FCB
  5. ;
  6. ; Write sector
  7. ;
  8. writes:    ld    a,0ffh            ; Set read/write flag
  9.     ld    (rdwr),a        ; And save it
  10.     call    chkro            ; Check disk r/o
  11.     push    ix            ; Save FCB pointer
  12.     pop    hl            ; Get it back in hl
  13.     call    chkfr0            ; Check file r/o
  14.     ld    a,(ix+32)        ; Get record count
  15.     cp    080h            ; Test if end this extent
  16.     jr    c,writs0        ; Yes then open next extent
  17.     call    openex            ; Open next extent
  18.     ld    a,(pexit)        ; Get error code
  19.     or    a        
  20.     jp    nz,writs9        ; Error then directory full error
  21.     ld    (ix+32),a        ; Clear record counter
  22. writs0:    call    getdm            ; Get block number from FCB
  23.     ld    a,d            ; Test if block number = 0
  24.     or    e
  25.     jr    nz,writs5        ; No then write sector
  26.     push    hl            ; Save pointer to block number
  27.     ld    a,c            ; Test first block number in extent
  28.     or    a
  29.     jr    z,writs1        ; Yes then jump
  30.     dec    a            ; Decrement pointer to block number
  31.     call    getdm4            ; Get previous blocknumber
  32. writs1:    call    getfre            ; Get nearest free block
  33.     pop    hl            ; Get pointer to block number
  34.     ld    a,d            ; Test if blocknumber = 0
  35.     or    e
  36.     jp    z,writs8        ; Yes then disk full error (jr without archive routines. L.h.)
  37.     res    7,(ix+14)        ; Reset FCB/file modified
  38.     ld    (hl),e            ; Save blocknumber
  39.     ld    a,(maxlen+1)        ; Get number of blocks
  40.     or    a            ; Test if <256
  41.     jr    z,writs2        ; Yes then jump
  42.     inc    hl            ; Increment to MSB block number
  43.     ld    (hl),d            ; Save MSB block number
  44. writs2:    ld    c,2            ; Set write new block flag
  45.     ld    a,(funct)        ; Get function number
  46.     sub    40            ; Test if write rr with zero fill
  47.     jr    nz,writs6        ; No then jump
  48.     push    de            ; Save blocknumber
  49.      ld    hl,(dirbuf)        ; Use directory buffer for zero fill
  50.     ld    b,128            ; 128 bytes to clear
  51. writs3:    ld    (hl),a            ; Clear directory buffer
  52.     inc    hl            ; Increment pointer
  53.     djnz    writs3            ; Clear all bytes
  54.     call    calsec            ; Calculate sector number (128 bytes)
  55.     ld    a,(nmask)        ; Get sector mask
  56.     ld    b,a            ; Copy it
  57.     inc    b            ; Increment it to get number of writes
  58.     cpl                ; Complement sector mask
  59.     and    e            ; Mask sector number
  60.     ld    e,a            ; And save it
  61.     ld    c,2            ; Set write new block flag
  62. writs4:    push    hl            ; Save registers
  63.     push    de
  64.     push    bc
  65.     call    calst            ; Calculate sector/track
  66.     call    dmadir            ; Set DMA directory buffer
  67.     pop    bc            ; Get write new block flag
  68.     push    bc            ; Save it again
  69. ;       res    7,(ix+11)        ; Reset the archive bit (l.h.)
  70.     call    writer            ; Write record on disk
  71.     pop    bc            ; Restore registers
  72.     pop    de
  73.     pop    hl
  74.     ld    c,a  ;writer sets a=0    ; Clear write new block flag
  75.     inc    e            ; Increment sector number
  76.     djnz    writs4            ; Write all blocks
  77.     call    stdma            ; Set user DMA address
  78.     pop    de            ; Get block number
  79. writs5:    ld    c,0            ; Clear write new block flag 
  80. writs6:    res    7,(ix+14)        ; Reset FCB/file modified flag
  81.     push    bc            ; Save it
  82.     call    calsec            ; Calculate sector number (128 bytes)
  83.     call    calst            ; Calculate sector/track
  84.     pop    bc            ; Get write new block flag
  85.     call    writer            ; Write record on disk
  86.     bit    7,(ix+11)        ; Archive bit set? (l.h.)
  87.     jr    z,noarc            ; If not, don't jump
  88.     res    7,(ix+11)         ; Reset the archive bit
  89.     call    cstat            ; Do it for all extents
  90. ;    xor    a            ; Make a null. Cstat returns a=0
  91.     ld    (pexit),a        ; Error code null on return to caller
  92. noarc:    ld    a,(ix+32)        ; Get record counter
  93.     cp    (ix+15)            ; Compare with next record
  94.     jr    c,writs7        ; If less then jump
  95.     inc    a            ; Increment record count 
  96.     ld    (ix+15),a        ; Save it on next record position
  97.     res    7,(ix+14)        ; Reset FCB/file modified flag
  98. writs7:    ld    a,(funct)        ; Get function number
  99.     cp    21            ; Test write sequential
  100.     ret    nz            ; Not then return
  101.     inc    (ix+32)            ; Increment record count
  102.     ret                ; And return to caller
  103. writs8:    ld    a,2            ; Set disk full error
  104.     ld    (pexit),a
  105.     ret                ; And return to caller
  106. writs9:    ld    a,1            ; Set directory full flag
  107.     ld    (pexit),a
  108.     ret                ; And return to caller
  109. ;
  110. ; Load FCB for random read/write
  111. ;  exit : zero flag : 1 no error
  112. ;                     0 error occured
  113. ;
  114. ldfcb:    ld    (rdwr),a        ; Save read/write flag
  115.     ld    a,(ix+33)        ; Get first byte random record
  116.     ld    d,a            ; Save it in d
  117.     res    7,d            ; Reset MSB to get next record
  118.     rla                ; Shift MSB in carry
  119.     ld    a,(ix+34)        ; Load next byte random record
  120.     rla                ; Shift carry
  121.     push    af            ; Save it
  122.     and    01fh            ; Mask next extent
  123.     ld    c,a            ; Save it in c
  124.     pop    af            ; Get byte
  125.     rla                ; Shift 4 times
  126.     rla
  127.     rla
  128.     rla
  129.     and    0fh            ; Mask it
  130.     ld    b,a            ; Save FCB+14
  131.     ld    a,(ix+35)        ; Get next byte random record
  132.     ld    e,6            ; Set random record to large flag
  133.     cp    4            ; Test random record to large 
  134.     jr    nc,ldfcb8        ; Yes then error
  135.     rlca                ; Shift 4 times
  136.     rlca
  137.     rlca
  138.     rlca
  139.     add    a,b            ; Add byte
  140.     ld    b,a            ; Save FCB+14 in b
  141.     ld    (ix+32),d        ; Set next record count
  142.     ld    d,(ix+14)        ; Get FCB+14
  143.     bit    6,d            ; Test error random record
  144.     jr    nz,ldfcb0        ; Yes then jump
  145.     ld    a,c            ; Get new extent number
  146.     cp    (ix+12)            ; Compare with FCB
  147.     jr    nz,ldfcb0        ; Not equal then open next extent
  148.     ld    a,b            ; Get new FCB+14
  149.     xor    (ix+14)            ; Compare with FCB+14
  150.     and    03fh            ; Mask it
  151.     jr    z,ldfcb6        ; Equal then return
  152. ldfcb0:    bit    7,d            ; Test FCB modified (write)
  153.     jr    nz,ldfcb1        ; No then jump
  154.     push    de            ; Save registers
  155.     push    bc
  156.     call    close            ; Close extent
  157.     pop    bc            ; Restore registers
  158.     pop    de
  159.     ld    e,3            ; Set close error
  160.     ld    a,(pexit)        ; Get exit code
  161.     inc    a
  162.     jr    z,ldfcb7        ; Error then exit
  163. ldfcb1:    ld    (ix+12),c        ; Save new extent number
  164.     ld    (ix+14),b        ; Save new FCB+14
  165.     bit    7,d            ; Test FCB modified (previous FCB)
  166.     jr    nz,ldfcb3        ; No then jump
  167. ldfcb2:    ld    a,15            ; Set number of bytes to search for
  168.     call    search            ; Search next FCB
  169.     jr    ldfcb4            ; Jump
  170. ldfcb3:    bit    7,(ix+10)        ; Test if system file
  171.     jr    z,ldfcb2        ; No use search
  172.     call    findf            ; Open file (use path name)
  173. ldfcb4:    ld    a,(pexit)        ; Get error code
  174.     inc    a
  175.     jr    nz,ldfcb5        ; No error then exit
  176.     ld    a,(rdwr)        ; Get read/write flag
  177.     ld    e,4            ; Set read empty record
  178.     inc    a
  179.     jr    nz,ldfcb7        ; Read then error
  180.     call    make            ; Make mew FCB
  181.     ld    e,5            ; Set make error
  182.     ld    a,(pexit)        ; Get error code
  183.     inc    a
  184.     jr    z,ldfcb7        ; Error then exit
  185.     jr    ldfcb6            ; No error exit (zero set)
  186. ldfcb5:    call    openf0            ; Open file
  187. ldfcb6:    xor    a            ; Set zero flag and clear error code
  188.     ld    (pexit),a
  189.     ret                ; And return to caller
  190. ldfcb7:    ld    (ix+14),0c0h        ; Set random record error
  191. ldfcb8:    ld    a,e            ; Get error code
  192.     ld    (pexit),a        ; And save it
  193.     set    7,(ix+14)        ; Set FCB/file not modified
  194.     or    a            ; Clear zero flag
  195.     ret                ; And return to caller
  196. ;
  197. ; Calculate random record
  198. ;  entry hl = offset in FCB
  199. ;        de = FCB pointer
  200. ;
  201. ;  exit  d  = LSB random record
  202. ;        c  = ISB random record
  203. ;        b  = MSB random record
  204. ;
  205. calrrc:    add    hl,de            ; Pointer to FCB+15 or FCB+32
  206.     ld    a,(hl)            ; Get byte
  207.     ld    hl,12            ; Offset to extent number
  208.     add    hl,de            ; Get pointer to extent byte
  209.     ld    d,a            ; Save first byte
  210.     ld    a,(hl)            ; Get extent byte
  211.     and    01fh            ; Mask it
  212.     rl    d            ; Shift MSB in carry
  213.     adc    a,0            ; Add carry
  214.     rra                ; Shift 1 time (16 bits)
  215.     rr    d
  216.     ld    c,a            ; Save ISB
  217.     inc    hl            ; Increment to FCB+14
  218.     inc    hl
  219.     ld    a,(hl)            ; Get FCB+14
  220.     rrca                ; Shift 4 times
  221.     rrca
  222.     rrca
  223.     rrca
  224.     push    af            ; Save it
  225.     and    03h            ; Mask MSB
  226.     ld    b,a            ; Save it
  227.     pop    af            ; Get LSB
  228.     and    0f0h            ; Mask it
  229.     add    a,c            ; Add with ISB
  230.     ld    c,a            ; Save ISB
  231.     ret    nc            ; No carry then return
  232.     inc    b            ; Increment MSB
  233.     ret                ; And return to caller
  234. ;
  235. ;
  236. ; Get/Set Flags Byte
  237. ;
  238. setflag:
  239.     ld    hl,flags        ; Get old flags byte
  240.     or    a            ; A=0 means get flags
  241.     jr    nz,sflg1        ; If not, then get/set
  242.     ld    a,(hl)            ; Load flags
  243.     ld    (pexit),a        ; to exit buffer
  244.     ret                ; and go home
  245. ;
  246. sflg1:    bit    7,a            ; Test of setting or resetting
  247.     res    7,a            ; Reset the set/reset bit
  248.     jr    z,sflg2            ; Jump if resetting
  249.     or    (hl)            ; Set
  250.     ld    (hl),a            ; and save
  251.     ret    
  252. sflg2:    cpl                ; Complement flags byte
  253.     and    (hl)            ; Reset
  254.     ld    (hl),a            ; and save
  255.     ret
  256.  
  257.      if    pathcall and ispath
  258. ;
  259. ; Get/Set Path Address
  260. ;
  261. setpath:
  262.     ld    a,d
  263.     or    e
  264.     jr    z,getpath
  265.     ld    (path),de
  266.     ret
  267. getpath:
  268.     ld    hl,(path)
  269.     ld    (pexit),hl
  270.     ret
  271.      endif    ; pathcall
  272.  
  273.      if    hifuncs
  274. ;
  275. ; Set Warm Boot Trap
  276. ;
  277. wbtrap:    
  278.     ld    (trap),de
  279.     ld    a,0ffh
  280.     jr    gotrap        ; Set the trap flag for wbtres
  281.  
  282. ;
  283. ; Reset Warm Boot Trap
  284. ;
  285. wbtres:    ld    hl,ramlow
  286.     ld    (trap),hl
  287.     xor    a
  288. gotrap:    ld    (trapflag),a
  289.     ret
  290.      endif    ; hifuncs
  291.  
  292. ;
  293. ; Relocate code
  294. ; 
  295. ; SPR type Relocator
  296. ; =================
  297. ; 
  298. ; Bridger Mitchell's  Word-wide relocator starts here.. Modified to work in
  299. ; DOS with relocation control block. The relocation control block has the
  300. ; format:
  301. ;
  302. ;    defw    codeadrs    ; Address of code to move and address adjust
  303. ;    defw    newadrs        ; Address to which to move code
  304. ;    defw    offset        ; Offset to add to relative addresses
  305. ;    defw    size        ; Size of code
  306. ;    defw    bitmap        ; Pointer to SPR type relocation bitmap
  307. ;
  308. ;
  309.      if    relfunc
  310. cmnd38:    di            ; Disable interrupt system
  311.     ex    de,hl        ; HL -> relocation control block
  312.     ld    (recdir),sp    ; Save stack pointer in free buffer
  313.     ld    sp,hl        ; SP -> relocation control block
  314.     pop    hl        ; HL has address of code
  315.     pop    de        ; DE has new address of code
  316.     push    de        ; Save it away
  317. ;
  318.     exx             ; Select alternate registers
  319.     pop    hl        ; HL -> new code
  320.     pop    de        ; DE' has offset for address adjustment
  321.     exx            ; Select main registers
  322. ;
  323.     pop    bc        ; BC = size of code
  324.     push    bc        ; Save it
  325.     or    a        ; Clear carry
  326.     sbc    hl,de        ; Test if new address higher than old
  327.     jr    c,rel2        ; If smaller (nc), then use LDIR
  328.     add    hl,de        ; Add restore HL -> old code, DE -> new
  329.     ldir            ; Move code, buttom up
  330.     jr    rel3
  331. rel2:    add    hl,de        ; Restore pointers to old and new
  332.     add    hl,bc        ; Offset to end of old code
  333.     ex    de,hl        ; Exchange old and new addresses
  334.     add    hl,bc        ; Offset to end of new code
  335.     ex    de,hl        ; HL -> end of old, DE -> end of new
  336.     dec    de        ; Move from past end to end
  337.     dec    hl        ; Save for source
  338.     lddr            ; Move from the top down
  339. rel3:    pop    bc        ; BC = size of code again
  340.     pop    de        ; DE -> bitmap
  341.     exx            ; Exchange to get start of moved code in HL
  342.     ld    sp,hl        ; Sp -> start of moved code, lag 1 byte
  343.     exx
  344.     dec    sp        ; ..because prl marks the high byte
  345.     ex    de,hl        ; HL -> bitmap, DE is surplus
  346.     ld    e,1        ; Init the rotation byte
  347.                 ; It will set CY every 8 bytes
  348. ; Main relocation loop..
  349.  
  350. rloop:    ld    a,b        ; Check byte count
  351.     or    c
  352.     jr    z,rdone        ; Return to MLOAD caller
  353.  
  354.     dec    bc        ; Reduce byte count
  355.     rrc    e        ; Every 8 bits the CY is set
  356.     jr    nc,same        ; ..not set
  357.  
  358.     ld    d,(hl)        ; Set d = next byte from bitmap
  359.     inc    hl        ; And advance bitmap pointer
  360.  
  361. same:    rlc    d        ; Shift bitmap byte left into CY
  362.     jr    nc,noof        ; No relocation needed
  363.  
  364.     exx            ; Alternate registers
  365.     pop    hl        ; Get word to relocate from 'stack'
  366.     add    hl,de        ; Add the load address in DE'
  367.     push    hl        ; Put it back
  368.     exx            ; Main registers
  369.  
  370. noof:    inc    sp        ; -> next byte of code
  371.     jr    rloop
  372.  
  373. rdone:    
  374.     ld    sp,(recdir)    ; Restore the stack pointer
  375.     ei            ; And permit interrupts again
  376.     ret            ; Return to caller
  377.      endif
  378. ;
  379. ;
  380. ; Set time and date
  381. ;  entry: e : 1 : set creation time/date
  382. ;             5 : set last update time/date
  383. ;  time return pointer in hl
  384. ;   hl+0 : low  byte date since Jan,1,1978
  385. ;   hl+1 : high byte date since Jan,1,1978
  386. ;   hl+2 : hours   (bcd)
  387. ;   hl+3 : minutes (bcd)
  388. ;   hl+4 : seconds (bcd) (not used in time stamp)
  389. ;    
  390.     if    dotime
  391. stime:    ld    hl,(dirbuf)        ; Get directory entry
  392.     ld    bc,060h            ; Offset entry point time/date stamp
  393.     add    hl,bc            ; Add offset
  394.     ld    a,(hl)            ; Get byte
  395.     sub    021h            ; Test if time stamp present
  396.     ret    nz            ; No then return
  397.     ld    d,a            ; Clear d
  398.     add    hl,de            ; Add entry (update/create)
  399.     ld    a,(secpnt)        ; Get sector pointer
  400.     rrca                ; Shift 2 times
  401.     rrca
  402.     ld    e,a            ; Save it
  403.     rrca                ; Shift 2 times
  404.     rrca
  405.     add    a,e            ; Add it (a=0,10,20)
  406.     ld    e,a            ; Save in e
  407.     add    hl,de            ; Add offset
  408.     push    hl            ; Save result
  409.     ld    c,0            ; Return pointer in hl
  410.                     ; c=ff means set date pointed to by hl
  411.     call    btime            ; Return pointer in hl
  412.     pop    de            ; Get pointer
  413.     ld    bc,4            ; Set 4 bytes
  414.     ldir                ; Copy 4 bytes
  415.     ret                ; And return to caller
  416. ;
  417. ; Get time
  418. ;
  419. gettim:    push    de            ; Save address to put time 
  420.     ld    c,0            ; Get time address
  421.     call    btime            ; Execute P2bios call
  422.     pop    de            ; Restore address to put time
  423.     ld    bc,5            ; 5 bytes to move
  424.     ldir                ; Store the time
  425.     ret                ; And return to caller
  426. ;
  427. ; Set time
  428. ;
  429. settim:    ex    de,hl            ; Get address time in hl 
  430.     ld    c,0ffh            ; Set time address
  431.                     ; and fall through to P2bios call 
  432. ;
  433. ; Execute P2bios time routine
  434. ;
  435. btime:    push    hl            ; Save value in hl
  436.     ld    hl,(timead)        ; Get address time routine
  437.     ex    (sp),hl            ; Put address on stack and restore hl
  438.     ret                ; Execute time routine
  439. ;
  440.     endif    
  441. ;
  442. ; P2dos exit routine
  443. ;
  444. p2exit:    ld    a,(fldrv)        ; Test drive select used flag
  445.     or    a            
  446.     jr    z,p2ext0        ; No then exit
  447.     ld    a,(FCB0)        ; Get FCB byte 0
  448.     ld    (ix+0),a        ; Save it
  449.     ld    a,(drive)        ; Get old drive number
  450.     call    seldk            ; Select disk
  451. p2ext0:    push    ix            ; Save ix
  452.     pop    de            ; Restore de
  453.      if    relfunc            ; If using relocation function
  454.     exx
  455.     pop    de            ; Restore alternate registers
  456.     pop    hl
  457.     exx
  458.      endif
  459.     pop    ix            ; Restore ix
  460.     ld    sp,(spsave)        ; Get old sp
  461.     ld    hl,(pexit)        ; Get exit code
  462.     ld    a,(funct)        ; Get function code
  463.     ld    c,a            ; Restore c
  464.     ld    a,l            ; Copy function code
  465.     ld    b,h
  466.     ret                ; And return to caller
  467. ;
  468. ; Ram area
  469. ;
  470. tabcnt:    db    0            ; Tab counter
  471. tabcx1:    db    0            ; Temporary tab counter (used by rdbuf)
  472. fcontp:    db    0            ; List enable flag (control p)
  473. lastch:    db    0            ; Last character
  474. delay:    db    0ffh            ; Delay counter
  475. ;
  476. trapflag:    db    0        ; Warm boot trap flag
  477. ;
  478. trans:    defw    0            ; Translation vector
  479. temp0:    defw    0            ; Number of files on drive 
  480. dirbuf:    defw    0            ; Directory buffer
  481. ixp:    defw    0            ; Disk parameter block
  482. csv:    defw    0            ; Check sum pointer
  483. alv:    defw    0            ; Allocation vector pointer
  484. ;
  485. maxsec:    defw    0            ; Maximum number of sectors/track
  486. nblock:    db    0            ; Number of blocks
  487. nmask:    db    0            ; Mask number of blocks
  488. nextnd:    db    0            ; Extent mask
  489. maxlen:    defw    0            ; Maximum block number-1
  490. nfiles:    defw    0            ; Maximum number of files-1
  491. ndir0:    db    0            ; First two entries alv buffer
  492. ndir1:    db    0
  493. ncheck:    defw    0            ; Number of checksum entruies
  494. nftrk:    defw    0            ; First track number
  495. ;
  496. dskro:    defw    0            ; Disk r/o vector
  497. login:    defw    0            ; Login vector
  498.      if     hifuncs
  499. pmedia:    defw    0            ; Permanent media vector
  500.      endif
  501. dma:    defw    080h            ; DMA address
  502. ;
  503. funct:    db    0            ; Function number
  504. pexit:    defw    0            ; Exit code
  505. ; The next two must remain together (l.h.)
  506. retflg:    db    0            ; Allows recovery from read/write errors 
  507. fldrv:    db    0            ; Drive select used flag
  508. ; The next two must remain together (l.h.)
  509. passfg:    db    0            ; Pass attrib check on extent > 0
  510. rdwr:    db    0            ; Read/write flag
  511. ;
  512. FCB0:    db    0            ; FCB byte 0
  513. user:    db    0            ; User number
  514. drive:    db    0            ; Drive number
  515. defdrv:    db    0            ; Default drive number
  516. recdir:    defw    0            ; Record directory (checksum)
  517. filcnt:    defw    0            ; File counter
  518. secpnt:    db    0            ; Sector pointer
  519. subflg:    db    0            ; Submit flag (reset disk command)
  520. ;
  521. dcopy:    defw    0            ; Copy address FCB
  522. searex:    db    0            ; Exit code search
  523. searnb:    db    0            ; Search number of bytes
  524. searqu:    db    0            ; Search question mark used
  525. searpu:    db    0            ; Search public file
  526. ;
  527. ; Next flag added by b.h.
  528. ;
  529. diff:    db    0            ; Disk changed flag
  530. ;
  531. spsave:    defw    0            ; Stack pointer location
  532.      if    exstack
  533. p2doss    equ    exstack
  534.      else
  535.     defs    36,0            ; 36 byte stack
  536. p2doss:        
  537.      endif                ; P2dos stack
  538. dosstop    equ    $
  539.         if z33adr or intadr
  540.     .dephase
  541.         endif
  542. ;
  543.  
  544. dossiz    equ    dosstop-dosstrt
  545.  
  546.     .printx ..
  547.     if    (dossiz gt 3584)
  548. oversiz    equ    (dosstop-dosstrt)-3584
  549.     .printx ..
  550.     .printx *=====================================*
  551.     .printx =***  B D O S   T O O   L A R G E  ***=
  552.     .printx *=====================================*
  553.     .printx ..
  554.     prtval    16,<DOS size......>,dossiz,<hex bytes>
  555.      if    oversiz gt 99
  556.     prtval    10,<Excess.........>,oversiz,<bytes>
  557.      else    ;oversiz < 100
  558.      if    oversiz gt 9
  559.     prtval    10,<Excess..........>,oversiz,<bytes>
  560.      else    ;oversiz <10
  561.     prtval    10,<Excess...........>,oversiz,<bytes>
  562.      endif    ;oversiz > 9
  563.      endif    ;oversiz > 99
  564.  
  565.     else    ; If DOS size is OK
  566.     
  567. freesiz    equ    3584-dossiz
  568.     prtval    16,<DOS size......>,dossiz,<hex bytes>
  569.      if    freesiz gt 99
  570.     prtval    10,<Free space.....>,freesiz,<bytes>
  571.      else    ;freesiz < 100
  572.      if    freesiz gt 9
  573.     prtval    10,<Free space......>,freesiz,<bytes>
  574.      else    ;freesiz <10
  575.     prtval    10,<Free space.......>,freesiz,<bytes>
  576.      endif    ;freesiz > 9
  577.      endif    ;freesiz > 99
  578.     endif
  579.     .printx ..
  580.