const
    messageline = 23;
    statusline = 3;
    short  = 1000; { delays for pauses }
    medium = 2000;
    long   = 3000;
    buffersize = $3000; { 12k buffer space }
    MAXTRIES   = 2;     { number of times to try diskio before giving up }
    maxdirs    = $400;  { maximum number of directory entries }
    drivemax   = 4;
    getintrp   = $35;   { dos 21 int functions }
    setintrp   = $25;

    disktable  = $1E;   { disk parameter block has address stored here }
    equip      = $11;

    diskio     = $13;   { does the dirty work }
    diskreset  = $00;   { put one of these in ah for intr $13 }
    diskstatus = $01;
    diskread   = $02;
    diskwrite  = $03;
    diskverify = $04;
    diskformat = $05;
    onesector  = $01;  { in al }
    phys       : array[0..3] of integer = (128,256,512,1024);
    carryflag  = $01;

    MAXsector  = 40;   { max sector number on a track }
    driveflag  = $00c1 ;
illegal : set of char = [' ','<','>','+','=','"','''','{','}',']','[',')','('];
type
   buffertype= array[0..buffersize] of byte;
   bufferptr = ^buffertype;
   anystring = string[255];
   nstring = string[64]; { suitable for DOS,CP/M names }
   paramptr = ^params;
   params = record     { disk parameter block }
                       { don't change for 512 byte disks }
              dmode1 : byte;
              dmode2 : byte;
              clocktick : byte;
              bytesector : byte; { 0..3 128..512 }
              lastsector : byte;
              gaplen : byte;
              datalen : byte;
              gaplenformat : byte;
              formatchar : byte;
              headsettle : byte;
              motorstart : byte;
            end;

cpmdpb  =  record  { standard CP/M disk parameters }
            spt : integer;
            bsh : byte;
            blm : byte;
            exm : byte;
            dsm : integer;
            drm : integer;
            all01 : integer;
            cks   : integer;
            off   : integer;
            end;

heathext =  record { header on label before the dpb }
           ver   : byte;
           typef : byte;
           select: byte;
           rps   : byte;  { cpm sectors / physical sector }
           rab   : byte;  { cpm sectors / allocation block }
           trk   : byte;
           speed : byte;
           sflag : byte;  { second flag byte }
           lun   : byte; { last logical unit mounted }
           end;  { 8 bytes }

heathlabel = record
           JUMP  : array[0..3] of byte;
           ext   : heathext;
           dpb   : cpmdpb;
           cksum : byte;
          end;

labelptr = ^heathlabel;
fakelabel = array[0..$1c] of byte; { at its barest }
fakelabelptr = ^fakelabel;


fcb1   = array[0..12] of byte;
fcb1ptr = ^fcb1;
cpmdir = record
              key :  fcb1;
              junk : integer;
              many : byte;
              block : array[0..15] of byte; { may be byte or integers }
              { redo as a variant record later }
              end;
cpmdirptr   = ^cpmdir;

var
    c,chh : char;
    ch2   : char;
  Cmmdline : nstring;

{ ROM parameters for floppies }
    myROMparams    : params;
    oldROMparms : paramptr;
    filler      : array[0..413] of byte; { got a 64k boundary notice }

    buffer      : bufferptr;
                  {largest allocation block to read in from floppy }
    drivename   : string[10];
    drivenumber : INTEGER;
    dosfile     : file of byte;
    dosname     : string[96];
    havelogged  : boolean;
    is96tpi     : boolean;
{ cp/m label, including dpb }

    defaultlabel,etx2 : heathlabel;     { default label is a holding tank }
    mylabel      : heathlabel;     { for labels read off disk before }
                                   { validity is verified  }
                                   { mylabel is the working label }

{ global variables calculated from heath label }

    totalspace  : integer;
    freespace   : integer; { in 1k's }
    is2sided    : boolean;
    totaltracks : integer;
    log2phys    : integer;
    secsize     : integer;   { 1,2, or 3 for 256, 512 or 1024 byte sectors }
    sectortrack : integer;
    directory   : array[0..maxdirs] of cpmdir;
    a           : array[0..maxdirs] of cpmdirptr;
    alloc       : array[0..1023] of boolean; { to map the usage }
    dirsectors  : integer; { number of physical sectors in the directory }
    numdir      : integer; { number of directory entries for current format }
    blkaddrbyte : boolean;
                  {true if 1 byte entries, false if 2 bytes in directory }
    numblk      : integer; { blocks reserved for directory }
    kperblk     : integer; { kilobytes per block }
    currentdir  : integer; { a[currentdir] is cpmdirptr,
                             pointing to directory entry }
    extent      : array[0..1023] of integer;
    counter     : integer;
    activefilename : string[20]; { current file name }
    buffercount   : integer  ; { current load  in buffer[ ] }
    phys2alloc  : integer;
    sizealloc   : integer;
    stupid86    : boolean; { global flag for pc cp/m-86 double sided format }
    defaultstring : nstring;

const

{ related to disk labels }
{ from h37 bios listing }
    dpeh37 = $60;  { h37 controller, different for z100-cp/m-85 }
    dpez100= $20;  { z100 CP/M-85 ID flag }
    dpe96t = $08;  { 96 tpi drives }
    dpeed  = $04;  { extended density, 5 1k sectors per track }
    dpedd  = $02;  { double density versus single density }
    dpe2s  = $01;  { double sided }

    cpm86ds  = $80  ; { private CWW flag for secondary flag to indicate }
    { pc cpm/86 double sided format }
    { some versions of my cp/m bios have another bit to mark Lobo format }
    { where physical sector numbering begins  with 0 }
    { a variant I haven't solved is the Zorba format with sector numbering}
    { wrapping around to the back of a cylinder. I.e., side 0 1..5, side 1 }
    { 6..10, with side flag not set for side 1 !!!!! This is not readable }
    { by the 1797 but is by the 1793 }