Bellacosa Mainframe e o Rambo codificando programas cobol mainframe

☕ Um Café no Bellacosa Mainframe

Rambo e as Quatro Divisões — O Caminho das Pedras para Escrever seu Primeiro Programa COBOL sem Voltar do Vietnã para uma América Desconhecida

Ou: você já sabe entrar no TSO, abrir o ISPF, submeter JCL e reconhecer um `S0C7`; falta descobrir que um programa COBOL não nasce inteiro — ele é montado, uma decisão pequena por vez.

Há um momento estranho na vida de quem começa COBOL no z/OS.

O aluno já entra no TSO. Abre o ISPF. Encontra um membro numa PDS. Submete um JOB. Vai ao SDSF, vê CC 0000, vê ABEND, talvez até saiba que o compilador fica em algum lugar atrás daquele JCL aparentemente escrito em sânscrito administrativo.

Então o instrutor diz: “agora escreva um programa”. E a tela fica vazia como uma estrada à noite.

Não é falta de inteligência nem de vontade. É que até aqui ensinaram os cômodos da fábrica; ninguém mostrou como uma peça nasce. O iniciante recebe palavras enormes — IDENTIFICATION DIVISION, arquivo, PERFORM, WORKING-STORAGE, compilação — antes de aprender a primeira disciplina de sobrevivência: um programa é uma sequência explícita de perguntas e ações.

John Rambo entenderia a sensação. O sujeito voltou de uma guerra, trouxe competência real, mas aterrissou num lugar cujas regras não reconhece. O aluno COBOL também: conhece comandos isolados, mas ainda não tem o mapa para transformar um problema em fonte executável.

Vamos construir esse mapa. Sem magia, sem “copie este monstro de 800 linhas e reze”. No fim haverá um programa compilado, executado e observável no SDSF.

Missão do laboratório: ler dois números inteiros fornecidos pelo SYSIN, somá-los e informar o resultado. Se a entrada não for numérica, terminar de forma controlada.

É um problema pequeno de propósito. Se você não consegue explicar cada linha de um programa de 70 linhas, um programa de 7 mil linhas só é uma floresta maior.

1. Antes de abrir o editor: Rambo não atira no escuro

O erro clássico é começar pela primeira linha de COBOL e tentar “pensar dentro da sintaxe”. Isso é como começar a construir uma ponte escolhendo o parafuso.

Primeiro escreva, em português comum, o contrato do programa:

Pergunta	Resposta desta missão
Qual é a entrada?	Dois números inteiros, um por linha, recebidos no `SYSIN`.
Qual é a saída?	Uma mensagem com a soma, enviada ao `SYSOUT`.
O que pode dar errado?	A linha não contém número ou falta uma das linhas.
Qual regra será aplicada?	Só soma quando as duas entradas são numéricas.
Como saberei que funcionou?	No `JESMSGLG`/`SYSOUT`, aparece a soma; o job fecha com `CC 0000`.

Agora reduza a lógica a pseudocódigo:

receber primeiro valor
receber segundo valor
se ambos são números
    somar
    mostrar resultado
senão
    mostrar mensagem de erro
    encerrar com código 8
fim-se
encerrar normalmente

Esse papel é o primeiro “programa”. COBOL será apenas a tradução disciplinada dele.

O truque que salva o iniciante

Antes de escrever uma instrução, complete a frase: “eu preciso guardar…”.

Para esta missão, precisamos guardar:

o texto bruto que chegou do SYSIN;
os dois valores convertidos para número;
o resultado;
uma forma de saber se a entrada é válida.

Pronto: você acabou de descobrir quase toda a DATA DIVISION.

2. As quatro divisões: quatro placas na trilha

COBOL não é uma língua que começa a contar uma história logo na primeira linha. Ele organiza o programa em quatro áreas. Pense nelas como as placas que Rambo fincaria na mata para não andar em círculos.

Divisão	Pergunta que responde	Nesta missão
`IDENTIFICATION DIVISION`	Quem é este programa?	Nome do programa.
`ENVIRONMENT DIVISION`	Com que ambiente/dispositivos ele conversa?	`SYSIN` e `SYSOUT`.
`DATA DIVISION`	Quais dados existem e como são descritos?	Entradas, números e resultado.
`PROCEDURE DIVISION`	O que acontece, em qual ordem?	Ler, validar, somar, exibir e terminar.

Uma dica de leitura para o resto da carreira:

Dados não fazem nada; procedimentos não guardam nada.

Quando você se perde, pergunte: “estou descrevendo uma coisa ou mandando executar uma ação?” Coisa vai para DATA; ação vai para PROCEDURE.

3. Primeiro marco: dar identidade ao recruta

Todo programa começa assim:

       IDENTIFICATION DIVISION.
       PROGRAM-ID. SOMA001.

PROGRAM-ID é o nome pelo qual o programa será conhecido pelo compilador e, em geral, pelo ambiente de execução. Use um nome que respeite a convenção local. Aqui, SOMA001 é curto, didático e cabe nas convenções tradicionais.

Não coloque regra de negócio aqui. Não declare variáveis aqui. Não tente impressionar o compilador. Esta divisão responde apenas: “quem se apresentou para a missão?”

4. Segundo marco: ligar a estrada de entrada e saída

Num programa batch simples, o JCL entrega recursos ao programa por DDNAME. SYSIN costuma ser a entrada padrão e SYSOUT a saída de mensagens. O COBOL precisa declarar que usará esses nomes.

       ENVIRONMENT DIVISION.
       INPUT-OUTPUT SECTION.
       FILE-CONTROL.
           SELECT ENTRADA ASSIGN TO SYSIN
               ORGANIZATION IS LINE SEQUENTIAL.
           SELECT SAIDA ASSIGN TO SYSOUT
               ORGANIZATION IS LINE SEQUENTIAL.

Traduzindo sem fumaça:

SELECT ENTRADA: dentro do COBOL, chamaremos esse fluxo de ENTRADA;
ASSIGN TO SYSIN: no JCL, ele será conectado ao DD chamado SYSIN;
LINE SEQUENTIAL: vamos tratar uma linha por vez, ideal para o exercício;
o mesmo raciocínio vale para SAIDA/SYSOUT.

Agora descrevemos os registros desses fluxos na DATA DIVISION.

5. Terceiro marco: a mochila de dados (`DATA DIVISION`)

A DATA DIVISION tem seções. Para este laboratório, usaremos duas:

FILE SECTION: como é cada linha lida ou gravada nos arquivos lógicos;
WORKING-STORAGE SECTION: a mochila do programa, onde ficam os dados de trabalho enquanto ele está em execução.

       DATA DIVISION.
       FILE SECTION.
       FD  ENTRADA.
       01  REG-ENTRADA                 PIC X(20).

       FD  SAIDA.
       01  REG-SAIDA                   PIC X(80).

       WORKING-STORAGE SECTION.
       01  WS-PRIMEIRO-TEXTO           PIC X(20).
       01  WS-SEGUNDO-TEXTO            PIC X(20).
       01  WS-PRIMEIRO-NUMERO          PIC 9(9).
       01  WS-SEGUNDO-NUMERO           PIC 9(9).
       01  WS-RESULTADO                PIC 9(10).
       01  WS-RESULTADO-EDITADO        PIC Z(9)9.

Como ler uma declaração COBOL

Pegue esta linha:

       01  WS-PRIMEIRO-NUMERO          PIC 9(9).

01 é o nível: um item independente;
WS-PRIMEIRO-NUMERO é o nome escolhido por nós; WS- é uma convenção comum para Working-Storage;
PIC 9(9) reserva nove posições numéricas, sem sinal e sem casas decimais.

O texto de entrada é PIC X(20) porque, quando a linha chega, ela é apenas texto. Antes de fazer conta, nós perguntaremos se ela é numérica e só então a moveremos para um campo numérico.

Esse detalhe evita o famoso S0C7: tentar tratar lixo como número. O S0C7 não é um fantasma; é normalmente a máquina dizendo, com pouca delicadeza, “você prometeu que havia dígitos aqui”.

WS-RESULTADO-EDITADO usa Z(9)9: os Z suprimem zeros à esquerda na apresentação. Assim, em vez de mostrar 0000000042, mostramos 42.

6. Quarto marco: transformar o roteiro em `PROCEDURE DIVISION`

Agora o programa ganha vida. Em COBOL, é saudável criar pequenos parágrafos com nomes que expliquem a intenção. Não escreva um único bloco de 400 linhas chamado MAIN. Isso é o equivalente corporativo de entrar na mata sem bússola.

       PROCEDURE DIVISION.
       0000-PRINCIPAL.
           PERFORM 1000-RECEBER-DADOS
           PERFORM 2000-VALIDAR-E-PROCESSAR
           PERFORM 9000-ENCERRAR
           .

Leia em voz alta: “execute receber dados; execute validar e processar; execute encerrar”. Se a leitura parece português burocrático, está no caminho certo.

O ponto final após o último comando encerra o parágrafo. Em código real, a convenção da equipe pode ser diferente, mas o princípio é o mesmo: seja consistente.

Receber dados

       1000-RECEBER-DADOS.
           READ ENTRADA
               AT END
                   MOVE SPACES TO WS-PRIMEIRO-TEXTO
               NOT AT END
                   MOVE REG-ENTRADA TO WS-PRIMEIRO-TEXTO
           END-READ

           READ ENTRADA
               AT END
                   MOVE SPACES TO WS-SEGUNDO-TEXTO
               NOT AT END
                   MOVE REG-ENTRADA TO WS-SEGUNDO-TEXTO
           END-READ
           .

Aqui há uma disciplina importante: READ lê para REG-ENTRADA, o registro definido na FILE SECTION. Em seguida copiamos para o campo de trabalho correspondente. A segunda leitura sobrescreverá REG-ENTRADA, e isso é normal.

Se não existir linha, colocamos espaços no campo. Mais adiante, a validação o rejeitará. Isso é muito melhor do que fingir que a linha existe.

Validar, converter, somar ou terminar com erro controlado

       2000-VALIDAR-E-PROCESSAR.
           IF FUNCTION TEST-NUMVAL(WS-PRIMEIRO-TEXTO) = 0
              AND FUNCTION TEST-NUMVAL(WS-SEGUNDO-TEXTO) = 0
               COMPUTE WS-PRIMEIRO-NUMERO =
                   FUNCTION NUMVAL(WS-PRIMEIRO-TEXTO)
               COMPUTE WS-SEGUNDO-NUMERO =
                   FUNCTION NUMVAL(WS-SEGUNDO-TEXTO)
               ADD WS-PRIMEIRO-NUMERO
                   WS-SEGUNDO-NUMERO
                   GIVING WS-RESULTADO
               MOVE WS-RESULTADO TO WS-RESULTADO-EDITADO
               MOVE SPACES TO REG-SAIDA
               STRING 'SOMA = ' DELIMITED BY SIZE
                      WS-RESULTADO-EDITADO DELIMITED BY SIZE
                 INTO REG-SAIDA
               END-STRING
               WRITE REG-SAIDA
           ELSE
               MOVE 'ERRO: INFORME DOIS NUMEROS INTEIROS.'
                 TO REG-SAIDA
               WRITE REG-SAIDA
               MOVE 8 TO RETURN-CODE
           END-IF
           .

Há cinco ferramentas essenciais aqui:

IF ... END-IF: escolhe um caminho. Sempre prefira o terminador explícito END-IF; ele evita que um ELSE perdido faça estrago mais à frente.
FUNCTION TEST-NUMVAL: verifica se o texto pode representar um número. Resultado 0 significa que é válido; ela aceita os espaços que normalmente acompanham uma linha curta recebida pelo SYSIN.
FUNCTION NUMVAL: converte o texto validado para valor numérico. A regra de ouro permanece: nunca converta antes de validar.
ADD ... GIVING: faz a soma e coloca o resultado no destino.
WRITE: envia o registro preparado para o fluxo de saída.

E entra um veterano importante: RETURN-CODE. Ele é uma área especial usada para devolver o resultado da execução ao z/OS/JES. 0 costuma significar sucesso; 8, erro de negócio ou entrada inválida neste exercício. Os significados formais dependem da política do seu ambiente, mas a ideia é universal: não esconda falhas.

Encerrar não é um detalhe

       9000-ENCERRAR.
           CLOSE ENTRADA
                 SAIDA
           GOBACK
           .

CLOSE finaliza os arquivos. GOBACK devolve o controle a quem chamou o programa — no nosso caso, o ambiente batch. Um programa que “parece ter terminado” mas não fecha recursos corretamente vira uma pequena dor de cabeça que cresce em produção.

7. O programa completo: uma peça que você consegue explicar

Crie um membro, por exemplo SOMA001, na PDS usada para fontes COBOL e coloque o código abaixo. Em ambientes de cartão fixo, respeite a coluna 8 para início do código; no editor ISPF, a numeração à esquerda normalmente já o mantém no lugar. Se sua instalação usa formato livre, siga o padrão definido por ela.

       IDENTIFICATION DIVISION.
       PROGRAM-ID. SOMA001.

       ENVIRONMENT DIVISION.
       INPUT-OUTPUT SECTION.
       FILE-CONTROL.
           SELECT ENTRADA ASSIGN TO SYSIN
               ORGANIZATION IS LINE SEQUENTIAL.
           SELECT SAIDA ASSIGN TO SYSOUT
               ORGANIZATION IS LINE SEQUENTIAL.

       DATA DIVISION.
       FILE SECTION.
       FD  ENTRADA.
       01  REG-ENTRADA                 PIC X(20).

       FD  SAIDA.
       01  REG-SAIDA                   PIC X(80).

       WORKING-STORAGE SECTION.
       01  WS-PRIMEIRO-TEXTO           PIC X(20).
       01  WS-SEGUNDO-TEXTO            PIC X(20).
       01  WS-PRIMEIRO-NUMERO          PIC 9(9).
       01  WS-SEGUNDO-NUMERO           PIC 9(9).
       01  WS-RESULTADO                PIC 9(10).
       01  WS-RESULTADO-EDITADO        PIC Z(9)9.

       PROCEDURE DIVISION.
       0000-PRINCIPAL.
           OPEN INPUT ENTRADA
                OUTPUT SAIDA
           PERFORM 1000-RECEBER-DADOS
           PERFORM 2000-VALIDAR-E-PROCESSAR
           PERFORM 9000-ENCERRAR
           .

       1000-RECEBER-DADOS.
           READ ENTRADA
               AT END
                   MOVE SPACES TO WS-PRIMEIRO-TEXTO
               NOT AT END
                   MOVE REG-ENTRADA TO WS-PRIMEIRO-TEXTO
           END-READ

           READ ENTRADA
               AT END
                   MOVE SPACES TO WS-SEGUNDO-TEXTO
               NOT AT END
                   MOVE REG-ENTRADA TO WS-SEGUNDO-TEXTO
           END-READ
           .

       2000-VALIDAR-E-PROCESSAR.
           IF FUNCTION TEST-NUMVAL(WS-PRIMEIRO-TEXTO) = 0
              AND FUNCTION TEST-NUMVAL(WS-SEGUNDO-TEXTO) = 0
               COMPUTE WS-PRIMEIRO-NUMERO =
                   FUNCTION NUMVAL(WS-PRIMEIRO-TEXTO)
               COMPUTE WS-SEGUNDO-NUMERO =
                   FUNCTION NUMVAL(WS-SEGUNDO-TEXTO)
               ADD WS-PRIMEIRO-NUMERO
                   WS-SEGUNDO-NUMERO
                   GIVING WS-RESULTADO
               MOVE WS-RESULTADO TO WS-RESULTADO-EDITADO
               MOVE SPACES TO REG-SAIDA
               STRING 'SOMA = ' DELIMITED BY SIZE
                      WS-RESULTADO-EDITADO DELIMITED BY SIZE
                 INTO REG-SAIDA
               END-STRING
               WRITE REG-SAIDA
           ELSE
               MOVE 'ERRO: INFORME DOIS NUMEROS INTEIROS.'
                 TO REG-SAIDA
               WRITE REG-SAIDA
               MOVE 8 TO RETURN-CODE
           END-IF
           .

       9000-ENCERRAR.
           CLOSE ENTRADA
                 SAIDA
           GOBACK
           .

Pare antes de compilar e faça a prova Rambo: aponte para cada bloco e responda o que ele guarda ou faz. Se não consegue responder, não é hora de decorar mais comandos; é hora de reduzir o trecho até compreendê-lo.

8. O JCL: o caminhão que leva o recruta até o campo de teste

Cada empresa possui procedure, bibliotecas e padrões próprios. Por isso, não copie cegamente os nomes de bibliotecas abaixo. Use o PROC de compilação que sua turma ou instalação já fornece. O objetivo é entender a estrutura.

Um JCL didático pode ter este desenho:

//SOMAJOB  JOB (ACCT),'ALUNO',CLASS=A,MSGCLASS=H,NOTIFY=&SYSUID
//COMPILE  EXEC IGYWCL,PGM=SOMA001
//COBOL.SYSIN DD DSN=SEU.USUARIO.COBOL(SOMA001),DISP=SHR
//GO.SYSIN     DD *
12
30
/*
//GO.SYSOUT    DD SYSOUT=*

O que interessa aqui:

Parte	Tradução humana
`EXEC IGYWCL`	Chama uma procedure de compilar, linkeditar e executar COBOL. O nome pode variar na sua instalação.
`PGM=SOMA001`	Indica o nome do módulo/programa.
`COBOL.SYSIN`	Entrega o membro-fonte ao passo de compilação. Alguns PROCs usam outro DDNAME; confira o padrão local.
`GO.SYSIN DD *`	Entrega dados de teste diretamente no JCL ao passo de execução.
`GO.SYSOUT`	Pede que as mensagens produzidas pelo programa sejam direcionadas para a saída do job.

Em muitos laboratórios, a procedure já faz compile + link + go, mas com nomes diferentes, como COBCLG, IGYWCLG ou um PROC local. O procedimento certo é o que existe no seu ambiente, não o que alguém colou num fórum em 2009.

Se a sua procedure só compila e linkedita, faça dois JOBs: primeiro construa o load module; depois execute-o com um passo EXEC PGM=SOMA001, acrescentando ao STEPLIB a load library indicada pelo instrutor.

9. Do `SUB` ao SDSF: onde procurar primeiro

Depois de salvar fonte e JCL, submeta o job. A rotina de investigação do iniciante deve ser sempre a mesma:

No ISPF, confirme que salvou o membro certo.
Digite SUB no comando primário do editor JCL ou use a opção de submit disponível.
No SDSF, abra ST e localize seu job.
Veja o resultado geral: CC 0000 é a luz verde; qualquer ABEND ou CC inesperado pede leitura.
Abra primeiro JESMSGLG: ele conta a história cronológica do job.
Abra a listagem do compilador (SYSPRINT, SYSOUT ou nome equivalente) se a compilação falhou.
Abra o SYSOUT do passo de execução para procurar SOMA = 42.

Para o teste com 12 e 30, a saída esperada é:

SOMA = 42

E o job deve fechar com CC 0000.

Faça também o teste de falha:

12
RAMBO

Agora a saída deve trazer a mensagem de erro, e o passo de execução deve terminar com CC 0008. Isto é sucesso do teste: o programa identificou uma entrada inválida sem cair num abend.

10. Quando der errado: o que a trilha está tentando dizer

Sintoma	Suspeita inicial	Primeira ação
Erros na compilação	Ponto faltando, palavra reservada, colunas/formato ou estrutura incompleta	Leia a primeira mensagem de erro do compilador; as seguintes podem ser consequência dela.
`S0C7`	Campo não numérico usado em operação numérica	Verifique onde houve `MOVE`, `ADD`, `COMPUTE` ou comparação; valide a entrada antes.
`S806`	Programa não foi encontrado para executar	Confira link-edit, nome do `PGM`, `STEPLIB`/`JOBLIB` e load library.
`S013` ou erro de arquivo	DCB/atributos ou modo de abertura incompatíveis	Confira o DD no JCL, `OPEN INPUT/OUTPUT` e o formato esperado.
`CC 0000`, mas nada aparece	Você escreveu em uma saída diferente da que está olhando, ou não executou o caminho do `WRITE`	Confira o `GO.SYSOUT` e adicione uma mensagem simples de rastreio temporária.

O comando tático é: leia a primeira causa, não a última explosão. Um ponto ausente pode criar vinte mensagens do compilador; consertar a vigésima é combater fumaça.

11. Os sete hábitos de quem deixa de apenas “saber comandos”

Comece pelo contrato, não pelo teclado. Entrada, saída, regra e erro antes da sintaxe.
Faça uma versão minúscula funcionar. Primeiro leia e dê DISPLAY; depois some; depois valide; só então enfeite.
Dê nomes que contem a história. WS-VALOR-ORIGEM é melhor que WS-A; 2000-CALCULAR-TOTAL é melhor que ROT2.
Separe dados de ações. Campo na DATA DIVISION; decisão e processamento na PROCEDURE DIVISION.
Valide bordas. Entrada vazia, letra em campo numérico, zero, valor máximo: os incidentes moram nas fronteiras.
Compile cedo e frequentemente. Não escreva 300 linhas antes do primeiro compile. Entregue pequenas etapas ao compilador.
Use o SDSF como painel, não como tribunal. Ele não está ali para humilhar ninguém; mostra o que de fato foi submetido e executado.

12. A próxima missão: aumentar só uma pedra por vez

Depois que SOMA001 funcionar, não pule direto para CICS, Db2 e um cadastro de clientes com 40 telas. Evolua em degraus:

Troque a soma por subtração e multiplicação.
Leia vários pares até fim de arquivo; aí você descobrirá PERFORM UNTIL e uma chave de fim de arquivo.
Grave um relatório de saída com cabeçalho e totalizador.
Leia um arquivo sequencial real no JCL, em vez de DD *.
Crie uma rotina para validar dados e outra para calcular.
Só então avance para VSAM, Db2, CICS ou chamadas de programas.

Cada degrau reaproveita a mesma gramática mental: receber → validar → processar → produzir saída → encerrar. Muda o recurso, não muda o raciocínio.

13. Checklist antes de chamar o instrutor

Antes de dizer “não funciona”, faça esta inspeção honesta:

Qual é a entrada exata que forneci?
Qual saída eu esperava?
Em que membro está o fonte? E em que membro está o JCL?
O PROGRAM-ID é o mesmo nome usado no build/exec?
O job chegou a executar ou morreu na compilação/linkedição?
Qual é a primeira mensagem relevante no SDSF?
Se há cálculo, os campos envolvidos são realmente numéricos?
Eu consigo explicar, em português, o caminho entre a leitura e a saída?

Se levar essas respostas, você não chega ao instrutor com “deu erro”. Chega com material de diagnóstico — e aprende dez vezes mais depressa.

Epílogo — Rambo não decorou a selva; ele aprendeu a ler rastros

Escrever COBOL não é conhecer todas as cláusulas da linguagem. É pegar um problema confuso e dividi-lo até que cada parte tenha uma resposta simples:

quem é o programa;
de onde vêm e para onde vão os dados;
o que precisa ficar guardado;
quais passos acontecem e em que ordem;
como o programa termina quando tudo vai bem — e quando não vai.

O aluno que voltou do “Vietnã” de TSO, ISPF, JOB e JCL não está atrasado. Ele já conhece o terreno e as ferramentas. Falta transformar ferramentas em método.

Abra um membro vazio. Escolha um problema de uma frase. Escreva o contrato. Monte as quatro divisões. Compile antes de o medo crescer. E, quando o SDSF mostrar o primeiro CC 0000 de um programa escrito por você, guarde o recibo: não foi sorte. Foi a primeira vez que você atravessou a trilha inteira.

E a partir daí, padawan, a floresta continua grande — mas já não é desconhecida.

Para ir mais longe

Conheça diversos laboratorios praticos para dominar o COBOL e ir mais longe na carreira de DEV Mainframe

https://eljefemidnightlunch.blogspot.com/2026/07/laboratorio-pratico-primeiros-passos-no.html

https://eljefemidnightlunch.blogspot.com/2024/01/laboratorio-pratico-testes-de.html

https://eljefemidnightlunch.blogspot.com/2025/06/laboratorio-pratico-de-cobol-mainframe.html

https://eljefemidnightlunch.blogspot.com/2025/10/lab-1-laboratorio-pratico-db2-para.html

https://eljefemidnightlunch.blogspot.com/2025/10/laboratorio-pratico-03-comandos-display.html

https://eljefemidnightlunch.blogspot.com/2026/07/comp-4-e-comp-5-sem-misterios-parte-ii.html

Translate

domingo, 6 de novembro de 2022