REXX Tips & Tricks:Additional Software for REXX

Development & Debugging Tools
This sections contains information about additional usefuls tools for developing REXX programs.

Skeleton - a REXX program skeleton
Description from the author:

"Extremely simple to use, the REXX Skeleton provides: display or extraction of embedded help code, automatic external function registration, automatic initialization of useful "global" variables, automatic trapping of REXX execution time events and errors with dump file generation containing variables and queues, and debug assistance. Needs only the standard OS/2 REXX but has more function with REXXLIB. Great for beginning REXX programmers as well as more advanced programmers. This is Zero-cost Shareware uploaded by the author, Bob Rice."

Note: see also Template for a REXX program

PPWIZARD - a pre-processor
Description from the author:

"This is a generic processor (for any text files) with specific support built in for rexx and html files.

When used with the "/rexx" switch it will by default remove comments and pack rexx code and then perform a syntax check.

You have access to instructions such as #define, #evaluate, #include, #if and #ifdef. You can develop macros that take both optional and mandatory parameters and the macros can conditionally generate output.

The program is extendable through rexx. Commands such as #if tests can be very complex, for example it would be relatively simple to compare environment variables or contents of files etc.

The html capability of this program is the basis of a series of e-Zine! articles (3 so far). Its use for rexx development would have to be at least as important. AWE def files are being developed using PPWIZARD macros and I generate PPWIZARD itself plus the extensive PPWIZARD INF and HTML documentation using PPWIZARD macros."

MakeREXX - a pre-processor for REXX
Description from the author:

"MAKEREXX is a utility that allows a REXX programmer to create a library of generic routines. Those routines are maintained in a subdirectory named 'XXX' and must have a file suffix of '.XXX'. The REXX code produced by MAKEREXX is placed in a subdirectory of '.CMD' and will have a suffix of either '.CMD' or '.ERX'. '.CMD' files are OS/2 REXX routines while the '.ERX' files are EPM editor REXX routines. Mainline REXX routines are maintained in a subdirectory named 'REX' and must have a file suffix of either '.REX' or '.EPM'. '.REX' routines will be expanded into '.CMD' routines while '.EPM' routines will be expanded into '.ERX' routines."

PrepProc - pre-processor for REXX
PrepProc is a simple pre-processor for REXX programs written in REXX. Supported directives in this version are #define, #ifdef, #ifndef and #include.

RxPrep - REXX pre-processor
This is another pre-processor for REXX programs written in REXX.

RXPREP is only available for DAP members.

REXX Toolbox and pre-processor
Note: All docs are in German!

FASTREXX is mainly a pre-processor for REXX programs. Also included are various REXX procedures.

RCF - REXX Code Formatter/2
Description from the author:

REXX Code Formatter/2 Description

The REXX Code Formatter/2 (RCF/2) is an OS/2 REXX application written using VisPro/REXX and VisPro/Reports. It is designed to allow a REXX programmer to format a program in a particular style, insuring that the format of each element of the REXX program conforms to that style.

Features of REXX Code Formatter/2

Using this product, users may, for example: In addition, while RCF/2 is not a syntax-checker or code debugger, it does provide some assistance in program development. It can, for example: New features in Release 1.2.0 are:
 * Define the indentation to be used in general plus the amount for:
 * Program statements subordinate to DO and SELECT,
 * Statements that begin with THEN/ELSE, and
 * Continued statements.
 * Specify whether:
 * Lines are to be split at semicolons,
 * Redundant spaces are to be removed from program statements,
 * New lines are to start before or after THEN/ELSE keywords, and
 * END statements are to be indented to align with the corresponding DO/SELECT subordinate statements.
 * Specify the formatting for:
 * REXX keyword Instructions,
 * REXX keywords besides those that begin a REXX keyword instruction,
 * Variables names,
 * Function names, and
 * Labels.
 * Define special formatting for selected function names.
 * Check for duplicate labels and insure all labels start on a new line.
 * Have RCF/2 create a file of label names as they appear in the program
 * so that all references to them in the program (and even other programs) will reflect this same format.
 * Align full-line, left-hand, and right-hand comments.
 * Generate a listing of the formatted program.
 * Identify DO and SELECT instructions missing a corresponding END clause,
 * Flag comments that are not started but not closed, and
 * Highlight literal strings with a missing quote.
 * A cross reference facility for labels, variables, and function names.
 * Optional formatting notes if undefined function names are found.
 * The ability to add "Commented line numbers" to statements.
 * Landscape printing formats.
 * Right-hand alignment of full-line comments with extension and truncation to allow for "boxing" of comments.
 * Specification of file name and directory for generated associated label files.
 * Maintenance of multiple generated associated label file data in a single file.
 * Separate formatting specification for the standard REXX built-in functions.
 * The specification of the file to be edited as a parameter at RCF invocation.
 * The extension of the allowable indentation values to be up to 999.
 * Placement of the print specification in a separate page to facilitate changing of printer specifications.
 * Use of WARP 4 notebook format for configuration settings when using OS/2 WARP 4.

RexxComm
This program formats comments in REXX program files according to a user-defined option and reports any uncommented program lines.

RXCALLLST - show the CALL structure of a program
RXCALLST is a tool to show the CALL structure of REXX programs.

RXCALLLST shows the call structure of a REXX program in a TOP-DOWN-view and a BOTTOM-UP view. It can also detect recursive code and dead code.

(see also and )

Checkfunc - Function analysis of a REXX program
Checkfunc is a handy routine to help you develop correct and portable REXX code. It contains a mini-parser for REXX that finds all the function calls in a program and lists them out for you to see. The output listing shows: (see also and )
 * BIFs Used
 * Internal functions
 * Duplicate (and therefore unreachable) labels
 * Rexxutil common functions
 * Rexxutil OS/2 only functions
 * Rexxutil Windows only functions
 * Rexxutil Version 2 functions
 * External functions
 * External commands

CodeAnalyzer
Description from the author:

"CodeAnalyzer is a generic engine for analyzing and formatting REXX code. This is a tool for the REXX programmer who works with large complex programs."

(see also and )

RXD - Rexx Debugger
RxD is a very useful debugger for OS/2 REXX programs. RxD supports Breakpoints, single stepping and watch variables. RxD is a PM program.

Note that RXD is an older 16-bit app and, according to the author, there may be some errors or unexpected conditions using it on 32-bit OS/2 (like WARP).

Rexx/Wrapper
Description from the author:

"Rexx/Wrapper is a tool that wraps a Rexx source file, or tokenised code into an executable program. The Rexx source code can be optionally compressed and encoded to ensure that the original Rexx code cannot be viewed (unless you have the original encryption key).

To use Rexx/Wrapper you need two extra bits of software: The Rexx interpreter that is linked with the executable must be capable of executing an "instore" Rexx macro via the SAA API. The Rexx interpreter used to build the executable wrapper can be different from the interpreter used to run the executable program. If wrapping tokenised code, then the Rexx interpreter that creates the tokenised code, MUST be the same interpreter that runs the tokenised code.
 * 1) A supported Rexx interpreter
 * 2) A supported C compiler

All suppliers of Rexx interpreters provide access to their interpreter via a shared or dynamic library. This means that it is not possible to build a completely stand-alone executable; you will always have to include the shared or dynamic library with the executable built with Rexx/Wrapper.

There is one exception to this rule; Regina. Regina also provides a static library, which means you can link your program with Regina's static library, and you will get a completely stand-alone executable.

There is a catch however with using the Regina static library :-(. The Rexx program that you wrap, cannot dynamically load an external function package. This is because the Regina static library does not (and cannot) support the dynamic loading of external functions. External functions, by their very nature, require the presence of a dynamic or shared library to operate.

Rexx/Wrapper supports all C compilers that support ANSI prototypes. Rexx/Wrapper will not work with older K&R C Compilers.

For a list of the supported C compilers for the current platform, run rexxwrap.cmd with the '-help' switch and see the list below."

see also, and

REXXCC - a REXX "compiler"
REXXCC "compiles" an OS/2 REXX program by substituting the source code with any text. This is possible because the OS/2 REXX interpreter stores a tokenized copy of each executed REXX program in the EAs of the program. If you execute an OS/2 REXX program, the OS/2 REXX interpreter first checks, if the tokenized copy in the EAs is still valid and, if so, executes the tokenized copy and ignores the source code.

Beginning with version 3.00 REXXCC can also compress REXX programs (this means: delete all leading and trailing whitespaces, all linefeeds and all comments).

Beginning with version 3.10 REXXCC also contains a REXX program to unpack packed or compressed REXX files.

Beginning with version 3.20 REXXCC also contains a REXX program to use the macro space for creating token images of REXX programs.

REXXCC is a command line program. But there is also a PM front-end for REXXCC called REXXCC/2 in the archive. REXXCC/2 uses Rexx Dialog for the PM interface.

The current version of REXXCC is always available at Hobbes in the same library as RXT&T (see Distribution)

Note: The format of the token image for REXX programs is the same since OS/2 version 2.1. So you can use a REXX program "compiled" with REXXCC on any OS/2 version since 2.1. But: You can't use a "compiled" REXX program with the new Object-Oriented REXX (see also "Compiling" REXX programs).

see also, and

RxCLS - a REXX 'compiler'
Description from the author:

"RXCLS is a shareware program which compiles a REXX programs into a stand alone executable. RXCLS is a 32bit program designed to run on OS/2* version 2.x or greater."

Well, the author did not say all: RXCLS does NOT compile REXX programs into machine readable code like other compilers. The only thing it does is: Create the token image of the REXX program and bind it with a little stub together to an EXE file. If called, the stub of the EXE calls the REXX interpreter to execute the included token image.

To verify this you may set the environment variable TRACE to ON and call an EXE 'compiled' by RXCLS.

But nevertheless RXCLS is fine done and useful if you want to hide your REXX source code. And this method does not have any compatibility problems through converting the REXX code, of course.

The advantage of the method used by RXCLS compared to my free REXX "compiler" REXXCC: It avoids the 64 K limit and you don't have problems with the EAs.

see also, and

REXX2EXE - a REXX "compiler"
Description from the author:

"This program will "compile" a rexx program in 2 main ways. It will tokenise the rexx (no 64K limit) or will simply wrap up the source (the default). The default action is to encrypt and compress the resultant image and attach it to an EXE stub. There are all sorts of options to control the stub, for example you can have a runtime DLL or standalone EXE. You can choose to have a compact EXE which will run in Warp onwards or a larger one which will also run in 2.0+. You can generate the stub as a PM program eliminating all the hassle of using 'RxMsgBox'."

see also, and

Arc
This is a REXX program to "crunch" (remove all not necessary parts) REXX programs

Rexx2Nrx
This program converts Classic REXX programs to NetRexx.

ExeHdr
An ExeHdr tool is also included in the OS/2 Developers Toolkit and in nearly all C/C++ Compiler packages.

An ExeHdr tool shows the names of the functions exported by a DLL. This is useful to get the propper spellings for functions exported by a REXX DLL if the DLL was linked in a case-sensitive manner (see DLL loading failed).

PMDLL
Description from the author:

"PMDLL is an OS/2 presentation manager program that shows you the complete tree of DLLs loaded by an OS/2 executable file or by a DLL (both 16 and 32 bit formats are supported). Sometimes it's uncertain why a program won't start (correctly) or behaves strange when running. When this program is using DLLs one of the causes can be that DLLs can't be found or that DLLs are loaded from unexpected directories which contain an incorrect version of the DLL. PMDLL gives you an easy way to detect these kind of problems."

PMDLL is a very useful tool to detect the further DLLs needed by a REXX DLL (see DLL loading failed).

There is also a command line tool named ckkdll32.exe from IBM for this purpose.

LX lite - a compressor for OS/2 executables
This is a fantastic program to pack OS/2 executables in Linear Executable (LX) format. OS/2 uses the LX format for .EXE, .DLL, .PDR, .QPR, .DRV, .FON and .SYS files. Virtual Device Drivers (VDDs) for DOS sessions are also in LX format. You can even compress the OS/2 kernel (os2krnl)! LX compresses the files in the same way as LINK386 does. The decompression algorithm is part of the OS/2 WARP program loader. So files compressed with LX are "simple" OS/2 executables. There's no additional stub program necessary to uncompress the compressed files.

The only drawback of this tool:

You cannot execute compressed executables under OS/2 prior to WARP because the decompression code was first introduced in WARP. But that's no great problem because LxLite can also decompress compressed files again.

Conclusion:

LxLite is one of the most useful tools for OS/2 I've seen so far.

(see Using REXX if booted from diskette for one use of LxLite)

Another useful tool contained in this package is UNLOCK.EXE:

"unLock is a simple utility which allows to 'unlock' application executables which are currently in use. Normally when an executable is loaded by OS/2 its file is open with a deny-write sharing mode. This is done because LX format structure is designed not to swap out unused pages in executables each time when they aren't needed anymore, but rather to discard them. When a discarded page is needed OS/2 simply reads it again from the executable. However, there is still a way to replace executables 'on-the-fly' even if they are currently running. There is an so-called 'well-known-undocumented' function (which in fact means that it won't be necessarily supported in future versions of OS/2) which allow to disable sharing protection on such files. Before doing that OS/2 reads entire executable in swap file, then page swapping is done as with usual memory. If you'll 'unlock' many running executables at the same time you can notice an increase in swap file size. So, this is just an temporary workaround, you have better to reboot after doing all necessary things on former locked files. The command-line format of unLock is much like lxLite's, except that it have much less options :-)"

lsof - list open files
You can use lsof to find out if your REXX program opens files without closing them.

You can also use the program psfiles.exe to get a list of open files (available in Warp 4 Fixpak 13) - but it's not as comfortable as lsof.

XWorkplace
XWorkplace (or its predecessor XFolder) is not only the best WPS enhancer for OS/2 - it's also a very good tool to examine the internals of the WPS.

XWorplace is a must have for OS/2 users and developers.

XRay - a PM window peeker
Xray is an utility to display window info of window under the mouse pointer.

You can use this tool to get the IDs necessary for the new setup string MENUITEMSELECTED in WARP 4.

PSPM
Description from the author:

"PSPM graphically displays the status of all processes running in OS/2. PSPM allows you to display information about any process, including thread information, to terminate a process or an entire process tree, or to switch to a running process."

PSPM (or a similar tool) is necessary if a program using VREXX crashes without calling VEXIT. In this case you must delete the invisible process created by VREXX manually before you can use VREXX in other REXX programs.

ConfigTool
ConfigTool is AFAIK the best database with various information about the CONFIG.SYS of OS/2. It includes also a tool to check and optimize the CONFIG.SYS.

DMrxWPS
Description from the author:

"DMrxWPS.dll is a REXX library that provides a bridge between REXX scripts and some of the WPS related OS/2 API functions, referred to as "Win functions". Its main purpose is to facilitate the installation and the reinstallation or updating of WPS classes. The current version of DMrxWPS supports only three Win functions in addition to its own two "helper functions". One of the Win functions, WinQueryObjectPath, is only available on WARP or above. Calling its corresponding DMrxWPS function, WpsQueryObjectPath, will not work on version of OS/2 before WARP.

Many of the Win functions are available in the RexxUtil REXX library. DMrxWPS is intended to supplement RexxUtil, not replace it. The three Win functions included in DMrxWPS are WpsQueryObject, WpsQueryObjectPath, and WpsSetObjectData. The first two functions were chosen because they can be used together to obtain the path to a WPFileSystem derived template in the Templates folder without knowing the path of the Templates folder itself. This path can then be used to manipulate the template using functions from RexxUtil. The sample script DelTmplt.cmd (included with DMrxWPS and described in section 3) shows how this can be done."

The dll provides the following functions:
 * WpsLoadFuncs Make the functions in DMRXWPS.DLL available to REXX.
 * WpsDropFuncs Unload the DLL DMRXWPS.DLL
 * WpsQueryObject Get the object handle of an object with an object ID
 * WpsQueryObjectPath Get the path of an object
 * WpsSetObjectData Set the data of an object

GetObj - Get the data of WPS objects
GETOBJ creates a list containing the data for all objects in a folder (and it's sub folder) for example your desktop folder. For each object the title, the class, the setup string and the location is shown.

GETOBJ can also create a REXX program with SysCreateObject calls to recreate the objects.

GETOBJ needs the DLL WPTOOLS.DLL from the WPTOOLS package. This DLL is included in this package.

RXOD - REXX Object Data
Description from the author:

"These external functions extend the ability of OS/2 REXX programmers to handle OS/2 Workplace objects with the following functions:
 * Return persistent object handle for an object, given the object's OBJECTID or file system name.
 * Return file system name for object given OBJECTID or handle
 * Set OBJECTID for an object, given its object handle.
 * Return object title given object handle for WPAbstract objects such as program references. (RXODTITL)"

WPTOOLS
WPTOOLS is a set of programs to (partially) backup and restore a customized WPS, remove obsolete WPS related information from the ini-files, repair some WPS problems, etc.

It is mentioned in this document because it contains a DLL named WPTOOLS.DLL. WPTOOLS.DLL is a dynamic link library that exports some functions to query the settings of WPS objects in REXX: Note: See List all associations for an example for using this DLL. You might also download GETOBJ.CMD to get an example for using WPTOOLS.DLL.
 * WPToolsLoadFuncs Make the functions in WPTOOLS.DLL available to REXX.
 * WPToolsQueryObject Query object data
 * WPToolsFolderContent Query abstract (non-disk) objects in a specific folder
 * WPToolsSetObjectData Change the settings of an object; this functions works with object IDs, file names and object handles.
 * WPToolsVersion Query version of WPTOOLS.DLL (DLL version v1.01+)

SysSet
Description from the author:

"This program contains an OS/2 WPS class which give the ability to set up systems components such as Keyboard, Mouse and System from a REXX command file."

ICONRESOURCE
This package shows how to properly use the WPS object setting ICON(N)RESOURCE when refering to icons delivered in resource DLLs. It is also taking care for the differences between Warp 3 and Warp 4. The package includes a REXX sample cmd and source for a REXX-DLL, which is required for using ICONRESOURCE under WARP 3.

(see also The keyword ICONRESOURCE)

ZipShell
Description from the author:

"A handful tiny batchfiles and WP-objects for handling ZIP- and ARJ-files with the WPS. Content and unpacking of ZIP and ARJ files. Packing ZIP files. With nice icons and REXX programs for installation and deinstallation. Freeware. English and German."

ZipShell is mentioned here because it contains a program called SendMsg.EXE. SendMsg can be used to send windows messages to running PM Programs and open PM folders. E.g. it's possible to use SendMsg Programs WM_CLOSE to close a folder from the command line.

See IDs for the setup string MENUITEMSELECTED for a list of possible windows messages.

CWHelp class
Description from the author:

"WPS class to display help from any program or REXX script without fighting with the OS/2 help system. Use setup strings to display a help panel."

PM Tools

 * APMT - A PM automation Tool
 * DrDialog
 * User control for DrDialog
 * EVRexx
 * PMPopup/2
 * Rexx Dialog
 * VREXX
 * RxTitle
 * Rexx/Tk
 * RxMsgBox
 * REXX/DW

CICS REXX Interface
This DLLs allow to access CICS resource information from a REXX program (one sample, no docs).

ICSS REXX Interface DLL
This DLL provides an REXX interface to the IBM product Continuous Speech.

Patrol REXX Interface DLL
Description from the author:

"RXPMPAPI.DLL is a Rexx interface to PM Patrol's Data Collection Facility (DCF). All four of the functions in the C language API set provided with PM Patrol have a Rexx equivalent. This Rexx interface is completely free of charge, but PM Patrol itself is a shareware program that requires registration after an initial trial period."

WarpDoctor REXX Plug-In
Special Note:

The version v1.01 12/25/2002 of this plugin needs the DLL CPPOM30.DLL which is NOT part of the package. To get this DLL search the WEB for the bamba plugin from IBM; the filename of the archive is bos2a.zip. This ZIP file contains a copy of the DLL CPPOM30.DLL. Hopefully this limitation will be removed in further versions!

Description from the authors:

"Rexx a substitute for Java? We think so, especially on OS/2. With the WarpDoctor Rexx Plug-in you can do in Rexx just about everything that you can do in Java, but faster and easier.

Java was designed as an interpreted language that was targeted at embedded systems. It "took off" as the darling language of the late 1990s when Netscape decided to include a Java Virtual Machine (JVM) in all their browsers and to recognize a new APPLET HTML tag which allowed Java programs to be downloaded from a web server on demand and run as "applets" within an HTML page - the applet being assigned an area on the page by the applet tag.

The WarpDoctor Rexx Plug-in does for Rexx what Netscape's inclusion of the JVM and applet tag did for Java: it enables Rexx programs to be downloaded from a web server on demand and run in an area of an HTML page, appearing to be part of the page. The WD Rexx plug-in however also enables downloaded Rexx programs to be run in their own Command Prompt window or in a separate window provided by a visual Rexx environment (such as VX-Rexx, GPF Rexx, etc.), and to run with output directed to a window on the HTML page.

This is the project page for the WarpDoctor Rexx Plug-in. The WD Rexx plug-in was developed by the WarpDoctor project team to facilitate data entry to, and maintenance of, the database used to store the content of the WarpDoctor site. While the plug-in was created specifically to solve WarpDoctor's database needs it was designed to be generic, to run any Rexx program from any web site. And in the spirit of WarpDoctor the plug-in and source code are made freely available to the OS/2 community in hopes that it will prove useful to other sites and users so that the entire OS/2 community can benefit."

REXXCOMP - compress/decompress files
This DLL provides routines to compress and decompress files in REXX.

Unzip - REXX DLL support
This is the Rexx (and C) DLL for the new InfoZip Unzip 5.2. This DLL adds a ZIP engine directly to the REXX language.

The list of functions in the dll, and the parameters for each, can be found in the dll source in unzip52.zip. Because there's no documentation in this package, I've included the documentation for it from the source zip here.

See also the note regarding the documentation for this DLL in the section for SREhttp/2.

rxGZlib
Description from the author:

"rxGZlib.dll is an OS/2 REXX callable dynamic link library that contains GZIP procedures. These procedures will deflate and inflate files; and store results using a GZIP.EXE compatible format."

RXGZLIB.DLL exports the following functions (as of 21 Dec 1999):
 * rxGZLoadFuncs Load the rxGZlib library
 * rxGZUnloadFuncs Unload the rxGZlib library
 * rxGZDefalteFile( infile,outfile,compression_opt ) Deflate infile and store results to outfile
 * rxGZInflateFile( inFile,outfile ) Inflate infile and store the results to outfile.
 * rxGZDeflateString( astring [,compression_opt] ) Deflate a string and return the results
 * rxGZInflateString( deflated_string ) Inflate a GZIP string and return the results

DsDate - date function
Description of the author:

"dsDate provides enhancements to all switches of the DATE function provided by REXX/2, and also provides additional date switches.

The dsDate function emulates ALL of the switches of the native REXX/2 DATE function. dsDate solves the following anamolies of the REXX/2 native function: You may use either switch at will. Other switches provided by dsDate and not native to REXX/2 are:
 * 1) DATE only returns data concerning the current system date. dsDate allows you to specify ANY date and obtain the same information using the same optional parameters used by DATE. If you do not provide a date, then (by default) dsDate will act on the current system date. See examples.
 * 2) DATE will generate a runtime error if you attempt to use either the 'C' or 'J' switches in native OS/2. Personal Rexx must be available in order for these switches to function. dsDate solves this problem.
 * 1) dsDate's 'T' switch will return a full text string representation of the supplied date; eg. "January 15, 1979".
 * 2) DATE has no native support to validate a date. dsDate provides the 'V' option to validate a date. This is very useful with data entry applications to ensure data integrity of dates entered by application users.
 * 3) DATE has no abilities to increment or compare dates. dsDate provides the 'I' (increment) option to add/subtract to/from a desired date. e.g. Obtain the date of the day 15 days ago or project a date 15 days in the future.
 * 4) dsDate provides the 'P'(Passed) switch to calculate the number of days between any two provided dates. eg. Return the # of days passed between DateParam1 and Dateparam2.
 * 5) dsDate provides the 'Q' (Quarter) switch to calculate the quarter of the calendar year for the given date. Returns integer (1-4).
 * 6) dsDate can return a Gregorian date in US format from a Julian date using the 'G' (Gregorian) switch. This is the counterpart to the 'J' switch of both DATE and dsDate.
 * 7) dsDate can return an integer representing the week day of any given date using its 'Y' (daY) switch. Unlike the 'W' switch which returns a text label, the 'Y' switch will produce a numeric suitable for calculations."

RexxDate Function Package for OS/2
RexxDate is a REXX function package for manipulating calendar dates.

RxDate - Date function library
RxDate is a REXX CMD containing some useful functions for working with dates:
 * Weekday
 * MonthName
 * Dow (= DayOfWeek)
 * IsLeap
 * DayOfYear
 * DaysInYear
 * DateDiff

FileREXX - File I/O & IOCTL for REXX
Description from the author:

"FILEREXX.DLL is a REXX Function Library. It adds "commands" to the REXX language, which a REXX script (i.e., program) can call. These commands offer alternatives to the REXX file reading/writing routines which make it possible to access the same files from multiple running scripts (i.e., allow file sharing).

FileRexx also makes it much easier to read/write files containing binary values. There are also routines which vastly simplify device (i.e., driver) I/O, and make some driver control possible which standard REXX doesn't allow. Finally, FileRexx offers a lot more parsing options when reading a line, thus eliminating the need to parse a line into separate pieces, or using TRANSLATE to change the case."

FILEREXX provides the following functions:
 * FileAddFuncs
 * FileDropFuncs
 * FileOpen
 * FileClose
 * FileRead
 * FileGets
 * FileReadValue
 * FileWrite
 * FilePuts
 * FileWriteValue
 * FileSeek
 * FileDevIOCtl
 * FileGetInfo
 * FileDeleteFile
 * FileMovefile
 * FileCopyFile
 * FileMkDir
 * FileRmDir
 * FileMatchFile
 * FileSearchPath
 * FileDriveMap
 * FileDevInfo
 * FileGetPath
 * FileEditName
 * FileSysInfo
 * FileIterateExe
 * FileBit
 * FileDoSleep

Read/Write disk sectors
SECTOR.DLL provides functions to read and write disk sectors:
 * qDrive
 * ReadSect
 * WriteSect

Display File Systems
Description from the author:

"File-system display & analysis utility. Shows partition-tables and bootsectors. Shows all HPFS internal disk structures like Superblock, Fnodes, Dirblocks etc. Check allocation integrity for volume. Can find any data-sequence on the disk and identify the file it belongs to. Display allocation maps for entire disk and for the directory-band."

DFS has an REXX ADDRESS envrionment thus you can use it from REXX programs.

Rexx procedures to implement the rsync differencing protocol
RxRsync contains two implementations of the rsync "differencing" protocol - one using a DLL and one in plain REXX.

EADump
This is a REXX program to extract all Extended Attributes from a file or directory into a file and convert them to ASCII format. EADUMP.CMD parses the output of the OS/2 program EAUTIL.EXE.

Touch function for REXX
This DLL contains a function to change the time stamp of a file. The function will only work for dates between 1940 and 1999.

RexxFile
"RexxFile is a small REXX function package (DLL) to show some file attributes and information."

RexxFile exports the following functions:
 * RFLoadFuncs initialize RexxFile support
 * RFDeregFuncs deregister RexxFile external functions
 * RFFuncList show a list of all RexxFile external functions
 * RFFileInfo get the full file information record
 * RFFileSize get the size of the entire file
 * RFEASize get the size of the extended attributes
 * RFLastWriteTime get the time when the file was last written
 * RFLastWriteDate get the date when the file was last written
 * RFLastWrite get the date and time when the file was last written
 * RFLastAccessTime get the time when the file was last accessed
 * RFLastAccessDate get the date when the file was last accessed
 * RFLastAccess get the date and time when the file was last accessed
 * RFCreateTime get the time when the file was created
 * RFCreateDate get the date when the file was created
 * RFCreated get the date and time when the file was created
 * RFFileAttrib get the file attributes: AHRS
 * RFAuthor show the author information
 * RFVersion get the version of this package
 * RFCopyright show the copyright information

Rexx File Utilities (FileUt)
Description from the author:

"FileUt is a set of functions which provide special kinds of file handling to rexx programs, roughly following the Rexx IO model. It gives functions filelinein, filelineout, filecharin, and filecharout, which work essentially the same way as the standard linein, lineout, charin, and charout functions, except they read and write special kinds of files.

In version 1.0, the library provides access to the standard input and output streams of running processes using pipes. The effect is much like the pipe operator in awk. In the future, it will possibly include access to various file archives and files compressed with gzip. Note that three years after the initial release, I haven't felt the need to do any of this."

The DLL exports the following functions: Please note that I did not get this DLL to work as of 05/06/2003. I already asked the author about this. He will look into it as soon as possible.
 * value = filelinein( command[,[line][,[count]][,stream]] )
 * count = filelineout (command[,[string][,line]] )
 * value = filecharin( command[,[line][,[count]][,stream]] )
 * count = filecharout( command[,[string][,line]] )
 * handle = fileopen( command, how )
 * rc = fileclose( command[,stream] )
 * count = filelines( command[, stream] )

ANSICD - Display I/O Control with ANSI
ANSICD contains some useful functions for doing display I/O control with ANSI sequences in REXX programs.

CMDLINE - extended input routine
Description from the author:

"CmdLine is a pair of REXX library functions that I wrote to implement the OS/2 command line features in REXX.

Its features are almost identical to the OS/2 command line when KEYS ON is in effect. It has additional functions that many OS/2 REXX programmers may find useful. In fact, it has most of the features needed to create a complete full screen data entry application."

See also: CMDLINE.CMD

GetOpt - UNIX like parameter handling
GetOpt is an implementation of the UNIX parameter handling in REXX.

PDS - Panel Display System
Description from the author:

"The Panel Display System provides a simple yet powerful method by which an application developer can create an interactive user interface without requiring OS/2 Presentation Manager (PM).

The method by which information is presented by the application to the end user and information from the end user is returned to the application is via a construct known as a 'PANEL'.

A panel is defined by the developer and displayed by the application thru calls to the REXX application programming interface (API), herein referred to as the REXX Panel Display API or rxPD, or thru calls to an optional high level language interface.

As the end user interacts with a displayed panel, the PD system takes care of most keystrokes and combinations of keystrokes, known as chords, without the application having to interpret these keystrokes.

The application can, however, be written to handle any keystroke that might require special handling other than the PDS default for that key or chord."

RxLBox - menu routine in REXX
RXLBOX is a textmode menu program for OS/2 written in REXX.

RXLBOX needs no further DLLs - even REXXUTIL is not needed. RXLBOX uses only ANSI sequences and ASCII codes to implement the menu.

RXLBOX uses the cursor keys, function keys and a command line for navigating through the menus. Nested menus are also supported. RXLBOX also supports menus for user input.

RXLBOX is completly configurable using a menu description file (including menus, messages, online help screens, function keys and macros).

RXLBOX also supports an external message handling routine for language dependent usage.

RXLBOX uses REXX as macro language in the menu description file.

New in version 1.30 is the support for the EXTPROC feature of the CMD.EXE (see also The EXTPROC command)

OLBOX A list box in OREXX
OLBOX is a REXX program implementing a ListBox in Object REXX.

Rexx/Curses
Description from the author:

"Rexx/Curses is an external function package for most Rexx interpreters that provides a portable text based user interface for Rexx programs. The underlying portable text based user interface is "curses".

The design of Rexx/Curses follows the C API for Curses as closely as possible.

Rexx/Curses should work on any system that has a curses library available and a Rexx interpreter that supports the REXX SAA API. This covers most Un*x platforms and DOS, OS/2 and Win32.

The recommended curses library for use on Un*x platforms is ncurses, while for DOS, OS/2 and Win32, PDCurses is the curses library required. It is possible to build native X11 applications with Rexx/Curses and PDCurses on Un*x platforms.

Enjoy, Mark."

MKey
"Get input from the keyboard, without the requirement for a key to be pressed. If there is no keyboard input within the given time, the function will return 0. Use timewait (optional, may not exceed the value of timelimit) to reduce CPU usage."

MRuntime
"High-level, easy-to-use, REXX mouse functions with usage example. No doc's"

Usenet message from the author:

"M contains several high-level mouse functions. It supports about everything I could think of in every way I could think of, and is rather easy-to-use.

For example, it can return the mouse cursor position. But also just the line number, return values (the default setting), and it includes some sound support, time-outs, and all (possible) screensizes.

There's a (OS) limitation: it requires fullscreen text-mode. And you have to do the screen-I/O (draw screen, et cetera) yourself. So don't expect functions like "FileSaveAs"! Not all functions are tested intensivly too.

Because it will take a while before the whole manual is completed (C nor English is my native language) I have already uploaded the runtime of "M" to Hobbes (http://hobbes.nmsu.edu), including one example with comments (select a drive with a key or the mouse). I assume it's somehow usable that way, but it doesn't use all (89!) available functions. Just ask if you've a specific need.

Anyway, I assume a typical REXX application can be based on the included EXAMPLE.CMD, so one can already use it as from now. The example is more "difficult" than required but OTOH it can be used by users, and it also supports the keyboard."

termsize
This DLL exports a function to retrive the columns and rows of the current terminal.

The DLL works also for CMD windows.

REXX Interpreter & Tools for DOS
This section lists all REXX Interpreter & Tools for MS-DOS and PC-DOS.