Rexx - Rexx
Paradigma | multiparadigma : procedimental , estruturado |
---|---|
Projetado por | Mike Cowlishaw |
Desenvolvedor | Mike Cowlishaw, IBM |
Apareceu pela primeira vez | 1979 |
Versão estável |
ANSI X3.274 / 1996
|
Disciplina de digitação | Dinâmico |
Extensões de nome de arquivo | .cmd, .bat, .exec, .rexx, .rex, EXEC |
Implementações principais | |
VM / SP R3, TSO / E V2, SAAREXX, ARexx , BREXX, Regina, Personal REXX, REXX / imc | |
Dialetos | |
NetRexx , Object REXX , agora ooREXX , KEXX | |
Influenciado por | |
PL / I , ALGOL , EXEC , EXEC 2 | |
Influenciado | |
NetRexx , Object REXX | |
|
Rexx ( Restructured Extended Executor ) é uma linguagem de programação interpretada desenvolvida na IBM por Mike Cowlishaw . É uma linguagem de programação estruturada de alto nível projetada para facilitar o aprendizado e a leitura. Existem intérpretes Rexx proprietários e de código aberto para uma ampla gama de plataformas de computação; existem compiladores para computadores mainframe IBM .
Rexx é usado como linguagem de script e macro e é frequentemente usado para processar dados e texto e gerar relatórios; essas semelhanças com o Perl significam que o Rexx funciona bem em programação CGI ( Common Gateway Interface ) e é realmente usado para esse propósito. Rexx é a linguagem de script principal em alguns sistemas operacionais, por exemplo, OS / 2 , MVS , VM , AmigaOS , e também é usada como uma linguagem de macro interna em algum outro software, como SPFPC , KEDIT , THE e o emulador de terminal ZOC . Além disso, a linguagem Rexx pode ser usada para scripts e macros em qualquer programa que use as linguagens de mecanismo de script ActiveX do Windows Scripting Host (por exemplo, VBScript e JScript) se um dos mecanismos Rexx estiver instalado.
Rexx é fornecido com VM / SP Release 3 ou superior, TSO / E Versão 2 superior, OS / 2 (1.3 e posterior, onde é oficialmente denominado Procedures Language / 2 ), AmigaOS Versão 2 superior, PC DOS ( 7.0 ou 2000 ), ArcaOS e Windows NT 4.0 (Resource Kit: Regina). Os scripts REXX para OS / 2 compartilham a extensão de nome de arquivo .cmd com outras linguagens de script e a primeira linha do script especifica o interpretador a ser usado. Macros REXX para aplicativos compatíveis com REXX usam extensões determinadas pelo aplicativo. No final da década de 1980, o Rexx se tornou a linguagem de script comum para IBM Systems Application Architecture , onde foi renomeado como "SAA Procedure Language REXX".
Um script ou comando Rexx às vezes é referido como EXEC em um aceno para o tipo de arquivo CMS usado para scripts EXEC , EXEC 2 e REXX em CP / CMS e VM / 370 a z / VM .
Recursos
Rexx possui as seguintes características e recursos:
- Sintaxe simples
- A capacidade de rotear comandos para vários ambientes
- A capacidade de oferecer suporte a funções, procedimentos e comandos associados a um ambiente de chamada específico.
- Uma pilha embutida, com a capacidade de interoperar com a pilha do host, se houver.
- Pequeno conjunto de instruções contendo apenas duas dúzias de instruções
- Sintaxe de forma livre
- Tokens que não diferenciam maiúsculas de minúsculas, incluindo nomes de variáveis
- Base de string de caracteres
- Tipos de dados dinâmicos , sem declarações
- Sem palavras-chave reservadas , exceto no contexto local
- Não inclui instalações de arquivo
- Precisão numérica arbitrária
- Aritmética decimal, ponto flutuante
- Uma rica seleção de funções integradas, especialmente string e processamento de texto
- Gerenciamento automático de armazenamento
- Proteção contra colisões
- Estruturas de dados endereçáveis de conteúdo
- Matrizes associativas
- Acesso direto aos comandos e instalações do sistema
- Tratamento de erros simples e rastreamento e depurador integrados
- Poucas limitações artificiais
- Instalações de E / S simplificadas
- Operadores não convencionais
- Suporta apenas parcialmente os parâmetros de linha de comando do estilo Unix, exceto implementações específicas
- Não fornece controle de terminal básico como parte da linguagem, exceto implementações específicas
- Não fornece uma maneira genérica de incluir funções e sub-rotinas de bibliotecas externas, exceto implementações específicas
Rexx tem apenas vinte e três anos, em grande parte auto-evidente, instruções (como call
, parse
, e select
) com pontuação mínima e requisitos de formatação. É essencialmente uma linguagem de forma quase livre com apenas um tipo de dados, a cadeia de caracteres; esta filosofia significa que todos os dados são visíveis (simbólicos) e a depuração e o rastreio são simplificados.
A sintaxe de Rexx é semelhante a PL / I , mas tem menos notações; isso torna mais difícil analisar (por programa), mas mais fácil de usar, exceto nos casos em que os hábitos PL / I podem levar a surpresas. Um dos objetivos de design do REXX era o princípio da menor surpresa .
História
pré-1990
Rexx foi projetado e implementado pela primeira vez, em linguagem assembly , como um projeto de 'tempo próprio' entre 20 de março de 1979 e meados de 1982 por Mike Cowlishaw da IBM, originalmente como uma linguagem de programação de script para substituir as linguagens EXEC e EXEC 2 . Ele foi projetado para ser uma linguagem de macro ou script para qualquer sistema. Como tal, Rexx é considerado um precursor do Tcl e do Python . Rexx também foi planejado por seu criador para ser uma versão simplificada e mais fácil de aprender da linguagem de programação PL / I. No entanto, algumas diferenças de PL / I podem enganar os incautos.
Ele foi descrito pela primeira vez em público na conferência SHARE 56 em Houston, Texas, em 1981, onde a reação do cliente, patrocinada por Ted Johnston do SLAC , o levou a ser vendido como um produto IBM em 1982.
Ao longo dos anos, a IBM incluiu Rexx em quase todos os seus sistemas operacionais ( VM / CMS , MVS TSO / E , IBM i , VSE / ESA , AIX , PC DOS e OS / 2 ) e disponibilizou versões para Novell NetWare , Windows , Java e Linux .
A primeira versão não IBM foi escrita para PC DOS por Charles Daney em 1984/5 e comercializada pelo Mansfield Software Group (fundado por Kevin J. Kearney em 1986). A primeira versão do compilador apareceu em 1987, escrita para CMS por Lundin e Woodruff. Outras versões também foram desenvolvidas para Atari , AmigaOS , Unix (muitas variantes), Solaris , DEC , Windows , Windows CE , Pocket PC , DOS , Palm OS , QNX , OS / 2 , Linux , BeOS , EPOC32 / Symbian , AtheOS , OpenVMS , a Apple Macintosh , e Mac OS X .
A versão Amiga do Rexx, chamada ARexx , foi incluída com o AmigaOS 2 em diante e era popular para scripts e também para controle de aplicativos. Muitos aplicativos Amiga possuem uma "porta ARexx" incorporada que permite o controle do aplicativo a partir do Rexx. Um único script Rexx pode até mesmo alternar entre diferentes portas Rexx para controlar vários aplicativos em execução.
1990 até o presente
Em 1990, Cathie Dager do SLAC organizou o primeiro simpósio Rexx independente, que levou à formação da REXX Language Association. Simpósios são realizados anualmente.
Várias versões freeware do Rexx estão disponíveis. Em 1992, apareceram as duas portas de código aberto mais amplamente usadas : REXX / imc de Ian Collier para Unix e Regina de Anders Christensen (posteriormente adotada por Mark Hessling) para Windows e Unix. BREXX é bem conhecido pelas plataformas WinCE e Pocket PC e foi "portado" para VM / 370 e MVS .
OS / 2 possui um sistema de desenvolvimento visual da Watcom VX-REXX . Outro dialeto foi VisPro REXX da Hockware.
Portable Rexx by Kilowatt e Personal Rexx by Quercus são dois intérpretes Rexx projetados para DOS e podem ser executados no Windows usando um prompt de comando. Desde meados da década de 1990, surgiram duas variantes mais recentes do Rexx:
- NetRexx : compila para Java byte-code via código-fonte Java; não tem palavras-chave reservadas e usa o modelo de objeto Java e, portanto, geralmente não é compatível com versões anteriores do Rexx "clássico".
- Object REXX : uma versão orientada a objetos geralmente compatível com versões anteriores do Rexx.
Em 1996, o American National Standards Institute (ANSI) publicou um padrão para Rexx: ANSI X3.274–1996 "Tecnologia da Informação - Linguagem de Programação REXX". Mais de duas dezenas de livros sobre Rexx foram publicados desde 1985.
A Rexx comemorou seu 25º aniversário em 20 de março de 2004, que foi celebrado no 15º Simpósio Internacional REXX da REXX Language Association em Böblingen, Alemanha, em maio de 2004.
Em 12 de outubro de 2004, a IBM anunciou seu plano de liberar suas fontes de implementação do Object REXX sob a Licença Pública Comum . Versões recentes do Object REXX contêm um mecanismo de script ActiveX Windows Scripting Host (WSH) que implementa esta versão da linguagem Rexx.
Em 22 de fevereiro de 2005, o primeiro lançamento público do Open Object Rexx (ooRexx) foi anunciado. Este produto contém um mecanismo de script WSH que permite a programação do sistema operacional Windows e aplicativos com Rexx da mesma maneira em que Visual Basic e JScript são implementados pela instalação WSH padrão e mecanismos de script de terceiros Perl , Tcl e Python .
Em janeiro de 2017, o REXX estava listado no índice TIOBE como um dos cinquenta idiomas entre os 100 principais, não pertencendo aos 50 principais.
Em 2019, o 30º Simpósio da Rexx Language Association marcou o 40º aniversário da Rexx. O simpósio foi realizado em Hursley, Inglaterra, onde o Rexx foi projetado e implementado pela primeira vez.
Kits de ferramentas
Rexx / Tk, um kit de ferramentas para gráficos a ser usado em programas Rexx da mesma maneira que Tcl / Tk está amplamente disponível.
Um Rexx IDE, RxxxEd, foi desenvolvido para Windows. RxSock para comunicação de rede, bem como outros add-ons e implementações de Regina Rexx foram desenvolvidos, e um interpretador Rexx para a linha de comando do Windows é fornecido na maioria dos Resource Kits para várias versões do Windows e funciona em todos eles, bem como DOS.
Ortografia e letras maiúsculas
Originalmente, a linguagem era chamada de Rex ( Executor Reformado ); o "X" extra foi adicionado para evitar colisões com nomes de outros produtos. O REX era originalmente todo em maiúsculas porque o código do mainframe era orientado para maiúsculas. O estilo naquela época era ter nomes em maiúsculas, em parte porque quase todo o código ainda era em maiúsculas naquela época. Para o produto, ele se tornou REXX, e ambas as edições do livro de Mike Cowlishaw usam letras maiúsculas. A expansão para REstructured eXtended eXecutor foi usada para o produto do sistema em 1984.
Sintaxe
Looping
A estrutura de controle de loop em Rexx começa com a DO
e termina com um, END
mas vem em várias variedades. NetRexx usa a palavra-chave em LOOP
vez de DO
para loop, enquanto ooRexx trata LOOP
e DO
como equivalente quando em loop.
Loops condicionais
Rexx suporta uma variedade de loops de programação estruturada tradicionais ao testar uma condição antes ( do while
) ou depois ( do until
) da lista de instruções serem executadas:
do while [condition]
[instructions]
end
do until [condition]
[instructions]
end
Loops repetitivos
Como a maioria das linguagens, o Rexx pode fazer um loop enquanto incrementa uma variável de índice e parar quando um limite é atingido:
do index = start [to limit] [by increment] [for count]
[instructions]
end
O incremento pode ser omitido e o padrão é 1. O limite também pode ser omitido, o que faz com que o loop continue para sempre.
Rexx permite loops contados, onde uma expressão é calculada no início do loop e as instruções dentro do loop são executadas tantas vezes:
do expression
[instructions]
end
Rexx pode até mesmo fazer um loop até que o programa seja encerrado:
do forever
[instructions]
end
Um programa pode sair do loop atual com a leave
instrução, que é a maneira normal de sair de um do forever
loop, ou pode causar um curto-circuito com a iterate
instrução.
Loops combinados
Mais raramente, Rexx permite que elementos condicionais e repetitivos sejam combinados no mesmo loop:
do index = start [to limit] [by increment] [for count] [while condition]
[instructions]
end
do expression [until condition]
[instructions]
end
Condicionais
Condições de teste com IF
:
if [condition] then
do
[instructions]
end
else
do
[instructions]
end
A ELSE
cláusula é opcional.
Para instruções individuais, DO
e END
também pode ser omitido:
if [condition] then
[instruction]
else
[instruction]
O recuo é opcional, mas ajuda a melhorar a legibilidade.
Teste para várias condições
SELECT
é de Rexx estrutura CASE , como muitas outras construções derivadas de PL / I . Como algumas implementações de construções CASE em outras linguagens dinâmicas, as WHEN
cláusulas de Rexx especificam condições completas, que não precisam estar relacionadas entre si. Nisso, eles se parecem mais com conjuntos de IF-THEN-ELSEIF-THEN-...-ELSE
código em cascata do que com a switch
instrução C ou Java .
select
when [condition] then
[instruction] or NOP
when [condition] then
do
[instructions] or NOP
end
otherwise
[instructions] or NOP
end
A NOP
instrução executa "nenhuma operação" e é usada quando o programador não deseja fazer nada em um lugar onde uma ou mais instruções seriam necessárias.
A cláusula OTHERWISE é opcional. Se omitido e nenhuma condição WHEN for atendida, a condição SYNTAX será gerada.
Variáveis simples
As variáveis no Rexx não têm tipo e são avaliadas inicialmente como seus nomes, em maiúsculas. Assim, o tipo de uma variável pode variar de acordo com seu uso no programa:
say hello /* => HELLO */
hello = 25
say hello /* => 25 */
hello = "say 5 + 3"
say hello /* => say 5 + 3 */
interpret hello /* => 8 */
drop hello
say hello /* => HELLO */
Variáveis compostas
Ao contrário de muitas outras linguagens de programação, o Rexx clássico não tem suporte direto para matrizes de variáveis endereçadas por um índice numérico. Em vez disso, ele fornece variáveis compostas . Uma variável composta consiste em uma haste seguida por uma cauda. UMA . (ponto) é usado para unir a haste à cauda. Se as caudas usadas forem numéricas, é fácil produzir o mesmo efeito que um array.
do i = 1 to 10
stem.i = 10 - i
end
Posteriormente, existem as seguintes variáveis com os seguintes valores: stem.1 = 9, stem.2 = 8, stem.3 = 7
...
Ao contrário dos arrays, o índice de uma variável raiz não precisa ter um valor inteiro. Por exemplo, o seguinte código é válido:
i = 'Monday'
stem.i = 2
No Rexx também é possível definir um valor padrão para uma haste.
stem. = 'Unknown'
stem.1 = 'USA'
stem.44 = 'UK'
stem.33 = 'France'
Após essas atribuições, o termo stem.3
produziria 'Unknown'
.
O radical inteiro também pode ser apagado com a instrução DROP.
drop stem.
Isso também tem o efeito de remover qualquer valor padrão definido anteriormente.
Por convenção (e não como parte da linguagem), o composto stem.0
é frequentemente usado para rastrear quantos itens estão em um radical, por exemplo, um procedimento para adicionar uma palavra a uma lista pode ser codificado assim:
add_word: procedure expose dictionary.
parse arg w
n = dictionary.0 + 1
dictionary.n = w
dictionary.0 = n
return
Também é possível ter vários elementos na cauda de uma variável composta. Por exemplo:
m = 'July'
d = 15
y = 2005
day.y.m.d = 'Friday'
Vários elementos finais numéricos podem ser usados para fornecer o efeito de uma matriz multidimensional.
Recursos semelhantes às variáveis compostas Rexx são encontrados em muitas outras linguagens (incluindo matrizes associativas em AWK , hashes em Perl e Hashtables em Java ). A maioria dessas linguagens fornece uma instrução para iterar sobre todas as chaves (ou caudas em termos Rexx) de tal construção, mas isso está faltando no Rexx clássico. Em vez disso, é necessário manter listas auxiliares de valores finais conforme apropriado. Por exemplo, em um programa para contar palavras, o procedimento a seguir pode ser usado para registrar cada ocorrência de uma palavra.
add_word: procedure expose count. word_list
parse arg w .
count.w = count.w + 1 /* assume count. has been set to 0 */
if count.w = 1 then word_list = word_list w
return
e depois:
do i = 1 to words(word_list)
w = word(word_list,i)
say w count.w
end
Ao custo de alguma clareza, é possível combinar essas técnicas em uma única haste:
add_word: procedure expose dictionary.
parse arg w .
dictionary.w = dictionary.w + 1
if dictionary.w = 1 /* assume dictionary. = 0 */
then do
n = dictionary.0+1
dictionary.n = w
dictionary.0 = n
end
return
e depois:
do i = 1 to dictionary.0
w = dictionary.i
say i w dictionary.w
end
Rexx não fornece nenhuma rede de segurança aqui, então se uma das palavras for um número inteiro menor do que dictionary.0
esta técnica falhará misteriosamente.
Implementações recentes do Rexx, incluindo o Object REXX da IBM e as implementações de código aberto como ooRexx incluem uma nova construção de linguagem para simplificar a iteração sobre o valor de um radical ou sobre outro objeto de coleção, como um array, tabela ou lista.
do i over stem.
say i '-->' stem.i
end
Instruções de palavras-chave
PARSE
A PARSE
instrução é particularmente poderosa; ele combina algumas funções úteis de manuseio de strings. Sua sintaxe é:
parse [upper] origin [template]
onde origin especifica a fonte:
-
arg
(argumentos, na cauda de nível superior da linha de comando) -
linein
(entrada padrão, por exemplo, teclado) -
pull
(Fila de dados Rexx ou entrada padrão) -
source
(informações sobre como o programa foi executado) -
value
(uma expressão)with
: a palavrawith
- chave é necessária para indicar onde termina a expressão -
var
(uma variável) -
version
(versão / número de lançamento)
e o modelo pode ser:
- lista de variáveis
- delimitadores de número de coluna
- delimitadores literais
upper
é opcional; se especificado, os dados serão convertidos em maiúsculas antes da análise.
Exemplos:
Usando uma lista de variáveis como modelo
myVar = "John Smith"
parse var myVar firstName lastName
say "First name is:" firstName
say "Last name is:" lastName
exibe o seguinte:
First name is: John Last name is: Smith
Usando um delimitador como modelo:
myVar = "Smith, John"
parse var myVar LastName "," FirstName
say "First name is:" firstName
say "Last name is:" lastName
também exibe o seguinte:
First name is: John Last name is: Smith
Usando delimitadores de número de coluna:
myVar = "(202) 123-1234"
parse var MyVar 2 AreaCode 5 7 SubNumber
say "Area code is:" AreaCode
say "Subscriber number is:" SubNumber
exibe o seguinte:
Area code is: 202 Subscriber number is: 123-1234
Um modelo pode usar uma combinação de variáveis, delimitadores literais e delimitadores de número de coluna.
INTERPRETAR
A instrução INTERPRET avalia seu argumento e trata seu valor como uma instrução Rexx. Às vezes, INTERPRET é a maneira mais clara de executar uma tarefa, mas geralmente é usado onde um código mais claro é possível usando, por exemplo value()
,.
Outros usos de INTERPRET são a aritmética de precisão arbitrária (decimal) de Rexx (incluindo comparações fuzzy), o uso da instrução PARSE com modelos programáticos, arrays de raiz e arrays esparsos.
/* demonstrate INTERPRET with square(4) => 16 */
X = 'square'
interpret 'say' X || '(4) ; exit'
SQUARE: return arg(1)**2
Isso exibe 16 e sai. Como os conteúdos variáveis em Rexx são strings, incluindo números racionais com expoentes e até programas inteiros, Rexx se oferece para interpretar strings como expressões avaliadas.
Esse recurso pode ser usado para passar funções como parâmetros de função , como passar SIN ou COS para um procedimento para calcular integrais.
Rexx oferece apenas funções matemáticas básicas como ABS, DÍGITOS, MAX, MIN, SIGN, RANDOM e um conjunto completo de conversões hexadecimais mais binárias com operações de bits. Funções mais complexas como SIN foram implementadas do zero ou obtidas de bibliotecas externas de terceiros . Algumas bibliotecas externas, normalmente aquelas implementadas em linguagens tradicionais, não suportavam precisão estendida.
Versões posteriores (não clássicas) suportam CALL variable
construções. Junto com a função embutida VALUE
, CALL pode ser usado no lugar de muitos casos de INTERPRET
. Este é um programa clássico:
/* terminated by input "exit" or similar */
do forever ; interpret linein() ; end
Uma "calculadora Rexx" um pouco mais sofisticada:
X = 'input BYE to quit'
do until X = 'BYE' ; interpret 'say' X ; pull X ; end
PULL
é uma abreviação de parse upper pull
. Da mesma forma, ARG
é uma abreviação de parse upper arg
.
O poder da instrução INTERPRET teve outros usos. O pacote de software Valor contou com a capacidade interpretativa da Rexx para implementar um ambiente OOP . Outro uso foi encontrado em um produto Westinghouse não lançado chamado Time Machine, que foi capaz de se recuperar totalmente após um erro fatal.
NUMÉRICO
say digits() fuzz() form() /* => 9 0 SCIENTIFIC */
say 999999999+1 /* => 1.000000000E+9 */
numeric digits 10 /* only limited by available memory */
say 999999999+1 /* => 1000000000 */
say 0.9999999999=1 /* => 0 (false) */
numeric fuzz 3
say 0.99999999=1 /* => 1 (true) */
say 0.99999999==1 /* => 0 (false) */
say 100*123456789 /* => 1.23456789E+10 */
numeric form engineering
say 100*123456789 /* => 12.34567890E+9 */
say 53 // 7 /* => 4 (rest of division)*/
Calcula √ 2 | Calcula e | |
---|---|---|
código |
numeric digits 50
n=2
r=1
do forever /* Newton's method */
rr=(n/r+r)/2
if r=rr then leave
r=rr
end
say "sqrt" n ' = ' r
|
numeric digits 50
e=2.5
f=0.5
do n=3
f=f/n
ee=e+f
if e=ee then leave
e=ee
end
say "e =" e
|
saída | sqrt 2 = 1,414213562373095048801688724209698078569671875377 | e = 2.7182818284590452353602874713526624977572470936998 |
SINAL
A instrução SIGNAL se destina a mudanças anormais no fluxo de controle (consulte a próxima seção). No entanto, ela pode ser mal utilizada e tratada como a instrução GOTO encontrada em outras linguagens (embora não seja estritamente equivalente, porque termina loops e outras construções). Isso pode produzir um código difícil de ler.
Tratamento de erros e exceções
É possível no Rexx interceptar e lidar com erros e outras exceções, usando a instrução SIGNAL. Existem sete condições do sistema: ERROR, FAILURE, HALT, NOVALUE, NOTREADY, LOSTDIGITS e SYNTAX. O manuseio de cada um pode ser ativado e desativado no código-fonte, conforme desejado.
O seguinte programa será executado até ser encerrado pelo usuário:
signal on halt;
do a = 1
say a
do 100000 /* a delay */
end
end
halt:
say "The program was stopped by the user"
exit
Uma instrução intercepta o uso de variáveis indefinidas, que, de outra forma, obteriam seu próprio nome (em maiúsculas) como valor. Independentemente do estado da condição, o status de uma variável pode sempre ser verificado com a função embutida retornando VAR para variáveis definidas.
signal on novalue
NOVALUE
SYMBOL
A VALUE
função pode ser usada para obter o valor de variáveis sem acionar uma NOVALUE
condição, mas seu objetivo principal é ler e definir variáveis de ambiente , semelhante a POSIX getenv
e putenv
.
Condições
ERROR
- RC positivo de um comando do sistema
FAILURE
- RC negativo para um comando do sistema (por exemplo, o comando não existe)
HALT
- Terminação anormal
NOVALUE
- Uma variável não definida foi referenciada
NOTREADY
- Erro de entrada ou saída (por exemplo, tentativas de leitura além do final do arquivo)
SYNTAX
- Sintaxe de programa inválida ou alguma outra condição de erro
LOSTDIGITS
- Dígitos significativos são perdidos (ANSI Rexx, não na segunda edição do TRL)
Quando uma condição é tratada por SIGNAL ON
, as variáveis do sistema SIGL
e RC
podem ser analisadas para entender a situação. RC contém o código de erro Rexx e SIGL contém o número da linha onde o erro surgiu.
A partir do Rexx versão 4, as condições podem receber nomes, e também há uma CALL ON
construção. Isso é útil se funções externas não existirem necessariamente:
ChangeCodePage: procedure /* protect SIGNAL settings */
signal on syntax name ChangeCodePage.Trap
return SysQueryProcessCodePage()
ChangeCodePage.Trap: return 1004 /* windows-1252 on OS/2 */
Veja também
Referências
Leitura adicional
- Callaway, Merrill. The ARexx Cookbook: Um Tutorial Guide to the ARexx Language no Commodore Amiga Personal Computer . Whitestone, 1992. ISBN 978-0963277305 .
- Callaway, Merrill. The Rexx Cookbook: Um Tutorial Guide to the Rexx Language in OS / 2 & Warp on the IBM Personal Computer . Whitestone, 1995. ISBN 0-9632773-4-0 .
- Cowlishaw, Michael. A linguagem Rexx: uma abordagem prática à programação . Prentice Hall, 1990. ISBN 0-13-780651-5 .
- Cowlishaw, Michael. A linguagem NetRexx . Prentice Hall, 1997. ISBN 0-13-806332-X .
- Daney, Charles. Programação em REXX . McGraw-Hill, TX, 1990. ISBN 0-07-015305-1 .
- Ender, Tom. Programação orientada a objetos com Rexx . John Wiley & Sons, 1997. ISBN 0-471-11844-3 .
- Fosdick, Howard. Referência do programador Rexx . Wiley / Wrox, 2005. ISBN 0-7645-7996-7 .
- Gargiulo, Gabriel. REXX com recursos OS / 2, TSO e CMS . MVS Training, 1999 (terceira edição 2004). ISBN 1-892559-03-X .
- Goldberg, Gabriel e Smith, Philip H. The Rexx Handbook . McGraw-Hill, TX, 1992. ISBN 0-07-023682-8 .
- Goran, Richard K. REXX Reference Summary Handbook . CFS Nevada, Inc., 1997. ISBN 0-9639854-3-4 .
- IBM Redbooks. Implementando Suporte Rexx em Sdsf . Vervante, 2007. ISBN 0-7384-8914-X .
- Kiesel, Peter C. Rexx: Técnicas Avançadas para Programadores . McGraw-Hill, TX, 1992. ISBN 0-07-034600-3 .
- Marco, Lou Desenvolvimento ISPF / REXX para programadores experientes . CBM Books, 1995. ISBN 1-878956-50-7
- O'Hara, Robert P. e Gomberg, David Roos. Programação moderna usando Rexx . Prentice Hall, 1988. ISBN 0-13-597329-5 .
- Rudd, Anthony S. 'Practical Usage of TSO REXX'. CreateSpace, 2012. ISBN 978-1475097559 .
- Schindler, William. Para baixo para a Terra Rexx . Perfect Niche Software, 2000. ISBN 0-9677590-0-5 .