Você está na página 1de 45

Carlos J E de Campos

JCL
Job Control Language
Comandos, Sintaxe, Regras e Procedimentos
Exemplos de programas e Pensamentos

Desenvolvimento COBOL
Mainframe
Guia de Referência

Primeira edição
São Paulo
2013
 Carlos J E de campos, 2013
Capa: Ramon Alvarenga
Diagramação: Carlos J E de Campos
Revisão: Fernanda Rizzo

É proibida a reprodução total ou parcial desta obra, de qualquer forma ou por qualquer
meio sem a autorização prévia e por escrito do autor. A violação dos Direitos Autorais (Lei
n.º 9610/98) é crime estabelecido pelo artigo 184 do Código Penal.

2013
Todos os direitos desta obra pertencem a
Carlos J E de Campos
www.carloscamposinfo.com
JCL

Agradecimentos

Agradeço a Deus por ter-me colocado na trilha do conhecimento.

Agradeço à minha filhota, Vanessa Soares de Campos, por ser a minha fonte de esperança
e por mostrar compreensão e paciência em muitos momentos da nossa vida.

Agradeço ao amigo Roberto Azem, que sempre esteve por perto, nos momentos de
estudo e naqueles em que precisava de ouvidos e conselhos.

Agradeço aos meus pais Alice de Assunção Esteves Costa e José Manuel Lopes Moreira de
Campos, por terem-me dado a vida, educação, formação moral e muito apoio.

Agradeço ao companheiro Benedito Aparecido Alves, pelo apoio que tem me dado nesta
segunda fase dos meus livros, acompanhando-me no dia a dia do trabalho, ouvindo-me e
apoiando-me com o seu conhecimento e sabedoria. Benê, como é conhecido, tem sido um
grande conselheiro.

Reflexão
“Para adquirir conhecimento é preciso estudar, para adquirir sabedoria é preciso
observar.”
Autor: William Arthur Ward

www.carloscamposinfo.com Página 3
Não estamos aqui para pagar nem
sobreviver, mas sim, para vencer,
adquirindo saber.
&
Usemos o conhecimento com ética e moral.
JCL

Introdução

JCL - Job Control Language é uma linguagem interpretada usada em Mainframes da IBM
para instruir o sistema operacional a inicializar um subsistema ou executar um programa
de lote. A sigla JCL também pode ser usada genericamente para se referir a qualquer
linguagem que realize as mesmas funções, tais como a WFL, da empresa Burroughs, ou a
OCL, da ICL. JCL é uma linguagem de controle de serviços e tem como objetivo descrever
os serviços, gerenciar a sequência de execução dos programas e dos arquivos e
dimensionar o volume de recursos, do sistema operacional, necessários para a realização
do serviço. O JCL existe para executar programa no chamado processamento batch. O
processamento batch é administrado pelos operadores, que se encarregam de manter,
supervisionar e garantir a execução dos programas e a integridade dos dados. Essas
execuções, normalmente, acontecem durante a noite, para que o sistema possa fornecer,
no dia seguinte, os dados corretos aos usuários. O JCL existe para executar e administrar
uma quantidade enorme de programas e arquivos de dados.
Esta obra
Esta obra tem como objetivo alcançar as pessoas que desejam criar programas COBOL
Batch para serem executados em ambiente Mainframe, principalmente da IBM, z/OS e
OS/390. Oferece uma base teórica e prática, suficientemente boa, para que o leitor
domine a criação, manutenção e utilização em programas COBOL. A abordagem segue
uma sequência, de forma que o leitor possa compreender como montar STEPs e PROCs
que vão executarprogramas e efetuar tratamento de arquivos sequenciais e VSAM.
Os comandos são apresentados com a sua sintaxe básica e explicados a partir de
pequenos programas apresentados especificamente e criados para esse fim, que podem
ser usados para praticar e realizar testes.

Reflexão
“E conhecereis a verdade e a verdade vos libertará.”
João 8:32

www.carloscamposinfo.com Página 5
Público-Alvo
As informações contidas neste livro podem ser aprendidas e aplicadas por qualquer
pessoa que deseje conhecer e programar em COBOL com o Banco de Dados DB2 em
ambiente Mainframe.
Os conceitos e os comandos são apresentados numa ordem, como forma de melhorar a
compreensão e são acompanhados por figuras para ilustrar e aumentar a clareza das
informações. Com a finalidade de reforçar e consolidar o aprendizado, cada comando é
apresentado com a sua sintaxe básica e com um exemplo da sua aplicação e uso na
programação COBOL.
Pré-Requisitos
Para desenvolver sistemas comerciais em COBOL que utilizem o banco de dados DB2, é
necessário conhecer a sua linguagem, a sua sintaxe e as suas regras, mas, para elaborar
programas nesta linguagem ou em outra, é preciso ter conhecimento sobre lógica de
programação. É somente com a lógica de programação que se conseguem elaborar
programas que atendam a algum propósito de negócio, com eficiência, e para executar
programas Batch no ambiente Mainframe é necessário conhecer JCL.
Para que o leitor possa tirar maior proveito dos conhecimentos apresentados neste livro,
é aconselhável que conheça:
✔Lógica de programação estruturada
✔Linguagem COBOL
✔DB2 para COBOL
✔CICS para COBOL
É aconselhada a leitura do livro de “LÓGICA” do mesmo autor que explica, passo a passo, a
construção de algoritmos e de lógicas de programação, seguido do livro de COBOl, do DB2
para COBOL, do livro de CICS. E, depois, o livro de JCL.
Esta obra está aderente ao programa de formação de Especialista em Desenvolvimento de
Programação COBOL Mainframe, CMCPDS - Certified Mainframe COBOL Program
Development Specialist, fornecido pelo instituto ICPDUG - INTERNATIONAL COBOL
PROGRAM DEVELOPER USERS GROUP.
Para mais informações, visite o site www.carloscamposinfo.com, ou entre em contato
através do e-mail do autor: carlosjec@hotmail.com.

Reflexão
“Muitos homens iniciaram uma nova era na sua vida a partir da leitura de um
livro”.
Autor: Henry Thoreau
JCL

Sumário
Agradecimentos ................................................................................ 3
Introdução ....................................................................................... 5
Sumário .......................................................................................... 7
Resenha ........................................................................................ 11
Formação de especialista COBOL ......................................................... 13
Metodologia dos cursos .................................................................. 14
Objetivo do método ...................................................................... 14
Benefícios do método .................................................................... 14
Certificação para desenvolvedor Mainframe ............................................ 15
Objetivo da certificação ................................................................. 15
Como é a certificação .................................................................... 15
Notação utilizada ......................................................................... 17
Mainframe ..................................................................................... 19
Características e estrutura do mainframe ........................................... 19
JCL – Job Control Language ................................................................ 29
Características e estrutura do mainframe ........................................... 29
Estrutura da linguagem .................................................................. 32
O que é um JOB ........................................................................ 33
O que é um STEP ....................................................................... 33
Estrutura de um JOB ..................................................................... 33
Como é executado um JOB.............................................................. 37
Identificando a situação de execução de um JOB .................................. 43
Instruções do JCL ............................................................................ 47
Principais instruções abordadas ........................................................ 48
Parâmetros ................................................................................. 49
Instrução JOB .............................................................................. 51
Instrução EXEC ............................................................................ 55
Instrução DD ............................................................................... 65
Concatenar (juntar) arquivos ........................................................... 89

www.carloscamposinfo.com Página 7
IDCAMS ......................................................................................... 91
Codificação dos comandos .............................................................. 91
Regras dos comandos ..................................................................... 92
Parâmetros posicionais e de palavra-chave .......................................... 92
Como continuar comandos e parâmetros ............................................. 93
Como terminar o comando .............................................................. 93
Usando o serviço de método de acesso ............................................... 94
Invocando o serviço de método de acesso ............................................ 94
Utilização do IDCAMS ..................................................................... 95
Comandos utilizados no IDCAMS ........................................................ 96
Comando DEFINE GDG .................................................................... 97
Comando PRINT ..........................................................................101
Comando DEFINE CLUSTER .............................................................107
Comando REPRO ..........................................................................113
Comando LISTCAT ........................................................................123
Comando DELETE.........................................................................125
Comando VERIFY .........................................................................127
IEBGENER .....................................................................................129
Controlar o IEBGENER ...................................................................129
Como controlar a execução do IEBGENER ...........................................130
Sintaxe do IEBGENER ....................................................................131
Comandos utilizados no IEBGENER ....................................................132
Exemplo de IEBGENER – Imprimir a partir do STEP ................................133
Exemplo de IEBGENER – Copiar a partir do STEP ...................................133
Exemplo de IEBGENER – Copiar a partir de arquivo ................................133
Copiar arquivo para particionado (PDS) ..............................................134
Exemplo para copiar arquivo para PDS ...............................................134
IEFBR14........................................................................................135
Criar arquivo sequencial ................................................................136
Criar arquivo particionado (PDS) ......................................................137
DFSORT ........................................................................................139
Cartão de controle do DFSORT ........................................................140
JCL

Sintaxe geral do DFSORT ............................................................... 140


Comandos do DFSORT ................................................................... 141
Classificar registros do arquivo ........................................................ 143
Comando SORT FIELDS .................................................................. 143
Selecionar registro do arquivo ......................................................... 149
Somar valores em registros ............................................................ 155
Eliminar chaves duplicadas ............................................................ 157
Reformatar registros de entrada ...................................................... 159
Reformatar registros de saída ......................................................... 161
Juntar arquivos ........................................................................... 167
Copiar partes de arquivo ............................................................... 171
IEBCOMPR ..................................................................................... 181
Controlar o IEBCOMPR .................................................................. 181
Cartão de controle do IEBCOMPR ..................................................... 182
Sintaxe geral do IEBCOMPR ............................................................ 182
Boas práticas ................................................................................. 183
Orientações para DFSORT .............................................................. 184
Anexos......................................................................................... 187
Como codificar subparâmetros ........................................................ 187
quantidade ................................................................................ 190
qtdecopias ................................................................................ 190
qtdebufers ................................................................................ 190
qtdedispositivo ........................................................................... 190
qtderegistro............................................................................... 190
Bibliografia ................................................................................... 193
Outras obras do autor ...................................................................... 195
Índice Geral .................................................................................. 199

www.carloscamposinfo.com Página 9
Página deixada em branco
JCL

Resenha

Benedito Aparecido Alves

Quando fui convidado para participar deste projeto, não fiquei surpreso nem tive dúvidas
do que iria encontrar quando pude ler todos os outros livros do autor. Na nossa área, os
livros são muito raros e com pouco conteúdo. Normalmente, sem exemplos que reforcem
o entendimento. Os que existem são os manuais técnicos e na língua inglesa.
Li este livro e comparei com outros da área, observando a maneira como o conteúdo do
JCL está organizado. Gostei muito da forma simples e objetiva de como os comandos são
apresentados. Todos estão na forma básica e possuem exemplos que o leitor pode ler,
interpretar e até executar.
O livro de JCL atingiu o objetivo: apresentar a linguagem de forma prática, de modo a ser
facilmente utilizado pelo programador, e ainda virar um guia de referência, assim como
foram elaboradas as outras obras do autor.
O autor, assim como fez no livro de LÓGICA, COBOL, DB2 e CICS, tem a preocupação de
fornecer um material didático e, ao mesmo tempo, um treinamento com uma
metodologia que leva a uma boa formação básica para ser um bom programador,
utilizando lógica e bons princípios da linguagem JCL para ambiente de desenvolvimento
Mainframe.

Benedito Aparecido Alves tem mais de 25 anos de experiência, no ambiente de produção


Mainframe, atuando no setor financeiro, tais com: Bradesco, Unibanco, Caixa Federal,
Boston e IBM. Atualmente, trabalha na Sonda IT como Suporte a Produção (Mainframe).

www.carloscamposinfo.com Página 11
Página deixada em branco
JCL

Formação de especialista COBOL


A formação de um
desenvolvedor especialista
em COBOL Mainframe
envolve diversas áreas do
conhecimento, necessárias
para a atuação que o
profissional precisa ter no
desempenho da sua
atuação. São seis módulos
específicos de
conhecimento que se
completam: Lógica, COBOL,
DB2, CICS, JCL e TSO.
A formação completa segue uma sequência, de acordo com um planejamento, para a
integração de todos os módulos e, com isso, potencializar a sinergia vinda de cada área de
conhecimento. Por exemplo, primeiro se desenvolve o racíocino e se aprende a construir
algoritmos e lógicas de programação; depois, se aprende a estrutura de linguagem de
programação com os seus comandos e constrói-se programa com base nas lógicas de
programação aprendidas. A seguir, aprende-se o banco de dados onde estarão
armazenados os dados e, finalmente, aprende-se a estrutura do ambiente online do
Mainframe, a forma de programação pseudoconversacional e, o JCL, linguagem de
administra a execução de programas batch.
No módulo de LÓGICA, são abordados como se constrói algoritmos e lógicas de
programação.
No módulo de COBOL, são vistos toda a teoria e estrutura da linguagem de programação e
todos os comandos principais e básicos para desenvolver a grande maioria dos programas.
No módulo de DB2, são abordados a teoria e estrutura básica de um banco de dados e,
todos os comandos principais e básicos para desenvolver programas que utilizam o banco
de dados DB2 em programas COBOL.
No módulo de CICS, são vistos toda a teoria e estrutura do ambiente, a forma de
programação pseudoconversacional e, todos os comandos principais e básicos para
desenvolver a grande maioria dos programas online.
No módulo de JCL, são vistos toda a teoria e estrutura da linguagem de programação e
todos os comandos principais e básicos para desenvolver a grande maioria das soluções
necessárias para a execução dos programas batch.

www.carloscamposinfo.com Página 13
Metodologia dos cursos
O assunto novo é apresentado
ao aluno, através da Apresentar
apresentação de SLIDES Conceito
animados e coloridos e tiradas
as dúvidas sobre o tópico. Para
praticar o conhecimento novo, Rever Tirar
o aluno é solicitado a realizar o
conceitos dúvidas
exercício, no caso: criar
algoritmo ou programa. Após o
tempo para criar a primeira Consolidar Praticar
solução, é apresentado; via Exercícios exercícios
SLIDES animados e coloridos, a
solução do exercício, tirando Apresentar
todas as dúvidas possíveis. Para Solução
consolidar e poder tirar novas
dúvidas do tópico do conhecimento, são solicitados, em média de dois a quatro exercícios
na aula. A solução dos exercícios propostos é apresentada, via SLIDES animados e
coloridos. E para tentar consagrar o conhecimento, é solicitado, em média de três a seis
exercícios extras para o aluno fazer fora as horas das aulas. E, para tentar tirar possíveis
dúvidas remanescentes, são reservados os primeiros minutos de cada aula, para tirar
dúvidas.

Objetivo do método
Este método tem como objetivo alcançar os mais diversos indivíduos (visual, auditivo ou
cinestésico) para que tomem consciência dos conceitos. Todo o método está baseado na
indução do raciocínio, para que se crie a lógica necessária. Com isto, a energia necessária
gasta com o esforço para criar a lógica é gasta durante o treinamento. Depois de formado,
o individuo passa a raciocinar automaticamente com muito menor esforço. Por exemplo,
quando houver uma solicitação que seja necessária à criação de duas quebras, uma dentro
da outra, o raciocínio vem automaticamente e, à medida que vai elaborando a lógica, o
seu formato já vem no padrão aprendido.

Benefícios do método
Os benefícios do método aplicado podem se resumir no seguinte:
 Ampliação das possibilidades de aprendizagem
 Aumento do desempenho no raciocínio lógico
 Acomodação crescente do conhecimento
 Consolidação das estruturas lógicas
 Facilidade de criar a solução lógica
JCL

Certificação para
desenvolvedor Mainframe
O instituto ICPDUG (INTERNATIONAL COBOL PROGRAM DEVELOPER USERS GROUP), para
valorizar a área de desenvolvimento de sistema, fornece o exame de certificação para
desenvolvedor COBOL Mainframe, com o objetivo de identificar o especialista em
desenvolvimento de sistemas COBOL Mainframe.

Objetivo da certificação
A certificação vem agregar valor para a empresa, na medida em que vai avaliar o
conhecimento para a necessidade específica que o profissional precisa ter, possibilitando
a criação de um quadro de profissionais altamente qualificados e nivelados com o objetivo
de planejar, definir e criar sistemas e programas com eficiência e qualidade.
E para o profissional, vem para valorizar a sua capacitação, a sua formação, diferenciando-
o dos demais profissionais, fornecendo-lhe as credencias de um profissional especialista,
aderente com as necessidades de conhecimento específico.

Como é a certificação
O certificado de Especialista em COBOL Mainframe, CMCPDS - Certified Mainframe COBOL
Program Development Specialist (Especialista em Desenvolvimento de Programação
COBOL Mainframe). O especialista máster recebe o título, após ter obtido todas as
certificações para as seguintes especialidades:
 LÕGICA - Programação estruturada
 COBOL - Linguagem de programação
 DB2 - Sistema Gerenciador de Banco de Dados Relacional
 CICS - Sistema Gerenciador de ambiente ONLINE
 JCL - Linguagem de controle Batch

Para mais informações, acesse o site www.icpdug.org.br ou utilize o e-mail


contato@icpdug.org.br.

Reflexão
“Em algum lugar, algo incrível está esperando para ser descoberto.”
Autor: Carl Seagan

www.carloscamposinfo.com Página 15
Página deixada em branco
JCL

Notação utilizada
[ ] Opcional
{ } Optar por um, sendo que as opções estão separadas pelo símbolo “|” que
significa “ou”
< > Substituir por um nome
| Operador lógico "OU". Significa que pode ser substituído por um dos parâmetros.
... Existem procedimentos não mencionados

....|....1....|....2....|....3....|....4....|....5....|....6....|....7..

A linha acima representa a régua do exemplo em questão para ajudar a mostrar a posição
do caracteres, muito importante para a linguagem COBOL.

Reflexão
“Só é lutador quem sabe lutar consigo mesmo.”
Autor: Carlos Drummond de Andrade

www.carloscamposinfo.com Página 17
Página deixada em branco
JCL

Mainframe 1
Este capítulo tem como finalidade apresentar a história e os fundamentos dos
computadores Mainframe, em especial, da IBM, por ter sido o que mais se popularizou.

Características e estrutura do mainframe

O que é Mainframe
Um Mainframe é um computador de grande porte, dedicado normalmente ao
processamento de um volume grande de informações. Os Mainframes são capazes de
oferecer serviços de processamento a milhares de usuários por meio de milhares de
terminais conectados diretamente ou por uma rede.
O termo Mainframe se refere ao gabinete principal que alojava a unidade central de fogo
nos primeiros computadores.
É uma linha de computadores de grande porte destinado ao
processamento contínuo e ininterrupto de grande volume de
informações com alto grau de confiabilidade e segurança.
Um Mainframe moderno pode processar uma quantidade
superior a 4 bilhões de transações por segundo, suportar
milhares de terminais remotos e suas controladoras, controlar o
acesso de centenas de discos, fitas, volume de milhões de impressão etc.
Mainframe não é sistema operacional, é um computador que usa o sistema operacional
OS/390 ou z/OS, desenvolvido pela IBM com o fim específico de processar grandes
volumes de dados de forma contínua e ininterrupta.
Anteriormente, eram computadores que ocupavam um grande espaço e necessitavam de
um ambiente especial para seu funcionamento. Atualmente, possuem o mesmo tamanho
dos demais servidores de grande porte com menor consumo de energia elétrica. Os
Mainframes são capazes de realizar operações em grande velocidade e sobre um volume
muito grande de dados.
O Mainframe possui grande número de processadores que auxiliam os processadores
centrais. Eles são utilizados em funções de criptografia, gerenciamento de entrada/saída,
monitoração do ambiente, manipulação de memória etc. Suportam totalmente o software
antigo (no caso da IBM, inclusive aplicações escritas na década de 1960) convivendo com
novas versões.

www.carloscamposinfo.com Página 19
História do Mainframe
Os Mainframes nasceram em 1946 e foram sendo aperfeiçoados. Em 7 de abril de 1964, a
IBM apresentou o System/360, Mainframe que,
na época, foi o maior projeto de uma empresa.
Desde então, outras empresas – como a HP e a
Burroughs (atual Unisys) – lançaram seus
modelos.
Posteriormente, a IBM lançou a série /370 e a
Burroughs, as máquinas de terceira geração: B-
3500 e B-6500, sucedidas pela série 700: B-3700
e B-6700.
Figura 1 – IBM 704
No fim da década de 1970, ao mesmo tempo
em que os sistemas destinados a grandes corporações cresciam, começaram a ser
reduzidos os tamanhos de uma série de máquinas: a IBM lançou o /3 e a Burroughs, a
série B-1700 e, posteriormente, a B-700, máquinas de quarta geração, cujo software
básico era escrito em MIL (Micro Implemented Language) e SDL (Software Development
Language). Como foram as primeiras máquinas Burroughs microprogramáveis, isso lhes
proporcionou flexibilidade ímpar. Estas máquinas marcaram o início do uso de circuitos
integrados com tecnologia TTL e integração em média escala (MSI).
Atualmente, a IBM produz quatro versões de Mainframes, denominados System Z series,
que, modernizados, suportam diversos sistemas operacionais: z/OS, z/OS.e, z/VM, z/VSE,
VSE/ESA, TPF, z/TPF e Linux on System z.
Hoje, segundo especialistas, há uma forte tendência de crescimento para este setor,
inclusive com as novas versões do Cobol (principal linguagem dos Mainframes) que usam
ambiente gráfico.
A primeira empresa a usar o S/360 no Brasil foi a Bayer, empresa de produtos químicos,
em 1966. Outras empresas e órgãos do governo adotaram o Mainframe depois, como o
governo do Estado de São Paulo, a Usiminas e Paulo Afonso.
Desde então, outras empresas, como a HP e a Unisys, lançaram seus modelos de
Mainframe. Além disso, bastante coisa mudou no mundo da tecnologia. Na verdade, boa
parte do mercado de informática que existe hoje surgiu depois do primeiro Mainframe.
Foi apenas depois disso, por exemplo, que surgiu o circuito integrado, mais conhecido
hoje em dia como chip semicondutor. Sem esses chips, dificilmente teriam surgidos os
microprocessadores, que começaram a se tornar populares na década de 80.

Reflexão
“Há um poder maravilhoso no silêncio.”
Autor Desconhecido
JCL

Primeiros Mainframes
Vejamos como eram os primeiros computadores Mainframes da IBM.

IBM 360 – LANÇADO EM 1964 IBM 370 – DÉCADA DE 70,


O primeiro mainframe a segunda geração

IBM MULTIPRISE – 1990


IBM 3090 – ANOS 80 Modelo compacto usado muito
Refrigerado a água em backup de sites

LINHA 9000 – ANOS 90, o LINHA Z/SERIES – ANO 2000 a


modelo mais utilizado nova geração

www.carloscamposinfo.com Página 21
Capacidade dos Mainframes
Os Mainframes possuem grande capacidade de armazenamento e velocidade (Fonte IBM).

Mainframe Atual - IBM System z9-EC – Clientes maiores


 Até 54 Processadores (para
aplicação)
 Até 512 Gb de memória
 Velocidade de Barramento até 172.8
Gb por segundo.

Mainframe suporta vários sistemas operacionais


Os Mainframes podem suportar vários sistemas operacionais (Fonte IBM).

Inovação com Processadores Especializados


A PU quando é um Processador
Central (CP) processa qualquer tipo
de carga de aplicativo, mas pode ser
configurada para processar cargas IBM System z9
específicas como: Integrated Information
Processor (zIIP) 2006

System z9
Processa parte
Application Assist das cargas do
Processor (zAAP) DB2
2004
Integrated Processa JAVA
Facility for Linux
(IFL) 2001

Internal Coupling Processa Linux e


Facility (ICF) 1997 Virtualização
Processa
Cluster
JCL

Disponibilidade do Mainframe
O Mainframe tem alta disponibilidade, atinge 99,99 % (Fonte IBM).

IBM System z – Disponibilidade – 99.999%

5 minutos de paradas programadas por ano!!


Componentes projetados para funcionar 100 anos sem apresentar falhas.

Imponência do Mainframe
A IBM tem o projeto BIG Green, que consolida em 30 Mainframes uma enorme
capacidade de armazenamento e de processamento, com alta economia de energia (Fonte
IBM).

Projeto IBM Big Green


 Consolidação de Servidores na IBM
- 3900 servidores Intel e Unix nos CPDs do
mundo todo
- 80% de Economia de Energia
- 250 milhões de dolares economizados em 5
anos com energia, software e suporte
- Usando Linux

 TUDO ISSO EM 30 MAINFRAMES

www.carloscamposinfo.com Página 23
Mainframe e supercomputador
A distinção entre supercomputadores e Mainframes não está clara, mas podemos dizer
que os supercomputadores são utilizados na solução de problemas em que o tempo de
cálculo é um limite, enquanto os Mainframes são utilizados em tarefas que exigem alta
disponibilidade e envolvem alto volume de processamento de dados.
Os supercomputadores são otimizados para realizar tarefas complexas, utilizando
principalmente a memória, enquanto os Mainframes são otimizados para realizar tarefas
que acessam grandes quantidades de informação oriunda de bases de dados, arquivos. Os
supercomputadores são construídos para atender a uma finalidade específica. Os
Mainframes são construídos para realizar uma grande variedade de tarefas de execução
diária. Normalmente, os supercomputadores são utilizados em aplicações científicas e
militares, enquanto os Mainframes são voltados a aplicações civis, sejam governamentais
ou empresariais. A análise de modelos de clima, análise estrutural de proteínas e
processamento de filmes digitais são tarefas bastante apropriadas para os
supercomputadores. O processamento de cartões de crédito, gerenciamento de contas
bancárias e processamento de seguro são tarefas normalmente realizadas por
Mainframes. Uma exceção: certas aplicações militares exigem um nível de segurança
muito alto, que é uma forte característica dos Mainframes.

Visão geral de um Mainframe

C
...
 
O
N
T
R
Console(s) O
operador L Terminal Terminal
A
D Discos
O
R Impressoras
A
CPU S Fitas
Cartuchos
JCL

Terminal 3270
Os terminais que se comunicam com o Mainframe são dedicados e não possuem
inteligência, como um computador, conhecido como PC
(Personal Computer). Eles são conhecidos como terminais
tipo 3270, terminal a caractere.
Nos terminais 3270 os pontos “endereçáveis” constituem um
vetor de (basicamente) 24 x 80 = 1920. Estes “pontos” podem
receber um conjunto limitado de conteúdos (basicamente 190
caracteres oriundos das 256 configurações EBCDIC).
Nos computadores, PC, os monitores cada vez mais possuem pontos endereçáveis, os
pixels (picture elements). Por exemplo, a configuração 640 x 480 possui 307.200 “pontos”,
que podem ser configurados à vontade. É a maravilha do terminal gráfico permitindo
imagens cada vez mais perfeitas. Parecidas com a natureza.
Por meio dos computadores PC, pode-se conectar-se ao Mainframe. Para isso ser possível,
é necessário utilizar um software de simula um terminal 3270 para a comunicação.

Teclado 3270
Os terminais (teclado) do Mainframe também são um pouco diferentes, assim como
existem diversos teclados para os computadores pessoais. Depende do fabricante e do
idioma do país.

A utilização dos recursos do teclado 3270 no PC depende do emulador e do teclado


utilizado.
No PC existem o processador, a memória e o software, que possibilitam o tratamento de
uma parte dos dados para que a comunicação com um host seja feita localmente; no
terminal, existe apenas um buffer (memória) capaz de conter informações que estão
limitadas ao tamanho da tela.

www.carloscamposinfo.com Página 25
Softwares utilizados no Mainframe
Sistema de gerenciamento e automação dos processos de migração
CHANGEMAN de software, ou aplicações, do ambiente de desenvolvimento para
produção, passando pelo ambiente de teste.

CICS Gerenciador de aplicações on-line.

DB2 Gerenciador de base de dados relacional (usa SQL).

Linguagem para desenvolvimento, que pode ser usada de forma


EASYTRIEVE
interpretada.

ENDEVOR Controle de objetos fonte.

FILE-AID Manipulação on-line de arquivos.

IDCAMS Manipulação batch de arquivos, principalmente VSAM.

Job Control Language: linguagem para especificação de


JCL
“conjuntos” de serviços a executar.

RACF Controle de acesso aos recursos.

Remote Operating System Conversation Operating Environment,


ROSCOE interface com funções utilizadas como interface com o sistema
operacional.

Time Sharing Option, interface para processamento on-line, com


TSO
funções utilizadas como interface com o sistema operacional.

Reflexão
“Para adquirir conhecimento é preciso estudar, para adquirir sabedoria é preciso
observar.”
William Arthur Ward
JCL

Sistema operacional do Mainframe


O sistema operacional OS/390 (ou z/OS) utiliza caractere, muito diferente do gráfico que
suporta a elaboração de imagens bonitas. O sistema operacional em “estado bruto” da
forma como é entregue pela IBM, ocupa cerca de 18 CDs de instalação.
A instalação do sistema operacional feita por um bom especialista em suporte operacional
pode levar longos dias até chegar ao “modus operandi”. Existe uma série longa de
parâmetros que devem ser selecionadas e customizadas de acordo com a padronização da
empresa, o perfil dos funcionários, a definição dos grupos de acesso, a instalação de
aplicativos, a customização das redes internas e externas, a escalação de segurança etc.
Isso tudo permite dizer que o OS/390 é realmente um sistema operacional radicalmente
corporativo.

O que é sistema operacional


Um sistema operacional, ou sistema operativo, é um programa ou um conjunto de
programas cuja função é servir de interface entre um computador e o usuário (pessoa que
interage com o computador ou com a aplicação).
A sigla usual para designar esta classe de programas é SO (Sistema Operacional, em
português) ou OS (Operating System, em inglês).
Segundo alguns autores, existem dois modos distintos de conceituar um sistema
operacional:
 Pela perspectiva do usuário ou programador, visão Top-Down, de cima para
baixo. O hardware faz o papel de intermediário entre o aplicativo (programa) e os
componentes físicos do computador (hardware).
 Pela visão Bottom-Up, de baixo para cima. É um gerenciador, i.e., que controla
quais aplicações (processos), quando e os recursos do computador (memória,
disco, entre outros dispositivos periféricos) que podem ser utilizados.

Reflexão
“Se quer tirar mel, não espante a colmeia.”
Autor desconhecido

www.carloscamposinfo.com Página 27
História do sistema operacional
Na primeira geração de computadores, aproximadamente entre 1945 e 1955, os
computadores usavam válvulas, e por essa razão eram tão grandes que ocupavam salas
imensas.
Eles não usavam sistemas operacionais e eram os programadores, também operadores,
que controlavam o computador por meio de chaves, fios e luzes de aviso.
A primeira geração de computadores deveu-se à dedicação de pessoas como: Howard
Aiken (Harvard); John von Neumann (Instituto de Estudos Avançados de Princeton); John
Adam Presper Eckert Jr. e William Mauchley (Universidade da Pennsylvania); e Konrad
Zuse (Alemanha).
Na geração seguinte, aproximadamente entre 1955 e 1965, foram criados os sistemas em
lote (batch systems), que permitiram melhor uso dos recursos computacionais. A base do
sistema operacional era um programa monitor, usado para enfileirar tarefas (JOBs). O
usuário foi afastado do computador e cada programa era escrito em cartões perfurados,
que por sua vez eram carregados com o respectivo compilador (normalmente Fortran ou
Cobol), por um operador, que usava uma linguagem de controle chamada JCL (Job Control
Language).
E assim, começou a história da linguagem de controle JCL, que existe até hoje nos
Mainframes.
Os sistemas operacionais desenvolvidos para Mainframes são criados especialmente para
cada modelo com finalidades específicas; seja para processar textos, bancos de dados,
efetuar cálculos ou gerenciar dispositivos, e estão baseados em sistemas próprios, por
exemplo: z/OS, z/VSE, z/VM, z/TPF (da IBM), OS2200, MCP (da Unisys), GCOS (da Bull), e
outros de empresas como Fujitsu, Hitachi e Amdhal.

Reflexão
“Não julgueis segundo a aparência, e sim pela reta justiça.”
João 7:24
JCL

JCL – Job Control Language 2


Este capítulo tem como finalidade apresentar os conceitos básicos do JCL (JOB CONTROL
LANGUAGE), a estrutura dos seus “programas” e os conceitos de ligados à execução de
programas de aplicação em lote (chamados de Batch).

Características e estrutura do mainframe

Job Control Language (JCL) é uma linguagem interpretada usada em Mainframes da IBM
para instruir o sistema operacional a inicializar um subsistema ou executar um programa
de lote.
A sigla JCL também pode ser usada genericamente para se referir a qualquer linguagem
que realize as mesmas funções, tais como a WFL, da empresa Burroughs, ou a OCL, da ICL.
A IBM possui duas linguagens JCLs: uma para sistemas operacionais iniciada com o
DOS/360 e cujo último membro é o z/VSE; e a outra para as linhas dos sistemas
operacionais que vão do OS/360 ao z/OS. Ambas possuem em comum alguns conceitos e
regras básicas de sintaxe, mas em geral são bastante diferentes.
Neste livro será tratada especificamente a linguagem JCL da IBM para as linhas dos
sistemas operacionais que vão do OS/360 ao z/OS.
A sintaxe da linguagem é caracterizada por um par de barras (//) que indicam o início de
cada instrução. Essa notação existe desde a década de 1960 no uso de cartões perfurados
e mantém a compatibilidade da linguagem desde a sua criação. A função original das
barras era assegurar que o cartão perfurado estivesse posicionado corretamente no leitor:
caso elas não fossem lidas logo no começo da instrução, todo o cartão seria rejeitado.
Outro conceito mantido é o tamanho dos comandos JCL, armazenados em registros de 80
bytes, o que equivale a um cartão.

Reflexão
“A menos que admita a existência de Deus, a questão sobre propósito de vida não
tem sentido.”
Bertrand Russell

www.carloscamposinfo.com Página 29
A unidade básica de trabalho é o Job (serviço). Um job consiste em um ou vários passos,
cada qual sendo uma requisição para um programa específico. Por exemplo, imagine o
seguinte processo responsável por criar um relatório impresso com os seguintes passos:
um programa para selecionar os registros apropriados e copiá-los para um arquivo
temporário; outro para organizar esses dados sob um determinado critério; e outro para
apresentar as informações ao usuário final.

Introdução ao JCL
Existem pessoas que interagem com o computador por meio de um serviço fornecido por
um sistema (aplicação). Por exemplo: obter o extrato da conta corrente. Neste caso, a
pessoa, como usuário do sistema de conta corrente, aciona a opção correspondente e
obtém, imediatamente, no monitor ou no papel, a movimentação da sua conta. A esse
tipo de processo dá-se o nome de processo on-line, onde a pessoa, chamada de usuário,
solicita a execução de uma determinada funcionalidade e recebe no mesmo instante a
resposta da máquina.
Mas existe o tipo de processamento que executa programas com a missão de processar
dados sem a intenção de mostrá-lo ao usuário. O objetivo é preparar dados, atualizar
arquivos ou emitir relatórios para quando o usuário pedir a execução, por exemplo, da
funcionalidade “listar movimentação” possa obter e ver o resultado atualizado
imediatamente. A esse tipo de processamento dá-se o nome batch.
O processamento batch é administrado pelos operadores, que se encarregam de manter,
supervisionar e garantir a execução dos programas e a integridade dos dados. Essas
execuções, normalmente, acontecem durante a noite, para que o sistema possa fornecer,
no dia seguinte, os dados corretos aos usuários.
Para executar e administrar uma quantidade enorme de programas e arquivos de dados é
necessária uma linguagem para a comunicação entre o usuário (operador) e o sistema
operacional, para que este fique “sabendo” quais as necessidades particulares de cada
usuário e como efetuar a distribuição de recursos. Quem possibilita a execução e
administração deste processamento é a linguagem JCL (JOB CONTROL LANGUAGE).
JCL é uma linguagem de controle de serviços e tem como objetivo descrever os serviços
que devem ser realizados, a sequência de execução dos programas e os arquivos
necessários para executar o respectivo serviço, além dos parâmetros que permitirão ao
sistema operacional do Mainframe dimensionar o volume de recursos necessários para a
realização do serviço.
JCL

O que é JCL
JCL significa linguagem de controle de serviço, que é composta por instruções, mais
conhecidas como cartões, que depois de codificadas são utilizadas pelo sistema
operacional para dirigir a execução de programas.
Qualquer Mainframe IBM utiliza o JCL para executar processos batch, porém o formato
poderá variar de acordo com a empresa.
A codificação das instruções JCL, os programas a serem executados e os arquivos de dados
utilizados no processamento, constituem um serviço, ou seja, um JOB.
As instruções JCL descrevem o que o sistema operacional deve fazer:
 Especifica a prioridade de execução do JOB.
 Pode condicionar a continuidade do fluxo de execução ou de um determinado
passo do processamento.
 Identifica o nome do programa ou procedure a ser executado.
 Identifica o arquivo que o programa quer trabalhar (ler ou gravar) e o relaciona
com sua execução.
 Especifica os dispositivos e as memórias auxiliares para a execução do programa
ou utilitário.

Submete


JES interpreta o JCL e passa
para S.O.

Saída
S.O. executa o serviço

JES agrupa as saídas e


informações sobre o JOB

Reflexão
“Não te furtes de fazer o bem a quem de direito, estando na tua mão o poder de
fazê-lo.”
Salomão. Sl 3: 27

www.carloscamposinfo.com Página 31
Estrutura da linguagem
'O JCL é uma linguagem estruturada que executa as tarefas solicitadas de modo sequencial
e pode ser controlada por meio de parâmetros. A linguagem está dividida em três grandes
programas que gerenciam a sua execução. São elas:
 JOB MANAGEMENT.
 TASK MANAGEMENT.
 DATA MANAGEMENT.

JOB MANAGEMANT
JOB MANAGEMENT é o programa responsável por receber e expedir os serviços
solicitados e gerenciar os recursos necessários para a execução de cada atividade
solicitada. O gerenciamento é feito individualmente para cada etapa chamada de STEP. É
por meio do comando JOB que é informado ao JOB MANAGEMENT o início de um novo
serviço.

TASK MANAGEMENT
TASK MANAGEMENT é também chamado de Supervisor, porque é responsável por
administrar o espaço de memória da CPU, das interrupções etc. Uma TASK é um serviço
solicitado pela execução de um programa, também definido como uma unidade de
trabalho da CPU. É por meio do comando EXEC que é informado ao TASK MANAGEMENT
qual o programa (PROCEDURE) vai ser executado.

DATA MANAGEMENT
DATA MANAGEMENT é o componente responsável por todas as operações em arquivos.
Administra a abertura, o fechamento, o volume necessário (EOV) e o fim do arquivo (EOF).
É por meio do comando DD, que é informado à DATA MANAGEMENT quais são os
arquivos que o programa vai utilizar.

Sistema
Operacional
JOB TASK DATA
MANAGEME MANAGEME MANAGEME
NT NT NT
JOB EXEC DD
JCL

O que é um JOB
Dá-se o nome de JOB a um programa, script, escrito na linguagem JCL para executar um
ou mais programas, utilitários, de forma serial. JOB é a unidade máxima de execução. O
JOB é codificado segundo instruções e é mais conhecido como cartões, com uma regra
rígida de posicionamento na linha, assim como faz o COBOL. O JOB, obrigatoriamente,
deve começar com a instrução de nome JOB. Popularmente, o nome da instrução JOB é
utilizado para identificar um “programa” em JCL.

O que é um STEP
Cada unidade de execução de um JOB, programa ou utilitário, que é comandado pela
execução do cartão (comando) EXEC, dá-se o nome de STEP.

Estrutura de um JOB
O JOB, obrigatoriamente, é identificado pelo cartão (comando) JOB, que identifica o início
do programa (script), da mesma forma que o programa COBOL precisa ter a divisão
IDENTIFICATION DIVISION.

//NMJOB01A JOB PARM1, PARM2


//*==================================
//* STEP 01 - EXCLUIR ARQUIVO
Cartão
//*================================== identificador do
//NMSTEP1A EXEC PGM=IDCAMS JOB.
//SYSPRINT DD SYSOUT=* Nesse caso, o
//SYSIN DD * nome do JOB é
“NMJOB01A”
DELETE (AD.CJEC.ARQNOV1A)
//

Cartão identificador de uma unidade de execução, o STEP.


Neste caso, o nome do STEP é “NMSETP1A”

O STEP de nome “NMSETP1A” executa o utilitário “IDCAMS”

www.carloscamposinfo.com Página 33
Regras de codificação
Um JOB é codificado cartão a cartão (instrução a instrução ou comando a comando).
Por quê?
Porque o objetivo do JOB é dirigir a execução de programas e utilitários.
Então, cada passo do JOB é uma execução de um programa ou utilitário.
E como cada instrução é um cartão, temos:
 Todo o cartão deve ser especificado, descrito, numa linha com tamanho máximo
de 80 caracteres.
 Toda a instrução deve estar codificada entre as posições 4 e 72.
 Para que os parâmetros de uma instrução possam continuar na linha seguinte é
preciso terminar a linha com uma vírgula “,”.
 Se for suprimir um parâmetro obrigatório, deve-se usar uma vírgula para indicar a
ausência.
 O nome da instrução (cartão) deve ter de um a oito caraceres e deve começar por
um caractere alfanumérico ou pelos caracteres: $, @ e #.

Identificador Área de Área de


Área de indicação Separador
de cartão programação comentário
3 a 10
1a2 (com exceções) 11 12 a 72 73 a 80
Espaço:
se existirem
informações, indica que
são parâmetros de uma
instrução.
Se o restante da linha à
direita estiver vazia,
significa fim do JOB. Codificação da Numeração
// Espaço instrução com seus
* – junto com duas parâmetros sequencial
barras indica que o que
está à direita é
comentário.

Conjunto de até oito


letras – indica o nome
do cartão.
Observação: essa é a nossa orientação para que o JOB possa ter sua codificação
organizada e facilmente entendida, visualmente, por todos os envolvidos.
JCL

Estrutura da linha de codificação


Um programa JCL possui estrutura bem definida e é composto por linhas que possuem
uma estrutura bem definida, assim como existe no programa COBOL.
A linha possui a seguinte estrutura:

//NOME COMANDO PARÂMETRO COMENTÁRIO

// Indica que é uma linha de comando.

Nome que identifica o comando (instrução). É um texto livre que


NOME deve ter no máximo oito (8) caracteres alfanuméricos (letras e
números). Deve começar por uma letra.

[ ] Símbolo que significa um ou mais espaços (caracter branco).

COMANDO Nome do comando (instrução, conhecido também como cartão).

PARÂMETRO Parâmetros do comando (instrução).

COMENTÁRIO Comentário posicional na mesma linha do comando.

Vejamos o exemplo de um cartão JOB para demonstrar como é uma linha de comando:

//JCL1001A JOB 'CJEC',CLASS=A

Primeiro, a linha começa com // porque todo o comando deve começar obrigatoriamente
com as duas barras. Obrigatório nas colunas um e dois.
Segundo, junto com as duas barras existe JCL1001A, que identifica o nome do cartão JOB.
Neste caso, que é cartão JOB, o nome deve ficar juntinho com as duas barras.
Terceiro, após JCL1001A, existe um espaço, que é um separador.
Quarta, após o espaço, existe JOB, que é um comando, e após, um espaço.
Quinto, existe dois parâmetros do cartão JOB separados por vírgula 'CJEC',CLASS=A.

www.carloscamposinfo.com Página 35
Regras para uso de comentários
Um JOB pode possuir comentários. Os comentários podem ocupar a linha toda ou uma
parte, neste caso, eles devem estar sempre à direita do comando. À direita do comentário
não pode existir mais nada a não ser comentário.

Declaração //*
Para codificar um comentário é necessário utilizar a combinação dos caracteres “//*”
(duas barras inclinadas para a direita seguido de um asterisco).

Comentar uma linha inteira


O comentário pode ser estendido para toda a linha, neste caso, os caracteres de controle
devem começar na primeira posição da linha.

Exemplo de comentário de linha


....|....1....|....2....|....3....|....4....|....5....|....6....|....7..
//* *******************************************************************
//* LINHA DE COMENTARIO *
//* *******************************************************************

Observar que a primeira linha representa a régua com a escala posicional para que se
visualize as posições nas linhas, e sempre será esta a sua função.
Neste exemplo, a linha começa com //*, por esse motivo toda a linha é um comentário.

Comentar um pedaço de linha


O comentário também pode ser inserido na parte final de cada linha. Neste caso, após o
comentário não poderá existir nada mais do que comentário.

Exemplo de comentário numa posição


....|....1....|....2....|....3....|....4....|....5....|....6....|....7..
//STEP01 EXEC PGM=IDCAMS //* IDCAMS EH O NOME DO UTILITARIO//*

Neste exemplo, o comentário começa na posição 29, e a partir daí o restante da linha é
um comentário.

Reflexão
“Ser subdesenvolvido não é "não ter futuro"; é nunca estar no presente.”
Arnaldo Jabor
JCL

Regras de continuação
O comando (cartão) pode ser definido em mais de uma linha, mas para isso é preciso
terminar a linha do parâmetro com uma vírgula “,”. Os parâmetros devem começar a ser
escritos entre as colunas quatro (4) e dezesseis (16).
Um parâmetro pode ser composto de vários outros parâmetros desde que estejam
colocados entre parênteses ().
....|....1....|....2....|....3....|....4....|....5....|....6....|....7.
//RELAT004 DD DSN=AD.RELAT004,
// DISP=(NEW,CATLG,DELETE),
// DCB=(LRECL=133,RECFM=FB),
// SPACE=(TRK,(10,10),RLSE),
// UNIT=SYSWRK

Primeiro, a linha do comando DD começa com //RELAT004.


Segundo, depois da primeira linha existem mais quatro linhas com parâmetros do
comando.
Terceiro, a quinta e última linha termina sem a vírgula porque significa o fim do comado.
Quarto, as linhas dois, três e quatro terminam com a vírgula porque significa que existem
mais parâmetros do comando.

Como é executado um JOB


Todo JOB é um arquivo-fonte, como se fosse a fonte de um programa, por exemplo,
COBOL, e por esse motivo precisa ter um nome.
Um JOB é executado de forma interpretativa pelo JCL, sendo desnecessário a sua
compilação e link de edição, como é feito com a linguagem de programação COBOL.

JES – Job Entry Subsystem


Antes que um JOB possa ser interpretado e executado, ele deve ser submetido e
enfileirado, e quem faz isso é o subsistema JES2.
JES2 é a mais nova versão do subsistema do JCL que administra a execução do JOB. É ele
que possui rotinas de manipulação e análise do JCL. Isso quer dizer que nenhum serviço
pode ser apresentado ao sistema operacional sem ter passado pelo JES.

Reflexão
“Só é livre o homem que sabe dar ordens a si mesmo.”
Pitágoras

www.carloscamposinfo.com Página 37
Entrada de JOB
Quando um JOB é submetido
(execução), ele é enfileirado num
arquivo especial chamado de
SPOOL de entrada.
SPOOL é um arquivo especial em
Fila de JOBs submetidos para execução
disco onde fica o JOB e os dados
utilizados no cartão SYSIN, que DC@51Z23
são controlados pelo JES.
Quando a execução do JOB cria CB@39Z76
saída de dados, mensagens ou
relatórios, por exemplo, eles são
direcionados ao SPOOL de saída. Uma vez no SPOOL de saída, as informações podem ser
vistas ou impressas.
Todo JOB deve ter uma classe, pois é a partir da sua classificação que é chamado a ser
executado.
À medida que os JOBs são submetidos, eles são validados quanto à sua sintaxe. Se a
sintaxe estiver correta, então o JOB é enfileirado para aguardar sua seleção para ser
executado. Se houver erro na sua sintaxe, o JOB e as mensagens de erro são armazenados
num arquivo específico indicado pelo parâmetro SYSOUT para que possam ser
recuperados e exibidos posteriormente.

Execução de JOB
Para que o JOB possa ser executado, é necessário que esteja enfileirado num arquivo
especial chamado SPOOL de entrada. A escolha do JOB a ser executado pode depender de
várias considerações, isto é, da configuração de cada instalação.
Uma das regras para a prioridade na seleção é a classe do JOB. Todo JOB deve ter uma
classe, porque é a partir da sua classificação que ele é chamado a ser executado.

Reflexão
“Todo o homem que encontro é superior a mim em alguma coisa. E, neste
particular, eu aprendo com dele.”
Emerson
JCL

Exemplo de JOB com um STEP


....|....1....|....2....|....3....|....4....|....5....|....6....|....7..
//JOB1001A JOB 'CJEC',CLASS=A
//*=====================================================================
//* CRIA UM ARQUIVO VAZIO =
//*=====================================================================
//STEP01 EXEC PGM=IDCAMS //* IDCAMS EH O NOME DO UTILITARIO
//SYSPRINT DD SYSOUT=*
//SAIDA DD DSN=ST.CJEC.ARQ.NOV1007A,
// DISP=(NEW,CATLG,DELETE),
// DCB=(LRECL=30,RECFM=FB), Cartão identificador do JOB.
//
//
SPACE=(TRK,(10,10),RLSE),
UNIT=SYSDA
Nome do JOB é “JOB1001A”
//SYSIN DD *
REPRO IDS(NULLFILE) REUSE OFILE(SAIDA)
//

Exemplo de JOB com dois STEPs


....|....1....|....2....|....3....|....4....|....5....|....6....|....7..
//JOB1002A JOB 'CJEC',CLASS=A
//*=====================================================================
//* CRIA UM ARQUIVO VAZIO =
//*=====================================================================
//STEP01 EXEC PGM=IDCAMS //* IDCAMS EH O NOME DO UTILITARIO
//SYSPRINT DD SYSOUT=*
//SAIDA DD DSN=ST.CJEC.ARQ.NOV2001A,
// DISP=(NEW,CATLG,DELETE),
// DCB=(LRECL=30,RECFM=FB),
// SPACE=(TRK,(10,10),RLSE),
// UNIT=SYSDA
//SYSIN DD * STEP UM (passo 1)
REPRO IDS(NULLFILE) REUSE OFILE(SAIDA)
//*
//STEP02 EXEC PGM=IDCAMS //* IDCAMS EH O NOME DO UTILITARIO
//SYSPRINT DD SYSOUT=*
//SAIDA DD DSN=ST.CJEC.ARQ.NOV2002A,
// DISP=(NEW,CATLG,DELETE),
// DCB=(LRECL=30,RECFM=FB),
// SPACE=(TRK,(10,10),RLSE),
// UNIT=SYSDA
//SYSIN DD * STEP DOIS (passo 2)
REPRO IDS(NULLFILE) REUSE OFILE(SAIDA)
//

NULLFILE será abordado mais adiante no item “Opção NULLFILE”

Reflexão
“Só é lutador quem sabe lutar consigo mesmo.”
Carlos Drummond de Andrade

www.carloscamposinfo.com Página 39
Saída de JOB
Quando um JOB é executado, ele pode precisar emitir mensagens do sistema e exibir
mensagens do próprio programa. Para ambas as situações, as mensagens são direcionadas
para uma área chamada SPOOL de saída, identificada no JCL pelo parâmetro SYSOUT.
Existem várias subáreas específicas para receber mensagens específicas. Por exemplo:
 JESJCL = recebe o JOB expandido gerado pelo JES2.
 JESMSGLG = recebe o resultado da pré-compilação gerada pelo JES2.
 JESYSMSG = recebe a estatística da pré-compilação gerada pelo JES2.
 SYSIN = recebe os dados que vão servir de entrada para a execução do programa
ou utilitário.
 SYSOUT = recebe as mensagens geradas pelo JCL referente à execução do
programa ou utilitário.
 SYSPRINT = recebe as mensagens geradas pelo programa ou utilitário.
 SYSUDUMP = recebe as mensagens pelo JCL referente ao DUMP.
A saída de um JOB é diferente dos arquivos de entrada ou de saída utilizados no STEP. No
caso, as informações geradas pela execução do JOB ou do STEP podem ser direcionadas
para visualização eletrônica ou ser diretamente impressas numa impressora.
Este direcionamento se dá na classificação do parâmetro SYSOUT, que será abordado mais
adiante.

Saída da execução do JOB com um STEP

RETURN CODE da execução Número da execução do JOB.


do STEP e do JOB Atribuído automaticamente pelo JCL
JCL

Saída da execução do JOB com dois STEPs

RETURN CODE da execução Número da execução do JOB.


dos dois STEPs e do JOB Atribuído automaticamente pelo JCL

Mensagem da execução do job com um STEP


Saída da execução do JOB na SPOOL de saída com o JOB e as mensagens do que ocorreu
na execução.

1 //JOB1001A JOB 'CJEC',CLASS=A


2 //*=====================================================================
3 //* CRIA UM ARQUIVO VAZIO =
4 //*=====================================================================
5 //STEP01 EXEC PGM=IDCAMS //* IDCAMS EH O NOME DO UTILITÁRIO
6 //SYSPRINT DD SYSOUT=*
7 //SAIDA DD DSN=ST.CJEC.ARQ.NOV1007A,
8 // DISP=(NEW,CATLG,DELETE),
9 // DCB=(LRECL=30,RECFM=FB),
10 // SPACE=(TRK,(10,10),RLSE),
11 // UNIT=SYSDA
12 //SYSIN DD *
14 // Código do JOB executado
**** EXECUTION SUMMARY -----------------------------------------------------

10:56:50 JCLCM0188I JOB STARTED

10:56:50 JCLCM0190I STEP STARTED STEP01


SYS2012.S0824.S105650.J01033.D00001.SYSPRINT SYSPRINT
C:\MFUSER\PROJECTS\JCLTB01A\DATA\S0000054.DAT SPOOLED
ST.CJEC.ARQ.NOV1007A SAIDA
C:\MFUSER\PROJECTS\JCLTB01A\DATA\S0000055.DAT CATALOGED
SYS2012.S0824.S105650.J01033.D00002.SYSIN SYSIN
C:\MFUSER\PROJECTS\JCLTB01A\DATA\S0000056.DAT DELETED
---> 10:56:50 JCLCM0191I STEP ENDED - RC(0000)

---> 10:56:50 JCLCM0182I JOB ENDED - RC(0000)

www.carloscamposinfo.com Página 41
Saída da execução do JOB na SPOOL de saída com o JOB e as mensagens do que ocorreu
na execução.

1 //JOB1002A JOB 'CJEC',CLASS=A


2 //*=====================================================================
3 //* CRIA UM ARQUIVO VAZIO =
4 //*=====================================================================
5 //STEP01 EXEC PGM=IDCAMS //* IDCAMS EH O NOME DO UTILITARIO
6 //SYSPRINT DD SYSOUT=*
7 //SAIDA DD DSN=ST.CJEC.ARQ.NOV2001A,
8 // DISP=(NEW,CATLG,DELETE) ,
9 // DCB=(LRECL=30,RECFM=FB),
10 // SPACE=(TRK,(10,10),RLSE),
11 // UNIT=SYSDA
12 //SYSIN DD *
14 //*
15 //STEP02 EXEC PGM=IDCAMS //* IDCAMS EH O NOME DO UTILITARIO
16 //SYSPRINT DD SYSOUT=*
17 //SAIDA DD DSN=ST.CJEC.ARQ.NOV2002A,
18 // DISP=(NEW,CATLG,DELETE),
19 // DCB=(LRECL=30,RECFM=FB),
20 // SPACE=(TRK,(10,10),RLSE),
21 // UNIT=SYSDA
22 //SYSIN DD *
24 //

**** EXECUTION SUMMARY -----------------------------------------------------

11:34:59 JCLCM0188I JOB STARTED


Execução do STEP01
11:34:59 JCLCM0190I STEP STARTED STEP01
SYS2012.S0824.S113459.J01039.D00001.SYSPRINT SYSPRINT
C:\MFUSER\PROJECTS\JCLTB01A\DATA\S0000066.DAT SPOOLED
ST.CJEC.ARQ.NOV2001A SAIDA
C:\MFUSER\PROJECTS\JCLTB01A\DATA\S0000067.DAT CATALOGED
SYS2012.S0824.S113459.J01039.D00002.SYSIN SYSIN
C:\MFUSER\PROJECTS\JCLTB01A\DATA\S0000068.DAT DELETED
---> 11:34:59 JCLCM0191I STEP ENDED - RC(0000)

11:34:59 JCLCM0190I STEP STARTED STEP02


SYS2012.S0824.S113459.J01039.D00003.SYSPRINT SYSP RINT
C:\MFUSER\PROJECTS\JCLTB01A\DATA\S0000069.DAT SPOOLED
ST.CJEC.ARQ.NOV2002A
C:\MFUSER\PROJECTS\JCLTB01A\DATA\S0000070.DAT CATALOGED
SYS2012.S0824.S113459.J01039.D00004.SYSIN SYSIN
C:\MFUSER\PROJECTS\JCLTB01A\DATA\S0000071.DAT DELETED
---> 11:35:00 JCLCM0191I STEP ENDED - RC(0000)

---> 11:35:00 JCLCM0182I JOB ENDED - RC(0000)


Execução do STEP02

Situação da execução do JOB de nome JOB1002A


JCL

Identificando a situação de execução de um JOB


O término e execução de um JOB podem ser normais ou anormais (ABEND).
A situação do JOB vai depender da situação da execução de cada unidade, e serve para
indicar o resultado da execução do processo como um todo. O que importa mesmo é a
execução de cada um dos passos, STEPs, que estão no JOB.

Situação final de execução do STEP


Quando o STEP é executado, é acionado um utilitário ou um programa de aplicação.
Quando um programa termina sua execução, ele envia para o sistema operacional um
número denominado RETURN-CODE (eventualmente referenciado como COND CODE)
para que o JCL possa identificar qual a situação da execução desse programa.
O valor da variável do sistema RETURN-CODE é transferido para a variável COND do JCL. A
variável COND está associada à execução do comando (cartão) EXEC.

Fim normal da execução do STEP


Um programa termina normalmente com RETURN-CODE igual a zero, mas pode possuir
algumas variações; automaticamente, o sistema se encarrega de atualizar a variável.
Mas existe a possibilidade de que cada programa possa atribuir um valor que esteja de
acordo com o interesse do sistema. Neste caso, antes que o programa termine, é
necessário movimentar o valor adequado ao tipo de erro ocorrido.
Exemplo de movimentação possível para o programa nas seguintes linguagens:

COBOL : MOVE 4 TO RETURN-CODE


Assembler : L 15,=F'4'
PL/I : CALL PLIRETC (4);
Easytrieve : RETURN-CODE = 4

Após a movimentação do valor para a variável, o programa deve emitir o comando


(instrução) que termina a execução de forma normal, conforme sua linguagem:

COBOL : STOP RUN ou GOBACK


Assembler : BR 14 ou RETURN
PL/I : RETURN ou END;
Easytrieve : STOP (explícito ou implícito)

Que valores o RETURN-CODE pode ter para indicar fim de execução normal fora o zero?
Isso depende do que está sendo executado.
Analisemos, por exemplo, a execução do aplicativo de compilação seguida pelos links
edição e execução.

www.carloscamposinfo.com Página 43
Vejamos como fica a situação de término para a compilação COBOL:
 Se não houver nenhum erro de compilação, a execução termina com return-code
igual a zero.
 Se houver erro simples, que não impede a execução do aplicativo de compilação,
a execução termina com return-code igual a 4.
 Se houver erro de maior severidade, que impede a execução do aplicativo de
compilação, a execução termina com return-code igual a 8.
 Se houver erros mais graves, a execução termina com return-code igual a 12 ou
16.
Após a execução desta etapa, o sistema operacional, analisa o RETURN-CODE da
compilação, antes de iniciar a execução do link editor, e pode determinar se as execuções
restantes, link edição e execução do programa, devem prosseguir ou não.
Vejamos como fica a situação de término para a link edição COBOL:
 Se não houver nenhum erro de link edição, a execução com return-code fica igual
a zero.
 Se houver algum erro, dependendo de sua severidade, a execução é terminada
com return-code igual a 4, ou 8, ou 12, ou 16.
Após a execução desta etapa, o sistema operacional analisa o RETURN-CODE do link
edição antes de iniciar a execução do programa, e pode determinar se ela deve ser
iniciada ou não.
Esta variação permite estabelecer uma relação de dependência para a execução
sequencial de diversos programas, na qual, quando um deles terminar em condições que
podem prejudicar os subsequentes, a execução dos seguintes pode ser “pulada”. Nos
casos dos programas, o valor de RETURN-CODE deve ser comandado pelo próprio
programa.

Fim anormal da execução do STEP


Assim como um programa pode terminar normalmente, também pode terminar de forma
anormal.
A forma anormal indica que houve algum tipo de erro, e se a execução iniciar ou
continuar, haverá com certeza algum tipo de problema no processo que se refletirá no
negócio. Por tudo isso, a partir da avaliação do valor do RETURN-CODE é que se poderá
determinar se o processamento continua ou para.
Ao término de execução anormal, dá-se o nome de ABEND (ABnormal END). Há dois tipos
de ABEND: os programados e os não programados.

ABEND programado
O ABEND programado é gerado pelo programa da aplicação por decisão da aplicação,
usuário do sistema, por ter detectado alguma condição anormal, que irá causar danos à
execução de todos os programas subsequentes e, eventualmente, dos JOBs subsequentes.
JCL

Nestes casos, o programa atualiza o RETURN-CODE com o valor indicativo do erro


ocorrido.
ABEND programado é identificado por um código (Unnnn), onde:
 A letra U identifica o erro gerado pelo aplicativo (Usuário do sistema), e
 Os quatro nnnn são um número de 0 a 4095.
Cada aplicação (aplicativo, sistema) define a numeração de cada erro previsto.
Por exemplo: um programa precisa ler registros de um arquivo do departamento 435. Se
for encontrado algum registro que não seja do referido departamento o processo precisa
parar porque existe alguma falha e se continuar poderá causar grandes danos aos dados e
deixar a aplicação num estado inconsistente. Neste caso, o erro ocorrido não iria interferir
no RETURN-CODE, que seria zero, e o processo continuaria, a menos que se determinasse
que o programa terminasse com o código 4091.

ABEND não programado


O ABEND não programado é gerado pelos componentes externos ao programa, e é
identificado por um código (Sxxx), onde:
 A letra S identifica que foi decisão do sistema, e
 Os três xxx indicam um código que possibilita identificar a anormalidade ocorrida
a partir de uma tabela preestabelecida.
Exemplo de código bem conhecido:
S0C7 = é um ABEND provocado pelo sistema. É quando ele detecta a tentativa de executar
uma instrução que manipula dados que deveriam estar no formato decimal compactado,
mas que estão em outro formato incompatível, por exemplo, caractere.

Reflexão
“O respeito próprio é uma resposta aprendida das experiências da vida.”
Nancy Van Pelt em Filhos Vencedores

www.carloscamposinfo.com Página 45