Programmeren in REXX/Fundamenten: verschil tussen versies
Verwijderde inhoud Toegevoegde inhoud
Dubbele vertikale streep geeft problemen bij creatie van een boek (wordt als cel voor tabel behandeld) |
Afwerken van dit hoofdstuk. |
||
Regel 3:
=Typische kenmerken=
Fundamenteel aan REXX is dat alle woorden binnen het programma intern als karakterreeks worden opgeslagen.
Het is enkel
Het resultaat van de bewerking wordt weer een karakterreeks.
Dit heeft als voornaamste gevolg dat er geen declaraties moeten worden gemaakt voor variabelen, zoals in de meeste andere programmeertalen wel het geval is.
We zullen karakterreeksen vanaf nu meestal met de Engelse term '''string''' benoemen.
Vervolgens werkt REXX meestal als een ''[[w:interpreter|interpreter]]''.
Hiermee wordt bedoeld dat REXX het programma lijn voor lijn zal uitvoeren, en daarvoor telkens in twee stappen wordt gewerkt. De eerste stap is een interpretatie van de programmalijn en omzetting naar interne code (te vergelijken met een compilatie). De tweede stap is dan de eigenlijke uitvoering. Er zijn wel optimalisaties voorzien om niet telkens de eerste stap te moeten doen, bv. in geval van een lus.
Dit heeft als gevolg dat REXX het in uitvoeringssnelheid in de meeste gevallen niet kan winnen van gecompileerde programma's. Daartegenover staat echter dat de ontwikkeling van een werkend programma veelal heel wat sneller kan. De interpretatie-stap kan ook voordelen hebben, bijvoorbeeld bij het debuggen.
Op mainframe besturingssystemen ([[w:z/OS|z/OS]] en [[w:z/VM|z/VM]]) bestaan wel compilers voor REXX.
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.
<!--------------------------------------------------->
=Bouwstenen=
Een REXX programma bestaat uit
Regel 22 ⟶ 29:
* functies
* labels
<!--------------------------------------------------->
==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 voorkomen kan het mislopen.
Op sommige systemen moet een REXX programma beginnen met een commentaar, desnoods een ''leeg'' commentaar zoals in een volgende voorbeeld.
Andere implementaties of systemen vereisen dat niet. Toch blijft het een goede gewoonte om het programma te beginnen met een korte beschrijving,
/* */
say "Hello" /* Dit zal Hello op het scherm zetten */
Regel 35 ⟶ 43:
allemaal
commentaar */
if i=5 /* en alleen dan */ then say "Adieu"
<!--------------------------------------------------->
==Constanten==
Constanten zijn karakterreeksen die begrensd
<br>
say "Nice weather, isn't it?"
definieert een constante (een zin). Omdat in de zin een
Een andere oplossing
say 'Nice weather, isn’’t it?'
Geef echter toe dat dit iets minder leesbaar overkomt, doch in sommige situaties kan dit nodig zijn.
Een constante kan ook met hexadecimale of binaire notatie opgegeven worden:
'1de8'x "11110110"b
Deze notatie laat o.a. toe onleesbare controlekarakters te plaatsen.
<!--------------------------------------------------->
==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.
Dit zijn allemaal geldige getallen:
17 98.07 -101 12.2e6 73e-128 '-17.9' ' 11.22 '
<!--------------------------------------------------->
==Symbolen==
Met symbolen bedoelen we ''woorden'' bestaande uit een reeks karakters.
Regel 63 ⟶ 74:
Cijfers en het punt mogen echter niet als eerste voorkomen.
De term ''woorden'' moet dus in een brede context gezien worden, want er kunnen naast letters ook andere tekens in voorkomen.
Elke token wordt van de rest gescheiden door één of meer spaties of bewerkingstekens. Deze symbolen worden dan, al naargelang hun plaats in het programma,
De initiële waarde van een
say a
beide woorden door REXX gezien worden als respectievelijk '''SAY''' en '''A'''. Het token '''SAY''' wordt door REXX daarna wel herkend als een commando dat wat volgt op het scherm moet afdrukken. Het token '''A''' zal als variabele gezien worden vermits het niet tussen aanhalingstekens staat en dus geen constante is. Nergens werd hier een waarde toegekend aan die variabele, dus, haar initiële waarde blijft zolang "A", en het zal die "A" zijn die we op het scherm zullen zien verschijnen.
{{Bericht
|titel=
|bericht=Rexx maakt geen onderscheid tussen kleine letters en hoofdletters (Engels: case-insensitive). '''ABC''' verwijst dus naar hetzelfde token als '''abc''' of '''Abc
|type=waarschuwing}}
In onderstaand voorbeeldje is het symbool
do do=1 to 10
say do
end
Dit is perfect geldig doch, omwille van de leesbaarheid, ten stelligste af te raden. Gebruik geen variabel-namen
<!--------------------------------------------------->
==
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/Commando1#ARG|ARG]]''', '''[[Programmeren in REXX/Commando2#CALL|CALL]]''',
'''[[Programmeren in REXX/Commando1#DO|DO]],''' '''[[Programmeren in REXX/Commando2#DROP|DROP]],'''
Regel 98 ⟶ 107:
'''[[Programmeren in REXX/Commando2#RETURN|RETURN]],''' '''[[Programmeren in REXX/Commando1#SAY|SAY]],'''
'''[[Programmeren in REXX/Commando1#SELECT|SELECT]],''' '''[[Programmeren in REXX/Commando2#SIGNAL|SIGNAL]],''' en
'''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''. Doch dit kan ook leiden tot verwarring met een volledige programmalijn.
<!--------------------------------------------------->
==Functies==
Functies
'''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.
Functies kunnen ook verschillen naargelang het besturingssysteem
Het is tenslotte mogelijk
Toch een voorbeeldje van een (basis-)functie hier:
say '''length'''(
De functie '''length''' geeft de lengte van zijn parameter terug.
<!--------------------------------------------------->
==Labels==
Labels (letterlijk: etiketten), zijn plaatsen naar waar een programma kan springen (met
[[Programmeren in REXX/Commando2#CALL|CALL]], of
Een label
signal MijnLabel /* We springen verder */
[instructies]
Regel 126 ⟶ 135:
exit /* we verlaten het programma */
Ook voor labels geldt dat ze
Het is zelfs mogelijk meerdere labels na elkaar te gebruiken, waarbij ze dan te beschouwen zijn als elkaars synoniem.
<!--------------------------------------------------->
==Leestekens==
===Vervolgteken===
De '''komma''' aan het eind van een
/* Gesplitste instructie */
Say "Dit is een"''','''
"tekst."
Merk op dat het voor commentaren over meerdere regels <u>niet</u> nodig is continuatietekens te gebruiken. De komma zal na het samenvoegen van de lijnen vervangen worden door een spatie.
===Scheidingsteken===
De '''puntkomma''' laat toe instructies van elkaar te scheiden, zoals hier:
Regel 144 ⟶ 152:
{{Bericht
|titel=Programma opbouw - statements.
|bericht=REXX interpreteert programmalijn per programmalijn
* bij het einde van een regel (een line-end, een CrLf bvb), tenzij een vervolgteken werd gebruikt
* een scheidingsteken, midden in een regel;
* een impliciet scheidingsteken binnen een instructie. REXX veronderstelt een scheidingsteken na THEN, ELSE en OTHERWISE.
Om duidelijk een onderscheid te maken tussen de tekstregels of programmalijnen die de broncode opmaken, en de aparte logische eenheden die REXX als instructies uitvoert zullen we deze laatste vanaf nu liever met het
Engelse woord '''statement''' beschrijven.
|type=info}}
===Bewerkingstekens===
Hiermee bedoelen we o.a. de tekens die toelaten op te tellen of af te trekken. We hebben, in volgorde van uitvoering:
Regel 166 ⟶ 175:
* '''&''' logische en (AND)
* '''| &&''' logische of (OR) en exclusieve of (XOR)
Bij vergelijkingen wordt het kortste lid tot gelijke lengte van het langste lid gemaakt door er spaties aan toe te voegen alvorens de vergelijking aan te vatten. Bij de '''strikte''' vormen van vergelijkingen wordt deze verlenging niet toegepast.
Het resultaat van een vergelijking is 1 (waar) of 0 (onwaar). Bij logische bewerkingen mogen enkel 1 of 0 gebruikt worden.
Voorbeelden:
\1 /* 0 (niet 1) */
-7 * (4+3) /* -49 */
-7*4 + 3 /* -25 (volgorde belangrijk)*/
'ABC'=='ABC' /* 1 (= waar) */
'ABC'=='ABC ' /* 0 (= niet waar) */
'ABC'\='abc' /* 1 (= waar) */
(1 | 0) & 1 /* 1 (= waar) */
12 % 7 /* 1 (modulo) */
12 // 7 /* 5 (rest van deling) */
Concatenatie wordt onmiddellijk hierna uitgelegd.
<!--------------------------------------------------->
=Concatenatie=
De term '''concatenatie'''
Het aantal spaties tussen tokens van statements heeft geen belang, ze zullen gereduceerd worden tot één spatie. Verwar dit niet met spaties tussen woorden in een constante.
Ook de komma die gebruikt wordt om een instructie op een volgende regel verder te zetten zal vervangen worden door één spatie.
Laten we nu even kijken naar volgende statements:
x=1 ; y=2
say x y /* Toont "1 2" */
say x y /* Toont evenzeer "1 2" */
if x y = '1 2' then say 'OK' /* "OK" want dit is waar! */
say xy /* "XY", want xy niet opgevuld */
say x
if x||,
y = 12 then say '
Tot zover het wel of niet samenvoegen van variabelen. Maar
x=1 ; y=2
say x"\="y
if x"\:"y then say '
if x"-"y = '1-2' then say '
if x"-"y = 1-2 then say '
We willen hiermee duidelijk maken dat geen concatenatieteken nodig is wanneer variabelen aan constanten worden geplakt.
Maar willen we constanten aan constanten ketenen, dan is het concatenatieteken meestal wel nodig:
say "Dit is een zin""!" /* Dit is een zin"! */
say "Dit is een zin"||"!" /* Dit is een zin! */
say "Dit is een zin"'!' /* Dit is een zin! */
Bij het eerste voorbeeld wordt het dubbele aanhalingsteken door een enkel vervangen zoals we al hadden geleerd.
<!--------------------------------------------------->
=Speciale variabelen=
Er zijn 3 gereserveerde variabelen in REXX:
# '''RC''', bevat de returncode van het laatst uitgevoerde
# '''RESULT''', bevat het resultaat van de laatst uitgevoerde functie.
# '''SIGL''', bevat het lijnnummer vanwaar men is gekomen met een '''signal'''
Deze variabelen zullen ten gepaste tijde meer uitleg krijgen.
<!--------------------------------------------------->
=Stems=
REXX kent een speciaal soort variabelen, namelijk '''stems'''. Ze laten o.a. toe om vectoren (arrays) en matrices te simuleren, maar ze zijn meer dan dat.
Een stem bestaat uit een geldig token, gevolgd door een punt. Zo zijn
Zoals
Een stem is enkel een impliciete definitie van een verzameling variabelen. Er zullen pas elementen in voorkomen indien we waarden toekennen aan '''samengestelde variabelen'''.
Een stem heeft geen
<p id="SamVar">Een '''samengestelde variabele''' definieert dus een element van een stem. Ze is opgebouwd uit de naam van
Zo zijn
jan.7 = 25
jan.hello = "Gisteren"
Regel 228 ⟶ 246:
j=7
jan.i.j=12
Tijdens de uitvoering zal REXX het token (de tokens) na het punt interpreteren. Hebben we een constante, zoals in jan.7 dan is
In het tweede geval
In het derde geval,
Net zo zal na de toekenning van de waarde "Hello" aan de variabele ''hello'', het element
In het geval
Als een stem gebruikt wordt om een reeks elementen te bevatten, gebruikt men vaak numerieke staarten (jan.1, jan.2, ...). Er is dan een soort conventie dat het
Noteer dat
piet. = 'Onbekend'
Merk tenslotte op dat een samengestelde variabele er zeer complex kan uitzien:
a="Dit is een hele volzin"
jan.a=17
zal
<!---------------------------------------------------------->
=Programmabuffer ofte Stack=
Gegevens die ingevoerd worden vanuit externe bronnen - meestal het toetsenbord, maar ook andere programma's - kunnen in de zogenaamde '''stack''' of programmabuffer worden opgeslagen in afwachting van verwerking. Het is één van de manieren om gegevens uit te wisselen tussen programma's.
Regel 256 ⟶ 272:
We kunnen deze buffer vergelijken met een stapel speelkaarten. Er kunnen kaarten onderaan of bovenaan worden toegevoegd. Ze worden steeds vanaf boven terug weggenomen.
Worden de kaarten
<br>Worden ze echter onderaan toegevoegd, dan zullen ze
De bevelen die met de stack werken bespreken we in het volgend hoofdstuk.
{{Bericht
|titel=Besluit van dit hoofdstuk.
|bericht=In dit hoofdstuk leerden we over constanten, variabelen, bevelen en functies. We leerden de lees- en bewerkingstekens kennen. Ook hoe labels eruitzien en wat de stack eigenlijk is. De uitleg over stems mocht zeker niet ontbreken. Termen als token, assignatie en statement werden aangebracht.
Probeer in gedachten nog eens elk van deze dingen voor de geest te halen zodat we ze als gekend kunnen beschouwen bij het aanvatten van volgend hoofdstuk.
}}
{{sub}}
| |||