Object REXX
Paradigm | Multi-paradigm: object-oriented (class-based), procedural (imperative), structured |
---|---|
Designed by | Simon C. Nash (IBM) |
First appeared | 1988 |
Stable release | 5.0.0
/ 10 May 2023 |
Preview release | 5.1.0
|
Implementation language | C++ |
Platform | IA-32, x86-64, ARM, s390x |
OS | Cross-platform: Linux, Microsoft Windows, macOS, Solaris, OpenIndiana, AIX, FreeBSD, OS/2 |
License | CPL 1.0, GPLv2 |
Filename extensions | .rxs, .rex, .rexx, .cls |
Website | www |
Major implementations | |
Object REXX (until 2004) ooRexx (since 2005) | |
Influenced by | |
Rexx, Smalltalk | |
Influenced | |
NetRexx |
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 (often called "Classic Rexx"), retaining all the features and syntax while adding full object-oriented programming (OOP) capabilities. Although ooRexx does not implement all optional aspects of the "Information Technology – Programming Language REXX" ANSI X3.274-1996[1] standard, it offers many new features of its own. Following its Classic Rexx influence, ooRexx is designed to be easy to learn, use, and maintain.
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]
History
[edit]In 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) and Workplace Shell (WPS) support.[12] The OS/2 version of Object REXX includes classes to support SOM [13] and WPS.[14] These are also included 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.[15]
In 2005, the RexxLA released ooRexx as a new incarnation of Object REXX as free and open-source software under the Common Public License.[16] 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 (Regina) and NetRexx. Furthermore, the RexxLA organizes international annual symposia.[17]
Releases
[edit]The 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.[18][19] 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. For Intellij IDEA, the ooRexxPlugin adds support for syntax highlighting, syntax checking, code completion and documentation support modeled after Javadoc using annotations.[20]
Major Releases | Release Date | Notable Features and Changes |
---|---|---|
1.0.0 (OS/2) [7] |
Object REXX1996-09-25 |
|
1.0.0 (Windows)[8] |
Object REXX1997-02-28 (IE) 1997-05-30 (DE) |
|
1.1.0 (AIX)[10] |
Object REXX1999-04-09 |
|
2.1.0 (Windows)[11] |
Object REXX2001-04-21 |
|
3.0.0[21][22] |
ooRexx2005-03-30 |
|
3.1.0[21] |
ooRexx2006-08-21 |
|
3.1.1[21] |
ooRexx2006-11-23 | |
3.1.2[21] |
ooRexx2007-09-17 |
|
3.2.0 |
ooRexx2008-01-22 |
|
4.0.0[23] |
ooRexx2009-09-30 |
|
4.1.0[24] |
ooRexx2011-09-28 |
|
4.2.0[26] |
ooRexx2014-02-23 |
|
5.0.0[27] |
ooRexx2022-12-22 |
|
5.1.0 |
ooRexx2024-09-19 |
|
Design philosophy
[edit]ooRexx 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][28] A readable syntax is enabled by being case-insensitive, free-form, requiring as little punctuation as possible, and using instructions that are straightforward English.[28] 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.[28][29]
Instructions
[edit]
As in Classic Rexx, there are assignment instructions, keyword instructions and command instructions, and in ooRexx there are also the directive instructions. In line with the desire to keep the language small, there are only thirty keyword instructions in ooRexx 5.0.0.[29] Unlike many other languages, no keywords are reserved, so there is no need to memorize a long list of reserved words.[30] 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 RC
for the return code. In addition, the ADDRESS
instruction allows commands to be redirected to specific command environments such as Bourne Shell, Bash, Z-Shell, Command Prompt and others, some editors including ISPF, TSO EDIT, XEDIT and its adaptations, as well as intercepting errors.
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 ooRexx 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 (::
). [29]
To facilitate the reusability of code, the ::REQUIRES
directive allows the integration of another Rexx program (also known as a package) or an external (native) library. This directive causes the ooRexx interpreter to make every routine and class that specifies the PUBLIC
option of the denoted Rexx program (package) to become directly accessible. External packages usually use the file extension .cls
, for example ::requires "csvstream.cls"
or ::requires "json.cls"
. Some external packages and libraries are delivered with the ooRexx interpreter.
Free-form
[edit]ooRexx 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 (||
), or implicitly by separating terms with spaces or by abutting terms. Optionally, clauses can be spread over several lines by using the comma (,
) or the minus sign (-
) as a continuation character, or several clauses can be used in a single line, separated by a semicolon (;
).[29] Since a free-form language provides flexibility and requires fewer syntactic rules to be considered, it is assumed that it eases the learning effort by reducing the intrinsic cognitive load.[31]
say "Hello World!" /* output: Hello World! */
say " This" 'is' - /* trailing dash for continuation */
"REXX" || "!" /* output: This is REXX! */
Case-insensitive
[edit]As Classic Rexx, ooRexx is a case-insensitive programming language. The interpreter capitalizes all characters outside quotation marks before executing them. Because the cases do not need to be differentiated, fewer additional details need to be learned and frustrating syntax errors are avoided.[31]
a = "This is REXX!"
Say A /* output: This is REXX! */
SAY a /* output: This is REXX! */
Everything is an Object
[edit]While 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.[32] 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 String
class. In addition, a string variable can contain any type of expression, including executable instructions, which can be evaluated or executed with the INTERPRET
keyword instruction.[29]
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 paradigm
[edit]Similar to the messaging paradigm implemented by Alan Kay in Smalltalk, everything in ooRexx is an object that can be communicated with by sending messages naming a method. The notion of sending messages to objects as if they were living beings helps beginners to learn OOP concepts.[30]
In contrast to Smalltalk, there is an explicit message operator, the tilde (~
), where the receiving object is placed to the left of it and the result of the operation is returned. Sending a message leads to the activation of a method with the corresponding name and to the manipulation of the receiving object. Like Smalltallk, ooRexx messages can be cascaded if two tildes (~~
) are used instead of one, returning the object that received the method rather than the result produced.[33]
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. This enables a literal understanding and reduces the learning effort for beginners.[31] For example the strip method by default removes leading and trailing blanks. This behavior can be changed, for example, by specifying "leading"
or "l"
as an option. While functions are nested in Classic Rexx, messages can be chained in ooRexx, which improves the readability of a statement.[30]
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 */
Features
[edit]ooRexx is designed to retain all the features of Classic Rexx. It conforms[d] with the ANSI standard for the Rexx language (X3.274-1996, “Programming Language Rexx”[1]) to ensure cross-platform interoperability with other compliant implementations. Thus Classic Rexx programs typically run under ooRexx without any changes. This makes it easy to transport both program code and developer knowledge from Classic Rexx to ooRexx. To this, ooRexx adds all the features of OOP, such as subclassing, polymorphism, and data encapsulation. Further features include multiple inheritance via mixin classes. The interpreter includes the rexxc
utility, which makes it possible to compile ooRexx programs and optionally encode the result as base64, a source-less file that starts faster since the initial parsing and compiling has already been done.[33]
Parsing
[edit]
The PARSE
keyword instruction makes it possible to quickly and flexibly parse a string and assign parts of it to variables in a single step.[2] Subsequent instruction is used to specify the source of the string, for example ARG
for arguments that are listed when the program or function is called, VAR
for variables, PULL
for data queues or standard input (typically the keyboard), VALUE
for any expression. When using VALUE
, the WITH
keyword is required to specify the end of an expression, followed by a parsing pattern. This pattern can be a list of variables, a position number or literal delimiters; it is possible to use these patterns in combination. Optionally, the upper and lower case of the string can be converted before parsing.[29]
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
[edit]
Procedures and functions that are not specific to a particular class are defined with the ::ROUTINE
directive. The CALL
instruction can be used to invoke a routine as a procedure. In addition, routines that return values via the RETURN
keyword instructions can be called using function calls by specifying the name of the routine followed by brackets in which arguments can be sent to the routine. The PARSE
instruction can be used to parse the received arguments and assign them to variables.[29]
call DoSomething /* call keyword instruction */
Sum = myFunction("2","4") /* function call */
say Sum /* output: 6 */
::Routine DoSomething /* routine directive (procedure) */
say "I did something!" /* output: I did something! */
::Routine myFunction /* routine directive (funciton) */
parse arg FirstVar, SecondVar /* assign arguments to variables */
Sum = FirstVar + SecondVar /* do calculation */
return Sum /* return result */
Class and Method
[edit]
The ::CLASS
directive followed by a class name causes the interpreter to define a new class. After the class name, options such as METACLASS
, SUBCLASS
, MIXINCLASS
, ABSTRACT
and INHERIT
can be set in order to use OOP features. The ::METHOD
directive can be used to define a new class method that is associated with the last ::CLASS
directive. The ::ATTRIBUTE
directive is used to define an accessor method that can retrieve or assign an object variable. Using the EXPOSE
instruction, an object variable can be directly exposed to a method.[29]
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 */
Parse arg name /* assigns "Bella" to name */
::method bark /* method directive */
Expose name
say Name "goes woof!" /* output: Bella goes woof! */
Multi-threading
[edit]Conceptually, 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.[29] Concurrency can be achieved either with the REPLY
keyword instruction, which causes an early return from a method while its remainder continues to execute in a new thread, with the GUARD
keyword instruction, which can set a method as unguarded so that it can execute together with other methods of the same class, or by using the START
method of the Object or the Message class, which causes the receiver to process the message in a separate thread.[29]
Tracing
[edit]As in Classic Rexx, the TRACE
keyword instruction and the built-in TRACE()
function facilitate debugging, allow for control of the level of detail and enable interactive debugging at runtime.[34] When interactive debugging, the interpreter pauses after most instructions that are traced.[29] While multi-threaded programs can be traced, ooRexx 5.1.0 introduces as an addition the TraceObject
class, which provides additional information such as time stamps, the interpreter instance, the thread ID on which the message is dispatched, and the state of the guard locks, allowing to judge which method is currently guarded and blocked.[34]
Built-in functions and classes
[edit]While ooRexx is an extension of Classic Rexx with objects, classes and methods, the traditional built-in functions are still available and thus ensure compatibility.[33] The ooRexx release 5.0.0 provides 82 built-in functions, including character manipulation, conversion and information functions, many of which call methods of the String
class.[29] In addition, the built-in dynamic link library RexxUtil offers 29 cross-platform, 25 Windows-specific and four Unix-specific functions for manipulating system files, directories, classes and objects.[29]
ooRexx 5.0.0 contains a total of 57 built-in classes, which are divided into the class groups Fundamental, Stream, Collection and Utility.
Fundamental classes
[edit]Fundamental classes are the essential building blocks for all other classes. The Object
class is the root of the class hierarchy, so that its methods and attributes are available for all instantiated objects of each class. The Class
class (a.k.a. meta class) is used to maintain the properties of a class (like its method objects) and gets used for creating instances (a.k.a. objects, values). Therefore, an instance of this class (a.k.a. class object) is created for each ::CLASS
directive.[29] The purpose of the Method
class and Routine
class is to create method or routine objects. The String
class provides methods for handling strings, such as logical operations, concatenation, copying, joining, splitting, reversing, arithmetic, conversion, and others.[33] A Package
class instance contains all created routines, classes, and methods and manages external dependencies referenced by ::REQUIRES
directives. The Message
class enables the asynchronous sending of messages, which enables the concurrent execution of methods.[29][33]
Stream classes
[edit]Stream classes facilitate communication with external objects such as files, queues, serial interfaces, devices, etc. The Stream
class itself is a mixin class that can be inherited and is a subclass of the InputOutputStream
, InputStream,
and OutputStream
classes.[29]
The Stream
class provides methods for opening, reading, writing, and closing streams and flushing buffers, setting the file location, retrieving information, and other stream-related operations. While the OPEN
method opens the stream, the ARRAYIN
method can be used to read its content into an array object. The CLOSE
method explicitly closes a stream before the stream object is reclaimed by the garbage collector.[29][33]
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 classes
[edit]A collection is an object that contains multiple items with associated indexes that enable items to be retrieved using the AT
or []
methods. There are MapCollection, SetCollection and OrderedCollection classes, all of which allow manipulation of a specific collection type.[33]
The MapCollection class is a mixin class that defines the basic set of methods implemented by all collections that map from an index to a value. The Directory
, StringTable
, IdentityTable
, Properties
, Table
, Relation
and Stem
classes inherit these methods.[29] A Directory or a StringTable object is a collection of unique string indexes. In an IdentityTable object, each item is associated with a single index, and there can only be one item for each index. The Properties object provides specific methods for saving and loading properties into files. Unlike a Table object, which cannot contain duplicate indexes, a Relation object is a collection in which elements can have the same index, which can be of any object type.
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 (.
). While the stem must begin with a letter, the tail can be any character. Using a single numeric tail creates the same effect as an array, while multiple numeric tails can be used to create a multidimensional array.[29][33]
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 Set
object are unique, each index in a Bag
object can appear more than once.[29]
The OrderedCollection class is a mixin class that defines the basic methods for all collections that have an inherent index order, such as the List
, Queue
, CircularQueue
and Array
classes. A List object allows new items, for which a new index is created, to be added at any position in a collection. The associated index remains valid for that item regardless of other additions or removals. A Queue object allows items to be removed from the head and added to the tail or head of the queue. A CircularQueue object is a queue with a predefined size. Once the end of the circular queue is reached, new elements are inserted from the beginning to replace the previous items.[29][33]
An Array is sequenced collection ordered by whole-number indexes. Like some other collection classes, the Array
class provides the MAKESTRING
method to encode its elements as a string object.[29]
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
[edit]
Utility classes are a collection of 31 classes that provide implementations for common tasks. The MutableBuffer
class enables greater efficiency in string operations such as concatenation, as no new object needs to be assigned. The File
class offers methods for all supported file systems, such as listing files in a directory or retrieving information about files and directories.
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 DateTime
or TimeSpan
classes support the retrieval and formatting of a date, time or timestamp in various formats and enable arithmetic operations between them. Several Comparator classes facilitate sorting for built-in classes such as File, DateTime and others. The class Supplier
and its subclass StreamSupplier
enable the enumeration of an items collection together with an indexes collection. The Validate
class provides methods that can be used to check whether given arguments are of the correct class and type, or within a numerical range. A VariableReference
instance maintains a reference, while a WeakReference
instance creates a reference to another object that is not pinned.
A regular expression is a pattern that can be used to match strings. To increase the readability of patterns in the code, the RegularExpression
class allows the use of symbolic names encapsulated with colons (:
) for common sets. For instance, matching a string containing only letters typically described as [A-Za-z]
can be abbreviated using [:alpha:]
.
Other classes help to obtain information about the context of the currently executed code (RexxContext
), the Rexx language or the executing platform (RexxInfo
) and execution specifics (StackFrame
) via environment symbols. The Buffer
and Pointer
classes are specifically designed to support writing methods and function in native code using the C/C++ APIs. Alarm
and Ticker
classes provide notification functions and EventSempahore
and MutexSempahore
classes implement synchronization mechanisms for multi-threading activities. The Monitor
class enables messages to be forwarded to various target objects and the RexxQueue
class provides object-like access to external Rexx data queues.
External packages and libraries
[edit]Using the ::REQUIRES
directive and specifying the LIBRARY
option, external libraries can be integrated per program. Such libraries are usually organized around domain-specific functions.[29]
The Rexx extension library provides a class for reading and writing comma-separated values (CSV) files, for creating and processing JavaScript Object Notation (JSON) data and a sub-command environment native library named "hostemu" that partially emulates a TSO/CMS environment.[35] The RxSock native library enables to incorporate TCP/IP protocols,[36] while the RxFtp native library[37] specifically provides access to the file transfer protocol. The RxMath native library offers advanced mathematical functions such as square root calculation, exponential function, logarithm, sine, cosine, tangent, arc sine and power calculation.[38]
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.[39] The ooRexx interpreter is delivered with several example programs and function packages that demonstrate the use of this framework.[33] For POSIX-compatible operating systems, the orxnCurses class library enables the writing of text-based user interfaces using the ncurses programming library.[40] 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.[41]
Many of these external packages and libraries are also compatible with other Rexx implementations.
Bridges
[edit]While 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++.[42] There is also an external library that implements a bidirectional Java bridge, which enables interaction between ooRexx and Java.[30] Furthermore, classes are provided that enable the automation of Windows applications. The ooSQLite class provides an interface to SQLite, an in-process library that implements a self-contained, serverless, zero-configuration, transactional SQL database engine.[43]
C/C++ APIs
[edit]As 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.[42]
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 ::REQUIRES
directive or by using the EXTERNAL
keyword instruction as part of a ::ROUTINE
, ::METHOD
, or ::ATTRIBUTE
directive.
Java
[edit]
Using the C++ APIs, BSF4ooRexx is a bidirectional Java bridge based on the Bean Scripting Framework that allows ooRexx to communicate with Java objects and enable Java to interact with Rexx applications.[44][45] The bridge is realized by requiring the ooRexx package BSF.CLS
, which defines public routines, classes and the environment symbol .BSF4REXX
.[45] Examples are provided for the use of Java classes in connection with AWT, Swing, JavaFX, JDBC, Java 2D and some others.[44]
.bsf~new('java.awt.Frame', 'Hi from ooRexx.')~show /* create Java object */
call SysSleep 10
::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 UNO.CLS
package.[46] In addition, the CLR.CLS
package together with Jini4Net enables the use of the .NET framework.[47] Communication with processes via the D-Bus middleware under Linux is possible using the DBUS.CLS
package.[48]
Windows automation
[edit]
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 OLEObject
.[49] OLE Automation is an inter-process communication mechanism developed by Microsoft that is based on a subset of the Component Object Model (COM) and enables, among other things, the invocation of program functions, the querying and setting of attributes and the interception of component events. The ooRexx interpreter includes examples that demonstrate OLE interaction with Access, Word, Excel, OpenOffice/LibreOffice, ActiveDirectory, WMI and other programs via OLE, and a utility to browse available OLE objects.[33]
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.[49]
Notes
[edit]- ^ Including interfaces to System Object Model (SOM) and Workplace Shell (WPS)
- ^ Excluding the SOM and WPS packages
- ^ As of 5.0.0, ooRexx has the following directives:
- ::ANNOTATE
- ::ATTRIBUTE
- ::CLASS
- ::CONSTANT
- ::METHOD
- ::OPTIONS
- ::REQUIRES
- ::RESOURCE
- ::ROUTINE.
- ^ Object REXX and Open Object Rexx do not include all of the new features of ANSI standard Rexx.
See also
[edit]References
[edit]- ^ a b "X3.274-1996 American National Standards Institute for Programming Language Rexx" (PDF).
- ^ a b c Fosdick, Howard (2005). Rexx Programmer's Reference. Wiley Publishing. ISBN 0-7645-7996-7.
- ^ "7 Reasons that Rexx Still Matters". SmartBear.com. Retrieved 2024-06-19.
- ^ a b "IBM Object REXX - EDM2". www.edm2.com. Retrieved 2024-06-19.
- ^ Nash, Simon C. (1990-06-11). "Object Oriented REXX" (PDF). Proceedings of the REXX Symposium for Developers and Users: 76-100.
- ^ Nash, Simon C. (2009-05-21). "An Object Rexx Retrospective" (PDF). Proceedings of the 20th Rexx Language Symposium.
- ^ a b "IBM Object REXX for OS/2 - EDM2". www.edm2.com. Retrieved 2024-06-19.
- ^ a b "IBM Object REXX Now Runs on Windows NT and Windows 95". IBM. 1997-02-25.
- ^ Schweizer, Manfred; Berger, Uwe (2005-04-21). "From Object REXX to ooRexx" (PDF). Proceedings of the 16th Rexx Language Symposium.
- ^ a b "IBM Object REXX for AIX - Object-Oriented Scripting Language for Beginners to Advanced Programmers". IBM. 1999-03-30.
- ^ a b "IBM Object REXX for Windows V2R1 - Object-Oriented Programming for Beginners to Advanced Users". IBM. 2001-03-20.
- ^ Where did SOM support go in 4.0.0?
- ^ Willis Boughton (2004). "SOM and Object REXX". EDM/2. Retrieved 2014-02-02.
- ^ "Accessing Workplace Shell Objects". Object REXX Reference. IBM.
- ^ "Does ArcaOS include REXX support?". Retrieved 2020-09-03.
- ^ "Software withdrawal and service discontinuance: IBM Object REXX". IBM. 2004-10-12.
- ^ "RexxLA - Rexx Symposia". www.rexxla.org. Retrieved 2024-05-17.
- ^ "ooRexx (Open Object Rexx) - Browse /oorexx at SourceForge.net". sourceforge.net. Retrieved 2024-05-18.
- ^ "ooRexx (Open Object Rexx) - Browse /oorexx-docs at SourceForge.net". sourceforge.net. Retrieved 2024-05-18.
- ^ Flatscher, Rony G. (2023). "The IntelliJ IDEA Plugin ooRexxPlugin 2.2 for Rexx and ooRexx 5.0" (PDF).
- ^ a b c d "ooRexx News". Sourceforge. Retrieved 18 May 2024.
- ^ Open Object Rexx Reference Version 3.0.0 Edition (PDF). RexxLA. 24 March 2005. Retrieved 18 May 2024.
- ^ "ooRexx 4.0.0: Readme" (PDF). Retrieved 18 May 2024.
- ^ "ooRexx 4.1.0: ReleaseNotes". Retrieved 18 May 2024.
- ^ "ooSQLite: Readme". Retrieved 18 May 2024.
- ^ "ooRexx 4.2.0: Changes". Retrieved 18 May 2024.
- ^ "ooRexx 5.0.0: Changes". Retrieved 18 May 2024.
- ^ a b c Cowlishaw, Mike (1987). "The design of the REXX language". ACM SIGPLAN Notices. 22 (2): 26–35. doi:10.1145/24686.24687.
- ^ a b c d e f g h i j k l m n o p q r s t u v w Ashley, W. David; Flatscher, Rony G.; Hessling, Mark; McGuire, Rick; Peedin, Lee; Sims, Oliver; Wolfers, Jon (2022). ooRexx Documentation 5.0.0 Open Object Rexx Reference (PDF). RexxLA.
- ^ a b c d Flatscher, Rony G.; Winkler, Till. "Employing the Message Paradigm to Ease Learning Object-oriented Concepts and Programming" (PDF). In 2024 47th MIPRO ICT and Electronics Convention (MIPRO): 1244–1249.
- ^ a b c Winkler, Till; Flatscher, Rony G. "Cognitive Load in Programming Education: Easing the Burden on Beginners with REXX" (PDF). Central European Conference on Information and Intelligent Systems.
- ^ Stefik, Andreas; Siebert, Susanna (2013). "An empirical investigation into programming language syntax". ACM Transactions on Computing Education. 13 (4): 1–40. doi:10.1145/2534973.
- ^ a b c d e f g h i j k Ashley, W. David; Flatscher, Rony G.; Hessling, Mark; McGuire, Rick; Peedin, Lee; Sims, Oliver; Wolfers, Jon (2022). ooRexx Documentation 5.0.0 Programmer Guide (PDF). RexxLA.
- ^ a b Flatscher, Rony G.; Winkler, Till (2024). "Devising a TraceObject Class for Improved Runtime Monitoring of ooRexx Applications". Proceedings of the 7th ACM International Workshop on Verification and Monitoring at Runtime Execution: 19-24.
- ^ Ashley, W. David; Flatscher, Rony G.; Hessling, Mark; McGuire, Rick; Peedin, Lee; Sims, Oliver; Wolfers, Jon (2022). ooRexx Documentation 5.0.0 Rexx Extensions Library Reference (PDF). RexxLA.
- ^ Ashley, W. David; Flatscher, Rony G.; Hessling, Mark; McGuire, Rick; Peedin, Lee; Sims, Oliver; Wolfers, Jon (2022). ooRexx Documentation 5.0.0 RxSock TCP/IP Socket Functions Reference (PDF). RexxLA.
- ^ Ashley, W. David; Flatscher, Rony G.; Hessling, Mark; McGuire, Rick; Peedin, Lee; Sims, Oliver; Wolfers, Jon (2022). ooRexx Documentation 5.0.0 RxFtp Class Library Reference (PDF). RexxLA.
- ^ Ashley, W. David; Flatscher, Rony G.; Hessling, Mark; McGuire, Rick; Peedin, Lee; Sims, Oliver; Wolfers, Jon (2022). ooRexx Documentation 5.0.0 RxMath Math Functions Reference (PDF). RexxLA.
- ^ Ashley, W. David; Flatscher, Rony G.; McGuire, Rick; Peedin, Lee; Sims, Oliver; Wolfers, Jon (2019). ooRexx Documentation 4.2.4 ooDialog Reference (PDF). RexxLA.
- ^ Ashley, W. David; Flatscher, Rony G.; Hessling, Mark; McGuire, Rick; Peedin, Lee; Sims, Oliver; Steinböck, Erich; Wolfers, Jon (2022). ooRexx Documentation 5.0.0 nCurses Class Library Reference (PDF). RexxLA.
- ^ Ashley, W. David; Flatscher, Rony G.; Hessling, Mark; McGuire, Rick; Peedin, Lee; Sims, Oliver; Steinböck, Erich; Wolfers, Jon (2022). ooRexx Documentation 5.0.0 Unix Extensions Function Reference (PDF). RexxLA.
- ^ a b Ashley, W. David; Flatscher, Rony G.; Hessling, Mark; McGuire, Rick; Peedin, Lee; Sims, Oliver; Wolfers, Jon (2022). ooRexx Documentation 5.0.0 Application Programming Interfaces (PDF). RexxLA.
- ^ Ashley, W. David; Flatscher, Rony G.; McGuire, Rick; Miesfeld, Mark; Peedin, Lee; Sims, Oliver; Wolfers, Jon (2022). ooRexx Documentation 1.0.0 ooSQLite Reference (PDF). RexxLA.
- ^ a b "BSF4ooRexx". sourceforge.net. Retrieved 2024-11-10.
- ^ a b Flatscher, Rony G. (2009). "The 2009 Edition of BSF4Rexx Part I" (PDF). 20th Rexx Language Symposium. RexxLA.
- ^ Waglechner, Christoph (2009). OpenOffice.org Automation Using ooRexx Scripting Language by means of Selected Nutshell Examples by Andrew Pitonyak (PDF).
- ^ Baginski, Adrian (2016). A .NET Cookbook Using ooRexx.NET (PDF).
- ^ Lagler, Richard (2015). D-Bus Language Binding for ooRexx: An Introduction on Nutshell Examples (PDF).
- ^ a b Ashley, W. David; Flatscher, Rony G.; Hessling, Mark; McGuire, Rick; Peedin, Lee; Sims, Oliver; Sims, Oliver; Wolfers, Jon (2022). ooRexx Documentation 5.0.0 Windows Extensions Reference (PDF). RexxLA.
Further reading
[edit]- Ashley, W. David; Flatscher, Rony G.; Hessling, Mark; McGuire, Rick; Peedin, Lee; Sims, Oliver; Wolfers, Jon (2022). ooRexx Documentation 5.0.0 Open Object Rexx Reference (PDF). RexxLA.
- Ashley, W. David; Flatscher, Rony G.; Hessling, Mark; McGuire, Rick; Peedin, Lee; Sims, Oliver; Wolfers, Jon (2022). ooRexx Documentation 5.0.0 Programmer Guide (PDF). RexxLA.
- Ashley, W. David; Flatscher, Rony G.; Hessling, Mark; McGuire, Rick; Peedin, Lee; Sims, Oliver; Sims, Oliver; Wolfers, Jon (2022). ooRexx Documentation 5.0.0 Windows Extensions Reference (PDF). RexxLA.
- Ashley, W. David; Flatscher, Rony G.; Hessling, Mark; McGuire, Rick; Peedin, Lee; Sims, Oliver; Wolfers, Jon (2022). ooRexx Documentation 5.0.0 Application Programming Interfaces (PDF). RexxLA.
External links
[edit]- Text-oriented programming languages
- High-level programming languages
- Multi-paradigm programming languages
- Class-based programming languages
- Object-oriented programming languages
- Structured programming languages
- Dynamically typed programming languages
- Free and open source interpreters
- Scripting languages
- IBM software
- Cross-platform software
- Rexx
- Programming languages created in 1988