Rexx 快速指南

---

---

Rexx - 概述

Rexx (Restructured Extended Executor) 旨在成为一种脚本语言。其目标是使脚本编写尽可能简单、快速、可靠和无错误。许多编程语言的设计是为了与旧语言兼容，并为特定受众或平台编写。Rexx 忽略了无关的目标。它从一开始就被设计成功能强大且易于使用。

Rexx 由 IBM 的 Mike Cowlishaw 于 1979 年 3 月 20 日至 1982 年年中设计并首次使用汇编语言实现，最初作为一个脚本编程语言来替代EXEC 和 EXEC 2语言。它被设计为任何系统的宏或脚本语言。因此，Rexx 被认为是 Tcl 和 Python 的前身。Rexx 的创建者还旨在使其成为 PL/I 编程语言的简化和易于学习的版本。

Rexx 的特性

作为一种编程语言，Rexx 具有以下关键特性：

• 简单的语法

• 能够将命令路由到多个环境

• 能够支持与特定调用环境相关的函数、过程和命令。

• 内置栈，能够与主机栈（如果存在）互操作。

• 包含只有几十条指令的小型指令集

• 自由格式语法

• 不区分大小写的标记，包括变量名

• 基于字符串

• 动态数据类型，无需声明

• 没有保留关键字，除非在局部上下文中

• 没有包含文件功能

• 任意数值精度

• 十进制算术，浮点数

• 丰富的内置函数选择，特别是字符串和单词处理

• 自动存储管理

• 崩溃保护

• 内容可寻址数据结构

• 关联数组

• 直接访问系统命令和功能

• 简单的错误处理以及内置跟踪和调试器

• 很少的人为限制

• 简化的 I/O 功能

Rexx 的官方网站是 www.oorexx.org

Rexx - 环境

在开始使用 Rexx 之前，您需要确保您的系统上运行着一个功能齐全的 Rexx 版本。本章将解释在 Windows 机器上安装 Rexx 及其后续配置，以便开始使用 Rexx。

在继续安装之前，请确保满足以下系统要求。

系统要求

下载 Rexx

要下载 Rexx，您应该使用以下 URL：https://www.oorexx.org/download.html

此页面提供了各种 Rexx 版本的各种下载，如下面的屏幕截图所示。

单击标题为 Release 4.2.0 的表中的“ooRexx 安装文件”。

之后，您将被重定向到以下页面。

单击ooRexx-4.2.0.windows.x86_64.exe 下载软件的64 位版本。我们将在下一章讨论有关软件安装的内容。

Rexx - 安装

以下步骤将详细解释如何在 Windows 系统上安装 Rexx。

步骤 1 - 启动在上一节下载的安装程序。安装程序启动后，单击“运行”按钮。

步骤 2 - 单击以下屏幕上的“下一步”按钮以继续安装。

步骤 3 - 单击“我同意”按钮继续。

步骤 4 - 接受默认组件，然后单击“下一步”按钮。

步骤 5 - 选择安装位置，然后单击“下一步”按钮。

步骤 6 - 接受将安装的默认进程，然后单击“下一步”按钮。

步骤 7 - 选择默认文件关联，然后单击“下一步”按钮。

步骤 8 - 单击将 Rexx 项目发送到可执行文件的复选框，然后单击“下一步”按钮，如下面的屏幕截图所示。

步骤 9 - 在下一个屏幕中，选择用于处理 Rexx 文件的编辑器。将记事本保留为默认选项。还接受每个 Rexx 文件的默认扩展名。

步骤 10 - 接受出现的下一个屏幕上的默认设置，然后单击“下一步”按钮以继续安装。

步骤 11 - 最后，单击“安装”按钮以继续安装。

步骤 12 - 安装完成后，您需要单击“下一步”按钮以继续。

步骤 13 - 单击“完成”按钮以完成安装。

Rexx - 插件安装

在本章中，我们将讨论如何在流行的 IDE（集成开发环境）中安装插件。Rexx 作为一种编程语言，也适用于流行的 IDE，例如Eclipse。让我们看看如何在这些 IDE 中获取所需的插件，以便您在使用 Rexx 时有更多选择。

在 Eclipse 中安装

要在 Eclipse 中顺利安装 Rexx，您需要遵守以下步骤。

步骤 1 - 打开 Eclipse 并单击菜单项帮助→Eclipse 市场，如下面的屏幕截图所示。

步骤 2 - 在下一个对话框中，在搜索条件中输入 Rexx，然后单击搜索按钮。

完成后，单击“安装”按钮。

步骤 3 - 单击“确认”按钮以继续进行功能安装。

步骤 4 - Eclipse 然后将下载必要的文 件以开始安装。完成后，Eclipse 将要求接受许可协议。单击接受许可协议，然后单击“完成”按钮，如下面的屏幕截图所示。

Eclipse 然后将在后台开始安装软件。

步骤 5 - 您可能会收到安全警告（如下面的屏幕截图所示）。单击“确定”按钮继续。

步骤 6 - 安装更新后，系统将提示您重新启动 Eclipse。单击“是”以重新启动 Eclipse。

Rexx - 基本语法

为了理解 Rexx 的基本语法，让我们首先来看一个简单的 Hello World 程序。

示例

/* Main program */ 
say "Hello World" 

可以看出 Hello World 程序有多简单。它是一个简单的脚本行，用于执行 Hello World 程序。

关于上述程序，需要注意以下几点：

• say 命令用于将值输出到控制台。

• /* */ 用于 Rexx 中的注释。

上述程序的输出将是：

Hello World

语句的一般形式

在 Rexx 中，让我们看看程序的一般形式。请看下面的例子。

/* Main program */ 
say add(5,6) 
exit 
add: 
parse arg a,b 
return a + b

上述程序的输出将是：

11

让我们回顾一下我们从上述程序中了解到的内容：

• Add 是一个定义为将两个数字相加的函数。

• 在主程序中，5 和 6 的值用作 add 函数的参数。

• exit 关键字用于退出主程序。这用于区分主程序和 add 函数。

• add 函数用“:”符号区分。

• parse 语句用于解析传入的参数。

• 最后，return 语句用于返回数值之和。

子程序和函数

在 Rexx 中，代码通常分为子程序和函数。子程序和函数用于将代码划分为不同的逻辑单元。子程序和函数之间的关键区别在于，函数返回值而子程序不返回值。

下面是子程序和函数在加法实现方面的关键区别示例：

函数实现

/* Main program */ 
say add(5,6) 
exit 
add: 
parse arg a,b 
return a + b

子程序实现

/* Main program */ 
add(5,6) 
exit 
add: 
parse arg a,b 
say a + b

两个程序的输出值都将是 11。

执行命令

Rexx 可用作各种基于命令的系统的控制语言。Rexx 在这些系统中执行命令的方式如下。当 Rexx 遇到既不是指令也不是赋值的程序行时，它会将该行视为要计算然后传递给环境的字符串表达式。

例如：

示例

/* Main program */ 
parse arg command 
command "file1" 
command "file2" 
command "file3" 
exit 

此程序中的三行类似的行都是字符串表达式，它将文件名（包含在字符串常量中）添加到命令名（作为参数给出）。生成的字符串将传递给环境以作为命令执行。命令完成后，“rc”变量将设置为命令的退出代码。

上述程序的输出如下：

sh: file1: command not found
     3 *-* command "file1" 
       >>>   " file1"
       +++   "RC(127)"
sh: file2: command not found
     4 *-* command "file2" 
       >>>   " file2"
       +++   "RC(127)"
sh: file3: command not found
     5 *-* command "file3" 
       >>>   " file3"
       +++   "RC(127)"

Rexx 中的关键字

REXX 的自由语法意味着某些符号在特定上下文中保留供语言处理器使用。

在特定指令中，某些符号可能被保留用于分隔指令的各个部分。这些符号被称为关键字。REXX 关键字的示例包括**DO 指令中的 WHILE**，以及**IF 或 WHEN 子句**后面的**THEN**（在这种情况下充当子句终止符）。

除了这些情况外，只检查那些作为子句中第一个标记且后跟“=”或“:”以外的简单符号，以查看它们是否为指令关键字。您可以在子句中的其他地方自由使用这些符号，而不会将其视为关键字。

REXX 中的注释

注释用于为代码添加文档。单行注释通过在该行的任何位置使用 /* */ 来标识。

例如：

/* Main program */
/* Call the add function */
add(5,6)

/* Exit the main program */
exit add:

/* Parse the arguments passed to the add function */ parse arg a,b
/* Display the added numeric values */
say a + b

注释也可以写在代码行之间，如下面的程序所示：

/* Main program */ 
/* Call the add function */ 
add(5,6) 

/* Exit the main program */ 
exit 
add: 
parse    /* Parse the arguments passed to the add function */ 
arg a,b 

/* Display the added numeric values */ 
say a + b

上述程序的输出将是：

11

您也可以在注释中包含多行，如下面的程序所示：

/* Main program 
The below program is used to add numbers 
Call the add function */ 
add(5,6) 
exit 
add: 
parse arg a,b 
say a + b

上述程序的输出将是：

11

REXX - 数据类型

在任何编程语言中，您都需要使用各种变量来存储各种类型的信息。变量只不过是保留的内存位置，用于存储值。这意味着当您创建变量时，您会在内存中保留一些空间来存储与该变量关联的值。

您可能希望存储各种数据类型的信息，例如字符串、字符、宽字符、整数、浮点数、布尔值等。根据变量的数据类型，操作系统将分配内存并决定可以在保留的内存中存储什么。

内置数据类型

REXX 提供了各种内置数据类型。以下是REXX中定义的数据类型列表。

• **整数** - 不包含小数点或指数标识符的数字字符串。第一个字符可以是**加号 (+) 或减号 (-)**。表示的数字必须介于 -2147483648 和 2147483647（含）之间。

• **大整数** - 不包含小数点或指数标识符的数字字符串。第一个字符可以是加号 (+) 或减号 (-)。表示的数字必须介于 -9223372036854775808 和 2147483648（含）之间，或介于 2147483648 和 9223372036854775807 之间。

• **十进制** - 将采用以下格式之一：

  • 包含小数点但不包含指数标识符的数字字符串。**p** 代表精度，**s** 代表字符串表示的十进制数的标度。第一个字符可以是加号 (+) 或减号 (-)。

  • 不包含小数点或指数标识符的数字字符串。第一个字符可以是加号 (+) 或减号 (-)。表示的数字小于 -9223372036854775808 或大于 9223372036854775807。

• **浮点数** - 以科学计数法表示数字的字符串。该字符串由一系列数字后跟指数标识符（E 或 e 后跟可选的加号 (+) 或减号 (-) 和一系列数字）组成。该字符串可以以加号 (+) 或减号 (-) 开头。

• **字符串** - 普通字符字符串。

以下是每种数据类型使用方法的一些示例。每种数据类型将在后续章节中详细讨论。这只是为了让您快速了解上述数据类型的简要说明。

整数

下面的程序显示了如何使用数字数据类型。此程序显示了两个整数的加法。

示例

/* Main program 
The below program is used to add numbers 
Call the add function */ 
add(5,6)  

exit 
add:  

parse arg a,b 
say a + b 

上述程序的输出将是：

11

大整数

下面的程序显示了 REXX 处理大整数的能力。此程序显示了如何添加两个大整数。

示例

/* Main program 
The below program is used to add numbers 
Call the add function */ 
add(500000000000,6000000000000000000000)  

exit 
add:  

parse arg a,b 
say a + b

上述程序的输出将是：

6.00000000E+21

十进制

下面的程序显示了 REXX 处理十进制数的能力。此程序显示了如何添加两个十进制数。

示例

/* Main program 
The below program is used to add numbers 
Call the add function */ 
add(5.5,6.6)  

exit 
add:  

parse arg a,b 
say a + b 

上述程序的输出将是：

12.1 

浮点数

以下示例展示了数字如何作为浮点数工作。

示例

/* Main program 
The below program is used to add numbers 
Call the add function */ 
add(12E2,14E4)  

exit 
add:  

parse arg a,b 
say a + b

上述程序的输出将是：

141200

字符串

下面的程序显示了如何使用元组数据类型。

在这里，我们定义了一个包含 3 个元素的**元组 P**。**tuple_size** 是 REXX 中定义的内置函数，可用于确定元组的大小。

示例

/* Main program */ 
display("hello")  

exit 
display:  

parse arg a 
say a

上述程序的输出将是：

hello

Rexx - 变量

在 REXX 中，所有变量都使用“=”语句绑定。变量名有时也称为符号。它们可以由字母、数字和字符（例如“**. ! ? _**”）组成。您创建的变量名不能以数字或句点开头。简单的变量名不包含句点。包含句点的变量名称为复合变量，表示数组或表。

以下是 REXX 中的基本变量类型，在上一章中也有解释：

• **整数** - 用于表示整数或浮点数。例如 10。

• **大整数** - 表示较大的整数值。

• **十进制** - 十进制值是包含小数点但不包含指数标识符的数字字符串。

• **浮点数** - 浮点值是以科学计数法表示数字的字符串。

• **字符串** - 一系列字符定义了 REXX 中的字符串。

不同类型的变量函数

在本节中，我们将讨论变量可以执行的各种函数。

变量声明

定义变量的通用语法如下所示：

var-name = var-value 

其中

• **var-name** - 这是变量的名称。

• **var-value** - 这是绑定到变量的值。

下面的程序是变量声明的示例：

示例

/* Main program */ 
X = 40 
Y = 50 
Result = X + Y 
say Result

在上面的示例中，我们有两个变量，一个是绑定到值**40**的**X**，另一个是绑定到值**50**的**Y**。另一个名为 Result 的变量绑定到**X 和 Y**的和。

上述程序的输出如下：

90

变量命名

变量名有时也称为符号。它们可以由字母、数字和字符（例如“. ! ? _”）组成。您创建的变量名不能以数字或句点开头。

如果尚未为变量赋值，则将其称为未初始化变量。未初始化变量的值是变量本身的大写字母名称。

未赋值变量的示例如下：

示例

/* Main program */ 
unassignedvalue 
say unassignedvalue 

如果运行上面的程序，您将得到以下输出：

UNASSIGNEDVALUE
sh: UNASSIGNEDVALUE: command not found
     2 *-* unassignedvalue 
       >>>   "UNASSIGNEDVALUE"
       +++   "RC(127)"

变量可以多次赋值。下面的程序显示了如何多次为 X 赋值。

示例

/* Main program */ 
X = 40 
X = 50 
say X 

上述程序的输出如下：

50

打印变量

使用**say**命令打印变量的值。以下是打印多个变量的示例。

示例

/* Main program */ 
X = 40 

/* Display an Integer */ 
say X 
Y = 50.5 

/* Display a Float */ 
say Y 
Z = "hello" 

/* Display a string */ 
say Z 

上述程序的输出如下：

40 
50.5 
hello 

Rexx - 运算符

运算符是一个符号，它告诉编译器执行特定的数学或逻辑操作。

REXX 有各种类型的运算符，也详细解释如下：

• 算术运算符
• 关系运算符
• 逻辑运算符
• 位运算符

算术运算符

REXX 语言支持与任何语言相同的普通算术运算符。以下是 REXX 中可用的算术运算符。

显示示例

关系运算符

关系运算符允许比较对象。以下是 REXX 中可用的关系运算符。在 REXX 中，真值用 1 表示，假值用 0 表示。

显示示例

逻辑运算符

逻辑运算符用于评估布尔表达式。以下是 REXX 中可用的逻辑运算符。

显示示例

位运算符

Groovy 提供四个位运算符。以下是 Groovy 中可用的位运算符。

显示示例

运算符优先级

下表按 REXX 运算符的优先级递减顺序显示运算符优先级。

Rexx - 数组

在任何编程语言中，数组都允许您对同一类型的值的列表进行分组。使用数组的好处是它允许您构建一个类似类型值的列表，这些值是**可排序的、可搜索的**，并且可以**轻松操作**。REXX 也允许定义数组。这些数组可以是一维的或多维的。

REXX 数组可能是稀疏的。也就是说，并非每个数组位置都必须有值，甚至不必初始化。在包含数据元素的那些元素之间，可能存在空的数组位置或槽。或者数组可以是密集的，其中连续的数组槽都包含数据元素。

在许多编程语言中，您必须关心表中第一个条目的下标是什么。第一个数字下标是 0 还是 1？在 REXX 中，第一个下标是您使用的任何值！因此，根据您的喜好，将第一个数组元素输入到位置 0 或 1。

array_name.0 = ‘first element’

或

array_name.1 = ‘first element’

让我们看看数组可用的不同操作。

创建数组

数组的创建使用与 REXX 中变量相同的命名约定。

创建数组的通用语法如下：

Arrayname.index = value 

其中

• **Arrayname** - 这是为数组提供的名称。

• **Index** - 这是数组中的索引位置，用于引用特定元素。

• **Value** - 这是分配给数组中索引元素的值。

数组声明的示例如下：

示例

/* Main program */ 
list.1 = 0 
list.2 = 0 
list.3 = 0

关于上述程序，需要注意以下几点：

• 数组的名称为 list
• 数组有 3 个元素，其值初始化为 0。

为数组元素赋值

可以像初始化数组元素一样重新为数组元素赋值。

下面的程序是一个示例，它可以为现有数组的各种索引值赋值。

/* Main program */ 
list.1 = 0 
list.2 = 0 
list.3 = 0 

/* Assigning new values to the array*/ 
list.1 = 10 
list.3 = 30 

显示数组的值

可以通过引用数组元素的索引位置来显示数组的值。以下示例演示如何访问数组的各种元素。

示例

/* Main program */ 
list.1 = 0 
list.2 = 0 
list.3 = 0 

/* Assigning new values to the array*/ 
list.1 = 10 
list.3 = 30 
say list.1 
say list.2 
say list.3 

上述程序的输出如下：

10
0
30

复制数组

可以将数组的所有元素复制到另一个数组中。其一般语法如下：

Newarray. = sourcearray. 

其中

• Newarray − 这是需要将元素复制到的新数组。

• Sourcearray − 这是需要从中复制元素的源数组。

以下程序显示了如何执行数组的复制操作：

示例

/* Main program */ 
list.1 = 0 
list.2 = 0 
list.3 = 0 

/* Assigning new values to the array*/ 
list.1 = 10 
list.3 = 30 
listnew. = list. 

say listnew.1 
say listnew.2 
say listnew.3 

上述程序的输出将是：

10
0
30

迭代数组元素

也可以使用 Rexx 中提供的迭代语句来迭代数组元素。以下是执行此操作的示例：

示例

/* Main program */ 
list.1 = 10 
list.2 = 20 
list.3 = 30 

number_of_elements = 3 
do j = 1 to number_of_elements 
say list.j 
end 

关于上述程序，需要注意以下几点：

• do 循环用于迭代数组元素。

• 变量number_of_elements用于存储数组中元素的数量。

• 变量j用于迭代数组的每个元素。

上述程序的输出将是：

10
20
30

二维数组

前面也提到过，我们可以在 Rexx 中构建多维数组。让我们来看一个如何实现二维数组的示例。

示例

/* Main program */ 
list.1 = 10 
list.1.1 = 11 
list.1.2 = 12 

say list.1 
say list.1.1 
say list.1.2 

上述程序的输出将显示如下：

10
11
12

关于上述程序，需要注意以下几点：

• 要创建多维数组，可以使用另一层索引。因此，在我们的示例中，我们使用list.1.1为 list 数组的索引值 1 创建另一个内部数组。

Rexx - 循环

到目前为止，我们已经看到了按顺序依次执行的语句。此外，Rexx 中还提供了用于更改程序逻辑控制流的语句。然后，它们被分类为控制流语句，我们将详细研究这些语句。

循环语句允许我们多次执行一条语句或一组语句。以下图示是大多数编程语言中循环语句的一般形式。

让我们讨论 Rexx 支持的各种循环。

受控重复

do 循环可以用于执行语句的受控重复。

语法

此类语句的一般语法如下。

do index = start [to limit] [by increment] [for count] 
statement #1 
statement #2 
end 

此语句的不同之处在于，有一个索引用于控制循环执行的次数。其次，有一些参数说明索引应从哪个值开始，应在哪里结束以及增量值是多少。

流程图

让我们来看看这个循环的流程图：

从上图可以清楚地看到，循环是根据索引值以及如何递增索引值来执行的。

以下程序是受控重复语句的示例。

示例

/* Main program */ 
do i = 0 to 5 by 2 
   say "hello" 
end 

在上例程序中，count i的值首先设置为 0。然后以 2 为增量递增，直到值不大于 5。

上述代码的输出将是：

hello 
hello 
hello 

Rexx - 决策

决策结构要求程序员指定一个或多个条件供程序评估或测试。

下图显示了大多数编程语言中典型的决策结构的一般形式。

如果条件确定为true，则执行一条或多条语句；如果条件确定为false，则可以选择执行其他语句。

让我们看看 Rexx 中可用的各种决策语句。

嵌套 if 语句

有时需要在彼此内部嵌套多个 if 语句，这在其他编程语言中也是可能的。在 Rexx 中，这也是可能的。

语法

if (condition1) then 
   do 
      #statement1 
   end 
else 
   if (condition2) then 
      do 
      #statement2 
   end

流程图

嵌套if语句的流程图如下：

让我们来看一个嵌套if语句的示例：

示例

/* Main program */ 
i = 50 
if (i < 10) then 
   do 
      say "i is less than 10" 
   end 
else 
if (i < 7) then 
   do 
      say "i is less than 7" 
   end 
else 
   do 
      say "i is greater than 10" 
   end 

上述程序的输出将是：

i is greater than 10 

select 语句

Rexx 提供了 select 语句，可用于根据 select 语句的输出执行表达式。

语法

此语句的一般形式为：

select 
when (condition#1) then 
statement#1 

when (condition#2) then 
statement#2 
otherwise 

defaultstatement 
end 

此语句的一般工作原理如下：

• select 语句有一系列 when 语句来评估不同的条件。

• 每个when 子句都有一个不同的条件需要评估，然后执行后续语句。

• 如果前面的 when 条件不评估为 true，则使用 otherwise 语句运行任何默认语句。

流程图

select语句的流程图如下

以下程序是 Rexx 中 case 语句的示例。

示例

/* Main program */ 
i = 50 
select 
when(i <= 5) then 
say "i is less than 5" 

when(i <= 10) then 
say "i is less than 10" 

otherwise 
say "i is greater than 10" 
end

上述程序的输出将是：

i is greater than 10 

Rexx - 数字

在数字方面，Rexx 具有以下数据类型。

• 整数− 不包含小数点或指数标识符的数字字符串。第一个字符可以是加号 (+) 或减号 (-)。表示的数字必须介于 -2147483648 和 2147483647（含）之间。

• **大整数** - 不包含小数点或指数标识符的数字字符串。第一个字符可以是加号 (+) 或减号 (-)。表示的数字必须介于 -9223372036854775808 和 2147483648（含）之间，或介于 2147483648 和 9223372036854775807 之间。

• 十进制− 以下格式之一：

  • 包含小数点但不包含指数标识符的数字字符串，其中p表示精度，s表示字符串表示的十进制数的规模。第一个字符可以是加号 (+) 或减号 (-)。

  • 不包含小数点或指数标识符的数字字符串。第一个字符可以是加号 (+) 或减号 (-)。表示的数字小于 -9223372036854775808 或大于 9223372036854775807。

• **浮点数** - 以科学计数法表示数字的字符串。该字符串由一系列数字后跟指数标识符（E 或 e 后跟可选的加号 (+) 或减号 (-) 和一系列数字）组成。该字符串可以以加号 (+) 或减号 (-) 开头。

现在让我们看看可用于数字的不同方法。

Rexx - 字符串

Rexx 中的字符串由一系列字符表示。以下程序是字符串的示例：

/* Main program */ 
a = "This is a string" 
say a

上述程序的输出如下：

This is a string 

让我们讨论一些 Rexx 中可用于字符串的方法。

Rexx - 函数

Rexx 中的代码通常分为函数和子程序。使用函数有助于将代码细分为更多逻辑单元。让我们详细了解这些函数。

定义函数

函数声明的语法如下：

FunctionName: 
PARSE ARG arguement1, arguement2… arguementN 
Return value 

其中：

• FunctionName − 这是分配给函数的名称。

• PARSE ARG − 这些是 Rexx 中的关键字，用于表示参数正在传递给函数。

• arguement1, arguement2… arguementN − 这些是传递给函数的参数。

• 返回值 − 这是函数返回的值。

以下程序是一个简单的示例，说明如何在 Rexx 中使用函数。

/* Main program */ 
say add(5,6) 
exit 
add: 
PARSE ARG a,b 
return a + b 

关于上述程序，需要注意以下几点：

• 我们正在定义一个名为 add 的函数，它接受 2 个参数 a 和 b。

• 该函数使用 return 语句返回 a 和 b 的总和。

• 必须使用 exit 语句来表示主程序的结束。

上述程序的输出将如下所示：

11

使用参数

在 Rexx 中，有一些特定函数可以与参数一起使用。让我们来看几个这样的参数。

arg

此方法用于返回为函数定义的参数数量。

语法：

arg() 

参数：无

返回值：此方法返回为函数定义的参数数量。

示例：

/* Main program */ 
say add(5,6) 
exit 
add: 
PARSE ARG a,b 

say arg() 
return a + b 

输出：运行上述程序时，我们将得到以下结果。

2 
11 

arg(index)

此方法用于返回特定位置的参数值。

语法：

arg(index)

参数：

• 索引：要返回的参数的索引位置。

返回值：此方法返回特定位置的参数值。

示例：

/* Main program */ 
say add(5,6) 
exit 
add: 
PARSE ARG a,b 

say arg(1) 
return a + b 

输出：运行上述程序时，我们将得到以下结果。

5 
11 

递归函数

递归函数或例程是调用自身的函数。任何递归函数都可以以传统的非递归方式（或迭代方式）编写代码，但有时递归会提供更好的问题解决方案。并非所有编程语言都支持递归；Rexx 支持。

让我们来看一个使用 Rexx 中递归函数的著名阶乘程序示例。

/* Main program */ 
do n = 1 to 5 
say 'The factorial of' n 'is:' factorial( n ) 
end 
return  

/* Function to get factorial */ 
factorial : procedure 
n = arg(1) 
if n = 1 then 
return 1 
return n * factorial( n - 1 ) 

上述程序的输出如下：

The factorial of 1 is: 1
The factorial of 2 is: 2 
The factorial of 3 is: 6 
The factorial of 3 is: 24 
The factorial of 3 is: 120 

Rexx - 栈

栈有时被称为外部数据队列，但我们遵循常用用法，将其称为栈。它是一块逻辑上位于 Rexx 外部的内存块。像 push 和 queue 这样的指令将数据放入栈中，而像 pull 和 parse 这样的指令则从中提取数据。queued 内置函数报告栈中包含多少项。

让我们来看一个栈的例子。

/* STACK: */
/* */ 
/* This program shows how to use the Rexx Stack as either a */ 

/* stack or a queue. */ 
do j = 1 to 3 
push ‘Stack: line #’ || j 

/* push 3 lines onto the stack */ 
end 
do j = 1 to queued() 

/* retrieve and display LIFO */ 
pull line 
say line 
end 
do j = 1 to 3 queue ‘Queue: line #’ || j 

/* queue 3 lines onto the stack */ 
end 
do queued() 

/* retrieve and display FIFO */ 
pull line 
say line 
end 
exit 0

程序中的第一个 do 循环将三行数据放入栈中。它使用 push 指令来完成此操作。我们对这些行进行编号，以便在 LIFO（后进先出）顺序检索它们时，它们的顺序一目了然。

push 指令放入栈中的项将按 LIFO 顺序检索 -

do j = 1 to 3 
push ‘Stack: line #’ || j     /* push 3 lines onto the stack */ 
end

下一个代码块显示了使用 queued 内置函数来查找栈中行数的方法，以及一个循环来从栈中检索所有行 -

do j = 1 to queued()    /* retrieve and display LIFO */ 
pull line 
say line 
end

由于这三个项目是通过 push 放入栈中的，因此它们以 LIFO 顺序检索。

上述程序的输出如下。

STACK: LINE #3 
STACK: LINE #2 
STACK: LINE #1   

Rexx - 文件I/O

在处理 I/O 时，Rexx 提供多种方法。Rexx 提供更简单的类来为文件提供以下功能。

• 读取文件
• 写入文件
• 查看文件是文件还是目录

Rexx 中用于文件 I/O 的函数基于行输入和字符输入，我们将详细研究这两种函数。

让我们探索 Rexx 提供的一些文件操作。出于这些示例的目的，我们将假设存在一个名为 **NewFile.txt** 的文件，其中包含以下文本行：

Example1

Example2

Example3

此文件将用于以下示例中的读写操作。在这里，我们将讨论如何以不同的方式读取文件的内容。

一次读取一行文件内容

对文件的常规操作是通过使用 Rexx 库本身中提供的方法来执行的。在 Rexx 中，读取文件是最简单的操作之一。

让我们看看用于完成此操作的函数。

linein

此方法从文本文件中返回一行。文本文件是作为函数输入参数提供的文件名。

语法：

linein(filename) 

参数：

• **文件名** - 这是需要从中读取行的文件名。

**返回值** - 此方法一次返回文件的一行。

示例：

/* Main program */ 
line_str = linein(Example.txt) 
say line_str

上面的代码非常简单，因为它将 **Example.txt** 文件名提供给 linein 函数。然后，此函数读取一行文本并将结果提供给变量 **line_str**。

输出：运行上述程序时，我们将得到以下结果。

Example1

一次读取文件的所有内容

在 Rexx 中，可以使用 while 语句读取文件的全部内容。while 语句将一行一行地读取，直到到达文件末尾。

下面显示了如何实现此目标的示例。

/* Main program */ 
do while lines(Example.txt) > 0  
line_str = linein(Example.txt) 
say line_str 
end 

在上述程序中，需要注意以下几点：

• lines 函数读取 **Example.txt** 文件。

• while 函数用于检查 **Example.txt** 文件中是否存在更多行。

• 对于从文件中读取的每一行，**line_str** 变量都保存当前行的值。然后将其发送到控制台作为输出。

输出：运行上述程序时，我们将得到以下结果。

Example1 
Example2 
Example3 

将内容写入文件

与读取文件一样，Rexx 也能够写入文件。让我们看看用于完成此操作的函数。

lineout

此方法将一行写入文件。需要向其写入行的文件作为 lineout 语句的参数提供。

语法：

lineout(filename) 

参数：

• **文件名** - 这是需要向其写入行的文件名。

**返回值** - 此方法返回 lineout 函数的状态。如果成功写入行，则返回的值为 0；否则，将返回 1。

示例：

/* Main program */ 
out = lineout(Example.txt,"Example4") 

**输出** - 每次运行上述代码时，都会将“Example4”写入 **Example.txt** 文件。

Rexx - 文件函数

在本章中，我们将讨论其他一些可用于文件的函数。

Rexx - 子程序

在任何编程语言中，整个程序都分解成逻辑模块。这使得编写易于维护的代码更加容易。这是任何编程语言的基本要求。

在 Rexx 中，可以使用子程序和函数编写模块。让我们详细了解子程序。

定义子程序

函数声明的语法如下：

FunctionName: 
   Statement#1 
   Statement#2 
   …. 
   Statement#N

其中：

• **函数名** - 这是分配给子程序的名称。

• **语句#1 .. 语句#N** - 这些是构成子程序的语句列表。

下面的程序是一个简单的示例，显示了子程序的使用。

/* Main program */ 
call add 
exit 
add: 
a = 5 
b = 10 
c = a + b 
say c 

关于上述程序，需要注意以下几点：

• 我们正在定义一个名为 **add** 的子程序。

• 该子程序执行简单的加法功能。

• 必须使用 exit 语句来表示主程序的结束。

上述程序的输出将如下所示：

15

使用参数

也可以在 Rexx 中使用参数。以下示例显示了如何实现此目标。

/* Main program */ 
call add 1,2 
exit 
add: 
PARSE ARG a,b 
c = a + b 
say c

关于上述程序，需要注意以下几点：

• 我们正在定义一个名为 add 的子程序，它接受 2 个参数。

• 在子程序中，使用 PARSE 和 ARG 关键字解析 2 个参数。

上述程序的输出将如下所示：

3

参数的不同方法

让我们看看其他一些可用于参数的方法。

arg

此方法用于返回为子程序定义的参数数量。

语法：

arg() 

参数：无

**返回值** - 此方法返回为子程序定义的参数数量。

示例：

/* Main program */ 
call add 1,2 
exit 
add: 
PARSE ARG a,b 

say arg() 
c = a + b 
say c 

运行上述程序后，我们将得到以下结果。

2 
3 

arg(index)

此方法用于返回特定位置的参数值。

语法：

arg(index)

参数

• 索引：要返回的参数的索引位置。

返回值：此方法返回特定位置的参数值。

示例：

/* Main program */ 
call add 1,2 
exit 
add: 
PARSE ARG a,b 

say arg(1) 
c = a + b 
say c 

运行上述程序后，我们将得到以下结果。

1 
3 

Rexx - 内置函数

每种编程语言都有一些内置函数，可以帮助程序员完成一些例行任务。Rexx 也具有许多内置函数。

让我们看看 Rexx 中所有这些可用的函数。

Rexx - 系统命令

Rexx 的最大优点之一是能够创建可重用的脚本。如今，在组织中，拥有可重用的脚本对于节省执行常见重复性任务的时间具有很大的附加值。

例如，IT 组织中的技术团队可能需要拥有执行日常常见任务的脚本。这些任务可能包括与操作系统的交互。然后可以对这些脚本进行编程以处理错误的返回代码或错误。

Rexx 提供了许多系统命令，可用于执行此类重复性任务。让我们看看 Rexx 中提供的一些系统命令。

dir

这是 Windows 中使用的普通目录列表命令。

语法

dir

参数

无

返回值

此方法返回系统上的当前目录列表。

示例

/* Main program */ 
dir 

输出取决于系统中的目录。

下面的程序只是一个例子。

输出

Volume in drive D is LENOVO 
Volume Serial Number is BAC9-9E3F  
Directory of D:\ 
04/06/2016  12:52 AM           268,205 100008676689.pdf 
10/20/2015  08:51 PM    <DIR>          data 
06/01/2016  10:23 AM                31 Example.txt 
10/28/2014  06:55 PM    <DIR>          Intel 
06/02/2016  11:15 AM                23 main.rexx 
12/22/2014  08:49 AM    <DIR>          PerfLogs  
12/13/2015  11:45 PM    <DIR>          Program Files 
12/24/2015  10:26 AM    <DIR>          Program Files (x86) 
07/17/2015  01:21 AM    <DIR>          Users 
12/23/2015  10:01 AM    <DIR>          Windows 
               3 File(s)        268,259 bytes 
               7 Dir(s)     202,567,680 bytes free 

以下程序显示了 **dir 命令** 的另一个示例。只是这一次我们使用了 **特殊的 rc 变量**。此变量在 Rexx 中是特殊的，它为您提供系统命令执行的状态。如果返回的值为 0，则表示命令已成功执行。否则，错误号将显示在 rc 变量名中。

示例

/* Main program */ 
dir 
if rc = 0 then 
   say 'The command executed successfully' 
else 
   say 'The command failed, The error code is =' rc 

运行上述程序后，我们将得到以下结果。

输出

The command failed, The error code is = 127 

重定向命令

Rexx 还具有使用重定向命令的功能。Rexx 中提供了以下重定向命令。

• **<** - 此命令用于接收来自文件的输入。

• **>** - 此命令用于将内容输出到文件。如果文件存在，它将被覆盖。

• **>>** - 这也用于将内容输出到文件。但是输出被添加到文件的末尾以保留文件的现有内容。

让我们来看一个如何使用重定向命令的示例。在下面的示例中，我们使用 sort 命令对名为 **sortin.txt** 的文件进行排序。文件中的数据被发送到 sort 命令。然后将 sort 命令的输出发送到 sortout.txt 文件。

示例

/* Main program */ 
'sort <sortin.txt> sortout.txt' 

假设 sortin.txt 文件包含以下数据。

输出

b 
c 
a

然后 sortout.txt 文件将包含以下数据。

a 
b 
c 

ADDRESS 函数

此方法用于找出用于输入、错误和输出流的默认环境是什么。

语法

ADDRESS(options) 

参数

• 特定系统的地址选项。

返回值

此方法返回输入、错误和输出流的环境名称。

示例

/* Main program */ 
say ADDRESS('I') 
say ADDRESS('O') 
say ADDRESS('E')

运行上述程序后，我们将得到以下结果。

输出

INPUT NORMAL 
REPLACE NORMAL 
REPLACE NORMAL

Rexx - XML

XML 是一种可移植的开源语言，允许程序员开发其他应用程序可以读取的应用程序，而不管操作系统和/或开发语言如何。这是用于在应用程序之间交换数据的最常见语言之一。

什么是 XML？

可扩展标记语言 XML 是一种标记语言，类似于 HTML 或 SGML。它由万维网联盟 (World Wide Web Consortium) 推荐，并作为开放标准提供。XML 非常适合跟踪少量到中等数量的数据，而无需 SQL 数据库的支持。

对于我们所有的 XML 代码示例，让我们使用以下简单的 XML 文件 **movies.xml** 来构建 XML 文件并随后读取该文件。

<collection shelf = "New Arrivals"> 
   <movie title = "Enemy Behind"> 
      <type>War, Thriller</type> 
      <format>DVD</format> 
      <year>2003</year> 
      <rating>PG</rating> 
      <stars>10</stars> 
      <description>Talk about a US-Japan war</description> 
   </movie> 
   
   <movie title = "Transformers"> 
      <type>Anime, Science Fiction</type> 
      <format>DVD</format> 
      <year>1989</year> 
      <rating>R</rating> 
      <stars>8</stars> 
      <description>A schientific fiction</description> 
   </movie> 
   
   <movie title = "Trigun"> 
      <type>Anime, Action</type> 
      <format>DVD</format> 
      <year>1986</year> 
      <rating>PG</rating> 
      <stars>10</stars> 
      <description>Vash the Stam pede!</description> 
   </movie> 
   
   <movie title = "Ishtar"> 
      <type>Comedy</type> 
      <format>VHS</format> 
      <year>1987</year> 
      <rating>PG</rating> 
      <stars>2</stars> 
      <description>Viewable boredom </description> 
   </movie> 
</collection>

入门

默认情况下，Rexx 解释器中不包含 xml 功能。为了在 Rexx 中使用 XML，需要遵循以下步骤。

• 下载以下文件：

  • Rexxxml − www.interlog.com/~ptjm/

  • Libxml2 − www.ctindustries.net/libxml/

  • iconv-1.9.2.win32 − www.xmlsoft.org/sources/win32/oldreleases/

  • libxslt-1.1.26.win32 − www.xmlsoft.org/sources/win32/oldreleases/

• 解压所有文件，并确保它们包含在系统路径中。

加载 XML 函数

一旦下载并成功注册了上一节中的所有文件，下一步就是编写代码来加载 Rexx XML 函数。这可以通过以下代码完成。

rcc = rxfuncadd('XMLLoadFuncs', 'rexxxml', 'xmlloadfuncs') 

if rcc then do 
   say rxfuncerrmsg() 
   exit 1 
end 
call xmlloadfuncs

关于上述程序，需要注意以下几点：

• 函数 **rxfuncadd** 用于加载外部库。**xmlloadfuncs** 函数用于将 **rexxxml** 文件中的所有库加载到内存中。

• 如果 rcc<>0，则会发生错误。为此，我们可以调用 **rxfuncerrmsg** 来获取有关错误消息的更多详细信息。

• 我们最终调用 **xmlloadfuncs**，以便现在可以在 Rexx 程序中启用所有与 xml 相关的功能。

让我们看看在 **Rexx 中可用的各种 XML 方法**。

xmlVersion

此方法返回系统上使用的 XML 和 XSLT 库的版本。

语法

xmlVersion()

参数

无

返回值

此方法返回系统上使用的 XML 和 XSLT 库的版本。

示例

rcc = rxfuncadd('XMLLoadFuncs', 'rexxxml', 'xmlloadfuncs') 

if rcc then do 
   say rxfuncerrmsg() 
   exit 1 
end 
call xmlloadfuncs 
say xmlVersion() 

运行上述程序后，我们将得到以下结果。这再次取决于系统上使用的 XML 库的版本。

输出

1.0.0 20631 10126 

xmlParseXML

此函数用于解析发送到函数的 XML 数据。文档树由函数返回。

语法

xmlParseXML(filename) 

参数

• **文件名** - 这是需要解析的 XML 文件的名称。

返回值

函数返回文档树。否则，如果发生错误，则返回 0。

示例

rcc = rxfuncadd('XMLLoadFuncs', 'rexxxml', 'xmlloadfuncs') 

if rcc then do 
   say rxfuncerrmsg() 
   exit 1 
end 
call xmlloadfuncs 

say xmlVersion() 
sw = xmlParseXML('test.xml') 

输出

无一般输出。

xmlFindNode

此方法评估传递给它的 **XPath 表达式**。这用于解析文档树以生成可以进一步处理的 **节点集**。

语法

xmlParseXML(XPath,document) 

参数

• **XPath** - 这是 xml 文件中节点的路径。

• **文档** - 这是 XML 文档

返回值

评估 XPath 表达式并将结果作为节点集返回，以便稍后使用。

示例

rcc = rxfuncadd('XMLLoadFuncs', 'rexxxml', 'xmlloadfuncs') 

if rcc then do 
   say rxfuncerrmsg() 
   exit 1 
end 
call xmlloadfuncs

say xmlVersion() 
document = xmlParseXML('test.xml') 
nodeset = xmlFindNode('//movie', document) 
say xmlNodesetCount(nodeset)

运行上述程序后，我们将得到以下结果。

输出

4

输出显示了我们的 xml 列表中电影节点的数量

xmlEvalExpression

以下方法用于评估 XPath 表达式并返回字符串作为结果。

语法

xmlParseXML(XPath,Node) 

参数

• **XPath** - 这是 xml 文件中节点的路径。

• **文档** - 特定的节点元素。

返回值

根据发送给它的 XPath 表达式返回一个字符串。

示例

rcc = rxfuncadd('XMLLoadFuncs', 'rexxxml', 'xmlloadfuncs') 

if rcc then do 
   say rxfuncerrmsg() 
   exit 1 
end 
call xmlloadfuncs 

document = xmlParseXML('test.xml') 
nodeset = xmlFindNode('//movie', document) 
do j = 1 to xmlNodesetCount(nodeset) 
value = xmlEvalExpression('type', xmlNodesetItem(nodeset, j)) 
say value 
end

运行上述程序后，我们将得到以下结果。

输出

War, Thriller 
Anime, Science Fiction 
Anime, Action 
Comedy 

Rexx - Regina

Regina 是另一个可用于编译和运行 Rexx 程序的 Rexx 解释器。Regina 的官方网站是：www.regina-rexx.sourceforge.net/

使用 Regina 的一些优点如下：

• Regina 可以在任何平台上运行，无论是 Windows、Linux 还是 Mac OS。

• Regina 符合所有可用标准。

• Regina 拥有庞大的社区支持，因此有很多论坛和学习资料可用于 Regina。

• Regina 提供了许多用于编写和测试 Rexx 程序的工具。

• 在 Regina 中，您可以运行在默认 Rexx 解释器中不可能运行的命令。例如，如果您包含某些配置设置，您实际上可以运行基本的系统级命令，这在 Rexx 中是不可能的。

当您通过 **第 2 章 – Rexx 环境** 中记录的安装方法安装 Rexx 时，Regina 解释器也会随之安装。

现在让我们看看使用 Regina 时可用的某些常用方法。这些函数是通过正常使用不可用的扩展函数。

要使用扩展函数，您需要包含以下代码行。这将启用 Regina 扩展函数的使用。

options arexx_bifs 

其次，在运行所有 Rexx 程序时，使用以下命令。

regina main.rexx 

其中：

• **regina** - 这是用于 Rexx 程序的解释器。

• **main.rexx** - 您的 Rexx 程序。

我们现在将详细讨论 **Regina Rexx 解释器的各种函数**。

Rexx - 解析

Rexx 最强大的功能之一是它能够解析文本值。您可能在任何其他编程语言中都看不到这一点。

parse 语句的一般格式如下：

语法

PARSE {UPPER|LOWER|CASELESS} source {template} 

其中：

• **UPPER** - 在解析之前，源代码将转换为大写。

• **LOWER** - 在解析之前，源代码将转换为小写。

• **CASELESS** - 传递此参数时，将忽略大小写。

• **源** - 这是需要解析的源。为此提供了许多选项，并且可以是以下任何一种：

  • **ARG** - 程序或过程的参数可以用作源。

  • **LINEIN** - 下一行输入可以用作源。

  • **SOURCE** - 程序的源信息可以用作源。

  • **VAR name** - 变量名的值可以用作源。

• **模板** - 此参数指定如何解析源。为此提供了许多选项。下面提到其中一些。

  • **变量名** - 分配给变量的值。

  • **字面字符串** - 可用作分割字符串的模式的字面字符串。

  • **#** - 源本身内的绝对字符位置。因此，如果您指定值为 5，则将使用第 5 个字符。

  • **+#** - 源本身内的相对字符位置。因此，如果您指定值为 5，则将相对使用第 5 个字符。

让我们来看一个如何在 Rexx 中完成解析的简单示例。

示例

/* Main program */ 
parse value 'This is a Tutorial' with word1 word2 word3 word4 
say "'"word1"'" 
say "'"word2"'" 
say "'"word3"'" 
say "'"word4"'" 

上述程序解析短语中的单词。当一个值由仅用一个空格分隔的单词组成，并且没有前导或尾随空格时，该值很容易解析为已知数量的单词，如下所示。

parse 函数用于在 Rexx 中获取字符串值，然后将其分解为单词。在上面的示例中，单词随后被拆分并存储在单词变量中。

上述程序的输出将如下所示：

'This' 
'is' 
'a' 
'Tutorial' 

以下程序显示了另一个解析示例。这次我们使用 while 子句来进行解析。

示例

/* Main program */ 
phrase = 'This is a Tutorial' 

do while phrase <> '' 
   parse var phrase word phrase 
   say "'"word"'" 
   end 

上述程序将给出以下输出：

'This' 
'is' 
'a' 
'Tutorial' 

位置解析

Rexx 还允许使用位置解析。让我们来看一个如何使用 parse 语句实现位置解析的示例。

示例

/* Main program */ 
testString = "Doe       John M.   03/03/78  Mumbai              India"; 
parse var testString name1 11 name2 21 birthday 31 town 51 country 
say name1 
say name2 
say birthday 
say town 
say country

从上面的示例中，您可以注意到，除了变量名之外，我们还指定了字符串应该结束的位置。因此，对于 name1，我们应该以第 11 个字符结束，然后开始解析 name2。

上述程序的输出如下：

Doe 
John M. 
03/03/78 
Mumbai 
India

在这种情况下，您还可以使用 **相对位置解析**。

示例

/* Main program */ 
testString = "Doe       John M.   03/03/78  Mumbai              India"; 
parse var testString name1 +10 name2 +10 birthday +10 town +20 country 
say name1 
say name2 
say birthday 
say town 
say country

上述程序的输出将如下所示。

Doe 
John M. 
03/03/78 
Mumbai 
India 

Rexx - 信号

在 Rexx 中，signal 指令通常用于两种目的：

• 一种是将控制转移到程序的另一部分。这通常类似于其他编程语言中使用的 go-to 标签。

• 另一种是转到特定的 trap 标签。

如果在以下任何指令命令中使用 signal 命令，则挂起的控制结构将自动停用。

• if ... then ... else ...

• do ... end

• do i = 1 to n ... end [以及类似的 do 循环]

• select when ... then ... ...etc. otherwise ... end

signal 语句的一般语法如下所示：

语法

signal labelName  
   
signal [ VALUE ] labelExpression 

让我们来看一个如何使用 signal 语句的示例。

示例

/* Main program */ 
n = 100.45 

if \ datatype( n, wholenumber ) then 
   signal msg 
   say 'This is a whole number' 
   return 0 
msg : 
   say 'This is an incorrect number'

上述程序的输出将如下所示。

输出

This is an incorrect number.

如果您将变量 n 的值更改为如下程序所示的整数：

/* Main program */ 
n = 100 

if \ datatype( n, wholenumber ) then 
   signal msg 
   say ' This is a whole number ' 
   return 0 
msg : 
   say ' This is an incorrect number ' 

您将获得以下输出：

This is a whole number

也可以像以下程序所示那样转移到标签的值：

/* Main program */ 
n = 1 

if \ datatype( n, wholenumber ) then 
   signal msg 

if n < 1 | n > 3 then 
   signal msg  
   signal value n 
   3 : say 'This is the number 3' 
   2 : say ' This is the number 2' 
   1 : say ' This is the number 1' 
   return n 
msg : 
   say ' This is an incorrect number ' 
   exit 99 

上述程序的输出将显示如下：

This is the number 1

Trap 标签转移激活/停用

如前所述，signal 指令也可用于将控制转移到 trap 标签。

Trap 标签转移的一般语法如下：

语法

signal ON conditionName [ NAME Label ] 
  
signal OFF conditionName

其中：

• **conditionName** - 这是应该打开或关闭信号的条件。

• **标签** - 程序应转移到的可选标签。

让我们来看一个使用 trap 标签转移的示例。

示例

/* Main program */ 
signal on error 
signal on failure 
signal on syntax 
signal on novalue 
beep(1) 
signal off error 
signal off failure 
signal off syntax 
signal off novalue 
exit 0 
error: failure: syntax: novalue: 
say 'An error has occured' 

在上面的示例中，我们首先打开错误信号。然后，我们添加一个将导致错误的语句。然后，我们使用错误 trap 标签来显示自定义错误消息。

上述程序的输出将如下所示：

An error has occurred.

Rexx - 调试

调试是任何编程语言中的重要功能。它帮助开发人员诊断错误，找到根本原因，然后相应地解决它们。在 Rexx 中，trace 实用程序用于调试。trace 指令可以通过两种方式实现，一种是批处理模式，另一种是交互模式。让我们看看如何实现这两个选项。

批处理模式下的 Trace

trace 命令用于详细显示执行的每个 Rexx 命令。

trace 语句的通用语法如下所示：

语法

trace [setting] 

其中，设置可以是以下任何选项：

• A - 追踪所有命令。

• C - 只追踪发送到操作系统的宿主命令。

• E - 只追踪发送到操作系统并导致错误的宿主命令。

• F - 只追踪发送到操作系统并导致失败的宿主命令。

• I - 提供 Rexx 命令的中级追踪。

• L - 如果你想在追踪发生时进行标记，可以使用此选项。

• N - 这是默认选项，不进行任何追踪。

让我们来看一个 trace 命令的例子。

示例

/* Main program */ 
trace A 

/* Main program */ 
n = 100.45 if datatype( n, wholenumber ) then signal msg 

say 'This is a whole number' 
return 0 

msg : 
   say ' This is an incorrect number ' 

上述程序的输出如下：

5 *-* n = 100.45 if datatype( n, wholenumber ) then signal msg
   7 *-* say 'This is a whole number
This is a whole number                                                   
   8 *-* return 0

从输出中，您可以看到程序输出中添加了额外的追踪信息。关于输出，需要注意以下几点：

• 执行语句的行号已添加到追踪输出中。

• 追踪输出中显示了每行执行的代码。

Trace 函数

也可以使用 trace 函数启用追踪。通用语法和示例如下所示。

语法

trace() 

上述函数返回当前的追踪级别。

参数

无

返回值

上述函数返回当前的追踪级别。

示例

/* Main program */ 
say trace() 

/* Main program */ 
n = 100.45 if datatype( n, wholenumber ) then signal msg 

say 'This is a whole number' 
return 0 
msg : 

say 'This is an incorrect number ' 

上述程序的输出如下。

N 
This is an incorrect number 

第一行的 N 表示追踪设置为正常。

设置追踪值

可以使用 trace 函数设置追踪级别。通用语法和示例如下所示。

语法

trace(travel_level) 

参数

• trace_level - 这与设置追踪级别可用的选项类似。

返回值

上述函数返回当前的追踪级别。

示例

/* Main program */ 
say trace() 
current_trace = trace('A') 
say current_trace 

/* Main program */ 
n = 100.45 if datatype( n, wholenumber ) then 
signal msg say 'This is a whole number' 
return 0 
msg : 
say ' This is an incorrect number ' 

上述程序的输出如下：

N 
   4 *-* say current_trace 
N 
   6 *-* n = 100.45 
   7 *-* if \ datatype( n, wholenumber ) then 
   8 *-* signal msg 
   12 *-* say 'This is an incorrect number' 
'This is an incorrect number' 

交互式追踪

交互式追踪是指在程序运行时进行追踪。就像在 Visual Studio for .Net 等 IDE 中，您可以添加断点并查看每条语句的执行情况一样，在这里您也可以在每行代码运行时查看程序。

通用语法如下：

语法

trace ?options 

其中，选项与 trace 命令的选项相同，如下所示。

• A - 追踪所有命令

• C - 只追踪发送到操作系统的宿主命令。

• E - 只追踪发送到操作系统并导致错误的宿主命令。

• F - 只追踪发送到操作系统并导致失败的宿主命令。

• I - 提供 Rexx 命令的中级追踪。

• L - 如果你想在追踪发生时进行标记，可以使用此选项。

• N - 这是默认选项，不进行任何追踪。

让我们来看一个实现主动追踪的例子。

示例

/* Main program */ 
trace ?A

/* Main program */ 
n = 100.45 if datatype( n, wholenumber ) then 
signal msg 

say 'This is a whole number' 
return 0 
msg : say 'This is an incorrect number' 

上述程序的输出将如下所示。追踪将在每一行代码处停止；然后，您需要按 Enter 键才能移动到下一行代码。

This is an incorrect number
       +++ "LINUX COMMAND /home/cg/root/5798511/main.rex"
     5 *-* n = 100.45 if datatype( n, wholenumber ) then 
+++ Interactive trace. "Trace Off" to end debug, ENTER to Continue. +++
     6 *-* signal msg 
    10 *-* msg :
    10 *-* say 'This is an incorrect number'

Rexx - 错误处理

Rexx 也像其他编程语言一样能够处理错误。

以下是 Rexx 中的一些常见错误条件。

• ERROR - 每当发送到操作系统的命令导致错误时，都会引发此事件。

• FAILURE - 每当发送到操作系统的命令导致失败时，都会引发此事件。

• HALT - 通常在某个操作依赖于另一个操作时引发。例如，如果 I/O 操作由于任何原因被中断。

• NOVALUE - 当变量未赋值时，会引发此事件。

• NOTREADY - 任何未准备好接受任何操作的 I/O 设备都会引发此事件。

• SYNTAX - 如果代码中存在任何语法错误，则会引发此事件。

• LOSTDIGITS - 当算术运算导致运算过程中数字丢失时，会引发此事件。

捕获错误

可以使用 signal 命令捕获错误。让我们来看一下语法和一个示例。

语法

signal on [Errorcondition]

其中：

• Errorcondition - 这是上面给出的错误条件。

示例

让我们来看一个关于这方面的例子。

/* Main program */ 
signal on error 
signal on failure 
signal on syntax 
signal on novalue beep(1) 
signal off error 
signal off failure
signal off syntax 
signal off novalue 
exit 0 
error: failure: syntax: novalue: 
say 'An error has occured'

在上面的示例中，我们首先打开错误信号。然后，我们添加一个将导致错误的语句。然后，我们使用错误 trap 标签来显示自定义错误消息。

上述程序的输出将如下所示。

An error has occurred.

以下程序显示了一个错误代码示例。

/* Main program */ 
signal on error 
signal on failure 
signal on syntax 
signal on novalue beep(1) 
exit 0 
error: failure: syntax: novalue: 

say 'An error has occured' 
say rc 
say sigl 

上述程序的输出将如下所示。

An error has occured 
40 
6

Rexx - 面向对象

根据环境章节安装 ooRexx 后，您还可以使用类和对象。请注意，以下所有代码都需要在 ooRexx 解释器中运行。普通的 Rexx 解释器将无法运行此面向对象的代码。

类和方法声明

类使用以下语法声明定义。

语法

::class classname 

其中 classname 是赋予类的名称。

类中的方法使用以下语法声明定义。

语法

::method methodname 

其中 methodname 是赋予方法的名称。

类中的属性使用以下语法声明定义。

语法

::attribute propertyname 

其中 propertyname 是赋予属性的名称。

示例

以下是一个 Rexx 类示例。

::class student 
::attribute StudentID 
::attribute StudentName 

关于上述程序，需要注意以下几点：

• 类的名称是 student。
• 该类具有 2 个属性，StudentID 和 StudentName。

Getter 和 Setter 方法

Getter 和 Setter 方法用于自动设置和获取属性的值。在 Rexx 中，当使用 attribute 关键字声明属性时，Getter 和 Setter 方法已就位。

示例

::class student 
::attribute StudentID 
::attribute StudentName 

在上面的示例中，将会有 StudentId 和 StudentName 的 Getter 和 Setter 方法。

以下程序显示了如何使用它们。

/* Main program */ 
value = .student~new 
value~StudentID = 1 
value~StudentName = 'Joe' 
say value~StudentID 
say value~StudentName 

exit 0 
::class student 
::attribute StudentID 
::attribute StudentName 

上述程序的输出将如下所示。

1 
Joe 

实例方法

可以使用 ~new 运算符从类创建对象。可以按以下方式调用类中的方法。

Object~methodname 

其中 methodname 是需要从类中调用的方法。

示例

以下示例显示了如何从类创建对象以及如何调用相应的方法。

/* Main program */ 
value = .student~new 
value~StudentID = 1 
value~StudentName = 'Joe' 
value~Marks1 = 10 
value~Marks2 = 20 
value~Marks3 = 30 
total = value~Total(value~Marks1,value~Marks2,value~Marks3) 
say total 

exit 0 
::class student 
::attribute StudentID 
::attribute StudentName 
::attribute Marks1 
::attribute Marks2 
::attribute Marks3 
::method 'Total' 
use arg a,b,c 
return (ABS(a) + ABS(b) + ABS(c)) 

上述程序的输出将如下所示。

60 

创建多个对象

也可以创建类的多个对象。以下示例将演示如何实现此目的。

在这里，我们创建了 3 个对象（st、st1 和 st2），并相应地调用它们的实例成员和实例方法。

让我们来看一个如何创建多个对象的例子。

示例

/* Main program */ 
st = .student~new 
st~StudentID = 1 
st~StudentName = 'Joe' 
st~Marks1 = 10 
st~Marks2 = 20 
st~Marks3 = 30 
total = st~Total(st~Marks1,st~Marks2,st~Marks3) 
say total  

st1  =  .student~new 
st1~StudentID = 2 
st1~StudentName = 'John' 
st1~Marks1 = 10 
st1~Marks2 = 20 
st1~Marks3 = 40 
total = st1~Total(st1~Marks1,st1~Marks2,st1~Marks3) 
say total  

st2  =  .student~new 
st2~StudentID = 3 
st2~StudentName = 'Mark' 
st2~Marks1 = 10 
st2~Marks2 = 20 
st2~Marks3 = 30 
total = st2~Total(st2~Marks1,st2~Marks2,st2~Marks3) 
say total  

exit 0 
::class student 
::attribute StudentID 
::attribute StudentName 
::attribute Marks1 
::attribute Marks2 
::attribute Marks3 
::method 'Total' 
use arg a,b,c 
return (ABS(a) + ABS(b) + ABS(c)) 

上述程序的输出将如下所示。

60 
70 
60 

继承

继承可以定义为一个类获取另一个类的属性（方法和字段）的过程。通过使用继承，信息以分层的方式进行管理。

继承其他属性的类称为子类（派生类、子类），其属性被继承的类称为超类（基类、父类）。

让我们来看一个 Rexx 中继承的例子。在下面的例子中，我们创建一个名为Person的类。然后我们使用子类关键字创建一个Student 类作为Person 的子类。

示例

/* Main program */ 
st = .student~new 
st~StudentID = 1 
st~StudentName = 'Joe' 
st~Marks1 = 10 
st~Marks2 = 20 
st~Marks3 = 30 
say st~Total(st~Marks1,st~Marks2,st~Marks3)  

exit 0 
::class Person 
::class student subclass Person 
::attribute StudentID 
::attribute StudentName 
::attribute Marks1 
::attribute Marks2 
::attribute Marks3 
::method 'Total' 
use arg a,b,c 
return (ABS(a) + ABS(b) + ABS(c)) 

上述程序的输出将如下所示。

60

Rexx - 可移植性

可移植性是任何编程语言中的一个重要方面。众所周知，Rexx 可用于各种操作系统，例如 Windows 和 Linux。因此，需要确保当在 Windows 平台上开发程序时，如果相同的程序在 Linux 平台上运行，则已采取必要的预防措施。

Rexx 能够运行系统级命令。有一些命令可用于了解其正在运行的操作系统。根据输出，它可以采取适当的操作来查看可以在此操作系统上运行哪些命令。

示例

以下示例显示了如何使用 parse 函数获取程序正在运行的操作系统的详细信息。

/* Main program */ 
parse version language level date month year. 
parse source system invocation filename. 
language = translate(language) 

if pos('REGINA',language) = 0 then 
   say 'Error , the default interpreter is not Regina' language 
   say 'The Interpreter version/release date is:' date month year 
   say 'The Language level is: ' level say 'The Operating System is'  

   select 
when system = 'WIN32' then 
   'ver'
when system = 'UNIX' | system = 'LINUX' then 
   'uname -a' 
   otherwise 
   say 'Unknown System:' system 
end 
if rc <> 0 then 
   say 'Error :' rc 

输出将根据操作系统而有所不同。下面给出一个示例输出。

The Interpreter version/release date: 5 Apr 2015 
The Language level is:  5.00 
The Operating System is 
Unknown System: WIN64 
Bad return code: RC 

Rexx - 扩展函数

Rexx 提供了许多扩展函数，这些函数提供了广泛的功能，其中大部分函数允许您与操作系统交互。让我们详细了解一下它们，如下所述。

Rexx - 指令

Rexx 提供了许多指令，这些指令提供了广泛的功能，其中大部分函数允许您与操作系统交互。让我们详细了解一下它们。

Rexx - 实现

正如我们在前几章中已经看到的，Rexx 语言有很多不同的实现。每种实现都有其自身的功能。让我们来看一下 Rexx 可用的各种实现。

OoRexx

这是 Rexx 的面向对象版本。默认情况下，Rexx 基本实现都是基于过程的。但是使用 ooRexx，您可以通过采用面向对象的方法来处理 Rexx 来提供更大的灵活性。通过使用 ooRexx，您可以通过创建可重用的类和对象来更好地重用。

以下程序是一个简单的 Rexx 程序示例，可以使用 ooRexx 实现器运行。

示例

/* Main program */ 
say ‘hello’ 

要运行此程序，请运行以下命令。

rexx main.rexx 

运行上述命令后，您将获得以下输出。

hello

Netrexx

这是为所有基于 Java 的开发人员提供的，因为它为 Rexx 语言提供了一个基于 Java 的替代方案。因此，所有对象都基于 Java 对象模型。此框架的优势在于，由于 Java 是一种非常流行的语言，因此开发人员更容易使用此框架。因此，在此实现中，Rexx 代码被转换为 Java 程序，然后可以在任何 Java 虚拟机上运行。

以下代码是一个 NetRexx 程序示例。

创建一个名为main.nrx的文件，并将以下代码放入文件中。

/* Main program */ 
say ‘hello’

要编译代码，请运行以下命令：

NetRexxC main.nrx 

然后您将获得以下输出。NetRexxC 是将 Rexx 程序转换为其 Java 等价物的编译器。

java -cp ";;G:\NetRexx-3.04GA\lib\NetRexxF.jar;." 
-Dnrx.compiler = ecj org.netrexx.process.NetRexxC  main.nrx 
NetRexx portable processor 3.04 GA build 4-20150630-1657 
Copyright (c) RexxLA, 2011,2015.   All rights reserved. 
Parts Copyright (c) IBM Corporation, 1995,2008. 
Program main.nrx 
Compilation of 'main.nrx' successful

您现在可以使用以下 Java 命令运行您的 Java 程序。

java main 

运行上述命令后，您将获得以下输出。

Hello

Brexx

这是 Rexx 的轻量级实现。这是一个比标准 Rexx 实现器更轻量级的包。但它仍然具有 Rexx 的全部功能。

以下代码是一个 BRexx 程序示例。

/* Main program */ 
say ‘hello’

要运行程序，请运行以下命令。

rexx32 main.rexx

运行上述命令后，您将获得以下输出。

hello

Rexx - Netrexx

NetRexx 是 Rexx 的 Java 实现。在 NetRexx 中，实现器用于将 Rexx 程序转换为 Java 程序，然后可以在任何 Java 虚拟机上运行。

设置 NetRexx

NetRexx 的第一步是在本地机器上进行设置。为此，需要执行以下步骤：

步骤 1 − 前往 NetRexx 下载网站 − http://www.netrexx.org/downloads.nsp

下载 NetRexx.3.04.GA 文件。

步骤 2 − 确保已安装 Java 并正在您的系统上运行。您可以使用 java -version 命令验证 Java 是否正在运行。

下面显示了输出示例。

H:\>java -version 
java version "1.7.0_79" 
Java(TM) SE Runtime Environment (build 1.7.0_79-b15) 
Java HotSpot(TM) Client VM (build 24.79-b02, mixed mode, sharing) 

步骤 3 − 解压缩 NetRexx 压缩文件的内容。将文件从 NetRexx3.04GA\lib 文件夹复制到您的 Java 安装/lib/etc 文件夹。

步骤 4 − 将 NetRexx-3.04GA\bin 路径添加到系统的 PATH 环境变量中。

运行第一个 NetRexx 程序

创建一个名为main.nrx的文件，并将以下代码放入文件中。

/* Main program */ 
say ‘hello’ 

要编译代码，请运行以下命令。

NetRexxC main.nrx 

然后您将获得以下输出。NetRexxC 是将 Rexx 程序转换为其 Java 等效程序的编译器。

java -cp ";;G:\NetRexx-3.04GA\lib\NetRexxF.jar;." 
-Dnrx.compiler = ecj org.netrexx.process.NetRexxC  main.nrx 
NetRexx portable processor 3.04 GA build 4-20150630-1657 
Copyright (c) RexxLA, 2011,2015.   All rights reserved. 
Parts Copyright (c) IBM Corporation, 1995,2008. 
Program main.nrx 
Compilation of 'main.nrx' successful

您现在可以使用以下 Java 命令运行您的 Java 程序。

java main 

运行上述命令后，您将获得以下输出。

Hello

现在让我们讨论一下NetRexx 库的一些特殊方面。

索引字符串

在 NetRexx 中，字符串可以成为数组的索引。下面显示了一个示例。

示例

/* Main program */ 
value = 'unknown' 
value['a'] = 'b' 
c = 'a' 
say value[c] 

运行上述程序时，我们将得到以下结果。

输出

b

多个索引

在 NetRexx 中，数组可以具有多个索引。下面显示了一个示例。

示例

/* Main program */ 
value = 'null' 
value['a', 'b'] = 1 
say value['a', 'b']

运行上述程序后，我们将得到以下结果。

输出

1

Rexx - Brexx

BRexx 是 Rexx 的轻量级实现。它仍然可以作为 Rexx 实现的一部分提供许多功能。

设置 BRexx

BRexx 的第一步是在本地机器上进行设置。为此，需要执行以下步骤：

步骤 1 − 前往 BRexx 下载网站 − https://ftp.gwdg.de/pub/languages/rexx/brexx/html/rx.html

转到下载部分并下载产品。

步骤 2 − 解压缩 Brexx 压缩文件的内容。

步骤 3 − 将 BRexx\bin 路径添加到系统的 PATH 环境变量中。

步骤 4 − 创建一个名为 RXLIB 的新环境变量，并将其指向 Brexx 文件夹中的 lib 文件夹。

运行第一个 BRexx 程序

创建一个名为main.rexx的文件，并将以下代码放入该文件中。

/* Main program */ 
say ‘hello’ 

要运行程序，请运行以下命令。

rexx32 main.rexx 

运行上述命令后，您将获得以下输出。

hello

现在让我们讨论一下 BRexx 库中一些最常用的函数。

Rexx - 数据库

Rexx 能够与各种数据库一起工作，如下所示。

• HSQLDB
• Oracle
• SQL Server
• MySQL
• MongoDB

单击以下链接后，即可找到 Rexx 数据库的所有信息：https://rexxsql.sourceforge.net/

在我们的示例中，我们将使用 MySQL DB 作为示例。因此，第一步是确保从 Rexx SQL 网站下载所需的驱动程序，以便 Rexx 程序可以相应地与 SQL 一起工作。因此，请按照后续步骤确保 Rexx 程序可以与 MySQL 数据库一起工作。

步骤 1 − 从 Rexx 网站访问以下驱动程序下载页面：https://sourceforge.net/projects/rexxsql/files/rexxsql/2.6/

步骤 2 − 下载 MYSQL 驱动程序 - rxsql26B3_my_w32_ooRexx

步骤 3 − 将内容解压缩到本地计算机。

步骤 4 − 将解压缩文件夹的路径添加到计算机的 PATH 环境变量中。

对于所有后续示例，请确保以下要点已到位：

• 您已创建数据库 TESTDB。

• 您已在 TESTDB 中创建表 EMPLOYEE。

• 此表包含字段 FIRST_NAME、LAST_NAME、AGE、SEX 和 INCOME。

• 已设置用户 ID“testuser”和密码“test123”以访问 TESTDB。

• 确保您已下载 mysql jar 文件并将其添加到您的类路径中。

• 您已学习 MySQL 教程

数据库连接

要建立数据库连接，首先需要 Rexxsql DLL，然后使用 SQLConnect 函数建立与数据库的连接。下面给出了如何实现此目的的语法和示例。

语法

SQLConnect(cname,username,password,dbname) 

参数

• cname − 这是要赋予连接的名称。

• username − 用于连接到数据库的用户名。

• password − 用于连接到数据库的密码。

• dbname − 要连接到的数据库模式。

返回值

值为 0 表示数据库连接成功。

示例

/* Main program */ 
Call RxFuncAdd 'SQLLoadFuncs', 'rexxsql', 'SQLLoadFuncs' 
Call SQLLoadFuncs 
say SQLConnect(c1,' testuser ',' test123','testdb')

上述程序的输出将如下所示。

0

创建数据库表

连接到数据库后的下一步是在数据库中创建表。以下示例显示了如何使用 Rexx 在数据库中创建表。所有 Rexx SQL 命令都是使用 SQLCommand 函数执行的。

语法

SQLConnect(sname,statement)

参数

• sname − 这是要赋予要执行的语句的名称。

• statement − 这是需要针对数据库执行的语句。

返回值

值为 0 表示命令成功。

示例

/* Main program */ 
Call RxFuncAdd 'SQLLoadFuncs', 'rexxsql', 'SQLLoadFuncs' 
Call SQLLoadFuncs 

if SQLConnect(c1,'testuser','test123','testdb') == 0 then say 'Connect Succedded' 
if SQLCommand(u1,"use testdb") == 0 then say 'Changed database to testdb' 
   sqlstr = 'create table employee (first_name char(20) not null, last_name 
   char(20),age int, sex   
   char(1), income float)' 

if SQLCommand(c2,sqlstr) == 0 then say 'Employee table created'

上述程序的输出将如下所示。

Connect Succedded 
Changed database to testdb 
Employee table created 

数据库表上的操作

以下类型的操作最常在数据库表上执行。

执行事务

事务是一种确保数据一致性的机制。事务具有以下四个属性：

• 原子性 − 事务要么完成，要么根本不会发生任何事情。

• 一致性 − 事务必须从一致状态开始，并使系统处于一致状态。

• 隔离性 − 事务的中间结果在当前事务之外不可见。

• 持久性 − 一旦事务提交，其效果就是持久的，即使在系统故障之后也是如此。

这是一个关于如何实现事务的简单示例。

示例

/* Main program */ 
Call RxFuncAdd 'SQLLoadFuncs', 'rexxsql', 'SQLLoadFuncs' 
Call SQLLoadFuncs 

if SQLConnect(c1,'testuser','test123','testdb') == 0 then say 'Connect Succedded' 
if SQLCommand(u1,"use testdb") == 0 then say 'Changed database to testdb' 
   sqlstr = "DELETE FROM EMPLOYEE WHERE AGE > 20" 

if SQLCommand(c2,sqlstr) == 0 then 
if sqlcommit() == 0 then say committed

上述程序的输出将如下所示。

Connect Succedded 
Changed database to testdb 
COMMITTED

提交操作

提交操作会告诉数据库继续进行操作并完成对数据库的所有更改。在上面的示例中，这是通过以下命令实现的。

Sqlcommit() 

回滚操作

如果您对一个或多个更改不满意，并且想要完全撤消这些更改，请使用回滚方法。在上面的示例中，这是通过以下命令实现的。

SqlRollback() 

Rexx - 手持式和嵌入式编程

手持设备已经发展了很多，Rexx 可以在这些设备上运行的方式有很多。Rexx 支持 Pocket PC、Palm 设备、PDA 和其他智能手机设备。Rexx 在这些平台上工作的优势在于 Rexx 实际上是一个非常轻量级的编程系统，仅占用几千字节的空间。因此，在这些设备上运行 Rexx 程序变得更容易。

手持设备上的 Rexx 可以以下列模式运行：

• 第一种模式是本机模式，它直接在操作系统上运行。在这种模式下运行的优势在于它速度更快，因为它直接从操作系统运行。

• 下一种模式是在手持设备上的 DOS 或模拟器程序之上。这种模式的优点是只要模拟器在该操作系统上运行，它就可以在任何类型的操作系统上运行。

下面显示了各种手持设备类别的 Rexx 解释器。

• Windows CE − Brexx
• Palm OS − Rexx for Palm OS
• Symbian OS − Regina

对于 DOS 模拟器，需要执行以下步骤：

步骤 1 − 首先下载 PocketDOS，这是一个流行的 DOS 模拟器。它设计用于在许多操作系统上运行，并支持常见的 VGA 屏幕以及串行和并行端口。

步骤 2 − 下一步是将 BRexx 文件（用于 16 位 DOS）下载到 Windows PC。

步骤 3 − 最后一步是使用 ActiveSync 将 Rexx 程序同步到手持设备。

还有一些其他可用的商业 DOS 产品。XTM 就是属于此类别的产品。该产品的特点如下：

• 支持 80186 CPU 和指令集。

• 它通过 BIOS 代码来提高性能。

• 它可以为 8087 MPU 数学协处理器进行仿真。

• 它可以访问串行端口。

• 它支持多种语言，例如英语、法语和德语。

Rexx - 性能

任何编程语言的关键方面之一是应用程序的性能。需要特别注意才能确保应用程序的性能不会受到影响。让我们按照步骤中描述的一些注意事项来更好地理解：

步骤 1 − 尝试减少指令数量 – 在 Rexx 中，每条指令都会带来一定的开销。因此，尝试减少程序中的指令数量。下面显示了一个可以重新设计的指令示例。

与其使用多个 if else 语句，不如使用 parse 语句。因此，在下面的程序中，无需为每个值设置 if 条件，并获取 word1、word2、word3 和 word4 的值，而是使用 parse 语句。

/* Main program */  

parse value 'This is a Tutorial' with word1 word2 word3 word4 
say "'"word1"'" 
say "'"word2"'" 
say "'"word3"'" 
say "'"word4"'" 

步骤 2 − 尝试将多个语句合并为一个语句。下面显示了一个示例。

假设您有以下代码，它为a 和 b赋值，并将其传递给名为proc的方法。

do i = 1 to 100 
   a = 0 
   b = 1 
   call proc a,b 
end

您可以使用 parse 语句轻松地将上面给出的代码替换为以下代码。

do i = 1 for 100 
   parse value 0 1 with 
   a, 
   b, 
   call proc a,b 
end 

步骤 3 − 尽可能用do..for 循环替换do..to 循环。当控制变量在循环中迭代时，通常建议这样做。

/* Main program */ 
do i = 1 to 10 
   say i 
end 

上面的程序应替换为以下程序。

/* Main program */ 
do i = 1 for 10 
   say i 
end

步骤 4 − 如果可能，请从 do 循环中删除 for 条件，如下面的程序所示。如果不需要控制变量，只需在 do 循环中放入结束值，如下所示。

/* Main program */ 
do 10 
   say hello 
end

步骤 5 − 在select 子句中，您认为最佳的将要评估的条件需要放在when 子句中的第一位。因此，在下面的示例中，如果我们知道 1 是最频繁的选项，我们将when 1 子句作为 select 语句中的第一个子句。

/* Main program */ 
select 
   when 1 then say'1' 
   when 2 then say'2' 
   otherwise say '3' 
end 

Rexx - 最佳编程实践

每个程序员都希望他们的程序在质量和效率方面都是最好的。以下是一些编写 Rexx 程序时的最佳编程实践或技巧，可以帮助您实现这些目标。

技巧 1

在向操作系统或命令提示符发出任何命令之前，请使用 address 命令。这将帮助您预先获得内存中的地址空间，并使您的程序运行更高效。

address 命令示例如下所示。

示例

/* Main program */ 
address system dir 

命令的输出如下所示，但它可能因系统而异。

Volume in drive H is Apps 
Volume Serial Number is 8E66-AC3D  
Directory of H:\  
06/30/2016  01:28 AM    <DIR>          Apps 
07/05/2016  03:40 AM               463 main.class 
07/07/2016  01:30 AM                46 main.nrx 
07/07/2016  01:42 AM                38 main.rexx 
3 File(s)            547 bytes 
Dir(s)  313,085,173,760 bytes free

技巧 2

确保所有对操作系统的命令都大写，并在可能的情况下用引号括起来。

同样的示例如下所示。

示例

/* Main program */ 
options arexx_bifs 
say chdir('\REXXML100') 
say directory()

运行上述程序时，我们将得到以下结果。

0 
D:\rexxxml100 

技巧 3

避免创建大型注释块，如下面的程序所示。

示例

/******/ 
/* */ 
/* */ 
/* */ 
/******/ 
/* Main program */ 
address system dir

技巧 4

使用 Parse 语句赋值默认值。同样的示例如下所示。

示例

parse value 0 1 with 
a, 
b 

技巧 5

尽可能使用“Left(var1,2)”语句代替“substr(var1,1,2)”语句。

技巧 6

尽可能使用“Right(var1,2)”语句代替“substr(var1,length(var1),2)”语句。

Rexx - 图形用户界面

为了使用 Rexx 中可用的图形用户界面，需要使用两个包，一个是ActiveTcl，另一个是Rexxtk包。结合这两个包，可以设计普通的表单，这些表单可以在表单上包含按钮和其他控件。

环境设置

首先要进行环境设置。让我们按照以下步骤来设置环境。

步骤 1 − 从以下网站下载 Activetcl 包 − https://www.activestate.com/activetcl

步骤 2 − 下一步是开始安装 ActiveTCl。点击屏幕上的“下一步”按钮继续。

步骤 3 − 接受许可协议，然后点击“下一步”按钮。

步骤 4 − 选择安装位置，然后点击“下一步”按钮。

步骤 5 − 选择演示的安装位置，然后点击“下一步”按钮。

步骤 6 − 点击“下一步”按钮继续安装。

步骤 7 − 点击“完成”按钮完成安装。

步骤 8 − 下一步是从以下链接下载 Rexxtk 软件 − https://sourceforge.net/projects/rexxtk/

步骤 9 − 双击上一步链接中的安装程序文件以启动安装。点击“下一步”按钮继续。

步骤 10 − 在下一个屏幕上，点击“是”按钮以同意许可协议。

步骤 11 − 在下一个屏幕上，选择安装位置，然后点击“下一步”按钮。

步骤 12 − 选择程序文件夹位置，然后点击“下一步”按钮。

安装完成后，我们现在可以开始在 Rexx 中编程 GUI 了。

基本程序

让我们看看如何在图形用户界面格式中使用 Rexx 设计一个简单的基本程序。

示例

/* Main program */ 
call RxFuncAdd 'TkLoadFuncs','rexxtk','TkLoadFuncs' 
call TkLoadFuncs 
do forever 
   interpret 'Call' TkWait() 
end 
call TkDropFuncs 
exit 0 

关于上述程序，需要注意以下几点：

• Rexxtk 库及其所有函数都使用 RxFuncAdd 命令加载。

• do forever 循环将保持窗口打开，并等待用户输入。

• 检测到用户输入后，程序将退出。

执行上述程序后，您将获得以下输出。

创建菜单

菜单是在 TkMenu 和 TkAdd 函数的帮助下创建的。这些函数的语法如下所示。

语法

TkMenu(widgetname,options,0) 

参数

Widgetname − 为菜单指定一个名称。

选项可以是以下任何一个 −

• selectcolor − 如果使用复选框或单选按钮作为菜单选项，则此选项指定选择任何菜单选项时要选择的颜色。

• tearoff − 此选项用于向主菜单添加子菜单。

• title − 需要用于为窗口指定标题的字符串。

返回值

创建菜单的句柄。

示例

/* Main program */ 
call RxFuncAdd 'TkLoadFuncs','rexxtk','TkLoadFuncs' 
call TkLoadFuncs 

menubar = TkMenu('.m1') 
filemenu = TkMenu('.m1.file','-tearoff', 0) 
call TkAdd menubar, 'cascade', '-label', 'File', '-menu', filemenu 
call TkAdd filemenu, 'command', '-label', 'Open...', '-rexx', 'getfile' 
call TkConfig '.', '-menu', menubar 

do forever 
   interpret 'Call' TkWait() 
end 
call TkDropFuncs 
exit 0

关于上述程序，需要注意以下几点：

• 菜单栏是使用 TkMenu 函数创建的。“tearoff”参数意味着我们需要创建将附加到主菜单的子菜单。

• 然后，我们使用 TkAdd 函数添加名为“文件”和“打开”的两个菜单选项。

执行上述程序后，您将获得以下输出。

Rexx - Reginald

Reginald 是另一个由 Jeff Glantt 开发的 Rexx 解释器，它对如何运行 Rexx 程序有一些自定义设置。在本节中，我们将了解如何设置 Reginald 并在其中运行一些 Rexx 程序。

环境设置

第一步是环境设置，即下载 Reginald 文件。这可以通过以下网站链接完成 − http://www.manmrk.net/tutorials/rexx/Reginald/win32/rxusrw32.htm

下载完成后并启动安装程序后，下一个屏幕将允许您选择安装位置。

点击“安装”按钮继续。

完成后，我们现在可以开始在 Reginald 解释器中运行一个示例程序了。创建一个简单的程序，如下所示。

/* Main program */ 
say 'Hello' 

然后运行以下命令 −

RxLaunch.exe main.rexx 

然后您将获得以下输出。此程序现在将在 Reginald 解释器中运行。

其他可用函数

除了普通的 Rexx 命令外，Reginald 还有一些专门为 Windows 操作系统定制的命令。DriveMap 就是这样的一个命令 −

DriveMap

此函数提供有关驱动器的信息。

语法：

Drivemap(,options) 

参数 −

选项 − 这些是一系列关键字，可用于获取有关本地计算机驱动器的各种信息。

返回值

包含有关驱动器信息的字符串值。

示例：

/* Main program */ 
say 'Drives on system : ' DriveMap(,'FIXED') 

如果运行上述程序，您将获得以下输出。此输出因系统而异。

List of disk drives :  C:\ D:\ 

Rexx - Web编程

Rexx 还可以与 Web 服务器一起使用。最常见的是 Apache Web 服务器。为了将 Rexxw 与 Apache Web 服务器一起使用，您需要首先从以下链接下载 Rexx 模块 − https://sourceforge.net/projects/modrexx/?source=typ_redirect

完成后，请确保将 mod Rexx 模块添加到类路径。

需要将以下行添加到 Apache 配置文件中并进行修改。

需要将以下行添加到相应的 −

• httpd.conf LoadModule 列表。
• LoadModule rexx_module modules/mod_rexx.dll

应将以下行添加到http.conf文件的末尾。

• AddType application/x-httpd-rexx-script .rex .rexx

• AddType application/x-httpd-rexx-rsp .rsp

• 添加这些以支持 REXX 服务器页面

• RexxRspCompiler “c:/Program Files/Apache Group/Apache2/bin/rspcomp.rex”

进行上述更改后，您需要关闭并重新启动 Apache Web 服务器。

以上几行还允许您拥有基于 Rexx 的服务器页面，就像 Java 服务器页面一样。您可以将 Rexx 代码直接添加到 html 页面中。

示例如下所示 −

<p>The current date and time is 
   <?rexx 
      /* Inserting the rexx statement */ 
      say date() time() 
   ?>
</p>

运行基于 Rexx 的服务器页面时，将执行以下操作 −

• 首先创建一个临时文件。

• 然后，Rexx 服务器编译器将文件编译成 Rexx 程序，并将其放在临时文件中。

• 下一步是实际运行 Rexx 程序。

最后，删除临时文件。