Programmeren in REXX/Fundamenten: verschil tussen versies

Verwijderde inhoud Toegevoegde inhoud
GuyDC (overleg | bijdragen)
Toevoeging van uitleg stack
GuyDC (overleg | bijdragen)
Toevoeging concatenatie en foutjes verbeterd
Regel 11:
Dit heeft als voornaamste gevolg dat er geen declaraties moeten worden gemaakt voor variabelen, zoals in de meeste andere programmeertalen wel het geval is.
 
Daarnaast is REXX in de meeste gevallen een ''[[w:interpreter|interpreter]]''. Enkel opOp mainframe besturingssystemen (zOS en zVM) bestaan compilers voor REXX.
 
Hiermee wordt bedoeld dat REXX het programma lijn voor lijn in 2 afzonderlijke stappen zal uitvoeren. De eerste stap is een interpretatie van de instructie en omzetting naar interne code (te vergelijken met een compilatie) en als tweede stap de uitvoering. Er zijn wel optimalisaties voorzien om niet telkens de interpretatiestap te hoeven doen, bv. in geval van een lus. Maar dit heeft als gevolg dat REXX, het in uitvoeringssnelheid, in de meeste gevallen niet kan winnen van gecompileerde programma's. Daartegenover staat echter eendat mogelijkheidde véélontwikkeling snellervan een werkend programma tedikwijls veel sneller kan. De interpretatiestappen kunnen ook voordelen hebben, bijvoorbeeld bij het bekomendebuggen.
 
Velen beschouwen REXX in eerste instantie enkel als een vervanger voor BAT-files (en ook op de mainframe was dat het eerste doel). Doch, de taal is volledig genoeg om er ook alle andere klassieke programmatietaken mee te vervullen. Op de snelle PC's (en zeker mainframes) van tegenwoordig kan deze 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.
Regel 134:
* '''| &&''' logische of (OR) en exclusieve of (XOR)
Bij de strikte vergelijkingen worden de twee leden strikt genomen zoals ze zijn, in de andere gevallen wordt de korste karakterreeks tot dezelfde lengte als de langste gebracht door er blanco karakters aan toe te voegen.
 
==Concatenatie==
De term '''concatenatie''' die we bij het bewerkingsteken || hebben gebruikt komt van het Engelse werkwoord '''to concatenate''' en betekent: aanelkaar-voegen, -plakken of -ketenen.
 
Toch moeten we hier iets meer over uitweiden.
 
Het aantal spaties tussen de tokens in de instructies heeft geen belang, ze zullen gereduceerd worden tot één blanco. 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 zonder andere voorzorgsmaatregelen vervangen worden door één spatie.
 
Laten we even kijken naar volgende instructies:
x=1
y=2
say x y /* Toont "1 2" */
say x y /* Toont eveneens "1 2" */
if x y = '1 2' then say 'Waar' /* "Waar" want dit is waar! */
say xy /* Toont XY, want variabele xy niet opgevuld */
say x||y /* Toont 12, want we plakken waarden samen */
if x||y=12 then say 'Waar' /* ook "Waar"! */
if x||,
y = 12 then say 'Waar' /* eveneens "Waar" */
Tot zover het wel of niet samenvoegen van variabelen. Maar beschouw nu ook volgende gevallen:
x=1 ; y=2
say x"\="y /* toont "1\=2" */
if x"\:"y then say 'Waar' /* Syntax error ! */
if x"-"y = '1-2' then say 'Waar' /* "Waar" ! */
if x"-"y = 1-2 then say 'Waar' /* Niets, want "1-2" is niet -1 */
Bestudeer laatste gevallen goed.
 
Wat we echter willen duidelijk maken is dat wanneer variabelen naast constanten worden gezet, geen concatenatieteken nodig is.
Maar wanneer constanten naast constanten worden gezet is het concatenatieteken meestal weer 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 boven al leerden.
 
==Speciale variabelen==
Regel 143 ⟶ 177:
 
==Stems==
REXX kent een speciaal soort variabelen, namelijk '''stems''' genaamd. 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 '''jan.''' en '''p.''' geldige namen van stems.
Zoals voorsteeds andere variabelen zijnis de basiswaarde van een stem zijn eigen naam in hoofdletters, dus ''JAN.'' en ''P.'' in ons voorbeeld.
 
OpEen deze manierstem is enkel een impliciete definitie gemaakt van een verzameling variabelen. Er zullen pas elementen in voorkomen indien we waarden toekennen aan '''samengestelde variabelen'''.
Een stem heeft geen gedefinieerde dimensie, er kunnen zoveel elementen aan toegevoegd worden als het geheugen van de computer toelaat.
 
Een '''samengestelde variabele''' is opgebouwd uit de naam van een stem en een symbool.
Regel 156 ⟶ 192:
i=5
jan.i = 17
hello="Hello"
jan.hello = "Goeiedag"
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 ''JAN.7'' de naam van het element van de stem ''JAN.''. Dit element heeft in ons voorbeeld de waarde 27 gekregen.
 
<br>In het geval van ''jan.hello'' komen we terug tot de fundamenten van REXX. ''hello'' is een variabele, die als waarde ''HELLO'' heeft (haar eigen naam in hoofdletters) gezien we er vooraf geen waarde aan hebben toegekend.
In het tweede geval moeten we teruggrijpen naar de fundamenten van REXX. ''hello'' stelt een geldige variabele voor. Maar in ons voorbeeld hebben we er nergens een waarde aan toegekend, dus is haar impliciete waard ''HELLO'' (haar eigen naam in hoofdletters).
''JAN.HELLO'' is dus een element van de stem ''JAN.'' en zal de waarde ''Gisteren'' worden toegewezen.
<br>In het geval van ''jan.i'' zal REXX zien dat ''i'' de waarde 5 bevat, zodat het element nu ''JAN.5'' zal noemen en de waarde 17 zal bevatten.
<br>In het geval ''jan.i.j'' tenslotte hebben beide i en j een waarde gekregen en geven we dus het element ''JAN.5.7'' de waarde 12. Op deze manier kan men een matrix met 2 (of meer) dimensies simuleren, doch voor REXX zijn het allemaal elementen van de stem.
 
<br>In het derde geval van ''jan.i'' zal REXX zien dat ''i'' de waarde 5 bevat, zodat het element nu ''JAN.5'' zal noemen en de waarde 17 zal bevatten.
De dimensie van de stem wordt bij conventie in het element 0 gezet, dus in '''jan.0''' in ons voorbeeld.
 
Net zo zal na de toekenning van de waarde "Hello" aan de variabele ''hello'', het element ''JAN.Hello'' (let op de hoofd- en kleine letters), de waarde "Goeiedag" hebben gekregen.
 
<br>In het geval ''jan.i.j'' tenslotte hebben beide i en j een waarde gekregen en geven we dus het element ''JAN.5.7'' de waarde 12. Op deze manier kan men een matrix met 2 (of meer) dimensies simuleren, doch voor REXX zijn het allemaal elementen van de stem.
 
Alhoewel een stem geen dimensie heeft zal men bij conventie het element 0 meestal opvullen met het aantal gekende elementen van de stem. Dit is niet écht verplicht, doch sommige programma's of functies zullen het aantal elementen dat ze teruggeven in het element stem.0 zetten.
 
Noteer dat we metna een eenvoudige assignatie zoals
piet. = 'Onbekend'
alle elementen van de stem waaraan niet ''expliciet'' een waarde is toegekend deze ''standaardwaarde'' (default waarde) zullen hebben. Dus zullen zowel ''PIET.7'' als ''PIET.Morgen'' een waarde "Onbekend" hebben zolang er geen andere waarde aan wordt toegekend.
 
Merk tenslotte op dat een samengestelde variabele er zeer complex kan uitzien:
Regel 176 ⟶ 219:
 
==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.
 
We kunnen deze buffer vergelijken met een stapel speelkaarten. Er kunnen kaarten onderaan of bovenaan worden toegevoegd. Ze worden steeds vanaf boven terug weggenomen. Als ze onderaan worden toegevoegd zullen ze dus als laatste terug van de stapel worden genomen en spreken we van FIFO (First In, First Out). De kaarten kruipen als het waren van onder naar boven.
 
Worden zede echterkaarten/regels bovenaan bijgevoegd, dan zullen ze dus als eerste terug worden weggenomen en spreken we van '''LIFO''' (Last In, LastFirst Out). De laatst toegevoegde wordt als eerste terug weggenomen.
Worden ze echter onderaan toegevoegd, dan zullen ze dus als laatste terug van de stapel worden genomen en spreken we van '''FIFO''' (First In, First Out). De kaarten kruipen als het waren van onder naar boven, waarbij de oudst toegevoegde eerst worden weggenomen.
 
Er zijn verschillende instructies ('''[[Programmeren in REXX/Syntaxis#PARSE|PARSE]],'''
Informatie afkomstig van https://nl.wikibooks.org Wikibooks NL.
Wikibooks NL is onderdeel van de wikimediafoundation.