 |
| Bellacosa Mainframe apresenta as funçoes criadas em cobol modo api on |
☕💣 FUNÇÕES SEM SUBPROGRAMAS? O DIA EM QUE O COBOL APRENDEU A CRIAR SUAS PRÓPRIAS APIs — E QUASE NINGUÉM PERCEBEU
Existe um momento na carreira de todo profissional de Mainframe em que ele descobre algo e pensa:
"Como ninguém me contou isso antes?"
Foi exatamente essa sensação que muitos desenvolvedores tiveram quando conheceram as User Defined Functions (UDFs) introduzidas nas versões modernas do COBOL Enterprise da IBM.
Durante décadas, quando precisávamos reutilizar lógica em COBOL, a solução era sempre a mesma:
CALL de subprograma
COPYBOOK
Macro
Módulos compartilhados
Funcionava.
Ainda funciona.
Mas o COBOL evoluiu.
E hoje o programador pode criar suas próprias funções, utilizá-las dentro de expressões e fazer chamadas tão elegantes quanto as funções nativas do compilador.
Sim.
Da mesma forma que você usa:
FUNCTION CURRENT-DATE
ou
FUNCTION UPPER-CASE(...)
você pode criar:
FUNCTION CALCULA-IR(...)
ou
FUNCTION VALIDA-CPF(...)
ou qualquer outra regra de negócio.
Para quem passou décadas trabalhando apenas com programas e subprogramas, isso parece quase magia.
Mas não é.
É apenas COBOL moderno.
Um Pouco de História
Nas versões clássicas do COBOL:
COBOL VS COBOL II
COBOL/370
COBOL for MVS
não existia conceito de função definida pelo usuário.
Tudo precisava ser feito através de:
CALL "ROTINA01"
O compilador não conhecia o conceito de retorno funcional.
Quando surgiram:
Enterprise COBOL V5
Enterprise COBOL V6
a IBM passou a suportar recursos alinhados ao padrão ISO COBOL moderno.
Entre eles:
User Defined Functions
ou simplesmente:
Funções Definidas pelo Usuário
O Que é Uma User Defined Function?
É um módulo COBOL especial que:
recebe parâmetros
processa dados
retorna um único valor
exatamente como uma função matemática.
Exemplo:
RESULTADO =
FUNCTION DOBRO(VALOR)
Ao invés de:
CALL "DOBRO"
Quando Vale a Pena Utilizar?
Imagine uma regra utilizada em centenas de programas.
Por exemplo:
cálculo de imposto
cálculo de juros
validação de CPF
mascaramento de dados LGPD
formatação de código interno
Criar uma função centralizada reduz:
duplicação
manutenção
erros
e aumenta a legibilidade.
Estrutura de Uma Função COBOL
O segredo está na identificação.
Observe:
IDENTIFICATION DIVISION.
FUNCTION-ID. DOBRO.
Perceba:
Não usamos:
PROGRAM-ID
Usamos:
FUNCTION-ID
Isso transforma o módulo em uma função.
Exemplo Completo
Função DOBRO
IDENTIFICATION DIVISION.
FUNCTION-ID. DOBRO.
DATA DIVISION.
LINKAGE SECTION.
01 LK-VALOR PIC S9(9) COMP-5.
01 RESULTADO PIC S9(9) COMP-5.
PROCEDURE DIVISION
USING LK-VALOR
RETURNING RESULTADO.
COMPUTE RESULTADO =
LK-VALOR * 2
GOBACK.
Simples.
Recebe:
LK-VALOR
Retorna:
RESULTADO
O RETURNING
A palavra-chave fundamental é:
RETURNING
Ela define o valor devolvido pela função.
Exemplo:
PROCEDURE DIVISION
USING ENTRADA
RETURNING SAIDA
Sem RETURNING não existe função.
Como Chamar a Função
Agora imagine um programa principal.
IDENTIFICATION DIVISION.
PROGRAM-ID. TESTE.
Working Storage
01 WS-NUMERO PIC 9(4).
01 WS-RESULTADO PIC 9(5).
Chamada
MOVE 10 TO WS-NUMERO
COMPUTE WS-RESULTADO =
FUNCTION DOBRO(WS-NUMERO)
DISPLAY WS-RESULTADO
Resultado:
20
O Que o Compilador Faz?
Quando encontra:
FUNCTION DOBRO(...)
o compilador procura um módulo com:
FUNCTION-ID. DOBRO
e gera a ligação automaticamente.
É semelhante ao que acontece com:
FUNCTION CURRENT-DATE
Em Qual Biblioteca Deve Ser Gravado?
Aqui existe uma dúvida muito comum.
A função compilada gera um módulo objeto exatamente como qualquer outro programa COBOL.
Normalmente:
OBJETO
Vai para:
&&OBJ
SYSLIN
durante a compilação.
LOAD MODULE
Após o Link Edit:
LOADLIB
ou
STEPLIB
ou
USER.LOADLIB
dependendo dos padrões da empresa.
Exemplo:
PROD.COBOL.LOAD
ou
DEV.COBOL.LOAD
Que Tipo de Objeto é Criado?
Fisicamente o compilador gera:
Object Deck
OBJETO
e depois:
Program Object
ou
Load Module
dependendo da configuração do Binder.
Ou seja:
não existe um tipo especial de dataset para funções.
A função é armazenada como um módulo executável normal.
O diferencial está no:
FUNCTION-ID
Passo a Passo Completo
Passo 1
Criar o fonte.
Exemplo:
USER.COBOL(FDOBRO)
Passo 2
Codificar:
FUNCTION-ID. DOBRO.
Passo 3
Compilar.
Exemplo de JCL:
//COBOL EXEC IGYWCL
ou
//COB EXEC PROC=IGYWCLG
Dependendo do ambiente.
Passo 4
Gerar módulo em LOADLIB.
Exemplo:
USER.LOADLIB
Passo 5
Adicionar a LOADLIB na STEPLIB.
//STEPLIB DD DSN=USER.LOADLIB,
Passo 6
Compilar os programas consumidores.
O compilador localizará a função.
Funções Com Múltiplos Parâmetros
Exemplo:
FUNCTION-ID. SOMA2.
Linkage:
01 LK-N1 PIC S9(9).
01 LK-N2 PIC S9(9).
01 RETORNO PIC S9(9).
Procedure:
PROCEDURE DIVISION
USING LK-N1 LK-N2
RETURNING RETORNO.
COMPUTE RETORNO =
LK-N1 + LK-N2
GOBACK.
Uso:
COMPUTE TOTAL =
FUNCTION SOMA2(10,20)
Resultado:
30
Funções Podem Chamar Outras Funções
Sim.
Exemplo:
FUNCTION DOBRO(
FUNCTION SOMA2(5,5))
Primeiro:
SOMA2 = 10
Depois:
DOBRO = 20
Muito parecido com linguagens modernas.
Funções Podem Ser Recursivas?
Sim.
Desde que o compilador permita:
RECURSIVE
e que a lógica esteja preparada.
Mas normalmente regras de negócio não exigem isso.
Diferença Entre CALL e FUNCTION
CALL
CALL "CALCULO"
Características:
múltiplos parâmetros
sem retorno obrigatório
paradigma tradicional
FUNCTION
FUNCTION CALCULO(...)
Características:
retorno explícito
pode participar de expressões
sintaxe mais elegante
Exemplo Real de Negócio
Imagine validar CPF.
Em vez de:
CALL "CPFVAL"
você pode escrever:
IF FUNCTION CPF-VALIDO(CPF)
Muito mais legível.
A regra passa a parecer uma instrução nativa da linguagem.
Opções de Compilação Recomendadas
Nas versões atuais do Enterprise COBOL V6.x é comum utilizar:
OPT(2)
ARCH(13)
RENT
LIST
MAP
XREF
SSRANGE
Em desenvolvimento:
SSRANGE
ajuda bastante na identificação de erros.
Em produção:
NOSSRANGE
para melhor desempenho.
Compatibilidade
As User Defined Functions fazem parte das versões modernas do COBOL Enterprise.
São suportadas nas famílias atuais:
Enterprise COBOL V5
Enterprise COBOL V6
z/OS modernos
Sempre confirme a versão instalada junto ao time de sistemas.
Ganho Arquitetural
O maior benefício não é técnico.
É arquitetural.
Você passa a criar uma verdadeira biblioteca corporativa de regras.
Imagine uma empresa com funções:
CALCULA-IR
CALCULA-IOF
VALIDA-CPF
VALIDA-CNPJ
FORMATA-CEP
Todas reutilizadas por centenas de programas.
O resultado é:
menos código duplicado
manutenção centralizada
maior padronização
menor risco operacional
A Grande Sacada
Durante quarenta anos aprendemos que reutilização em COBOL significava:
CALL
Mas o COBOL moderno adicionou uma camada muito mais elegante.
Hoje podemos construir verdadeiras APIs corporativas diretamente dentro da linguagem usando:
FUNCTION-ID
e consumi-las com:
FUNCTION nome-da-funcao(...)
Para o desenvolvedor que ainda programa como em 1995, isso parece um detalhe.
Para quem projeta sistemas corporativos gigantescos, isso é uma mudança de paradigma.
Porque, pela primeira vez, o COBOL permite encapsular regras de negócio reutilizáveis com a mesma simplicidade com que usamos CURRENT-DATE, UPPER-CASE ou LENGTH.
E é justamente aí que mora a ironia: milhares de profissionais continuam criando subprogramas para tudo, enquanto o compilador moderno já oferece uma forma muito mais elegante de transformar regras de negócio em funções reutilizáveis.
Em outras palavras, o COBOL não virou uma linguagem nova.
Mas aprendeu um truque que muitos veteranos ainda não descobriram. ☕💣🚀
