In een eerdere serie schreef ik over Linux en daar gold het adagium: everything is a file. DOS heeft dat idee in rudimentaire vorm ook: bestanden zijn de centrale manier waarop je met de computer praat.

MS-DOS was indertijd een systeem dat maximaal moest lijken op CP/M en later steeds meer uit Unix is gaan overnemen. Linux is zelf ook weer geïnspireerd op Unix. Dat is van al deze systemen de oudste, maar in veel opzichten toch al moderner dan MS-DOS ooit is geworden.

Waar Unix, en dus Linux, een rijk en doordacht systeem bouwde van inodes, rechten, pipes en device nodes, is DOS vooral plat en eenvoudig. Een bestand is gewoon een rij bytes op schijf, met een naam in 8.3-formaat (acht letters voor de punt, drie erna).

Subdirectories kwamen pas met MS-DOS 2.0 en zelfs dan voelt het alsof er een directory-laag over een platte lijst heen is gelijmd. Geen rechten, geen gebruikers, geen eigenaarschap: één PC, één gebruiker en die heeft alle macht. Het is minimalistisch, maar daardoor wel overzichtelijk.

Overigens behandelt ook MS-DOS randapparatuur als file. Neem de printer: als je data stuurt naar het "bestand" LPT1:, dan gaat die data naar de printer.

MS-DOS gebruikt net als Unix een file handle om bestanden mee te identificeren. Wat onderhuids gebeurt is dat MS-DOS een gebiedje in het geheugen maakt, een File Control Block om geopende bestanden te beheren en een buffer waar data in gezet wordt, tot de buffer vol is. Dan wordt het hele blok ineens naar een drive gestuurd. De file handle is feitelijk een index in de System File Table, die verwijst naar het FCB en daarmee naar die buffer.

Werken met een buffer is handig, efficiënt en snel. Het heeft wel een nadeel: als je een diskette verwijderd of een programma afbreekt vóór de inhoud van de buffer is weggeschreven, gaat data verloren zonder dat je dat merkt.

Hoe werkt het netjes in Pascal? Altijd vier stappen.

Eerst leg je een koppeling tussen een variabele en een bestandsnaam:

1. Koppelen: Assign
2. Openen: Reset (voor lezen) of Rewrite (voor schrijven)
3. Lezen/schrijven: met Read, Readln, Write, Writeln
4. Sluiten: Close

Een minivoorbeeld:

Program LeesBestand;

Var
  F: Text;
  S: String;

Begin
  Assign(F, 'TEST.TXT');
  Reset(F);
  While not Eof(F) do
  Begin
    Readln(F, S);
    Writeln('Regel: ', S);
  End;
  Close(F);
End.

Dit programma leest een bestand regel voor regel in en schrijft het naar het scherm. Zonder Assign weet Pascal niet welk DOS-bestand bij variabele F hoort. Zonder Reset of Rewrite is er geen toegang. En zonder Close blijft het bestand openstaan, wat in DOS een garantie is voor frustraties en datacorruptie. 

En wat als het misgaat?
DOS is in dit opzicht onvriendelijk. Als Reset een niet-bestaand bestand moet openen, gaat het gewoon mis. Turbo Pascal geeft dan een runtime-error en het programma stopt. Geen exceptions, geen nette foutmeldingen. Daarvoor is wel een oplossing, IOResult, maar dat komt later.

Dit voorbeeld werkte goed met een tekstbestand. Daarvoor gebruik je Readln en Writeln. Maar Turbo Pascal kent ook binaire bestanden. Die declareer je bijvoorbeeld als:

Var
  B: File of Integer;

In plaats van Readln en Writeln gebruik je hier Read en Write, die niet werken met regels maar met vaste records van een bepaald type of formaat. Een File of Integer is dus letterlijk een rijtje integers op schijf, zonder scheidingstekens of opmaak. En Reset opent hier een bestand voor zowel lezen als schrijven. 

Het verschil lijkt subtiel, maar is groot in de praktijk:

• Text-bestanden zijn makkelijk te lezen en te bewerken met elke editor (WordPerfect, EDIT, zelfs TYPE in DOS).
• Binaire bestanden zijn compacter en sneller, maar onleesbaar voor mensen zonder het juiste programma.

In Pascal is een groot verschil dat de file handle voor een tekstbestand simpelweg bestaat uit de naam van het bestand en van type Text is, terwijl een binair bestand als type File of <type> is.