|
Programma besturing
De WHILE lus
De programmeertaal REXX heeft verschillende structuren beschikbaar voor
iteraties en beslissingen. We zullen die in deze les gaan bestuderen,
te beginnen met de while lus. De while lus blijft verwerken zolang een
bepaalde conditie WAAR is. Zodra de conditie ONWAAR wordt, eindigt
de verwerking van de lus. While doet dus precies wat het statement
zegt, doe zolang. Bestudeer nu het programma WHILE.rex.
<![CDATA[
/* REXX */
PUNTEN = 0
Do While (PUNTEN < 60)
Say 'Het totaal aantal punten is 'PUNTEN
PUNTEN = PUNTEN + 10
End
Exit 0
]]>
We zien dat het programma begint met de declaratie van de integer
variabele PUNTEN binnen het hoofdblok. De variabele krijgt
de waarde nul. Dan komen we bij de while lus zelf.
De syntax van de While statement is zoals we hem hier zien.
Het gereserveerde woord While wordt gevolgd door een
voorwaarde tussen haakjes. Zolang nu de voorwaarde tussen haakjes waar
is, worden alle statements die tussen Do en End staan uitgevoerd.
In dit geval wordt de waarde van de variabele PUNTEN
opgehoogd tot en met 60 en stopt de verwerking. Het programma zal
verder gaan met het statement volgend op End, in dit
geval einde programma.
Hetgeen tussen haakjes staat is de voorwaarde, de conditie, waarover
later meer. Neem voorlopig aan dat de conditie waar of niet waar
oplevert.
Enkele dingen moeten nog worden opgemerkt over de while lus. Ten
eerste, als de variabele PUNTEN bij aanvang van de lus reeds
de waarde 60 of hoger had, wordt geen enkel statement in het blok
uitgevoerd. Het is dus mogelijk dat de statement van de while
lus nul keer worden verwerkt. Ten tweede, als de variabele
PUNTEN in het geheel niet wordt opgehoogd, krijgt men een
eindeloze lus. In zo'n geval zal het programma niet
eindigen.
Compileer en test dit programma nu.
De DO-UNTIL lus
Een variatie op de while lus is de do-until lus, hetgeen bestudeerd kan
worden met programma DOUNTIL.rex.
<![CDATA[
/* REXX */
PUNTEN = 0
Do Until (PUNTEN > 60)
Say 'Het totaal aantal punten is 'PUNTEN
PUNTEN = PUNTEN + 10
End
Exit 0
]]>
Dit programma is vrijwel gelijk aan het vorige programma. Het verschil
bestaat hieruit dat bij de do-until lus de voorwaarde is omgedraaid.
De statements die herhaald moeten worden uitgevoerd,
staan ook hier in en Do End blok.
Ook hier de voorwaarde tussen haakjes.
De statements in de lus worden uitgevoerd totdat de conditie niet waar
wordt. Het programma wordt dan voortgezet met het statement volgend op
de do-until. Omdat voor de do-until geldt dat de test achteraf wordt
gedaan, zullen de statements binnen de lus altijd minstens een maal
worden uitgevoerd. Ten tweede, als de variabele PUNTEN nooit
wordt opgehoogd, zal de verwerking niet eindigen.
Compileer en test het programma.
Opmerking: Het is uiteraard toegestaan om een lus
binnen een andere lus te programmeren (nesten).
De FOR lus
De for lus is niet iets nieuws, maar een andere manier om de while lus
te schrijven. De for gedraagt zich dus als de
while. Bestudeer nu het programma FORLOOP.rex als voorbeeld
van een programma met daarin een for lus.
De for lus bestaat uit het gereserveerde woord Do gevolgd
door een uitgebreide expressie.
De expressie is opgebouwd uit twee delen.
<![CDATA[
/* REXX */
Do INDEX=1 To 5
WORP.INDEX = '.'
End
Exit 0
]]>
Het eerste deel bevat de expressie INDEX=1 en draagt zorg
voor de nodige initialisatie. De expressie die in dit deel
voorkomt, wordt uitgevoerd voordat de statements van de eigenlijke
for lus zelf worden uitgevoerd.
Het tweede deel, hier de expressie To 5, is de test die
wordt uitgevoerd voordat aan de doorgang door de lus wordt begonnen.
Telkens nadat de lus is doorlopen, wordt de variabele INDEX met 1 opgehoogd.
Als bij aanvang INDEX al groter is dan 5, wordt de lus niet doorlopen.
De Do wordt vervolgens gevolgd door een (1)
statement. Dit mag uiteraard een groep zijn. Dit statement of deze
groep statements wordt bij elke lus doorgang uitgevoerd. In de
programmeertaal REXX is het bijna altijd zo dat een enkel statement mag
worden vervangen door een groep statements omgeven door Do End.
Compileer en test dit programma nu.
Het IF statement
Bestudeer nu het programma IFELSE.rex als voorbeeld van een programma met
een beslissing, de If. Het programma bevat twee
statements, een zonder en een met een Else tak.
Laten we het eerste statement bekijken. Het begint met het
gereserveerde woord If gevolgd door een expressie tussen
haakjes. De expressie wordt geevalueerd. Wanneer deze WAAR is, wordt
het enkele statement op de volgende regel uitgevoerd. Indien de
expressie ONWAAR is, wordt dat statement overgeslagen.
Ook hier geldt weer dat het enkele statement mag wordt vervangen door
een groep, bestaande uit een of meerdere andere statements omgeven door
Do End.
<![CDATA[
/* REXX */
SCORE = 100
PERSREC = 200
If (SCORE > PERSREC) Then
Say 'Je hebt je persoonlijk record verbeterd !!!'
If (SCORE > PERSREC) Then
Say 'Score: *** 'Right(SCORE,4,0)' ***'
Else
Say 'Score: 'Right(SCORE,4,0)' '
Exit 0
]]>
De expressie SCORE > PERSREC vraagt eenvoudig af of de
waarde van de huidige score groter is dan die van het persoonlijk
record van de speler.
Het tweede If statement is vrijwel gelijk aan de eerste,
echter nu is het uitgebreid met het gereserveerde woord
Else. Als na evaluatie de expressie WAAR is wordt de eerste
Say uitgevoerd. Als deze ONWAAR is wordt de tweede
Say uitgevoerd. Er wordt dus altijd iets
afgedrukt, terwijl in het eerste geval er soms wel en soms niet iets
wordt afgedrukt.
Beide vormen hebben zo hun eigen toepassing binnen een programma. Het
tweede If statement wordt hier toegepast om de score extra
te accentueren, wanneer deze boven het persoonlijk record uitkomt.
Compileer en test nu dit programma.
Het LEAVE en ITERATE statement
Bestudeer het programma BREAKCON.rex als voorbeeld van het
Leave en Iterate statement. Het programma bevat
twee bijna identieke iteraties.
<![CDATA[
/* REXX */
Do XX=1 To 14
If (XX = 10) Then
Leave
Say 'In het "LEAVE" deel; XX heeft de waarde 'XX
End
Do XX=1 To 14
If (XX = 10) Then
Iterate
Say 'In het "ITERATE" deel; XX heeft de waarde 'XX
End
Exit 0
]]>
In de eerste iteratie staat een If die een Leave
aanroept als XX de waarde 10 bereikt. Het Leave
statement heeft als eigenschap uit de lus van een iteratie te springen
en het programma te vervolgen met het eerste statement na de
lus. De lus wordt daarmee (voortijdig) beeindigd. Het is een waardevol
statement in die situaties waar je uit de lus van een iteratie wil
springen afhankelijk van de waarde van een bepaald resultaat dat in de
lus zelf wordt berekend.
De tweede iteratie bevat een Iterate statement. Dit
statement heeft als eigenschap uit de lus van een iteratie te springen,
maar de lus niet te beeindigen. Het programma wordt vervolgd met het
eerste statement in de lus. Als XX de waarde 10
bereikt, zal het programma naar het begin van de lus springen en
doorgaan. Het effect zal zijn dat alle waarden worden afgedrukt,
behalve de waarde 10.
Compileer en test dit programma om te zien of het werkt zoals
hierboven beschreven.
Het SELECT statement
Bestudeer nu het programma SELECT.rex om een indruk te krijgen van een
van de sterkere structurerings primitiva van de programmeertaal REXX, de
Select. De Select is niet echt ingewikkeld, dus
laat je er niet door afschrikken.
Het statement begint met het gereserveerde woord Select
gevolgd door een aantal takken van verwerking. Het gereserveerde woord
When gevolgd door een woorwaarde tussen haakjes, wordt gebruikt
om zo'n tak aan te geven. De tak die zal worden doorlopen, is degene
waarvan de waarde van OPDRACHT overeenkomt met de voorwaarde.
<![CDATA[
/* REXX */
Select
When (OPDRACHT = 1) Then
Say 'Verwerk 'vooruit bladeren' opdracht ...'
When (OPDRACHT = 2) Then
Say 'Verwerk 'achteruit bladeren' opdracht ...'
When (OPDRACHT = 3 | OPDRACHT = 4 | OPDRACHT = 9) Then
Say 'Stop de verwerking.'
Otherwise
Say 'Dit is een onbekende opdracht !!!'
End
Exit 0
]]>
Als in het voorbeeld programma OPDRACHT de waarde 2 heeft,
zal de tekst Verwerk 'achteruit bladeren' opdracht ...
worden afgedrukt.
Zodra een verwerkings-tak wordt gevonden, zal het statement in die
tak worden uitgevoerd, of totdat het programma door de laatste tak
valt. Dit laatste is belangrijk om te onthouden.
De verschillende takken mogen niet in willekeurige volgorde staan.
Ze worden namelijk van boven na beneden geevalueerd. Zodra een voorwaarde
voldoet, wordt de bijbehorende tak gekozen. Meerdere statements moeten
tussen een Do End staan.
Als een tak niet wordt gevonden, wordt het deel achter
Otherwise uitgevoerd. Als OPDRACHT de waarde
16 heeft, zal de tekst Dit is een onbekende opdracht !!!
worden afgedrukt.
Tenslotte nog een opmerking. De hiervoor behandelde statements mogen
alle binnen elkaar genest worden of in elke volgorde na
elkaar geprogrammeerd worden.
Compileer en test dit programma.
Een voorbeeld programma
Bestudeer nu het programma PVK.rex. Het programma lost het probleem op
van een boer die naar de markt gaat. Hij heeft honderd gulden en
daarvoor moet hij precies honderd beesten kopen. Een paard kost
vijftien gulden, een varken kost een gulden en de kippen kosten een
kwartje. De vraag is hoeveel paarden, varkens en kippen moet hij kopen.
Er is een (1) oplossing. Onderstaand het REXX programma.
<![CDATA[
/* REXX */
Say 'PAARDEN VARKENS KIPPEN BEDRAG '
Say '------- ------- ------- ------- '
/* Ga uit van het duurste beest, het paard ... */
Do PAARD=1 While(PAARD <= (100.00 / 15.00))
SUBTOT = PAARD * 15.00
/* Varieer dan met het aantal mogelijke varkens ... */
Do VARKEN=1 While (VARKEN <= ((100.00 - subtot) / 1.00))
KIP = 100 - PAARD - VARKEN
/* Wat is nu het totaal bedrag aan beesten ... */
BEDRAG = SUBTOT + VARKEN * 1.00 + KIP * 0.25
/* Indien buiten de grenswaarden, dan het volgende varken ... */
If ((100.00 - 0.50) > BEDRAG | BEDRAG > (100.00 + 0.50)) Then
Iterate
/* Indien tussen de grenswaarden, druk dan af ... */
Call CharOut,Right(PAARD,6)Right(VARKEN,9)Right(KIP,9)Format(BEDRAG,7,2)
/* BINGO !!! */
If (BEDRAG = 100.00) Then
Call CharOut,' <===='
Say
End /* Do */
End /* Do */
Exit 0
]]>
Er is hier gekozen voor commentaar dat met de statements is
uitgelijnd. Commentaar en statements zijn bij elkaar gehouden door het
gebruik van blanco regels. Statement groepen zijn twee spaties
ingesprongen, zodat te zien is wat respectievelijk tot de
Do's en wat tot de If's behoort.
Het programma genereert mogelijke aankopen en berekent daarvan het
aankoopbedrag. Als dit bedrag niet te veel afwijkt van honderd gulden
wordt de samenstelling afgedrukt. De afwijking in het voorbeeld is
vijftig cent. In het geval het aankoopbedrag precies op honderd gulden
uitkomt, wordt een pijl naast de samenstelling afgedrukt.
Compileer en test het programma. Controleer of het werkt zoals hierboven
beschreven.
| 
