- MODULO BÁSICO –
2. REXX – CONCEITOS GERAIS 3. REXX - COMPONENTES (Clausulas) 4. REXX - TIPOS DE INSTRUÇÕES 5. REXX – SINTAXE DE INSTRUÇÕES 6. REXX – O USO DE INSTRUÇÕES 7. REXX - VARIÁVEIS E EXPRESSÕES
8. REXX - VARIÁVEIS COMPOSTAS E STEMS 9. REXX - VARIÁVEIS ESPECIAIS
10. REXX – OPERADORES ARITMÉTICOS 11. REXX – OUTROS OPERADORES
12. REXX - CONTROLANDO FLUXO DO PROGRAMA 13. REXX -FUNÇÕES Internas(“Built-in functions” ) 14. REXX – O USO DE FUNÇÕES Internas
15. REXX - FUNÇÕES Externas
16. REXX – O USO DE FUNÇÕES Externas
17. REXX - PASSANDO INFORMAÇÕES A UM EXEC 18. REXX – ACESSAR E ARMAZENAR DADOS 19. REXX - COMANDOS
20. REXX - O USO DE COMANDOS 21. REXX - ALOCANDO ARQUIVOS
22. REXX - EXECUTANDO INPUT/OUTPUT 23. REXX - TABELA DE FUNÇÕES
REXX é uma linguagem de programação interpretada, criada pela IBM em 1979.
É uma linguagem estruturada de alto nível para ambiente multi-plataforma como servidores e mainframes e extremamente versátil.
Aspectos como a estrutura de programação comum e o formato livre, fazem com que a REXX seja uma ferramenta interessante tanto para iniciantes como para experientes programadores.
A linguagem pode ser utilizada em diversos ambientes IBM:
• MVS (TSO/E,APPC/MVS,batch,CICS TS,IMS )
•VM CMS
•Operating System/400 (OS/400)
•Operating System/2 (OS/2)
•WINDOWS
➢Características de REXX
✓Facilidade de utilização: As instruções de REXX são as palavras comuns, tais como a SAY, PULL, IF...THEN... ELSE..., DO... END, e EXIT.
✓Formato livre: Há poucas regras sobre o formato de REXX. Não é necessário começar uma instrução em uma coluna particular, podem ser escritas mais de uma instrução por linha, uma instrução em várias linhas, identação não obrigatória.
✓Funções Internas (built-in functions): REXX fornece funções internas que executam pesquisas e comparações, cálculos aritméticos e outras.
REXX - INTRODUÇÃO
✓Capacidade de Debug : Quando um exec de REXX, que funciona em TSO/E encontra um erro, mensagens que descrevem o erro são indicadas na tela. Pode-se utilizar instrução TRACE de REXX com facilidades de debug interativo, facilitando encontrar os erros.
✓Linguagem Interpretada: TSO/E executa REXX como uma linguagem interpretada. Pode-se também utilizar um compilador IBM com algumas vantagens tais como: melhoria de performance, redução da carga no sistema, proteção para o código fonte, portabilidade de programas compilados.
➢ O QUE É UMA REXX EXEC
Uma EXEC consiste em um conjunto de instruções na linguagem REXX . Inicia com uma linha de comentário /*REXX*/.
O delimitador que indica comentário é o /* no início da linha e o */ ao final da linha.
+--- Exemplo de REXX ---+
/**************************** REXX *********************************/
/* This exec adds two numbers and displays their sum. */
/*******************************************************************/
SAY ‘Digite o 1 numero'
PULL numero1 -> Digitado 7 SAY ‘Digite o 2 numero '
PULL numero2 -> Digitado 8 soma = numero1 + numero2
SAY ‘A soma eh ‘ soma '.’
➔ aparecerá na tela -> A soma eh 15 +---+
➢ Escrevendo um EXEC
✓ Use o EDIT do TSO.
✓ Tomemos como exemplo um programa de conversação:
✓ O nome do programa será MYEXEC.
✓ No ambiente TSO, acessar um particionado previamente alocado (BIBREXX) e editar um membro que terá o programa
/************************** REXX ***********************************/
/* Este é um prog. REXX interativo que pergunta ao usuário */
/* o nome de um animal e mostra a resposta na tela. */
/********************************************************************/
SAY “Por favor, digite o nome de um animal."
PULL animal /* Guarda o nome digitado */
SAY animal /* mostra na tela o nome */
✓ Salvar o membro do PDS.
✓ Agora o seu programa está pronto para rodar.
REXX – CONCEITOS GERAIS
➢ Ambientes (Environments):Em REXX pode-se executar comandos de TSO/E ou não TSO/E (ex.: MVS, ISPF). Para saber qual o ambiente corrente (Address Space) , utilizar a função ADDRESS(). Para mudar de ambiente utilizar a instrução ADDRESScomo:
✓ “ADDRESS MVS” ➔COMANDOS DO MVS;
✓ “ADDRESS ISPEXEC” ➔COMANDOS DE EXECUÇÃO NO ISPF
➢ Interpretando Mensagens de Erro: Quando é rodado um EXEC REXX.EXEC(HELLO),que contenha um erro, uma mensagem indica a linha em que o erro ocorreu e dá uma explanação sobre ele. As mensagens podem resultar dos erros da sintaxe e dos erros computacionais. Exemplo: o seguinte exec tem um erro da sintaxe, pois não está com */ fechando o comentário na linha 7.
************************** REXX ***********************************/
/* este eh um exec interativo de REXX que pede ao usuario o */
/* nome e cumprimenta o usuario com o nome fornecido. */
/* contem um erro deliberado. */
/******************************************************************/
SAY “Olá! Qual o seu nome?"
PULL QUEM /* guarda o nome em QUEM.
IF QUEM = '' THEN SAY ‘Olá estranho!' ELSE
SAY ‘Olá' QUEM
Quando este EXEC for rodar, aparecerá uma tela com erro:
Olá! Qual o seu nome??
7 +++ PULL QUEM /* Guarda o nome em QUEM.IFQUEM = '' THEN SAY 'OLA ESTRANHO!'
SAY 'Hello' who
IRX0006I Error running REXX.EXEC(HELLO), line 7: Unmatched "/*" or quote
➢ Depuração– Utiliza-se a instrução TRACE seguido do parâmetro que indicará o modo de ação da depuração como: All , Comands, Error, Failure, Intermediates, Label, Normal, Off, Results, Scan .
Para utilizar o Trace Interativo, utilizar o símbolo ? EX: TRACE ?I. Para finalizar um procedimento de depuração, utiliza-se a instrução TRACE OFF.
Exemplo:
000001 /************************* REXX *****************************/
000002 x = 9 000003 y = 2 000004 TRACE I 000005
000006 IF x + 1 > 5 * y THEN 000007 SAY 'x is big enough.'
000008 ELSE NOP /* No operation on the ELSE path */
******* ********************** BOTTOM OFDATA *****************************
Quando executado este exemplo, poderá ser visto na tela:
9 *-* IF x + 1 > 5 * y
>V> "9“ ➔ (valor da variável x)
>L> "1“ ➔ (valor da literal 1)
>O> "10“ ➔ (resultado da operacao x + 1)
>L> "5“ ➔ (valor da literal 5)
>V> "2“ ➔ (valor da variável y)
>O> "10“ ➔ (resultado da operacao 5 * y)
>O> "0“ ➔ (resultado final da operacao 10 > 10 is false)
➢ INSTRUÇÕES
•Uma instrução consiste em um ou mais cláusulas que descreve algum curso de ação para o processador executar.
São 5 tipos:
1. NULLS - Comentários ou brancos são cláusulas nulas (ignoradas pelo interpretador).
2. LABELS- Conjunto de caracteres seguido por dois pontos . Indica um nome de parágrafo. São usados por instruções de transferência. Mais de uma palavra em um nome de parágrafo deve ser separada por “underline”.
Ex. PARAGRAFO: LER_ARQ_CMS:
3. ASSIGNMENT ( Atribuições ) - São clausulas como: símbolo=expressão Usados para atribuir valor a variáveis . 4. KEYWORD -São as palavras que compõem o vocabulário “REXX”. Uma instrução keyword diz para o
processador de língua para fazer algo . EX. say ' QUAL O SEU NOME' ; DO...instrução... END
5. COMANDOS- Uma instrução que não é uma keyword, um assinalamento, um label ou uma cláusula nula é processado como um comando e enviado para processamento em um ambiente (environment) previamente definido.
➢ REXX Built-in Functions - São FUNÇÕES INTERNASdo “interpretador”. Sempre retornam um valor.
➢ External System Functions–São as FUNÇÕES EXTERNAS, escritas pelos usuários.
➢Data Stack Functions– (Pilha de Dados) -Uma Data Stack pode armazenar dados para I/O e outros tipos de processamentos.
000001 /********* REXX *********************************/
000002 /* REXX exec interativo que pergunta ao usuário */
000003 /* a hora atual, e mostra a hora do sistema . */
000004 /************************************************/
000005 Game1:
000006 000007 SAY 'What time is it?' 000008 PULL usertime
000009 000010
000011 IF usertime = '' THEN 000012 SAY "O.K. Game's over."
000013 ELSE 000014 DO
000015 SAY "The computer says:"
000016 /* TSO system */ TIME /* command */
000017 END 000018 000019 EXIT
➢Keyword: Diz ao interpretador para fazer algo.
•(linha7)SAY=> exibir string na tela
•(linha8)PULL=>“pegar” uma ou mais palavras da entrada e colocar em uma variável (no caso usertime) .
•IF,THEN(linha 11) eELSE(linha 13) são keywords que trabalham juntas em uma instrução.
•Cada keyword forma uma cláusula que é uma parte da instrução.
• Se a expressão que segue o keyword IFfor verdadeira, a instrução que segue oTHEN será processada. Em outro caso, a instrução que segue o ELSEé que será processada.
•Se mais de uma instrução irá seguir oTHENou oELSE, a keywordDO deverá preceder esta instrução (linha 14) e no final deverá haver umEND (linha 17).
A keywordEXIT(linha 19) diz ao processador finalizar a exec.
➢Assinalamento: Um assinalamento atribui um valor à uma variável.
Ex.: number = 4 number = 4 + 4 number = number + 4
No primeiro exemplo a variável number irá conter o valor 4; no segundo o valor será o resultado da operação(8), no terceiro será o valor da variável acrescido de 4 resultado 8.
➢Label: (linha5)Game1:- Nome do parágrafo. Os Labels são usados por instruções de transferência.
➢Comentários: (linhas 1 a 4, linhas 8 a 11, 16)
➢Comando : (linha 16) – Uma instrução que não é uma keyword, um assinalamento, um label ou uma cláusula nula é processado como um comando e enviado para processamento em um ambiente (environment) previamente definido.
Por exemplo, a palavra TIME (linha 16) está entre comentários e será processada como um comando do ambiente TSO/E . Mais detalhes sobre comandos no tópico 2.1.
✓ Uma instrução REXX pode conter caracteres maiúsculos, minúsculos ou mistos.
✓ Uma série de caracteres entre aspas, é chamada de uma string literal, pode conter no máximo 250 caracteres.
Ex. SAY 'This is a REXX literal string.' /* Usando aspas simples */
SAY "This is a REXX literal string." /* Usando aspas duplas */
SAY "This isn't a CLIST instruction.“
✓ Em uma linha geralmente há uma instrução exceto quando termina com uma vírgula (,) ou um ponto e vírgula (;).
✓ Uma instrução pode começar em qualquer linha ou coluna.
✓ Uma vírgula indica que a instrução continua à linha seguinte.
✓ Duas barras( ||) indica operando de concatenação.
SAY 'Este é um string literal que foi que'||,
'brado.‘ ==> 'Este é um string literal que foi quebrado’
✓ O fim da linha ou um ponto e vírgula indicam o fim de uma instrução. Para se colocar mais de uma instrução sobre uma linha, estas devem ser separadas com um ponto e vírgula.
SAY 'Hi!‘ ; say 'Hi again!‘ ; say 'Hi for the last time!'
Uma variável é um caracter ou um grupo de caracteres que representam um valor.
•As variáveis podem ser:
✓A...Z Caracteres alfabéticos Maiúsculos
✓a...z Caracteres alfabéticos Minúsculos
✓0...9 Caracteres numéricos
✓@ # $ ¢ ? ! . _ Caracteres Especiais
✓X'41' ... X'FE' double-byte character set (DBCS).
•Restrições:
✓O primeiro caracter não pode ser 0 a 9 e nem ponto;
✓Não pode exceder tamanho de 255 bytes.
Valores em variáveis :
✓Inteiros (12) , Decimais (12.5) , Sinalizado ( -12 ) , Literal ( ‘ 12 ‘), Números flutuantes (1.25E2) .
✓String : uma ou mais palavras entre aspas ou não.
✓Valor de outra variável : variavel1 = variavel2
✓Uma expressão : variavel2 = 12 + 12
✓Antes que uma variável esteja atribuída de um valor, seu valor será seu próprio nome traduzido a caixa. Ex.: variável NOVA sem valor atribuído, no comando SAY será exibido a palavra NOVA.
➢As variáveis compostas são uma maneira criar uma array dimensional ou uma lista das variáveis em REXX.
➢Uma variável composta contem no nome ao menos um ponto com caracteres em ambos os lados. Exemplos : FRED.5 Array.Row.Col
employee.name.phone
➢Ao trabalhar com variáveis compostas, é frequentemente útil inicializar uma coleção inteira das variáveis com o mesmo valor. Isto pode ser feito facilmente com uma STEM. Por exemplo, para mudar todos os nomes da STEM NOMES. para NINGUEM , utilizar a seguinte instrução de assinalamento:
NOMES. = ' Ninguem '
Em conseqüência, todas as variáveis compostas que começam com NOMES. , retornam o valor Ninguem.
SAY nome.5 /* Displays ' Ninguem ' */
SAY nome.10 /* Displays ' Ninguem ' */
➢Para limpar todas as variáveis da stem:
✓ usar a instrução da DROPcomo segue, que ajusta todas as variáveis da stem ao seu estado inicial.
DROPNOMES.
✓ajustar todas as variáveis da stem para nulo como segue:
NOMES. = ''
1. Após essas instruções de assinalamento, o que será exibido seguindo a instrução SAY?
A = 3 ; B = 4 ; C = 'last' A.B = 2 ; A.C = 5 ; X.A.B = 'cv3d' a) SAY 'A = ' A
b) SAY 'B = ' B c) SAY 'C = ' C d) SAY 'A.A = ' A.A e) SAY 'A.B = ' A.B f) SAY 'B.C = ' B.C g) SAY 'C.A = ' C.A h) SAY 'A.FIRST = 'A.FIRST i) SAY 'X.A.4 = 'X.A.4 j) SAY 'X.B = 'X.B k) SAY 'X.3.4 = ' X.3.4
2.Após esses assinalamentos, o que será exibido?
HOLE.1 = ‘FULL’ ; HOLE. = ‘EMPTY’ ; HOLE.S = ‘FULL’
a)SAY 'HOLE.1 = 'HOLE.1 b)SAY 'HOLE.S = 'HOLE.S c)SAY 'HOLE.MOUSE = 'HOLE.MOUSE
Respostas (1.) Respostas (2.)
a) A = 3 a) HOLE.1 = EMPTY
b) B = 4 b) HOLE.S = FULL
c) C = LAST c) HOLE.MOUSE = EMPTY d) A.A = A.3
e) A.B = 2 f) B.C = B.LAST g) C.A = C.3 h) A.FIRST = A.FIRST i) X.A.4 = CV3D
➢ Existem três variáveis especiais em “REXX”. Estas variáveis são “setadas”
automaticamente pelo “interpretador”.
➢ VARIÁVEL RC : RETURN CODE– É setada sempre que um comando é executado.
O valor de “RC” pode ser testado para verificar o que aconteceu após a emissão do comando.
➢ VARIÁVEL RESULT: É setada pela instrução “RETURN” de uma rotina chamada anteriormente. Contem o valor de uma variável de retorno da subrotina.
➢ VARIÁVEL SIGL:Contém o número da linha, da última instrução de transferência dada. Quando um SIGNAL ou CALL de uma rotina for executada, a variável SIGL guarda o número da linha desta instrução de transferência.
+ Adição - Subtracão
* Multiplicação / Divisão
% Divide e retorna número inteiro sem o resto
// Divide e retorna somente o resto.
** Exponenciação
-number Número negativo +number Número positivo
•PRIORIDADES
:
- + (Sinalização)
** (Exponencial)
* / e % // (Multiplicação e Divisão) + - (Adição e subtração)
Expressões entre parêntesis são avaliadas primeiro. EX:
7 + 2 * (9 / 3) - 1
\___/
3 7 + 2 * 3 - 1
\___/
6
7 + 6 - 1 = 12
➢ DE COMPARAÇÃO
= IGUAL
\=, ¬=,/= DIFERENTE
> MAIOR QUE
< MENOR QUE
><,<> MAIOR OU MENOR (Diferente)
\<, ¬< NÃO MENOR (> OU =)
\>, ¬> NÃO MAIOR (< OU =)
<= MENOR OU IGUAL
>= MAIOR OU IGUAL
➢ LÓGICA(BOOLEANOS)
& AND
| OR
&& EXCLUSIVE OR
\, ¬(prefixo) NOT LÓGICO
➢ DE CONCATENAÇÃO
Utiliza-se o símbolo ||
Ex.: A = Ma, B= ria, C=A||B, C=Maria,
+---+
¦ ¦
¦ >>--ADDRESS---;--->< ¦
¦ +-environment---¦ ¦
¦ ¦ +-expression-+ ¦ ¦
¦ +---expression1---+ ¦
¦ +-VALUE-+ ¦
¦ ¦ +---+
Usada para identificar o destino de comandos. Environment é o nome de um ambiente especificado.
Se expression for especificadO, o ambiente será “setado” temporariamente. Se expression não for especificada, o ambiente será “setado” permanentemente, até o próximo comando “ADDRESS”.
VALUEé usado quando queremos fazer uma montagem do nome do ambiente.
Ex:
LIBX = “’TSO.ISPF.”SYSVAR(SYSUID)”.LIB(MEM1)’”
ADDRESS TSO
“ DELETE” LIBX
+---+
¦ ¦
¦ >>--CALL----name---;--->< ¦
¦ ¦ +-expression-+ ¦ ¦
¦ +-OFF----ERROR---¦ ¦
¦ ¦ +-FAILURE-¦ ¦ ¦
¦ ¦ +-HALT----+ ¦ ¦
¦ +-ON----ERROR---+ ¦
¦ +-FAILURE-¦ +-NAME--trapname-+ ¦
¦ +-HALT----+ ¦
¦ ¦ +---+
Usada para chamar uma rotina que pode ser interna, externa, programa “REXX”, função “REXX” ou função do
programador. “name” é o nome da rotina. Se “name” estiver entre aspas, será chamado somente uma rotina externa.
Dez expressões separadas por vírgula podem ser especificadas. As “expressões” podem ser omitidas.
A instrução “PROCEDURE” pode ser usada, quando chamamos uma rotina interna, para que não haja confusão entre as variáveis. RETURN é usada para retorno à rotina principal. Se “RETURN” especifica uma expressão, a variável RESULT será setada com o valor da expressão. Rotinas internas podem chamar rotinas internas. O total de
“ninhos” de estrutura de rotinas internas não pode exceder a 250.
Ex:
/* CALCULO DE VOLUME */
COMPRIMENTO = 10 LARGURA = 5 ALTURA = 2
CALL VOLUME COMPRIMENTO, LARGURA, ALTURA SAY “O VOLUME É “ RESULT
EXIT
VOLUME: PROCEDURE ARG A, B, C
CONTA = A * B * C RETURN CONTA
+---+
¦ ¦
¦ ¦
¦ >>--DO---;---> ¦
¦ +-¦ repetitor +-+ +-¦ conditional +-+ ¦
¦ ¦
¦ >---END---;--->< ¦
¦ ¦ <---+ ¦ +-name-+ ¦
¦ +---instruction---+ ¦
¦ ¦
¦ repetitor: ¦
¦ +----name=expri---¦ ¦
¦ ¦ +-TO--exprt-+ +-BY--exprb-+ +-FOR--exprf-+ ¦ ¦
¦ +-FOREVER---¦ ¦
¦ +-exprr---+ ¦
¦ ¦
¦ conditional: ¦
¦ +----WHILE--exprw---¦ ¦
¦ +-UNTIL--expru-+ ¦
¦ ¦ +---+
Usado para executar um grupo de instruções juntas, podendo executá-las repetidas vezes (LOOP).
“NAME é chamada de variável de controle do “DO”. “EXPR” são expressões que resultem em um número. Em
“instruction” podem aparecer “IF” , “SELECT” , ou “DO”. “TO” , “BY” , “FOR” , “WHILE”, “UNTIL” e “FOREVER” são palavras exclusivas da instrução “DO”. Se “WHILE” for usada, a variável de controle será testada antes das
execuções das instruções. Se “UNTIL” for usada, a variável de controle será testada depois da execução das instruções.
+---+
¦ ¦
¦ <---+ ¦
¦ >>--DROP---name---;--->< ¦
¦ +-(name)-+ ¦
¦ ¦ +---+
Usada para liberar variáveis, retornando a ser apenas símbolos sem valor.
“NAME” indica o nome de uma variável. As variáveis serão liberadas da esquerda para a direita.
Nenhum erro ocorrerá, se um nome de variável for especificado mais de uma vez ou não existir.
EX:
NUMERO = 523 DROP NUMERO SAY NUMERO
/* SERÁ MOSTRADA A PALAVRA “NUMERO” */
/* E NÃO O VALOR “523” */
+---+
¦ ¦
¦ >>--EXIT---;--->< ¦
¦ +-expression-+ ¦
¦ ¦ +---+
A instrução EXITcausa um término incondicional de uma EXEC e o retorno para onde o EXEC foi chamado. Se o EXEC for chamado por um programa, tal como um outro EXEC, EXIT retornará ao programa chamador. Se expressão for especificada, deverá resultar em um valor que será passado para o programa chamador.
Ex: J = 3
EXIT J * 4 /* RETORNARA O VALOR “12” */
---+
¦ ¦
¦ >>--IF--expression---THEN---instruction---> ¦
¦ +-;-+ +-;-+ ¦
¦ ¦
¦ >--->< ¦
¦ +-ELSE---instruction-+ ¦
¦ +-;-+ ¦
¦ ¦ +---+
• IFcondiciona a execução de uma instrução ou grupo de instruções. A expression é avaliada e resultado pode ser 1 (verdadeiro) ou 0 (falso). THENexecuta se verdadeiro e ELSEquando falso. Caso haja um grupo de instruções a serem executadas, estas devem ser delimitadas por DO ... END.
IFexpression THEN DO
Instruction
IF expression THEN instruction ELSE
Instruction END
ELSE
Instruction
+---+
¦ ¦
¦ >>--INTERPRET--expression--;--->< ¦
¦ ¦ +---+
Usada para executar instruções que terão de ser construídas dinamicamente, pela avaliação de
“expressão” . Expressão é analisada, inserida dentro do programa e então executada.
“INTERPRET” é requerido em casos especiais, quando mais de uma instrução for ser interpretada ao mesmo tempo.
answer = 5 + 5
INTERPRET 'say' answer ' "= 5 + 5" ' /* displays 10 = 5 + 5 */
action = 'DO 3; SAY "Hello!"; END'
INTERPRET action /* results in:
Hello!
Hello!
Hello! */
---+
¦ ¦
¦ >>--NOP--;--->< ¦
¦ ¦ +---+
É uma instrução usada para tornar uma estrutura que use “THEN”, “ELSE’ ou “OTHERWISE”
sintaticamente correta, quando em uma condição não há ação a ser executada.
EX:
SELECT
WHEN A = B THEN NOP ➔nenhuma ação será executada WHEN A > B THEN SAY ‘A >B’
OTHERWISE SAY ‘A < B’
END
¦ ¦
¦ >>--PROCEDURE---;--->< ¦
¦ ¦ <---+ ¦ ¦
¦ +-EXPOSE---name---+ ¦
¦ +-(name)-+ ¦
¦ ¦ +---+
É usada em subrotinas e funções, definidas internamente em um programa “REXX”. Esta instrução salva as variáveis da rotina principal, permitindo que subrotinas e funções internas façam uso das mesmas variáveis. Ao ser executada a instrução “RETURN” , as variáveis da rotina principal são restauradas, e as da subrotina ou função são perdidas.
Ex:
/* A VARIÁVEL “A” NÃO ESTÁ PROTEGIDA */
A = 10; B = 20; C = 30
CALL SUBROTINA /*SERÁ MOSTRADO*/
SAY A B C 12 20 30 EXIT
SUBROTINA: PROCEDURE EXPOSE A A = A +2 ; B = 200
C = B + 50 /*SERÁ MOSTRADO*/
SAY A B C 12 200 250
RETURN
+---+
¦ ¦
¦ >>--SAY---;--->< ¦
¦ +-expression-+ ¦
¦ ¦ +---+
O resultado de “expression” será exibido no terminal. Caso “expression” não seja uma variável com conteúdo, a própria palavra será mostrada.
Ex:
Data = 100
SAY DATA ‘DIVIDIDO POR 4 => ‘DATA/4 /* SERÁ MOSTRADO */
100 DIVIDIDO POR 4 => 25
SAY ‘”AGORA VAMOS MOSTRAR UMA FRASE”’
/* SERÁ MOSTRADO */
”AGORA VAMOS MOSTRAR UMA FRASE”
+---+
¦ ¦
¦ <---+ ¦
¦ >>--SELECT;----WHEN--expression---THEN---instruction---> ¦
¦ +-;-+ +-;-+ ¦
¦ ¦
¦ >---END--;--->< ¦
¦ +-OTHERWISE---+ ¦
¦ +-;-+ ¦ <---+ ¦ ¦
¦ +---instruction---+ ¦
¦ ¦ +---+
Usada para selecionar uma opção. Cada instrução seguinte a um “WHEN” é analisada resultando em “0” ou “1”, FALSO ou VERDADEIRO. Se o resultado for “1”, a instrução seguinte ao “THEN” será executada. O controle passa para a instrução seguinte ao “END”. Se o resultado for “0”, o controle passa para o próximo “WHEN”. Se nenhum
“WHEN” for verdadeiro, o controle passará para as instruções seguintes ao “OTHERWISE”. Neste caso, se
“OTHERWISE” for omitido causará erro. Sempre deve ser encerrado com END. SELECT
WHEN expression THEN instruction WHEN expression THEN instruction WHEN expression THEN instruction .
.
OTHERWISE instruction(s)
+---+
¦ ¦
¦ >>--SIGNAL----labelname---;--->< ¦
¦ +---expression---¦ ¦
¦ ¦ +-VALUE-+ ¦ ¦
¦ +-OFF----ERROR---¦ ¦
¦ ¦ +-FAILURE-¦ ¦ ¦
¦ ¦ +-HALT----¦ ¦ ¦
¦ ¦ +-NOVALUE-¦ ¦ ¦
¦ ¦ +-SYNTAX--+ ¦ ¦
¦ +-ON----ERROR---+ ¦
¦ +-FAILURE-¦ +-NAME--trapname-+ ¦
¦ +-HALT----¦ ¦
¦ +-NOVALUE-¦ ¦
¦ +-SYNTAX--+ ¦
¦ ¦ +---+
Instrução de transferência incondicional. Interrompe o fluxo normal de um EXEC passando o controle a um LABEL especificado. Não retorna para uma instrução específica para recomeçar a execução. Quando usado dentro de um loop este termina automaticamente; e quando você usa o SIGNAL de uma rotina interna, esta não retornará a seu chamador. A procura de LABELNAME começa no início do programa.
Ex:
/* SIGNAL SIMPLES */ /* SIGNAL PARA PARAGRAFO ESPECIAL */
... ...
SIGNAL MOSTRA SIGNAL ON ERROR
... ...
MOSTRA:
SAY ’TRANSFERENCIA INCONDICIONAL’ DELETE TESTE /*NÃO EXISTE ESTE ARQUIVO*/
...
ERROR:
SAY ‘ARQUIVO NAO EXISTE’
+---+
¦ ¦
¦ ¦
¦ >>--TRACE---;--->< ¦
¦ ¦ +-number-+ ¦ ¦
¦ ¦ +-Normal---+ ¦ ¦
¦ +---+---+-+ ¦
¦ ¦ <---+ ¦ +-All---¦ ¦
¦ +----?----+ +-Commands---¦ ¦
¦ +-!-+ +-Error---¦ ¦
¦ +-Failure---¦ ¦
¦ +-Intermediates-¦ ¦
¦ +-Labels---¦ ¦
¦ +-Off---¦ ¦
¦ +-Results---¦ ¦
¦ +-Scan---+ ¦
¦ Or, alternatively: ¦
¦ ¦
¦ ¦
¦ >>--TRACE---;--->< ¦
¦ +-string---¦ ¦
¦ +-symbol---¦ ¦
¦ +---expression-+ ¦
¦ +-VALUE-+ ¦
¦ ¦ +---+
Usada para depuração de um programa REXX. A ação de depuração é determinada pela opção seguinte à instrução
“TRACE”. Somente a primeira letra de uma palavra é necessária. “TRACE” pode ser colocado em qualquer parte do programa. “NUMBER” é um número inteiro. “STRING” ou “EXPRESSÃO” pode ser uma opção numérica, um prefixo ou palavra mostrada acima,ou nulo. “SYMBOL” pode ser uma opção numérica, um prefixo ou palavra mostrada acima.
---+
¦ ¦
¦ <---+ ¦
¦ >>--UPPER----variable----;--->< ¦
¦ ¦ +---+
Usada para passar o conteúdo de uma ou mais variáveis para maiúsculo.
Ex:
/* ADMITINDO QUE AS VARIAVEIS “A” E “B” */
/* TENHAM VALORES MINUSCULOS, ENTÃO: */
A = “Ola”
B = “amigo”
UPPER A B
/* “A” E “B” PASSARÃO A TER VALORES MAIÚSCULOS, ou seja, A = “OLA” ; B = “AMIGO”
+---+
¦ ¦
¦ >>--RETURN---;--->< ¦
¦ +-expression-+ ¦
¦ ¦ +---+
Usada para retornar o controle a um programa “REXX”. Finaliza uma subrotina ou uma função, e retorna ao programa principal, na instrução seguinte ao ponto onde foi chamado. Se “expression” for especificada, será achado seu valor e a variável expecial RESULT assumirá este valor .
Se “RETURN” for dado em uma função, “expression” tem que ser especificada. Isto lembra que toda função retorna um valor.
Ex:
CALL SUBROTINA /*SERÁ MOSTRADO*/
SAY RESULT /* 74 */
EXIT
SUBROTINA:
B = 54 + 20 RETURN B
+---+
¦ ¦
¦ >>--PULL---;--->< ¦
¦ +-template_list-+ ¦
¦ ¦ +---+
Usada para ler o primeiro elemento da fila “STACK AREA” ou para receber dados via terminal.
“PULL” passa os dados alfabéticos para letras maiúsculas e atribui estes dados `as variáveis de acordo com o especificado em “TEMPLATE”.
EX:
/* Recebe dados do “BUFER” DE TERMINAL */
SAY ‘VOCE QUER DELETAR O ARQUIVO? SIM OU NÃO’
PULL RESPOSTA
IF RESPOSTA = SIM THEN SIGNAL DELETA ELSE NOP
EXIT
/* Se na “STACK AREA” tiver : PROGRAMA,EXEC, 1243 */
PULL NOME ‘,’ TIPO ‘,’ VALOR
/* NAS VARIÁVEIS FICARÃO: NOME= PROGRAMA TIPO= EXEC VALOR = 1243
*/
➢Usando Interação com o terminal ( PULL)
/**************************** REXX *******************/¦
/*This exec adds two numbers and displays their sum. */¦
/*****************************************************/¦
SAY 'Please enter two numbers.' PULL number1 number2 sum = number1 + number2 SAY 'The sum of the two numbers is' sum'.' +---+
✓ Na invocação da execução ( EXEC) EXEC rexx.exec(add) '42 21'
Esses valores (42 e 21), são chamados de argumentos. A instrução ARG é usada para receber esses valores como no exemplo:
/******************* REXX***********************/
/*This exec receives two numbers as input,adds */
/*them, and displays their sum. */
/******************* REXX***********************/
ARG number1 number2 sum = number1 + number2 SAY 'The sum of the two numbers is' sum'.' +---+
➢ Geralmente, para diferenciar comandos de outros tipos de instruções, coloca-se o comando entre aspas duplas ou aspas simples. Ao emitir comando TSO/E em um exec, é recomendado que se coloque entre aspas duplas.
➢ Se o comando não estiver dentro das aspas, será processado como uma expressão e pode terminar com erro. Por exemplo, uma palavra seguida imediatamente por um parêntese esquerdo é processada como uma chamada de função.
➢ Diversos comandos TSO/E, um deles é ALLOCATE, requerem os keywords seguidos por parênteses.
"ALLOC DA(NEW.DATA) LIKE(OLD.DATA) NEW"
➢ Se o comando ALLOCATE no exemplo acima não fosse colocado entre aspas, os parênteses indicariam ao processador que DA e LIKE eram chamadas de função, e o comando terminaria em um erro.
Ex.:
"EXEC myrexx.exec(add) '25 78 33' exec"
"ALLOC DA('USERID.MYREXX.EXEC') F(SYSEXEC) SHR REUSE“
➢Quando uma variável é usada em um comando de TSO/E, a variável não pode ser colocada entre aspas se seu valor tiver que ser substituído. Somente variáveis fora das aspas são processadas pelo processador de linguagem.
Por exemplo, para a variável nameé atribuído o data set name MYREXX.EXEC. Quando a variável nameé usada no comando LISTDS por exemplo, deve ficar fora das aspas colocadas em torno do comando.
name = myrexx.exec
"LISTDS" name "STATUS"
➢Quando uma variável representa um data set name qualificado, o nome deve ser colocado entre duas aspas simples ou apóstrofes
name = "'project.rel1.new'"
"LISTDS" name "STATUS"
• Uma outra maneira:
name = project.rel1.new
"LISTDS ' "name" ' STATUS"
➢ LOOP simples
IF A=3 THEN /* se A for igual a 3 o DO será executado */
DO A=A+2
SAY A ===➔Será mostrado 5 END
➢ LOOP Simples Repetitivo:
DO 5
SAY 'Hello!’ /* Será mostrado Hello 5 vezes */
END
➢ LOOP Repetitivo Controlado
DO count = 1 to 10 SAY 'Number' count count = count - 1 END
➢ Loop Repetitivo com Controle Interno:
I = 1
DO FOREVER IF I = 3 THEN LEAVE
SAY I I = I + 1
END
➢ LOOP Condicional
• Executa até que expressão seja verdadeira
DO UNTIL expressão instruções
END
• Executa enquanto expressão for verdadeira
DO WHILE expressão instruções
END
➢ LOOP Condicional Repetitivo Controlado
• Executa até que I seja maior que 6 e CT variando de 2 em 2:
DO CT = 1 TO 10 BY 2 UNTIL CT > 6 SAY ct /* Será mostrado 1 3 5 7 */
END
• Executa enquanto X for menor que 6 e X variando de 2 em 2:
DO X = 1 TO 10 BY 2 WHILE X < 6 SAY X/* Será mostrado 1 3 5 */
END
➢Instrução LEAVE
•A instrução LEAVE causa uma saída imediata de um lopp repetitivo.
•O controle vai para a instrução depois do keyword END do loop. Um exemplo de usar a instrução daLEAVEsegue:
DO FOREVER SAY ‘INFORME O DSN E TECLE
ENTER.'
PULL dataset_name
IF DATA = '' THEN LEAVE
ELSE SAY 'DATA SET :' dataset_name
END
➢Instrução ITERATE
A instrução ITERATE interrompe a execução do LOOP e o controle passa ao DO inicial.
Dependendo do tipo de DO, uma variável de controle é incrementada e testada e/ou uma condição é testada para determinar se será repetido o loop. Como a instrução LEAVE, ITERARE é usado dentro do loop.
DO count = 1 TO 10 IF count = 8
THEN ITERATE ELSE
SAY 'Number' count END
➢Instruções CALL / RETURN
A instrução CALL é usada para chamar uma rotina que pode ser interna, externa, programa “REXX”, função
“REXX” ou função do programador. Pode-se chamar rotinas passando argumentos
A instrução “PROCEDURE” pode ser usada dentro de uma rotina interna (sub-rotina ou função). Esta instrução salva as variáveis da rotina principal, permitindo que sub-rotinas e funções internas façam uso das mesmas variáveis. Ao ser executada a instrução “RETURN” , as variáveis da rotina principal são restauradas, e as da sub-rotina ou função são perdidas.
A instrução RETURNinterrompe o fluxo de um EXEC passando o controle a uma sub-rotina internaou externa. Uma sub-rotina interna é parte do EXEC de chamada. Uma sub-rotina externa é um outro EXEC. A instrução RETURN retorna o controle de uma sub-rotina anterior ao EXEC de chamada e retorna opcionalmente um valor na variável RESULT.
➢Instrução EXIT
A instrução EXIT causa um término incondicional de uma EXEC. Se o EXEC for chamado por um programa, EXITretornará ao programa chamador.
Exemplos:
/* CALCULO DE VOLUME */
COMPRIMENTO = 10 LARGURA = 5 ALTURA = 2
CALL VOLUME COMPRIMENTO, LARGURA, ALTURA SAY “O VOLUME É “ RESULT
EXIT
VOLUME: PROCEDURE ARG A, B, C
CONTA = A * B * C RETURN CONTA
➢Built-in functions:– Existem os seguintes tipos:
✓ Funções Aritméticas
✓ Funções de Comparação
✓ Funções de Formatação
✓ Funções de Manipulação de String
✓ Funções Diversas (Miscellaneous Functions)
➢ Funções de manipulação de String
• LENGTH( Retorna o tamanho de um string) LENGTH(’abcdefgh’) -> 8
• POS (Retorna a posição de um caracter dentro do string informado)
POS(’day’,’Saturday’) -> 6 POS(’x’,’abc def ghi’) -> 0 POS(’ ’,’abc def ghi’,5) -> 8
• LEFT/RIGTH /SUBSTR (Retira do string o conteudo informado x posicoes
LEFT(’ abc ’,2) -> ’ab’
RIGHT(’ abcd ’,2) -> ’cd ’
SUBSTR(’Nome de Alguem’,6,2’) -> ’de’
• ABS( Retorna o valor absoluto de um número)
ABS(’12.3’) -> 12.3 ABS(’ -0.307’) -> 0.307
• MAX( Retorna o maior número dentre os informados)
MAX(12,6,7,9) -> 12 MAX(17.3,19,17.03) -> 19
MAX(-7,-3,-4.3) -> -3
➢ Funções de comparação :
• COMPARE( Retorna 0 se strings informadas forem iguais, senão retorna a posição do primeiro caracter diferente).
COMPARE(’abc’,’abc’) -> 0 COMPARE(’abc’,’ak’) -> 2
➢ Funções de Conversão:
• D2X ( Converte valor decimal para Hexa)
D2X(9) -> ’9’ D2X(129) -> ’81
➢ Funções de Formatação
• CENTER/CENTRE(Retorna String centralizado, com preechimento, se solicitado)
CENTER(abc,7) -> ’ ABC ’ CENTER(abc,8,’-’) -> ’--ABC---’
CENTRE(’The blue sky’,8) -> ’e blue s’
CENTRE(’The blue sky’,7) -> ’e blue ’ .
• COPIES (Retorna n cópias do string)
COPIES(’abc’,3) -> ’abcabcabc’
COPIES(’-’,5) -> ’---’
➢ Funções Diversas
• ADDRESS (Retorna o nome do ambiente a que os comandos estão sendo emitidos atualmente).
ADDRESS() ->’TSO’ /* default sob TSO/E */
ADDRESS() ->’MVS’ /* default sob MVS */
• VALUE(name) – Retorna o valor do símbolo name.
/* K = 5 ; fred =‘K’ ; list.5 = ‘HI’ */
VALUE(fred) -> '5' VALUE('LIST.'k) -> 'Hi'
• TIME (Retorna o horário no formato solicitado)
TIME()->’16:54:22’
TIME(’C’)->’4:54pm’
TIME(’H’)->’16’
TIME(’L’)->’16:54:22.123456’ /* Perhaps */
TIME(’M’) ->’1014’ /* 54 + 60*16 */
TIME(’N’)->’16:54:22’
TIME(’S’)->’60862’ /* 22 + 60*(54+60*16) */
▪ DATE ( Retorna uma data no formato solicitado )
Ex. Para data de 13 de Março de 1992:
DATE() -> '13 Mar 1992' DATE(,'19960527','S') -> '27 May 1996' DATE('B') -> '727269' DATE('B','27 May 1996') -> '728805' DATE('C') -> '33675' DATE('E') - > '13/03/92' DATE('J') -> '92073‘
DATE('M') -> 'March' DATE('N') -> '13 Mar 1992' DATE('N','35488','C') -> '28 Feb 1997' DATE('O') -> '92/03/13‘
DATE('S') -> '19920313' DATE('U') -> '03/13/92' DATE('U','96/05/27','O') -> '05/27/96' DATE('U','97059','J') -> '02/28/97' DATE('W') -> 'Friday'
➢ Funções Externas -definidas externamente pelo programador REXX. Você pode também escrever suas próprias funções e também usar funções escritas por outras pessoas em sua instalação. Também recebem argumento, processam e retornam informação
• Chamando uma função externa : X = function(argument1, argument2,...). Resultado ficará em “X”
➢TSO/E External Functions - Além das funções escritas pelo programador REXX, pode-se utilizar outras funções externas para se fazer tarefas específicas. Alguns exemplos:
• LISTDSI (list data set information) – Fornece informações detalhadas sobre atributos de Data Sets.
X = LISTDSI(DSN) ➔ x irá conter Return Code.
A partir da execução desta função, informações sobre o DataSet ‘DSN’ estarão disponíveis. Alguns exemplos:
SYSDSNAME ; SYSDSORG ; SYSRECFM ,
SYSMEMBERS (se parâmetro DIRECTORY foi especificado), etc.
• SYSDSN(dsname) - Informa se um DataSet especificado está disponível para uso. Caso positivo, retorna OK. Senão, retornará mensagem de erro que podem ser: “MEMBER NOT FOUND” , “DATASET NOT FOUND”, etc.
x = SYSDSN("proj.exec(mem1)") IF x =’OK’ THEN
CALL routine1 ELSE
CALL routine2
• OUTTRAP(parms)– Captura linhas de saída de um comando TSO/E , podendo armazenar em variável stem. Exemplo:
X = OUTTRAP('MBR.')
"LISTDS ('"BIBREXX"') MEMBERS"
X = OUTTRAP('OFF')
MBR.1 até MBR.6 = INFORMAÇÕES GERAIS MBR.7 em diante = NOME DOS MEBRO DO DATASET
• REXX em TSO/E usa uma estrutura de dados expansível chamada uma pilha de dados para armazenar a informação (Data Stack ou Stack Area).
• A pilha de dados combina características de uma pilha e de uma fila convencionais. As pilhas e as filas são tipos similares de estruturas de dados usadas para reter temporariamente itens de dados (elementos) até que necessitadas.
• Quando os elementos são necessários, serão removidos do alto da estrutura de dados. A diferença básica entre uma pilha e uma fila é o lugar onde os elementos são adicionados (como mostrado na seguinte figura). Os elementos são adicionados ao alto de uma pilha (top) e ao fundo de uma fila(bottom).
• Usando uma pilha, o último elemento adicionado à pilha (elem6) será removido primeiramente. Porque os elementos são colocados no alto de uma pilha e removidos do alto, os elementos mais novos em uma pilha serão processados primeiramente. A técnica é chamada LIFO(LastInputFirstOutput).
• Usando uma fila, o primeiro elemento adicionado à fila (elem1) será removido primeiramente. Porque os elementos são colocados no fundo de uma fila e removidos do alto, os elementos os mais velhos em uma fila serão processados primeiramente. A técnica é chamadaFIFO(FirstInput FirstOutput).
• Os elementos podem ser colocados no alto ou no fundo de uma pilha de dados. A remoção dos elementos da pilha de dados, entretanto, ocorre do alto da pilha somente (PULL).
Stack Pilha Stack Queue (Fila)
( LIFO ) ( FIFO )
+---¦ +---¦
¦ elem6 ¦ ¦ elem1 ¦ +---¦ +---¦
¦ elem5 ¦ ¦ elem2 ¦ +---¦ +---¦
¦ elem4 ¦ ¦ elem3 ¦ +---¦ +---¦
¦ elem3 ¦ ¦ elem4 ¦ +---¦ +---¦
¦ elem2 ¦ ¦ elem5 ¦ +---¦ +---¦
¦ elem1 ¦ ¦ elem6 ¦ +---+ +---¦
• Há várias instruções REXX que manipulam Data Stack. Duas instruções adicionam elementos e outra retira elementos da Data Stack.
•Adicionando Elementos:
–O armazenamento de informações no Data Stack pode ser feito por duas Keyword:
PUSH e QUEUE.
PUSH– Coloca um item de dado no início do data stack (Top - Pilha )
Ex.:elem1 = 'String 1 for the data stack' PUSH elem1
QUEUE– Coloca um item de dado no final do Data Stack (Bottom - Fila)
Ex.: elemA = 'String A for the data stack' QUEUE elemA
•Removendo Elementos da Stack: Para se remover informações da Data Stack, pode-se usar a instrução PULLe PARSE PULL. Se a Data Stack estiver vazia, PULL remove
informações pelo terminal.
•PULL e PARSE PULL – removem um elemento do início da Data Stack (top)
Ex.: PULL stackitem
SAY stackitem /* displays STRING 1 da Stack */
• Quando for utilizado PARSE PULL, o conteúdo não será traduzido para maiúscula (uppercase).
Ex.:PARSE PULL stackitem
SAY stackitem /* displays STRING 1 da Stack */
➢ A função QUEUED()retorna o número total de elementos da Data Stack.
➢ Os comandos de TSO/E REXX processam serviços, como:
• Controle de operações de I/O em data sets (EXECIO) ;
• Execução de serviços da pilha de dados (MAKEBUF, DROPBUF, QBUF, QELEM, NEWSTACK, DELSTACK, QSTACK) ;
• Mudanças de características que controlam a execução de um exec(EXECUTIL )
➢ ALLOCATE
Para se criar um arquivo ou acessar os dados de um arquivo em uma operação de I/O, é necessário que este arquivo esteja aloca do ao programa REXX ativo naquele momento. Esta é a função da instrução ALLOCATE. Para “desalocar” um arquivo, utiliza-se a instrução FREE.
Pode-se alocar um arquivo:
•NOVO;
•PRÉ-EXISTENTE;
•COM ACESSO EXCLUSIVO;
•COM ACESSO COMPARTILHADO;
•SOBREGRAVANDO SEUS DADOS OU PRESERVANDO OS SEUS DADOS.
• Alocando um arquivo novo: deve-se informar ao Sistema Operacional todos os parâmetros necessários para a correta alocação do arquivo. Este procedimento permitirá que você possa usar o arquivo de forma adequada às diretrizes do seu programa. Exemplo:
+---+
| /* ALLOCANDO UM ARQUIVO NOVO */ |
| say“Entre o Nome do Arquivo a ser alocado” |
| pull NOME . |
| |
| “ALLOC FILENAME(“DDN1”) DATASET(“NOME”) NEW CYL |
| RECFM (F B) LRECL(080) BLKSIZE(27920) SPACE(50 10 30) |
| UNIT(SYSDA)” |
| IF RC /= 0 THEN |
| DO |
| SAY “ERRO DE ALOCAÇÃO DE “ NOME |
| EXIT /* se positivo retorno para o |
| END CMS */ |
| “EXECIO 1 DISKW” DDN1 “(STRING” linha |
| end |
+---+
No exemplo temos os operandos::
✓FILENAME – (FI) faz associação do arquivo a um NOME LÓGICO que passará a ser a referência do arquivo para o seu uso pelo programa REXX, como o DDNAME do JCL, ( DDN1).
✓DATASET – (DA) é o nome real do arquivo, identificado pelo CATÁLOGO do MVS. Deverá obedecer as restrições em vigor na instalação, como PADRÕES, RACF, etc. Corresponde ao parâmetro DSN do JCL.
✓NEW– indica para o MVS que este arquivo ainda não existe, o que nos forçará passar os demais parâmetros de criação de arquivo (abaixo).
▪CYL– indica que a quantidade de alocação informada deverá contar-se em CILINDROS, neste caso, ou TRK, para TRILHAS, ou ainda BLK para BLOCOS.
▪RECFM– Formato do registro, neste caso F FIXO e B BLOCADO, pode-se usar ainda V variável e U UNFORMATED.
▪LRECL– é o comprimento do registro, ou a quantidade de caracteres existentes num único registro.
▪BLKSIZE– é o tamanho do bloco lógico do arquivo (é um produto da quantidade de caracteres existentes em um registro que é aproximado a o tamanho da trilha do disco magnético).
▪SPACE– com 3 sub-parâmetros. 1) quantidade de alocação PRIMÁRIA(50 CILINDROS). 2) é a alocação SECUNDÁRIA(10 CILINDROS). 3) é alocação de BLOCOS DE DIRETÓRIO(30 BLOCOS). Este último informa ao S.O. que a alocação é de um ARQUIVO PARTICIONADO.
▪UNIT– informa ao S.O. o nome do POOL DE DISCOS onde será alocado o arquivo. Neste caso, SYSDA, é um mnemônico da própria IBM , que aponta para todos os discos da instalação.
REXX - ALOCANDO ARQUIVOS
➢ALLOCATE
• Alocando um arquivo novo a partir de um existente, é utilizado o comando ALLOCATE, especificando o operando DATASET seguido pelo nome do novo data set, e especificando o operando LIKE seguido pelo nome do data set que será modelo. Assim, os atributos do novo data set serão os mesmos do modelo .
Exemplo:
+---+
"ALLOCATE DATASET(test.data) LIKE(model.data)"
"FREE DATASET(test.data)"
+---+
• Alocando um arquivo novo a partir de outro, com exceções:
Algumas vezes, pode-se querer criar um Data Set a partir de outro que é semelhante, exceto alguns atributos. Neste caso, deverá ser informado o atributo a ser alterado.
Exemplo: Apenas o BLKSIZE é diferente:
+---+
"ALLOCATE DATASET(test.data) LIKE(model.data) BLKSIZE(8000)"
"FREE DATASET(test.data)"
+---+
