Rexx Shopping
REXX 		Articles about
Rexx 		Website Links For
Rexx 		 

Information About

Rexx
  CATEGORIES ABOUT REXX
   
ibm software
   
programming languages
   
scripting languages
   
text-oriented programming languages
   
command shells
   
APPAREL
BABY
BEAUTY
BOOKS
CAR TOYS
CELL PHONES
DVD'S
ELECTRONICS
GOURMET FOOD
GROCERIES
HEALTH & PERSONAL
HOME & GARDEN
JEWELRY
MUSIC
MUSIC INSTRUMENTS
OFFICE PRODUCTS
SOFTWARE
SPORTING GOODS
TOOLS & HARDWARE
TOYS
VIDEO GAMES
SHOPPING HOME
MORE SHOPPING...



  paradigm , Procedural , Structured
  year 1979
  designer Mike Cowlishaw
  developer Mike Cowlishaw & IBM
  latest Release Version ANSI X3274
  latest Release Date 1996
  typing Dynamic , everything is a String <small>(ClassicREXX)</small> or Object <small>(ObjectRexx)</small>
  implementations IBM NetREXX , Open Object Rexx , Regina , others
  dialects Open Object REXX , NetRexx
  influenced By PL/I , EXEC 2 , BASIC
  influenced ECMAScript


REXX (REstructured eXtended eXecutor) is an Interpreted Computer Programming Language which was developed at IBM . It is a structured high-level programming language which was designed to be both easy to learn and easy to read. Both commercial and Open Source Interpreters for REXX are available on a wide range of computing platforms, and compilers are available for IBM mainframes.


FEATURES

REXX has the following characteristics and features:


REXX has just twenty-three, largely self-evident, instructions (''e.g.'', call, '''parse''', and '''select''') with minimal punctuation and formatting requirements. It is essentially an almost Free-form Language with only one data-type, the character string; this philosophy means that all data are visible (symbolic) and debugging and tracing are simplified.

REXX syntax looks similar to PL/I , but has fewer notations; this makes it harder to parse (by program) but easier to use.


HISTORY

REXX was designed and first implemented, in Assembly Language , as an ‘own-time’ project between 20 March 1979 and mid- 1982 by Mike Cowlishaw of IBM, originally as a Scripting Programming Language to replace the languages EXEC and EXEC 2 1. It was designed to be a Macro or scripting language for any system. As such, REXX is considered a precursor to Tcl and Python .

It was first described in public at the SHARE 56 conference in Houston, Texas, in 1981 2, where customer reaction, championed by Ted Johnston of SLAC , led to it being shipped as an IBM product in 1982 .

Over the years IBM included REXX in almost all of its operating systems ( VM/CMS , VM/GCS , MVS TSO/E , AS/400 , VSE/ESA , AIX , CICS/ESA , PC-DOS , and OS/2 ), and has made versions available for Novell NetWare , Windows , Java , and Linux .

The first non-IBM version was written for PC-DOS by Charles Daney in 1984/5. Other versions have also been developed for Atari , Amiga , Unix (many variants), Solaris , DEC , Windows , Windows CE , PocketPC , MS-DOS , Palm OS , QNX , OS/2 , Linux , BeOS , EPOC32 , AtheOS , OpenVMS , OpenEdition , Macintosh , and Mac OS X .
3

The Amiga version of Rexx, called ARexx was included with AmigaOS 2 onwards and was popular for scripting as well as application control. Many Amiga applications have "ARexx ports" built into them which allows control of the application via a user defined script.

Several freeware versions of Rexx are available. In 1992 , the two most widely-used Open-source ports appeared: Ian Collier's REXX/imc for Unix and Anders Christensen's Regina (later adopted by Mark Hessling) for Windows and Linux. BREXX is well-known for WinCE and PocketPC platforms.

In 1996 ANSI published a standard for REXX:
ANSI X3.274–1996 “Information Technology – Programming Language REXX”. More than two dozen books on REXX have been published since 1985 .

Since the mid- 1990s , two newer variants of REXX have appeared:

  • NetRexx – which compiles to Java Byte-code via Java source code; this has no reserved keywords at all, and uses the Java object model, and is therefore not generally upwards-compatible with ‘classic’ REXX.

  • Object Rexx – which is an Object-oriented generally upwards-compatible version of REXX.


In 1990 , Cathy Dager of SLAC organized the first independent REXX symposium, which led to the forming of the REXX Language Association. Symposiums are held annually.

Rexx marked its 25th anniversary on 20 March 2004 , which was celebrated at the REXX Language Association’s 15th International REXX Symposium in Böblingen, Germany, in May 2004.

On October 12 , 2004 , IBM announced their plan to release their Object Rexx implementation under the Common Public License .

On February 22 , 2005 , the first public release of ooRexx (Open Object Rexx) was announced.


Spelling


In plain text, Cowlishaw seems to prefer Rexx, whereas IBM documents and the majority of the web uses REXX. The ANSI standard uses the form preferred by the standardization committee, which has small capitals for the final three letters: REXX.
This style is also used on the cover pages of "The Rexx Language" TRL and "The NetRexx Language" written by Michael Cowlishaw. Originally it was just called "Rex" because the author liked how it sounded, the extra "x" was added to avoid collisions with other products' names. The expansion of Rexx to the Restructured E'''x'''tended E'''x'''ecutor is a Bacronym .


SYNTAX


Looping


The loop control structure in Rexx always begins with a DO and ends with an '''END''' but comes in several varieties.

Traditional forms:

do '''until''' {Link without Title}
{Link without Title}
end



do '''while''' {Link without Title}
{Link without Title}
end

With an index variable:

do ''i'' = ''x'' ''y'' ''z''
{Link without Title}
end


The step increment (''z'' above) may be omitted and defaults to 1. The upper limit (''y'' above) can also be omitted, which makes the loop continue forever. You can also loop forever without an index variable with this:

do '''forever'''
{Link without Title}
end


A program can break out of the current loop with the leave instruction (which is the normal way to exit a "forever" loop), or can short-circuit it with the '''iterate''' instruction. The '''do while''' and '''do until''' forms are equivalent to:

do '''forever'''
if {Link without Title} '''then''' '''leave'''
{Link without Title}
end
and:

do '''forever'''
{Link without Title}
if {Link without Title} '''then''' '''leave'''
end



Conditionals


Testing conditions with IF


if {Link without Title} '''then'''
do
{Link without Title}
end
else
do
{Link without Title}
end


For single instructions, DO and '''END''' can also be omitted:


if {Link without Title} '''then'''
{Link without Title}
else
{Link without Title}



Testing for multiple conditions


SELECT is REXX's CASE structure, like many other constructs derived from PL/I :

select
when {Link without Title} '''then'''
{Link without Title}
when {Link without Title} '''then'''
do
{Link without Title}
end
otherwise
{Link without Title} or NOP
end


NOP indicates no instruction is to be executed.


Simple Variables

Variables in REXX are typeless, and initially are evaluated as their names, in upper case. Thus a variable's ''type'' can vary with its use in the program:


  • => HELLO ---/

    • hello = 25

  • => 25 ---/

    • hello = "say 5 + 3"

  • => say 5 + 3 ---/

  • => 8 ---/

    • drop hello

  • => HELLO ---/

    •



Compound variables


Unlike many other programming languages, classic REXX has no direct support for arrays of variables addressed by a numerical index. Instead it provides compound variables. A compound variable consists of a stem followed by a tail. A . (dot) is used to join the stem to the tail. If the tails used are numeric, it is easy to produce the same effect as an array.


do i = 1 '''to''' 10
''stem.i'' = 10 - i
end


Afterwards the following variables with the following values exist: stem.1 = 9, stem.2 = 8, stem.3 = 7...

Unlike arrays, the index for a stem variable is not required to have an integer value. For example, the following code is valid:

i = 'Monday'
stem.i = 2


In Rexx it is also possible to set a default value for a stem.

stem. = 'Unknown'
stem.1 = 'USA'
stem.44 = 'UK'
stem.33 = 'France'


After these assignments the term stem.3 would produce 'Unknown'.

The whole stem can also be erased with the DROP statement.

drop stem.


This also has the effect of removing any default value set previously.

By convention (and not as part of the language) the compound stem.0 is often used to keep track of how many items are in a stem, for example a procedure to add a word to a list might be coded like this:

add_word: procedure expose dictionary.
parse arg w
n = dictionary.0 + 1
dictionary.n = w
dictionary.0 = n
return


It is also possible to have multiple elements in the tail of a compound variable. For example:

m = 'July'
d = 15
y = 2005
day.y.m.d = 'Friday'


Multiple numerical tail elements can be used to provide the effect of a multi-dimensional array.

Features similar to Rexx compound variables are found in many other languages ('' Associative Array s'' in AWK , '' Hash es'' in Perl , ''Hashtables'' in Java , ''etc''). Most of these languages provide an instruction to iterate over all the keys (or ''tails'' in Rexx terms) of such a construct, but this is lacking in classic Rexx. Instead it is necessary to keep auxiliary lists of tail values as appropriate.
For example in a program to count words the following procedure might be used to record each occurrence of a word.

add_word: procedure expose count. word_list
parse arg w .
  • assume count. has been set to 0 ---/

    • if count.w = 1 '''then''' word_list = word_list w

return


and then later

do i = 1 '''to''' words(word_list)
w = word(word_list,i)
say w count.w
end


At the cost of some opacity it is possible to combine these techniques into a single stem.

add_word: procedure expose dictionary.
parse arg w .
dictionary.w = dictionary.w + 1
  • assume dictionary. = 0 ---/

    • then do

n = dictionary.0+1
dictionary.n = w
dictionary.0 = n
end
return

and later

do i = 1 '''to''' dictionary.0
w = dictionary.i
say i w dictionary.w
end

However Rexx provides no safety net here, so if one of your words happens to be a whole number less than dictionary.0 the above technique will fail mysteriously.

Recent implementations of Rexx, include IBM 's Object Rexx and the open source implementations like Regina and OORexx include a new language construct to simplify iteration over the value of a stem.

do i '''over''' stem.
say i '-->' stem.i
end



Keyword instructions


PARSE


The PARSE instruction is particularly powerful; it combines some useful string-handling functions. Its syntax is:


parse {Link without Title} ''origin template''


where ''origin'' specifies the source:
  • arg (arguments, at top level tail of command line)

  • linein (standard input, e.g. keyboard)

  • pull (REXX data queue or standard input)

  • source (info on how program was executed)

  • value (an expression) '''with'''

  • : the keyword ''with'' is required to indicate where the expression ends

  • var (a variable)

  • version (version/release number)


and ''template'' can be:
  • list of variables

  • column number delimiters

  • literal delimiters


upper is optional; if you specify it, data will be converted to upper case.

Examples:

Using a list of variables as template


myVar = "John Smith"
parse var myVar firstName lastName
say "First name is:" firstName
say "Last name is:" lastName


displays the following:


First name is: John
Last name is: Smith


Using a delimiter as template:


myVar = "Smith, John"
parse var myVar LastName "," FirstName
say "First name is:" firstName
say "Last name is:" lastName


also displays the following:


First name is: John
Last name is: Smith


Using column number delimiters:


myVar = "(202) 123-1234"
parse var MyVar 2 AreaCode 5 7 SubNumber
say "Area code is:" AreaCode
say "Subscriber number is:" SubNumber


displays the following:


Area code is: 202
Subscriber number is: 123-1234


A template can use a combination of variables, literal delimiters, and column number delimiters.


INTERPRET


The INTERPRET instruction is very powerful and one of the two reasons why writing REXX compilers isn't trivial, the other reason being REXX's decimal arbitrary precision arithmetic:


  • a touch of LISP ---/

    • X = 'square'

  { Border "1" class="wikitable" cellspacing="2" cellspacing="2"