|
Een inleiding tot REXX
Inleiding
In dit hoofdstuk worden afspraken gemaakt over de wijze van naamgeven
aan programma's, de bestanden, functies, constanten en variabelen. Verder
wordt een schema gegeven voor programma indeling. Ook wordt aandacht besteed
aan de opmaak van de tekst. Tenslotte wordt aangegeven hoe in REXX met
commentaar kan worden gewerkt.
Naamgeving
Programma's
De naam van programma's moeten voldoen aan de eisen die MS-DOS stelt.
Wordt alleen in een Windows95/98 omgeving gewerkt dan mogen uiteeraard
ook lange bestandsnamen gekozen worden. De extensie voor de programma
bestanden is rex.
Functies
Eigen functie namen beginnen met een hoofdletter en bestaan verder uit een
combinatie van kleine- en hoofdletters, zoals bijvoorbeeld MaakSamenvatting:.
of SlaGegevensOp: Functie namen moeten zoveel mogelijk zelfverklarend
zijn en uit een werkwoord + zelfstandig naamwoord bestaan. De maximum naamlengte
is niet gedefinieerd, maar een praktische maat is 32 posities. Gebruik geen
namen als A of B.
Constanten
Probeer van meet af aan constanten te benoemen met een zelfverklarende naam
in plaats van een waarde. Dit maakt achteraf wijzigen eenvoudiger. Constante-namen
zoals ZEROzijn ongelukkig gekozen, in geval de waarde ervan veranderd
in bijvoorbeeld 10. In plaats daarvan kan beter voor ONDERGRENS gekozen
worden.
Als er constanten zijn die op enigerlei wijze logisch gegroepeerd
kunnen worden, geef die dan een groepcode vooraf. Stel dat je
programma een aantal foutcodes kan afgegeven, dan zou je die
bijvoorbeeld de namen FC_GOED, FC_FOUT
en FC_NIET_GEVONDEN kunnen geven.
Constanten krijgen een naam met behulp van de toekenning.
Het voorbeeld van boven zou er uit kunnen zien als:
<![CDATA[ FC_GOED = 0 /* Geen fout opgetreden */ FC_NIET_GEVONDEN = 10 /* Geen gegevens
*/ FC_FOUT = 99 /* Fout opgetreden */ ]]>
Variabelen
Variabelen moeten een zelfverklarende naam hebben die bij voorkeur uit hoofdletters
bestaat. In REXX is er geen onderscheid tussen grote en kleine letters voor
programma code. Het maakt je programma echter wel heel leesbaar, dus onderhoudbaar.
Tabellen
REXX ondersteund enkelvoudige (scalar) variabelen en samengestelde (vector
en tabel) variabelen. Samengestelde variabelen worden ook wel stemmed
variabelen genoemd. Het begrip stem is uniek voor REXX. Samengestelde
variabelen bestaan uit een stem gedeelte, eindigend op de punt en
een tail, het gedeelte na de punt. In feite worden op deze manier
ook de dimensies van tabellen aangeduid. Daar waar in andere talen een element
uit een twee dimensionale tabel wordt aangeduid met ELEMENT(1,1) wordt dat
in REXX met ELEMENT.1.1 gedaan. Het aantal dimensies kent geen limiet. Ook
hoeft niet elke dimensie een even groot aantal sub-dimensies te hebben.
Een tabel in REXX kan heel eenvoudig geïnitialiseerd worden door initialisatie
van de stem. Het statement 'ELEMENT. = 0' maakt alle elementen van de tabel
gelijk aan nul.
Taal elementen
De taalelementen van REXX, de zogenaamde reserved words, worden bij
voorkeur genoteerd in lettergreep stijl, d.w.z. per lettergreep beginnen
met een hoofdletter en de rest kleine letters.
Programma indeling
In de nu volgende paragraaf wordt een model aangereikt, volgens welke
REXX programma's kunnen worden opgebouwd. In dit model worden de volgende
programma onderdelen onderscheiden:
- Hoofdprogramma met het main entry-point (.rex)
- Subprogramma of functie (.rex)
Hoofdprogramma met het main entry-point
Een bestand met daarin het REXX hoofdprogramma wordt als volgt ingedeeld:
- Proloog, zijnde een commentaarblok met gegevens over het
programma, parameters, etc.
- Eventueel een Copyright regel
- Declaratie/definitie van globale variabelen
- De main: functie
- Definitie van functies, liefst alfabetisch
Subprogramma of functie
Een bestand met daarin een of meerdere REXX modules (functies) wordt als
volgt ingedeeld:
- Proloog voor het hele functie bestand
- Declaratie/definitie van globale variabelen
- Een korte proloog met een beschrijving van de functie
- De functie zelf
- Eventueel een herhaling van 3 en 4, liefst alfabetisch
Programma tekst opmaak
Regel lengte
Een regel code, commentaar of code + commentaar moeten bij
voorkeur niet voorbij het zichtbare deel van het scherm worden
ingetikt. Hoewel de meeste, moderne editors dit toestaan, wordt
om reden van portabiliteit aangeraden de regels niet langer te
maken dan 79 tekens. De cursor kan dan nog net op positie 80
staan zonder dat het scherm gaat scrollen.
Als een regel toch langer dan 79 posities wordt, moet die worden
gesplitst over twee of meer regels. Het verdient aanbeveling de
gesplitste regels links uit te lijnen.
Als een aanroep of een declaratie van een functie niet op een
regel past, moeten de delen uitgelijnd worden met de eerste
parameter.
Als een tekst-string moet worden gesplitst, doe dit dan bij een
spatie en gebruik in dat geval een extra paar apostrofs ('').
Vergeet niet de gespliste regels af te sluiten met een komma.
Voor de REXX interpreter betekent een komma aan het einde van een
regel, dat deze regel op de volgende regel verder gaat.
Tussenruimte
Laat altijd een blanco regel tussen te onderscheiden programma
delen. Een voorbeeld hiervan is een blanco regel tussen
declaraties en de uitvoerbare code, of blanco regel rondom loops
en blokken code.
In het algemeen moet de programmeur met een flinke dosis eigen
inzicht de plaatsen in een programma opzoeken, waar het gebruik
van blanco regels het programma beter leesbaar zullen maken en
gemakkelijker voor het onderhoud.
Inspringen en uitlijnen
Een blok (Do) moet altijd op de regel worden gezet bij
het statement waartoe het behoort. De programmaregels die tot het
blok behoren moeten 2 posities inspringen.
Elk nieuw blok (Do) moet weer 2 posities inspringen,
aldus een niveau van inspringen vormend. Zorg ervoor niet teveel
niveaus van inspringen op te bouwen, anders wordt het programma te
onoverzichtelijk.
Einde blok (End) moet op een aparte regel worden gezet en
wel recht onder de statement waartoe het behoort. Aldus wordt een
niveau van inspringen terug gesprongen. Voeg het statement als
commentaar achter de accolade toe. Op deze manier is bij een wat
groter blok precies te achterhalen bij welk statement de rechter
accolade hoort.
Voorbeeld:
<![CDATA[
If (INVOER = WORP) Then Do
Do w=1 While (w < 6)
WORP.w = '.'
End /* Do */
Call DropField SCREEN 21 66
End; Else Do
Call DropField SCREEN 21 69
...
Call DropField SCREEN 21 75
End /* If */
]]>
Declaraties binnen functies
De declaratie van de parameters moet in de function header worden
gedaan. Als de parameters niet meer op een regel passen, moeten
ze over meerdere regels worden verspreid. Het beste is een per
regel en keurig inspringen onder de eerste declaratie.
Statement specIfieke opmaak
Gebruik de volgende opmaak voor het If-Else statement:
<![CDATA[
If (conditie) Then Do
statement(s);
End; Else Do
statement(s);
End /* If */
]]>
Gebruik de volgende opmaak voor het If statement:
<![CDATA[
If (conditie) Then Do
statement(s);
End /* If */
]]>
Gebruik de volgende opmaak voor het Do-While statement:
<![CDATA[
Do While (conditie)
statement(s);
End /* While */
]]>
Gebruik de volgende opmaak voor het Select statement:
<![CDATA[
Select
When (conditie 1) Then Do
statement(s);
End
When (conditie 2) Then Do
statement(s);
End
When (conditie 3) Then Do
statement(s);
End
Otherwise
statement(s);
End /* Select */
]]>
Richtlijnen voor commentaar
Commentaar moet duidelijk zijn, beschrijvend en tot hulp dienen.
Voor nationale toepassingen moet het commentaar in het Nederlands
gesteld zijn, voor internationale toepassingen moet het
commentaar in het Amerikaans Engels worden opgesteld.
Commentaar in REXX begint met de /* combinatie en eindigt met de
*/ combinatie.
Het zogenaamd nesten van commentaar is NIET mogelijk.
Commentaar blok
Commentaar wordt meestal toegevoegd in blokken. Deze blokken
moeten zoveel mogelijk vierkant lijken en samen met de programma
tekst inspringen.
Voorbeeld van een commentaarblok
<![CDATA[
/******************************************************************/
/* */
/* Dit is een voorbeeld van een commentaar blok ... */
/* */
/******************************************************************/
]]>
Commentaar regel
Commentaar regels worden alleen toegepast als verduidelijking.
Dit commentaar wordt altijd links en rechts uitgelijnd.
Voorbeeld van een commentaarregel
<![CDATA[
/* Dit is een voorbeeld van een commentaar regel ... */
]]>
Toegevoegd commentaar
Commentaar kan ook achter de programma regels worden toegevoegd.
Probeer links uit te lijnen op een vaste (zelf te kiezen) kolom
en rechts met de andere type commentaar regels. Het commentaar
kan worden toegevoegd op meerdere regels indien nodig.
Voorbeeld van toegevoegd commentaar
<![CDATA[ Say 'Start programma...' /* Debugging informatie */ /* links/rechts uitgelijnd
*/ ]]>
| 
