type
  nstring = string[64]; { suitable for DOS,COCO names }
   
const
  NROWS = 18;
  NCOLS = 4;
  COLWIDTH = 19;

    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    = 72;  { 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  = 18;   { max sector number on a track }
    driveflag  = $00c1 ;

{ COCO constants }
   dirtrack = 17;
   dirsec   =  3;
   dirmany  =  9;
   fatsec   =  2;
   fatmany  =  1;
   secs_per_granules = 9;
   granules_disk = 68;
   maxgranules = 255; { one sector's worth }
   FatMask = $c0; { last entry encodes number of sectors as lower 6 bits }
   freegranule = $ff;
   DeleteDir = 0;
   UnusedDir = $ff;

{ COCO types }
const
   file_type : array[0..3] of string[20] = ('BAS ', 'DATA',
             'ML  ', 'TXT ');
   ascii_flag : array[0..1] of string[3] = ('B','A');

const

illegal : set of char = ['/','.'];



(* constants for AT 1.2meg controllers *)
const
  clock    =$70;
  diskbyte =$10;
  lodensity = 1;
  hidensity = 2;
  nodrive   = 0;
  drivetype : array[0..15] of nstring =('No drive.','5.25 inc 360 KB',
  '5.25 inch 1.2 meg ',
  '3.5 inch 720KB'
  ,'3.5 inch 1.44 meg'
  , '','','','','','','','','','','');

(* state machine at $40:$90 , $40:$91 *)

  datarate = $C0; (* 0 = 500, 1 = 300, 2 = 250 3= junk *)
  Double   = $20; (* 1 = please doublestep in 1.2 meg drive *)
  MediaEST = $10; (* 1 = don't let machine test for itself *)
  MediaState = $0F;  (* 3 = 360kb in 360kb established.
                        4 = 360kb in 1.2 meg established.
                        5 = 1.2meg  in 1.2meg  established *)
  mystate = $70;



{ display module }
const
   hexint : string[16] = '0123456789ABCDEF';

type
   buffertype= array[0..buffersize] of byte;
   bufferptr = ^buffertype;
   anystring = string[255];
   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;

   fcb1   = array[0..10] of byte;
   granuletable = array[0..67] of integer;
   fcb1ptr = ^fcb1;
   COCOdir = record
              key :  fcb1;  { 0 for byte 0 means available, ff means not used }
              kind : byte;
              ascii : byte;
              first : byte; { may be byte or integers }
              lastbytes: integer; { reversed order }
              res : array[16..31] of byte;
              end;
   COCOdirptr   = ^COCOdir;

(* stuff for AT floppy controllers *)
var ATflag : boolean;
var drive0,drive1 : byte;

{ screen sizes }
var
   tagged : longint; (* file space tagged *)
   MAXFILESperPAGE : integer;


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 granule to read in from floppy }
    drivename   : string[10];
    drivenumber : INTEGER;
    dosfile     : file of byte;
    dosname     : string[96];
    havelogged  : boolean;
    is96tpi     : boolean;

    actualcocodirs : integer;
    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 COCOdir;
    a,original  : array[0..maxdirs] of COCOdirptr;
    cocofat     : array[0..maxgranules] of byte;
    granulefree : array[0..maxgranules] 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 }
    bytespergran     : integer; { bytes per block }
    currentdir  : integer; { a[currentdir] is COCOdirptr,
                             pointing to directory entry }
    extent      : array[0..1023] of integer;
    counter     : integer;
    activefilename : string[20]; { current file name }
    buffercount   : integer  ; { current load  in buffer[ ] }
    phys2granule  : integer;
    sizegranule   : integer;
    defaultstring : nstring;


var ch5 : char;

type
   byteptr = ^byte;
   byte16 = array[1..16] of byte;
   byte16ptr = ^byte16;

type
     tristate = integer; { 1=true, 0=false, -1=abort }

var panic : integer;

const
 s1:nstring ='';
 s2:nstring ='';
 s3:nstring ='';


const
   paged =1;
   SCR   =2;
   HEX   =4;
   PRT   =8;
   TITLE =$10;

type
      dirtag = record
                 place : integer;
                 tag   : char;
               end;
var
     thisdir : array[0..71] of dirtag;