Programmeren in REXX/Fundamenten: verschil tussen versies
Verwijderde inhoud Toegevoegde inhoud
Redirect uitschakelen |
Toevoegingen, herstructureren, verbeteren tekst |
||
Regel 19:
Door velen wordt REXX ten onrechte beschouwd als enkel een vervanger voor scripting (BAT-files). Dat was wel het eerste doel op mainframes. We zullen echter zien dat de taal volledig genoeg is om er ook alle andere klassieke programmeertaken mee te vervullen. Op de huidige snelle PC's (en zeker de mainframes) kan een tragere uitvoeringstijd een verwaarloosbare handicap zijn, en ruimschoots gecompenseerd worden door de snelheid van ontwikkeling. Zeker in die gevallen waar het programma slechts sporadisch of zelfs éénmalig moet worden uitgevoerd zal REXX een zeer interessant alternatief voor andere programmeertalen zijn.
Door de weinig complexe schrijfwijze, het gebruik van leesbare (Engelse) termen en het ontbreken van declaraties is het ook een uitgelezen programmeertaal voor minder geroutineerde of beginnende computergebruikers.
Lees [http://www.rexxla.org/rexxlang/mfc/rexxadv.html hier] wat Mike Cowlishaw, de "uitvinder" van REXX, als voor- en nadelen van zijn programmeertaal opsomt.
<!--------------------------------------------------->
=Bouwstenen=
Een REXX programma
*een of meer spaties, die genegeerd worden;
*een reeks "tokens" (zie verder);
* constanten▼
*geen of een reeks spaties die ook genegeerd worden;
* getallen▼
*een punt-komma dat de zin afsluit. Aan het eind van een lijn is deze optioneel.
* symbolen (instructies of variabelen)▼
Daarnaast kan het programma doorspekt zijn met commentaren (zie verder).
* labels▼
Elk van deze zinnen - die we vanaf nu liever '''statements''' noemen - wordt één voor één geanalyseerd en uitgevoerd. De analyse gebeurt van links naar rechts. Dit laatste kan soms van groot belang zijn.
De term '''token''' staat voor de bouwstenen waarmee REXX statements zijn opgebouwd. De tokens kunnen gelijk welke lengte hebben, tenzij er limieten worden opgelegd door de implementatie. Het beschikbaar geheugen is anders de ultieme limiet.
De soorten tokens zijn:
*operatoren
*speciale syntactische tekens
Laten we al deze elementen in detail bekijken, te beginnen met commentaren.
<!--------------------------------------------------->
==Commentaren==
Commentaren worden in REXX begrensd door een beginnende <span style="color:red">/*</span> en een eindigende <span style="color:red">*/</span>.
Commentaren kunnen over meerdere lijnen gaan en een commentaar kan een ander commentaar bevatten (geneste commentaren). Ze kunnen praktisch overal voorkomen, ook midden in een instructie. REXX zoekt naar die begin- en eindaanduidingen zonder rekening te houden met andere inhoud. Dus indien ergens in een constante van het programma één van die tekens
Op sommige systemen moet een REXX programma beginnen met een commentaar op de eerste positie, desnoods een ''leeg'' commentaar zoals in een
Andere implementaties of systemen vereisen dat niet. Toch blijft het een goede gewoonte om het programma te beginnen met een korte beschrijving,
eventueel aangevuld met de naam van de programmeur, een creatiedatum en de historiek van de veranderingen. Ook als het programma moet kunnen gebruikt worden op verschillende systemen is het veilig te starten met een commentaar in de eerste positie.
/* */
say "Hello" /* Dit zal Hello op het scherm zetten */
/* Deze lijnen zijn
/* écht waar ! */
allemaal commentaar */
if i=5 /* en alleen dan */ then say "Adieu"
<!--------------------------------------------------->
Regel 51 ⟶ 66:
definieert een constante (een zin). Omdat in de zin een apostrof nodig is, wordt de zin omgeven door de dubbele aanhalingstekens.
Een
say 'Nice weather, isn’’t it?'
Daar dit minder leesbaar is, gebruiken we deze oplossing enkel in die gevallen waar het niet anders kan, bijvoorbeeld omdat zowel apostrof als dubbel aanhalingsteken nodig is in de contante.
Een constante kan ook met hexadecimale of binaire notatie opgegeven worden:
'1de8'x "11110110"b
Constanten worden dus "letterlijk" genomen door het programma en zijn als dusdanig een element van een statement tijdens de uitvoering.
<!--------------------------------------------------->
==Getallen==
Een getal is een reeks cijfers, met eventueel een decimaal <u>punt</u> (geen komma dus!). Negatieve getallen worden voorafgegaan door een minteken. Exponentiële notatie kan ook worden gebruikt. Een enkele 0 voor het decimaal punt mag weggelaten worden.
Dit zijn allemaal geldige getallen:
17 98.07 -101 .14 12.2e6 73e-128 '-17.9' ' 11.22 '
De laatste 2 getallen (als een constante voorgesteld) zijn evengoed geldig, want we leerden al dat REXX alles opslaat als karakterreeksen tot eventueel blijkt dat er moet mee gerekend worden. Spaties worden
<!--------------------------------------------------->
==Symbolen==
Regel 72 ⟶ 89:
Op z'n minst kunnen volgende karakters gebruikt worden:
A tot Z, a tot z, 0 tot 9, . (punt) en _ (liggend streepje)
Als een symbool niet met een cijfers of een punt begint, dan kan het een variabele voorstellen. Dit betekent dat men er een waarde kan aan toekennen.
Dus, een symbool zal, al naargelang zijn plaats in het programma, beschouwd worden als een variabele of als een instructie (bevel, functie).
De initiële waarde van een token is gelijk aan zijn naam in hoofdletters. Dus zullen in volgende zin
say a
beide woorden door REXX gezien worden als respectievelijk '''SAY''' en '''A'''. Het token '''SAY''' wordt door REXX daarna wel herkend als een
{{Bericht
|titel=Hoofdletter-ongevoelig (Case-insensitive)
Regel 86 ⟶ 101:
|type=waarschuwing}}
In onderstaand voorbeeldje is het symbool "do" op de eerste regel tweemaal gebruikt. De eerste maal is het een
do do=1 to 10
say do
end
Dit is een perfect geldig
<!--------------------------------------------------->▼
Speciale vormen van symbolen zijn dus bevelen en functies:
==Bevelen==▼
▲<!--------------------------------------------------->
▲===Bevelen===
Deze zullen in meer detail beschreven in volgende hoofdstukken, maar de lijst ervan is zo beperkt dat we ze hier toch even kunnen opsommen: '''ADDRESS,'''
'''[[Programmeren in REXX/Bevelen,_deel_1#ARG|ARG]]''',
Regel 115 ⟶ 131:
'''[[Programmeren in REXX/Bevelen,_deel_1#SELECT|SELECT]]''',
'''[[Programmeren in REXX/Bevelen,_deel_2#SIGNAL|SIGNAL]]''' en
'''[[Programmeren in REXX/Debugging#TRACE|TRACE]]'''.
Van een aantal kan men nu al vermoeden waartoe ze zullen dienen. Soms gebruiken we hiervoor ook de term ''instructies'' zoals in het Engels ''instructions''. <!--------------------------------------------------->
===Functies===
Functies komen
'''functienaam(parameter1,parameter2,...)'''
waarbij de parameters van elkaar gescheiden worden door komma's. De lijst van parameters moet aan de functienaam plakken, er mag geen spatie tussen geplaatst worden.
Regel 127 ⟶ 144:
Het is tenslotte mogelijk eigen functies te schrijven.
a="tekst"
say '''length'''('Dit is een Dit zijn de stappen die door de REXX interpreter worden uitgevoerd (herinner u, de interpretatie werkt van links naar rechts):
#het token "a" is niet gekend als bevel of functie, maar is wel een geldige naam voor een variabele;
#het gelijkheidsteken beveelt om een waarde toe te kennen aan de variabele (assignatie);
#de toegekende waarde is alles tot aan het einde van het statement (hier impliciet het einde van de zin). De variabele ''a'' krijgt dus de waarde "tekst"
#het token "say" wordt herkend als een bevel dat alles wat volgt tot aan het einde van het statement op het scherm moet afdrukken;
#het token "length" wordt vervolgens herkend als een standaardfunctie die de lengte van zijn parameter moet opzoeken en teruggeven;
#het deel tussen haakjes is de eerste, en in dit geval enige parameter voor de functie. REXX ontdekt dat het een constante is, gevolgd door een variabele, dus
de variabele wordt door haar waarde vervangen, en de parameter wordt uiteindelijk "Dit is een tekst";
#de functie '''length''' telt nu het aantal karakters en komt tot de waarde 16;
#het bevel '''say''' drukt het getal 16 af op het scherm.
<!--------------------------------------------------->
==Labels==
| |||