Translate

Mostrar mensagens com a etiqueta lógica. Mostrar todas as mensagens
Mostrar mensagens com a etiqueta lógica. Mostrar todas as mensagens

quarta-feira, 29 de outubro de 2025

☕💣 Lab: SEU PRIMEIRO PLANTÃO NO MAINFRAME — LABORATÓRIO COMPLETO DE LÓGICA DE PROGRAMAÇÃO IBM Z PARA INICIANTES 💣☕

 

Bellacosa Mainframe Laboratorio de Logica de Programação Mainframe

☕💣 “SEU PRIMEIRO PLANTÃO NO MAINFRAME” — LABORATÓRIO COMPLETO DE LÓGICA DE PROGRAMAÇÃO IBM Z PARA INICIANTES 💣☕

Aprenda a pensar como um programador de alta plataforma antes mesmo de dominar COBOL


🔥 OBJETIVO DO LABORATÓRIO

Neste laboratório você irá aprender:

✅ Como pensar em lógica Mainframe
✅ Como funciona o raciocínio batch
✅ Variáveis
✅ Validações
✅ Estruturas de repetição
✅ Sections e Paragraphs
✅ Procedures
✅ Subrotinas
✅ Modularização
✅ Boas práticas de alta plataforma
✅ Erros clássicos de iniciantes
✅ Como programadores IBM Z organizam sistemas reais


☕ CENÁRIO DO LABORATÓRIO

Você foi contratado para trabalhar em um banco.

Sua missão:

💣 PROCESSAR UM ARQUIVO DE CLIENTES

Cada registro possui:

NOME
IDADE
SALDO
STATUS

O programa deve:

  1. Ler registros

  2. Validar dados

  3. Calcular bônus

  4. Gerar relatório

  5. Exibir totais


🔥 PRIMEIRA LIÇÃO — PENSAR COMO MAINFRAME

Antes do código:

☕ O PROGRAMADOR MAINFRAME PENSA EM FLUXO


Entrada

Arquivo de clientes

Processamento

Validar
Calcular
Atualizar
Contabilizar

Saída

Relatório
Arquivo atualizado
Totais

💣 ISSO É O DNA DO BATCH

No Mainframe:

  • entrada

  • processamento

  • saída

são sagrados.


☕ ETAPA 1 — DECLARANDO VARIÁVEIS

No Mainframe tudo precisa ser previsível.


🔥 TIPOS MAIS COMUNS

Texto

01 WS-NOME            PIC X(30).

Número inteiro

01 WS-IDADE           PIC 9(03).

Valores monetários

01 WS-SALDO           PIC 9(07)V99.

Indicadores lógicos

01 WS-FIM-ARQUIVO     PIC X VALUE 'N'.

☕ DICA BELLACOSA MAINFRAME

🔥 Nome de variável precisa explicar a intenção

RUIM:

01 A PIC 9(5).

BOM:

01 WS-TOTAL-CLIENTES PIC 9(5).

💣 O MAINFRAME SOBREVIVE POR LEGIBILIDADE

Quem mantém sistemas bancários precisa entender rápido o código.


☕ ETAPA 2 — ESTRUTURA DO PROGRAMA

O COBOL corporativo normalmente segue:

IDENTIFICATION DIVISION
ENVIRONMENT DIVISION
DATA DIVISION
PROCEDURE DIVISION

🔥 O CORAÇÃO DA LÓGICA

PROCEDURE DIVISION

Aqui vive:

  • fluxo

  • validação

  • cálculos

  • repetições


☕ ETAPA 3 — SECTIONS E PARAGRAPHS

SECTION

Agrupa grandes áreas do programa.


PARAGRAPH

Divide tarefas menores.


💣 EXEMPLO CORPORATIVO

PROCESSAMENTO-SECTION.

    PERFORM LE-ARQUIVO
    PERFORM VALIDA-DADOS
    PERFORM CALCULA-BONUS
    PERFORM GRAVA-RELATORIO.

☕ VANTAGEM DISSO

✅ Organização
✅ Manutenção
✅ Reuso
✅ Facilidade de debugging
✅ Clareza


🔥 ETAPA 4 — LEITURA DE REGISTROS

Todo batch gira em torno disso.


💣 MODELO CLÁSSICO MAINFRAME

PERFORM UNTIL WS-FIM-ARQUIVO = 'S'

    PERFORM LE-REGISTRO

    IF WS-FIM-ARQUIVO NOT = 'S'
       PERFORM PROCESSA-REGISTRO
    END-IF

END-PERFORM.

☕ O QUE O INICIANTE PRECISA ENTENDER

O batch:

  • processa

  • repete

até acabar o arquivo.


🔥 ETAPA 5 — LAÇOS DE REPETIÇÃO

☕ 1. PERFORM UNTIL

Mais usado em batch.


Exemplo

PERFORM UNTIL WS-FIM = 'S'

Repete até condição ser verdadeira.


☕ 2. PERFORM VARYING

Semelhante ao FOR.


Exemplo

PERFORM VARYING WS-INDICE FROM 1 BY 1
UNTIL WS-INDICE > 10

☕ 3. PERFORM TIMES

Executa quantidade fixa.


Exemplo

PERFORM 5 TIMES
   DISPLAY 'MAINFRAME'
END-PERFORM.

💣 ERRO CLÁSSICO DE INICIANTE

Criar loop infinito.

Exemplo perigoso:

PERFORM UNTIL WS-FIM = 'S'

Sem alterar WS-FIM.

Resultado:

  • CPU presa

  • JOB travado

  • consumo absurdo


☕ ETAPA 6 — VALIDAÇÕES

🔥 MAINFRAME AMA VALIDAÇÃO

Sistemas bancários precisam ser paranoicos.


☕ TIPOS DE VALIDAÇÃO


Campo vazio

IF WS-NOME = SPACES

Número inválido

IF WS-IDADE IS NUMERIC

Faixa permitida

IF WS-IDADE >= 18

Status permitido

IF WS-STATUS = 'A'

💣 DICA CORPORATIVA

Sempre valide:

  • entrada

  • arquivo

  • cálculo

  • retorno

  • integração


☕ ETAPA 7 — CÁLCULO DE BÔNUS

Regra:

Se saldo > 1000:

  • bônus = 10%


🔥 EXEMPLO

IF WS-SALDO > 1000
   COMPUTE WS-BONUS = WS-SALDO * 0.10
ELSE
   MOVE 0 TO WS-BONUS
END-IF.

☕ ETAPA 8 — MODULARIZAÇÃO

💣 O SEGREDO DOS SISTEMAS GIGANTES

Separar responsabilidades.


🔥 EXEMPLO

LEITURA
VALIDAÇÃO
PROCESSAMENTO
RELATÓRIO
FINALIZAÇÃO

☕ ISSO REDUZ

✅ Bugs
✅ Retrabalho
✅ Confusão
✅ Dependência de pessoas


☕ ETAPA 9 — SUBROTINAS

Grandes empresas usam MUITO isso.


🔥 O QUE É SUBROTINA?

Programa auxiliar reutilizável.


Exemplo

CALCULA-JUROS
VALIDA-CPF
FORMATA-DATA

💣 VANTAGEM

Um único módulo pode ser usado por:

  • banco

  • cartão

  • seguros

  • investimentos


☕ CHAMADA DE SUBROTINA

CALL 'CALCJURO'

☕ ETAPA 10 — FUNÇÕES

Funções retornam valores.


🔥 EXEMPLO

FUNCTION CURRENT-DATE

☕ MUITAS FUNÇÕES MODERNAS COBOL

  • data

  • matemática

  • string

  • conversão


💣 O QUE O INICIANTE PRECISA EVITAR


🔥 1. GOTO EM EXCESSO

Código vira espaguete.


🔥 2. NOMES RUINS

Dificultam manutenção.


🔥 3. DUPLICAÇÃO

Mesmo código repetido.


🔥 4. FALTA DE VALIDAÇÃO

Causa bugs perigosos.


🔥 5. TENTAR FAZER TUDO NUM BLOCO

Divida em procedures.


☕ LABORATÓRIO PRÁTICO — FLUXO COMPLETO

💣 OBJETIVO

Processar 3 clientes.


🔥 PASSO 1 — INICIALIZAÇÃO

MOVE 0 TO WS-TOTAL
MOVE 'N' TO WS-FIM

🔥 PASSO 2 — LOOP PRINCIPAL

PERFORM UNTIL WS-FIM = 'S'

🔥 PASSO 3 — LEITURA

READ CLIENTE-ARQ

🔥 PASSO 4 — VALIDAÇÃO

IF WS-SALDO IS NUMERIC

🔥 PASSO 5 — PROCESSAMENTO

COMPUTE WS-BONUS = WS-SALDO * 0.10

🔥 PASSO 6 — ACUMULADOR

ADD WS-BONUS TO WS-TOTAL

🔥 PASSO 7 — RELATÓRIO

DISPLAY WS-TOTAL

☕ RESULTADO FINAL ESPERADO

O programa:

  • processa clientes

  • valida dados

  • calcula bônus

  • gera total


💣 ISSO É O INÍCIO DA ENGENHARIA MAINFRAME

Você acabou de praticar:

✅ lógica imperativa
✅ lógica procedural
✅ lógica estruturada


☕ COMO PROGRAMADORES MAINFRAME PENSAM?

Eles perguntam:

O dado entrou correto?
O arquivo está íntegro?
A rotina está modularizada?
O batch aguenta milhões de registros?
O operador conseguirá diagnosticar erro?

🔥 ISSO É ALTA PLATAFORMA

Não é apenas programar.

É:

  • previsibilidade

  • confiabilidade

  • rastreabilidade

  • engenharia


☕ CURIOSIDADES DO MUNDO REAL


💣 Muitos bancos ainda usam lógica escrita nos anos 80

E continuam funcionando.


💣 Um erro de loop pode consumir milhões em CPU

Por isso revisão é levada extremamente a sério.


💣 COBOL foi desenhado para manutenção humana

Legibilidade sempre foi prioridade.


💣 Grandes batches processam bilhões de registros

Tudo baseado nessa lógica.


☕ DESAFIO FINAL PARA O ALUNO

Tente adicionar:

✅ validação de idade
✅ tratamento de saldo negativo
✅ contador de clientes inválidos
✅ relatório final formatado
✅ cálculo de média


🔥 MISSÃO CONCLUÍDA

Você deu os primeiros passos no raciocínio que move:

  • bancos

  • governos

  • cartões

  • seguradoras

  • bolsas financeiras


💣 A GRANDE VERDADE DO MAINFRAME

Antes de aprender comandos…

☕ O PROGRAMADOR IBM Z PRECISA APRENDER A PENSAR COMO ENGENHEIRO.


quarta-feira, 8 de janeiro de 2020

☕💥 Algoritmos no Mainframe: Da Matemática de Al-Khwarizmi ao COBOL no z/OS

 

Bellacosa Mainframe apresenta algoritmos na programação

☕💥 Algoritmos no Mainframe: Da Matemática de Al-Khwarizmi ao COBOL no z/OS

Ou como um programador COBOL Padawan descobre que, antes de existir código, existia lógica

"Um bom algoritmo faz um bom programa. Um excelente algoritmo faz o programador parecer um mago. Um algoritmo ruim faz o operador do turno da madrugada querer abrir um chamado para exorcismo."

— Bellacosa Mainframe

Introdução

Existe uma frase que gosto de repetir aos meus alunos padawans:

"COBOL não é difícil. Difícil é pensar."

E isso pode soar estranho.

Muitos acreditam que programar significa decorar comandos, aprender sintaxe, conhecer verbos COBOL ou dominar JCL.

Não.

Programar é, essencialmente, aprender a pensar de forma estruturada.

E isso possui um nome.

Algoritmo.

Antes do COBOL.

Antes do Assembler.

Antes do FORTRAN.

Antes do System/360.

Antes do z16.

Antes do ChatGPT.

Já existiam algoritmos.

E a história deles é simplesmente fantástica.


O nascimento dos algoritmos

A palavra algoritmo deriva do nome do matemático persa:

Muhammad ibn Musa al-Khwarizmi

(cerca de 780–850 d.C.)

Ele escreveu um tratado chamado:

"Kitab al-Jabr wa-l-Muqabala"

Livro que deu origem à palavra:

Algebra

E seu nome latinizado tornou-se:

Algorismus

Posteriormente:

Algorithm

Ou seja...

Cada vez que fazemos:

ADD A TO B GIVING TOTAL

estamos usando ideias desenvolvidas há mais de mil anos.


Algoritmos antes dos computadores

Curiosamente, algoritmos são muito mais antigos que computadores.

Exemplos:

Receitas culinárias

Procedimentos militares

Construção de pirâmides

Cálculos astronômicos

Navegação marítima

Tributação romana

Tudo era algoritmo.

Apenas não era chamado assim.


O primeiro algoritmo famoso

O algoritmo de Euclides.

300 a.C.

Encontrar o MDC.

Exemplo:

MDC(48,18)

Passo 1

48 mod 18 = 12

Passo 2

18 mod 12 = 6

Passo 3

12 mod 6 =0

Resposta

6

Dois mil anos depois...

Continuamos utilizando a mesma lógica.


A chegada dos computadores

Década de 1940.

ENIAC

UNIVAC

EDSAC

LEO I

IBM 650

IBM 7070

A grande dificuldade não era processador.

Era ensinar uma máquina a pensar.

E pensar significava:

Transformar problemas em algoritmos.


O nascimento do mainframe

1952

IBM 701

1954

IBM 704

1964

System/360

Um dos projetos mais revolucionários da história.

Pela primeira vez:

Uma arquitetura única.

Diversos equipamentos.

Compatibilidade.

E o software começava a ganhar importância.


O problema dos programas gigantes

Década de 50.

Empresas começavam a automatizar:

Folha de pagamento

Seguros

Bancos

Governo

Previdência

Surgiu um problema.

Como ensinar milhares de pessoas a desenvolver sistemas?

Resposta:

Criando linguagens de alto nível.


COBOL nasce em 1959

CODASYL.

Grace Hopper.

Departamento de Defesa Americano.

Objetivo:

Criar uma linguagem próxima do inglês.

Exemplo:

READ CLIENTE

IF SALDO > 1000

   PERFORM LIBERA-CREDITO

END-IF

Mas existe um detalhe importante.

COBOL não pensa.

Quem pensa é o desenvolvedor.

COBOL apenas executa.

O algoritmo continua sendo o verdadeiro cérebro.


O algoritmo escondido dentro do COBOL

Muitos iniciantes acreditam:

"Aprendi COBOL."

Não.

Aprendeu comandos.

Programar é construir algoritmos.

Exemplo.

Problema:

Calcular média.

Padawan inexperiente:

ADD A TO B
ADD C TO TOTAL
DIVIDE 3 INTO TOTAL

Padawan treinado:

Entrada

3 notas

Processamento

Somar

Dividir

Saída

Média

Ele pensa primeiro.

Codifica depois.


Características de um algoritmo

Entrada

Pode possuir dados.

Exemplo:

Arquivo VSAM

DB2

MQ

GDG

SYSIN


Saída

Relatório

Arquivo

Mensagem

Tela CICS

API JSON


Finitude

Todo algoritmo precisa terminar.

Exemplo ruim:

PERFORM FOREVER

Exemplo bom:

PERFORM UNTIL EOF='S'

Clareza

Evitar ambiguidades.

Ruim:

"Processar cliente"

Bom:

Ler registro

Validar CPF

Consultar saldo

Atualizar DB2

Gravar auditoria


Algoritmos nos Batchs Mainframe

Imagine.

Banco processando PIX.

2 bilhões de registros.

A lógica continua igual.

Entrada

SORTIN

Processamento

JOINKEYS

ICETOOL

COBOL

Saída

SORTOUT

Relatórios

DB2

MQ


O algoritmo do fechamento bancário

Leitura

Validação

Consolidação

Apuração

Tributação

Geração de extrato

Backup

Auditoria

Tudo algoritmo.


Algoritmos no CICS

O novato vê:

EXEC CICS RECEIVE

EXEC CICS SEND

EXEC CICS LINK

Mas por trás existe:

Receber dados

Validar

Consultar

Persistir

Retornar

Fluxo decisório.


Algoritmos no Natural

Mesmo conceito.

MAP

READ

FIND

END-FIND

ESCAPE TOP

DECIDE ON

São apenas ferramentas.

O raciocínio continua sendo algoritmo.


Pseudocódigo

Excelente ferramenta para padawans.

Exemplo.

Transferência bancária.



Inicio


Ler conta origem


Ler conta destino


Ler valor


Saldo suficiente ?


SIM


Debitar


Creditar


Gerar log


Nao


Retornar erro



Fim



Só depois escrevemos COBOL.


Fluxogramas

Muito utilizados nos anos 70.

Analistas desenhavam:

Retângulos

Losangos

Setas

Pastas físicas.

Canetas.

Régua.

Pranchetas.

Sim.

Mainframe já existia antes do Visio.


Algoritmos de busca

Busca sequencial.

Busca binária.

Hash.

Índices VSAM.

DB2 Index.

B-tree.

LSM Trees.

Todos são algoritmos.


Algoritmos de ordenação

Mainframe ama ordenação.

DFSORT.

SYNCSORT.

ICETOOL.

Métodos famosos:

Bubble Sort

Merge Sort

QuickSort

HeapSort

No universo IBM, o Merge Sort praticamente reina.


Complexidade computacional

Nem todo algoritmo é igual.

O(1)

Constante

O(log n)

Busca binária

O(n)

Linear

O(n²)

Bubble

O(2ⁿ)

Exponencial


O dia em que um COBOL virou um monstro

Já vi programa COBOL com:

70 mil linhas.

350 PERFORM.

1200 IF.

85 GO TO.

Documentação inexistente.

Autor aposentado em 1998.

Chamado aberto em produção.

Ninguém sabe mexer.

Por quê?

Ausência de algoritmo.

Código cresceu.

Pensamento não.


Design de algoritmos

Força Bruta

Dividir e conquistar

Backtracking

Greedy

Programação dinâmica

Mesmo em bancos.

Mesmo em seguradoras.

Mesmo em governo.


Algoritmos modernos no IBM Z

Hoje temos:

z16

z17

LinuxONE

OpenShift

zCX

API Connect

z/OS Connect

Kafka

Python

Java

Node.js

AI

Machine Learning

Mas adivinhe.

O algoritmo continua sendo rei.


Inteligência Artificial também vive de algoritmos

Redes neurais.

Transformers.

LLMs.

Árvores.

Regressão.

Clustering.

Tudo algoritmo.

A IA não substituiu algoritmos.

Ela apenas os sofisticou.


O maior erro dos novos programadores

Querer aprender linguagem.

Antes de aprender lógica.

É equivalente a comprar um sabre de luz sem saber usar a Força.


Conselhos para um Padawan COBOL

Primeiro pense.

Depois desenhe.

Depois escreva.

Depois teste.

Depois otimize.

Nunca faça o inverso.

Pergunte sempre:

Quais entradas?

Qual processamento?

Qual saída?

Existem exceções?

Qual volume?

Como recuperar falhas?

Como auditar?

Como escalar?


O algoritmo invisível que move o mundo

Quando um cliente faz PIX.

Existe algoritmo.

Quando um avião decola.

Existe algoritmo.

Quando uma seguradora calcula prêmio.

Existe algoritmo.

Quando um cartão aprova compra.

Existe algoritmo.

Quando o INSS paga benefícios.

Existe algoritmo.

Quando um CICS responde em menos de um segundo.

Existe algoritmo.

E quando um velho programa COBOL criado em 1987 continua funcionando perfeitamente em um IBM Z moderno...

Existe um bom algoritmo escondido ali.


Considerações finais

Muitos dizem que COBOL é uma linguagem antiga.

Discordo.

COBOL é apenas um meio de expressão.

A verdadeira tecnologia imortal chama-se algoritmo.

Ela nasceu com matemáticos árabes, sobreviveu aos impérios, atravessou a Revolução Industrial, alimentou os primeiros computadores, ajudou a criar o System/360, sustentou bancos por décadas, acompanhou a internet, chegou ao z/OS, conversa hoje com APIs REST e provavelmente continuará existindo quando estivermos programando computadores quânticos.

Portanto, jovem Padawan, lembre-se:

Você não é pago para escrever DISPLAY, MOVE, ADD ou EXEC CICS.

Você é pago para transformar problemas caóticos em sequências ordenadas de decisões capazes de gerar valor para empresas, governos e pessoas.

E esse poder, desde Al-Khwarizmi até o IBM z17, continua tendo exatamente o mesmo nome:

Algoritmo.

☕🚀 E como diria um velho mestre do Bellacosa Mainframe:

"Código envelhece. Linguagens mudam. Frameworks desaparecem. Mas um algoritmo elegante continua sendo reconhecido por qualquer programador, em qualquer época, em qualquer plataforma."

 

segunda-feira, 5 de março de 2007

O que é o Comando EVALUATE em COBOL?

 

Bellacosa Mainframe e o comando evaluate em cobol

O que é o Comando EVALUATE em COBOL?

O comando EVALUATE é uma das estruturas de decisão mais poderosas do COBOL.

Ele é equivalente ao:

  • CASE (C, Java, C#)

  • SWITCH (Java, JavaScript)

  • MATCH (algumas linguagens modernas)

Seu objetivo é:

executar diferentes ações dependendo do valor de uma variável ou condição.


Por que o EVALUATE existe?

Imagine um programa com vários IFs:

IF WS-OPCAO = 1
   PERFORM CONSULTA
ELSE
   IF WS-OPCAO = 2
      PERFORM INCLUSAO
   ELSE
      IF WS-OPCAO = 3
         PERFORM ALTERACAO
      END-IF
   END-IF
END-IF

Funciona, mas fica difícil de ler.

Com EVALUATE:

EVALUATE WS-OPCAO

   WHEN 1
      PERFORM CONSULTA

   WHEN 2
      PERFORM INCLUSAO

   WHEN 3
      PERFORM ALTERACAO

END-EVALUATE

Muito mais limpo.


Sintaxe básica

EVALUATE variável

   WHEN valor-1
      ação

   WHEN valor-2
      ação

   WHEN valor-3
      ação

END-EVALUATE

Exemplo simples

EVALUATE WS-NOTA

   WHEN 10
      DISPLAY 'EXCELENTE'

   WHEN 8
      DISPLAY 'MUITO BOM'

   WHEN 6
      DISPLAY 'APROVADO'

END-EVALUATE

WHEN OTHER

Funciona como:

DEFAULT
ELSE

Exemplo

EVALUATE WS-OPCAO

   WHEN 1
      DISPLAY 'CONSULTA'

   WHEN 2
      DISPLAY 'ALTERACAO'

   WHEN OTHER
      DISPLAY 'OPCAO INVALIDA'

END-EVALUATE

EVALUATE TRUE

Muito utilizado em sistemas corporativos.

Permite avaliar condições.


Exemplo

EVALUATE TRUE

   WHEN WS-SALDO > 10000
      DISPLAY 'CLIENTE VIP'

   WHEN WS-SALDO > 5000
      DISPLAY 'CLIENTE GOLD'

   WHEN OTHER
      DISPLAY 'CLIENTE NORMAL'

END-EVALUATE

Comparação com IF

IF:

IF WS-IDADE >= 18
   DISPLAY 'MAIOR'
ELSE
   DISPLAY 'MENOR'
END-IF

EVALUATE:

EVALUATE TRUE

   WHEN WS-IDADE >= 18
      DISPLAY 'MAIOR'

   WHEN OTHER
      DISPLAY 'MENOR'

END-EVALUATE

Avaliando faixas

EVALUATE TRUE

   WHEN WS-NOTA >= 9
      DISPLAY 'A'

   WHEN WS-NOTA >= 7
      DISPLAY 'B'

   WHEN WS-NOTA >= 5
      DISPLAY 'C'

   WHEN OTHER
      DISPLAY 'D'

END-EVALUATE

Avaliando múltiplos valores

EVALUATE WS-MES

   WHEN 1 2 3
      DISPLAY 'TRIMESTRE 1'

   WHEN 4 5 6
      DISPLAY 'TRIMESTRE 2'

   WHEN 7 8 9
      DISPLAY 'TRIMESTRE 3'

   WHEN 10 11 12
      DISPLAY 'TRIMESTRE 4'

END-EVALUATE

Avaliando múltiplas variáveis

Uma das características mais poderosas.

EVALUATE WS-TIPO ALSO WS-STATUS

   WHEN 'PF' ALSO 'A'
      DISPLAY 'PESSOA FISICA ATIVA'

   WHEN 'PJ' ALSO 'A'
      DISPLAY 'EMPRESA ATIVA'

   WHEN OTHER
      DISPLAY 'OUTRA SITUACAO'

END-EVALUATE

ALSO

Permite comparar vários campos simultaneamente.


Exemplo bancário

EVALUATE WS-CANAL ALSO WS-PRODUTO

   WHEN 'APP' ALSO 'PIX'
      PERFORM PROCESSA-PIX

   WHEN 'ATM' ALSO 'SAQUE'
      PERFORM PROCESSA-SAQUE

   WHEN OTHER
      PERFORM TRATA-ERRO

END-EVALUATE

Intervalos com THRU

EVALUATE WS-NOTA

   WHEN 0 THRU 4
      DISPLAY 'REPROVADO'

   WHEN 5 THRU 6
      DISPLAY 'RECUPERACAO'

   WHEN 7 THRU 10
      DISPLAY 'APROVADO'

END-EVALUATE

EVALUATE com LEVEL 88

Combinação muito elegante.

01 WS-STATUS PIC X.

   88 STATUS-OK VALUE 'S'.
   88 STATUS-ERRO VALUE 'N'.
EVALUATE TRUE

   WHEN STATUS-OK
      DISPLAY 'SUCESSO'

   WHEN STATUS-ERRO
      DISPLAY 'FALHA'

END-EVALUATE

Vantagens do EVALUATE

Mais legível

Menos IF aninhado

Fácil manutenção

Excelente para regras de negócio

Melhor organização do código


Cuidados

  • A ordem dos WHEN é importante.

  • WHEN OTHER deve ficar por último.

  • Em EVALUATE TRUE, a primeira condição verdadeira é executada.


Onde é mais utilizado?

Praticamente em todos os sistemas COBOL modernos:

  • Bancos

  • Seguradoras

  • Cartões

  • PIX

  • Folha salarial

  • Processamento batch

  • CICS


Exemplo completo

WORKING-STORAGE SECTION.

01 WS-OPERACAO PIC 9.

PROCEDURE DIVISION.

    MOVE 2 TO WS-OPERACAO

    EVALUATE WS-OPERACAO

       WHEN 1
          DISPLAY 'CONSULTA'

       WHEN 2
          DISPLAY 'INCLUSAO'

       WHEN 3
          DISPLAY 'ALTERACAO'

       WHEN OTHER
          DISPLAY 'INVALIDO'

    END-EVALUATE

    STOP RUN.

Saída:

INCLUSAO

EVALUATE vs IF

IFEVALUATE
Bom para poucas condiçõesIdeal para muitas condições
Pode gerar IFs aninhadosCódigo mais limpo
Menos legível em regras complexasExcelente legibilidade
SimplesMais poderoso

Resumo rápido

ElementoFunção
EVALUATEEstrutura de decisão
WHENCondição
WHEN OTHERCaso padrão
ALSOMúltiplas variáveis
THRUIntervalo
EVALUATE TRUEAvaliação de expressões

Conclusão

O comando EVALUATE é a principal estrutura de decisão múltipla do COBOL. Ele substitui grandes blocos de IF aninhados, melhora a legibilidade do código e é amplamente utilizado em sistemas corporativos executados em mainframes IBM Z para implementar regras de negócio complexas de forma organizada e eficiente.


sexta-feira, 2 de março de 2007

O que é o Comando COMPUTE em COBOL?

 

Bellacosa Mainframe e o comando compute no cobol

O que é o Comando COMPUTE em COBOL?

O comando COMPUTE é uma das instruções mais importantes do COBOL para realizar:

  • cálculos matemáticos;

  • fórmulas financeiras;

  • operações aritméticas;

  • expressões complexas.

Ele foi criado para simplificar operações que antes exigiam vários comandos separados.


O que faz o COMPUTE?

O COMPUTE permite:

calcular uma expressão matemática completa em uma única instrução.


Sintaxe básica

COMPUTE resultado = expressão

Exemplo:

COMPUTE WS-TOTAL = WS-VALOR1 + WS-VALOR2

Exemplo simples

Sem COMPUTE:

ADD WS-VALOR1 TO WS-VALOR2 GIVING WS-TOTAL

Com COMPUTE:

COMPUTE WS-TOTAL =
        WS-VALOR1 + WS-VALOR2

Operações suportadas

Soma

COMPUTE WS-TOTAL =
        WS-A + WS-B

Subtração

COMPUTE WS-SALDO =
        WS-CREDITO - WS-DEBITO

Multiplicação

COMPUTE WS-TOTAL =
        WS-QUANTIDADE * WS-PRECO

Divisão

COMPUTE WS-MEDIA =
        WS-SOMA / WS-QTD

Potência

COMPUTE WS-RESULTADO =
        WS-VALOR ** 2

Operadores matemáticos

OperadorSignificado
+Soma
-Subtração
*Multiplicação
/Divisão
**Potência

Exemplo de expressão complexa

COMPUTE WS-RESULTADO =
       (WS-A + WS-B)
       * WS-C
       / WS-D

Ordem de precedência

O COBOL segue regras matemáticas normais:

()
**
* /
+ -

Exemplo

COMPUTE WS-TOTAL =
        10 + 20 * 3

Resultado:

70

Porque:

20 * 3 = 60
60 + 10 = 70

Usando parênteses

COMPUTE WS-TOTAL =
       (10 + 20) * 3

Resultado:

90

COMPUTE com valores monetários

Muito comum em sistemas bancários.

COMPUTE WS-JUROS =
        WS-SALDO * WS-TAXA

Exemplo financeiro

COMPUTE WS-VALOR-FINAL =
        WS-VALOR +
        (WS-VALOR * WS-PERCENTUAL / 100)

COMPUTE com COMP-3

Extremamente comum.

01 WS-SALDO      PIC S9(7)V99 COMP-3.
01 WS-JUROS      PIC S9(5)V99 COMP-3.
01 WS-TOTAL      PIC S9(9)V99 COMP-3.

COMPUTE WS-TOTAL =
        WS-SALDO + WS-JUROS

COMPUTE e Funções Intrínsecas

Podem ser usados juntos.

Exemplo:

COMPUTE WS-RAIZ =
        FUNCTION SQRT(625)

Resultado:

25

Exemplo com ABS

COMPUTE WS-VALOR =
        FUNCTION ABS(-500)

Resultado:

500

COMPUTE com CURRENT-DATE

MOVE FUNCTION CURRENT-DATE
     TO WS-DATA

Embora CURRENT-DATE normalmente seja usado com MOVE, ele também pode participar de expressões.


ON SIZE ERROR

Muito importante.

Detecta estouro de campo.

Exemplo:

COMPUTE WS-TOTAL =
        WS-A * WS-B

   ON SIZE ERROR
      DISPLAY 'ERRO DE TAMANHO'
END-COMPUTE

O que é Size Error?

Quando o resultado não cabe no campo.

Exemplo:

Campo:

PIC 9(3)

Máximo:

999

Resultado calculado:

1500

Ocorre:

SIZE ERROR


Exemplo completo

WORKING-STORAGE SECTION.

01 WS-SALARIO      PIC 9(7)V99.
01 WS-BONUS        PIC 9(5)V99.
01 WS-TOTAL        PIC 9(7)V99.

PROCEDURE DIVISION.

    MOVE 5000 TO WS-SALARIO
    MOVE 1000 TO WS-BONUS

    COMPUTE WS-TOTAL =
            WS-SALARIO + WS-BONUS

    DISPLAY WS-TOTAL

    STOP RUN.

Saída:

6000.00

COMPUTE vs ADD

ADD:

ADD A TO B GIVING C

COMPUTE:

COMPUTE C = A + B

COMPUTE vs MULTIPLY

MULTIPLY:

MULTIPLY A BY B GIVING C

COMPUTE:

COMPUTE C = A * B

Vantagens do COMPUTE

Código mais legível

Menos instruções

Expressões complexas

Fácil manutenção

Mais próximo da matemática tradicional


Cuidados

  • Verificar tamanho dos campos.

  • Usar ON SIZE ERROR quando necessário.

  • Atenção com casas decimais.

  • Validar divisões por zero.


Onde o COMPUTE é mais usado?

Praticamente em todos os sistemas COBOL:

  • bancos;

  • cartões;

  • seguros;

  • folha salarial;

  • faturamento;

  • cálculo de juros;

  • cálculo de impostos.


Curiosidade

Antes do COMPUTE, muitos cálculos exigiam combinações de:

ADD
SUBTRACT
MULTIPLY
DIVIDE

O COMPUTE trouxe uma sintaxe muito mais próxima das fórmulas matemáticas tradicionais.


Resumo rápido

ComandoFunção
COMPUTEExecuta cálculos
+Soma
-Subtração
*Multiplicação
/Divisão
**Potência
ON SIZE ERRORTrata estouro
FUNCTIONUsa funções intrínsecas

Conclusão

O comando COMPUTE é a principal instrução de cálculo do COBOL. Ele permite executar operações matemáticas simples ou complexas de forma clara, legível e eficiente, sendo amplamente utilizado em aplicações financeiras e sistemas corporativos executados em mainframes IBM Z.