Introductory examples

Here are several introductory Rexx programming examples.

1. File search

2. Directory listing revision

3. Data queue processing

4. Lottery number generation

5. Prime numbers

File search

/* find.rex -- file search utility */ parse arg infile textToFind textToFind = translate( strip( textToFind ) ) /* convert to uppercase */ if textToFind = '' then call usagemsg 'Please enter the text to find...' if lines( infile ) = 0 then call usagemsg 'The input file is empty...' do lineNumber = 1 for lines( infile ) lin = linein( infile ) if pos( textToFind, translate( lin ) ) > 0 then say lineNumber'.' lin end return 0 usagemsg : procedure if arg(1) <> '' then do say 'Note:' arg(1) say '' end say 'Usage:' say ' rexx find infile textToFind' exit 1

• The find.rex program locates lines within a text file, that contains a target text string.

• The program's command line argument string is processed by the parse instruction. The file to search is provided as the first word. The target text string is obtained as the remainder of the command line argument string. Spaces at the end of the target text string are removed by the strip built-in function. Then, the text to find is converted to upper case by the translate built-in function. As the lines are processed they are also converted to upper case. This allows this simple program to locate all lines that contain the target text string, regardless of character case.

• If the text to find is empty, an error note and usage information is displayed. The usagemsg procedure is invoked by the call instruction.

• The lines built-in function is used to determine if the number of lines in the text file is 0. If so an error note and usage information is displayed.

• The lines in the text file are processed iteratively by the do loop. The loop proceeds for the number of lines in the text file. The current line number is incremented during each loop iteration. This allows located lines to be preceded by the corresponding line number.

• The linein built-in function is used to read the text file lines. The line is assigned to the lin variable, in the original character case.

• The pos built-in function is used to determine if the text to find is contained in the current line. The text within the line is converted to upper case by the translate built-in function. As mentioned before, this allows this simple program to locate all lines that contain the target text string, regardless of character case.

• If the position of the text to locate is greater than 0, then the text line contains the target string. The associated line number and the original text line are written with the say instruction.

• The loop is concluded by an end instruction.

• The main program is concluded by an return instruction.

• An error note and usage information is displayed by the usagemsg procedure. It is assumed the program is invoked by a Rexx interpreter named rexx. Since the usagemsg procedure concludes with an exit instruction, the program concludes at that point.

Directory listing revision

/* directoryListingRevision.rex revise lines in directory listing so they can be sorted chronologically usage: rexx directoryListingRevision < directoryListing > sortableDirectoryListing assume an input line has the following format: 07-27-01 11:01PM 1237 abc.dat the resulting output line will be 2001/07/27 23:01 1237 abc.dat */ do while lines() > 1 /* acquire a directory listing line, and assign text segments to variables */ parse linein month'-'day'-'year hour':'minute +2 amOrPm size file /* adjust year to four digit format */ if year > 70 then year = year + 1900 else year = year + 2000 /* adjust hour to 24 hour clock format */ if amOrPm = 'PM' & hr <> 12 then hour = hour + 12 /* emit sortable line */ say year'/'month'/'day hour':'minute right( size, 10 ) file end

• The directoryListingRevision.rex program revises the lines in a directory listing so that they can be sorted chronologically. The lines might also be sortable by size or file name, if the sort utility accepts positional offsets. The sort utility must also support numeric comparisons in order to sort by size.

• Lines are processed iteratively by the do instruction, which repeats while lines remain in the default input stream..

• Input lines are partitioned into components by the parse instruction.

• A two digit year is adjusted to four digit format by adding 1900 if the year is greater than 70, and 2000 otherwise.

• An hour value in 12 hour civilian format is adjusted to 24 hour format by adding 12, if the 'AM' or 'PM' indicator is 'PM'.

• The output line is written to the default output stream with the say instruction.

Data queue example

/* prepare a sequence of programs to process */ queue 'Program1 -- main program' queue 'Subprog1 -- subprogram 1' queue 'Subprog2 -- subprogram 2' programs = '' do queued() parse pull program . 'cc' program'.c' if rc <> 0 then do say 'An error occurred while compiling' program'.c ...' rc exit 1 end programs = programs program'.obj' end 'link /out:Module.exe' programs if rc <> 0 then do say 'An error occurred while linking Module.exe ... code:' rc exit 1 end exit 0

Lottery number generation

/* lottery.rex -- the following generates 6 random lottery numbers */ limit = 49 /* the highest value is 49, adjust as necessary */ numbers = '' /* the selected numbers will be added to this variable */ /* prepare 6 random numbers */ do until words( numbers ) = 6 /* need 6 numbers */ number = random( 1, limit ) /* get another random number */ if wordpos( number, numbers ) = 0 then /* not already selected? */ numbers = numbers number /* remember number */ end /* end loop */ /* format results */ say 'Here come 6 numbers [range: 1-'limit']' /* title line */ say numbers /* show 6 numbers */ say 'Good luck' /* closing remark */

• The program lottery.rex generates 6 unique random numbers between 1 and a limit value. The default limit value is 49. You can adjust the limit when you need numbers within a different range. If you do not need unique numbers you can eliminate the if instruction within the loop. If you do not need exactly 6 numbers you can adjust the number of numbers in the do instruction.

• The do instruction repeats the selection of random numbers until the number of words is 6. The selected values are stored as words in the variable named numbers. Initially the numbers value is set to the empty string.

• During each iteration of the do loop the following steps are performed:
  1. A random number between 1 and the limit is selected.

  2. The number is checked to determine if was selected before. When the word position is 0, then this number is not in the list of selected numbers.

  3. Unique numbers are remembered by concatenating them to the numbers variable. The numbers are concatenated with an intervening space. This makes the numbers variable a list of words that can be processed by the WORDPOS built-in function.

  4. The loop is concluded by the end instruction.

• When the loop completes three lines are written to the default output stream with the SAY instruction.

• The first line is a title, which shows the range of numbers.

• The second line shows the unique random numbers that were selected.

• The last line shows a cheerful closing remark.

Prime numbers

/* sieve.rex Eratosthenes prime number sieve algorithm */ arg limit . /* processing limit */ if datatype( limit, 'Wholenumber' ) <> 1 then /* validate numeric value */ call usagemsg 'The limit is not a whole number' isPrime. = 1 /* presume all numbers are prime ! */ do n=2 to limit if isPrime.n then call anotherPrime n end exit 0 anotherPrime : procedure expose limit isPrime. arg prime say right( prime, length( limit ) ) /* emit current prime */ do multiple=prime by prime to limit /* mark multiples as non-primes */ isPrime.multiple = 0 /* multiples of primes are not prime */ end return usagemsg : procedure if arg(1) <> '' then say arg(1) say 'Usage' say ' rexx sieve limit' exit 1

• The program, sieve.rex, shows the prime numbers up to the limit value.

• The limit is obtained by the ARG instruction.

• The limit is validated to be a whole number by using the DATATYPE built-in function.

• If the limit value is not a whole number then an error message is displayed, along with program usage information. It is assumed the program is invoked by a Rexx interpreter named rexx. The actual program that is invoked is implementation-dependent.

• A collection of compound variables that begin with the stem isPrime. is prepared. The default value for this collection is 1. This presumes that all numbers are prime. When a specific number is determined to be non-prime, then the associated value in the isPrime. collection is set to 0.

• All numbers are checked from 2 to the limit, by using a simple iterative DO instruction.

• Each prime number is processed by CALLing the anotherPrime internal procedure. This causes the procedure to execute as a subroutine.

• The anotherPrime internal procedure receives an argument which is the number to test. The procedure also has access to the limit variable and the isPrime. collection of compound variables in the main procedure, as a consequence of the EXPOSE clause of the PROCEDURE instruction.

• The current prime is displayed by the SAY instruction. The value is displayed right-justified for the width of the limit value. This makes the numbers appear with their least significant digits in the same column.

• All numbers that are multiples of the current prime value are marked as non-prime in the isPrime. collection, using a DO instruction that has an explicit BY value.

• The anotherPrime internal procedure returns to the main procedure without providing a return value. The internal procedure is operating as a subroutine, so a return value is unnecessary. If the internal procedure were invoked as a function call an error condition (#45) would be raised if the RETURN statement did not provide a return value.