✨ Bem-vindo ao meu espaço! ✨ Este blog é o diário de um otaku apaixonado por animes, tecnologia de mainframe e viagens. Cada entrada é uma mistura única: relatos de viagem com fotos, filmes, links, artigos e desenhos, sempre buscando enriquecer a experiência de quem lê. Sou quase um turista profissional: adoro dormir em uma cama diferente, acordar em um lugar novo e registrar tudo com minha câmera sempre à mão. Entre uma viagem e outra, compartilho também reflexões sobre cultura otaku/animes

domingo, 4 de março de 2007

O que é o Comando MOVE em COBOL?

Bellacosa Mainframe e o comando move em cobol

O que é o Comando MOVE em COBOL?

O comando MOVE é um dos comandos mais utilizados em COBOL.

Sua função é simples:

copiar dados de um campo para outro.

Praticamente todo programa COBOL utiliza MOVE para:

transferir valores;
inicializar variáveis;
mover dados de arquivos;
preencher layouts;
preparar registros para gravação.

Sintaxe básica

MOVE origem TO destino

Exemplo simples

MOVE 100 TO WS-SALDO

Resultado:

WS-SALDO = 100

Movendo texto

MOVE 'BELLACOSA'
     TO WS-NOME

Resultado:

WS-NOME = BELLACOSA

Movendo entre variáveis

MOVE WS-SALDO-ATUAL
     TO WS-SALDO-ANTERIOR

Analogia simples

Imagine um operador copiando um documento de uma pasta para outra.

O MOVE faz exatamente isso:

ORIGEM
   ↓
DESTINO

Exemplo completo

WORKING-STORAGE SECTION.

01 WS-NOME     PIC X(20).
01 WS-CLIENTE  PIC X(20).

PROCEDURE DIVISION.

    MOVE 'VAGNER'
         TO WS-NOME

    MOVE WS-NOME
         TO WS-CLIENTE

    DISPLAY WS-CLIENTE

    STOP RUN.

Saída:

VAGNER

MOVE Numérico

MOVE 5000
     TO WS-SALARIO

MOVE Decimal

MOVE 1234.56
     TO WS-VALOR

MOVE entre formatos diferentes

COBOL realiza conversões automáticas em muitos casos.

Exemplo:

01 WS-TEXTO PIC X(5).
01 WS-NUM   PIC 9(5).

MOVE WS-NUM TO WS-TEXTO

MOVE para grupos

Uma característica poderosa do COBOL.

01 CLIENTE.
   05 NOME  PIC X(20).
   05 IDADE PIC 9(3).

01 CLIENTE-BKP PIC X(23).

MOVE CLIENTE
     TO CLIENTE-BKP

Move toda a estrutura.

MOVE CORRESPONDING

Também chamado:

MOVE CORR

Move campos com o mesmo nome.

Exemplo

01 CLIENTE-A.
   05 NOME PIC X(20).
   05 IDADE PIC 9(3).

01 CLIENTE-B.
   05 NOME PIC X(20).
   05 IDADE PIC 9(3).

MOVE CORRESPONDING CLIENTE-A
                   TO CLIENTE-B

O que acontece?

NOME  → NOME
IDADE → IDADE

Automaticamente.

MOVE HIGH-VALUES

Preenche com o maior valor hexadecimal.

MOVE HIGH-VALUES
     TO WS-CAMPO

Muito usado em:

VSAM;
inicialização;
pesquisas.

MOVE LOW-VALUES

Preenche com o menor valor hexadecimal.

MOVE LOW-VALUES
     TO WS-CAMPO

MOVE SPACES

Preenche com espaços.

MOVE SPACES
     TO WS-NOME

Equivalente:

MOVE ' '
     TO WS-NOME

MOVE ZEROES

Preenche com zeros.

MOVE ZEROES
     TO WS-SALDO

MOVE ALL

Repete um valor.

MOVE ALL '*'
     TO WS-LINHA

Resultado:

********************

MOVE em arquivos

Muito usado antes do WRITE.

MOVE WS-NOME
     TO NOME-SAIDA

WRITE REG-SAIDA

MOVE em DB2

Muito usado para preencher host variables.

MOVE WS-CPF
     TO HV-CPF

MOVE em CICS

Também extremamente comum.

MOVE WS-MENSAGEM
     TO MSG-AREA

Cuidados com MOVE

Truncamento

Campo menor que origem.

Exemplo:

PIC X(5)

Recebendo:

BELLACOSA

Resultado:

BELLA

Perda de casas decimais

MOVE 123.99
     TO PIC 9(3)

Pode perder precisão.

Conversões inválidas

Mover texto para numérico pode gerar erro lógico.

MOVE vs COMPUTE

MOVE:

MOVE 100 TO WS-A

Apenas copia.

COMPUTE:

COMPUTE WS-A = 50 + 50

Calcula.

MOVE vs ADD

MOVE:

MOVE 100 TO WS-A

Substitui conteúdo.

ADD:

ADD 100 TO WS-A

Soma ao conteúdo existente.

Onde o MOVE é utilizado?

Praticamente em todos os programas COBOL:

Batch;
CICS;
DB2;
VSAM;
Arquivos QSAM;
APIs;
Processamento financeiro.

Curiosidades

1. MOVE é provavelmente o comando mais utilizado do COBOL

2. Alguns sistemas executam milhões de MOVEs por segundo

3. MOVE CORRESPONDING é muito usado em sistemas corporativos

4. Grande parte da integração entre layouts depende de MOVE

Resumo rápido

Comando	Função
MOVE	Copia dados
MOVE CORRESPONDING	Copia campos iguais
MOVE SPACES	Preenche espaços
MOVE ZEROES	Preenche zeros
MOVE HIGH-VALUES	Maior valor hexadecimal
MOVE LOW-VALUES	Menor valor hexadecimal
MOVE ALL	Repete conteúdo

Conclusão

O comando MOVE é a principal instrução de transferência de dados do COBOL. Ele permite copiar informações entre variáveis, registros e estruturas de forma simples, eficiente e segura, sendo um dos pilares de praticamente todos os sistemas executados em mainframes IBM Z.

sábado, 3 de março de 2007

O que são ADD, SUBTRACT, MULTIPLY e DIVIDE em COBOL?

Bellacosa Mainframe e os comandos de calculo no COBOL

O que são ADD, SUBTRACT, MULTIPLY e DIVIDE em COBOL?

Antes do comando COMPUTE se popularizar, os cálculos em COBOL eram realizados principalmente através de quatro verbos aritméticos clássicos:

ADD
SUBTRACT
MULTIPLY
DIVIDE

Esses comandos fazem parte do COBOL desde suas primeiras versões e continuam sendo amplamente utilizados em sistemas batch e online.

ADD

O comando ADD realiza:

soma de valores.

Sintaxe básica

ADD valor-1 TO valor-2

Exemplo:

ADD 100 TO WS-SALDO

Se WS-SALDO era:

Passará a ser:

Usando GIVING

ADD WS-A WS-B
    GIVING WS-TOTAL

Exemplo:

WS-A = 10
WS-B = 20

Resultado:

WS-TOTAL = 30

SUBTRACT

O comando SUBTRACT realiza:

subtração.

Sintaxe básica

SUBTRACT valor-1
    FROM valor-2

Exemplo:

SUBTRACT 100
    FROM WS-SALDO

Se WS-SALDO era:

Resultado:

Com GIVING

SUBTRACT WS-DESCONTO
    FROM WS-VALOR
    GIVING WS-LIQUIDO

MULTIPLY

O comando MULTIPLY realiza:

multiplicação.

Sintaxe básica

MULTIPLY valor-1
    BY valor-2

Exemplo:

MULTIPLY 10
    BY WS-TOTAL

Se WS-TOTAL era:

Resultado:

Com GIVING

MULTIPLY WS-QTD
    BY WS-PRECO
    GIVING WS-TOTAL

Exemplo

QTD   = 5
PRECO = 100

Resultado:

DIVIDE

O comando DIVIDE realiza:

divisão.

Sintaxe básica

DIVIDE valor-1
    INTO valor-2

Exemplo

DIVIDE 2
    INTO WS-TOTAL

Se WS-TOTAL era:

Resultado:

Forma mais usada

DIVIDE WS-SOMA
    BY WS-QTD
    GIVING WS-MEDIA

Exemplo

SOMA = 100
QTD  = 5

Resultado:

MEDIA = 20

ON SIZE ERROR

Todos os comandos matemáticos podem usar:

ON SIZE ERROR

Exemplo:

ADD WS-A TO WS-B

   ON SIZE ERROR
      DISPLAY 'ERRO'
END-ADD

END-ADD

COBOL moderno permite fechamento explícito.

ADD WS-A TO WS-B
END-ADD

END-SUBTRACT

SUBTRACT WS-A
    FROM WS-B
END-SUBTRACT

END-MULTIPLY

MULTIPLY WS-A
    BY WS-B
END-MULTIPLY

END-DIVIDE

DIVIDE WS-A
    INTO WS-B
END-DIVIDE

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

    ADD WS-BONUS
        TO WS-SALARIO
        GIVING WS-TOTAL

    DISPLAY WS-TOTAL

    STOP RUN.

Resultado:

6000.00

Comparação com COMPUTE

ADD

ADD A TO B GIVING C

Equivalente:

COMPUTE C = A + B

SUBTRACT

SUBTRACT A FROM B
GIVING C

Equivalente:

COMPUTE C = B - A

MULTIPLY

MULTIPLY A BY B
GIVING C

Equivalente:

COMPUTE C = A * B

DIVIDE

DIVIDE A INTO B
GIVING C

Equivalente:

COMPUTE C = B / A

Quando usar ADD, SUBTRACT, MULTIPLY e DIVIDE?

Muitos sistemas legados COBOL utilizam esses comandos porque:

são extremamente claros;
seguem o padrão COBOL clássico;
facilitam manutenção de sistemas antigos.

Quando usar COMPUTE?

Quando a fórmula for mais complexa:

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

Curiosidade

Durante décadas, praticamente todos os sistemas bancários COBOL foram escritos usando:

ADD
SUBTRACT
MULTIPLY
DIVIDE

O comando COMPUTE tornou-se popular posteriormente por deixar as fórmulas mais próximas da matemática tradicional.

Resumo rápido

Comando	Função
ADD	Soma
SUBTRACT	Subtração
MULTIPLY	Multiplicação
DIVIDE	Divisão
GIVING	Guarda resultado
ON SIZE ERROR	Trata estouro
COMPUTE	Fórmulas completas

Conclusão

ADD, SUBTRACT, MULTIPLY e DIVIDE são os verbos aritméticos clássicos do COBOL. Eles continuam presentes em milhões de linhas de código executadas diariamente em mainframes IBM Z, especialmente em aplicações financeiras, bancárias e de processamento batch.

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

Operador	Significado
+	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:

Porque:

20 * 3 = 60
60 + 10 = 70

Usando parênteses

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

Resultado:

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:

Exemplo com ABS

COMPUTE WS-VALOR =
        FUNCTION ABS(-500)

Resultado:

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:

Resultado calculado:

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

Comando	Função
COMPUTE	Executa cálculos
+	Soma
-	Subtração
*	Multiplicação
/	Divisão
**	Potência
ON SIZE ERROR	Trata estouro
FUNCTION	Usa 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.

quinta-feira, 1 de março de 2007

O que é Função Intrínseca em COBOL?

Bellacosa Mainframe e as funções intrinsecas em COBOL

O que é Função Intrínseca em COBOL?

As funções intrínsecas (Intrinsic Functions) são funções internas do COBOL que permitem realizar operações comuns sem a necessidade de criar rotinas próprias.

Elas foram introduzidas para facilitar tarefas como:

manipulação de datas;
cálculos matemáticos;
conversão de dados;
tratamento de strings;
operações estatísticas.

Em vez de escrever dezenas de linhas de código, você pode usar uma função pronta fornecida pelo compilador COBOL.

O que significa "intrínseca"?

Significa:

embutida na linguagem.

Ou seja, já faz parte do compilador COBOL.

Não é necessário:

COPY;
CALL;
subprograma;
biblioteca externa.

Sintaxe básica

FUNCTION nome-da-funcao(argumentos)

Exemplo:

MOVE FUNCTION CURRENT-DATE
     TO WS-DATA

Exemplo simples

Sem função intrínseca:

COMPUTE WS-IDADE = ANO-ATUAL - ANO-NASCIMENTO

Com função:

COMPUTE WS-RAIZ =
        FUNCTION SQRT(144)

Resultado:

Principais categorias

Datas e Horas

Matemáticas

Conversão de Dados

Strings

Estatísticas

Financeiras

Função CURRENT-DATE

Uma das mais usadas.

Retorna:

data;
hora;
milissegundos;
fuso horário.

Exemplo:

MOVE FUNCTION CURRENT-DATE
     TO WS-DATA-HORA

Resultado:

2026080215304500

Função LENGTH

Retorna o tamanho de um campo.

Exemplo:

COMPUTE WS-TAM =
        FUNCTION LENGTH(WS-NOME)

Função UPPER-CASE

Converte texto para maiúsculo.

MOVE FUNCTION UPPER-CASE(WS-NOME)
     TO WS-NOME-MAIUSCULO

Função LOWER-CASE

Converte texto para minúsculo.

MOVE FUNCTION LOWER-CASE(WS-NOME)
     TO WS-NOME-MINUSCULO

Função REVERSE

Inverte caracteres.

MOVE FUNCTION REVERSE("COBOL")
     TO WS-TEXTO

Resultado:

LOBOC

Função NUMVAL

Converte texto para número.

Exemplo:

MOVE FUNCTION NUMVAL("12345")
     TO WS-VALOR

Função NUMVAL-C

Converte valores monetários.

Exemplo:

MOVE FUNCTION NUMVAL-C("R$1.234,56")
     TO WS-VALOR

(Dependendo da configuração regional do compilador.)

Função INTEGER

Remove casas decimais.

COMPUTE WS-INTEIRO =
        FUNCTION INTEGER(123.99)

Resultado:

Função ABS

Valor absoluto.

COMPUTE WS-VALOR =
        FUNCTION ABS(-500)

Resultado:

Função SQRT

Raiz quadrada.

COMPUTE WS-RAIZ =
        FUNCTION SQRT(625)

Resultado:

Função RANDOM

Gera número aleatório.

COMPUTE WS-NUM =
        FUNCTION RANDOM

Função MOD

Retorna resto da divisão.

COMPUTE WS-RESTO =
        FUNCTION MOD(10 3)

Resultado:

Função MAX

Maior valor.

COMPUTE WS-MAX =
        FUNCTION MAX(10 20 30)

Resultado:

Função MIN

Menor valor.

COMPUTE WS-MIN =
        FUNCTION MIN(10 20 30)

Resultado:

Função MEAN

Média aritmética.

COMPUTE WS-MEDIA =
        FUNCTION MEAN(10 20 30)

Resultado:

Função ORD

Retorna código ordinal do caractere.

COMPUTE WS-COD =
        FUNCTION ORD("A")

Função CHAR

Retorna caractere de um código.

MOVE FUNCTION CHAR(65)
     TO WS-LETRA

Resultado:

Função TRIM

Remove espaços.

MOVE FUNCTION TRIM(WS-NOME)
     TO WS-NOME-LIMPO

Exemplo prático

WORKING-STORAGE SECTION.

01 WS-NOME          PIC X(20).
01 WS-NOME-MAIUS    PIC X(20).

PROCEDURE DIVISION.

    MOVE 'bellacosa'
         TO WS-NOME

    MOVE FUNCTION UPPER-CASE(WS-NOME)
         TO WS-NOME-MAIUS

    DISPLAY WS-NOME-MAIUS

    STOP RUN.

Saída:

BELLACOSA

Funções muito usadas em Mainframe

As mais encontradas em sistemas corporativos:

CURRENT-DATE
LENGTH
NUMVAL
NUMVAL-C
UPPER-CASE
LOWER-CASE
TRIM
INTEGER
MOD
ABS

Vantagens

Menos código

Mais legibilidade

Melhor manutenção

Menos rotinas auxiliares

Melhor produtividade

Cuidados

Nem todas as funções estão disponíveis em compiladores muito antigos.

Alguns ambientes COBOL legados podem não suportar:

TRIM
UPPER-CASE
LOWER-CASE
funções estatísticas mais modernas

Curiosidade

Antes das funções intrínsecas, tarefas simples exigiam dezenas de linhas de código COBOL.

Converter um texto para maiúsculo, por exemplo, frequentemente exigia tabelas de tradução e loops complexos.

As funções intrínsecas simplificaram enormemente o desenvolvimento COBOL moderno.

Resumo rápido

Função	Finalidade
CURRENT-DATE	Data e hora atual
LENGTH	Tamanho do campo
UPPER-CASE	Maiúsculas
LOWER-CASE	Minúsculas
TRIM	Remove espaços
NUMVAL	Texto → Número
ABS	Valor absoluto
SQRT	Raiz quadrada
MOD	Resto da divisão
MAX	Maior valor
MIN	Menor valor
RANDOM	Número aleatório

Conclusão

As funções intrínsecas são recursos nativos do COBOL que simplificam cálculos, manipulação de dados, datas e strings. Elas tornam os programas mais legíveis, reduzem a quantidade de código e são amplamente utilizadas em aplicações modernas de COBOL no ambiente mainframe IBM Z.

quarta-feira, 28 de fevereiro de 2007

O que é a Cláusula END nos Comandos COBOL?

Bellacosa Mainframe e a clausula END no COBOL

O que é a Cláusula END nos Comandos COBOL?

A cláusula END foi introduzida nas versões modernas do COBOL para indicar explicitamente o fim de um comando ou estrutura lógica.

Ela torna os programas:

✅ Mais legíveis

✅ Mais seguros

✅ Mais fáceis de manter

✅ Menos sujeitos a erros de aninhamento

Antes do END

Nas versões antigas do COBOL era comum encontrar:

IF SALDO > 0

   DISPLAY 'SALDO POSITIVO'

ELSE

   DISPLAY 'SALDO NEGATIVO'.

Em estruturas complexas, ficava difícil saber onde terminava cada comando.

Com END

IF SALDO > 0

   DISPLAY 'SALDO POSITIVO'

ELSE

   DISPLAY 'SALDO NEGATIVO'

END-IF.

Agora o término fica explícito.

Por que a IBM criou os ENDs?

Imagine:

IF A = 1

   IF B = 2

      IF C = 3

         DISPLAY 'OK'

      ELSE

         DISPLAY 'ERRO'

Pergunta:

O ELSE pertence a qual IF?

Nem sempre é fácil responder.

Com ENDs:

IF A = 1

   IF B = 2

      IF C = 3

         DISPLAY 'OK'

      ELSE

         DISPLAY 'ERRO'

      END-IF

   END-IF

END-IF.

Não existe dúvida.

Principais Comandos com END

END-IF

Finaliza IF.

IF WS-SALDO > 0

   DISPLAY 'OK'

END-IF.

END-PERFORM

Finaliza PERFORM inline.

PERFORM

   DISPLAY 'PROCESSANDO'

END-PERFORM.

END-READ

Finaliza READ.

READ ARQCLI

   AT END

      MOVE 'S' TO FIM-ARQ

END-READ.

END-WRITE

Finaliza WRITE.

WRITE REG-SAIDA

END-WRITE.

END-REWRITE

Finaliza REWRITE.

REWRITE REG-CLIENTE

END-REWRITE.

END-DELETE

Finaliza DELETE.

DELETE ARQCLI

END-DELETE.

END-SEARCH

Finaliza SEARCH.

SEARCH TAB-CLIENTES

   WHEN CODIGO = 100

      DISPLAY 'ACHOU'

END-SEARCH.

END-EVALUATE

Finaliza EVALUATE.

EVALUATE TRUE

   WHEN SALDO > 0

      DISPLAY 'POSITIVO'

   WHEN OTHER

      DISPLAY 'ZERO'

END-EVALUATE.

END-STRING

Finaliza STRING.

STRING

   NOME
   SOBRENOME

   INTO WS-NOME

END-STRING.

END-UNSTRING

Finaliza UNSTRING.

UNSTRING WS-DADOS

   DELIMITED BY ';'

   INTO CAMPO1
        CAMPO2

END-UNSTRING.

END-COMPUTE

Finaliza COMPUTE.

COMPUTE WS-TOTAL = A + B

END-COMPUTE.

END-CALL

Finaliza CALL.

CALL 'CALCULA'

   USING WS-VALOR

END-CALL.

END-START

Finaliza START.

START ARQVSAM

   KEY >= WS-CHAVE

END-START.

END-ACCEPT

Finaliza ACCEPT.

ACCEPT WS-DATA

END-ACCEPT.

END-DISPLAY

Finaliza DISPLAY.

DISPLAY 'TESTE'

END-DISPLAY.

END-ADD

Finaliza ADD.

ADD 10 TO WS-TOTAL

END-ADD.

END-SUBTRACT

Finaliza SUBTRACT.

SUBTRACT 5 FROM WS-TOTAL

END-SUBTRACT.

END-MULTIPLY

Finaliza MULTIPLY.

MULTIPLY A BY B

END-MULTIPLY.

END-DIVIDE

Finaliza DIVIDE.

DIVIDE A INTO B

END-DIVIDE.

END-JSON

Usado em COBOL moderno.

JSON GENERATE WS-JSON

   FROM CLIENTE

END-JSON.

END-XML

Também muito comum.

XML GENERATE WS-XML

   FROM CLIENTE

END-XML.

END-EXEC

Muito utilizado em DB2 e CICS.

DB2

EXEC SQL

   SELECT NOME

   INTO :WS-NOME

   FROM CLIENTES

END-EXEC.

CICS

EXEC CICS

   SEND MAP('TELA1')

END-EXEC.

END-EXEC é Especial

Porque:

EXEC SQL

EXEC CICS

não são comandos COBOL puros.

São pré-processados antes da compilação.

Exemplo Completo

IF WS-SALDO > 0

   PERFORM

      DISPLAY 'SALDO POSITIVO'

   END-PERFORM

ELSE

   DISPLAY 'SEM SALDO'

END-IF.

Benefícios

✅ Legibilidade

✅ Menos erros

✅ Melhor manutenção

✅ Facilita debug

✅ Facilita revisões de código

Padrão Corporativo

Hoje a maioria das empresas exige:

END-IF
END-PERFORM
END-EVALUATE
END-READ
END-EXEC

mesmo quando opcionais.

Erros Comuns

Esquecer END-IF

IF A = 1

   DISPLAY 'OK'

Pode gerar erro de compilação.

Misturar ENDs

IF A = 1

   PERFORM

      DISPLAY 'OK'

END-IF

Compilador detecta inconsistência.

Curiosidade

Nas décadas de 1970 e 1980 muitos programas COBOL eram escritos sem ENDs, utilizando apenas pontos finais (.) para encerrar blocos. Em aplicações modernas, os ENDs são considerados uma das melhores práticas de programação COBOL.

Resumo Rápido

Comando	Terminador
IF	END-IF
PERFORM	END-PERFORM
READ	END-READ
EVALUATE	END-EVALUATE
SEARCH	END-SEARCH
STRING	END-STRING
UNSTRING	END-UNSTRING
CALL	END-CALL
JSON	END-JSON
XML	END-XML
EXEC SQL	END-EXEC
EXEC CICS	END-EXEC

Conclusão

A cláusula END em COBOL serve para indicar explicitamente o término de comandos e blocos lógicos. Ela melhora a legibilidade, reduz ambiguidades, facilita a manutenção e é considerada uma prática obrigatória em praticamente todos os projetos COBOL modernos, especialmente em ambientes IBM Z, CICS, IMS, DB2, XML e JSON.

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.

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

Tipo	Característica
CALL Estático	Nome fixo
CALL Dinâmico	Nome variável
Nested	Programa dentro de programa
Recursivo	Chama a si próprio
LINK CICS	Retorna
XCTL CICS	Não retorna
BY REFERENCE	Passa endereço
BY CONTENT	Passa cópia
BY VALUE	Passa valor
CANCEL	Remove 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.

segunda-feira, 26 de fevereiro de 2007

O que é o comando GOBACK em COBOL?

Bellacosa Mainframe e o comando Goback em Cobol

O que é o comando GOBACK em COBOL?

O comando GOBACK é utilizado para encerrar a execução de um programa ou retornar o controle para o programa chamador.

Ele é considerado uma das instruções mais importantes do COBOL moderno e, em muitos ambientes, substitui o uso de STOP RUN.

Definição Simples

O GOBACK significa:

Volte para quem me chamou

ou, se não existir programa chamador:

Termine a execução

Sintaxe

GOBACK.

Exemplo Simples

IDENTIFICATION DIVISION.
PROGRAM-ID. TESTE.

PROCEDURE DIVISION.

DISPLAY 'OLA MUNDO'.

GOBACK.

Resultado:

OLA MUNDO

Programa finalizado.

Como Funciona?

O comportamento depende da forma como o programa foi executado.

Programa Principal

Executado por JCL:

//STEP1 EXEC PGM=PROG1

Fluxo:

JCL
 ↓
PROG1
 ↓
GOBACK
 ↓
Fim da execução

Subprograma

Programa principal:

CALL 'SUBROT1'.

Subprograma:

DISPLAY 'ENTREI'.

GOBACK.

Fluxo:

MAIN
 ↓
CALL SUBROT1
 ↓
GOBACK
 ↓
MAIN continua

Exemplo Completo

Programa Principal:

IDENTIFICATION DIVISION.
PROGRAM-ID. MAIN.

PROCEDURE DIVISION.

DISPLAY 'ANTES'.

CALL 'SUB1'.

DISPLAY 'DEPOIS'.

GOBACK.

Subprograma:

IDENTIFICATION DIVISION.
PROGRAM-ID. SUB1.

PROCEDURE DIVISION.

DISPLAY 'SUBPROGRAMA'.

GOBACK.

Saída:

ANTES
SUBPROGRAMA
DEPOIS

GOBACK x STOP RUN

Essa é a comparação mais importante.

GOBACK	STOP RUN
Retorna ao chamador	Finaliza tudo
Seguro para subprogramas	Perigoso em subprogramas
Recomendado atualmente	Uso tradicional
Funciona em programas chamados	Encerra toda aplicação

Exemplo Visual

GOBACK

MAIN
 ↓
SUB1
 ↓
GOBACK
 ↓
MAIN continua

STOP RUN

MAIN
 ↓
SUB1
 ↓
STOP RUN
 ↓
Tudo termina

Uso em Batch

Muito comum.

OPEN INPUT ARQCLI

PERFORM PROCESSA

CLOSE ARQCLI

GOBACK.

Uso em Subprogramas

É a principal recomendação.

CALL 'CALCULO'

CALL 'VALIDA'

GOBACK.

Uso em Programas DB2

Também é amplamente utilizado.

IF SQLCODE NOT = 0

   DISPLAY SQLCODE

   GOBACK

END-IF.

GOBACK e Return Code

Pode ser combinado com:

MOVE 8 TO RETURN-CODE.

GOBACK.

Resultado:

CC=0008

GOBACK e Language Environment

No ambiente LE (Language Environment), o GOBACK é tratado de forma inteligente.

Se existir chamador:

Retorna ao chamador

Se não existir:

Finaliza execução

EXIT PROGRAM x GOBACK

Outro comando relacionado.

EXIT PROGRAM

EXIT PROGRAM.

Retorna apenas ao chamador.

GOBACK

GOBACK.

Retorna ao chamador ou termina a aplicação.

Comparação

Comando	Função
EXIT PROGRAM	Retorna ao chamador
GOBACK	Retorna ou termina
STOP RUN	Finaliza tudo

Exemplo com EXIT PROGRAM

IDENTIFICATION DIVISION.
PROGRAM-ID. SUB1.

PROCEDURE DIVISION.

DISPLAY 'SUB'.

EXIT PROGRAM.

Boas Práticas

✅ Utilize GOBACK em subprogramas

✅ Utilize GOBACK em programas novos

✅ Defina RETURN-CODE quando necessário

✅ Evite STOP RUN em módulos chamados

✅ Padronize o encerramento dos programas

Erros Comuns

STOP RUN em subprograma

CALL 'SUB1'

SUB1:

STOP RUN.

Resultado:

Aplicação inteira termina

Não retornar código

GOBACK.

Sem:

MOVE 8 TO RETURN-CODE

Pode dificultar automação.

Curiosidades

1. O GOBACK foi introduzido para simplificar o retorno de programas chamados

2. É amplamente recomendado pela IBM para novos desenvolvimentos

3. Funciona perfeitamente com Language Environment (LE)

4. É um dos comandos mais encontrados em aplicações COBOL modernas

5. Em muitos padrões corporativos, STOP RUN é proibido em subprogramas

Resumo Rápido

Conceito	Função
GOBACK	Retorna ao chamador ou termina
STOP RUN	Finaliza toda aplicação
EXIT PROGRAM	Retorna ao chamador
CALL	Chama subprograma
RETURN-CODE	Código retorno
LE	Language Environment
Batch	Uso comum
Subprograma	Comando recomendado

Conclusão

O GOBACK é o comando de encerramento mais flexível do COBOL moderno. Ele permite que um subprograma retorne ao programa chamador sem interromper toda a aplicação e, quando executado em um programa principal, encerra normalmente a execução. Por isso, é considerado a melhor prática para o desenvolvimento COBOL em ambientes z/OS, CICS, IMS e DB2.

Translate

domingo, 4 de março de 2007