Translate

Mostrar mensagens com a etiqueta Linkage Section. Mostrar todas as mensagens
Mostrar mensagens com a etiqueta Linkage Section. Mostrar todas as mensagens

domingo, 10 de fevereiro de 2019

☕💥 A Jornada do Padawan COBOL – Parte 2 Desvendando o Universo dos CALLs no Mainframe Parte II

 

Bellacosa Mainframe explora o comando CALL no COBOLparte II

☕💥 A Jornada do Padawan COBOL – Parte 2

Desvendando o Universo dos CALLs no Mainframe

Os Segredos de BY REFERENCE, BY CONTENT, BY VALUE, Ponteiros, Work-Storage e Local-Storage

Ou como descobrir que um simples CALL pode criar um S0C4 capaz de assombrar um desenvolvedor por semanas

Por Vagner Bellacosa – Bellacosa Mainframe


A Hora em que o Padawan descobre que CALL não é magia

Na Parte 1 descobrimos que existem dois grandes reinos:

  • Static CALL

  • Dynamic CALL

Mas ainda falta compreender algo muito mais importante.

O que realmente acontece quando passamos dados para outro programa?

Porque é aqui que nascem aproximadamente 70% dos S0C4 que já vi em produção.

E quase todos começam com uma frase inocente:

"Só acrescentei um campo..."


O Grande Segredo do COBOL

Muitos desenvolvedores vindos de Java imaginam algo parecido com:

funcao(cliente);

Criou cópia.

Passou objeto.

Garbage Collector resolve.

No Mainframe não existe fada madrinha.

Existe endereço de memória.

E apenas endereço.


O padrão COBOL

O padrão do COBOL é:

BY REFERENCE

Mesmo quando você não escreve.

CALL 'SUBPGM'
USING WS-CLIENTE.

É equivalente a:

CALL 'SUBPGM'
USING BY REFERENCE WS-CLIENTE.

Como funciona na memória

Programa principal

MAIN

00010000


WS-NOME

JOAO

CALL

Passa:

00010000

Subprograma

LINKAGE


LK-NOME

Recebe

00010000

Mesmo local.


Diagrama


MAIN


WS-NOME
+---------+
| JOAO    |
+---------+

      |
      |
      V


SUBPGM


LK-NOME


+---------+
| JOAO    |
+---------+



A magia acontece

Subrotina

MOVE 'MARIA' TO LK-NOME

Retorno

Main

MARIA

Mudou.

Porque é o mesmo endereço.


Vantagens

Muito rápido

Pouca memória

Zero cópia

Ideal tabelas grandes

VSAM

DB2

Buffers


Desvantagens

Subprograma pode destruir dados.

Sem querer.

Ou querendo.


O pesadelo do suporte

Programa A

passa saldo

Programa B

zera saldo

Programa A

grava no DB2

Cliente perde dinheiro.


O truque Jedi

Criar cópia antes.

MOVE WS-AREA TO WS-BACKUP

Quando usar

Grandes estruturas

100 mil registros

buffers VSAM

SQLDA

COMMAREA


CALL BY CONTENT

Agora o Padawan ganha maturidade.

Quer proteger dados.


Exemplo

CALL 'VALIDA'

USING
BY CONTENT WS-DATA

O compilador cria

uma área temporária.


Na memória

Original

WS-DATA


20250623

Cópia

TEMP


20250623

Subprograma recebe

TEMP


Alterações desaparecem

Subprograma

MOVE ZEROS TO LK-DATA

Volta

Main

Continua

20250623


Vantagens

Segurança

Proteção

Imutabilidade


Desvantagens

Consome memória.

Faz cópia.

CPU extra.


Benchmark imaginário

Estrutura

2 MB

1000 chamadas

By Reference

2 MB

By Content

2000 MB movimentados


O Mestre Mainframe pensa

Preciso alterar?

Não.

By Content.

Preciso compartilhar?

Reference.


CALL BY VALUE

Pouco conhecido.

Muito poderoso.


Surge com LE.

Language Environment.


Exemplo

CALL 'MINHAROT'

USING
BY VALUE WS-ID

Subrotina recebe

valor.

Não endereço.


É muito usado com

C

Assembler

LE APIs


Exemplo famoso

CALL 'CEE3ABD'

USING
BY VALUE 4095

O universo dos Ponteiros

Padawan vê isso.

USAGE POINTER

E fica com medo.

Com razão.


Exemplo

01 PTR USAGE POINTER.

Setar endereço

SET PTR TO ADDRESS OF WS-CLIENTE

PTR

00001000

Pode passar

CALL 'ROTINA'

USING PTR

Subprograma

recebe

endereço bruto.


É perigoso?

Muito.


Erro clássico

PTR inválido.

Resultado

S0C4


S0C4 explicado

CPU tenta acessar

endereço inexistente.


Exemplo

00000000

Crash.


LINKAGE SECTION

O portal interdimensional do COBOL.


Exemplo

LINKAGE SECTION.


01 LK-CLIENTE.


05 LK-NOME.


05 LK-ID.

Procedure Division

PROCEDURE DIVISION USING LK-CLIENTE.

Não aloca memória.

Nunca.


Apenas mapeia.


Work-Storage

Existe durante toda execução.


Carregado

uma vez.


Ideal

cache

tabelas

constantes


Exemplo

WORKING-STORAGE SECTION.


01 WS-CONTADOR PIC 9(9).

Local-Storage

Poucos usam.

Deveriam usar mais.


É recriado.

Toda chamada.


Exemplo

LOCAL-STORAGE SECTION.


01 LS-AREA.


05 LS-TEMP.

Diferença

WS

Persiste.

LS

Nasce.

Morre.


Exemplo

Chamada 1

contador=1

Chamada 2

contador=0


Excelente para

subrotinas reentrantes.

CICS.

LE.

Threads.


Reentrant

IBM adora isso.


Programa

não compartilha estado.


Evita corrupção.


Compilar

RENT

Erros clássicos

S0C4

Parâmetro errado


S0C7

Campo inválido


U4038

LE erro


S806

Programa não encontrado


Como validar

Antes do CALL

IF WS-PGM = SPACES

DISPLAY 'ERRO'

STOP RUN

END-IF

Conferir quantidade de parâmetros

IBM fornece

CEE3PRM

Easter Egg IBM

Muitos bancos possuem

CALL 'GENERICA'

Dentro.

EVALUATE WS-CODIGO

Mais de 300 WHEN.

Documentação

nenhuma.

Autor

aposentado em 2003.

Programa

continua funcionando.

Ninguém toca.

É conhecido como:

O Dragão Adormecido do Mainframe™


Dicas Bellacosa Mainframe

Dica 1

By Reference

90% dos casos.


Dica 2

By Content

Dados protegidos.


Dica 3

By Value

LE.

C.

Assembler.


Dica 4

Local-Storage

Muito subestimado.


Dica 5

Nunca assumir layout.

Validar tamanho.


Dica 6

Documente interfaces.

Algo parecido com:

************************************************
* ENTRADA
* CLIENTE
* DATA
*
* SAIDA
* RC
************************************************

A Filosofia Jedi do CALL – Parte 2

O Padawan iniciante pensa:

"Passar parâmetro é fácil."

O desenvolvedor intermediário pensa:

"By Reference é mais rápido."

O Mestre Mainframe entende:

"Passagem de parâmetros é um contrato binário entre programas."

E sabe que uma única alteração aparentemente inocente, como adicionar um campo em uma estrutura passada por referência, pode fazer um sistema bancário inteiro produzir S0C4, S0C7, dados corrompidos, abends misteriosos e algumas noites muito longas acompanhadas por café requentado e dumps de 500 MB.

Na próxima parte da jornada, o Padawan descobrirá os segredos de RETURN-CODE, GOBACK, STOP RUN, CEE3DMP, IPCS, CEEDUMP, rastreamento de CALLs, técnicas avançadas de troubleshooting, otimização de performance, análise de dumps e as ferramentas secretas usadas pelos Mestres Jedi do z/OS para domar os dragões da produção.


quinta-feira, 3 de janeiro de 2019

☕💥 A Jornada do Padawan COBOL – Parte 1 Desvendando o Universo dos CALLs no Mainframe

 

Bellacosa Mainframe e o CALL em programas COBOL Parte I

☕💥 A Jornada do Padawan COBOL – Parte 1

Desvendando o Universo dos CALLs no Mainframe

Ou como descobrir que chamar um programa em COBOL é quase tão importante quanto saber preparar café às 3 da manhã durante uma janela de produção

Por Vagner Bellacosa – Bellacosa Mainframe


Introdução

Todo desenvolvedor COBOL passa por um momento de iluminação.

Normalmente acontece quando ele abre um programa de produção com 30 mil linhas e encontra algo parecido com isto:

CALL 'PROG0001'
USING WS-AREA.

CALL WS-PROGRAMA
USING WS-COMMAREA.

CALL 'VALIDA01'
USING BY CONTENT WS-DATA.

CALL 'ROTINA99'
USING BY REFERENCE WS-BLOCO.

Neste momento surge a dúvida existencial:

Por que existem tantos tipos de CALL?

Qual é o mais rápido?

Qual gasta menos memória?

O que acontece dentro do z/OS?

O compilador faz mágica?

O Load Module engorda?

Como um banco executa milhões de CALLs por segundo sem explodir?

Prepare seu café.

Vamos abrir a tampa do motor do z/OS.


O que é um CALL?

Simplificando:

CALL significa pedir ajuda para outro programa.

Em vez de colocar 100 mil linhas em um único fonte, quebramos o sistema em pequenas peças reutilizáveis.

Por exemplo:

Programa principal

PROCESSA-CLIENTES

chama

VALIDA-CPF

CALCULA-JUROS

GERA-BOLETO

ENVIA-MQ

ATUALIZA-DB2

Cada um especializado.

É praticamente microserviços.

Só que inventados em 1960.


Por que IBM fez isso?

Porque memória custava uma fortuna.

Década de 70

Memória podia custar mais que um carro.

Era necessário:

reutilizar código

economizar memória

compartilhar lógica

facilitar manutenção

Assim nasceu o CALL.


Anatomia de um programa COBOL

Um programa COBOL compilado produz:

Objeto

Binder

Load Module

PDs Loadlib

Execução

Exemplo:

SYS1.LOADLIB


PROCESSA
VALIDA
JUROS
CPFCHK

O Padawan descobre o Static CALL

Exemplo

CALL 'VALIDA'

Simples.

Mas o compilador já conhece VALIDA.

Ele avisa o Binder:

Inclua VALIDA aqui.


O que acontece no LinkEdit

Binder faz:

PROCESSA


+

VALIDA


+

CPFCHK


+

JUROS


=

EXECUTÁVEL FINAL

Na memória

Antes:

PROCESSA

Depois:

PROCESSA


VALIDA


CPFCHK


JUROS

Tudo junto.

Tudo carregado.


Vantagens

Performance

Excelente.

Não precisa procurar.

Não precisa abrir bibliotecas.

Não precisa localizar módulo.

É praticamente:

BALR

Menor CPU

Menos instruções.

Menos overhead.

Menos I/O.


Desvantagens

Executável cresce.

Muito.

Exemplo

Programa principal

1 MB

Subrotinas

500 KB

Total

1,5 MB


Imagine 200 subrotinas.

Seu módulo vira um Godzilla.


Problema clássico

Padawan:

"Troquei VALIDA"

Produção:

Ainda usa antiga.

Porque precisa relinkar.


Quando usar?

Sempre que:

Programa nunca muda

Alta performance

Rotina crítica

Batch pesado

Exemplo:

Juros

Cálculo tributário

Validação interna


O Dynamic CALL aparece

Padawan evolui.

Descobre:

01 WS-PGM PIC X(8).

MOVE 'VALIDA' TO WS-PGM.

CALL WS-PGM.

O que acontece?

COBOL não sabe quem será chamado.

Somente em execução.


Busca do módulo

zOS procura:

STEPLIB

JOBLIB

LPA

LINKLIST


Exemplo

CALL CPFCHK

Sistema:

Existe?

Não.

Próximo.

Existe?

Sim.

Carrega.

Executa.


Vantagens

Flexibilidade absurda.

Pode trocar programas.

Sem recompilar.

Sem binder.

Sem relink.


Plugins COBOL

Exemplo

Cartão VISA

MOVE 'VISA0001'

Master

MOVE 'MASTER01'

PIX

MOVE 'PIX00001'

Mesmo sistema.

Rotinas diferentes.


Desvantagens

Procura programa.

Mais CPU.

Mais I/O.

Mais tempo.


Mas é lento?

Depende.

Primeira chamada.

Sim.

Segunda.

Muito rápida.

Porque pode ficar residente.


O segredo da residência

zOS é esperto.

Se programa está em memória.

Reutiliza.

Não busca novamente.


Comparação

Static

Casa própria

Dynamic

Airbnb

O executável cresce?

Static

Sim.

Dynamic

Não.

Executável principal fica pequeno.


Exemplo

Static

PROCESSA

1.5 MB

Dynamic

PROCESSA

600 KB

Subrotinas externas.


O que é mais performático?

Resposta curta.

Static.

Fim.

Mas...


O que é melhor?

Depende.

Banco.

Static.

Framework.

Dynamic.

Produtos.

Dynamic.

Rotinas financeiras.

Static.


Como o CALL funciona internamente?

Imagine isto.

Programa principal

00001000
PROCESSA

Subrotina

00025000
VALIDA

CALL executa

Guardar endereço retorno


Ir para 25000


Executar


Voltar

É praticamente um GOTO sofisticado.

Só que elegante.


Erros clássicos

S806

Programa não encontrado.

Mensagem

IEC806I

Causa

Módulo ausente.

STEPLIB errada.

Nome inválido.


S0C1

Executou lixo.

Programa corrompido.


S0C4

Endereço inválido.

Muito comum em parâmetros errados.


Como descobrir

SDSF

JESMSGLG

SYSOUT


Verificar:

STEPLIB

SYSLIB

LOADLIB


Easter Egg IBM

Muitos bancos possuem:

PROG0001

PROG0002

PROG0003

Ninguém sabe o que fazem.

Autor aposentou em 1998.

Documentação desapareceu.

Programa continua funcionando.

Todos têm medo de alterar.

É chamado:

Código Arqueológico Mainframe™


Dicas Bellacosa Mainframe

Dica 1

Static para alta frequência.


Dica 2

Dynamic para produtos.


Dica 3

Nunca fazer:

MOVE WS-USUARIO TO WS-PGM

CALL WS-PGM

Sem validar.

Pode chamar qualquer coisa.

Inclusive algo inexistente.


Dica 4

Validar sempre.

EVALUATE WS-PGM

WHEN 'CPFCHK'

WHEN 'JUROS01'

WHEN 'PIX0001'

WHEN OTHER

DISPLAY 'INVALIDO'

END-EVALUATE

Dica 5

Logar chamadas.

DISPLAY 'CALL=' WS-PGM

Ajuda muito.


A Filosofia Jedi do CALL

O Padawan iniciante pensa:

CALL serve apenas para executar outro programa.

O desenvolvedor intermediário pensa:

CALL serve para reutilizar código.

O Mestre Mainframe entende:

CALL é uma decisão arquitetural.

Ele impacta:

  • CPU

  • Memória

  • Tempo de resposta

  • Tamanho do Load Module

  • Facilidade de manutenção

  • Segurança

  • Escalabilidade

  • Observabilidade

  • Estratégia de deploy

E é exatamente por isso que, cinquenta anos depois, os sistemas bancários que movimentam bilhões de dólares diariamente ainda utilizam a mesma instrução COBOL que um programador digitou em um terminal verde na década de 1970:

CALL 'SUBPGM'

Na próxima etapa da jornada, o Padawan descobrirá que o verdadeiro poder do COBOL não está apenas em chamar programas, mas em como os dados atravessam a fronteira entre eles, mergulhando nos mistérios de BY REFERENCE, BY CONTENT, BY VALUE, ponteiros, Work-Storage, Local-Storage e Language Environment, onde vivem os temidos S0C4, os buffers compartilhados e os segredos que fazem alguns programas parecerem mágicos aos olhos dos desenvolvedores mais jovens.

quinta-feira, 23 de maio de 2013

☕🔥 ABEND S0C4 — O “BURACO NEGRO DA MEMÓRIA” NO MAINFRAME

 

Bellacosa Mainframe abend s0c4

☕🔥 ABEND S0C4 — O “BURACO NEGRO DA MEMÓRIA” NO MAINFRAME

Quando o IBM Z Diz:

“VOCÊ TOCOU EM UMA ÁREA QUE NÃO DEVERIA EXISTIR.”

Se existe um ABEND que faz veterano suspirar fundo…

é o lendário:

🚨 S0C4

E normalmente ele aparece assim:

SYSTEM COMPLETION CODE=0C4

ou:

PROTECTION EXCEPTION

ou ainda:

ADDRESSING EXCEPTION

E então o Junior Padawan entra em desespero:

“O COBOL explodiu?”
“O dataset corrompeu?”
“O CICS morreu?”
“A memória evaporou?”

☕ Respira.

Porque o S0C4 é um dos ABENDs MAIS IMPORTANTES da computação corporativa.


🔥 O QUE É O S0C4?

O S0C4 é um:

🚨 PROTECTION / ADDRESSING EXCEPTION

Traduzindo:

O PROGRAMA TENTOU ACESSAR UMA ÁREA DE MEMÓRIA INVÁLIDA.

Ou:

  • memória proibida

  • endereço inexistente

  • ponteiro inválido

  • storage corrompido

  • área não autorizada


☕ A FILOSOFIA DO S0C4

O IBM Z protege memória como um cofre nuclear.

Seu programa NÃO pode simplesmente sair acessando qualquer lugar.

Quando tenta…

💥 S0C4


🔥 ANALOGIA BELLACOSA MAINFRAME

Imagine um funcionário entrando em um banco.

Ele pode acessar:

✅ sua mesa
✅ seu departamento

Mas de repente tenta entrar:

❌ no cofre principal
❌ na sala do presidente
❌ na área militar subterrânea

O segurança aparece.

Isso é o:

☠️ S0C4


☕ O QUE REALMENTE ACONTECE

O programa executa:

MOVE
MVC
LOAD
STORE

Tudo normal.

Mas então tenta:

acessar endereço inválido

A MMU (Memory Management Unit) do IBM Z detecta:

❌ acesso ilegal

Resultado:

🚨 INTERRUPTION CODE → S0C4


🔥 OS TIPOS MAIS COMUNS DE S0C4


☠️ Protection Exception

Tentou acessar storage protegido.


☠️ Addressing Exception

Endereço inválido.


☠️ Translation Exception

Página inexistente.


☠️ Storage Overlay

Memória corrompida anteriormente.


☕ O MAIOR VILÃO DO S0C4

🚨 SUBSCRIPT FORA DA TABELA

O clássico dos clássicos.


🔥 EXEMPLO COBOL JUNIOR

01 WS-TABELA.
   05 WS-ITEM OCCURS 10 TIMES
      PIC X(10).

01 IDX PIC 9(04).

Tudo bem.

Mas aí:

MOVE WS-ITEM(999) TO WS-CAMPO

O COBOL tenta acessar memória além da tabela.

Resultado:

☠️ S0C4


☕ O DEMÔNIO CHAMADO SSRANGE

Sem:

SSRANGE

o COBOL NÃO protege tabelas adequadamente.

Então:

  • leitura inválida

  • corrupção silenciosa

  • overlay

  • S0C4 mais tarde


🔥 O S0C4 FANTASMA

O mais assustador.

Erro aparece LONGE da causa real.


☕ EXEMPLO

Linha 100:

MOVE lixo para tabela

Linha 5000:

💥 S0C4

O dano ocorreu antes.

Mas a explosão veio depois.


🔥 O S0C4 E O CICS

No CICS normalmente vira:

🚨 ASRA + S0C4

O CICS intercepta o program check.


☕ O CASO MAIS FAMOSO NO CICS

DFHCOMMAREA inválida

Programa espera:

01 DFHCOMMAREA.
   05 WS-CODIGO PIC 9(05).

Mas recebe:

  • tamanho menor

  • layout diferente

  • lixo

  • ponteiro inválido

Agora:

MOVE WS-CODIGO

explode.


🔥 O LINKAGE SECTION MALDITO

Outro clássico.


☕ EXEMPLO

PROCEDURE DIVISION USING LK-AREA.

Mas o chamador envia:

parâmetro incompatível

Agora o programa lê memória errada.

Resultado:

☠️ S0C4


🔥 O VERDADEIRO HORROR: OVERLAY

Aqui começa o lado sombrio do mainframe.


☕ O QUE É OVERLAY?

Programa sobrescreve memória alheia.

Exemplo:

STRING A B C
 INTO CAMPO-PEQUENO

Overflow.

Agora memória próxima é destruída.

Mais tarde:

💥 S0C4


🔥 O S0C4 E O PONTEIRO NULO

Muito comum em:

  • assembler

  • C

  • LE

  • APIs

Equivalente mainframe do:

NULL POINTER


☕ O QUE O DUMP ESTÁ DIZENDO

O dump do S0C4 é um mapa do crime.

Veteranos leem como CSI mainframe.


🔥 COMO INVESTIGAR PASSO A PASSO


✅ PASSO 1 — IDENTIFIQUE O PSW

Exemplo:

PSW AT TIME OF ERROR

Esse é o GPS do desastre.


✅ PASSO 2 — PEGUE O INTERRUPTION CODE

Exemplo:

0004

ou:

00000010

Ajuda identificar:

  • protection

  • addressing

  • translation


✅ PASSO 3 — IDENTIFIQUE O OFFSET

Exemplo:

OFFSET X'02FA'

✅ PASSO 4 — CRUZE COM O LISTING COBOL

Agora você encontra:

MOVE WS-TABELA(IDX)

Boom.

Caso resolvido.


☕ O SEGREDO DOS REGISTERS

Especialmente:

R1
R13
R14
R15

☕ R13

Stack/save area.


☕ R14

Return address.


☕ R15

Entry point/programa.


🔥 O HEXADECIMAL ENTRE AS SOMBRAS

Veteranos analisam:

00000000

Endereço zero.

Clássico ponteiro inválido.


☕ O “LOW VALUES DA MORTE”

Outro clássico:

X'00'

Memória zerada sendo usada como endereço.


🔥 O S0C4 E O AMODE/RMODE

Modo arquimago mainframe ativado.

Problemas entre:

  • 24 bits

  • 31 bits

  • 64 bits

podem gerar endereços inválidos.


☕ O S0C4 E O COBOL MODERNO

Hoje ainda ocorre muito por:

  • APIs

  • ponteiros

  • XML PARSE

  • JSON PARSE

  • LE

  • integração C


🔥 COMO EVITAR S0C4


✅ Compile com SSRANGE


✅ Valide índices


✅ Revise OCCURS


✅ Cuidado com REDEFINES


✅ Valide COMMAREA


✅ Nunca confiar em parâmetro externo


✅ Revisar overlays


☕ O SSRANGE — O ESCUDO DOS JEDIS

Compilar:

SSRANGE

faz o COBOL detectar acesso inválido ANTES da corrupção.

Sem isso:

corrupção silenciosa.


🔥 CURIOSIDADE HISTÓRICA

O S0C4 vem das arquiteturas:

IBM System/360

Década de:

🏛️ 1960

É literalmente um dos mecanismos clássicos de proteção de memória da história da computação.


☕ EASTER EGG MAINFRAME

Veteranos brincam:

“S0C4 é o mainframe dizendo:

VOCÊ TOCOU ONDE NÃO DEVIA.”


🔥 O MAIOR ERRO DO PADAWAN

Olhar apenas:

S0C4

e pensar:

“o COBOL morreu aqui.”

Não.

Frequentemente:

o crime aconteceu muito antes.


☕ A VERDADE FINAL

O S0C7 destrói números.
O S0C1 destrói instruções.
Mas…

☕ O S0C4 DESTRÓI A PRÓPRIA GEOGRAFIA DA MEMÓRIA.

Porque naquele instante…

O PROGRAMA TENTOU ATRAVESSAR UMA FRONTEIRA QUE O IBM Z JAMAIS PERMITIRIA.

terça-feira, 27 de fevereiro de 2007

Chamando Subprogramas em COBOL – Tipos de comandos CALL

 

Bellacosa Mainframe e o comando CALL e subprogramas em COBOL

Chamando Subprogramas em COBOL – Tipos de comandos CALL

Um dos recursos mais importantes do COBOL é a capacidade de dividir uma aplicação em vários módulos menores chamados:

Subprogramas

Isso permite reutilização de código, manutenção mais simples e melhor organização das aplicações Mainframe.


O que é um Subprograma?

É um programa COBOL que é chamado por outro programa.


Estrutura

Programa Principal
        ↓
     CALL
        ↓
   Subprograma
        ↓
     GOBACK
        ↓
Programa Principal

Exemplo Simples

Programa Principal:

CALL 'CALCULA'.

Subprograma:

IDENTIFICATION DIVISION.
PROGRAM-ID. CALCULA.

PROCEDURE DIVISION.

DISPLAY 'ENTREI NO SUBPROGRAMA'.

GOBACK.

Resultado:

ENTREI NO SUBPROGRAMA

Tipos de CALL

Existem vários tipos de chamada.


1. CALL Estático

O nome do programa é conhecido durante a compilação.

CALL 'CALCULA'

Características:

✅ Mais rápido

✅ Verificação na Linkedição

✅ Muito usado em Batch


Fluxo:

MAIN
 ↓
CALL 'CALCULA'
 ↓
CALCULA

2. CALL Dinâmico

O nome do programa está em uma variável.

01 WS-PGM PIC X(8).

MOVE 'CALCULA' TO WS-PGM.

CALL WS-PGM.

Características:

✅ Flexibilidade

✅ Escolha em tempo de execução

✅ Muito usado em frameworks


Fluxo:

WS-PGM
   ↓
CALCULA
VALIDA
CONSULTA

Exemplo

IF TIPO = 'A'

   MOVE 'CALCA' TO WS-PGM

ELSE

   MOVE 'CALCB' TO WS-PGM

END-IF

CALL WS-PGM

3. Nested Program Call

Programa interno chamando outro.

IDENTIFICATION DIVISION.
PROGRAM-ID. MAIN.

PROCEDURE DIVISION.

CALL 'SUB1'.

PROGRAM-ID. SUB1.

CALL 'SUB2'.

Fluxo:

MAIN
 ↓
SUB1
 ↓
SUB2

4. CALL Recursivo

Um programa chama ele próprio.

Necessário:

RECURSIVE PROGRAM

Exemplo:

IDENTIFICATION DIVISION.
PROGRAM-ID. FATORIAL
RECURSIVE.

Fluxo:

FATORIAL
    ↓
FATORIAL
    ↓
FATORIAL

5. CALL para Módulos LE

Chamada de rotinas do Language Environment.

Exemplo:

CALL 'CEE3ABD'

Usado para:

  • ABEND controlado

  • Datas

  • Hora

  • Serviços LE


6. CALL para Rotinas Assembler

Muito comum em Mainframe.

CALL 'ROTASM01'

Fluxo:

COBOL
 ↓
ASSEMBLER
 ↓
COBOL

7. CALL para CICS

Em CICS normalmente usamos:

EXEC CICS LINK
     PROGRAM('PROG2')
END-EXEC.

Ou

EXEC CICS XCTL
     PROGRAM('PROG2')
END-EXEC.

LINK x XCTL

LINK

Retorna ao chamador.

PROG1
 ↓
LINK
 ↓
PROG2
 ↓
Retorna

XCTL

Não retorna.

PROG1
 ↓
XCTL
 ↓
PROG2

Passagem de Parâmetros

O mais comum.


Programa Principal

CALL 'CALCULA'
USING WS-VALOR.

Subprograma

LINKAGE SECTION.

01 LK-VALOR PIC 9(5).

PROCEDURE DIVISION USING LK-VALOR.

Fluxo

MAIN
 ↓
USING
 ↓
LINKAGE

Múltiplos Parâmetros

Programa Principal:

CALL 'CALCULA'

USING

   WS-NOME
   WS-SALDO
   WS-DATA.

Subprograma:

PROCEDURE DIVISION USING

   LK-NOME
   LK-SALDO
   LK-DATA.

BY REFERENCE

Padrão do COBOL.

Passa endereço.

CALL 'PROG1'

USING BY REFERENCE WS-NOME.

Pode alterar o valor original.


BY CONTENT

Passa cópia.

CALL 'PROG1'

USING BY CONTENT WS-NOME.

Não altera a variável original.


BY VALUE

Passa valor diretamente.

Muito usado em integração com C.

CALL 'PROG1'

USING BY VALUE WS-CODIGO.

Exemplo

MOVE 100 TO WS-VALOR

CALL 'TESTE'

USING BY CONTENT WS-VALOR

Subprograma altera:

MOVE 500 TO LK-VALOR

Resultado:

WS-VALOR = 100

CANCEL

Remove programa da memória.

CANCEL 'CALCULA'

Muito usado após CALL dinâmico.


Fluxo

CALL
 ↓
Executa
 ↓
CANCEL
 ↓
Memória liberada

CALL e Load Modules

O programa chamado precisa estar:

STEPLIB
JOBLIB
LINKLIST
LPA

Erros Comuns

S806

Programa não encontrado.

S806

U4038

Erro interno.


S0C4

Parâmetro incorreto.


Boas Práticas

✅ Usar GOBACK nos subprogramas

✅ Validar parâmetros recebidos

✅ Documentar USING

✅ Evitar excesso de níveis CALL

✅ Utilizar COPYBOOK para parâmetros


Exemplo Corporativo

MAIN
 │
 ├── VALIDA
 │
 ├── CONSULTA-DB2
 │
 ├── CALCULA-JUROS
 │
 ├── GERA-ARQUIVO
 │
 └── LOG-ERRO

Cada módulo é um subprograma especializado.


Resumo Rápido

TipoCaracterística
CALL EstáticoNome fixo
CALL DinâmicoNome variável
NestedPrograma dentro de programa
RecursivoChama a si próprio
LINK CICSRetorna
XCTL CICSNão retorna
BY REFERENCEPassa endereço
BY CONTENTPassa cópia
BY VALUEPassa valor
CANCELRemove da memória

Conclusão

O comando CALL é o mecanismo que permite a modularização das aplicações COBOL. Através dele, programas podem compartilhar regras de negócio, reutilizar código e organizar grandes sistemas corporativos em componentes menores. Dominar CALL estático, dinâmico, parâmetros USING, BY REFERENCE, BY CONTENT, BY VALUE, LINK, XCTL e CANCEL é essencial para qualquer programador COBOL que deseje atuar em ambientes Mainframe modernos.