|
Bestands Invoer/Uitvoer
Een bestand aanmaken
Bestudeer het programma SCHRLIJN.rex voor een eerste kennismaking met het
schrijven van gegevens naar een bestand. Zoals gebruikelijk worden
enkele variabelen gedeclareerd.
<![CDATA[
/* REXX */
DS1 = 2; DS2 = 3; DS3 = 4; DS4 = 5; DS5 = 6 /* initialiseer */
PF = 'CURSUS.DAT' /* bestandsnaam */
Do INDEX=1 To 10
Call LineOut PF,'Regel nummer 'Right(INDEX,2,0)':',
DS1' 'DS2' 'DS3' 'DS4' 'DS5
End
Exit 0
]]>
Voordat we in een bestand kunnen schrijven , moeten we het openen.
Concreet betekent dit dat we het systeem moeten vertellen dat we naar
een bestand willen schrijven en wat de naam van dat bestand is. We doen
dit met behulp van de LineOut functie, zoals je in het
voorbeeld programma kunt zien. In dit geval zal PF de bestandsnaam
'CURSUS.DAT' bevatten. De bestandsnaam moet een geldige MS-DOS/Windows95
naam zijn en kan zowel in kleine- als in hoofdletters worden opgegeven.
De bestandsnaam wordt als string aan de functie aangeboden. Een waarschuwing
is hier op zijn plaats. Neem voor de bestandsnaam niet per ongeluk de naam
van een waardevol bestand. Het programma zal, zonder pardon, dit bestand
beschrijven, zodat de inhoud verloren gaat.
Het bestand wordt door REXX altijd geopend voor toevoegen. Dit betekent
dat het zal worden aangemaakt als het niet reeds op schijf aanwezig is.
Is het een bestaand bestand dan zullen de gegevens achteraan bijgeschreven
worden. Bestaande gegevens gaan dus niet verloren.
Uitvoer naar een bestand lijkt erg veel op standaard uitvoer. Het
verschil zit in de toegepaste functies en het gebruik van de bestands
naam. In het voorbeeld programma heeft LineOut de plaats ingenomen
van de vertrouwde Say functie.
De bestands naam is de eerste parameter, de andere parameters zijn
volkomen gelijk aan die van Say.
Een bestand moet na gebruik ook weer worden afgesloten. Dit wordt
impliciet door de REXX interpreter gedaan bij afsluiting van het programma.
Wanneer tussentijds sluiten van het bestand nodig is, bijvoorbeeld om
te lezen na schrijven, dan moet het bestand expliciet worden gesloten.
Dit kan met de REXX Stream functie, en wel als volgt:
<![CDATA[
Call Stream PF,'C','Close' /* PF = 'CURSUS.DAT' */
Call Stream 'CURSUS.DAT','C','Close'
]]>
Je kunt een bestand openen voor schrijven, sluiten, wederom openen voor
lezen, sluiten, openen voor toevoegen, enz. enz. Telkens kun je
dezelfde bestands naam gebruiken of een andere. De naam van het bestand
bepaald naar welk bestand uiteindelijk wordt geschreven.
Compileer en test dit programma. Het programma drukt niets af. Kijk na
afloop echter in het bestand CURSUS.DAT via de editor of middels het
MS-DOS type commando. Kijk of inhoud en programma
specificatie met elkaar overeen stemmen.
Een bestand uitbreiden
Het is ook mogelijk teken voor teken naar een bestand te schrijven.
Bestudeer programma SCHRCHAR.rex voor een voorbeeld.
<![CDATA[
/* REXX */
REGEL = 'Tripple Yahtzee - pc3270' /* initialiseer */
PF = 'CURSUS.DAT' /* bestandsnaam */
Do 10
Do i=1 To Length(REGEL)
CHAR = Substr(REGEL,i,1)
Call CharOut PF,CHAR
End
Call LineOut PF,''
End
Exit 0
]]>
Het programma begint met de declaratie van een lus variabele, een
index naar een character en een string met characters, die initieel
gevuld is met een tekst. Ook de naam van een bestand is nu niet
vreemd meer. Het bestand wordt vervolgens geopend voor toevoegen. Dit
is hetzelfde bestand van het vorige hoofdstuk, waardoor we in staat
zijn te controleren of het werkt.
Het programma bevat twee iteraties binnen elkaar. De buitenste lus
wordt 10 keer doorlopen om enkele regels uitvoer te genereren. De
binnenste lus wordt doorlopen totdat het teken uit de tekst string het
laatste karakter is. De index i wijst het uit te voeren
teken aan en wijst telkens aan het begin van de iteratie naar het
eerste teken van de tekst string.
Interessant is nu de CharOut functie. Deze functie schrijft
hier telkens 1 teken naar het bestand. Het teken is de tweede parameter.
De eerste parameter is de naam van het bestand waarin moet worden
geschreven.
Als alle tekens uit de tekst string weg zijn geschreven, wordt nog een
NewLine karakter toegevoegd, omdat deze niet in de tekst
zelf stond. Op deze wijze worden er 10 regels aan het bestand CURSUS.DAT
toegevoegd en het bestand wordt afgesloten. Compileer en test dit
programma en kijk of de regels inderdaad aan het einde van het bestand
zijn toegevoegd. Voer het programma nogmaals uit en kijk wat er
gebeurt.
Een bestand lezen
We gaan nu leren hoe een bestand kan worden gelezen. Bestudeer daartoe
nu het programma LEESCHAR.rex.
<![CDATA[
/* REXX */
PF = 'CURSUS.DAT' /* bestandsnaam */
Do ForEver
CHAR = CharIn(PF,,1)
If (CHAR == '') /* einde bestand */
Then Leave
Call CharOut,CHAR
End
Exit 0
]]>
Er wordt een iteratie gestart. Teken voor teken wordt gelezen en afgedrukt
tot einde bestand (EOF). Het bestand wordt dan afgesloten en het
programma stopt. De CharIn functie levert bij EOF een lege waarde
af. Omdat in REXX '' en ' ' gelijk zijn aan elkaar, wordt nu vergelegen
middels exact match om EOF te kunnen constateren.
Compileer en test dit programma.
Woorden lezen uit een bestand
Bestudeer nu het programma LEESTEXT.rex waarin wordt uitgelegd hoe een bestand
woord voor woord te lezen. <![CDATA[ /* REXX */ PF = 'CURSUS.DAT' /* bestandsnaam
*/ Do ForEver REGEL = LineIn(PF) If (REGEL == '') /* einde bestand */ Then
Leave Do While (REGEL <> '') Parse Var REGEL WOORD REGEL Say WOORD End End
Exit 0 ]]> Dit programma gebruikt de LineIn functie om een regel
te lezen. Omdat LineIn het lezen stopt bij het vinden van een NewLine
karakter, zal per regel een aantal woorden worden gelezen. Elk gelezen woord
wordt op een nieuwe regel afgedrukt. Compileer en test het programma.
Regels lezen uit een bestand
Bestudeer nu het programma LEESLIJN.rex, waarin wordt uitgelegd hoe een
complete regel (ook wel record genoemd) uit een bestand kan worden
gelezen. Dit programma lijkt als twee druppels water op het LEESTEXT.rex
programma, echter nu wordt gewerkt met de Lines functie om op EOF
te testen.
<![CDATA[
/* REXX */
PF = 'CURSUS.DAT' /* bestandsnaam */
Do While Lines(PF)
REGEL = LineIn(PF)
Say REGEL
End
Exit 0
]]>
De LineIn functie leest regel voor regel uit een bestand,
inclusief het NewLine karakter. Het resultaat komt in de
variabele REGEL terecht. De parameter is de naam van het
te lezen bestand. Bij het lezen van EOF, wordt FALSE terug gegeven
door de Lines functie. In het voorbeeld programma wordt direct op
deze FALSE waarde getest.
Door de constructie met de While wordt de test vooraf gedaan en
werkt het programma verder correct. Bij het bereiken van EOF wordt het
bestand gesloten en stopt het programma. Compileer en test ook dit programma.
|
