Object REXX
Object REXX is a high-level, general-purpose, interpreted, object-oriented (class-based) programming language. Today it is generally referred to as ooRexx (short for "Open Object Rexx"), which is the maintained and direct open-source successor to Object REXX. It is a follow-on and a significant extension of the Rexx programming language (called here "classic Rexx"), retaining all the features and syntax while adding full object-oriented programming (OOP) capabilities and other new enhancements. Following its classic Rexx influence, ooRexx is designed to be easy to learn, use, and maintain. It is essentially compliant with the "Information Technology – Programming Language REXX" ANSI X3.274-1996[1] standard and therefore ensures cross-platform interoperability with other compliant Rexx implementations. Therefore, classic Rexx programs typically run under ooRexx without any changes. There is also Rexx Object Oriented (“roo!”), which was originally developed by Kilowatt Software and is an unmaintained object-oriented implementation of classic Rexx.[2] HistoryIn 1988, the "Oryx" project at IBM, under the technical direction of Simon C. Nash, experimented with merging classic Rexx with the object model of Smalltalk.[3][4] The motivation behind the project was to transfer the advantages of OOP to classic Rexx while remaining compatible and thus transferring the usability of classic Rexx to OOP.[5] Early on, the projects focused on OOP aspect such as treating everything as an object, object-based encapsulation and message passing, object-based concurrency, classes and inheritance.[6]  This initial work later led under the direction of Rick McGuire to the first prototype of Object REXX, which was presented in 1992. In 1994, IBM announced that Object REXX would replace classic Rexx as the standard REXX interpreter in the next version of OS/2.[4] In 1996, Object REXX[a] was released as part of the OS/2 Warp 4 operating system.[7] In 1997, versions for Windows 95, Windows NT and Linux followed.[8][9] In 1999 an Object REXX version for AIX V4.1.5 or higher was released.[10] In 2000, versions for zLinux and Sun/Solaris followed. For Windows 2000, Windows Me, Windows 98 and Windows NT 4.0, the last major update for Object REXX was released in 2001.[11]  On 12 October 2004, IBM announced the discontinuation of Object REXX and transferred the source code and licensing rights[b] to the non-profit Special Interest Group (SIG), the Rexx Language Association (RexxLA). The code that IBM released to open source did not include the classes for IBM System Object Model (SOM), which is known as the object framework for OS/2's Workplace Shell (WPS).[12] Although IBM discontinued the development of SOM in 1997, it is still a fundamental framework for OS/2.[13] The OS/2 version of Object REXX includes classes to support SOM and WPS.[14][15] These are included in OS/2's initial follow-on product, eComStation, and also in its current descendant, ArcaOS, for which IBM's original Object REXX interpreter continues to be available.[16] In 2005, the RexxLA released ooRexx as a new incarnation of Object REXX as free and open-source software under the Common Public License.[17] This first version of ooRexx 3.0.0 has been heavily refactored compared to the original IBM source code in order to increase readability. Later, the ooRexx kernel was rewritten in pure C++, and a new architecture and native interface were designed and implemented under the technical direction of Rick McGuire. This work enabled the RexxLA to release ooRexx 4.0.0 with support for 64-bit in 2009. To this day, the RexxLA continues to develop, support and maintain ooRexx as well as classic Rexx and NetRexx. Furthermore, the RexxLA organizes international annual symposia.[18] ReleasesThe following table contains noteworthy features and changes of major Object REXX and ooRexx interpreter versions. All ooRexx releases and the necessary documentation are available freely on Sourceforge.[19][20] For Arch Linux based distributions the current and the development version are available as Arch User Repository. Since version 5.0.0 there are portable versions of the interpreter that can be used without installation, and an unofficial port to OS/2 also exists. The "net-oo-rexx" bundle contains the latest portable version of ooRexx, Netrexx, a Netrexx shell, the Java bridge and associated packages, a shell for ooRexx and various other packages and programs.[21] For Intellij IDEA, the ooRexxPlugin adds support for syntax highlighting, syntax checking, code completion and documentation support modeled after Javadoc using annotations.[22] As of September 2012 there is support for syntax highlighting of ooRexx 4.0 features in Vim.[23] RexxCPS is a benchmark that measures the number of Rexx clauses (independent syntax units in a line) per second that an interpreter processes. Legend: Unsupported Latest version Preview version
Design philosophyooRexx follows the design philosophy of classic Rexx to create a "human-centered" programming language that is easy to learn, code, remember and maintain. This is achieved, in part, by keeping the language small and following the principle of least astonishment.[2][33] A readable syntax is enabled by being case-insensitive, free-form, requiring as little punctuation as possible, and using instructions that are straightforward English.[33] In addition, it is a dynamic programming language that offers flexibility and allows to focus on development rather than language constraints. Following the "documentation before implementation" design principle of classic Rexx, ooRexx offers comprehensive documentation in accordance with the IBM Style Guide that includes syntax diagrams and examples.[33][32] InstructionsAs in classic Rexx, there are assignment instructions, keyword instructions and command instructions. In line with the desire to keep the language small, ooRexx has only thirty keyword instructions.[32] Unlike many other languages, no keywords are reserved, so keyword instructions such as
In cases where an instruction is neither an assignment nor a keyword instruction, it must be a string literal or a valid expression which is considered a command instruction, which causes the interpreter to pass the string to the operating system for execution and set a variable a = "hello world" /* assignment instruction */
do i = 1 to 2 /* keyword instruction "DO" */
say "round #" i":" a /* keyword instruction "SAY" */
end /* keyword instruction "END" */
"echo Hello World" /* command to operating system */
say "RC:" rc /* command's numeric return code */
In addition to the three instruction types of classic Rexx, ooRexx adds directive[c] instructions which need to be placed at the end of the program. After loading and the syntax check, the interpreter executes all defined directives to set up the execution environment for the program before further instructions are executed. Directives can be used to define routines, classes, methods, attributes or execution options like the number of digits to use in arithmetics. To make directive instructions readily recognizable, they are introduced with two consecutive colons ( To facilitate the reusability of code, the Free-formooRexx has a free-form syntax where the positioning of the program code is irrelevant, which allows a high degree of flexibility. Before execution, the interpreter merges multiple unquoted blanks into one, while a character string enclosed in quotation marks (single or double) is not changed. Concatenation can be requested explicitly with two vertical bars ( say "Hello World!" /* output: Hello World! */
say " This" 'is' - /* trailing dash for continuation */
"REXX" || "!" /* output: This is REXX! */
Case-insensitiveAs classic Rexx, ooRexx is a case-insensitive programming language. Accordingly, the ooRexx interpreter capitalizes all characters outside quotation marks (single or double) and ignores case for instructions, variable names and all other aspects of the language. Only sequences within quotation marks are treated as literal strings and are not changed during processing.[32] Because the cases do not need to be differentiated, fewer additional details need to be learned and frustrating syntax errors are avoided.[35] a = "This is" rexx!
Say A /* output: This is REXX! */
SAY a /* output: This is REXX! */
Everything is an ObjectWhile classic Rexx follows the "Everything is a String" philosophy and has string as its only data type, ooRexx considers everything as objects, including non-string objects such as arrays, streams and many more. Objects are manipulated using methods instead of traditional functions.
In ooRexx, a string variable is a reference to a string object and does not need to be declared, which reduces the effort for programmers compared to strictly typed languages.[36] A string object can be of any length and contain any characters, including numerical values. It is therefore possible to change numerical values with string manipulations and methods of the a = 2 /* string with numerical value */
a = a || '0' /* resulting string: 20 */
str = "do i = 1 to "a"; say i; end" /* string contains loop instruction */
interpret str /* interpret string: counts to 20 */
Message paradigmSimilar to the messaging paradigm implemented by Alan Kay in Smalltalk, everything in ooRexx is an object that can be communicated with. The notion of sending messages to objects as if they were living beings helps beginners to learn OOP concepts.[34] In contrast to Smalltalk, there is an explicit message operator, the tilde (
The default behavior of most methods can be changed by specifying an option, which can be either spelled out or abbreviated and is not case-sensitive. When reading code, this enables a literal understanding and reduces the learning effort for beginners, as there is no need to learn the meaning of abbreviations.[35] For example, the method with the name a = " I am ooRexx!"
say a /* output: I am ooRexx! */
say a~Strip("Leading") /* output: I am ooRexx! */
say a~strip("l")~reverse /* output: !xxeRoo ma I */
CompatibilityooRexx is designed to retain all the features of classic Rexx and essentially complies with the ANSI standard for the Rexx language (X3.274-1996, "Programming Language REXX").[1] In contrast to an optional specification in the ANSI standard, ooRexx does not allow characters such as Classic Rexx scripts typically run without changes under ooRexx, making it easy to migrate to OOP features at the desired rate while preserving the time invested in the original code.[2] There are incompatibilities with some platform-specific implementations such as Rexx for z/VM (e.g. CustomizationooRexx offers various customization mechanisms, such as extending built-in functions and classes, using unspecified methods, adding command environments and invocation switches or creating own builds.[39]
The default behavior of built-in functions can be changed by adding a label with the same name as the function to be overwritten (e.g. say Date() /* output, e.g.: 16 JUN 2025 */
exit
Date: return newDate() /* lable pointing to "newDate" routine */
::Routine newDate
newDate = date()~upper /* use of date() BIF, but with capital letters */
return newDate
Since ooRexx 5.0.0 namespaces have been added that allow the subclassing of built-in classes.[39][32] This makes it possible to extend built-in classes, e.g. by adding a method such as Say .stream~new("someFile.txt")~ArrayInClose
::Class stream subclass rexx:stream /* create a subclass of stream */
::Method ArrayInClose /* add new method to stream class */
self~open /* open the stream */
FileContent = self~ArrayIn /* read content */
self~close /* close the stream */
return FileContent /* return content */
The definition of an PackageObj = .Package~new
PackageObj~SomeMethod("First", "Second", "Third")
::Class Package
::Method Init
::Method Unknown
Use arg MethodName, ArgArr
say "Method was:" MethodName /* output: Method was: SOMEMETHOD */
say ArgArr /* output: First, Second, Third */
FeaturesAbove all, ooRexx offers OOP features such as subclassing, polymorphism, data encapsulation and multiple inheritance via mixin classes. The interpreter includes the Parsing
The str = "Person: Rick McGuire"
/* parse string using the literal ":" and blanks between words
into variables a ("Person"), b ("Rick"), and c ("McGuire") */
parse var str a ":" b c /* parse by literal and blank */
say b c /* output: Rick McGuire */
Procedure and function
ooRexx provides a new way to define procedures and functions that are not specific to a particular class by using the call DoSomething /* "CALL" keyword instruction */
table = .stem~new /* Stem object for indsum */
table[1] = 2; table[2] = 4
say indsum{table,1.2) /* function call requiring use arg */
say dirsum(2,4) /* either parse arge or use arg okay */
::Routine DoSomething /* "ROUTINE" directive (procedure) */
say "I did something!" /* output: I did something! */
/* Implicit return because next */
/* statement is a directive. */
::Routine dirsum /* "ROUTINE" directive (function) */
parse arg first, second /* Valid because both are strings. */
return first+second
::Routine indsum /* "ROUTINE" directive (function) */
use strict arg table, first, second /* can't use parse arg with stem arg */
Sum = table{first} + table[second] /* do calculation */
return Sum /* "RETURN" result */
Class and Method
The d = .dog~new("Bella") /* create and assign a dog */
d~bark /* send bark message */
say d~name /* output: Bella */
::class dog /* class directive */
::attribute name /* attribute directive */
::method init /* object initiation method */
Expose name /* exposes name of dog */
use arg name /* assigns "Bella" to name */
::method bark /* method directive */
Expose name
say Name "goes woof!" /* output: Bella goes woof! */
Error handlingThe
The built-in Signal on Syntax /* switch on SYNTAX trap */
Say 1 + "AString" /* an impossible calculation */
Exit
SYNTAX:
ConditionObject = Condition(Object) /* get additional information */
say "Error code is" ConditionObject~Code /* output: Error code is 41.1 */
say ConditionObject~ErrorText /* output: Bad arithmetic conversion. */
Similarly, the Multi-threadingConceptually, ooRexx provides object-based concurrency, according to which objects have independent resources to execute methods and can communicate with each other using the messaging paradigm. Several objects can be active at the same time and exchange messages for synchronization.[32] Concurrency can be achieved with the TracingAs in classic Rexx, the
The amount of additional information provided can be specified by using either the trace off /* do not trace prolog */
.TraceObject~option = "Full" /* set option to "Full" */
.TraceObject~collector = .array~new
o = .Test~new /* create an instance */
say "starting worker asynchronously ..."
o~start("do") /* dispatched on a new thread */
say "about to wait for worker to end ..."
o~wait /* synchronize with worker */
say "waiting is over"
::class Test
::method init /* constructor */
expose lock /* access attribute */
lock = .true /* set default */
::method wait unguarded
expose lock /* access attribute */
guard on when lock = .false
::method do /* do some work */
expose lock /* access attribute */
t = random(1,999)/1000
say "do: working for" t "secs"
call sysSleep t
say "do: ending work"
lock = .false /* release lock */
::options trace results
The ooRexx debugger, which is also included in the "net-oo-rexx" bundle, is based on Trace and offers a graphical user interface (GUI) that uses the Java bridge to facilitate debugging on all platforms.[21][43] Built-in functions and classesAs ooRexx aims to be compatible with classic Rexx, the traditional built-in functions are still available.[37] Release 5.1.0 provides 82 built-in functions, including character manipulation, conversion and information functions, many of which call methods of the In keeping with its object-oriented roots, ooRexx provides most of its functionality via built-in classes and methods. ooRexx 5.1.0 is delivered with a total of 58 built-in classes, which are divided into the class groups Fundamental, Stream, Collection and Utility.[32] Fundamental classesFundamental classes are the essential building blocks for all other classes. The Stream classesStream classes facilitate communication with external objects such as files, queues, serial interfaces, devices, etc. The
The StreamObj = .stream~new("someFile.txt") /* create stream object */
StreamObj~open /* open the stream */
FileContent = StreamObj~ArrayIn /* read content */
StreamObj~close /* close the stream */
say FileContent /* outputs content */
Collection classesA collection is an object that contains multiple items with associated indexes that enable items to be retrieved using the A MapCollection is a mixin class that defines the basic set of methods implemented by all collections that map from an index to a value. The
A Stem object is created automatically when a compound variable is used. As in classic Rexx, such a variable consists of a stem and a tail, separated by a dot ( fruits.1 = "Apple" /* assigning to stem variable */
fruits.4 = "Orange" /* assigning to stem variable */
say fruits.4 /* output: Orange */
say fruits.[1] /* output: Apple */
SetCollections are special types of MapCollections where the index and the element are the same object. While the indexes in a An OrderedCollection is a mixin class that defines the basic methods for all collections that have an inherent index order, such as the
An Array is sequenced collection ordered by whole-number indexes. Like some other collection classes, the ArrayObj = .array~of("One", "Two", "Three") /* array with 3 items */
say ArrayObj~at(2) /* output: Two */
say ArrayObj~makeString(,"; ") /* output: One; Two; Three */
Utility classes
Utility classes are a collection of 31 classes that provide implementations for common tasks. The FileObj = .File~new("~/someFolder/") /* create file object for folder */
FileArr = FileObj~ListFiles /* retrieve array of files */
do FilePath over FileArr /* iterate over the array items */
say FilePath /* output: FilePath item */
end
The A regular expression is a pattern that can be used to match strings. To increase the readability of patterns in the code, the Other classes help to obtain information about the context of the currently executed code ( External packages and librariesUsing the Supplied with interpreterThe Rexx extension library offers classes for reading and writing comma-separated values (CSV) files, as well as for creating and processing JavaScript Object Notation (JSON) data. A library called “hostemenu” is also included, which partially emulates a TSO/CMS environment.[44] The RxSock native library enables to incorporate TCP/IP protocols,[45] while the RxFtp native library[46] specifically provides access to the file transfer protocol (FTP). The RxMath native library offers advanced mathematical functions such as square root calculation, exponential function, logarithm, sine, cosine, tangent, arc sine and power calculation.[47] Say rxcalcsin(1) /* output: 0.0174524064 */
::requires 'rxmath' LIBRARY /* load a native library */
For Windows, ooRexx includes the ooDialog framework allowing to produce Windows dialogs and therefore graphical user interfaces.[48] The interpreter is delivered with several example programs and function packages that demonstrate the use of this framework.[37] For POSIX-compatible operating systems, the orxnCurses class library enables the writing of text-based user interfaces using the ncurses programming library.[49] The RxUnixSys library provides functions on most Unix systems for interacting with processes and threads, users and user groups, files and file systems and other.[50] Many of these external packages and libraries are also compatible with other Rexx implementations. Not supplied with interpreter
There are also packages that need to be downloaded and added manually. As part of the Net-oo-rexx bundle, the Regex package enables handling regular expressions, while Log4rexx provides a logging framework and Oorexxshell an interactive ooRexx shell.[21] The Mod_Rexx package provides a module for Apache 2.4 that gives an interface to ooRexx under Windows, AIX and Linux and enables all phases of an Apache request to be processed.[51] The Rexx Parser package provides an abstract syntax tree parser for Rexx and ooRexx, which assigns a category to all script elements, while the Rexx Highlighter package expands the parser and enables highlighting to be output as HTML, ANSI colors, LuaTex and LaTeX.[52][53] The Rexx XML parser enables the parsing of XML files into an in-memory model and access to this model via a DOM-like API.[54] ooRexxUnit is a test framework inspired by JUnit that enables the execution of ooRexx test cases that help to verify whether an application's specifications are met.[55] BridgesWhile ooRexx compared to Object REXX no longer contains classes for SOM and WPS support, it offers application programming interfaces (APIs) for interacting with code written in C or C++.[56] There is also an external library that implements a bidirectional Java bridge, which enables interaction between ooRexx and Java.[34] There are also classes that enable interaction with SQL databases and the automation of Windows applications. At the 36th Rexx Symposium, an experimental bridge to Python was presented.[57] C/C++ APIsAs classic Rexx, ooRexx includes APIs for extending Rexx with applications written in C and vice versa. This enables the creation of handlers for subcommands used in Rexx programs that run as application macros, external functions that allow a direct extension of the ooRexx function set and system functions that allow the behavior of the interpreter to be customized.[56] With ooRexx 4.0.0 APIs have been introduced that allow C++ applications to extend ooRexx and vice versa. This includes handlers for methods and functions written in C++ that extend ooRexx, both packaged as external libraries. These are dynamic link libraries on Windows or as shared libraries on Unix-based systems. An external library can be loaded with the Java
Using the C++ APIs, BSF4ooRexx was developed as a bidirectional Java bridge based on the Bean Scripting Framework. This bridge enables ooRexx to communicate with Java objects and Java to interact with Rexx applications.[58][40] The bridge is realized by requiring the ooRexx package /* create Java object */
frame=.bsf~new("javax.swing.JFrame", "Hello, my beloved world - from ooRexx!")
frame~setSize(410,20) /* set width and height */
frame~visible=.true /* make JFrame visible */
call SysSleep 10 /* sleep for ten seconds */
::requires "BSF.CLS" /* get Java support */
Based on BSF4ooRexx, interaction with Universal Network Objects (UNO), as used in OpenOffice and LibreOffice, is supported via the SQLThe ooSQLite class provides an interface to SQLite, an in-process library that implements a self-contained, serverless, zero-configuration, transactional SQL database engine.[64] It allows interaction with several variants of SQL databases without having to change the script, but multi-threading is not supported.[65] The external Rexx/SQL package enables access to SQL databases of different vendors via Open Database Connectivity (ODBC).[66] With the goal of providing more functionality than a subset of ODBC and being thread-safe, the Rexx MySQL library provides a wrapper in C to add MySQL support.[67] Windows automation
The Windows extension includes the Windows Script Host (WSH) Scripting Engine that can be used to perform general automation tasks. It also includes Object Linking and Embedding/ActiveX (OLE) support allowing to interact with Windows programs via the exc = .OLEObject~new("Excel.Application") /* create object for Excel */
exc~visible = .true /* make Excel visible */
Worksheet = exc~Workbooks~Add~Worksheets[1] /* add worksheet */
Worksheet~cells(1,1)~Value = “First Cell” /* insert string into cell */
In addition to OLE support, the Windows extension enables interaction with the Windows program manager, the system event log, the clipboard and the registry as well as to query, edit and interact with windows, menus or sub-menus.[68] Notes
See alsoReferences
Further reading
External links Wikimedia Commons has media related to REXX (programming language).
|
||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
![[icon]](File:Wiki_letter_w_cropped.svg){kind=small}
Portal di Ensiklopedia Dunia
