 |
| Bellacosa Mainframe subrotina e funções no REXX |
☕🔥 REXX: O “CALL” QUE SEPARA AMADORES DE MESTRES DO MAINFRAME 🔥☕
Quando uma simples subrotina vira arquitetura corporativa no z/OS
Existe um momento curioso na vida de todo profissional de Mainframe.
No começo, o programador escreve scripts REXX pequenos:
-
um
SAY -
um
PARSE -
um
LISTDSI - um loopzinho no TSO
Tudo parece simples…
Até o dia em que o EXEC cresce.
E cresce.
E cresce MAIS.
De repente:
- o REXX virou ferramenta operacional
- automatizou JES2
- conversa com SDSF
- consulta DB2
- gera relatórios
- envia alertas
- dispara jobs
- trata datasets
- faz parsing de SYSOUT
E então nasce o monstro.
O famoso:
“REXX ESPAGUETE”
O EXEC com:
- 4 mil linhas
- 93 labels
- 17 GOTOs improvisados
- variáveis globais brigando entre si
-
e um
EXITperdido que encerra tudo sem aviso.
É nesse ponto que Functions e Subroutines deixam de ser “assunto básico”.
E passam a ser:
ENGENHARIA DE SOFTWARE NO z/OS
🧠 O DIA EM QUE O REXX MUDA
A maioria aprende REXX assim:
SAY 'HELLO WORLD'
Depois:
DO I = 1 TO 10
SAY I
END
Mas o verdadeiro salto acontece quando alguém descobre:
CALL
Parece banal.
Mas não é.
Porque o CALL introduz:
- modularização
- reutilização
- encapsulamento
- separação de responsabilidades
Ou seja:
arquitetura.
☕ A FILOSOFIA UNIX… DENTRO DO MAINFRAME
Existe uma ideia clássica no UNIX:
“Faça uma coisa… e faça bem.”
REXX absorveu isso perfeitamente.
Uma boa subrotina:
- tem responsabilidade única
- é reutilizável
- é previsível
- é segura
🔥 O ERRO QUE TODO MUNDO COMETE
O clássico:
/* REXX */
contador = 0
CALL SOMA
CALL SOMA
CALL SOMA
SAY contador
EXIT
SOMA:
contador = contador + 1
RETURN
Resultado:
3
O iniciante acha lindo.
O veterano começa a suar frio.
Porque:
- a subrotina alterou variável global
- qualquer outra rotina pode quebrar tudo
- debugging vira inferno
🧨 O APOCALIPSE DAS VARIÁVEIS GLOBAIS
Em ambientes corporativos isso gera:
- bugs fantasmas
- comportamento imprevisível
- corrupção lógica
- falhas intermitentes
O tipo de erro que:
- acontece só em produção
- às 3h da manhã
- no fechamento bancário
🛡️ PROCEDURE: O HERÓI ESQUECIDO DO REXX
Aí surge ele.
O cavaleiro do encapsulamento:
PROCEDURE
O MESMO CÓDIGO — AGORA PROFISSIONAL
/* REXX */
contador = 0
CALL SOMA
CALL SOMA
CALL SOMA
SAY contador
EXIT
SOMA:
PROCEDURE
contador = contador + 1
RETURN
Resultado:
0
BOOM.
Agora:
- a variável ficou isolada
- a rotina ficou segura
- o EXEC ficou previsível
🧠 O QUE O PROCEDURE REALMENTE FAZ?
Muita gente pensa:
“Ah… ele só protege variáveis.”
Não.
Ele cria:
CONTEXTO DE EXECUÇÃO
Quase como stack frame em linguagens modernas.
Ou seja:
- escopo local
- isolamento
- proteção de memória lógica
Isso é MUITO avançado para uma linguagem criada em 1979.
👀 EASTER EGG MAINFRAME #1
Muitos programadores COBOL estranham isso porque COBOL tradicionalmente compartilha Working-Storage de forma mais explícita.
Já o REXX:
- pode ser extremamente dinâmico
- extremamente perigoso
- ou extremamente elegante
Tudo depende do uso do PROCEDURE.
☠️ O “EXIT” QUE MATOU PRODUÇÃO
Existe um erro lendário em REXX.
Esse aqui:
MINHAROTINA:
EXIT
O programador queria retornar.
Mas o EXIT:
- encerrou o EXEC inteiro
- abortou processamento
- deixou JOB preso
- não gerou relatório
- não liberou recurso
Resultado:
- operador chamou suporte
- suporte chamou sysprog
- sysprog chamou o programador
- o programador fingiu que estava em reunião.
O CORRETO
MINHAROTINA:
RETURN
☕ EASTER EGG MAINFRAME #2
Veteranos de TSO geralmente têm trauma de:
-
IKJ56500I - loops infinitos
- EXEC preso consumindo CPU
- SDSF mostrando step “ativo eternamente”
Muitas vezes a causa era:
-
RETURNfaltando - variável compartilhada
- parsing errado
🔍 FUNCTIONS: A JOIA DO REXX
Subrotina executa ações.
Função:
- calcula
- transforma
- retorna valor
EXEMPLO CLÁSSICO
nome = 'MAINFRAME'
tam = LENGTH(nome)
SAY tam
Resultado:
9
A função:
- recebe argumento
- processa
- devolve resultado
O PODER DAS BUILT-IN FUNCTIONS
REXX é quase um canivete suíço textual.
Tem funções para:
- palavras
- parsing
- HEX
- EBCDIC
- decimal
- binary
- formatação
- datas
- sistema
🔥 O MOMENTO “MATRIX” DO MAINFRAME
Quando alguém descobre:
C2X()
X2C()
o cérebro explode.
Porque agora:
- dumps fazem sentido
- buffers CICS fazem sentido
- mensagens MQ fazem sentido
- VSAM hexadecimal faz sentido
EXEMPLO
SAY C2X('A')
Resultado:
C1
E aqui está a magia.
No Windows:
- “A” normalmente seria 41 hexadecimal
No Mainframe:
- é C1
Porque o z/OS vive no glorioso mundo:
EBCDIC
👀 EASTER EGG MAINFRAME #3
Você sabe que alguém virou “mainframer raiz” quando ele olha:
F1F2F3
e instantaneamente pensa:
123
🚀 PARSE ARG — A ARTE DO REXX
Outras linguagens:
campos = texto.split()
REXX:
PARSE ARG nome sobrenome idade
Fim.
Elegante.
Natural.
Humano.
EXEMPLO PROFISSIONAL
/* REXX */
CALL PROCESSA 'VAGNER BELLACOSA MAINFRAME'
EXIT
PROCESSA:
PROCEDURE
PARSE ARG nome sobrenome area
SAY 'NOME :' nome
SAY 'SOBRENOME:' sobrenome
SAY 'AREA :' area
RETURN
Saída:
NOME : VAGNER
SOBRENOME : BELLACOSA
AREA : MAINFRAME
🔥 INTERNAL vs EXTERNAL ROUTINES
Esse conceito é GIGANTE.
INTERNAL
Dentro do mesmo EXEC.
EXTERNAL
Outro membro da PDS.
Isso permitiu nascer:
- frameworks REXX
- bibliotecas corporativas
- automação enterprise
- ferramentas operacionais gigantes
🏦 O REXX QUE NINGUÉM VÊ
Muita gente acha que Mainframe moderno vive só de:
- COBOL
- DB2
- CICS
Mas nos bastidores…
REXX roda:
- automação operacional
- health checks
- deployment
- monitoramento
- auditoria
- SDSF automation
- RACF tooling
- DevOps z/OS
☕ EASTER EGG MAINFRAME #4
Em muitos bancos:
- o sistema crítico é COBOL
- mas quem “cola tudo” é REXX
O REXX virou:
a fita isolante do z/OS.
🎯 O VERDADEIRO ENSINAMENTO
Esse módulo parece ensinar:
- CALL
- RETURN
- FUNCTION
Mas o que ele REALMENTE ensina é:
COMO ORGANIZAR PENSAMENTO
O SALTO DE MATURIDADE
O iniciante escreve:
- scripts
O profissional escreve:
- módulos
O especialista escreve:
- frameworks reutilizáveis
O veterano escreve:
- automação que parece sistema operacional.
💡 EXEMPLO FINAL — ESTILO CORPORATIVO
/* REXX */
CALL CABECALHO
usuario = USERID()
data = DATE()
hora = TIME()
msg = MONTA_MSG(usuario,data,hora)
CALL EXIBE msg
EXIT
/* ======================= */
CABECALHO:
PROCEDURE
SAY '================================='
SAY ' SISTEMA DE AUDITORIA MAINFRAME '
SAY '================================='
RETURN
/* ======================= */
MONTA_MSG:
PROCEDURE
PARSE ARG user,data,hora
RETURN 'USUARIO:' user ' DATA:' data ' HORA:' hora
/* ======================= */
EXIBE:
PROCEDURE
PARSE ARG texto
SAY texto
RETURN
RESULTADO
=================================
SISTEMA DE AUDITORIA MAINFRAME
=================================
USUARIO: IBMUSER DATA: 2026-05-07 HORA: 14:32:10
☕ CONCLUSÃO
Functions e Subroutines não são “detalhes” do REXX.
São:
- modularização
- arquitetura
- reutilização
- encapsulamento
- engenharia de software
E talvez essa seja a maior surpresa do Mainframe moderno:
Mesmo décadas depois…
O REXX ainda ensina conceitos que muitos sistemas distribuídos continuam tentando reaprender.
