Praticando Cobol: variáveis estruturais

Variáveis estruturais - Apresentação

Olá! Meu nome é Ivan Petrucci. Boas-vindas ao curso de COBOL.

Audiodescrição: Ivan se identifica como uma pessoa de pele branca. Possui cabelos curtos, barba curta e bigode castanhos, além de olhos castanhos. Usa óculos de grau, de armação escura, e uma camiseta escura. Ao fundo, uma parede lisa, iluminada em tons de azul.

O que aprenderemos?

Neste curso, aprenderemos sobre variáveis estruturadas. Convidamos você a aprender mais sobre o assunto no próximo vídeo.

Variáveis estruturais - Variáveis

Neste curso, vamos aprender sobre variáveis estruturadas, ou do tipo estrutura.

Revisando a estrutura de dados em COBOL

Vamos fazer uma breve revisão: as variáveis de estrutura vão de 1 a 49. Isso significa que temos a variável pai, NÍVEL 01, depois a filha, NÍVEL 02 e uma filha da filha, NÍVEL 03. Esses são os níveis de variáveis que podem ser utilizados:

• NÍVEL 01
  • NÍVEL 02
  • NÍVEL 02
    • NÍVEL 03
  • NÍVEL 02

Para ilustrar, vamos criar uma estrutura de dados em COBOL. No exemplo abaixo, definimos uma variável WS-DADOS com seus respectivos filhos:

01 WS-DADOS.
    02 WS-NOME PIC X(15).
    02 WS-EMAIL PIC X(20).
    02 WS-ENDERECO.
        03 WS-RUA     PIC X(15).
        03 WS-BAIRRO PIC X(10).

Neste exemplo, temos uma variável DADOS, que possui os filhos NOME, EMAIL e ENDERECO. O filho ENDERECO não tem tamanho definido, pois é subdividido em outros dois filhos: RUA e BAIRRO.

O layout abaixo, supostamente de 60 posições, é exatamente o tamanho da variável DADOS:

1------------------------------------------------------------60
CARLOS ALBERTO|CARLOS@GMAIL.COM   |RUA RIO CLARO   |LAPA

Assim, cada informação, como o nome "Carlos Alberto", o e-mail, a rua e o bairro, se encaixará dentro dos espaços definidos.

Repetindo nomes de variáveis

Uma questão que surge é: podemos repetir nomes de variáveis? Vamos imaginar uma situação em que precisamos usar uma estrutura para ler dados do arquivo 1 e outra para o arquivo 2, ambas com nomes iguais:

ESTRUTURA 1:

01 WS-ARQUIVO1.
    02 WS-NOME PIC X(15).
    02 WS-EMAIL PIC X(20).
    02 WS-ENDERECO.
        03 WS-RUA     PIC X(15).
        03 WS-BAIRRO PIC X(10).

ESTRUTURA 2:

01 WS-ARQUIVO2.
    02 WS-NOME PIC X(15).
    02 WS-EMAIL PIC X(20).
    02 WS-ENDERECO.
        03 WS-RUA     PIC X(15).
        03 WS-BAIRRO PIC X(10).

Podemos ter WS-NOME em ambas. O Cobol não se confundirá com os nome iguais porque cada variável pertence ao seu respectivo conjunto. Quando estruturamos uma variável, os filhos dela são independentes.

Para referenciar uma variável específica, podemos usar o OF, como mostrado abaixo:

DISPLAY "NOME ARQUIVO1" OF WS-ARQUIVO1.
DISPLAY "NOME ARQUIVO2" OF WS-ARQUIVO2.

Manipulando datas

Acessaremos o Visual Studio para abrir um programa pré-pronto, variaveis.cob, cuja proposta é trabalhar com datas. Em seu interior, observaremos que os nomes das variáveis, como ANO, são os mesmos:

variaveis.cob:

IDENTIFICATION DIVISION.
PROGRAM-ID. VARIAVEIS.
*================================================*
*-- AUTHOR: IVAN
*================================================*

DATA DIVISION.

WORKING-STORAGE SECTION.

01 WRK-DATA.
    05 WRK-ANO PIC 9(04).
    05 WRK-MES PIC 9(02).
    05 WRK-DIA PIC 9(02).

01 WRK-DATA-EDITADA.
    05 WRK-DIA PIC 9(02).
    05 FILLER PIC X VALUE "/".
    05 WRK-MES PIC 9(02).
    05 FILLER PIC X VALUE "/".
    05 WRK-ANO PIC 9(04).

* Código omitido

Isso poderia causar um problema de referência, mas agora sabemos da existência do OF.

A diferença entre as variáveis é que estamos formatando uma delas para o formato dia, mês, ano. O COBOL devolve os dados no formato ano, mês, dia, mas queremos dia, mês, ano.

Ao ler na variável DATA, ele devolverá quatro caracteres para o ano, dois para mês e dois para dia. Ao imprimir na variável DATA-EDITADA, mostraremos o dia, incluindo um filler entre cada dado para inserir barras entre o mês e o ano.

As variáveis HORARIO-E e HORARIO-S trabalham com o horário. Vamos entendê-las em breve.

Também temos as variáveis de apoio TECLA e tempo que serão usadas daqui a pouco.

01 WRK-TECLA  PIC X.
01 WRK-TEMPO  PIC S9(02).

Mais abaixo, temos a PROCEDURE na qual receberemos a informação na variável DATA, no formato ano, mês, dia. Se mostrarmos essa variável, a data virá nesse formato. Para evitar isso, usaremos o MOVE CORRESPONDING e moveremos os dados para uma variável com o formato editado, que será exibida.

Importante: somente variáveis de mesmo nome são movidas de um programa para outro.

Ao receber a data, precisamos forçar quatro dígitos para o ano. Por isso, utilizamos quatro 'Y'.

PROCEDURE DIVISION.
ACCEPT WRK-DATA FROM DATE YYYYMMDD.
    MOVE CORRESPONDING WRK-DATA TO WRK-DATA-EDITADA.

DISPLAY "DATA ATUAL " WRK-DATA-EDITADA.

GOBACK.

Executando o programa

Vamos compilar e rodar o programa. No terminal, faremos:

cobc -x -o bin\variaveis.exe variaveis.cob

No prompt de comando, acessando a pasta onde soltamos os arquivos executáveis, rodaremos:

VARIAVEIS

Ao rodar, ele nos devolverá a data atual formatada com a string "DATA ATUAL ":

DATA ATUAL 08/04/2025.

O CORRESPONDING fez esse papel.

Agora, faremos outra alteração no código, utilizando o recurso do OF.

Manipulando horários

Já aprendemos que podemos mover estruturas de um programa para outro, movendo apenas as variáveis iguais. Vamos aproveitar isso.

Temos as variáveis HORARIO-E e HORARIO-S, com HORA, MINUTO e SEGUNDO. Agora, vamos receber a hora. Na PROCEDURE, abaixo do MOVE CORRESPONDING, pularemos uma linha e adicionaremos um ACCEPT.

Dentro da variável HORARIO-E, vamos receber a hora atual. Diremos que a hora virá dessa variável no formato horas, minutos, segundos e milissegundos — todos com dois dígitos. Não há separador entre eles, pois isso poderia causar confusão.

Além disso, não precisamos dos milissegundos — se o quisermos posteriormente, criaremos mais uma variável.

ACCEPT WRK-HORARIO-E FROM TIME.

A variável TECLA existe apenas para aguardar a tecla digitada pela pessoa usuária. Vamos adicioná-la abaixo da linha acima.

ACCEPT WRK-TECLA.

Assim que pressionarmos "Enter", receberemos a hora S, que nos dará a hora após a execução.

ACCEPT WRK-HORARIO-S FROM TIME.

Temos a hora de entrada, seguramos a tecla, e a hora de saída. Estamos simulando o processamento de um programa.

Quando o programa começa, gravaremos a hora. Quando termina, gravaremos novamente. Podemos mostrar o tempo decorrido entre o início e o fim do programa.

Calculando o tempo decorrido

Abaixo do DISPLAY da data atual, colocaremos os dois horários. A hora de entrada terá o texto "HORA E " e a variável HORARIO-E e a hora de saída terá o texto "HORA S " e a variável HORARIO-S.

DISPLAY "HORA E " WRK-HORARIO-E.
DISPLAY "HORA S " WRK-HORARIO-S.

Colocamos a hora de entrada, esperamos um pouco, e colocamos a hora de saída, mostrando a diferença entre elas. Vamos compilar e verificar como ficou.

Ao compilar e rodar, o programa espera que pressionemos alguma tecla. Ao pressionar "Enter", ele mostra quando começou e quando terminou:

DATA ATUAL 08/04/2025

HORA E 150641

HORA S 150649

Não se trata de um programa interativo, então não adicionaremos mensagens para a pessoa usuária. Estamos apenas testando.

Por fim, moveremos o DISPLAY da data atual para abaixo do MOVE CORRESPONDING, acima do trecho que manipula os horários.

Calculando intervalos de tempo

Vamos calcular o intervalo de tempo entre os horários de entrada e saída. Usaremos a variável de apoio, TEMPO. Utilizamos S de negativo nela, pois ao fazer a diferença entre tempos, podemos ter um resultado negativo.

01 WRK-TEMPO  PIC S9(02).

Por exemplo, se começarmos em 58 segundos e terminarmos em 4 segundos, 58 menos 4 resultará em um valor negativo.

O DISPLAY das horas de entrada e de saída estão nas últimas linhas do código. Acima delas, faremos algumas contas.

Na variável TEMPO, faremos a seguinte conta: pegaremos a hora de saída e subtrairemos da hora de entrada. Isso nos dará o tempo decorrido.

Por fim, exibiremos o tempo em horas na variável TEMPO. Podemos apagar os DISPLAY de HORA-E e HORA-S

COMPUTE WRK-TEMPO =
WRK-HORA OF WRK-HORARIO-S - WRK-HORA OF WRK-HORARIO-E.
DISPLAY "TEMP EM HORAS " WRK-TEMPO.

Em horas, não teremos quase nada. Portanto, começaremos a calcular minutos e segundos. A variável TEMPO pode ser a mesma, pois será usada e descartada.

Teremos blocos de código para os minutos e segundos, similares ao bloco de hora. Calcularemos os minutos e segundos da hora de saída menos os minutos e segundos da hora de entrada.

COMPUTE WRK-TEMPO =
WRK-HORA OF WRK-HORARIO-S - WRK-HORA OF WRK-HORARIO-E.
DISPLAY "TEMP EM HORAS " WRK-TEMPO.

COMPUTE WRK-TEMPO =
WRK-MINUTO OF WRK-HORARIO-S - WRK-MINUTO OF WRK-HORARIO-E.
DISPLAY "TEMP EM MINUTOS " WRK-TEMPO.

COMPUTE WRK-TEMPO =
WRK-SEGUNDO OF WRK-HORARIO-S - WRK-SEGUNDO OF WRK-HORARIO-E.
DISPLAY "TEMP EM SEGUNDOS " WRK-TEMPO.

Vamos salvar, compilar e rodar. Após rodar VARIAVEIS, esperar um pouco após a exibição da data e apertar "Enter", veremos que em minutos não houve diferença, mas em segundos, sim:

DATA ATUAL 08/04/2025

TEMP EM HORAS +00

TEMP EM MINUTOS +00

TEMP EM SEGUNDOS +03

Ao rodar novamente, contar quatro segundos e pressionar "Enter", vemos que ele contará quatro segundos passados.

TEMP EM SEGUNDOS +04

Conclusão

Adaptando esse código, conseguiremos medir precisamente quanto tempo passou. Quando o programa começa, gravamos a hora, e quando termina, subtrairemos a hora de saída da outra para saber a diferença. Isso foi possível graças ao uso do OF, que indica se a variável é de saída ou entrada.

Esperamos que tenha gostado deste conteúdo. Até a próxima!

Sobre o curso Praticando Cobol: variáveis estruturais

O curso Praticando Cobol: variáveis estruturais possui 14 minutos de vídeos, em um total de 17 atividades. Gostou? Conheça nossos outros cursos de em Programação, ou leia nossos artigos de Programação.

Matricule-se e comece a estudar com a gente hoje! Conheça outros tópicos abordados durante o curso:

• Variáveis estruturais