

        INTRODUCTIE REXX

                      ˿ ˿    ˿    ˿
                            
                               

                   introductie voor absolute beginners

                             Rob Hamerling


        REXX is de afkorting van "REstructured eXtended eXecutor".  Maar
        ja, daar schiet je nog niet veel mee op!

        REXX is een programmeertaal, vooral bestemd als alternatief voor de
        standaard 'batch'-talen welke op diverse platforms (waaronder
        mainframes) beschikbaar zijn.  De BAT-files van MS/PC-DOS en de
        CMD-files van OS/2 kennen slechts zeer primitieve faciliteiten voor
        het bouwen van procedures.  Met REXX worden de mogelijkheden sterk
        uitgebreid en verbeterd.

        REXX is een complete, gestructureerde programmeertaal, die snel is
        te leren, maar daarnaast vele geavanceerde functies biedt voor
        professionele automatiseringsprojecten.  REXX is niet beperkt tot
        gebruik voor batch-files, er kunnen eigenlijk 'gewone'
        computerprogramma's mee worden gebouwd.

        De voorbeelden in deze introductie zijn beperkt tot de toepassing
        van REXX op PC's onder OS/2 of DOS.































        
                                                        Introductie REXX  1


        KENMERKEN

        REXX heeft de volgende kenmerken:

          Begrijpelijk: snel te leren en door incidentele gebruikers toe
           te passen.
          Vrij formaat: opdrachten mogen op 1 regel worden geplaatst, of
           over meer dan een regel worden gespreid, zonder enige
           positie-afhankelijkheid.
          Faciliteiten voor gestructureerd programmeren.
          Interpreted language: de broncode wordt niet eerst vertaald tot
           een uitvoerbaar programma, maar kan direct worden uitgevoerd.
          Bevat een aantal ingebouwde functies voor veel voorkomende
           bewerkingen.
          Werkt zonder type-aanduiding van variabelen: het is niet nodig
           om aan te geven of een variabele een characterstring of een
           numerieke variabele o.i.d. is.  Tijdens uitvoering wordt dit
           afgeleid uit het soort gebruik.










































        
                                                               Kenmerken  2


        KENNISMAKING

        Om een beetje een plaatje te krijgen hoe een REXX procedure
        (programma) eruit ziet hieronder een voorbeeldje:

        /* Voorbeeld 1 - Mijn eerste REXX programma */
                SAY "Hallo, wat is je naam?"
                PULL wie
                IF wie = "" THEN
                  SAY "Hallo onbekende!"
                ELSE
                  SAY "Hallo" wie
                RETURN

        Toelichting:

        /* ... */           Alles tussen '/*' en '*/' is commentaar.  Door
                            '/*' op de eerste twee posities van de file
                            onderscheidt deze zich van een ordinaire CMD of
                            BAT file.  Commentaar mag op elke willekeurige
                            plaats voorkomen.

        SAY                 Geeft de daarop volgende uitdrukking weer op
                            het scherm.

        "Hallo ..."         Iets tussen '"'-tekens wordt letterlijk
                            weergegeven.

        PULL                Wacht op input van het scherm en verwerkt deze.

        wie                 Is de variabele aan welke de gehele input van
                            'PULL' wordt toegewezen.

        IF                  Test de daarop volgende uitdrukking.

        wie = ""            Is de te testen uitdrukking (test of 'wie' een
                            lege string is).

        THEN                Geeft de tak aan van de procedure die moet
                            worden uitgevoerd als de test 'waar' als
                            uitkomst heeft

        SAY "Hallo onbekende!" Wordt uitgevoerd als er geen input is (een
                            lege string: er is alleen op 'Enter' gedrukt).

        ELSE                Geeft de tak aan welke moet worden uitgevoerd
                            wanneer de test 'onwaar' als uitkomst heeft.

        SAY "Hallo" wie     Geeft op het scherm de tekst "Hallo" plus
                            daarachter de inhoud van de variabele 'wie'.

        RETURN              Keert terug naar de plaats van aanroep.  Bij
                            zelfstandige REXX procedures is de RETURN niet
                            nodig, maar bij procedures die vanuit een ander
                            REXX procedure wordt aangeroepen is RETURN wel
                            verplicht.

        NB. In alle voorbeelden zijn voor de REXX keywords GROTE LETTERS
        gebruikt, ter onderscheid van de eigen tekst.  Maar normaal dat is

        
                                                            Kennismaking  3


        niet nodig, zelfs niet gebruikelijk.  REXX maakt geen onderscheid
        tussen grote en kleine letters voor keywords en namen van
        variabelen.

























































        
                                                            Kennismaking  4


        VARIABELEN EN BEWERKINGEN

        Een 'variabele' is een stukje informatie dat met een naam wordt
        aangeduid, en waarvan de inhoud kan worden gewijzigd, d.m.v.
        'bewerkingen'.  Een voorbeeldje:

        /* Voorbeeld 2 - bewerkingen met variabelen */
                aantal = 100
                valuta = "Euro"
                SAY aantal valuta
                aantal = aantal + 25
                SAY aantal valuta
                RETURN

        Variabelen worden niet van tevoren 'gedeclareerd'.  De toe te
        kennen waarde is in principe een string, zelfs wanneer het een
        getal is.  Wanneer een variabele onderdeel gaat uitmaken van een
        rekenkundige bewerking wordt de string intern naar een numerieke
        waarde omgezet.

        Wanneer een variabele geen waarde toegekend heeft gekregen wordt de
        naam van de variabele weergegeven (in hoofdletters).

        /* Voorbeeld 3 - onbenoemde variabelen */
                aantal = 100
                valuta = "Euro"
                SAY aantal valuta
                aantal = aantal + 25
                SAY "De som is" som valuta
                som    = aantal + 25
                SAY "De som is" som valuta
                koers  = 1.08
                som    = som / koers
                SAY "Bij een koers van" koers "is de som" som "Dollar"

        Regel 6 geeft als output: De som is SOM Euro.  Het woordje 'SOM'
        komt er hier uit omdat de variable 'som' op dat moment nog geen
        waarde toegekend heeft gekregen.  REXX bevat faciliteiten om van te
        voren te bekijken of een variable al een waarde heeft en van welk
        type (numeriek of alphanumeriek).

        Regel 8 geeft als output: "De som is 150 Euro".  Nu heeft 'som' wel
        een waarde en die wordt dan ook weergegeven.  Ga voor jezelf na hoe
        het komt dat 'som' de waarde 150 heeft!

        Met de output van de laatste regel zie je het effect van de
        berekening: "Bij een koers van 1.08 is de som 138.888889 Dollar".
        Dus het maakt ook niet uit met welk soort (gehele of drijvende
        komma) getallen je werkt.  Afronding van de uitkomst op een gewenst
        aantal decimalen is mogelijk, alsmede wetenschappelijke notatie.

        Naast optellen, aftrekken vermenigvuldigen en delen kent REXX ook
        bewerkingen als machtverheffen, logische bewerkingen als 'and',
        'or' etc. en vergelijkings-operaties (gelijk aan, groter dan,
        kleiner dan, etc).





        
                                               Variabelen en Bewerkingen  5


        REEKSEN (ARRAYS)

        Variabelen kunnen ook 'arrays' zijn, zoals in het volgende
        voorbeeld met een 1-dimensionale array, meer-dimensionale arrays
        zijn ook mogelijk.

        /* Voorbeeld 4 - array variabelen */

                maand.1  = 'Januari'
                maand.2  = 'Februari'
                maand.3  = 'Maart'
                maand.4  = 'April'
                maand.5  = 'Mei'
                maand.6  = 'Juni'
                maand.7  = 'Juli'
                maand.8  = 'Augustus'
                maand.9  = 'September'
                maand.10 = 'Oktober'
                maand.11 = 'November'
                maand.12 = 'December'

                SAY "Geef het nummer van de maand "
                PULL num
                IF num > 0 & num < 13 THEN
                  SAY "Maand nummer" num "heet:" maand.num
                ELSE
                  SAY "sorry, een jaar heeft maar twaalf maanden!"


        Om te bereiken dat niet buiten het toegewezen gebied van de array
        wordt gekomen wordt eerst getest of het opgegeven nummer uit de
        reeks 1..12 is.  Verder bevat dit voorbeeld een samengestelde tests
        met een 'and'-conditie (d.m.v. het '&'-teken).  Natuurlijk is er
        ook een 'or'-conditie met het '|'-teken beschikbaar.  Door gebruik
        van haakjes '(' en ')' kunnen  complexe condities worden
        samengesteld.

        Ook zie je in dit voorbeeld dat enkele en dubbele quotes equivalent
        zijn.  Maar na een openings-quote is de andere soort inaktief tot
        de sluitings-quote.  Dit is de wijze waarop quotes in de output
        kunnen worden weergegeven!



















        
                                                        Reeksen (arrays)  6


        HERHAALDE BEWERKINGEN

        REXX kent verschillende vormen van herhaalde bewerkingen:

        DO FOREVER          Onbeperkte herhaling van een groep bewerkingen.
                            Er kan uit de 'loop' worden ontsnapt d.m.v.
                            'leave'.

        DO times            herhaal de bewerking 'times' keer

        DO i=1 TO n         herhaal de bewerking totdat 'i' waarde 'n'
                            heeft bereikt (inclusief)

        DO WHILE (cond.)    onbeperte herhaling ZOLANG een bepaalde
                            conditie zich voordoet

        DO UNTIL (cond.)    onbeperte herhaling TOTDAT een bepaalde
                            conditie zich voordoet

        Een voorbeeld van een 'do until' is opgenomen in de volgende
        procedure, waarmee de vierkantswortel uit een getal wordt berekend.
        Een populaire methode hiervoor is de snel convergerende reeks:

            W[i+1] = (W[i] + A / W[i]) / 2

        Hiermede wordt stap-voor-stap een volgende benadering van de
        vierkantswortel 'W' van een willekeurig positief(!) getal 'A'
        verkregen.  Als eerste benadering nemen we A/2.  Het aantal stapjes
        'i' dat genomen moet worden hangt af van de gewenste
        nauwkeurigheid.  Wanneer de laatste decimaal niet meer verandert is
        het doel bereikt.

        /* Voorbeeld 5 - groepen (herhaalde) bewerkingen */

                ARG getal cijfers                       /* commandline argumenten */
                IF  getal = ""  |  cijfers = "" THEN
                  DO
                    SAY "Commando syntax is"
                    SAY "    VB5  <basis_getal>  <aantal_cijfers>"
                    RETURN
                  END

                IF  getal < 0  |  cijfers < 2 THEN
                  DO
                    SAY "Alleen positieve getallen, en resultaat minstens 2 cijfers"
                    RETURN
                  END

                NUMERIC DIGITS cijfers                  /* gewenste nauwkeurigheid */
                wortel = getal / 2                      /* eerste benadering */
                vorige = wortel
                i = 1                                   /* aantal benaderingen */
                DO UNTIL wortel = vorige                /* tot nauwk. behaald */
                  i = i + 1                             /* tel benaderingen */
                  vorige = wortel                       /* onthoud huidige waarde */
                  wortel = (wortel + getal / wortel) / 2    /* stapje dichterbij */
                END

                SAY "De wortel uit" getal "is" wortel

        
                                                   Herhaalde bewerkingen  7


                SAY "("i" benaderingen)"
                RETURN



        Voor het berekenen van de 'wortel' uit het getal wordt de 'loop'
        tussen 'DO UNTIL' en 'END' herhaald totdat de laatste decimaal niet
        meer verandert.  Deze 'loop' kan nog iets compacter geschreven
        worden als:

                DO i = 1 UNTIL wortel = vorige
                  vorige = wortel
                  wortel = (wortel + getal / wortel) / 2
                END

        Zoals je ziet kunnen (sommige) condities worden gecombineerd.

        Dit voorbeeld loopt enigszins vooruit op het volgende hoofdstuk.
        De aan een REXX procedure meegegeven 'commandline' argumenten
        kunnen worden opgepikt met de functies ARG en PARSE.








































        
                                                   Herhaalde bewerkingen  8


        KEYWORD-INSTRUKTIES EN FUNKTIES

        Een aantal bewerkingen van REXX worden d.m.v. een 'keyword'
        aangesproken in plaats van een bewerkingsteken.  Typerend voor een
        KEYWORD is dat de bewerking geen waarde teruggeeft, en doet dus
        alleen iets met de betrokken variabelen.  Dit in tegenstelling tot
        FUNKTIES, die wel een waarde teruggeven, welke wordt 'ingevoegd' op
        de plaats van aanroep, alsof het een gewone variabele was.  De
        waarde kan een getal of een string zijn (REXX maakt immers voor de
        gebruiker geen onderscheid!).

        Enkele voorbeelden van keyword instrukties hebben we al gezien,
        zoals SAY, PULL, IF, THEN, ELSE, DO, WHILE, UNTIL.  Enkele andere
        zijn:

        CALL                Voor het aanroepen van een procedure zonder
                            return-waarde.  Dit kan naar externe of interne
                            REXX procedure springen of een OS commando
                            uitvoeren.

        RETURN              Be-eindigt de procedure en keert terug naar de
                            plaats van aanroep.  Er kan een return-waarde
                            worden teruggegeven (vergelijk ERRORLEVEL).

        PARSE               Hiermede kunnen strings worden gesplitst en de
                            afzonderlijke delen aan variabelen worden
                            toegekend.  Parse wordt veel gebruikt voor het
                            analyseren van de inhoud van strings m.b.v.
                            'patronen' en van parameters welke bij de
                            aanroep van procedures worden meegegeven.

        Enkele voorbeelden van standaard REXX functies:

        FORMAT              Vormt een variabele of uitdrukking om in een
                            getal met een aan te geven aantal cijfers voor
                            en achter de komma.

        DATE                Geeft de systeemdatum.  Met een parameter kan
                            worden gekozen uit een aantal formaten, zoals
                            ddd; dd/mm/yyyy; mm/dd/yy; dd mon yy; etc.

        C2D C2X             Voor omzetting van een variabele van
                            'character' naar 'decimale' of 'hexadecimale'
                            notatie.  Naast deze zijn er nog: B2X B2C D2X
                            D2C X2B X2C X2D ('B' staat voor 'binair').

        SUBSTR              Hiermede kan uit een willekeurige string een
                            deel worden geselecteerd.  Een toepassing
                            hiervan is opgenomen in voorbeeld 6 in het
                            volgende hoofdstuk.

        WORD                Lijkt op SUBSTR, maar selecteert gehele woorden
                            uit zinnen.

        Het is ook mogelijk om zelf procedures en functies te bouwen.  Dit
        kunnen 'interne' functies zijn, welke op een andere plaats in
        dezelfde file voorkomen, maar ook externe functies: andere REXX
        files.


        
                                         Keyword-instrukties en Funkties  9


        Elke REXX procedure kan als functie vanuit een andere REXX
        procedure of vanaf de commandline worden aangeroepen.  Hiermede is
        het mogelijk om elke procedure afzonderlijk te testen en met een
        samenstel van op zich relatief eenvoudige procedures een vrij
        complex automatiseringsproces te bouwen.























































        
                                        Keyword-instrukties en Funkties  10


        WERKEN MET FILES

        REXX heeft aantal functie voor het werken met files.  Files kunnen
        vanuit een REXX-procedure rechtstreeks worden gelezen, aangemaakt,
        gewijzigd, etc.

        Door de vele mogelijkheden van REXX voor het manipuleren van
        strings, kunnen gemakkelijk en handig file specifikaties worden
        gemaakt en of de inhoud van files worden gewijzigd.  Als voorbeeld
        hieronder het toevoegen van een regel aan een logfile.  Elke dag
        moet een nieuwe logfile worden aangemaakt.  Alle log-records van
        dezelfde dag moet in dezelfde logfile komen, compleet met de
        bijbehorende tijd.

        /* Voorbeeld 6 - werken met files, datum en tijd */

               vandaag = DATE("S")                          /* formaat: yyyymmdd */
               logname = "vb"SUBSTR(vandaag, 3, 6)".log"    /* (bijv. vb021113.log */

               rc      = LINEOUT(logname, TIME('n') "= tijd van wegschrijven.")

               logsize = STREAM(logname, 'C', "query size")
               SAY  "De huidige log '"logname"' is" logsize "bytes groot."

               RETURN

        Het toevoegen van een record gebeurt met de 'LINEOUT'-functie.
        Evenzo is er een 'LINEIN'-functie voor het lezen van files.  REXX
        begint bij het lezen van een file (LINEIN) altijd vooraan, en bij
        het schrijven (LINEOUT) altijd achteraan, maar het kan ook anders.
        Het openen en sluiten van files doet REXX automatisch, en behoeft
        alleen bij uitzondering expliciet in de procedure te worden
        opgenomen.



























        
                                                       Werken met Files  11


        INTERFACE MET HET OPERATING SYSTEM

        Zoals eerder gezegd is REXX vooral bedoeld als alternatief van CMD
        of BAT files.  De wijze waarop dat gebeurt is even simpel als voor
        de hand liggend: alle instrukties die REXX niet zelf verder kan
        verwerken worden aan het Operating Systeem als commando aangeboden.
        Op die wijze kunnen dus standaard commando's van OS/2 of DOS worden
        aangeroepen, maar ook 'gewone' programma's.

        /* Voorbeeld 7 - Interface met het operating system */

                olddir = DIRECTORY()               /* bewaar huidige directory */
                tmpdir = "test"                    /* naam tijdelijke directory */
                mkdir tmpdir                       /* maak nieuwe directory */
                xcopy "vb*.cmd" tmpdir             /* copy files */
                CALL  DIRECTORY tmpdir             /* switch naar andere dir. */
                dir                                /* DIR commando */
                erase "*.*"                        /* maak dir leeg */
                call  DIRECTORY olddir             /* terug naar vorige */
                rmdir tmpdir                       /* verwijder tijdelijke dir. */
                RETURN

        Het bovenstaande voorbeeld toont een manipulatie met directories en
        files, alleen om aan te geven hoe OS commando's (interne en
        externe!) worden aangeroepen: niet anders dan REXX functies zelf.
        Het hangt puur van de naam van de functie af wat er zal gebeuren.


































        
                                     Interface met het Operating System  12


        UITBREIDINGS BIBLIOTHEKEN

        REXX heeft een gepubliceerd API (Application Programming
        Interface).  Daarmeede is het mogelijk om REXX uit te breiden met
        eigen functies.  Onder OS/2 zal dat meestal worden gedaan m.b.v.
        een .DLL (Dynamic Link Library).  De extra functies kunnen worden
        opgeroepen en uitgevoerd vanuit elke REXX procedure, nadat ze door
        een speciale oproep zijn geaktiveerd.

        Bij OS/2 wordt standaard een REXX utility (-functie-) bibliotheek
        meegeleverd voor diverse aanvullende bewerkingen.  Heel handige
        functies daarin zijn bijvoorbeeld SysFileTree en SysFileSearch,
        waarmede directory informatie en file inhoud als variabelen in de
        REXX procedure beschikbaar kunnen worden gemaakt.  Ter illustratie
        hiervan wordt in het volgende voorbeeld van elk van de in dit
        artikeltje opgenomen voorbeelden nagegaan hoe vaak het woord 'say'
        wordt gebruikt, en op welke regels.

        /* Voorbeeld 8 - Standaard OS/2 utilities voor REXX */

                /* aktiveren van de utility bibliotheek */
                CALL RxFuncAdd 'SysLoadFuncs', 'RexxUtil', 'SysLoadFuncs'
                CALL SysLoadFuncs

                CALL SysFileTree "vb*.*", file          /* zoek bepaalde files */
                DO i = 1 TO file.0                      /* alle gevonden files */
                  naam = WORD(file.i, 5)                /* selecteer filespec */
                  grootte = WORD(file.i, 3)             /* selecteer filesize */
                  CALL SysFileSearch "say", naam, "hit.", "N"    /* zoek 'say' */
                  SAY  naam "("grootte "bytes), bevat" hit.0 "regel(s) met 'say'"
                  IF hit.0 > 0 THEN
                    DO j=1 TO hit.0
                      SAY hit.j                         /* laat gehele regel zien */
                    END
                  SAY  ""                               /* blanko regel */
                END
                RETURN


        Met een variant van deze procedure kunnen gemakkelijk documenten
        worden doorzocht, bijv. op een telefoonnummer voor omnummering.  In
        het onderstaande voorbeeld worden alle sub-directories van een
        programma-bibliotheek doorzocht!

        /* Voorbeeld 8a - Standaard OS/2 utilities voor REXX */

                CALL RxFuncAdd 'SysLoadFuncs', 'RexxUtil', 'SysLoadFuncs'
                CALL SysLoadFuncs

                telnr = "123"                           /* te zoeken string */
                fspec = "f:\c\*.?"                      /* te doorzoeken files */

                CALL SysFileTree fspec, file, 'FSO'     /* filenames in subdirs */
                DO i = 1 TO file.0                      /* alle matching files */
                  CALL SysFileSearch telnr, file.i, 'hit.', 'N'    /* zoek */
                  IF hit.0 > 0 THEN
                    DO
                      SAY  file.i 'bevat' hit.0 'regel(s) met' telnr
                      DO j=1 TO hit.0

        
                                              Uitbreidings bibliotheken  13


                        SAY hit.j                       /* laat regel zien */
                      END
                      SAY ''                            /* spatieregel */
                    END
                END
                RETURN


        Er zijn ook andere libraries beschikbaar voor uitbreiding van REXX
        onder OS/2 met specifieke functies, zoals:

          'Object REXX', standaard bij OS/2 Warp 4 voor object oriented
           programming en met een interface naar DB/2.

          REXXBASE, waarmede dBase files rechtstreeks met REXX procedures
           kunnen worden bewerkt.

          'Visual REXX' voor een GUI (Grafical User Interface), zoals
           VisPro/REXX en VX&bullet.REXX.









































        
                                              Uitbreidings bibliotheken  14


        SAMENVATTING

        Aan de hand van een aantal voorbeelden en de toelichting erbij
        hebben we gezien welke mogelijkheden REXX als programmeertaal
        biedt, alsmede hoe eenvoudig het gebruik ervan is.  Dit was
        natuurlijk maar een kleine selectie van de alle beschikbare
        faciliteiten, en kan slechts een globale indruk geven.  Standaard
        meegeleverde meer geavanceerd aspekten als multi-tasking, queuing,
        trace, debug, e.d. vallen buiten het bestek van een introductie!

        Het gebruik van REXX als alternatief voor OS/2 of DOS batch-files
        is niet zo uitgebreid aan de orde gekomen.  Niettemin lijkt het me
        onweerlegbaar dat REXX een aanzienlijke verbetering is t.o.v. de
        standaard mogelijkheden van OS/2-CMD en DOS-BAT files.

        Misschien is het opgevallen dat in geen van de voorbeelden een
        'GOTO' wordt gebruikt.  Bij 'structured programming' past geen
        'GOTO', en REXX kent 'm dan ook niet.  Dit in tegenstelling tot de
        standaard OS/2 en DOS batch-taal, waarbij eigenlijk alleen met
        'GOTO' de uitvoeringsvolgorde kan worden veranderd!

        Naast 'batch'-taal is REXX als universele programmeertaal een goed
        alternatief voor het (nog?) zo populaire BASIC.  Het is
        bijvoorbeeld zeer geschikt voor prototyping en om 'eenmalige'
        problemen op te lossen (bijv. allerlei soorten puzzels).

        REXX wordt standaard bij IBM OS/2 meegeleverd, en bij IBM PC-DOS
        vanaf versie 7.  Er zijn vele uitbreidingsbibliotheken beschikbaar
        voor speciale functies.































        
                                                           Samenvatting  15


        LITERATUUR

        Voor wie meer van REXX wil weten zijn er verscheidene bronnen van
        informatie, zoals:

          OS/2 Warp REXX users guide: \OS2\BOOK\REXX.INF
          OS/2 Warp toolkit (object) REXX Programmers Guide:
           \TOOLKIT\BOOK\REXXPG.INF
          IBM manual S01F-0283 REXX User's guide
          IBM manual S01F-0283 REXX Reference
          OS/2 REXX: From Bark to Byte, IBM GG24-4199
          The REXX Language, a practical approach to programming, Mike
           Colishaw, Prentice Hall
          Teach yourself REXX in 21 days, William and Ester Schindler,
           SAMS
          OS/2 2.1 REXX Handbook: Basics, Applications and Tips, Hallet
           German, Van Nostrand Reinhold
          The REXX Handbook, Gabriel Goldberg and Philip H. Smith III,
           McGraw-Hill
          Programming in REXX, Charles Daney, McGraw-Hill
          REXX: Advanced Techniques for Programmers, Peter C. Kiesel,
           McGraw-Hill
          Object REXX for OS/2 Warp, Trevor Turton and Ueli Wahli, IBM
           (incl.  CDROM)
          De FWREXX filearea op Bulletin Boards, en ook de Hobbes CDROMs
           en de Hobbes Internet site bevat een aantal documentatie files
           en vele voorbeelden van REXX procedures en handige hulpmiddelen
           welke gebruik maken van REXX.  Zie bijvoorbeeld
           http://hobbes.nmsu.edu/pub/os2/dev/rexx RXTT33.ZIP: REXX Tips &
           Tricks v3.30,

        

        Rob Hamerling, november 2002.


























        
                                                             Literatuur  16
