**Rexx** er et prosedyralt programmeringsspråk med en engelsklignende syntaks. Språket ble utviklet av Mike Cowlishaw hos IBM i 1979. Det var i starten brukt på IBMs stormaskinsystem CMS, men ble også populært som innebygget skriptspråk i Commodore sitt Amiga operativsystem og IBMs OS/2. Det har også tidvis vært brukt som makrospråk i andre applikasjoner, hovedsakelig på OS/2 og Amiga hvor det har vært enkelt å bruke Rexx fra andre språk.

I dag finnes det implementasjoner av Rexx som er portable over en rekke operativsystemer og plattformer. Rexx finnes i en objektorientert utgave kalt ObjectRexx, og en utgave av som kjører under en Java virtuell maskin kalt NetRexx. Rexx ble godkjent som en ANSI-standard i 1996.

Syntaks
-------

Rexx har en engelsklignende syntaks, og gjør svært lite bruk av skilletegn i forhold til mange andre språk. Målet med språket er at det skal være enkelt å bruke for nybegynnere, men likevel kraftig nok til avanserte oppgaver.

### Hello, World!

Det idiomatiske *Hello, World*-programmet ser slik ut:

```
say "Hello, World!"
```

### Et litt mer utførlig eksempel

```
 /* enkel aritmetikk i rexx */
 
 do forever
    say "Type a number:"
    parse pull number
    if datatype(number) \= "NUM" then do
        say '"'number'" is not a number!'
        exit
    end
 
    factor = 1;
    do while factor <= 10
        say number "*" factor "=" number*factor
        factor = factor + 1
    end
 end

```

Kommentarer skrives på samme måte som i C, mellom */\** og *\*/*. Kommandoen *parse pull* leser inn en linje fra konsoll og lagrer den i variabelen *number*. Funksjonen *datatype()* gir ut en streng som beskriver typen data som er i variabelen *number* (*CHAR* eller *NUM*.) Resten skulle være noenlunde selvforklarende.

Datatyper
---------

Rexx har egentlig kun to datatyper, *symboler* og *strenger*. Symboler brukes som regel til å holde navnet på variabler, mens strenger inneholder de faktiske dataene som programmet bruker.

### Symboler

I Rexx har et symbol alltid en verdi. Et uinitialisert symbol er en streng med sitt eget navn (med store bokstaver). For eksempel:

```
say "Hallo" navn
navn = "Guttorm"
say "Hallo" navn
```

Vil gi følgende resultat:

```
Hallo NAVN
Hallo Guttorm
```

### Strenger

I Rexx er alle data i form av strenger. Numeriske operasjoner opererer på tall representert som strenger, uten begrensninger på størrelse eller presisjon. Den faktiske typen av data i en streng kan utledes ved bruk av den innebygde funksjonen *datatype()*. For eksempel:

```
say datatype("1")
say datatype("Fredrik")
say datatype("3.14")
```

Vil gi resultatet:

```
NUM
CHAR
NUM
```

### Stilker

Rexx har ingen egen strukturert datatype, men gjør bruk av noe som kalles *stilker* (fra engelsk "stems"). Dette er ikke en egentlig datatype, men en konvensjon som er mye brukt. Stilker består av to eller flere symboler og indekser adskilt med punktum.

```
person.0 = 2
person.1.navn = "Harald"
person.1.alder = 36
person.2.navn = "Einar"
person.2.alder = 42

do i = 1 to person.0
   say person.i.navn "er" person.i.alder "år gammel."
end
```

Dette gir følgede resultat:

```
Harald er 36 år gammel.
Einar er 42 år gammel.
```

I tilfeller hvor man bruker stilker som lister, er det konvensjon å bruke indeks 0 til å angi hvor mange elementer det er i listen.

Prosedyrer
----------

En prosedyre er i Rexx en navngitt programsnutt som kan utføre en oppgave, og som kan kalles en eller flere ganger fra den resterende programkoden. Rexx skiller mellom interne og eksterne prosedyrer. 

### Interne prosedyrer

En intern prosedyre er en som er definert i samme programfil som den blir kalt fra, mens en ekstern prosedyre er definert i sin egen programfil.

Her er et eksempel på bruk av en intern prosedyre:

```
say half(16)
say half(6.8)
exit

half:
   parse arg num
   return "Halvparten av" num "er" num/2
```

### Eksterne prosedyrer

Vi kan lage det samme programmet som over med en ekstern funksjon i stedet. Først hovedprogrammet:

```
say half(16)
say half(6.8)
exit
```

I en separat fil som vi kaller *half.rexx* har vi følgende:

```
parse arg num
return "Halvparten av" num "er" num/2
```

Resultatet av de to programmene skal være det samme.

Når et program kaller en prosedyre vil Rexx først se om det finnes en prosedyre med samme navn i den kjørende programfilen. Dersom det ikke gjør det vil den lete etter en egen fil som har det navnet til prosedyren. Regler for hvilke etternavn, og om store bokstaver er viktige eller ikke er noe opp til implementasjonen.

### Lokale variabler

Når man definerer en intern prosedyre som over, vil prosedyren i utgangspunktet ha tilgang til alle varable som er i bruk i programmet. Ofte ønsker vi å benytte lokale variable i en prosedyre, og begrense tilgangen til varable utenfor. Dette kan vi gjøre med *procedure*-kommandoen.

```
a = 4
b = "Nils"
call baklengs
say c
exit

baklengs:
    procedure expose b
    say a
    say reverse(b)
    c = 5
    return
```

Prosedyren *baklengs* har her to lokale variable *a* og *c*, mens den har blitt gitt tilgang til den globale *b*. Resultatet av å kjøre dette programmet vises nedenfor.

```
A
sliN
C
```

Vi ser at prosedyren skriver ut *A* i stedet for verdien av variablene *a* siden denne ikke er definert i prosedyren. Verdien av *c* er på samme måte ikke synlig utenfor prosedyren hvor den er definert. Variabelen *b* har dermed blitt gjort synlig via *expose*-kommandoen, så prosedyren har full tilgang til den.

*Expose*-kommandoen gir en prosedyre tilgang til variable som er tilgjengelige der hvor prosedyren blir kalt fra. Rexx har ikke noe globalt skop for variable, så om ikke variabelen ikke er tilgjengelig der en prosedyre blir kalt fra så finnes det ingen måte å gi prosedyren tilgang til variabelen heller.

Programmet nedenfor vil kanskje ikke gi helt det resultatet man ville forvente:

```
a = "Geir"
b = "Nils"
call forlengs_baklengs
exit

forlengs_baklengs:
   procedure expose a
   say a
   call baklengs
   return

baklengs:
    procedure expose b
    say reverse(b)
    return
```

Resultat:

```
Geir
B
```

Hvis man derimot i prosedyren *forlengs\_baklengs* satte inn:

```
procedure expose a b
```

Så ville resultatet bli mer som forventet:

```
Geir
sliN
```

Referanser
----------

1. ↑  «The Rexx Language Association - What is Rexx?». Besøkt 9. januar 2009.
2. ↑  «The Rexx Language Association - Standard Rexx». Besøkt 12. januar 2009.

Eksterne lenker
---------------

* (en) REXX (programming language) – kategori av bilder, video eller lyd på Commons Rediger på Wikidata
* The Rexx Language Association
* Open Object Rexx
* IBMs NetRexx side
* Regina Rexx Interpreter (portabel over mange plattformer.)

| * v
* d
* r
Programmeringsspråk |
| --- |
| Tidslinje |
| A# **·** ActionScript **·** Ada **·** Alef **·** ALGOL **·** ALGOL 58 **·** ALGOL 60 **·** ALGOL 68 **·** ALTRAN **·** APL **·** AppleScript **·** Argus **·** Assembler **·** Autokode **·** awk **·** B **·** BASIC **·** BCPL **·** BETA **·** BitC **·** BLISS **·** Bourne Shell **·** C **·** C++ **·** C-- **·** CHILL **·** C# **·** C shell **·** Caml **·** Ch **·** Cilk **·** Cilk++ **·** Cilk Plus **·** Clarion **·** Clipper **·** CLISP **·** Clojure **·** CLU **·** COBOL **·** COMAL **·** Common Lisp **·** Concurrent C **·** Concurrent Euclid **·** Concurrent Pascal **·** C shell **·** D **·** Delphi **·** Dylan **·** ECMAScript **·** Eiffel **·** Emacs Lisp **·** Erlang **·** Euclid **·** F\* **·** F# **·** Forth **·** Fortran **·** GNU Common Lisp **·** GNU Pascal **·** Go **·** Haskell **·** HyperTalk **·** Incr Tcl **·** INTERCAL **·** Interlisp **·** Java **·** JavaScript **·** JRuby **·** LaTeX **·** Legoscript **·** LilyPond **·** Limbo **·** Lisp **·** LPC **·** Lua **·** Lynx **·** Mary **·** MATLAB **·** Mesa **·** ML **·** MML **·** Modula **·** Modula-2 **·** MUMPS **·** Objective-C **·** Objective-C++ **·** OCaml **·** OpenVera **·** O'Haskell **·** Pascal **·** Perl **·** PHP **·** Pike **·** PL/I **·** Plankalkül **·** PLEX **·** Prolog **·** Protel **·** Pure Data **·** Python **·** R **·** Ratfor **·** REXX **·** RTL/2 **·** Ruby **·** Rust **·** SAS **·** Scala **·** Scheme **·** Scratch **·** Simula **·** SML **·** Smalltalk **·** SNOBOL **·** Tcsh **·** Tcl **·** TECO **·** TOM **·** Turbo Basic **·** Turbo Pascal **·** Verilog **·** Visual Prolog **·** Turing **·** TypeScript **·** Vala **·** VHDL **·** Visual Basic **·** Flere.. |
| 
* Kategori **Kategori**

 |

|  |  |
| --- | --- |
| Oppslagsverk/autoritetsdata | GND **·** LCCN
 |