Использование основных элементов языка REXX

В этом разделе пользователю предоставляется возможность ознакомиться с некоторыми элементами, используемыми при написании процедур REXX. Не беспокойтесь том, что при программировании могут быть ошибки, так как в этом разделе информация излагается последовательно по шагам.

В процедурах REXX могут быть любые или все перечисленные ниже элементы:

в дальнейшем REXX) разработан как

это слово, фраза или аббревиатура,

Все процедуры REXX должны начинаться

Метки

В качестве метки может выступать любое слово, за которым следует двоеточие (между словом и двоеточием не должно быть пробелов) и которое не заключено в кавычки. Например:

MYNAME:

Метка отмечает начало подпрограммы. Ниже приведен пример использования метки error внутри процедуры:

. . . IF problem = 'yes' then SIGNAL error . . . error: SAY 'Ошибка в данных' EXIT

Написание процедур

Напишем следующую процедуру REXX с помощью текстового редактора. Чтобы написать процедуру REXX с именем HELLO.CMD, выполните следующие инструкции:

1. Создайте текстовый файл с именем HELLO.CMD.

2. Наберите текст процедуры HELLO.CMD, приведенной ниже:

/* Введение в REXX */ SAY "Привет! Я - REXX" SAY "Как Вас зовут?" PULL who IF who = "" THEN SAY "Привет, Незнакомец" ELSE SAY "Привет," who EXIT

3. Сохраните файл и выйдите из текстового редактора.

Теперь все готово для того, чтобы выполнить эту процедуру REXX. Наберите имя процедуры в командном режиме OS/2 и нажмите клавишу ENTER.

hello

Когда процедура сделает паузу, Вы можете либо ввести свое имя, либо просто нажать клавишу ENTER, чтобы увидеть второй вариант ответа.

Далее приведено краткое описание каждой части процедуры HELLO.CMD :

/* Введение в REXX */ В этом комментарии указывается, что данная процедура выполняет. Строка комментария начинается с символа /* и заканчивается символом */. Все процедуры REXX должны начинаться с комментария в первой позиции первой строки файла. Строка комментария указывает процессору команд, что процедура, которую нужно выполнить, - это процедура REXX. По этому признаку процессор команд отличает ее от обычных пакетных файлов.

SAY "Привет! Я - REXX." SAY "Как Вас зовут?" С помощью этих инструкций слова, заключенные в двойные кавычки, выводятся на экран.

PULL who С помощью инструкции PULL читается ответ, введенный с клавиатуры, и помещается в память операционной системы. Who - это имя, присвоенное области памяти, куда помещается введенный пользователем ответ. В инструкции PULL можно использовать любое имя.

IF who = " " Инструкция IF проверяет условие. В этом примере проверяется, пусто ли поле who. Оно будет пустым, если пользователь набрал пробел, а затем нажал клавишу ENTER, либо просто нажал клавишу ENTER.

THEN Определяет, что в случае истинности проверяемого условия, должна выполняться инструкция, следующая за данной.

SAY "Привет, Незнакомец" Выводит на экран слова Привет, Незнакомец.

ELSE Определяет, что в случае ложности проверяемого условия должна выполняться инструкция, следующая за данной.

SAY "Привет," who Выводит на экран слово Привет с последующим отображением содержимого поля who.

EXIT Эта инструкция прекращает выполнение процедуры.

Если пользователь с именем Сергей выполнит процедуру HELLO, то протокол его работы будет иметь следующий вид:

[C:\]hello Привет! Я - REXX. Как Вас зовут?

Сергей

Привет, Сергей

[C:\]

Если Сергей не введет свое имя, а наберет пробел, то протокол работы будет следующим:

[C:\]hello Привет! Я - REXX. Как Вас зовут?

Привет, Незнакомец

[C:\]

Операторы присваивания

Оператор присваивания сообщает системе, что цепочку символов нужно поместить в определенное поле в памяти операционной системы. Например:

Work = "Здание 021" строка Здание 021 запоминается как значение поля Work в памяти операционной системы. Так как поле Work может принимать различные значения (переопределяться по ходу выполнения) в различных частях процедуры, то его можно назвать переменной.

Приступая к работе с REXX

Процедура REXX представляет собой программу, состоящую из набора заданий, заключенных в один обрабатывающий или пакетный файл.

Для написания программ могут быть использованы многие языки программирования. BASIC, который широко используется для базовых вычислений, имеет очень ограниченный набор правил, однако при написании сложных программ требует многих строк кода. Такие языки, как PL/1, COBOL, C, APL и PASCAL имеют более обширный набор правил, но при этом позволяют в нескольких строках закодировать большее число функций.

REXX сочетает простоту такого языка программирования, как BASIC, с возможностями более мощных языков, перечисленных выше. REXX легок в изучении, так как использует знакомые слова и понятия. При этом REXX позволяет решать как простые задачи, так и более сложные комплексные проблемы.

Чтобы начать работу с языком REXX, необходимо иметь:

Персональный компьютер с инсталлированной на нем операционной системой OS/2 версии 2.0. Процедуры REXX выполняются только в сеансах OS/2. Сведения об использовании текстового редактора.

Многие изучают язык программирования, просматривая примеры, поэтому настоящий обзор сопровождается примерами процедур REXX. Сначала просмотрите процедуру, затем изучите разъяснение к примерам, чтобы понять, что содержится в процедуре. При желании можно выполнить процедуру, чтобы увидеть, как она работает.

Строки

Строка представляет собой цепочку символов, заключенных в апострофы или кавычки. Можно использовать любые из этих символов, но только парами. Когда интерпретатор команд встречает один из этих символов, он прекращает интерпретацию и последующие символы оставляет в таком виде, в каком они были набраны, включая строчные и прописные буквы. Когда интерпретатор команд опять встречает такой же символ, он возобновляет интерпретацию. Например:

'Грандиознейшее Шоу на Планете' "Президент правит своей страной"

Оба сообщения - строки.

Чтобы использовать апостроф или кавычки внутри строки, для обрамления полной строки выберите другой символ. Например:

"Don't count your chickens before they hatch." или

'Do not count your "chickens" before they hatch.'

Внутри строки можно также использовать удвоенный символ (такого же типа, как и для обрамления полной строки). Например:

SAY "Mary said ""He's here."""

Эту инструкцию REXX интерпретирует следующим образом:

Mary said "He's here."

Написание арифметических процедур REXX

Ниже дано упражнение, позволяющее повторить некоторые правила, используемые в предыдущих примерах. Вам нужно написать процедуру, выполняющую операцию сложения двух чисел. Имя процедуры - ADD.CMD.

В своей процедуре Вам придется выполнить следующие действия:

Идентифицировать и описать процедуру REXX. Предложить пользователю ввести числа. Прочитать введенные числа и поместить их в память системы. Сложить два числа и вывести результат на экран. Завершить выполнение процедуры.

Существует множество способов, позволяющих выполнить поставленную задачу. Чтобы облегчить ее выполнение в данной процедуре, предложим пользователю ввести каждое число отдельно, а затем сложим эти числа. Далее приведены размышления, которые помогут Вам при написании процедуры ADD.CMD.

Первым делом, что идентифицирует процедуру REXX? Если Вы считаете, что это комментарий, то Вы правы. Далее, нужно предложить пользователю ввести число. С помощью инструкции SAY можно вывести это предложение на экран. Когда число введено, его нужно поместить в память компьютера. Инструкция PULL получает ответ и помещает его в память. Инструкция, которая запрашивает ввод второго числа, может выглядеть подобно первой; второе число также должно быть помещено в память. Следующая инструкция похожа на инструкцию в процедуре MATH. В одном операторе языка REXX можно приказать интерпретатору сложить два значения в памяти и вывести результат на экран. Для этого используйте одну инструкцию, которая содержит строку и операцию сложения. В заключение, для завершения выполнения процедуры используйте инструкцию EXIT. Если Вы хотите проверить работу этой процедуры, то наберите и сохраните текст, приведенный ниже.

/* Эта процедура складывает два числа */ SAY "Введите первое число." PULL num1 SAY "Введите второе число." PULL num2 SAY "Сумма двух чисел равна" num1 + num2 EXIT

Чтобы выполнить процедуру ADD.CMD, введите ADD в командном режиме OS/2, а затем введите два любых числа. Ниже приведен протокол работы этой процедуры, если Вы ввели числа 3 и 12.

[C:\]ADD Введите первое число. 3 Введите второе число. 12 Сумма двух чисел равна 15 [C:\]

Переменные

Переменная представляет собой часть данных с изменяющимся значением. Каждой переменной внутри процедуры присваивается уникальное имя, по которому на нее ссылаются в дальнейшем.

При выборе имени переменной имейте в виду, что первым символом может быть один из следующих:

A B C...Z ! ? _

Первым символом имени может быть и строчная буква. Интерпретатор перекодирует ее в прописную.

Остальными символами могут быть все перечисленные символы, а также цифры от 0 до 9.

Работа с переменными и арифметическими выражениями

В этом разделе рассказывается о том, как использовать переменные и производить арифметические вычисления, а также как писать комментарии, поясняющие работу процедуры. Этот раздел содержит информацию по следующим темам:

Выполнение арифметических вычислений

Может возникнуть необходимость включить в процедуры REXX арифметические операции сложения, вычитания, умножения и деления. Например, Вам потребуется присвоить числовые значения двум переменным и затем сложить их.

Арифметические операции выполняются обычным образом. Вы можете использовать целые числа и десятичные дроби. Целое число - это любое натуральное число, положительное, отрицательное или ноль, которое не содержит десятичной части (например, 1, 25 или 50). Десятичная дробь содержит десятичную точку (например, 1.45 или 0.6).

Прежде чем продемонстрировать использование этих четырех операций в процедурах, мы приведем примеры написания арифметических выражений и символов, предназначенных для каждой операции. Это будут просто некоторые арифметические операции, используемые в REXX.

Операторы - Символы, используемые для арифметических операций (+, -, *, /), называются операторами. Они производят действия над соседними элементами. В следующем примере операторы производят действия над числами (элементами) 4 и 2:

Сложение - Оператор сложения - это знак плюс (+). Инструкция сложения двух чисел выглядит следующим образом:

SAY 4 + 2

Результат выполнения инструкции Вы увидите на экране, это будет число 6.

Вычитание - Оператором вычитания - это знак минус (-). Инструкция вычитания двух чисел выглядит следующим образом:

SAY 8 - 3

Результатом выполнения инструкции будет число 5, которое выводится на экран.

Умножение - Оператор умножения - это звездочка (*). Инструкция умножения двух чисел выглядит следующим образом:

SAY 2 * 2

Результатом выполнения инструкции будет число 4, которое выводится на экран.

Значение переменной, в отличие от имени, может изменяться. Когда Вы именуете переменную (придаете ей некоторое значение), то тем самым выполняете присваивание. Например, любой оператор типа

symbol = выражение является оператором присваивания. Таким образом, Вы приказываете интерпретатору вычислить значение выражения и поместить результат в поле переменной symbol. Это эквивалентно следующему: "Присвоить переменной symbol значение результата выражения" или каждый раз, когда переменная symbol появляется в тексте строки инструкции SAY без кавычек, выводить на ее месте значение выражения. Взаимосвязь между переменной и ее значением такая же, как и между почтовым ящиком и его содержимым. Номер почтового ящика всегда один и тот же, а его содержимое может поменяться в любое время. Ниже приведен пример еще одного оператора присваивания:

num1 = 10

Здесь num1 имеет то же смысловое значение, что и слово symbol в предыдущем примере, а значение 10 соответствует слову выражение.

Один из способов изменения значения переменной num1 - добавление некоторого числа или выражения к старому значению с помощью следующего оператора присваивания:

num1 = num1 + 3

Значение num1 теперь изменилось с 10 на 13.

Специальным соглашением в REXX является то, что в качестве первоначального значения переменной, которой не было присвоено значение, является ее имя, выводимое прописными буквами. Например, если Вы напишете в процедуре

list = 2 20 40 SAY list то на экран выведется следующая информация:

2 20 40

Таким образом, переменная list принимает значения, которые были ей присвоены. Однако, если Вы не присвоите переменной list никакого значения и просто напишете:

SAY list то на экран выведется:

LIST

Ниже приведен пример простой процедуры VARIABLE.CMD, которая присваивает значения переменным:

/* Присваивание значений переменным */ a = 'abc' SAY a b = 'def' SAY a b EXIT

Если Вы выполните процедуру VARIABLE, то протокол работы будет выглядеть следующим образом:

[C:\]VARIABLE abc abc def

[C:\]

Процесс присваивания значений прост, однако убедитесь в том, что имя, выбранное для переменной, не будет использовано непредумышленно, как показано на примере процедуры MEETING.CMD:

/* Непреднамеренная интерпретация переменной */ the='no' SAY Here is the person I want to meet EXIT

Протокол выполнения процедуры:

[C:\]MEETING HERE IS no PERSON I WANT TO MEET

[C:\]

Чтобы предотвратить непреднамеренное замещение слова переменной, заключите предложение в кавычки, как это сделано в процедуре MEETING.CMD, которая теперь уже правильно присваивает значение переменной:

/* Правильная интерпретация переменной the*/ the= 'no' SAY "Here is the person I want to meet" EXIT

Инструкции SELECT, AND, WHEN, OTHERWISE и NOP

SELECT приказывает интерпретатору выбрать одну инструкцию из перечня возможных. Она используется только вместе с WHEN, THEN, END и иногда с OTHERWISE. Инструкция END отмечает конец каждой группы SELECT. Инструкция SELECT выглядит следующим образом:

SELECT WHEN выражение1 THEN инструкция1 WHEN выражение2 THEN инструкция2 WHEN выражение3 THEN инструкция3 ... OTHERWISE инструкция инструкция инструкция END

На диаграмме, приведенной ниже, представлена наглядная структура инструкции SELECT:

Инструкцию DO-END можно включить в инструкцию SELECT следующим образом:

SELECT WHEN выражение1 THEN DO инструкция1 инструкция2 инструкция3 END . . .

Инструкцию SELECT применяйте для использования одной переменной, которая может принимать несколько различных значений. С каждым из этих значений можно связать выполнение различных действий.

Допустим, Вы хотите составить памятку основных дел на неделю. Переменная day может принимать значения Понедельник - Пятница. В зависимости от дня недели (значение переменной), Вы можете вывести список дел на соответствующий день (с помощью инструкции). Процедура SELECT.CMD, приведенная ниже, решает поставленную задачу.

/* Выбор дел на каждый день недели */ SAY 'Какой сегодня день?' Pull day SELECT WHEN day = 'ПОНЕДЕЛЬНИК' THEN SAY ' Знакомство с доской объявлений' WHEN day = 'ВТОРНИК' THEN SAY "Встреча с моей командой" WHEN day = 'СРЕДА' THEN NOP /* Нет операции */ WHEN day = 'ЧЕТВЕРГ' THEN SAY "Мой семинар" WHEN day = 'ПЯТНИЦА' THEN SAY "Рецензирование книги" OTHERWISE SAY "Выходной день, все может случиться!" END EXIT

Инструкция NOP: Если Вы не хотите предпринимать никаких действий для определенного выражения, то используйте инструкцию NOP (No Operation), как показано в предыдущем примере для значения СРЕДА.

Инструкция ELSE

ELSE определяет инструкцию, которая должна быть выполнена в случае, если выражение ложно. Чтобы приказать интерпретатору выбрать одну из двух возможных инструкций, используйте следующую конструкцию: IF выражение THEN инструкция1 ELSE инструкция2

Формат IF-THEN-ELSE можно включить и в следующую процедуру:

IF answer = 'ДА' THEN SAY 'ХОРОШО!' ELSE SAY 'почему нет?'

Выполните процедуру GOING.CMD, чтобы посмотреть, как на практике осуществляется выбор между двумя инструкциями:

/* Использование IF-THEN-ELSE */ SAY "Ты собираешься на заседание?" PULL answer IF answer = "ДА" THEN SAY "Я буду тебя ждать." ELSE SAY "Я сделаю для тебя заметки." EXIT

Ниже приведен протокол работы этой процедуры:

[C:\]GOING Ты собираешься на заседание?

да

Я буду тебя ждать.

[C:\]

Логические операторы NOT, AND, OR

Логические операторы могут возвращать только значения 1 или 0. Оператор NOT (¬ или \), указанный перед элементом, изменяет его значение либо с истинного на ложное, либо с ложного на истинное.

SAY \ 0 /* выведет '1' */ SAY \ 1 /* выведет '0' */ SAY \ (4 = 4) /* выведет '0' */ SAY \ 2 /* выведет ошибку синтаксиса */

Оператор AND (&), указанный между двумя элементами, принимает значение истина только в том случае, когда оба элемента истинны.

SAY ( 3 = 3 ) & ( 5 = 5 ) /* выведет '1' */ SAY ( 3 = 4 ) & ( 5 = 5 ) /* выведет '0' */ SAY ( 3 = 3 ) & ( 4 = 5 ) /* выведет '0' */ SAY ( 3 = 4 ) & ( 4 = 5 ) /* выведет '0' */

Оператор OR ( | ), указанный между двумя элементами, принимает значение истина, если хотя бы один элемент имеет значение истина.

Если Вы хотите просмотреть еще некоторые примеры по использованию логических операторов, =>.

Операторы истинности и ложности

Операторы сравнения - Перечисленные далее операторы можно использовать для сравнений:

Сравнивать можно как числовые, так и символьные величины. Ниже приведены примеры сравнения чисел:

Если элементы, которые нужно сравнить, не числа, то интерпретатор сравнивает символы. Например, при сравнении двух слов (строк) airmail и airplane, символ за символом, три первых буквы у них совпадут. Далее, так как m < p, то и airmail < airplane.

Равенство - В языке REXX знак равенства (=) может иметь два значения в зависимости от его местоположения. Например,

amount = 5 /* Это оператор присваивания */ присваивает переменной amount значение 5. Если же знак равенства используется не в операторе присваивания, то в этом случае будет выполняться сравнение. Например,

Если Вы хотите просмотреть еще некоторые примеры сравнений => .

Принятие решений (IF THEN)

В процедурах, примеры которых были приведены ранее, инструкции выполнялись последовательно одна за другой. В этом разделе описывается, как управлять порядком выполнения инструкций. В зависимости от диалога, который пользователь ведет с процедурой, некоторые строки ее кода могут быть опущены.

Существует две инструкции, IF и SELECT, которые позволяют принимать решения о порядке выполнения прочих инструкций в процедуре. Инструкция IF подобна команде OS/2 IF. Она определяет, выполнять ли следующую инструкцию или пропустить ее. Инструкция SELECT позволяет выбрать для выполнения одну инструкцию из группы.

Для принятия решения инструкция IF должна использоваться вместе с инструкцией THEN. Интерпретатор выполняет следующую за IF инструкцию в том случае, если выражение истинно, например:

IF answer = "ДА" THEN SAY "ХОРОШО!"

В предыдущем примере инструкция SAY выполняется только в том случае, если переменная answer имеет значение ДА.

Объединение инструкций с помощью DO и END - Для того, чтобы приказать интерпретатору выполнить некоторый перечень инструкций, следующих за инструкцией THEN, используйте конструкцию типа:

DO Инструкция1 Инструкция2 Инструкция3 END

Инструкция DO и завершающая ее инструкция END указывают интерпретатору рассматривать все инструкции, расположенные между ними, как одну инструкцию.

Средства языка REXX

В этом разделе описываются средства языка REXX, которые можно использовать для написания более сложных процедур. Вы увидите, как в процедуре можно сделать выбор, проверяя значение переменной с помощью инструкции IF. Вы также узнаете, как сравнивать величины и определять, является выражение истинным либо ложным. Ниже приведено краткое описание элементов, обсуждаемых в этом разделе.

Автоматизация повторяющихся задач - использование циклов

Если Вы хотите повторить выполнение нескольких инструкций в процедуре, можете использовать цикл. Циклы часто используются в программировании, так как они группируют некоторое множество инструкций, выполняемых несколько раз. Циклы делают Вашу процедуру более краткой, а также позволяют опрашивать пользователя до тех пор, пока он не введет правильный ответ.

С помощью циклов можно складывать или вычитать числа до тех пор, пока Вы не захотите остановиться. Вы можете определить, сколько раз процедура должна выполнить указанные инструкции. В этом разделе Вы познакомитесь с простейшими циклами, используемыми для выполнения в процедуре повторяющихся инструкций.

Существуют два типа циклов. Это и . Циклы начинаются с инструкции DO и завершаются инструкцией END. Ниже приведено краткое описание элементов, обсуждаемых в этом разделе:

Повторяющиеся циклы

Простые повторяющиеся циклы могут быть выполнены определенное количество раз. Вы можете указать число повторений цикла или использовать переменную, которая имеет изменяющееся значение.

Ниже приведен пример цикла, который повторяется фиксированное число раз.

DO num инструкция1 инструкция2 инструкция3 ... END

Num представляет собой целое число, указывающее количество повторений цикла.

Процедура LOOP.CMD является примером простого повторяющегося цикла.

/* Простой цикл */ DO 5 SAY 'Спасибо' END EXIT

Ниже приведен протокол работы процедуры LOOP.CMD:

[C:\]loop Спасибо Спасибо Спасибо Спасибо Спасибо

[C:\]

Инструкция DO может также иметь следующий вид:

DO XYZ = 1 to 10

Инструкция DO такого типа подсчитывает каждый проход по циклу, поэтому этот счетчик можно использовать как переменную. Значение XYZ изменяется (на 1) каждый раз, когда отрабатывает цикл. Значение 1 (или любое другое число) присваивается переменной, когда цикл выполняется первый раз. Значение 10 (или любое другое число) будет присвоено переменной при последнем проходе по циклу.

Процедура NEWLOOP.CMD является примером подобного цикла:

/* Цикл с инструкцией DO другого типа */ sum = 0 DO XYZ = 1 to 7 SAY 'Введите значение' XYZ PULL value sum = sum + value END SAY 'Общий итог равен' sum EXIT

Ниже приведен протокол работы процедуры NEWLOOP.CMD:

[C:\]newloop Введите значение 1 2 Введите значение 2 4 Введите значение 3 6 Введите значение 4 8 Введите значение 5 10 Введите значение 6 12 Введите значение 7 14 Общий итог равен 56

[C:\]

После завершения цикла выполнение процедуры продолжается с инструкции, следующей за инструкцией END (которая свидетельствует о конце цикла).

Разбор слов

Инструкция PULL получает ответ и помещает его в память некоторой переменной. PULL может также использоваться для помещения в память нескольких переменных каждого слова из группы слов. В языке REXX это называется разбором. В следующем примере используются переменные с именами: first, second, third и rest.

SAY 'Введите, пожалуйста, три слова или более' PULL first second third rest

Предположим, Вы ввели следующий ответ:

garbage in garbage out

После нажатия клавиши Enter выполнение процедуры продолжится. При этом указанные переменные получат следующие значения:

Каждая переменная в качестве своего значения получает слово без пробелов, а последняя переменная - остаток введенной строки, если он есть, вместе с пробелами. Если в процедуре указано больше переменных, чем введено слов, то лишние переменные получают нулевое или пустое значение.

Условные циклы

Условные циклы выполняются до тех пор, пока удовлетворяется условие истинности или ложности некоторого выражения. Рассмотрим несколько инструкций, которые используются для условных циклов:

DO WHILE и DO UNTIL - Инструкции DO WHILE и DO UNTIL выполняются, пока удовлетворяется некоторое условие или до тех пор, пока оно не удовлетворится. Инструкция DO WHILE имеет следующую структуру:

DO WHILE выражение инструкция1 инструкция2 инструкция3 END

Инструкция DO WHILE проверяет истинность или ложность некоторого выражения в начале цикла; т.е. перед выполнением последующих инструкций. Если выражение является истинным, то инструкции выполняются. Если выражение является ложным, то цикл завершается и управление передается инструкции, следующей за END.

На диаграмме, приведенной ниже, представлена наглядная структура инструкции DO WHILE:

Чтобы просмотреть примеры использования инструкции DO WHILE в процедурах, выберите =>.

DO UNTIL - Инструкция DO UNTIL отличается от DO WHILE тем, что она сначала выполняет инструкции, образующие тело цикла, а затем проверяет значение выражения. Если выражение ложно, то инструкции повторяются (в цикле). Если выражение истинно, то цикл завершается и управление передается инструкции, следующей за END.

Так как инструкция DO UNTIL проверяет значение выражения в конце цикла, инструкции внутри цикла DO выполняются по крайней мере один раз.

Инструкция DO UNTIL имеет следующую структуру:

DO UNTIL выражение инструкция1 инструкция2 инструкция3

END

На диаграмме, приведенной ниже, представлена наглядная структура инструкции DO UNTIL:

Чтобы просмотреть примеры использования инструкции DO UNTIL в процедурах, выберите =>.

LEAVE - Вам может понадобиться выйти из цикла до того, как он завершится естественным образом по удовлетворении некоторого условия. Вы можете сделать это с помощью инструкции LEAVE. Эта инструкция завершает цикл, и управление передается инструкции, следующей за END. Проиллюстрируем на примере процедуры LEAVE.CMD использование инструкции LEAVE.

Выход из циклов

Чтобы прекратить выполнение большинства процедур REXX, пользуйтесь комбинацией клавиш Ctrl+Break. REXX распознает комбинацию Ctrl+Break после окончания выполнения текущей инструкции. Бывают случаи (как, например, в приведенной ниже процедуре), когда для того, чтобы выйти из цикла, нужно нажать комбинацию клавиш Ctrl+Break, а затем Enter.

/* Угадайте пароль ! */ DO UNTIL answer = "Sesame" SAY "Введите, пожалуйста, пароль . . ." PULL answer END EXIT

Если Вы все-таки не смогли завершить процедуру, то нажмите комбинацию клавиш Alt+Esc, чтобы завершить сеанс OS/2 и остановить выполнение процедуры.

Расширенные функции REXX

По мере приобретения опыта в программировании Вы научитесь создавать процедуры, обладающие большими возможностями и работающие более эффективно. Иногда это означает добавление в процедуру специальных функций или вызов подпрограмм.

В этом разделе мы рассмотрим, как с помощью этих функций можно поставить написание процедур REXX на более профессиональную основу.

ADDRESS

Инструкция ADDRESS используется для того, чтобы послать на выполнение в указанную среду, представленную на диаграмме словом среда, одну команду. В качестве обозначения среды может выступать текстовая цепочка или символ, которые являются константами и позиционно предшествуют выражению. Выражение вычисляется и результирующая командная строка направляется в указанную среду. После того, как команда выполнится, среда устанавливается в то состояние, в котором она находилась до выполнения команды. Таким образом происходит временное изменение адресата для одной команды.

Пример: ADDRESS CMD "DIR C:\STARTUP.CMD" /* OS/2 */

Если указана только среда, то происходит постоянное изменение адресата: все последующие команды (предложения, которые не являются инструкциями REXX и операторами присваивания) будут направляться в указанную командную среду до тех пор, пока не будет введена следующая инструкция ADDRESS. Сохраняется среда, установленная ранее.

Пример:

Предположим, что в качестве среды для текстового редактора зарезервировано имя "EDIT": address CMD 'DIR C:\STARTUP.CMD' if rc=0 then 'COPY STARTUP.CMD *.TMP' address EDIT

Все последующие команды направляются на выполнение в среду текстового редактора до тех пор, пока не будет введена очередная инструкция ADDRESS.

Чтобы выполнить постоянное изменение среды, можно также использовать форму VALUE. В этом случае выражение1 (которое может быть просто именем переменной) вычисляется и результат формирует имя среды. Вложенное ключевое слово VALUE может быть опущено при условии, что выражение1 начинается со специального символа (для того, чтобы не ошибиться с символом или строкой).

Пример: ADDRESS ('ENVIR'number)

Если инструкция введена без аргументов, то команды направляются для выполнения в среду, которая была установлена до предыдущего постоянного изменения среды, и имя этой текущей среды сохраняется. Поэтому повторное выполнение инструкции ADDRESS без аргументов приводит к попеременному переключению командных сред с одной на другую. Пустая строка (" "), указанная для имени среды, означает то же самое, что и среда, принимаемая по умолчанию.

ARG

Инструкция ARG используется для восстановления строк аргументов, предоставляемых программе или внутренней подпрограмме, и присваивания их значений некоторым переменным. Представляет собой краткую форму следующей инструкции:

Шаблон представляет собой список символов, разделенных пробелами.

Если выполняется не подпрограмма или внутренняя функция, то интерпретатор считывает аргументы, указанные при вызове программы; встречающиеся буквы переводит в прописные (например, строчные a-z в прописные A-Z), а затем присваивает значения считанных аргументов некоторым переменным. Если Вы не хотите переводить строчные буквы в прописные, то используйте инструкцию PARSE ARG.

Если выполняется подпрограмма или внутренняя функция, то использованные данные будут строками аргументов, переданных программе.

Инструкции ARG и PARSE ARG могут выполняться как угодно часто (как правило, с различными шаблонами), при этом всегда разбирая по переменным одну и ту же текущую строку ввода. Не существует ограничений на длину или содержание разбираемых данных, кроме тех, которые налагаются вызывающей программой.

Пример: /* Переданная строка - "Easy Rider" */

Arg adjective noun

/* Теперь: "ADJECTIVE" содержит 'EASY' */ /* "NOUN" содержит 'RIDER' */

Если ожидается, что программе будут доступны несколько строк аргументов, то каждая из них может быть выбрана по очереди, ориентируясь на разделяющую запятую в разбираемом шаблоне.

Пример: /* функция вызывается следующим образом: FRED('data X',1,5) */

Fred: Arg string, num1, num2

/* Теперь: "STRING" содержит 'DATA X' */ /* "NUM1" содержит '1' */ /* "NUM2" содержит '5' */

Примечания: Строки аргументов для процедур REXX или внутренних программ можно восстановить или проверить и с помощью встроенной функции ARG.

Источник данных, которые будут обрабатываться, также предоставляется при входе в программу. Для получения более подробной информации обращайтесь к описанию инструкции PARSE (режим SOURCE).

CALL

Инструкция CALL используется для вызова программы (если Вы указали имя) или для управления отслеживанием некоторых условий (если Вы указали ON или OFF).

Для управления отслеживанием укажите OFF или ON и условие, которое Вы хотите отследить. OFF прекращает процесс отслеживания указанного условия. ON запускает процесс отслеживания указанного условия.

Для вызова программы укажите имя, являющееся символом или текстовой строкой, которые представляют собой константу. Имя должно быть действительным символом. Вызываемая программа может быть одной из следующих: Внутренняя программа Внешняя программа Встроенная функция.

Если для указания имени используется строка (т.е. имя заключено в кавычки), то поиск внутренних меток не производится и вызываются только встроенные функции или внешние программы. Следует отметить, что имена встроенных функций (и, как правило, имена внешних программ тоже) пишутся прописными буквами; поэтому и имя в текстовой строке должно быть указано прописными буквами.

В необязательном порядке программа может возвращать результат, который функционально идентичен следующему предложению:

Исключительная ситуация возникает тогда, когда переменная result инициализируется при отсутствии результата, возвращенного вызванной программой.

Имя, заданное в инструкции CALL, должно быть действительным символом.

Интерпретатор OS/2 допускает возможность указания до 20 выражений, разделенных запятыми. Выражения вычисляются слева направо и формируют строки аргументов в процессе выполнения программы. Любая инструкция ARG или PARSE ARG, а также встроенная функция ARG в вызванной программе получит доступ к этим строкам прежде, чем они станут активными в вызывающей программе. При необходимости Вы можете опустить некоторые выражения, вставляя на их место дополнительные запятые.

Инструкция CALL инициирует затем переход к программе с указанным именем, используя тот же механизм, что и при вызове функции. Порядок, в котором осуществляется поиск программ, описан в разделе, посвященном функциям.
Ниже приведена краткая информация:

DO

повторитель:

условие:

DO используется для того, чтобы объединить некоторые инструкции и, необязательно, неоднократно их выполнить. В процессе неоднократного выполнения инструкций управляющая переменная (имя) может наращиваться, принимая различные значения из некоторого диапазона.

Примечания по синтаксису: Значения exprr, expri, exprb, exprt и exprf (если они указаны) представляют собой выражения, результат вычисления которых - число. Значения exprr и exprf представляют собой выражения, результат вычисления которых - целое неотрицательное число. При необходимости числа округляются в соответствии с установкой NUMERIC DIGITS. Значения exprw или expru (если они указаны) могут быть любым выражением, результат вычисления которого равен 1 или 0.

Фразы TO, BY и FOR могут указываться в любом порядке, если они используются.

Инструкции могут включать в себя операторы присваивания, команды и ключевые инструкции (которые сами могут включать любую из более сложных конструкций, таких, как IF, SELECT и инструкцию DO).

Вложенные ключевые слова TO, BY, FOR, WHILE и UNTIL зарезервированы внутри инструкции DO, в которой они не могут использоваться в качестве имен переменных в выражениях, но могут выступать в качестве имени управляющей переменной. Вложенное ключевое слово FOREVER также зарезервировано, но только в том случае, если оно непосредственно следует за ключевым словом DO.

Значение exprb по умолчанию принимается равным 1, если это имеет отношение к делу.

Простая группа DO:

Если не указан ни повторитель, ни условие, то конструкция DO просто группирует вместе некоторое число инструкций. Они выполняются один раз. В противном случае группа инструкций образует повторяющийся цикл DO, который выполняется несколько раз, в зависимости от заданного повторителя и условия, которое может его изменять.

В следующем примере инструкции выполняются один раз.

Пример: /* Две инструкции между DO и END будут */ /* выполнены в случае, если A = 3. */ If a=3 then Do a=a+2 Say 'Улыбнитесь!' End

DROP

Каждое имя представляет собой имя действительной переменной, иногда заключенное в скобки (для обозначения дополнительного списка), и отделяется от любого другого имени одним или несколькими пробелами.

Инструкция DROP используется для отмены назначений переменных; т.е. для восстановления их в первоначальное непроинициализированное состояние.

Каждая указанная переменная удаляется из списка известных переменных. Если единственное указанное имя заключено в скобки, то его значение рассматривается как дополнительный список переменных, которые нужно освободить. Принцип расположения переменных в дополнительном списке должен подчиняться тем правилам, которые приняты и для основного списка (содержать действительные имена переменных, разделенные пробелами), но без пробелов в начале и конце списка. Переменные освобождаются последовательно слева направо. Не будет ошибкой указание одного и того же имени переменной несколько раз или попытка освободить переменную, имя которой неизвестно. Если указана проявляющаяся переменная (см. описание инструкции PROCEDURE), то эта переменная сама будет освобождена при последующей генерации.

Пример: j=4 Drop a x.3 x.j /* освободит переменные: A, X.3, and X.4, поэтому */ /* последующая ссылка на них выдаст их имена. */

В следующем примере имя переменной в скобках используется как дополнительный список.

Пример: x=4;y=5;z=6; a='x y z' DROP (a) /* освободит x,y и z */

Если указана основа (символ, содержащий только одну точку в качестве последнего знака), то освобождаются все переменные, начинающиеся с этой основы.

Пример: Drop x. /* освободит все переменные, чьи имена начинаются с X. */

EXIT

Инструкция EXIT используется для безусловного завершения программы. В некоторых случаях EXIT возвращает вызывающей программе строку данных. Программа завершается немедленно, даже если при этом выполняется внутренняя программа. При отсутствии активных внутренних программ инструкции RETURN и EXIT идентичны по их воздействию на выполняющуюся программу.

Если Вы указали выражение, то оно вычисляется и после завершения программы результирующая строка возвращается вызывающей программе.

Пример: j=3 Exit j*4 /* Завершится с результирующей строкой '12' */

Если Вы не указываете выражение, то вызывающей программе никакие данные не передаются. Если программа была вызвана как внешняя функция, то это воспринимается как ошибка, независимо от того, немедленно завершилась программа (при использовании EXIT) или по возврату в вызывающую программу (при использовании RETURN).

Выражение "достижение конца" программы всегда равнозначно инструкции EXIT в той ее форме, когда она завершает всю программу и не возвращает результирующей строки.

IF

Инструкция IF используется для условного выполнения инструкции или группы инструкций в зависимости от результата вычисления выражения. Результат вычисления выражения должен быть равен 0 или 1.

Инструкция, следующая за THEN, выполняется только в том случае, если результат вычисления равен 1. Если Вы указали предложение ELSE, то инструкция, следующая за ELSE, выполняется только в том случае, если результат вычисления равен 0.

Пример: if answer='ДА' then say 'Хорошо!' else say 'Почему нет?'

Не забывайте, что если предложение ELSE находится в той же строке, что и последняя часть предложения THEN, то их нужно разделить точкой с запятой.

Пример: if answer='ДА' then say 'Хорошо!'; else say 'Почему нет?'

Предложение ELSE связывается с ближайшей инструкцией соответствующего уровня. Чтобы исключить ошибки и возможную путаницу при написании вложенных конструкций IF, можно использовать инструкцию NOP, как показано в следующем примере.

Пример: If answer = 'ДА' Then If name = 'ФРЕД' Then say 'Хорошо, Фред.' Else nop Else say 'Почему нет?'

Примечания:

Инструкцией может быть любой оператор присваивания, команда или ключевая инструкция, включающая любую более сложную конструкцию, такую как DO, SELECT или саму инструкцию IF. Предложение, содержащее пустую строку, не является инструкцией; поэтому указание за THEN или ELSE дополнительной точки с запятой не равнозначно выполнению фиктивной инструкции (как это принято в языке С). Для этих целей предназначена инструкция NOP.

Слово THEN нельзя использовать внутри выражения (в котором оно не предназначается для начала предложения), так как ключевое слово THEN обрабатывается иначе. Если же оно используется, то это может привести к завершению выражения в предложении IF посредством символа THEN, указанного без требуемого разделителя (;). Если бы это было не так, то пользователи других компьютерных языков испытывали бы определенные затруднения.

INTERPRET

Инструкция INTERPRET используется для выполнения инструкций, построенных динамически в процессе вычисления выражения.

Выражение вычисляется, а затем обрабатывается (интерпретируется) так, как если бы результирующая цепочка символов была строкой, вставленной в исходный файл (и ограниченной DO; и END;).

Допустимы любые инструкции (включая инструкции INTERPRET), но конструкции типа DO ... END и SELECT ... END должны иметь завершенный вид. Например, строка инструкций, которая интерпретируется, не может содержать инструкции LEAVE или ITERATE (действительные только внутри повторяющегося цикла DO), если она при этом не содержит полную повторяющуюся конструкцию DO ... END.

Для удобства пользователя в конце выражения подразумевается точка с запятой.

Пример: data='FRED' interpret data '= 4' /* a) построит строку "FRED = 4" */ /* b) вычислит FRED = 4; */ /* Теперь переменной "FRED" будет присвоено значение "4" */

Пример: data='do 3; say "Привет!"; end' interpret data /* Выведет: */ /* Привет! */ /* Привет! */ /* Привет! */

Примечания:

Использование инструкции INTERPRET обычно требуется лишь в специальных случаях, например, когда за один раз должно быть интерпретировано несколько операторов.

ITERATE

Инструкция ITERATE предназначена для изменения естественного потока инструкций внутри повторяющегося цикла DO (т.е. любой конструкции DO, кроме простых циклов DO).

Выполнение группы инструкций прекращается и управление передается инструкции DO, как если бы встретилось предложение END. Управляющая переменная (если она существует) наращивается и проверяется как обычно, и выполнение группы инструкций возобновляется, если только цикл не завершится по инициативе инструкции DO.

Если имя не указано, то инструкция ITERATE будет отноcиться к самому внутреннему активному повторяющемуся циклу. Если имя задано, то оно должно быть именем управляющей переменной текущего активного цикла, который может быть самым внутренним циклом; к этому циклу и будет применяться инструкция ITERATE. Любой активный цикл, вложенный в цикл, выбранный для итераций, завершается (как если бы встретилась инструкция LEAVE).

Пример: do i=1 to 4 if i=2 then iterate say i end /* Будут выведены числа: 1, 3, 4 */

Примечания:

Если указано имя, то оно должно совпадать с именем в инструкции DO во всех отношениях, кроме регистра клавиатуры (строчные или прописные буквы). При этом, когда выполняется сравнение имен, никакие подстановки для составных переменных не производятся.

Цикл считается активным, если он в настоящий момент обрабатывается. Если в процессе выполнения цикла была вызвана подпрограмма или началась обработка инструкции INTERPRET, то цикл становится неактивным до тех пор, пока не будет осуществлен возврат из подпрограммы или не завершится выполнение инструкции INTERPRET. Инструкцию ITERATE нельзя использовать в неактивных циклах.

Если одна и та же управляющая переменная используется в нескольких активных циклах, то инструкция ITERATE относится к самому внутреннему циклу.

Ключевые инструкции

Ключевая инструкция представляет собой одно или несколько предложений, первое из которых начинается ключевым словом, определяющим инструкцию. Если инструкция состоит из нескольких предложений, то они должны отделяться друг от друга точкой с запятой (;).

Некоторые ключевые инструкции, например, начинающиеся ключевым словом DO, могут включать в себя вложенные инструкции.

В синтаксических диаграммах символы (слова), изображенные прописными буквами, представляют ключевые слова; остальные слова (такие как выражение) являются набором символов. Ключевые слова не зависят от того, какими буквами они набраны (прописными или строчными), поэтому все нижеперечисленные слова: if, If и iF будут вызывать выполнение одной и той же инструкции IF. Вы можете также опускать большинство указанных разделителей (;), приведенных в синтаксисе для обозначения конца строки.

LEAVE

Инструкция LEAVE используется для немедленного выхода из одного или нескольких повторяющихся циклов DO (т.е. из любой конструкции DO, отличной от простого цикла DO).

Выполнение группы инструкций завершается, и управление передается инструкции, следующей за предложением END, как если бы цикл закончился естественным образом после обработки условия завершения. Однако при этом управляющая переменная, если она есть, на выходе будет иметь то значение, которое она имела перед выполнением инструкции LEAVE.

Если имя не указано, то инструкция LEAVE завершает самый внутренний активный повторяющийся цикл. Если имя указано, то оно должно быть именем управляющей переменной текущего активного цикла, который может быть самым внутренним циклом; этот цикл (как и все активные циклы, вложенные в него) будет завершен. Потом управление передается инструкции, следующей за предложением END, соответствующим предложению DO выбранного цикла.

Пример: do i=1 to 5 say i if i=3 then leave end /* Будут выведены числа: 1, 2, 3 */

Примечания: Если указано имя, то оно должно совпадать с именем в инструкции DO во всех отношениях, кроме регистра клавиатуры (строчные или прописные буквы). При этом, когда выполняется сравнение имен, никакие подстановки для составных переменных не производятся.

Цикл считается активным, если он в настоящий момент обрабатывается. Если в процессе выполнения цикла была вызвана подпрограмма или началась обработка инструкции INTERPRET, то цикл становится неактивным до тех пор, пока не выполнится возврат из подпрограммы или не завершится выполнение инструкции INTERPRET. Инструкцию LEAVE нельзя использовать для завершения неактивного цикла.

Если одна и та же управляющая переменная используется в нескольких активных циклах, то инструкция LEAVE завершит самый внутренний цикл.

NOP

NOP - это фиктивная инструкция, которая не выполняет никаких действий. Может использоваться в качестве инструкции в предложениях THEN или ELSE.

Пример: Select when a=b then nop /* Ничего не делать */ when a>b then say 'A > B' otherwise say 'A < B' end

NUMERIC

Инструкция NUMERIC используется для изменения способа выполнения арифметических операций. Режимы данной инструкции подробно описаны в документе Язык процедур 2/REXX для OS/2. Справочник.

Инструкция NUMERIC с режимом DIGITS управляет точностью вычисления арифметических выражений и арифметических встроенных функций. Если выражение опущено, то по умолчанию используется значение 9. В противном случае результат выражения при необходимости округляется в соответствии с текущим назначением NUMERIC DIGITS. Используемое значение должно быть целым положительным числом, большим, чем текущее назначение NUMERIC FUZZ.

Не существует ограничений на значение DIGITS (кроме объема доступной памяти), но следует отметить, что высокая точность вычислений обычно требует много процессорного времени. Поэтому рекомендуется во всех возможных случаях использовать значение по умолчанию.

Текущее назначение NUMERIC DIGITS можно получить с помощью встроенной функции DIGITS.

Инструкция NUMERIC с режимом FORM управляет формой экспоненциального представления результатов выполнения арифметических операций и встроенных арифметических функций, используемой в языке REXX. Это может быть SCIENTIFIC (в этом случае перед десятичной точкой появляется только одна цифра, отличная от нуля) или ENGINEERING (в этом случае степень числа 10 всегда кратна трем). По умолчанию принимается значение SCIENTIFIC. Режим FORM устанавливается либо с помощью прямого указания вложенного ключевого слова (SCIENTIFIC или ENGINEERING), либо принимается как результат вычисления выражения, следующего за VALUE. Результат в этом случае может быть либо SCIENTIFIC, либо ENGINEERING. Вы можете опустить вложенное ключевое слово VALUE, если выражение начинается не с символа или текстовой строки (например, если оно начинается со специального знака: оператора или скобки).

Текущее значение NUMERIC FORM можно получить с помощью встроенной функции FORM.

Инструкция NUMERIC с режимом FUZZ указывает, сколько цифр результата, полученного с указанной точностью, можно отбросить при выполнении операции сравнения.
Если выражение опущено, то по умолчанию принимается значение 0. В противном случае результат вычисления выражения должен быть нулевым или целым положительным числом, которое перед использованием нужно округлить в соответствии с текущей установкой NUMERIC DIGITS. Используемое значение должно быть целым положительным числом, меньшим, чем текущее назначение NUMERIC DIGITS.

Режим FUZZ временно уменьшает значение DIGITS на величину FUZZ перед каждой операцией числового сравнения. Сравниваемые числа вычитаются одно из другого, используя точность (DIGITS - FUZZ), а потом результат сравнивается с нулем.

Текущее значение NUMERIC FUZZ можно получить с помощью встроенной функции FUZZ.

OPTIONS

Инструкция OPTIONS используется для передачи специальных запросов или параметров языковому процессору. Например, это могут быть режимы языкового процессора или определения специального набора символов.

Результат вычисления выражения проверяется слово за словом. Если слова распознаются языковым процессором, то они принимаются. Нераспознанные слова игнорируются. Считается, что это инструкции другого процессора.

Языковый процессор распознает следующие слова:

Примечания: Из-за просмотра процедур языковым процессором в программах, содержащих текстовые строки DBCS, помещайте инструкцию OPTIONS ETMODE в качестве первой инструкции.

Чтобы не сомневаться в правильности просмотра программы, содержащей символы DBCS, вводите режимы ETMODE, NOETMODE, EXMODE и NOEXMODE инструкции OPTIONS как текстовые строки (в кавычках).

Назначения OPTIONS ETMODE и OPTIONS EXMODE сохраняются на время выполнения подпрограммы или функции, а затем восстанавливаются.

Слова ETMODE, EXMODE, NOEXMODE и NOETMODE могут встретиться несколько раз внутри результирующей строки. При этом режим, который будет принят к исполнению, определяется последним действительным словом, указанным между парами ETMODE/NOETMODE и EXMODE/NOEXMODE.

PARSE

Инструкция PARSE используется для присваивания данных из различных источников одной или нескольким переменным в соответствии с правилами и шаблонами, описанными в разделе по разбору слов документа Язык процедур 2/REXX для OS/2. Справочник.

Если указан шаблон, то он представляет собой список символов, разделенных пробелами.

Если шаблон не указан, то переменные не назначаются, но при необходимости выполняется подготовка данных к разбору. Например, для PARSE PULL строка данных перемещается из текущей очереди данных; для PARSE LINEIN (и PARSE PULL, если текущая очередь пуста) строка выбирается из входного потока значений по умолчанию; для PARSE VALUE вычисляется выражение. Для PARSE VAR выбирается указанная переменная. Если эта переменная не имеет никакого значения, то устанавливается условие NOVALUE, если оно разрешено.

Если указан режим UPPER, то буквы в строке, которую нужно разобрать, сначала переводятся в прописные (например, строчные a-z в прописные A-Z). В противном случае при разборе слов не производится перевод строчных букв в прописные.

Данные, используемые для каждого из вариантов инструкции PARSE, приведены ниже:

PARSE ARG - Разбираются строки, которые передаются программе, подпрограмме или функции в качестве входного списка аргументов. Для получения более подробной информации смотрите описание инструкции ARG.

PARSE LINEIN - Разбирается следующая строка из входного потока значений по умолчанию. (Смотрите документ Язык процедур 2/REXX для OS/2. Справочник для получения сведений о формате входных данных REXX). PARSE LINEIN - это краткая форма следующей инструкции:

Если нет готовых доступных строк, то выполнение программы временно приостанавливается до тех пор, пока строка не завершится. Отметим, что инструкцию PARSE LINEIN нужно использовать только в том случае, когда необходим прямой доступ к входному потоку символов.
Обычный построчный диалог с пользователем лучше вести с помощью инструкций PULL или PARSE PULL.

Чтобы проверить, есть ли доступные строки во входном потоке значений по умолчанию, используйте встроенную функцию LINES.

PARSE PULL - Разбирается следующая строка из очереди. Если очередь пуста, то строки считываются с устройства ввода, определенного по умолчанию; обычно это пользовательская клавиатура. Вы можете добавить данные в начало или конец очереди, пользуясь инструкциями PUSH и QUEUE соответственно. Вы можете также определить количество строк в очереди на данный момент, используя встроенную функцию QUEUED. Очередь остается активной до тех пор, пока активен языковый процессор. Очередь может изменяться другими программами в операционной системе и может использоваться как средство взаимодействия между этими программами и процедурами REXX.

PROCEDURE

Инструкцию PROCEDURE можно использовать во внутренней программе (подпрограмме или функции) для защиты всех существующих переменных путем удаления их из числа известных для последующих инструкций. При выполнении инструкции RETURN восстанавливается исходная среда переменных. Все переменные, использованные в программе (которые не были проявлены), освобождаются.

Режим EXPOSE изменяет приведенный порядок действий. Любая переменная, указанная именем, проявляется, т.е. любое обращение к ней (включая назначение и освобождение) направляется в среду переменных, которая принадлежит вызывающей программе. Указывая режим EXPOSE, Вы должны определить по крайней мере одно имя, т.е. символ, отделенный от другого имени одним или несколькими пробелами. При необходимости Вы можете заключить единственное имя в скобки, чтобы определить дополнительный список переменных. Все переменные, не указанные с помощью своих имен в инструкции PROCEDURE EXPOSE, остаются защищенными. Следовательно, некоторый ограниченный набор переменных вызываемой программы может быть доступным, и эти переменные могут изменяться (или создаваться новые переменные в этом множестве). Все выполненные изменения будут видимы для вызывающей программы после возвращения из подпрограммы.

Все переменные проявляются последовательно слева направо. Не считается ошибкой указание одного и того же имени переменной несколько раз или указание имени, которое не использовано в качестве переменной в вызывающей программе.

Пример: /* Это основная программа */ j=1; x.1='a' call toft say j k m /* выведет на экран "1 7 M" */ exit

toft: procedure expose j k x.j say j k x.j /* выведет на экран "1 K a" */ k=7; m=3 /* переменная "M" не проявляется */ return

Заметим, что если бы в предыдущем примере X.J в списке EXPOSE было помещено перед J, то значение J не было бы видимым в настоящий момент, таким образом и переменная X.1 не проявилась бы.

Инструкция PULL используется для чтения первой строки из очереди данных REXX, активной в данный момент. ниже приведена краткая форма инструкции:

Текущее начало очереди данных читается как одна строка. Если в инструкции не указан шаблон, то никакие дальнейшие действия не производятся и считанная строка отвергается. Если шаблон указан, то он представляет собой список символов, отделенных друг от друга пробелами. Буквы в строке переводятся в прописные (например, строчные a-z в прописные A-Z), а затем строка разбирается по переменным в соответствии с правилами, описанными в разделе по разбору слов документа Язык процедур 2/REXX для OS/2. Справочник. Если не нужно переводить строчные буквы в прописные, то используйте инструкцию PARSE PULL.

Пример: Say 'Вы хотите удалить файл? Ответьте Да или Нет:' Pull answer . if answer='НЕТ' then Say 'Файл не будет удален.'

Здесь в шаблоне используется пустая метка-заполнитель "." для того, чтобы изолировать первое слово, введенное пользователем.

С помощью встроенной функции QUEUED можно определить количество строк в очереди на данный момент.

PUSH

Инструкция PUSH используется для занесения строки, являющейся результатом вычисления выражения, по принципу LIFO (последним вошел, первым вышел) в очередь данных REXX, активную в настоящий момент. Если Вы не указали выражение, то в очередь данных заносится пустая строка.

Пример: a='Fred' push /* Помещает в очередь пустую строку */ push a 2 /* Помещает в очередь строку "Fred 2" */

С помощью встроенной функции QUEUED можно определить количество строк, находящихся в очереди на данный момент.

QUEUE

Инструкция QUEUE используется для добавления строки, являющейся результатом вычисления выражения, в конец очереди данных REXX, активной в настоящий момент. При этом добавление осуществляется по принципу FIFO (первым вошел, первым вышел).

Если Вы не указали выражение, то в конец очереди данных добавится пустая строка.

Пример: a='Toft' queue a 2 /* Добавит в конец очереди строку "Toft 2" */ queue /* Добавит в конец очереди пустую строку */

С помощью встроенной функции QUEUED можно определить количество строк, находящихся в очереди на данный момент.

RETURN

Инструкция RETURN используется для возврата управления (и, возможно, результата) из программы REXX или внутренней программы в точку, откуда она была вызвана.

Если нет активной внутренней программы (подпрограммы или функции), то инструкции RETURN и EXIT идентичны по своему действию на выполняющуюся программу.

Если выполняется подпрограмма (см. инструкцию CALL), то вычисляется выражение (если оно указано), управление передается назад вызывающей программе и специальной переменной RESULT языка REXX присваивается значение выражения. Если выражение опущено, то специальная переменная RESULT освобождается (становится непроинициализированной). Различные назначения, сохраненные на время выполнения CALL (трассировка, адреса и т.д.), также восстанавливаются.

Если выполняется функция, то предпринимаемые действия идентичны описанным, исключая то, что в инструкции RETURN должно быть указано выражение. Результат вычисления выражения используется затем в исходном выражении в точке, из которой была вызвана функция.

Если внутри программы (подпрограммы или внутренней функции) выполняется инструкция PROCEDURE, то после вычисления выражения и до того, как результат будет использован или присвоен переменной RESULT, все переменные текущей генерации освобождаются (и проявленные переменные из предыдущей генерации тоже).

SAY

Инструкция SAY используется для записи в выходной поток результата вычисления выражения. Результат обычно выводится на экран пользователя, однако назначение для выходного потока зависит от конкретного применения. Результат вычисления выражения может иметь любую длину.

> Примечания:

Данные из инструкции SAY посылаются в выходной поток, принимаемый по умолчанию (STDOUT:). Однако для вывода инструкции SAY применимы стандартные правила перенаправления выходных потоков, принятые в OS/2.

Инструкция SAY не форматирует данные; упаковка строки выполняется операционной системой и аппаратурой. Несмотря на то, что форматирование все же происходит, выходные данные представляют собой единую логическую строку.

Пример: data=100 Say data ', разделенное на 4 =>' data/4 /* Выведет на экран: "100, разделенное на 4 => 25" */

SELECT

Инструкция SELECT используется для условного выполнения одной из нескольких альтернативных инструкций.

По очереди вычисляется каждое выражение после фразы WHEN. Результат вычисления должен быть равен 0 или 1. Если результат равен 1, то выполняется инструкция, следующая за фразой THEN (которая может быть составной инструкцией, например, IF, DO или SELECT), а затем управление передается фразе END. Если результат равен 0, то управление передается следующей фразе WHEN.

Если ни один из результатов вычисления выражений WHEN не равен 1, то управление передается инструкциям, следующим за OTHERWISE (если они есть). В этом случае отсутствие предложения OTHERWISE приводит к ошибке.

Пример balance = balance - check Select when balance > 0 then say 'Поздравляем! У Вас на счету' balance 'долларов.' when balance = 0 then do say 'Внимание! Баланс равен нулю! ПРЕКРАТИТЕ все траты!' say "Вы подрезали свой счет в этом месяце. Надеемся," say "что Вы не будете подписывать крупные чеки." end Otherwise say "Вы уже перекрыли свой счет." say "Ваш баланс составляет сейчас" balance "долларов." say "Ооо! Остается надеяться, что банк не закроет Ваш счет." end /* Select */

Примечания: В качестве инструкции может выступать любой оператор присваивания, команда или ключевая инструкция, включающая любую более сложную конструкцию, например, DO, IF или SELECT.

Предложение, содержащее пустую строку, не является инструкцией, поэтому указание за WHEN дополнительной точки с запятой не равнозначно помещению в файл фиктивной инструкции. Для этих целей предназначена инструкция NOP.

Слово THEN нельзя использовать внутри выражения, где оно не предназначается для начала предложения, так как ключевое слово THEN обрабатывается иначе. Если же оно используется, то это может привести к завершению выражения в предложении WHEN посредством слова THEN, указанного без требуемого разделителя ";".

SIGNAL

Инструкция SIGNAL используется для выполнения аварийного изменения потока управления или, если указаны ON или OFF, для управления отслеживанием некоторых условий.

Для управления отслеживанием укажите OFF или ON и условие, которое Вы хотите отследить. Значение OFF прекращает процесс отслеживания указанного условия. Значение ON запускает процесс отслеживания указанного условия.

Прим. Для получения информации по отслеживанию требуемых условий обращайтесь к документу Язык процедур 2/REXX для OS/2. Справочник.

Чтобы изменить поток управления, имя метки выбирается из имени-метки или принимается как результат вычисления выражения, следующего за VALUE. В качестве имени-метки можно указать символ, трактующийся буквально, или текстовую строку, которая является константой. Вложенное ключевое слово VALUE можно опустить, если выражение не начинается символом или текстовой строкой (например, если оно начинается со специального знака, такого как оператор или скобка). Все активные незавершенные инструкции DO, IF, SELECT и INTERPRET в текущей программе завершаются; т.е. их невозможно активизировать повторно. Затем управление передается первой метке в программе, которая соответствует требуемой строке.

Пример: Signal fred; /* Переходит на метку "FRED" */ .... .... Fred: say 'Привет!'

Так как поиск обычно начинается с начала программы, то при наличии нескольких одинаковых меток управление всегда передается первой метке в программе, которая соответствует указанной.

Когда управление передается на указанную метку, специальной переменной SIGL присваивается значение, равное номеру строки с инструкцией SIGNAL. Это помогает при отладке программы, так как можно определить, откуда был выполнен переход на метку.

Использование SIGNAL с инструкцией INTERPRET

Если инструкция SIGNAL выдается как результат выполнения инструкции INTERPRET или происходит событие, которое отслеживается, то остаток интерпретируемой строки не просматривается с целью поиска указанной метки. В действительности метки внутри интерпретируемых строк игнорируются.

TRACE

Альтернативная форма:

Инструкция TRACE используется для отладки. Она управляет трассировкой событий (т.е. выводом процесса их выполнения), имеющих место при работе программы REXX. Синтаксис инструкции TRACE более сжатый и конкретный, в отличие от других инструкций языка REXX. Немногочисленность ключевых слов, используемых в данной инструкции, особенно удобна, так как TRACE обычно вводится вручную в процессе диалоговой отладки.

Число представляет собой целое число.

Результатом вычисления строки или выражения может быть: Число Один из действительных префиксов, алфавитных режимов (слов), либо и то, и другое, как показано на данной панели. Ноль.

Символ является константой и может представлять собой: Число Один из действительных префиксов, алфавитных режимов (слов), либо и то, и другое, как показано на данной панели.

Действие трассировки определяется указанным режимом инструкции TRACE или результатом вычисления выражения. При наличии выражения можно опустить вложенное ключевое слово VALUE, если выражение начинается со специального символа или оператора (во избежание ошибок для символа или строки).

Алфавитные режимы (слова)

Несмотря на то, что режим можно задать полным словом, значащей является только первая прописная буква; остальные буквы игнорируются. Поэтому эти режимы и называются алфавитными.

Ниже приведено соответствие алфавитных режимов и действий, выполняемых при этом инструкцией TRACE: