Grande porte cobol level 1 - versão 2.3.5

www.grandeporte.com.br  (11) 4427-4579 (11) 9 9903-3218
COBOL Level 1

Versão 2.3.5 – PDF liberado em 26/04/2015
Fique atento para novas versões em nosso site.
Sobre o autor
Prof. Nelson Goncalves de Oliveira
Cientista da Computacão pelo IMES-SCS,
Especialista em Telecomunicacões pela
FAAP-SP, mestrando em ciência da
computacão pela UFAbc-sp.
Iniciou a carreira como desenvolvedor de
software em 1987, especializando-se em
COBOL para Mainframes IBM.
Professor universitário Desde 2000,
leciona diversas disciplinas nos cursos de
Ciência da Computacão e Informática.
fundou a Grande Porte em 2008 com o
objetivo de difundir essa experiência para
o mercado.
“O COBOL tem aberto as portas de
diversas empresas para os nossos
alunos e, mesmo após 55 anos de
existência, continua firme e forte
suportando globalmente o comércio
mundial.”
,
,
,
,
,
nelson@grandeporte.com.br

Parte
A Almirante Grace Murray Hopper (1906 – 1992) foi
uma das primeiras programadoras do sistema Haward Mark I
e foi a criadora do primeiro compilador para uma linguagem de
programação de computadores. Criou a Linguagem de
programação FLOW-MATIC, que serviu como base para a
criação da linguagem COBOL, participando ativamente da
validação da primeira versão desta linguagem.

Parte 1
3
1
Antes de iniciarmos, vamos conversar sobre os tópicos apresentados na
capa desta parte. Isso é importante para que seu instrutor e seus colegas
saibam como está seu conhecimento sobre o assunto e se você precisa ou
pode fornecer ajuda aos colegas e instrutor.
 O que você já sabe ?
 O que você não sabe ?
 Porque é importante conhecer estes tópicos ?
 Quais são os seus temores ?
 O que você considera difícil ?
Depois de falar sobre o assunto com seus colegas e instrutor, escreva,
desenhe, rabisque, diga algo sobre o que você vai fazer para dominar esses
tópicos. Comprometa-se!
TrocandoIdeias É agora que você fala !!
Preparation
Reflexão É aqui que você se compromete !!

Parte 1
4
A XPTO consultoria em desenvolvimento de software é uma empresa
especializada no desenvolvimento de soluções informatizadas para seus clientes.
Suas soluções atendem as mais diversas plataformas de Hardware e Sistemas
Operacionais, tais como Mainframe (Z/OS), AS/400 (OS/400), RISC (UNIX), PC
(Windows/Linux), Tablets (Android/iOS), bem como aplicações para a Internet.
Suas soluções de software são também desenvolvidas nas mais diversas
linguagens de programação, tais como COBOL, Java, C#, C/C++, HTML, ASP.NET,
etc.
Você é o mais novo estagiário da XPTO e, portanto passará por esse programa
de treinamento em COBOL, junto com o TSO e a linguagem JCL, utilizados na
plataforma mainframe. Todo o conhecimento de lógica de programação que você
possui será usado neste treinamento.
Chama-se plataforma Mainframe ao computador de Grande Porte da IBM para
processamento de transações. É utilizado por grandes empresas e está vivendo uma
fase de crescimento, apesar da dificuldade de se encontrar mão de obra qualificada. A
linguagem de programação mais utilizada nesta plataforma é o COBOL. Criada no fim
da década de 1950 é a linguagem mais importante nesta plataforma, de fácil
compreensão por ser parecida com o inglês corrente. Este será o foco de seu
treinamento.
Então vamos lá, bons estudos e tenham muita dedicação.
Presentation
Consultoria
em
Desenvolvimento
de
Software
História Conheca a xpto !!,

Parte 1
5
1
Origens
O COBOL foi criado em 1959 pelo CODASYL (Conference on Data Systems
Language), um dos três comitês propostos numa reunião no Pentágono em Maio de
1959, organizado por Charles Phillips do Departamento de Defesa dos Estados
Unidos. O CODASYL foi formado para recomendar as diretrizes de uma linguagem de
programação para negócios. Foi constituído por membros representantes de seis
fabricantes de computadores e três órgãos governamentais, a saber:
 Burroughs Corporation
 IBM
 Minneapolis-Honeywell (Honeywell Labs)
 RCA
 Sperry Rand
 Sylvania Electric Products
 Força Aérea dos Estados Unidos
 David Taylor Model Basin
 Agência Nacional de Padrões (National Bureau of Standards ou NBS).
Este comitê foi presidido por um membro do NBS. Um comitê de Médio Prazo e
outro de Longo Prazo foram também propostos na reunião do Pentágono. Entretanto,
embora tenha sido formado, o Comitê de Médio Prazo nunca chegou a funcionar; e o
Comitê de Longo Prazo nem chegou a ser formado. Por fim, um subcomitê do Comitê
de Curto Prazo desenvolveu as especificações da linguagem COBOL. Este subcomitê
era formado por seis pessoas:
William Selden e Gertrude Tierney da IBM
Howard Bromberg e Howard Discount da RCA
Vernon Reeves e Jean E. Sammet da Sylvania Electric Products
Este subcomitê completou as especificações para o COBOL no fim do ano de
1959. Elas foram inspiradas em grande parte pela linguagem FLOW-MATIC inventada
por Grace Murray Hopper, e pela linguagem COMTRAN da IBM inventada por Bob
Bemer.
As especificações foram aprovadas pelo CODASYL. A partir daí foram
aprovadas pelo Comitê Executivo em Janeiro de 1960, e enviadas à gráfica do
governo, que as editou e imprimiu com o nome de COBOL 60. O COBOL foi
desenvolvido num período de seis meses, e continua ainda em uso depois de mais de
50 anos.
Teoria
Introdução à
linguagem cobol

Parte 1
6
Grace Murray Hopper
Grace Hopper foi uma analista de sistemas da marinha americana nas
décadas de 1940 e 1950, criadora da linguagem de programação FLOW-MATIC, hoje
extinta. Como sua linguagem serviu como base para a criação do COBOL, atribui-se à
ela o título de “Mãe do COBOL”. É (equivocadamente) de autoria de Hopper a
invenção da palavra "bug", usada para designar uma falha em um código-fonte, devido
a uma traça que ela encontrou esmagada em um relê do computador UNIVAC MARK
II.
FLOW-MATIC
A linguagem FLOW-MATIC, originalmente conhecida como B-0 (Business
Language version 0), foi a primeira linguagem de processamento de dados parecida
com o idioma inglês. Ela foi desenvolvida para o UNIVAC I da Remington Rand por
Grace M. Hopper.
Grace havia observado que os usuários da área de negócios não se sentiam
confortáveis com a notação matemática exigida pelo FORTRAN, que foi a primeira
linguagem de programação de alto nível, significando FORmula TRANslator (Tradutor
de Fórmulas). No final de 1953 ela propôs que os problemas de processamento de
dados deveriam ser expressos usando palavras-chave em inglês, mas a gestão da
Rand considerava a ideia inviável. No início de 1955, ela e sua equipe escreveram
uma especificação para uma linguagem de programação com essas características e
implementaram um protótipo. O compilador do FLOW-MATIC tornou-se publicamente
disponível no início de 1958 e foi substancialmente completado em 1959.
O FLOW-MATIC foi a primeira linguagem de programação a expressar suas
operações usando comandos em inglês, foi o primeiro sistema que separou a
descrição dos dados das operações. Sua linguagem de definição de dados, diferente
Almirante Grace Murray Hopper
 1906 – 1992
1º bug (inseto = erro) de computador

Parte 1
7
1
dos comandos de execução, não eram em inglês, em vez disso, as estruturas de
dados eram definidas preenchendo formulários pré-impressos.
O FLOW-MATIC foi a maior influência no projeto do COBOL. Muitos de seus
elementos foram incorporados ao COBOL, tais como:
 Definição dos arquivos em detalhes, separando em arquivos de entrada
(INPUT) e saída (OUTPUT).
 Qualificação dos nomes de dados (cláusulas IN e OF)
 Cláusulas IF END OF DATA (AT END) na operação de leitura (READ) de
arquivos
 Constante figurativa ZERO (originalmente ZZZ...ZZZ, onde a quantidade de Z's
indicava a precisão)
 Dividir o programa em seções, separando diferentes partes dos programas. O
FLOW-MATIC incluía as seções COMPUTER (ENVIRONMENT DIVISION),
DIRECTORY (DATA DIVISION) e COMPILER (PROCEDURE DIVISION).
CONTRAM
A linguagen COMTRAN (COMmercial TRANslator) é uma antiga linguagem de
programação desenvolvida na IBM. Seu objetivo era ser uma linguagem de
programação comercial equivalente a linguagem de programação cientítica FORTRAN
(FORmula TRANslator). Ela serviu como impulsionadora da linguagem COBOL. foi
desenvolvida em 1957 por Bob Bemer (Robert William Bemer 1920 – 2004), foi
influenciada pelo FLOW-MATC e influenciou o COBOL. O CONTRAM foi a primeira
linguagem de programação a usar a cláusula PIC.
Muitos elementos da COMTRAN foram incorporados ao COBOL, tais como:
 Cláusula PIC, define o tamanho dos dados e seu tipo
 Divisão do código em parágrafos com nomes, sendo possível pular (GO TO)
para um nome de parágrafo
 Cláusula AT END nas operações de arquivos de entrada
 Constante figurativa HIGH-VALUE
 Retorno ao sistema operacional de um valor numérico quando o programa
encerra. (RETURN-CODE)
COBOL II
O COBOL é uma linguagem de alto nível, isto é, semelhante a linguagem
humana. É um acrônimo e significa COmmon Business Oriented Language
(Linguagem Comum Orientada aos Negócios). Como seu nome indica, o objetivo
desta linguagem é permitir o desenvolvimento de aplicações comerciais para pessoas
sem conhecimento profundo de computadores. Por isso a linguagem COBOL usa
frases normais da língua inglesa, e a estrutura de um programa COBOL se assemelha
a um texto com divisões, seções, parágrafos e frases em inglês. Uma das
características importantes do COBOL é sua auto documentação: um programador
pode entender um programa COBOL pela simples leitura de sua codificação.

Parte 1
8
O COBOL II foi liberado pela IBM no inicio dos anos 90 e é a atual versão
utilizada pelas empresas usuárias de computadores de Grande Porte. É uma
linguagem poderosa e flexível para as aplicações comerciais atuais e permite a
codificação de programas especificados pelas metodologias: Programação
Estruturada, TOP-DOWN e MODULAR.
No COBOL II foram incluídos comandos para COPY book, PERFORM IN-LINE,
DELIMITADORES DE ESCOPO e os comandos EVALUATE e INITIALIZE entre outros.
O módulo objeto gerado ficou mais potente, podendo utilizar todas as
facilidades dos sistemas operacionais modernos. Pode-se rodar um programa acima
da linha dos 16 MBytes e com 31 bits de endereçamento de memória tornando mais
fácil o desenvolvimento de grandes aplicações. O compilador foi totalmente reescrito
tendo sido eliminados comandos e instruções obsoletas das versões anteriores,
tratando-se de um compilador novo, o COBOL II apresenta algumas melhorias em
relação ao antigo permitindo uso mais eficiente dos recursos, como maior facilidade de
depuração BATCH e novo formato das listagens de compilação.
Grace Hopper em 1960
com o manual da
1ª versão do COBOL

Parte 1
9
1
É a modalidade de processamento onde uma coleção de registros de um ou
mais arquivos de entrada é processada e um ou mais arquivos de saída são gravados.
Não há interação com o usuário, uma vez iniciado um programa batch, ele só termina
quando todos os dados de entrada foram processados ou quando acontecer um erro
de processamento.
Os algoritmos desenvolvidos para esta modalidade de processamento têm o
seguinte aspecto:
algoritmo batch
execute rotina-inicializar
execute rotina-processar até fim dos arquivos de entrada
execute rotina-termino
fim-algoritmo
Na rotina-inicializar, realizamos as seguintes tarefas:
 Inicialização das variáveis (contadores e acumuladores)
 Abertura dos arquivos de entrada e saída
 Leitura do primeiro registro dos arquivos de entrada
Na rotina-processar, realizamos as seguintes tarefas:
 Seleção de registros para o processamento, pelos operadores
relacionais (=, <, >, >=, <= e NOT =) e operadores lógicos (AND,
OR e NOT)
 Processamento dos campos numéricos pelos operadores
aritméticos (+,-,*,/ e **)
 Movimentação de campos da entrada para a saída
 Gravação do registro de saída
 Leitura do próximo registro do arquivo de entrada
Na rotina-termino, realizamos as seguintes tarefas:
 Exibição de uma estatística de processamento, mostrando
registros lidos, gravados, desprezados, selecionados, etc.
(contadores e acumuladores)
 Fechamento dos arquivos de entrada e de saída
 Exibição de mensagem avisando do término normal do
processamento
Teoria PROCESSAMENTO BATCH
== EM LOTES ==

Parte 1
10
O processamento em lotes é uma atividade corriqueira, que realizamos toda a
vez que precisamos lidar com um lote de documentos, fichas de inscrição, provas para
corrigir, contas para conferir, etc.
rotina-inicializar Começamos organizando a mesa onde vamos trabalhar,
zerando a calculadora, abrindo o lote de documentos e pegando o primeiro documento
da pilha.
rotina-processar Enquanto houver documentos na pilha, para cada
documento vamos processando seus dados, contabilizando ocorrências, acumulando
valores e por último pegamos o próximo documento da pilha.
rotina-termino No final, aliviados pelo término do trabalho, fechamos o lote,
exibimos o resultado do processamento e avisamos que acabou.
Exemplo de processamento em lote (batch)

Parte 1
11
1
Objetivo do Programa
Calcular o valor a receber de vários funcionários, com base na quantidade de
horas trabalhadas, com salário fixo de R$ 25,00 por hora.
Macro-Fluxo
Observação
A quantidade de horas trabalhadas pelos funcionários está gravada em uma
SYSIN. O programa EEXXNN01 lê todas as horas gravadas na SYSIN, e para cada
uma delas, calcula o salário e o exibe na SYSOUT.
Além disso, também deve ser exibido o número de salários que foram
calculados e a soma de todos os salários.
A SYSIN (SYSTEM INPUT) é lida com o comando ACCEPT, que carrega na
variável informada o dado lido. Exemplo:
ACCEPT QTDHSTRAB FROM SYSIN
A SYSOUT (SYSTEM OUTPUT) é gravada com o comando DISPLAY, que
exibe constantes e valores de variáveis informadas. Exemplo:
DISPLAY "TOTAL DE FUNCIONARIOS LIDOS.: " CONTFUNC
EXEMPLO PROCESSAMENTO BATCH
SYSIN
SYSOUT
EEXXNN01

Parte 1
12
JOB de Execução
Observe a SYSIN, onde as horas trabalhadas estão informadas. O último valor
0000 é um indicador de que não há mais horas para calcular o salário. É comum
utilizar um valor previamente combinado para indicar o término dos dados da SYSIN,
essa técnica é conhecida como SENTINELA.
11234567892123456789312345678941234567895123456789612345678971234567898
12345678901234567890123456789012345678901234567890123456789012345678901234567890
//GPXXNNE1 JOB 'SEUNOME',MSGCLASS=X,CLASS=C,NOTIFY=GPXXNN,TIME=(0,20)
//*******************************************************************
//JOBLIB DD DSN=GP.GERAL.LOADLIB,DISP=SHR
//STEP1 EXEC PGM=EEXXNN01
//SYSIN DD *
0150
0085
0180
0025
0090
0125
0070
0000
//*
Programa COBOL
----+-*A-1-B--+----2----+----3----+----4----+----5----+----6----+----7--|-+----8
*--------------------------------------------------------------*
* EXEMPLO 01 - COBOL LEVEL 1 *
*--------------------------------------------------------------*
* OBJETIVO : CALCULAR O VALOR A RECEBER DE VARIOS FUNCIONARIOS *
* COM BASE NA QUANTIDADE DE HORAS TRABALHADAS, COM *
* SALARIO FIXO DE R$ 25,00 POR HORA. *
*--------------------------------------------------------------*
IDENTIFICATION DIVISION.
*--------------------------------------------------------------*
PROGRAM-ID. EEXXNN01.
AUTHOR. GRACE.
*--------------------------------------------------------------*
ENVIRONMENT DIVISION.
*--------------------------------------------------------------*
CONFIGURATION SECTION.
SPECIAL-NAMES.
DECIMAL-POINT IS COMMA.
INPUT-OUTPUT SECTION.
*--------------------------------------------------------------*
DATA DIVISION.
*--------------------------------------------------------------*
FILE SECTION.
WORKING-STORAGE SECTION.
77 QTDHRSTRAB PIC 9(04).
77 CONTFUNC PIC 9(05).
77 SOMASAL PIC 9(12)V99.
77 SALARIO PIC 9(06)V99.
Sentinela.
e

Parte 1
13
1
----+-*A-1-B--+----2----+----3----+----4----+----5----+----6----+----7--|-+----8
*--------------------------------------------------------------*
PROCEDURE DIVISION.
*--------------------------------------------------------------*
0000-EEXXNN01.
PERFORM 1000-INICIALIZAR
PERFORM 2000-PROCESSAR
UNTIL QTDHRSTRAB = 0
PERFORM 3000-TERMINO
STOP RUN
.
1000-INICIALIZAR.
MOVE 0 TO CONTFUNC
MOVE 0 TO SOMASAL
PERFORM 1500-LER-SYSIN
.
1500-LER-SYSIN.
ACCEPT QTDHRSTRAB FROM SYSIN
IF QTDHRSTRAB NOT = 0
COMPUTE CONTFUNC = CONTFUNC + 1
END-IF
.
2000-PROCESSAR.
COMPUTE SALARIO = QTDHRSTRAB * 25
COMPUTE SOMASAL = SOMASAL + SALARIO
DISPLAY "*********************************"
DISPLAY "FUNCIONARIO........: " CONTFUNC
DISPLAY "QTDE. HORAS TRAB...: " QTDHRSTRAB
DISPLAY "SALARIO............: " SALARIO
DISPLAY "*********************************"
.
3000-TERMINO.
DISPLAY "*-------------------------------------------------*"
DISPLAY " TOTAL DE FUNCIONARIOS LIDOS.: " CONTFUNC
DISPLAY "*-------------------------------------------------*"
DISPLAY " SOMA DOS SALARIOS A PAGAR...: " SOMASAL
DISPLAY "*-------------------------------------------------*"
DISPLAY "* TERMINO NORMAL DO EEXXNN01 *"
DISPLAY "*-------------------------------------------------*"
.

Parte 1
14
ACCEPT da SYSIN
O COBOL foi desenvolvido originalmente para processar arquivos de dados e
ainda é usado com esta finalidade. Entretanto, em muitas ocasiões existe a
necessidade de interação com o operador do Mainframe. Usamos o comando (verbo)
ACCEPT para receber os dados de entrada por meio de um cartão DD do JCL (tratado
no programa COBOL como SYSIN). Exemplo:
12345678911234567892123456789312345678941234567895123456789612345678971234567898
12345678901234567890123456789012345678901234567890123456789012345678901234567890
//GPXXNNE1 JOB ‘SEUNOME’,MSGCLASS=X,CLASS=C,NOTIFY=GPXXNN,TIME=(0,20)
//*********************’*********************************************
//JOBLIB DD DSN=GP.GERAL.LOADLIB,DISP=SHR
//STEP1 EXEC PGM=EEXXNN01
//SYSIN DD *
0150
0085
0180
0025
0090
0125
0070
0000
//*
Abaixo temos um exemplo de ACCEPT da SYSIN:
----+-*A-1-B--+----2----+----3----+----4----+----5----+----6----+----7--|-+----8
ACCEPT QTDHRSTRAB FROM SYSIN
Quando a opção FROM é omitida o padrão FROM SYSIN é assumido.
Cada vez que o programa passa pela instrução ACCEPT, uma linha da SYSIN
do JCL é carregada na variável QTDHRSTRAB.
É necessário colocar no programa COBOL uma condição para parar de ler a
SYSIN. Observe no JCL acima que o último número é tudo zero. No programa a
SYSIN será lida até que (UNTIL) se encontre o valor zero (0).
Essa técnica é chamada de SENTINELA, pois temos um valor previamente
combinado que indica o término da SYSIN. Se isso não for feito, o ACCEPT lerá os
números da SYSIN até acabar e depois repetirá a leitura do último número vária vezes,
até que o programa pare por TIME OUT, ou seja, acabar o tempo reservado para ele
executar.
Teoria Comandos básicos

Parte 1
15
1
DISPLAY
Exibe constantes e/ou variáveis num dispositivo de saída. Normalmente é o
dispositivo cujo DDNAME é SYSOUT. Exemplo:
----+-*A-1-B--+----2----+----3----+----4----+----5----+----6----+----7--|-+----8
.......999-ERRO.
...........DISPLAY "*------------------------------------------*"
...........DISPLAY " MENSAGEM.....: " WS-MSG
...........DISPLAY " FILE STATUS..: " WS-FS
...........DISPLAY "*------------------------------------------*"
...........DISPLAY " TERMINOxANORMALxDOxPROGRAMAx xxxxxxx"
...........DISPLAY "*------------------------------------------*"
...........STOP RUN
............
COMPUTE
Realiza operações aritméticas mais sofisticadas, utilizando o operador de
atribuição = (sinal de igualdade) e uma expressão aritmética. Exemplo:
----+-*A-1-B--+----2----+----3----+----4----+----5----+----6----+----7--|-+----8
COMPUTE WS-CONTADOR = WS-CONTADOR + 1
COMPUTE WS-SALARIO-ANUAL = WS-SALARIO-MES * 12
COMPUTE WS-DIAGONAL = ((2 * WS-LADO ** 2) ** 0,5)
Observe o compute com o número 0,5 escrito com vírgula para separar a parte
decimal. Isso só é possível se no parágrafo SPECIAL-NAMES for utilizado a
declaração DECIMAL-POINT IS COMMA como será visto mais adiante.
Os operadores aritméticos possuem prioridades diferentes, como mostra a
tabela abaixo. Quando houver operadores de mesma prioridade, eles serão
executados da esquerda para a direita.
Operação Símbolo Prioridade
Parênteses ( ) 0
Potência ** 1
Multiplicação * 2
Divisão / 2
Adição + 3
Subtração - 3
Deve haver um espaço em branco antes e depois do operador aritmético e
do operador de atribuição. Fique atento ao fato de que as expressões aritméticas
devem ser escritas em formato linear. Exemplo, a expressão aritmética abaixo
𝑥 = 𝐴 +
𝐵
𝐶 +
𝐷
𝐸 + 𝐹
convertida para o formato linear fica
X = A + (B /(C + (D / (E + F))))

Parte 1
16
MOVE Básico
A instrução MOVE copia o valor de uma constante ou o conteúdo de uma
variável para uma ou mais variáveis. IMPORTANTE: A instrução não MOVE dados,
mas sim faz uma CÓPIA.
Alinhamento alfabético ou alfanumérico
Os dados são acomodados na variável receptora alinhado-se da esquerda para
a direita. Se a variável emissora for maior que a receptora, os caracteres mais a direita,
em excesso, serão truncados na variável receptora. Se a emissora for menor que a
receptora os caracteres faltantes para preencher o campo receptor serão preenchidos
com SPACES. Exemplo:
----+-*A-1-B--+----2----+----3----+----4----+----5----+----6----+----7--|-+----8
MOVE “GRACE HOPPER” TO WS-NOME
Alinhamento Numérico
Os dados são acomodados na variável receptora alinhando-se da direita para a
esquerda. Se a variável emissora for maior que a receptora os dígitos mais a esquerda
da variável emissora serão truncados. Quando a variável receptora for maior que a
emissora ou o valor numérico menor que o tamanho da variável, ocorre preenchimento
com zeros à esquerda. Exemplo:
----+-*A-1-B--+----2----+----3----+----4----+----5----+----6----+----7--|-+----8
MOVE 7010,50 TO WS-VALOR
Quando há vírgula na variável emissora e receptora, separando a parte inteira
da decimal, as vírgulas são alinhadas e depois o move é realizado. O que não couber
na parte inteira (à esquerda) ou decimal (à direita) é truncado.
Exemplos de MOVE:
----+-*A-1-B--+----2----+----3----+----4----+----5----+----6----+----7--|-+----8
MOVE 0 TO WS-CTLIDO
WS-CTGRAVA
WS-CTDESP
MOVE 3.14159 TO WS-PI
MOVE ZEROS TO WS-ACUMULADOR
MOVE SPACES TO WS-MENSAGEM
MOVE ALL “-” TO WS-LINHA
MOVE “N” TO WS-FIM
MOVE HIGH-VALUES TO WS-CODCLI
MOVE LOW-VALUES TO WS-CHAVE
G R A C E H O P P E R
WS-NOME
0 0 0 0 0 0 7 0 1 0 5 0
WS-VALOR

Parte 1
17
1
As constantes figurativas SPACES, HIGH-VALUES e LOW-VALUES só podem
ser movidas para variáveis alfanuméricas. A opção ALL move uma constante repetida
vezes até preencher a variável receptora.
A constante figurativa ZERO, ZEROS ou ZEROES, pode ser movida para
variáveis numéricas e alfanuméricas.
A tabela abaixo mostra quais tipos de variáveis podem ter seu conteúdo
movido para outros tipos de variáveis.
LOW-VALUES e HIGH-VALUES
são respectivamente o menor e o maior
valor que se pode armazenar em uma
variável. Na tabela EBCDIC, que é a
tabela de caracteres aceitos pelo
mainframe correspondem ao primeiro e
último valor respectivamente, como mostra
a tabela ao lado:
LOW-VALUES
....
HIGH-VALUES

Parte 1
18
Abaixo temos um trecho de programa COBOL mostrando os diversos tipos de
variáveis, alguns MOVEs e o DISPLAY dos valores.
*----------------------------------------------------------------*
WORKING-STORAGE SECTION.
*----------------------------------------------------------------*
* VE – VARIAVEL EMISSORA
77 VE-ALFANUMERICO PIC X(10).
77 VE-NUMERICO-INTEIRO PIC 9(10).
77 VE-NUMERICO-NAO-INTEIRO PIC 9(08)V99.
77 VE-NUMERICO-EDITADO PIC $ZZ.ZZZ.ZZ9,99+.
77 VE-ALFANUMERICO-EDITADO PIC XXBXXBXXBXXBXX.
77 VE-ALFABETICO PIC A(10).
* VR – VARIAVEL RECEPTORA
77 VR-ALFANUMERICO PIC X(10).
77 VR-NUMERICO-INTEIRO PIC 9(10).
77 VR-NUMERICO-NAO-INTEIRO PIC 9(08)V99.
77 VR-NUMERICO-EDITADO PIC $ZZ.ZZZ.ZZ9,99+.
77 VR-ALFANUMERICO-EDITADO PIC XXBXXBXXBXXBXX.
77 VR-ALFABETICO PIC A(10).
*----------------------------------------------------------------*
PROCEDURE DIVISION.
*----------------------------------------------------------------*
MOVE '1A2B3C4D5E' TO VE-ALFANUMERICO
MOVE 123 TO VE-NUMERICO-INTEIRO
MOVE 123,45 TO VE-NUMERICO-NAO-INTEIRO
MOVE 678,90 TO VE-NUMERICO-EDITADO
MOVE '1A2B3C4D5E' TO VE-ALFANUMERICO-EDITADO
MOVE 'QWERTYUIOP' TO VE-ALFABETICO
DISPLAY '*----------------------------------------------*'
DISPLAY 'CONTEUDO VARIAVEL EMISSORA'
DISPLAY '*----------------------------------------------*'
DISPLAY 'VE-ALFANUMERICO ' VE-ALFANUMERICO
DISPLAY 'VE-NUMERICO-INTEIRO ' VE-NUMERICO-INTEIRO
DISPLAY 'VE-NUMERICO-NAO-INTEIRO ' VE-NUMERICO-NAO-INTEIRO
DISPLAY 'VE-NUMERICO-EDITADO ' VE-NUMERICO-EDITADO
DISPLAY 'VE-ALFANUMERICO-EDITADO ' VE-ALFANUMERICO-EDITADO
DISPLAY 'VE-ALFABETICO ' VE-ALFABETICO
*----------------------------------------------------------------*
O comando DISPLAY exibe na SYSOUT as seguintes informações:
*----------------------------------------------*
CONTEUDO VARIAVEL EMISSORA
*----------------------------------------------*
VE-ALFANUMERICO 1A2B3C4D5E
VE-NUMERICO-INTEIRO 0000000123
VE-NUMERICO-NAO-INTEIRO 0000012345
VE-NUMERICO-EDITADO $ 678,90+
VE-ALFANUMERICO-EDITADO 1A 2B 3C 4D 5E
VE-ALFABETICO QWERTYUIOP

Parte 1
19
1
Foram feitos vários MOVEs de variáveis de um tipo para todos os outros tipo,
as que dão erros na compilação estão escritos em vermelho, já as que produzem
valores errados estão em azul.
*----------------------------------------------------------------*
MOVE VE-ALFANUMERICO TO VR-ALFANUMERICO
MOVE VE-ALFANUMERICO TO VR-NUMERICO-INTEIRO
MOVE VE-ALFANUMERICO TO VR-NUMERICO-NAO-INTEIRO
MOVE VE-ALFANUMERICO TO VR-NUMERICO-EDITADO
MOVE VE-ALFANUMERICO TO VR-ALFANUMERICO-EDITADO
MOVE VE-ALFANUMERICO TO VR-ALFABETICO
*----------------------------------------------------------------*
MOVE VE-NUMERICO-INTEIRO TO VR-ALFANUMERICO
MOVE VE-NUMERICO-INTEIRO TO VR-NUMERICO-INTEIRO
MOVE VE-NUMERICO-INTEIRO TO VR-NUMERICO-NAO-INTEIRO
MOVE VE-NUMERICO-INTEIRO TO VR-NUMERICO-EDITADO
MOVE VE-NUMERICO-INTEIRO TO VR-ALFANUMERICO-EDITADO
MOVE VE-NUMERICO-INTEIRO TO VR-ALFABETICO
*----------------------------------------------------------------*
MOVE VE-NUMERICO-NAO-INTEIRO TO VR-ALFANUMERICO
MOVE VE-NUMERICO-NAO-INTEIRO TO VR-NUMERICO-INTEIRO
MOVE VE-NUMERICO-NAO-INTEIRO TO VR-NUMERICO-NAO-INTEIRO
MOVE VE-NUMERICO-NAO-INTEIRO TO VR-NUMERICO-EDITADO
MOVE VE-NUMERICO-NAO-INTEIRO TO VR-ALFANUMERICO-EDITADO
MOVE VE-NUMERICO-NAO-INTEIRO TO VR-ALFABETICO
*----------------------------------------------------------------*
MOVE VE-NUMERICO-EDITADO TO VR-ALFANUMERICO
MOVE VE-NUMERICO-EDITADO TO VR-NUMERICO-INTEIRO
MOVE VE-NUMERICO-EDITADO TO VR-NUMERICO-NAO-INTEIRO
MOVE VE-NUMERICO-EDITADO TO VR-NUMERICO-EDITADO
MOVE VE-NUMERICO-EDITADO TO VR-ALFANUMERICO-EDITADO
MOVE VE-NUMERICO-EDITADO TO VR-ALFABETICO
*----------------------------------------------------------------*
MOVE VE-ALFANUMERICO-EDITADO TO VR-ALFANUMERICO
MOVE VE-ALFANUMERICO-EDITADO TO VR-NUMERICO-INTEIRO
MOVE VE-ALFANUMERICO-EDITADO TO VR-NUMERICO-NAO-INTEIRO
MOVE VE-ALFANUMERICO-EDITADO TO VR-NUMERICO-EDITADO
MOVE VE-ALFANUMERICO-EDITADO TO VR-ALFANUMERICO-EDITADO
MOVE VE-ALFANUMERICO-EDITADO TO VR-ALFABETICO
*----------------------------------------------------------------*
MOVE VE-ALFABETICO TO VR-ALFANUMERICO
MOVE VE-ALFABETICO TO VR-NUMERICO-INTEIRO
MOVE VE-ALFABETICO TO VR-NUMERICO-NAO-INTEIRO
MOVE VE-ALFABETICO TO VR-NUMERICO-EDITADO
MOVE VE-ALFABETICO TO VR-ALFANUMERICO-EDITADO
MOVE VE-ALFABETICO TO VR-ALFABETICO
*----------------------------------------------------------------*
Os MOVES que produzem resultados errados, geram os seguintes conteúdos:
*----------------------------------------------*
RESULTADO DO MOVE DE ALFANUMERICO PARA OUTRAS
*----------------------------------------------*
VR-ALFANUMERICO 1A2B3C4D5E
VR-NUMERICO-INTEIRO 1A2B3C4D55
VR-NUMERICO-NAO-INTEIRO 2B3C4D5500
VR-NUMERICO-EDITADO $22.334.455,00+
VR-ALFANUMERICO-EDITADO 1A 2B 3C 4D 5E
VR-ALFABETICO 1A2B3C4D5E
Mother of God!

Parte 1
20
Na compilação, as mensagens de erros para os MOVEs inválidos são:
"VE-NUMERICO-INTEIRO (NUMERIC INTEGER)" and "VR-ALFABETICO (ALPHABETIC)" did not follow
the "MOVE" statement compatibility rules. The statement was discarded.
"VE-NUMERICO-NAO-INTEIRO (NUMERIC NON-INTEGER)" and "VR-ALFANUMERICO (ALPHANUMERIC)" did
not follow the "MOVE" statement compatibility rules. The statement was discarded.
"VE-NUMERICO-NAO-INTEIRO (NUMERIC NON-INTEGER)" and "VR-ALFANUMERICO-EDITADO
(ALPHANUMERIC-EDITED)" did not follow the "MOVE" statement compatibility rules. The
statement was discarded.
"VE-NUMERICO-NAO-INTEIRO (NUMERIC NON-INTEGER)" and "VR-ALFABETICO (ALPHABETIC)" did not
follow the "MOVE" statement compatibility rules. The statement was discarded.
"VE-NUMERICO-EDITADO (NUMERIC-EDITED)" and "VR-ALFABETICO (ALPHABETIC)" did not follow
"VE-ALFANUMERICO-EDITADO (ALPHANUMERIC-EDITED)" and "VR-NUMERICO-INTEIRO (NUMERIC
INTEGER)" did not follow the "MOVE" statement compatibility rules. The statement was
discarded.
"VE-ALFANUMERICO-EDITADO (ALPHANUMERIC-EDITED)" and "VR-NUMERICO-NAO-INTEIRO (NUMERIC
NON-INTEGER)" did not follow the "MOVE" statement compatibility rules. The statement
was discarded.
"VE-ALFANUMERICO-EDITADO (ALPHANUMERIC-EDITED)" and "VR-NUMERICO-EDITADO (NUMERIC-
EDITED)" did not follow the "MOVE" statement compatibility rules. The statement was
discarded.
"VE-ALFABETICO (ALPHABETIC)" and "VR-NUMERICO-INTEIRO (NUMERIC INTEGER)" did not follow
"VE-ALFABETICO (ALPHABETIC)" and "VR-NUMERICO-NAO-INTEIRO (NUMERIC NON-INTEGER)" did not
follow the "MOVE" statement compatibility rules. The statement was discarded.
"VE-ALFABETICO (ALPHABETIC)" and "VR-NUMERICO-EDITADO (NUMERIC-EDITED)" did not follow

Parte 1
21
1
IF ELSE END-IF
Permite o desvio condicional do fluxo de processamento. Operadores
relacionais e lógicos são usados para montar uma condição, que pode ser verdadeira
ou falsa, de acordo com os valores das variáveis desta condição.
Abaixo do IF são executadas as instruções se a condição for verdadeira, após
o ELSE são executadas as instruções se a condição for falsa. Um IF pode ou não ter
ELSE. O THEN é opcional e raramente usado. Não será usado neste treinamento.
Exemplo:
----+-*A-1-B--+----2----+----3----+----4----+----5----+----6----+----7--|-+----8
XXXXXXXXXXXIF WS-QTDEST < WS-QTDMIN THEN
XXXXXX*-------INSTRUCOES SE CONDICAO FOR VERDADEIRA
XXXXXXXXXXX COMPUTE WS-QTDREP = WS-QTDMAX – WS-QTDMIN
XXXXXXXXXXX DISPLAY “QUANTIDADE PARA REPOR NO ESTOQUE = “ WS-QTDREP
XXXXXXXXXXXELSE
XXXXXX*-------INSTRUCOES SE CONDICAO FOR FALSA
XXXXXXXXXXX MOVE 0 TO WS-QTDREP
XXXXXXXXXXX DISPLAY “NAO HA NADA PARA REPOR NO ESTOQUE”
XXXXXXXXXXXEND-IF
CONDIÇÃO – As condições podem sem simples (apenas operador relacional)
ou complexas (expressões aritméticas, relacionais e lógicas). As tabelas abaixo
mostram os operadores relacionais, operadores lógicos e os testes de categoria.
OPERADORES RELACIONAIS
Símbolo Palavra em
COBOL
Significado
= EQUAL igual
NOT = NOT EQUAL diferente
< LESS Menor
>= NOT LESS maior ou igual
NOT < NOT LESS maior ou igual
> GREATER maior
<= NOT GREATER menor ou igual
NOT > NOT GREATER menor ou igual
OPERADORES LÓGICOS
Operador Significado Prioridade
( ) parênteses 0
NOT NÃO 1
AND E 2
OR OU 3
OPERADORES DE CATEGORIAS
Teste de
Sinal
IS POSITIVE
IS NEGATIVE
IS ZERO
Teste de
Classe
IS NUMERIC
IS ALPHABETIC

Parte 1
22
Exemplos:
----+-*A-1-B--+----2----+----3----+----4----+----5----+----6----+----7--|-+----8
XXXXXX*--------------------IF SEM ELSE---------------------*
XXXXXXXXXXXIF WS-SALARIO < 400
XXXXXXXXXXX COMPUTE WS-SALARIO = WS-SALARIO + 200
XXXXXXXXXXX PERFORM 050-IMPRIME-DEMONSTRATIVO
XXXXXXXXXXXEND-IF
XXXXXX*--------------------IF COM ELSE---------------------*
XXXXXXXXXXXIF WS-MEDIA NOT < 7
XXXXXXXXXXX DISPLAY “ALUNO APROVADO COM MEDIA = ” WS-MEDIA
XXXXXXXXXXXELSE
XXXXXXXXXXX DISPLAY “ALUNO REPROVADO COM MEDIA = ” WS-MEDIA
XXXXXXXXXXXEND-IF
XXXXXX*--------------------IF ENCADEADO--------------------*
XXXXXXX IF A > B
XXXXXXXXXXX IF A > C
XXXXXXXXXXX IF B > C
XXXXXXXXXXXXXXXXX DISPLAY C “ – ” B “ – ” A
XXXXXXXXXXX ELSE
XXXXXXXXXXXXXXXXX DISPLAY B “ – ” C “ – ” A
XXXXXXXXXXX END-IF
XXXXXXXXXXX ELSE
XXXXXXXXXXXXXX DISPLAY B “ – ” A “ – ” C
XXXXXXXXXXX END-IF
XXXXXXXXXXXELSE
XXXXXXXXXXX IF A > C
XXXXXXXXXXXXXX DISPLAY C “ – ” A “ – ” B
XXXXXXXXXXX ELSE
XXXXXXXXXXX IF B > C
XXXXXXXXXXXXXXXXX DISPLAY A “ – ” C “ – ” B
XXXXXXXXXXX ELSE
XXXXXXXXXXXXXXXXX DISPLAY A “ – ” B “ – ” C
XXXXXXXXXXX END-IF
XXXXXXXXXXX END-IF
XXXXXXXXXXXEND-IF
XXXXXX*---------------------IF COMPLEXO--------------------*
XXXXXXXXXXXIF R4 = 0 AND R100 NOT = 0 OR R400 = 0 AND R3600 NOT = 0
XXXXXXXXXXX DISPLAY “EH BISSEXTO”
XXXXXXXXXXXELSE
XXXXXXXXXXX DISPLAY “NAO EH BISSEXTO”
XXXXXXXXXXXEND-IF
XXXXXX*------------------IF DE CATEGORIAS------------------*
XXXXXXXXXXXIF WS-SALARIO IS NUMERIC AND
XXXXXXXXXXXXXXWS-NOME IS ALPHABETIC AND
XXXXXXXXXXXXXXWS-TAXA IS POSITIVE
XXXXXXXXXXX PERFORM 150-CALCULA-VALOR
XXXXXXXXXXXELSE
XXXXXXXXXXX DISPLAY “REGISTRO INVALIDO”
XXXXXXXXXXXEND-IF
XXXXXX*-----------IF DE TESTE DE MULTIPLO VALORES----------*
XXXXXXXXXXXIF WS-OPCAO = 1 OR 2 OR 3 OR 4 OR 5
XXXXXXXXXXX DISPLAY “BOA OPCAO”
XXXXXXXXXXXEND-IF
XXXXXXXXXXXIF WS-VALOR = 2 OR > 3 OR NOT < 4
XXXXXXXXXXX DISPLAY “VALOR IDEAL”
XXXXXXXXXXXEND-IF
XXXXXXXXXXXIF WS-OPCAO = 8 OR 9 AND WS-VALOR = 7 OR 9
XXXXXXXXXXX DISPLAY “OTIMA COMBINACAO”
XXXXXXXXXXXEND-IF
XXXXXX*-----------IF DE EXPRESSAO ARITMETICA---------------*
XXXXXXXXXXXIF WS-SALARIO + WS-BONUS > 5000
XXXXXXXXXXX DISPLAY “OTIMO SALARIO, JA PODE CASAR.”
XXXXXXXXXXXEND-IF

Parte 1
23
1
PERFORM Básico
Executa apenas 1 vez o bloco de instruções de um parágrafo ou SECTION.
Exemplos:
----+-*A-1-B--+----2----+----3----+----4----+----5----+----6----+----7--|-+----8
PERFORM 070-TERMINO
PERFORM com a opção UNTIL
Executa o bloco de instruções de um parágrafo ou SECTION até que uma
determinada situação ocorra.
Se nada for informado, é feito o teste da condição ANTES de executar o
parágrafo ou SECTION, mas é possível especificar se o teste deve ser feito antes ou
depois com a opção WITH TEST BEFORE ou WITH TEST AFTER, respectivamente.
Exemplos:
----+-*A-1-B--+----2----+----3----+----4----+----5----+----6----+----7--|-+----8
*
* POR DEFAULT, SERA VERIFICADO A CONDICAO PRIMEIRO E SE
* FOR VERDADEIRA, A ROTINA SERA EXECUTADA
*
PERFORM 030-PROCESSAR
UNTIL FS-VCADPRD = ‘10’
*
* COM A OPCAO WITH TEST BEFORE (DEFAULT)
* O PERFORM FUNCIONA COMO O LACO DE REPETICAO
* WHILE (ENQUANTO)
*
PERFORM 055-IMPRIME-TABUADA
WITH TEST BEFORE
UNTIL WS-CONTADOR > 10
*
* COM A OPCAO WITH TEST AFTER (NAO DEFAULT)
* O PERFORM FUNCIONA COMO O LACO DE REPETICAO
* DO/WHILE (FACA/ENQUANTO), EXECUTANDO A ROTINA
* PRIMEIRO E DEPOIS VERIFICANDO SE PODE EXECUTAR NOVAMENTE
*
PERFORM 080-CALCULA-JUROS
WITH TEST AFTER
UNTIL WS-MES > 12

Parte 1
24
É a visão geral do algoritmo em relação aos arquivos de entrada e de saída. Os
símbolos utilizados em macro-fluxo e seu significado são mostrados abaixo:
Símbolo Significado
ou Arquivo sequencial em fita magnética
Arquivo sequencial em disco
Arquivo indexado em disco
Tabela de um banco de dados relacional
Relatório (Arquivo para impressão)
Programa
SYSIN (System Input – Entrada via JCL)
SYSOUT (System Output – Saída via
SPOOL)
Teoria MACRO-FLUXO

Parte 1
25
1
No Macro-Fluxo os arquivos de entrada (INPUT) ficam acima do programa, e
os de saída (OUTPUT) ficam abaixo. Um macro-fluxo dá uma primeira idéia do esforço
necessário para desenvolver o algoritmo. Quanto maior a quantidade de arquivos que
o programa deve manipular, maior deve ser sua complexidade.
Um programa complexo não significa um programa difícil. O termo
complexidade aqui se refere a quantidade de instruções que o programa deverá
executar para atingir seu objetivo.
Abaixo temos um exemplo de macro-fluxo onde o arquivo de vendas é lido e é
gravado um relatório de comissões a pagar através do programa GeraComi.
Arquivo de entrada
(leitura) INPUT
Arquivo de saída
(gravação) OUPUT
vendas
GeraComi
Comissao

Parte 1
26
Responda as questões abaixo, depois peça para
que seu colega as corrija.
1) Dadas as sentenças abaixo, coloque V ou F entre os parênteses, caso a mesma
seja verdadeira ou falsa.
A. ( ) – O COBOL foi criado em 1959 pelo CODASYL, mas a primeira versão só saiu
em 1960 com o nome COBOL 60.
B. ( ) – Grace Hopper criou a linguagem FLOW-MATIC, que junto com a linguagem
CONTRAM de Bob Bemer, foram as principais linguagens que influenciaram o
COBOL.
C. ( ) – O COBOL é uma linguagem de baixo nível (próxima a linguagem de
máquina), parecida com o Assembly, de difícil aprendizagem e altamente
complexa.
D. ( ) – COBOL é um acrônimo para Completely Over and Beyond Obvius Logic.
E. ( ) – No processamento BATCH, uma coleção de registros é processada, sem a
intervenção do usuário, até que todos os registros terminem ou um erro de
processamento ocorra.
F. ( ) – São exemplos de processamento Batch: Pagar uma conta de luz no caixa
eletrônico, consultar o saldo de uma conta corrente via internet, entrevistar um
candidato a uma vaga de emprego e escrever um e-mail solicitando a 2ª via de
um boleto.
Practice
Atividade Revisão aos pares

Parte 1
27
1
2) Coloque entre parênteses qual parte do processamento BATCH essas tarefas são
executadas:
a) rotina-inicializar b) rotina-processar c) rotina-termino
( ) – Processamento dos campos numéricos pelos operadores aritméticos
(+, -, *, / ou **)
( ) – Abertura dos arquivos de entrada e saída
( ) – Fechamento dos arquivos de entrada e saída
( ) – Exibição de mensagem avisando do término normal de processamento
( ) – Inicialização das variáveis (Contadores e Acumuladores)
( ) – Leitura do primeiro registro do arquivo de entrada
( ) – Leitura do próximo registro do arquivo de entrada
3) Coloque V ou F se as ações abaixo caracterizam (verdadeiro) ou não (falso) um
processamento batch
( ) – O professor corrigindo as avaliações de uma turma
( ) – Um contador registrando no livro fiscal as notas fiscais emitidas por uma
empresa no mês passado
( ) – Pagar uma conta de telefone no caixa eletrônico de um banco
( ) – Dar baixa no estoque de uma geladeira vendida na loja
( ) – Separar do cadastro de clientes aqueles que não compram a mais de 30 dias

Parte 1
28
4) Marque com um X os comandos COBOL com erro de sintaxe ou de lógica,
sublinhando a parte errada.
a. ( ) ACCEPT WS-HORASTRAB FROM SYSOUT
b. ( ) DISPLAY “PROCESSADO COM SUCESSO”
c. ( ) DISPLAY “LIDOS = ” WS-CTLIDO
d. ( ) DISPLAY ((2 * WS-LADO ** 2) ** 0,5)
e. ( ) COMPUTE WS-DIAGONAL = ((2 * WS-LADO ** 2) ** 0,5)
f. ( ) COMPUTE WS-SALARIO=WS-HORASTRAB*WS-SALARIOHORA
g. ( ) MOVE 25 TO WS-SALARIO-A WS-SALARIO-B WS-SALARIO-C
h. ( ) MOVE WS-SALARIO TO 25
i. ( ) MOVE WS-LADO1 WS-LADO2 WS-LADO3 TO WS-TRIANGULO
j. ( ) IF WS-QTDEST NOT < 1000
k. ( ) IF WS-SALDO IS NUMERIC AND ALPHABETIC
l. ( ) IF WS-SALDO IS POSITIVE OR NEGATIVE
m. ( ) IF WS-TIPOCONTA = “CC” OR “CP” OR “CI”
n. ( ) PERFORM 010-INICIALIZAR 020-PROCESSAR 030-TERMINO
o. ( ) PERFORM 055-CALCULO UNTIL WS-SENTINELA = 0
p. ( ) PERFORM WITHOUT TEST 040-EXIBE-RESULTADO

Parte 1
29
1
Em grupo de até 3 alunos, faça os Macro-fluxos solicitados,
compare com os de seus colegas e anote os corretos.
a) O programa PGMFOPAG processa a folha de pagamento de uma empresa.
Ele lerá o arquivo HORARIO (sequencial em disco) e a tabela TABFUNC
(tabela de um banco de dados) e gravará o arquivo FOLHAPAG (sequencial
em fita magnética) e imprimirá o relatório CHEQUES.
b) O programa ATUESTOK atualiza o estoque de uma empresa com base na
movimentação. Lerá o arquivo CADANT (sequencial em disco) e o arquivo
MOVESTOK (sequencial em fita magnética) e gravará o arquivo CADATU
(sequencial em disco) e imprimirá o relatório RELOCORR.
Atividade Flip chart

Parte 1
30
Converta a especificação do programa abaixo para
a PROCEDURE DIVISION do COBOL.
Parágrafo 0000-EEXXNN02
Executar o parágrafo 1000-INICIALIZAR
Executar o parágrafo 2000-PROCESSAR
até que a variável WS-FIM seja igual a “S”
Executar o parágrafo 3000-termino
Parar o programa
Parágrafo 1000-inicializar
Mover zero para as variáveis WS-CONT, WS-CTLIDO
Mover “N” para a variável WS-FIM
Executar o parágrafo 1500-LER-SYSIN
Parágrafo 1500-LER-SYSIN
Receber dado da SYSIN e armazenar na variável WS-TAB
Se a variável WS-TAB for igual a zero
Mover “S” para a variável WS-FIM
Senão
Incrementar de um a variável WS-CTLIDO
Fim-se
Parágrafo 2000-PROCESSAR
Executar o parágrafo 2500-IMPRIME-TABUADA
até que a variável WS-CONT seja igual a dez
Mover zero para a variável WS-CONT
Parágrafo 2500-IMPRIME-TABUADA
Incrementar de um a variável WS-CONT
Multiplicar as variáveis WS-CONT e WS-TAB dando WS-PROD
Exibir WS-TAB “ X “ WS-CONT “ = “ WS-PROD
Parágrafo 3000-TERMINO
Exibir “Quantidade de números lidos = ” WS-CTLIDO
Exibir “TERMINO NORMAL DO EEXXNN02”
Trabalheem duplas TEXTO  COBOL

Parte 1
31
1
0000-EEXXNN02.
PERFORM 2000-PROCESSAR UNTIL WS-FIM = "S"
STOP RUN
.
1000-INICIALIZAR.
.
1500-LER-SYSIN.
.
2000-PROCESSAR.
.
2500-IMPRIME-TABUADA.
.
3000-TERMINO.
.

Parte 1
32
Converta o programa COBOL abaixo para texto.
0000-EEXXNN03.
PERFORM 2000-PROCESSAR UNTIL WS-FIM = "S"
STOP RUN
.
1000-INICIALIZAR.
MOVE "N" TO WS-FIM
MOVE 0 TO WS-CTLIDO
.
1500-LER-SYSIN.
ACCEPT WS-NUM FROM SYSIN
IF WS-NUM = 0
MOVE "S" TO WS-FIM
ELSE
COMPUTE WS-CTLIDO = WS-CTLIDO + 1
END-IF
.
2000-PROCESSAR.
MOVE 1 TO WS-CONT
MOVE 0 TO WS-SOMA
PERFORM 2500-CALCULA UNTIL WS-CONT > WS-NUM
DISPLAY “A SOMA DOS NATURAIS ATE “ WS-NUM " = " WS-SOMA
.
2500-CALCULA.
COMPUTE WS-SOMA = WS-SOMA + WS-CONT
COMPUTE WS-CONT = WS-CONT + 1
.
3000-TERMINO.
DISPLAY "TOTAL DE NUMEROS LIDOS = " WS-CTLIDO
DISPLAY "TERMINO NORMAL DO EEXXNN03"
.
Trabalheem duplas COBOL  TEXTO

Parte 1
33
1
Parágrafo 0000-EEXXNN03.
Executar o parágrafo 1000-inicializar
Executar o parágrafo 2000-processar até que WS-FIM seja “S”
Executar o parágrafo 3000-termino
Parar o programa
Parágrafo 1000-INICIALIZAR.
Parágrafo 1500-LER-SYSIN.
Parágrafo 2000-PROCESSAR.
Parágrafo 2500-calcula.
Parágrafo 3000-TERMINO.

Parte 1
34
Objetivo do Programa
O Departamento Financeiro do Banco DOPOLVO S.A. precisa de um programa
para simular empréstimos aos seus clientes.
Os dados dos diversos empréstimos serão fornecidos via SYSIN e lidos pelo
programa GPXXNN01, que deverá calcular o valor da parcela de cada empréstimo a
partir da fórmula abaixo, onde vp é o valor da parcela, ve é o valor do empréstimo, j é
o juros e n é a quantidade de parcelas.
𝑣𝑝 =
𝑣𝑒 ×
𝑗
100
1 −
1
(1 +
𝑗
100
)
𝑛
𝑣𝑝 = (𝑣𝑒 ∗ 𝑗 / 100) / (1 − 1 / (1 + 𝑗 / 100) ∗∗ 𝑛 )
Macro-Fluxo
Performance
TodosJuntos PROJETO 1
SYSIN
SYSOUT
GPXXNN01

Parte 1
35
1
Layout da SYSIN
Nome do Registro WS-REG-SYSIN
Nome da Variável
Tipo e
Tamanho
do Dado
Descrição do Dado
WS-NUM-SIMULACAO 9(04) Número da Simulação
WS-VAL-EMPRESTIMO 9(06)V99 Valor do Empréstimo
WS-JUROS 9(02)V99 Percentual de Juros Compostos ao Mês
WS-QTD-PARCELAS 9(02) Quantidade de Parcelas
Layout da SYSOUT
O resultado do processamento será exibido na SYSOUT pela instrução
DISPLAY. Para cada simulação de empréstimo exibir os seguintes dados:
11234567892123456789312345678941234567895
12345678901234567890123456789012345678901234567890
**************************************************
NUMERO DA SIMULACAO.....: 9999
VALOR DO EMPRESTIMO.....: 99999999
JUROS...................: 9999
QTDE. DE PARCELAS.......: 99
VALOR DA PARCELA ........: 99999999
VALOR TOTAL.............: 9999999999
**************************************************
No final do processamento, exibir o seguinte resumo:
11234567892123456789312345678941234567895
12345678901234567890123456789012345678901234567890
**************************************************
TOTAL DE SIMULACOES LIDAS........: 9999
TOTAL DE SIMULACOES PROCESSADAS..: 9999
**************************************************
Bem como a frase:
11234567892123456789312345678941234567895
12345678901234567890123456789012345678901234567890
**************************************************
* TERMINO NORMAL DE PROCESSAMENTO DO GPXXNN01 *
**************************************************

Parte 1
36
Observação
O parágrafo principal chama os parágrafos inicializar, processar e término,
formando a seguinte hierarquia de parágrafos:
JOB de Execução
O dados para realização da simulação do empréstimo podem ser vistas na
SYSIN. Observe a última simulação com tudo zero (sentinela), que indicará ao
programa que não há mais simulações para processar:
11234567892123456789312345678941234567895123456789612345678971234567898
12345678901234567890123456789012345678901234567890123456789012345678901234567890
//GPXXNN01 JOB 'SEUNOME',MSGCLASS=X,CLASS=C,NOTIFY=GPXXNN,TIME=(0,20)
//*******************************************************************
//STEP1 EXEC PGM=GPXXNN01
//STEPLIB DD DSN=GP.GERAL.LOADLIB,DISP=SHR
//SYSIN DD *
000100100000100010
000200400000080015
000308000000150050
000410000000040060
000000000000000000
//*
0000-PRINCIPAL
1000-INICIALIZAR 2000-PROCESSAR 3000-TERMINO
1500-LER-SYSIN 1500-LER-SYSIN
ACCEPT
0 0 0 1 0 0 1 0 0 0 0 0 1 0 0 0 1 0
WS-REG-SYSIN

Parte 1
37
1Orientação para processamento
Parágrafo Principal (0000-GPXXNN01)
Executa o parágrafo 1000-INICIALIZAR
Executa o parágrafo 2000-PROCESSAR
até que o registro lido na SYSIN seja o sentinela
Executar o parágrafo 3000-TERMINO
Encerrar o programa
Parágrafo 1000-INICIALIZAR
Mover zero para os contadores
contador de simulações lidas
contador de simulações processadas
Parágrafo 1500-LER-SYSIN
Ler um registro na SYSIN (ACCEPT)
Se o registro não for tudo zero
Somar 1 ao contador de Simulações lidas
Parágrafo 2000-PROCESSAR
Calcular o valor da parcela do empréstimo
Calcular o valor da soma das parcelas
Exibir os dados na SYSOUT
Somar 1 ao contador de simulações processadas
No parágrafo 3000-TERMINO fazer:
Exibir o resumo do processamento
Exibir frase de término normal
Com base nesta especificação de programa, escreva nas páginas seguintes a
PROCEDURE DIVISION do programa COBOL que atenda a necessidade do Banco
DOPOLVO S.A.

Parte 1
38

Parte 1
39
1

Parte 1
40
Avaliação Então...Como foi ?!?
Estou fera!
Fiz Certo!
Muito Bom Bom regular ruim Muito ruim    

Parte
O que é um Mainframe?
É um computador de Grande Porte. Nos anos
70 e 80 quando quase todos os computadores eram
grandes, o termo Mainframe era usado para se
referir a diferentes sistemas de computadores. Hoje
a maioria desses sistemas se foram, e o termo
Mainframe quase sempre se refere aos
computadores IBM zSeries. De agora em diante
quando falarmos sobre Mainframes, estaremos
falando da zSeries.
David Stephens
What on earth is a Mainframe?
IBM System Z10

Parte 2
3
2
Preparation

Parte 2
4
Vamos agora acessar o ambiente mainframe. Em geral, demora uma ou duas
semanas para que seja criado um usuário e senha para o estagiário acessar
mainframe, é um processo burocrático, onde o gerente do estagiário manda e-mail
para a área de segurança (Security Office), justificando a necessidade do acesso, etc,
etc. Mas aqui na XPTO seu acesso será imediato. Seu usuário e senha já estão
criados e você poderá acessar agora o ambiente.
Você poderá ter esse ambiente em sua casa. Todo estagiário da XPTO tem um
mainframe virtual chamado Hercules, que poderá inclusive ser instalado em seu
notebook ou netpc.
Pratique bastante, pois a XPTO aprecia muito o estagiário que tem
desenvoltura com a interface baseada em caractere do mainframe.
Presentation
História O acesso ao Mainframe

Parte 2
5
2
O TSO (Time Sharing Option) é um ambiente interativo que compartilha o
tempo do Mainframe com seus usuários, mas o usuário tem a impressão que é o único
a utilizar o Mainframe.
Uma vez conectado (login) ao TSO, o usuário pode excluir, visualizar,
submeter e acompanhar Jobs (serviços), alocar, renomear, mover, copiar e excluir
arquivos, e também utilizar outros aplicativos do sistema operacional que rodam sob o
TSO como, por exemplo, RACF, HCD, SDSF, Control/M, Endevor etc. O TSO controla
todos estes aplicativos.
O nome Time Sharing Option deriva do fato que quando surgiu nos anos de
1960, “tempo compartilhado” (time-sharing) era considerada uma característica
opcional, comparado com o padrão de processamento em lotes (Batch) da época.
Então o TSO era oferecido como uma característica opcional do Sistema Operacional
OS/MVT. Ele se tornou padrão como parte do Sistema Operacional MVS em 1974.
TSO/E (E=extentions) é uma série de extensões ao TSO original e é a mais usada
hoje em dia. Todos as versões atuais do Sistema Operacional, a família Z/OS, tem o
TSO e TSO/E instalados e é comum chamá-los apenas de TSO.
Teoria finalidade

Parte 2
6
O acesso ao TSO é feito por um Software de Telnet (tele network = rede à
distância). Usamos o Tn3270 plus, cujo ícone está no desktop.
Um duplo-clique neste ícone inicializa o programa, que tem este
aspecto:
No campo Session Name você pode colocar o seu nome, pois ele apenas
identifica a sessão do Telnet. No campo Host Name coloca-se o número IP do
servidor. No campo Telnet Port coloca-se o número da porta habilitada no servidor
para a conexão remota. No campo Terminal Time deixar 3279, que é o tipo de
terminal que estamos usando. Finalmente pressione o botão connect para se conectar
ao servidor.
Anote aqui o IP e a Porta para se conectar em nosso servidor:
Teoria Login e logoff
IP
PORT
SOCKET

Parte 2
7
2
Você obterá a seguinte tela:
Basta pressionar a tecla Esc para ter acesso ao menu de serviços do Sistema
Operacional. Digite então TSO e pressione ENTER para entrar na tela de Login do
TSO.
Informar o seu USERID (identificação do usuário) e pressione ENTER, então
informe sua senha e pressione ENTER novamente. Quando aparecer os 3 asteriscos,
você estará logado, pressione ENTER mais uma vez para ir ao menu principal do TSO.
Outra maneira de Logar no TSO é digitar o comando L seguido do seu usuário, indo
direto para a tela de digitação da senha, exemplo:
L GPAZ99
Anote aqui o seu USERID:
USERID

Parte 2
8
Para sair do TSO pressionar X (EXIT) no menu principal ou PF3.
Se o painel Specify Disposition of Log Data Set aparecer, escolher a opção 2
Delete data set without printing para excluir o arquivo de LOG sem imprimi-lo. O LOG
registra todas as ações que o usuário executou durante a sessão do TSO. Isso é bom
para a empresa investigar quem fez algo de errado. No nosso caso podemos excluir
sem imprimi-lo.

Parte 2
9
2
Quando aparecer READY, digitar LOGOFF e pressionar ENTER que a sessão
do TSO será encerrada.

Parte 2
10
Com seu usuário e senha em mãos, fazer o LOGIN
e o LOGOFF para se familiarizar com o procedimento.
Descubra como alterar sua senha (Password). Anote
o procedimento abaixo.
Atividade Prática de laboratório

Parte 2
11
2
O uso do TSO se dá através de Menus, Painéis ou Comandos. A Navegação
por menus é a mais usual. Um Menu é sempre composto de opções onde você deverá
escolher uma, e somente uma, opção. Um Menu pode levar a outro Menu ou a um
Painel. O Painel é o último estágio da navegação dentro do TSO. No painel você
deverá digitar os dados solicitados e pressionar ENTER, para que ação seja
executada.
Teoria
Navegação por
menus e painéis

Parte 2
12
A partir do Menu Principal, no campo OPTION ===> informamos as letras da
opção que desejamos acessar. As mais comuns, que usaremos em nosso curso são:
P – que leva ao menu ISPF/PDF – Interactive System Productivity Facility /
Program Development Facility. Que usaremos para manipular arquivos, editar
programas e submeter Jobs (serviços).
SD – que leva ao menu System Display and Search Facility – Que usaremos
para acompanhar a execução dos Jobs (serviços).
A navegação pelos menus e painéis é feita selecionando opções, preenchendo
campos e pressionando uma tecla de ação. A mais comum é a ENTER, que executa a
ação selecionada. Abaixo temos uma imagem do teclado de um terminal IBM 3270
que é emulado nos terminais PC (Personal Computer) e uma relação das teclas de
ação e seus efeitos.
Program Function (PF)
PF1 (Help) Exibe ajuda contextualizada
PF2 (Split) Divide a Janela do TSO no Cursor
PF3 Voltar ou sair salvando
PF5 Repete o último comando
PF7 Retrocede uma página
PF8 Avança uma página
PF9 Navega entre 2 janelas abertas com PF2
PF10 Desloca tela à esquerda
PF11 Desloca tela à direita
PF12 Cancela ação em curso ou sair sem salvar
Program Attention (PA)
PA1 Encerra um comando iniciado com
erro ou Esc pressionado por engano
no PC usar tecla Page Up
PA2 Desfaz o que foi digitado
No PC usar tecla Page Down
Outras Teclas
Tab Salta o cursor para o próximo campo
CLR Limpa a tela
no PC usar ESC ou Ctrl+C
Enter Executa a ação solicitada
Reset desbloqueia o teclado
no PC usar Ctrl esquerdo
Ctrl direitoCtrl esquerdo
PF7
PF8
PF10 PF11

Parte 2
13
2
A partir do Menu principal do TSO, digitamos P para ir ao menu PDF e depois 0
para ir ao painel ISPF Setting. Também podemos abreviar a navegação e digitarmos
as duas opções de uma única vez, separando-as por ponto (P.0) ou ponto-e-vírgula
(P;0).
No painel ISPF Setting vamos modificar a localização da linha de comando,
que por default (padrão) está localizado em baixo na tela, tirando a barra (/) do campo
Command line at bottom e pressionando ENTER. A linha de comando passa então
para cima. Vamos desmarcar também a Tab to action bar choices, pois ao
pressionarmos a tecla HOME, o cursor é posicionado na linha de comando e não na
primeira linha da tela.
Teoria
Modificando as
configurações

Parte 2
14

Parte 2
15
2
Modifique as configurações de sua sessão TSO/E,
conforme solicitadas abaixo. Anote o procedimento.
a) Posicionar a linha de comando na parte superior da tela.
(Command line at bottom).
b) Configure a tecla HOME para que, quando pressionada, posicionar o cursor na
linha de comando. (Tab to action bar choices).

Parte 2
16
No ambiente de Grande Porte (Mainframe) os arquivos são chamados de
DATA SET (Conjunto de Dados). O nome de um arquivo deve seguir as seguintes
regras:
a) O nome do arquivo consiste em uma ou mais partes, chamadas
qualificadores. Eles são conectados por pontos.
b) Cada qualificador deve iniciar com um caractere alfabético de A a Z ou
caracteres nacionais americanos @, # ou $.
c) O tamanho de cada qualificador não deve exceder 8 caracteres.
d) O tamanho máximo do nome de um arquivo é 44 caracteres, incluindo os
pontos conectores.
Exemplos:
CADCLI
BACKLOG.ACTIVIT
GP.GPAZ99.COBLIB
XPTO.RHSP.FERIAS.2010
A Organização de um Arquivo (DSorg = Data Set Organizartion) diz respeito a
forma como os dados são arranjados ou organizados dentro de um arquivo. As
organizações mais comuns são:
PS – Physical Sequential (Físico Sequencial)
É um arquivo que possui registros organizados
sequencialmente, um atrás do outro, podendo ser de
tamanho fixo ou variável. São os arquivos mais
comuns para o armazenamento de dados para
processamento em lote (Batch).
Qualificador_1 
Qualificador_2 
Qualificador_3 
Qualificador_n
de 1 a 8 caracteres
máximo de44 caracteres
Teoria
Alocação de
data set (arquivo)

Parte 2
17
2
PO – Partitioned Organization (Particionado) ou
PDS – Partitioned Data Set
Um particionado é um arquivo subdividido em
um pequeno e limitado número de arquivos virtuais
chamados membros. Para nossos propósitos, você
pode considerar um membro como um arquivo,
cujos registros possuem um tamanho fixo,
usualmente de 80 caracteres. Os particionados
também são chamados de bibliotecas (Library), pois
lembram uma estante cheia de livros, que no caso
são os membros.
Ambos os arquivos (PS ou PO/PDS) podem ser “blocados”. Um arquivo
blocado permite que o equipamento que o lê (unidade de disco ou fita), faça a leitura
de um grupo de registros de uma única vez (bloco de registros), armazenando-os em
um buffer de memória e disponibilizando para a aplicação um registro por vez. Isso
agiliza a leitura, pois o acesso aos dados em disco ou fita é mais lento por possuírem
componentes mecânicos. Entre os registros (arquivo não blocado) ou entre os blocos
de registros (arquivo blocado) há um espaço não gravado chamado IRG (Inter Record
Gap).
IRG
REGISTRO
REGISTRO
REGISTRO
REGISTRO
REGISTRO
IRG
REGISTRO
REGISTRO
REGISTRO
REGISTRO
REGISTRO
IRG
REGISTRO
REGISTRO
REGISTRO
REGISTRO
REGISTRO
IRG
REGISTRO
IRG
REGISTRO
IRG
REGISTRO
IRG
REGISTRO
IRG
REGISTRO
IRG
REGISTRO
IRG
REGISTRO
IRG
IRG
BUFFER
FIFO
PROGRAMA

Parte 2
18
O processo de criação de arquivos é chamado de Alocação. O modo mais fácil
de alocar um arquivo é consultando as características de um arquivo já existente,
assim essas características ficam gravadas na memória e são repassadas para o
arquivo que se deseja alocar. A partir do menu principal do TSO escolhemos:
P (Menu PDF), 3 (utilities) e 2 (data set), ou digitamos P.3.2.
No painel Data Set Utility deixamos o campo Option em branco e preenchemos
os campos Project, Group e Type com o nome do arquivo que desejamos consultar as
informações (características do arquivo).
Um arquivo particionado (PDS – Partitioned Data Set) possuem um nome de
arquivo com 3 níveis (qualificadores).

Parte 2
19
2
Vamos consultar as informações do arquivo GP.GPAZ99.COBLIB.
Quando pressionamos ENTER, as informações do arquivo aparecem no painel
Data Set Information.
Depois pressionamos PF3 para voltar ao painel Data Set Utility.
Aquelas informações ficaram armazenadas na memória e serão utilizadas na
alocação do próximo arquivo.
Para alocarmos um novo arquivo colocamos no campo Option a opção A
(Allocate new data set) e nos campos Project, Group e Type o nome do arquivo que
desejamos alocar, por exemplo, GP.GPNE19.BOOKLIB e pressionamos ENTER.
As informações consultadas anteriormente são automaticamente preenchidas
nos campos. Basta pressionar ENTER que o arquivo é alocado e a mensagem “data
set allocated” aparece no canto superior direito da tela.

Parte 2
20

Parte 2
21
2
Faça a alocação dos seguintes arquivos (DATA
SET), substituindo XXNN pela identificação de seu
usuário. Utilize como base os arquivos de seu instrutor.

Parte 2
22
A partir do menu principal, digitamos P.3.4, que nos levará ao painel Data Set
List Utility, que permitirá a visualização dos arquivos criados, bem como dos membros
dos arquivos particionados. No campo Dsname Level, que significa Data Set Name
Level, colocamos o nome do arquivo completo ou o começo do nome do arquivo.
Exemplo:
GP.GPAZ99
GP.GPAZ99.C*
GP.GPAZ*
GP.*.COBLIB
Quando paramos logo antes do ponto, que separa o nome do arquivo, não
usamos o asterisco, que neste caso faz o papel de coringa. No segundo exemplo
GP.GPAZ99.C*, desejo exibir todos os arquivos que comecem com GP.GPAZ99.C, o
coringa permite que qualquer outro caractere apareça após o último C.
No campo Initial View, temos a possibilidade de exibir as seguintes
informações dos arquivos:
1 – Volume em qual disco (storage) o arquivo se encontra
2 – Espaço quantas trilhas (56.664 bytes no modelo de disco 3390)
3 – Atributos dados armazenados no catálogo (VTOC – volume table
of contents) que aponta a localização física dos arquivos
4 – Total todas as informações juntas
Teoria
Visualização dos
arquivos alocados

Parte 2
23
2
Depois de informado o Dsname Level e o Initial View, pressione ENTER e os
arquivos serão exibidos, conforme tela a seguir.
INITIAL VIEW 1
INITIAL VIEW 2
INITIAL VIEW 3
INITIAL VIEW 4

Parte 2
24
Visualize os DATA SET que você alocou na
atividade anterior, alterando o valor do campo INITIAL
VIEW desde 1 até 4.
O que acontece, na visualização dos arquivos, quando pressionamos PF10 ou
PF11 repetidas vezes?

Parte 2
25
2
Após exibir os arquivos pelo painel Data Set List Utility, podemos executar
diversas operações, tais como renomear, excluir, editar, compactar, etc. Basta colocar
o cursor pelo menos a 1 caractere de distância do lado esquerdo do nome do arquivo
e digitar um dos comandos:
E (Edit) Editar arquivo / membros
V (View) Visualizar arquivo / membros, não permite alterações
B (Browse) Exibe arquivo / membros, não permite alterações
R (Rename) Renomear arquivo / membros
D (Delete) Excluir arquivo / membros
Z (Compress) Comprime arquivos particionados com 100% de uso
/ exibe menu com diversas ações. Digitar o número da ação desejada.
I (Information) Exibe informações sobre o Data Set
S (Information Short) Exibe informações reduzidas sobre o Data Set
Abaixo vamos editar os membros da GP.GPAZ99.JOBLIB.
Observe que ele está com 100% de uso. Isso ocorre porque sempre que se
editar membros será preciso salvar as alterações. O TSO salva o membro alterado em
outro lugar dentro do particionado, deixando o anterior indisponível. Isso faz com que o
arquivo particionado fique logo cheio, mesmo que tenha apenas um membro. Neste
caso é necessário comprimir (Z = Compress) o particionado, liberando os membros
não usados. O ABEND SE37 é o indício de que o arquivo está 100% usado e precisa
ser comprimido, ele acontece ao salvar um membro, ou sair da edição do membro
com PF3.
Teoria
manipulação dos
arquivos alocados

Parte 2
26
A charge faz referência ao Parallel Sysplex, onde é possível conectar até 32
mainframes, permitindo que todos trabalhem em conjunto para a execução de uma
tarefa.

Parte 2
27
2
Execute os procedimentos solicitados nos Data
Sets alocados na atividade anterior, anotando como o
procedimento foi realizado:
A) Visualizar as informações do DATA SET GP.GPXXNN.COBLIB.
B) Renomear o DATA SET GP.GPXXNN.DADOS.PESSOAIS para
GP.GPXXNN.PESSOAIS.
C) Excluir o DATA SET GP.GPXXNN.PESSOAIS.

Parte 2
28
Para adicionar um membro em um particionado, utilizamos a opção P.2 para
abrir o painel Edit Entry Utility. Informamos nos campos Project, Group e Type o nome
do particionado e no campo member o nome do membro que desejamos criar e
pressionamos ENTER. Um membro vazio é aberto no modo de edição e já podemos
digitar nossos textos.
Teoria Edição de membros

Parte 2
29
2
Na linha Command podemos usar os seguintes comandos:
CANCEL sai da edição do membro sem salvar
SAVE salva o membro
RES restore – apaga as mensagens exibidas pelo TSO
HI ON ativa as cores de acordo com o que está sendo digitado
HI ON COBOL ativa as cores para a linguagem COBOL
HI ON JCL ativa as cores para a linguagem JCL
HI ON ASM ativa as cores para a linguagem Assembly
HEX ON exibe o arquivo em hexadecimal
HEX OFF desliga a exibição do arquivo em hexadecimal
NUM ON enumera as linhas de 100 em 100 (o mesmo que RENUM)
NUM OFF enumera as linhas de 1 em 1
CAPS ON transforma tudo o que foi digitado em maiúsculo
CAPS OFF desativa CAPS ON
RECOVERY ON apenas uma vez, habilita o UNDO (desfazer)
UNDO desfaz a última modificação no texto
F xxxx find – localiza a string xxxx no texto – PF5 posiciona na próxima
C xxx yyy change – troca a primeira ocorrência de xxx por yyy
C xxx yyy ALL change – troca todas as ocorrências de xxx por yyy
L 44 locate – posiciona o cursor na linha 44
M + PF8 move – Letra M e tecla PF8 – Avança para o fim do texto
M + PF7 move – Letra M e tecla PF7 – Avança para o início do texto
EXC aaa ocultar a linha com a string aaa.
EXC aaa ALL ocultar todas as linhas com a string aaa.
PFSHOW OFF não exibe o rodapé, com as teclas de função
PFSHOW ON exibe o rodapé, com as teclas de função
PROF exibe o perfil do usuário (PROFILE) do usuário
BOTTOM avança para o fim do texto
TOP avança para o início do texto
START Abre uma nova janela
LIST Exibe um menu com as janelas abertas
Toda linha que começa com '''''' não foi usada e quando se pressiona
ENTER elas são apagadas. Para inserir linhas, basta colocar o cursor nos asteriscos
da lateral esquerda da linha Top of Data e digitar I seguido da tecla ENTER. Para
inserir 5 linhas, digitar I5. Toda vez que for pressionado ENTER após a digitação de
uma linha, uma nova linha com '''''' será exibida. Se for pressionado ENTER
novamente, ela desaparece e será necessário digitar I em qualquer linha da lateral
esquerda da tela.
No campo SCROOL podemos escolher:
PAGE paginação da tela inteira. Abreviadamente P.
CSR paginação até a posição do cursor. Abreviadamente C.
número paginação pelo número de linhas indicado

Parte 2
30
A melhor escolha para o SCROOL é CSR, pois colocamos o cursos no linha
desejada e pressionamos PF8, avançando a tela, mas parando na posição do cursor.
Os comandos que podem ser utilizados na lateral esquerda da tela de edição
são:
I insere uma linha. I5 insere 5 linhas (ou outro número que desejar).
D Exclui uma linha. D5 Exclui 5 linhas.
R repete uma linha. R5 repete a linha 5 vezes.
M move a linha para um destino (usar A = after ou B=before) na linha de destino
C copia a linha para um destino (usar A = after ou B=before) na linha de destino
LC (Lower Case) converte os caracteres da linha para minúsculo
UC (Upper Case) converte os caracteres da linha para maiúsculo
X oculta uma linha. X5 oculta 5 linhas.
S exibe linha ocultada. S5 exibe 5 linhas ocultadas.
TS (Text Split) divide a linha na posição atual do cursor
COLS insere uma régua na linha, o que ajuda na identificação das colunas
) descola linha para a direita. )5 desloca 5 colunas para a direita.
( descola linha para a esquerda. (5 desloca 5 colunas para a esquerda.
Comandos para grupos de linhas (blocos de linhas)
MM marca o início e o término do bloco que desejamos mover,
usar A ou B no destino
CC marca o início e o término do bloco que desejamos copiar,
usar A ou B no destino
DD marca o início e o término do bloco que desejamos excluir
RR marca o início e o término do bloco que desejamos repetir
)) marca o início e o término do bloco que desejamos deslocar para a direita.
(( marca o início e o término do bloco que desejamos deslocar para a esquerda.

Parte 2
31
2
Crie o membro TESTE dentro do particionado
GP.GPXXNN.COBLIB e digite trechos do texto abaixo.

Parte 2
32
Podemos copiar membros de arquivos particionados. Basta informar a origem e
o destino do membro. A partir do menu principal digitamos P.3.3 para acessar o painel
Move/Copy Utility.
No campo option digitamos C para copiar. Abaixo da frase Specify "From" Data
Set below, then press ENTER key, digitamos nos campos Project, Group, Type e
Member o nome do particionado e do membro que desejamos copiar e pressionamos
ENTER.
Abaixo da frase Specify "To" Data Set Below, digitamos nos campos Project,
Group, Type o nome do particionado de destino do membro copiado. Se não
preenchermos o campo member, ele será copiado com o mesmo nome, ou damos um
novo nome para o membro e pressionamos ENTER.
Uma mensagem aparece no canto superior direito indicando que a cópia foi
realizada com sucesso, como mostra as telas abaixo.
Teoria cópia de membros

Parte 2
33
2
Execute os procedimentos abaixo e anote como foram
feitos:
A) Copie os membros ESKELETO e EEXXNN01 da COBLIB de seu instrutor para
seu PDS COBLIB. Anote o procedimento abaixo.
B) Mova o membro DICAS da COBLIB de seu instrutor para seu PDS COBLIB.
Anote o procedimento abaixo. O que ocorreu?
C) Copie os membros COMPCOB e CCXXNN01 da JOBLIB de seu instrutor para seu
PDS JOBLIB. Anote o procedimento abaixo.
D) Renomeie os membros (usando a opção P.3.4) EEXXNN01 de seu PDS COBLIB e
CCXXNN01 do seu PDS JOBLIB, trocando XXNN pelo prefixo de seu usuário, e
responda: Logo após a alteração, o membro ficou com o nome alterado?
O que fazer para mostrar o nome alterado do membro?

Parte 2
34
O programa COBOL é chamado de Programa Fonte e está escrito em uma
linguagem de alto nível, pois está mais próximo da linguagem humana, no caso inglês
estruturado. Um programa fonte não pode ser executado, porque o computador não
“fala inglês”. É preciso convertê-lo para uma sequência de zeros (0) e uns(1)
(linguagem binária), facilmente reconhecida e executada pelo computador, chamado
de Módulo de Carga (Load Module).
O processo de converter um programa fonte em módulo de carga (Load
Module) é chamado de Compilação. Na verdade ocorrem três etapas, como mostra a
figura abaixo:
Teoria Compilando programa cobol
1º. Passo
PRE-COMPILE
2º. Passo
COMPILE
3º. Passo
LINKAGE EDITOR
LOAD
MODULE
Programa Fonte
COBOL
LIBRARY
BOOKs
SPOOL
A
s
d
p
GP.GPXXNN.COBLIB
(GPXXNN04)
GP.GPXXNN.BOOKLIB
(CLISP)
GP.GERAL.LOADLIB
(GPXXNN04)
GP.GPXXNN.JOBLIB
(COMPCOB)
SD.ST
? JOBID
S SYSPRINT
Programa Fonte
COBOL
+
BOOKs
PROGRAMA
OBJETO

Parte 2
35
2
1º - Pré-Compilação – O pré-compilador procura a instrução COPY seguida do
nome de um arquivo (membro) que será inserido no fonte COBOL. Muitas rotinas já
prontas e o layout dos arquivos não são digitados, mas sim inseridos no fonte pela
instrução COPY. Isso é feito antes de passar o programa fonte pela compilação.
2º - Compilação – O compilador faz uma análise sintática, em busca de
palavras do COBOL escritas erroneamente, como por exemplo PERFORMI, no lugar
de PERFORM, ou END IF no lugar de END-IF. Depois é feita uma análise semântica
(de significado), onde os comandos incompletos são apontados como errados,
exemplo ADD 1 WS-CTLIDO, no lugar de ADD 1 TO WS-CTLIDO. Se tudo estiver
certo, ocorre a tradução para a linguagem da máquina, menos as instruções de I-O
(Input-Output), que são os comandos OPEN. CLOSE, READ, WRITE, REWRITE e
DELETE. Esses comandos são substituídos por chamadas (CALL) à funções de I-O,
que estão em biblioteca externa.
3º - Linkage-Editor – O linkeditor analisa os CALLs existentes no programa
compilado e acessa uma biblioteca de funções, buscando a função chamada e
substituindo no ponto onde está o CALL. Assim o Módulo de Carga (Load Module) é
gerado e está pronto para uso.
Um log com o resultado do processo de Compilação e Linkedição é gravado e
armazenado em uma fila (SPOOL – Simultaneous Peripheral Operations Online), para
consulta posterior.
Normalmente chamamos de compilação a execução dessas três etapas. O
JOB de compilação que usaremos está abaixo:
11234567892123456789312345678941234567895123456789612345678971234567898
12345678901234567890123456789012345678901234567890123456789012345678901234567890
//GPXXNN01 JOB SEUNOME,MSGCLASS=X,CLASS=C,NOTIFY=&SYSUID,TIME=(0,20)
//*****************************************************************
//* JOB DE COMPILACAO PROGRAMA COBOL BATCH
//* TROCAR XXNN POR SEU USUARIO
//*****************************************************************
// JCLLIB ORDER=GP.LB.PROCLIB
//COBCOMP EXEC DFHCOBOL,INSTR='GPXXNN',NOME='GPXXNN01'
//LKED.SYSIN DD *
NAME GPXXNN01(R)
/*
Esse JOB executa as três etapas do processo de compilação. Os exercícios da
apostila têm o seguinte formato: GPXXNN01, onde:
GP significa Grande Porte
XX é a sigla que identifica seu instrutor
NN é o número do aluno
01 é o número do projeto

Parte 2
36
Para preparar o JOB de compilação para compilar, por exemplo, o projeto
GPAZ9901 devemos, no TSO, utilizar o comando C (CHANGE) da seguinte forma:
C XXNN AZ99 ALL
Com o comando SUB, submetemos esse JOB ao JES, que atribuirá um
número ao JOB, chamado de Job Id. Esse número será usado na identificação do JOB
na fila do JES.
Pressione ENTER de tempos em tempos, até aparecer uma notificação no topo
da tela, com o MAXCC obtido. Se tudo der certo, obteremos MAXCC = 0. Caso
contrário, o MAXCC será 4, 8 ou 12.
Quando obtemos MAXCC diferente de zero, o programa fonte COBOL está
com erro. Precisamos tirar os erros do programa e recompilar, até obter MAXCC=0.

Parte 2
37
2
Compile o programa EEXXNN01. Anote o
procedimento abaixo. Qual foi o MAXCC de retorno?

Parte 2
38
A partir do Menu Principal do TSO escolhemos SD (SDSF-System Display and
Search Facility) e depois ST (Display status of jobs in the JES2 queues). Chegamos ao
SPOOL.
Uma relação de JOB aparece. Identifique o Job Id que você havia obtido.
Coloque uma interrogação (?) à esquerda e pressione ENTER. Os arquivos que
compõem o JOB aparecem.
Coloque um S do lado esquerdo do arquivo SYSPRINT COBCOMP COBOL
para ele ser aberto.
Teoria
Tirando erros detectados
na compilação

Parte 2
39
2
Utilize o comando F MESSAGE para localizar o início das mensagens de erro
que ocorreram em seu programa fonte
Na coluna LineID está a linha do programa fonte que está com erro. Na coluna
Message Code os erros terminam com S (Severe), E (Error) ou W (Warning),
dependendo da severidade do erro. Com as teclas PF11 e PF10 é possível deslocar a
tela para a esquerda e direita, assim é possível ler toda a mensagem de erro.
Divida a tela em duas partes, posicionando o cursor no topo da tela e
pressionando PF2. Você sabe que a tela está dividida quando aparece uma linha
pontilhada. Para “trocar de tela” pressione PF9. Em uma tela mantenha os erros e na
outra abra o programa fonte para correção. Retire os erros e recompile o programa,
até obter MAXCC=0.

Parte 2
40
Encontre e elimine os erros do programa
EEXXNN01. Recompile até encontrar MAXCC=0. Anote o
procedimento abaixo.

Parte 2
41
2
Para executarmos um programa compilado (Load Module), montamos um JOB
de execução. A seguir temos o Job de execução do programa do exemplo. Observe a
SYSIN, que será lida com o comando ACCEPT do COBOL.
Depois de executar com sucesso, digite SD.ST a partir do menu principal do
TSO, coloque um S ao lado da SYSOUT para abri-la. No programa fonte COBOL, o
resultado do comando DISPLAY aparece na SYSOUT.
No exemplo, a finalidade do exercício é o calcular o salário de funcionários, que
ganham lidos da SYSIN na SYSOUT.
Teoria Executando cobol

Parte 2
42
ALGUMAS DICAS
Dica 1) Na opção SD.ST, é possível abrir o JOB submetido digitando SJ no
lado esquerdo do JOBNAME. SJ é a sigla para submit job.
Dica 2) Para abrir uma nova janela, digite START na linha de comando. É
possível abrir mais de 2 janelas simultaneamente. Mas a tecla PF9 só faz a troca entre
2 janelas. Para ver as demais janelas, digitar KEYS na linha de comando e na opção
PF9 colocar SWAP LIST. Ao pressionar PF9 aparece uma lista de janelas. A janela
ativa aparece com *. Para dar nome às janelas, digite SCRNAME nome_da_janela na
linha de comando.
Na próxima página estão as telas onde essas dicas são mostradas na prática.

Parte 2
43
2

Parte 2
44
Execute o programa EEXXNN01 utilizando o job
CCXXNN01 e compare seus resultados com os dos
outros colegas. Anote o procedimento abaixo.

Parte 2
45
2
Responda as questões abaixo, depois peça para
que seu colega as corrija.
1) Coloque as letras, que representam a navegação pelos menus do TSO nos
parênteses que indicam o nome do painel correspondente.
A – P.0 ( ) – SDSF STATUS DISPLAY ALL CLASSES
B – P.3.2 ( ) – ISPF Settings
C – P.3.3 ( ) – Data Set List Utility
D – P.3.4 ( ) – Edit Entry Panel
E – SD.ST ( ) – Data Set Utility
F – P.2 ( ) – Move/Copy Utility
2) Associe os comandos utilizados durante a edição de um membro com a sua ação.
A – CAPS ON ( ) – ativa as cores para a linguagem COBOL
B – NUM OFF ( ) – posiciona o cursor na linha informada
C – RES ( ) – Localiza uma string no membro
D – HI ON COBOL ( ) – apaga as mensagens exibidas pelo TSO
E – SAVE ( ) – sai da edição do membro sem salvar
F – CANCEL ( ) – enumera as linhas de 1 em 1
G – L nn ( ) – habilita o UNDO (desfazer)
H – M + PF8 ( ) – salva o membro
I – M + PF7 ( ) – transforma tudo o que for digitado em maiúsculo
J – F string ( ) – substitui todas as ocorrência da string1 por string2
K – RECOVERY ON ( ) – substitui 1ª ocorrência da string1 por string2
L – C XXXX YYYY ( ) – desfaz a última modificação no texto
M – UNDO ( ) – Avança para o fim do texto
N – C XXXX YYYY ALL ( ) – Avança para o início do texto
Practice
Atividade Revisão aos pares

Parte 2
46
3) Com base no texto abaixo, localize as palavras em vermelho no caça-palavras.
O processo de COMPILACAO transforma um programa FONTE escrito
em uma linguagem de alto nível, como o COBOL, em um módulo de CARGA
que é a linguagem da MAQUINA (binário). No Mainframe, esse processo
ocorre em três etapas, a pré-compilacao, que faz a inserção de BOOK com o
comando COPY, a compilação, que faz análise SINTATICA e SEMANTICA no
fonte, indicando as rotinas de I-O com CALL e a LINKEDICAO, que substitui
esses CALLs pelas respectivas funções de I-O.
O A C I D E K N I L
A N A V O T N K R S
C I L O C N O Z I E
A U O N E O B X D M
L Q R E B F P L I A
I A T S O E E Y O N
P M C O B O L B M T
M J O B L I B S A I
O C A R G A L L A C
C S I N T A T I C A

Parte 2
47
2
Neste bate-bola, fale o nome de um colega, faça
uma pergunta e jogue a bola para ele. Quem recebe a
bola, responde a pergunta e repete o jogo.
Anote as respostas mais criativas!
Dinâmica Pense rápido !
P.2
SD.ST
Menu/ Painel

Parte 2
48
Instalação do Hercules
Faça a instalação do ambiente mainframe no seu
computador pessoal. Nossos alunos já instalaram esse
ambiente em diversas versões de Windows (do 95 ao
Seven) e em diversas configurações de hardware (desde
NetPC, Notebook até Desktops).
No DVD que você recebeu há os seguintes arquivos:
abendassist.exe programa com diversas tabelas de abends
Helpdib.hlp arquivo de Help também com tabelas de abends
Instalação do Hercules.doc manual de instalação passo a passo do ambiente
GrandePorte-1.zip arquivo com o ambiente mainframe compactado
Serão necessários aproximadamente 22 GB livres em seu HD para essa
instalação.
É importante ter o Hercules instalado em seu computador para que você possa
praticar e ganhar vivência nesse ambiente. Refaça todos os projetos de programas
feitos na Grande Porte em sua casa.
O Hercules é um emulador de computador que permite que softwares
projetados para computadores mainframe IBM (System/370, System/390, zSeries e
System z) e para mainframes plug-compatível (como máquinas de Amdahl) funcionem
em outros tipos de computadores, como os computadores pessoais por exemplo.
Performance
Atividade Para casa

Parte 2
49
2
Embora existam outros emuladores de mainframe que desempenhem uma
função semelhante, o Hercules é considerado o melhor de sua categoria. O Hercules é
executado em vários sistemas operacionais, incluindo Linux, Windows, FreeBSD,
Solaris e Mac OS X e é liberado sob a licença open source software QPL.
O Hercules foi o primeiro emulador de mainframe a incorporar 64 bits
z/Architecture suporte, superando as ofertas comerciais. Roger Bowler, programador
de sistemas mainframe, iniciou o desenvolvimento do emulador Hercules em 1999.
Jay Maynard atualmente mantém e hospeda o projeto.
Para mais informações consulte www.hercules-390.org
Roger Bowler
Engenheiro do sistema z/OS e criador do
emulador Hercules ESA/390, que em 1999 causou
uma grande revolução no mundo dos computadores
mainframe, permitindo que pessoas físicas puderem
executar pela primeira vez, softwares de mainframe
em seus próprios PCs, e o mais importante, de graça.
Jay Maynard
Gerente de projetos do emulador de
mainframe Open Source Hercules. Foi um
programador de mainframe e sistemas de rede por
mais de 15 anos, e tem também trabalhado com uma
grande variedade de computadores como sistemas
Unix, AS/400 e outros sistemas de computadores.

Parte 2
50
Avaliação Então...Como foi ?!?
Estou fera!
Fiz Certo!
Muito Bom Bom regular ruim Muito ruim    

Parte
Teste de Turing - Um computador pode ser chamado
"inteligente" se conseguir enganar uma pessoa fazendo-se
passar por um ser humano.
O logo da Apple é atribuído erroneamente como um
tributo a Alan Turing, com a marca de mordida fazendo
referencia ao seu método de suicídio.
Alan Turing
1912 – 1954

Parte 3
3
3
Preparation

Parte 3
4
Continuando com seu programa de treinamento,
vamos agora ficar mais íntimos do COBOL. Vamos
conhecer os comandos básicos, necessários para o
processamento batch.
Esses comandos devem ter seu significado e
sintaxe dominados pelos estagiários. Você deve sabê-
los na ponta da língua.
Também aprenderemos um pouco de
matemática, onde os sistemas de numeração decimal,
binário e hexadecimal serão usados para representar
os números armazenados em diversos tipos de
variáveis do COBOL.
Você ficará maravilhado com a grande
quantidade de programas que já são possíveis de se
fazer com o conhecimento que você vai adquirir nesta
parte do treinamento.
Boas práticas de programação também serão
exigidas e seus programas devem segui-las. Não basta
fazer o programa funcionar, ele também deve ser
esteticamente bonito, de fácil leitura e compreensão.
Fazer um programa é fácil, o difícil é dar manutenção.
Escreva seus programas pensando no próximo.
Presentation
História Ficando íntimo do cobol

Parte 3
5
3
A linguagem COBOL possui algumas regras a serem seguidas quanto a
formatação do programa fonte. Uma linha de programa COBOL pode ter até 80
caracteres, conforme o formato abaixo:
12345678911234567892123456789312345678941234567895123456789612345678971234567898
12345678901234567890123456789012345678901234567890123456789012345678901234567890
NNNNNNCAAAABBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBNNNNNNNN
----+-*A-1-B--+----2----+----3----+----4----+----5----+----6----+----7--|-+----8
Colunas de 1 a 6 (N) não usado
Coluna 7 (C) área de indicação
Colunas de 8 a 11 (A) margem A
Colunas de 12 a 72 (B) margem B
Colunas de 73 a 80 (N) não usado
Área de indicação (Coluna 7)
(-) Hífen – Indica que existe uma constante alfanumérica entre aspas ou
apóstrofe, que foi iniciada na linha anterior. Uma constante alfanumérica que não cabe
em uma linha, para que seja continuada, precisa ter na próxima linha a indicação da
continuação (hífen na coluna 7) e, em qualquer coluna a partir da 12 (margem B), um
apóstrofe (ou aspas) indicando o início da continuação. Exemplo:
----+-*A-1-B--+----2----+----3----+----4----+----5----+----6----+----7--|-+----8
XXXXXXXXXXXDISPLAYX“AXLINGUAGEMXDEXPROGRAMACAOXCOBOLXEHXMUITOXUTILIZADA
XXXXXX-XXXXXXXXXXXX“EMXEMPRESASXDEXGRANDEXPORTEXDEVIDOXAXSUAXGRANDEXCAPA
XXXXXX-XXXXXXXXXXXX“CIDADEXDEXPROCESSAMENTOXEXCONFIABILIDADE”
(*) Asterisco – Indica, para o compilador COBOL, que a linha inteira deve ser
tratada como uma linha de comentário. Linhas de comentário não são compiladas e,
portanto não interferem na execução do programa. Porém são importantes para
documentar o programa e esclarecer a lógica desenvolvida pelo programador.
Exemplo:
----+-*A-1-B--+----2----+----3----+----4----+----5----+----6----+----7--|-+----8
......*----------------------------------------------------------------*
......* EMPRESA : METALURGICA FERRO FORTE LTDA.
......* SISTEMA : CONTABILIDADE
......* PROGRAMA : CONT0231
......*----------------------------------------------------------------*
.......IDENTIFICATION................ ..DIVISION.
......*----------------------------------------------------------------*
.......PROGRAM-ID...................... CONT0231.
Linhas em branco com * na coluna 7, são tratadas mais rapidamente pelo
compilador COBOL, pois são ignoradas logo no início da compilação.
Teoria
Formato do programa
fonte cobol

Parte 3
6
(/) Barra – Indica, para a impressora que deve fazer um salto de página. Isso é
interessante quando desejamos que determinada parte do programa comece no início
da próxima página, como por exemplo as DIVISIONS, os parágrafos da PROCEDURE
DIVISION, etc. Deve estar em uma linha em branco.
Exemplo:
----+-*A-1-B--+----2----+----3----+----4----+----5----+----6----+----7--|-+----8
/
......*----------------------------------------------------------------*
.......PROCEDURE ................ ..DIVISION.
......*----------------------------------------------------------------*
Margem A – Colunas de 8 a 11
Posição a partir da qual se escrevem o nome de Divisão, Seção, Parágrafo e
os níveis FD (FILE DESCRIPTION), 01 (grupo de variáveis) e 77 (variável individual).
----+-*A-1-B--+----2----+----3----+----4----+----5----+----6----+----7--|-+----8
......*----------------------------------------------------------------*
.......DATA............................ DIVISION.
......*----------------------------------------------------------------*
.......FILE....... ....... ....... .... SECTION.
.......WORKING-STORAGE....... ......... SECTION.
Margem B – Colunas de 12 a 72
Posição a partir da qual se escrevem os valores dos parágrafos e as instruções
COBOL.
----+-*A-1-B--+----2----+----3----+----4----+----5----+----6----+----7--|-+----8
......*--------------------------------------------------------------* x
.......PROCEDURE DIVISION. x
......*--------------------------------------------------------------* x
.......000-GPAZ9901. x
...........PERFORM 010-INICIALIZAR x
...........PERFORM 030-PROCESSAR x
UNTIL WS-FIM = "S" x
...........PERFORM 050-TERMINO x
...........STOP RUN x
............ x
EJECT – igual a / (barra), indica, para a impressora que deve fazer um salto de
página. Pode estar na margem A ou B.
Exemplo:
----+-*A-1-B--+----2----+----3----+----4----+----5----+----6----+----7--|-+----8
EJECT
......*----------------------------------------------------------------*
.......PROCEDURE ................ ..DIVISION.
......*----------------------------------------------------------------*
EJECT

Parte 3
7
3
Folha de codificação COBOL
É um formulário para escrever o programa fonte COBOL, da época em que o
programa precisava ser perfurado em cartões. Podem-se ver claramente as colunas e
as margens A e B.

Parte 3
8
De maneira semelhante a um livro com seus capítulos, parágrafos e itens, um
programa COBOL é formado por uma hierarquia de divisão (DIVISION), seção
(SECTION), parágrafo e instruções. Uma regra importante em COBOL é que todo
nome de Divisão, Seção e Parágrafo deve ser terminada por ponto final (.). O código
COBOL possui quatro divisões que devem ser utilizadas nesta ordem:
----+-*A-1-B--+----2----+----3----+----4----+----5----+----6----+----7--|-+----8
.......IDENTIFICATION DIVISION.
.......ENVIRONMENT DIVISION.
.......DATA DIVISION.
.......PROCEDURE DIVISION.
Por questões de estética e melhor visualização, costuma-se digitar essas
divisões da seguinte forma, com DIVISION na coluna 44:
----+-*A-1-B--+----2----+----3----+----4----+----5----+----6----+----7--|-+----8
......*----------------------------------------------------------------*
.......IDENTIFICATION.................. DIVISION.
......*----------------------------------------------------------------*
......*----------------------------------------------------------------*
.......ENVIRONMENT..................... DIVISION.
......*----------------------------------------------------------------*
......*----------------------------------------------------------------*
.......DATA............................ DIVISION.
......*----------------------------------------------------------------*
......*----------------------------------------------------------------*
.......PROCEDURE....................... DIVISION.
......*----------------------------------------------------------------*
Esta é a DIVISION de identificação do programa. Não contêm SECTIONs, mas
somente alguns parágrafos pré-estabelecidos e opcionais. O único parágrafo
obrigatório é o PROGRAM-ID (Identificação do Programa). A identificação do
programa deve ser uma palavra com até 8 caracteres (letras ou números), começando
por uma letra, que será usado no processo de linkedição para identificar o programa e
nomear o programa objeto. Possui a seguinte estrutura.
----+-*A-1-B--+----2----+----3----+----4----+----5----+----6----+----7--|-+----8
*--------------------------------------------------------------*
*--------------------------------------------------------------*
PROGRAM-ID. GPNENN01.
AUTHOR. COMENTARIO.
DATE-WRITTEN. COMENTARIO.
DATE-COMPILED. SE PRESENTE, O COMPILADOR PREENCHE.
SECURITY. COMENTARIO.
Todos os parágrafos que possuem a palavra COMENTARIO, não possuem
efeito. São parâmetros opcionais para documentação do programa. Observe a
utilização do ponto final (.) no programa fonte COBOL. Nenhum destes pontos pode
ser omitido para não causar erro de compilação.
Teoria As 4 divisões

Grande porte cobol level 1 - versão 2.3.5

Grande porte cobol level 1 - versão 2.3.5

Empfohlen

Empfohlen

Weitere ähnliche Inhalte

Was ist angesagt?

Was ist angesagt? (20)

Andere mochten auch

Andere mochten auch (12)

Ähnlich wie Grande porte cobol level 1 - versão 2.3.5

Ähnlich wie Grande porte cobol level 1 - versão 2.3.5 (20)

Mehr von Jeison Barros

Mehr von Jeison Barros (20)

Grande porte cobol level 1 - versão 2.3.5