Introdução ao JCL

DEFINIÇÃO DE UM JOB

Um job (serviço) é composto por um ou mais programas que serão

processados dentro de uma seqüência. Se esta seqüência for quebrada por
alguma anormalidade, interrompe-se o fluxo, repara-se o erro e faz a retomada.
Uma interrupção causada pelo programa chamamos de ABEND. Esta retomada
(ou restart) poderá ser feita desde o início, a partir do ponto que houve a
ocorrência, em algum ponto anterior do Job, ou até mesmo de algum job anterior.
Pode também ser necessário a recuperação de algum arquivo que tenha sido o
causador do término anormal. Um seqüência de jobs em cadeia chamamos de
rotina.

Observações muito importantes sobre um JOB:

•Um job é composto de pelo menos um programa.

•Este programa poderá ser um desenvolvido na empresa ou até mesmo um
utilitário.
•Um job SEMPRE (obrigatoriamente) começa com um cartão ‘JOB’, que irá se
‘apresentar’ para o sistema operacional e disponibilizar as filas e
prioridades dentro do sistema
•A cada programa ou utilitário denominamos STEP.
•Cada step é representado por um cartão chamado ‘EXEC’.
•O cartão EXEC é responsável por chamar o programa compilado e
linkeditado. (Podendo ser também um utilitário)
•Dentro de cada cartão EXEC teremos cartões ‘DD’ que irão disponibilizar os
dispositivos necessários para o funcionamento do programa.

DESENHO BÁSICO DE UM JOB

//XXXXXXX JOB XXXXXXXXXXXXXXXXXXXXXXX

//XXXXXXX EXEC XXXXXXXXXXXXXXXXXXXXXX
//XXXXXXX DD XXXXXXXXXXXXXXXXXXXXXXX
//XXXXXXX DD XXXXXXXXXXXXXXXXXXXXXXX
//XXXXXXX DD XXXXXXXXXXXXXXXXXXXXXXX
//XXXXXXX.....EXEC XXXXXXXXXXXXXXXXXXXXXXX
//XXXXXXX DD XXXXXXXXXXXXXXXXXXXXXXX
//XXXXXXX DD XXXXXXXXXXXXXXXXXXXXXXX
//XXXXXXX DD XXXXXXXXXXXXXXXXXXXXXXX
//XXXXXXX.....DD XXXXXXXXXXXXXXXXXXXXXXX
//XXXXXXX.....EXEC XXXXXXXXXXXXXXXXXXXXXXX
//XXXXXXX DD XXXXXXXXXXXXXXXXXXXXXXX
//XXXXXXX DD XXXXXXXXXXXXXXXXXXXXXXX
//XXXXXXX DD XXXXXXXXXXXXXXXXXXXXXXX
//XXXXXXX.....DD XXXXXXXXXXXXXXXXXXXXXXX

Pág: 2
//XXXXXXX.....EXEC XXXXXXXXXXXXXXXXXXXXXXX
//XXXXXXX DD XXXXXXXXXXXXXXXXXXXXXXX
//XXXXXXX DD XXXXXXXXXXXXXXXXXXXXXXX
//XXXXXXX DD XXXXXXXXXXXXXXXXXXXXXXX
//XXXXXXX.....DD XXXXXXXXXXXXXXXXXXXXXXX
//
Fig. 02

Repare: temos neste exemplo um Job composto de 4 steps. Estes steps podem
ser programas ‘caseiros’ e/ou utilitários (como o SORT e o IDCAMS) que serão
visto adiante.
Voltando a fig.01 poderá muito bem ser a seqüência 01 tendo um SORT entre os
programas PROG003 e PROG009. Neste caso o PROG003 gerou um arquivo a
ser lido pelo PROG009. Mas antes de utilizar, o PROG009 precisa reclassificar o
arquivo para atender sua regra de negócio.

A FUNÇÃO DO J.C.L.

Quando mencionamos as palavras JOB, EXEC e DD, estamos falando de uma

linguagem: JCL (Job control language ou linguagem de programação de serviços).
A função do JCL é solicitar e informar recursos e dispositivos ao sistema
operacional.
Os cartões JOB, EXEC e DD obrigatoriamente deverão ter um NOME. Este nome
será conhecido como JOBNAME, STEPNAME e DDNAME. São inserido logo
após o ‘//’ e antes do cartão comando.

EXEMPLO DE J.C.L.

Um exemplo típico de um JOB com um step apenas para ilustração.

//GPAE99PG JOB ‘(9983,98,978,09)’,’ANTONIO’,CLASS=6,MSGCLASS=U

//STEP0101 EXEC PGM=MYPROGSS
//ENTR01 DD DSN=GP.GPALU99.CADCLI,DISP=SHR
//SAIDA02 DD DSN=GP.GPALU99.CADENT,DISP=(NEW,CATLG,DELETE),
// UNIT=SYSALLDA,SPACE=(TRK,(5,1),RLSE),
// DCB=(RECFM=FB,LRECL=80,BLKSIZE=0)
//SYSOUT DD SYSOUT=*
//PARM01 DD *
PRINTALL
//*
//STEP0102 EXEC PGM=MYPROGXX,COND=(0,NE)
//ENTR03 DD DSN=GP.GPALU99.CADENT,DISP=SHR
//ENTR04 DD DSN=GP.GPALU99.CADRET,DISP=SHR
//SAIDA03 DD DSN=GP.GPALU99.CADSAI(+1),DISP=(NEW,CATLG,DELETE),

Pág: 3
// UNIT=SYSDA,SPACE=(TRK,(5,1),RLSE),
// DCB=(GDG,RECFM=FB,LRECL=120,BLKSIZE=0)
//RELATO DD SYSOUT=(R,,XPTO)
//

Fig.03

Neste exemplo temos um job com 2 steps apenas que irá executar um programa
chamado ‘MYPROGRSS’ , e terá 2 arquivos de entrada sendo o primeiro em disco
chamado pelo DDNAME ENTR01 e um parâmetro chamado PARM01 E uma
saída chamado pelo DDNAME SAIDA02.
Um outro step irá executar o programa MYPROGXX, que irá ler 2 arquivos e gerar
um terceiro arquivo em GDG.

POSICIONAMENTO DOS CARTÕES DE JCL

-------------------------------------------------------------------------------------------------------
123456789012345678901234567890123456789012345678901234567890123456
7890123--------------------------------------------------------------------------------------------------
---------------------------
//UP0014KR JOB ‘(9983,98,978,09)’,’ANTONIO’,CLASS=6,MSGCLASS=U
//STEP0101 EXEC PGM=MYPROGSS
//ENTR01 DD DSN=GP.GPALU99.CADCLI,DISP=SHR

Os cartões JCL possuem 4 (quatro) divisões em seu comando:

• Colunas 1-2 = cartões ‘//’ (obrigatório)
• Colunas 3-10 = nome do cartão (pode ser JOBNAME, STEPNAME ou
DDNAME)
• Colunas 12-15 = Tipo
• Colunas 16-72 = Comando

É necessário um espaço em branco entre o cardname / comando / cláusula.

Toda cláusula do JCL começa com ‘//’ nas colunas 1 e 2. Exceção apenas quando
vai se inserir massa dados.
-Um job é composto de pelo menos um programa. Este programa poderá ser um
desenvolvido na empresa ou um utilitário.
-Um job SEMPRE (obrigatoriamente) começa com um cartão ‘JOB’, que irá se
‘apresentar’ para o sistema operacional e disponibilizar as filas e prioridades
dentro do sistema
-A cada programa ou utilitário denominamos STEP.
-Cada step é representado por um cartão chamado ‘EXEC’.
-O cartão EXEC é responsável por chamar o programa compilado e linkeditado.
(Podendo ser também um utilitário)

Pág: 4
-Dentro de cada cartão EXEC teremos cartões ‘DD’ que irão disponibilizar os
dispositivos necessários para o funcionamento do programa.

REGRAS BÁSICAS DE J.C.L.

•Não se esqueça que JCL é uma série de comandos que você está passando
para o sistema operacional ‘entender’ o seu programa, como se fossem
parâmetros.
•JAMAIS confunda JCL ERROR com ABEND. O primeiro é erro de sintaxe ou
indisponibilidade de recursos. O segundo é falha de programa que em
alguns casos pode até mesmo ser causado por recursos do sistema.
•Em caso de erro de JCL, o programa em questão não foi executado.
•Os cartões ‘//’ nas colunas 1 e 2 são obrigatórios em todo o JCL, exceto se
houver algum parâmetro a ser passado pelo usuário (opção) ao programa.
(Veja regra 6)
•Existem parâmetros obrigatórios e parâmetros opcionais.
•Com exceção do Account e programer-name do cartão Job, todos os outros
parâmetros possuem o sinal ‘=’. O parâmetros vêm a esquerda e os sub-
parâmetros á direita do sinal.]
•Os sub-parâmetros podem ser 1 ou mais de 1. Quando houver mais de 1 sub-
parâmetro deverá estar entre aspas.
•Se o seu programa tem opção de processamento (ex: listagem total ou
parcial), este opção (que na verdade também é um parâmetro), este poderá
ser ‘passado’ após um cartão DD que contenha o comando ‘DD *’.
•Ao começar numa empresa peça sempre uma cópia da padronização da
empresa. Nem sempre você poder ‘batizar’ seu programa, jobname,
stepname etc com o nome que você quer. Existem regras, com certeza.

Pág: 5
CARTÃO JOB

//GPAE99PG JOB ‘(9983,98,978,09)’,’ANTONIO’,

// CLASS=6,MSGCLASS=U

GPAE99PG – É o JOBNAME. Deverá ter sempre uma padronização estabelecida

pela área de produção da empresa. Procure saber a regra antes de fazer a
denominação. Na G&P é sempre o userid seguido de 2 posições livres.

Regra: Deverá ter de 1 a 8 caracteres (em geral sempre 8), sendo o primeiro
alfabético.
JOB – Nome do cartão de comando – Obrigatório. Sempre entre espaços em
branco.
‘(9983,98,978,09)’: Informe-se com a produção pois isto varia de empresa para
empresa. Pode nem ser obrigatório. Mas se for, deverá ser sempre o primeiro
após o JOB.
‘ANTONIO’ – Programer-name. Obrigatório. Para identificar o nome do usuário.
Se não houver account, vem logo após o comando JOB.
CLASS=Define a classe que será submetida na fila de JOBS.
MSGCLASS=Define a classe de sysout (relatório) onde serão geradas todas as
logs durante o tempo em que o job permanecer no sistema.
MSGLEVEL=(x,y) Define o nível das mensagens que serão exibidas após a
execução do JOB.
• O parâmetro X pode assumir os valores 0, 1 ou 2
• O parâmetro Y pode assumir os valores 0 ou 1
TYPERUN=HOLD|SCAN
Outros parâmetros usados poderão ser requeridos na empresa, mas não são
obrigatório no cartão JOB, tais como TYPRUN, NOTIFY e outros.

O CARTÃO EXEC

É composto do stepname, cartão comando (EXEC) e o nome do programa (ou

utilitário) a ser chamado pelo JOB, após a palavra PGM=.

Pode-se codificar o parâmetro PROC= ou indicar um nome sem qualquer palavra

chave (PGM ou PROC) para chamadas a procedures catalogadas.

PROCEDURE CATALOGADA

Muitas empresas preferem utilizar procedure catalogadas ao invés de JOBS

extensos. É uma opção bem saudável pois evita-se manutenções e permite
passar parâmetros para as procedures. Veja o exemplo de um JOB antes e depois
da conversão em procedure catalogada (ou simplesmente PROC).

Pág: 6
Antes:

//UP0014KR JOB ‘(9983,98,978,09)’,’ANTONIO’,

// CLASS=6,MSGCLASS=U
//STEP0101 EXEC PGM=MYPROGSS
//ENTR01 DD DSN=GP.GPALU99.CADCLI,DISP=SHR
//SAIDA02 DD DSN=GP.GPALU99.CADENT,DISP=(NEW,CATLG,DELETE),
// UNIT=SYSDA,SPACE=(TRK,(5,1),RLSE),
// DCB=(RECFM=FB,LRECL=80,BLKSIZE=0)
//SYSOUT DD SYSOUT=*
//PARM01 DD *
PRINTALL
//*
//STEP0102 EXEC PGM=MYPROGXX,COND=(0,NE)
//ENTR03 DD DSN=GP.GPALU99.CADENT,DISP=SHR
//ENTR04 DD DSN=GP.GPALU99.CADRET,DISP=SHR
//SAIDA03 DD DSN=GP.GPALU99.CADSAI(+1),DISP=(NEW,CATLG,DELETE),
// UNIT=SYSDA,SPACE=(TRK,(5,1),RLSE),
// DCB=(GDG,RECFM=FB,LRECL=120,BLKSIZE=0)
//RELATO DD SYSOUT=(R,,XPTO)

DEPOIS:

O job (chamada) vai executar uma procedure chamada UP01P04 que está na
biblioteca padrão do sistema. Os parâmetros podem ser passados pelo JOB ou
pelo cartão PROC.

//UP0014KR JOB ‘(9983,98,978,09)’,’ANTONIO’,

// CLASS=6,MSGCLASS=U
//PROC001 EXEC UP01P04,CLIENTE=’UP0014’,SAIDA=’CADRET’

A PROCEDURA CATALOGADA

//UP01P04 PROC VOUP=’SHR’

//STEP0101 EXEC PGM=MYPROGSS
//ENTR01 DD DSN=&CLIENTE..GPALU99.CADCLI,DISP=SHR
//SAIDA02 DD DSN=&CLIENTE..GPALU99.CADENT,
// DISP=(NEW,CATLG,DELETE),
// UNIT=SYSDA,SPACE=(TRK,(5,1),RLSE),
// DCB=(RECFM=FB,LRECL=80,BLKSIZE=0)
//SYSOUT DD SYSOUT=*
//PARM01 DD *
PRINTALL
//*
//STEP0102 EXEC PGM=MYPROGXX,COND=(0,NE)
//ENTR03 DD DSN=&CLIENTE..GPALU99.CADENT,DISP=&VOUP

Pág: 7
//ENTR04 DD DSN=&CLIENTE..GPALU99.&SAIDA,DISP=SHR
//SAIDA03 DD
// DSN=&CLIENTE..GPALU99.CADSAI(+1),
// DISP=(NEW,CATLG,DELETE),
// UNIT=SYSDA,SPACE=(TRK,(5,1),RLSE),
// DCB=(GDG,RECFM=FB,LRECL=120,BLKSIZE=0)
//RELATO DD SYSOUT=(R,,XPTO)

O parâmetro PARM=, no cartão EXEC é usado para passar informações para o

programa.

Sintaxe:
//STEP0101 EXEC PGM=MYPROGXX,PARM=’900512’,COND=(0,NE)

Neste caso, o MYPROGSS é um programa que deverá estar na biblioteca padrão

do sistema. Antes de dar OPEN no programa o sistema irá verificar se o
programa realmente existe. Em seguida irá verificar os recursos solicitados pelos
cartões DD para só então dar OPEN no programa e carrega-lo em memória.

Todos os programas ao terminarem, emitem um código de retorno para o sistema

operacional. Se for ‘0’ (zero) significa que terminou OK.
O COND, neste caso será para checar se o(s) step(s) anterior(es) terminou(aram)
ok. Os mais comuns:
(0,NE) – Se todos os steps anteriores terminaram OK, pode processar este step.
(2,LT) – Significa que este step aceita que um os steps anteriores emitam um
return code igual a ‘0’ ou ‘1’.
Regra básica: Comparar os return code anteriores e comparar com o parâmetro.
Se for negativo, execute. Se for positivo não execute. Outros exemplos:
(0,LT) não irá executar nunca pois não existe return code negativo.
(0,EQ) só processa se algum step anterior der return code diferente de ‘0’.
(EVEN) executa mesmo que algum step anterior tenha terminado anormalmente.
(ONLY) executa somente se algum programa tenha terminado anormalmente.

OBSERVAÇÃO: Em caso de erro de JCL o parâmetro COND não é respeitado. A

interrupção ocorre de qualquer forma.

O CARTÃO DD

Acompanhando nosso exemplo, vamos utilizar os cartões para as definições.

Antes porém, é bom lembrar que o cartão DD é utilizado para pedir ao sistema
alocação de recursos físicos (dispositivos) para que o programa seja processado.

Sintaxe:

Pág: 8
//ENTR01 DD DSN=GP.GPALU99.CADCLI,DISP=SHR
//SAIDA02 DD DSN=GP.GPALU99.CADENT,DISP=(NEW,CATLG,DELETE),
// UNIT=SYSDA,SPACE=(TRK,(5,1),RLSE),
// DCB=(RECFM=FB,LRECL=80,BLKSIZE=0)

DDNAME = (ENTR01) Tem que ser o mesmo que você especificou na select do
seu programa. Confira sempre a padronização na sua instalação.

DD = É o nome do cartão-comando.

DSN = Parâmetro que irá dizer ao sistema qual o nome externo do arquivo em
questão. Lembre-se que neste caso você está associando ENTRO1 ao arquivo
UP0014.UP0.CADCLI e SAIDA02 ao arquivo UP0014.UP0.CADENT. O nome
externo é o nome que o sistema conhece o arquivo.

DISP = Informa o status do arquivo no sistema operacional.

Sintaxe:

DISP=(NEW,CATLG,CATLG)
DISP=(SHR,UNCTLG,UNCTLG)
DISP=(OLD,DELETE,DELETE)
......DISP=(NEW,KEEP,KEEP)

PRIMEIRO SUB-PARÂMETRO – STATUS DO ARQUIVO

SHR ---> Significa que o arquivo já existe e pode ser lido por outro recurso
simultâneamente.
OLD ---->Significa que o arquivo já existe e que o programa exige exclusividade
na leitura.
NEW ---->Arquivo novo, a ser criado neste momento.

SEGUNDO E TERCEIRO SUB-PARÂMETRO – AÇÃO A SER TOMADA EM

CASO DE TÉRMINO NORMAL E TÉRMINO ANORMAL RESPECTIVAMENTE.

CATLG --> Catalogue o arquivo. Óbviamente que esta opção deve estar sempre
acompanhada de NEW no primeiro sub-parâmetro. Porque se o arquivo estiver
sendo lido é porque já está catalogado.
UNCATLG --> Descatalogue o arquivo. Evite usar sempre.
DELETE ---> Delete o arquivo. Se precisar deletar o arquivo use sempre esta
opção.
KEEP ---> Mantenha o arquivo do jeito que intacto (do que jeito que estava antes).

LEMBRETES:

-SEMPRE use o modelo da página anterior para entrada/saída.

Pág: 9
-Se o arquivo é de entrada(OLD ou SHR) não precisa especificar demais
parâmetros, pois óbviamente já está catalogado e o sistema saberá
encontrá-lo. Se for de saída você deverá usar os demais parâmetros do
exemplo ENTR02.

Exemplos inválidos:
(SHR,CATLG,DELETE) ---> Se o arquivo é novo (SHR) como irá catalogar se já
está catalogado ? O sistema não recataloga.
(NEW,KEEP,DELETE) ---> Como manter um arquivo que ainda não existe ?

Default:
Se você colocar apenas DISP=SHR o sistema assume (SHR,KEEP,KEEP).

Outros sub-parâmetros:

UNIT= ----> Especifica o tipo de dispositivo onde você criará o arquivo.

Geralmente disco é SYSALLDA. Confira sempre com um funcionário da sua seção
ou com a equipe de produção.

VOL=SER=nome ---- > indica o volume onde reside ou residirá o arquivo. Se

especificarmos um nome genérico para o parâmetro UNIT (ex. SYSALLDA)
durante a criação de um arquivo ou o mesmo estiver catalogado quando for
utilizado com entrada esse parametro poderá ser omitido.

SPACE= ----> Espaço a ser utilizado. Lembre-se que não precisa ser preciso, mas
quanto mais preciso melhor. É uma estimativa. O sistema irá checar se há
disponibilidade para gravar seu arquivo. Se não houver, cancelará.
Sintaxe: SPACE=(TRK,(5,2),RLSE).

Repare que há sub-parâmetro dentro de sub-parâmetro. Neste caso permanece a

regra de utilizar ' ( ) '.
Neste exemplo estamos alocando 5 trilhas (TRK) na alocação primária, 2 trilhas de
alocação secundária e liberando (RLSE) as trilhas não utilizadas. Poderia ser
cilindros (CYL) ao invés de TRK mas não convém sua utilização. Para saber o
número ideal considere que uma trilha comporta aproximadamente 56.000 bytes.
Portanto neste caso estamos alocando 5 trilhas. Se não for suficiente esta
alocação, o sistema alocará mais 2 trilhas (alocação secundária) até 16 vezes
para atender a solicitação. Se ainda não for suficiente o programa cancelará.

DCB= ---> Indica o formato do arquivo a ser gravado. Não necessário para
arquivos a serem lidos, pois o catálogo guarda esta informações.
Sintaxe:
DCB=(RECFM=FB,LRECL=98,BLKSIZE=0)
Obs.: A ordem dos sub-parâmetros não é obrigatória.
Neste exemplo:
Indica que o arquivo é FB (fixo blocado). Confira que o seu programa possui as
cláusulas 'BLOCK 0' e 'RECORD FORMAT IS FIXED'. Outras opções possíveis:

Pág: 10
VB (variável blocado), FBA (fix blocado com caracter de impressão) e F (fixo sem
blocagem. EVITE sempre) e PO (particionado)
O tamanho do registro é 98. Se fosse variável deveria ser o tamanho do maior
registro + 4.
BLKSIZE= ---> Blocagem do registro. É o maior número de bytes trazidos para a
memória de uma só vez. É sempre uma quantidade próxima de 32.000. Deixe
sempre com '0', pois o sistema calcula automáticamente a blocagem ideal.

SYSOUT= ---> Este cartão tem finalidade definir a classe em que o relatório será
impresso. Como as empresas sempre tem mais que uma impressora, diversos
recebedores, diversos tipos de formulários estas informações serão de utilizadas
para fazer estas definições. Neste exemplo o relatório será emitida na classe 5
com tipo de formulário XPTO, que pode ser por exemplo uma fatura.

DDs ESPECIAIS

Comando SYSIN ou ‘DD *’

(PRONUNCIA-SE (DEDÊ ASTERISCO))

Quando se faz necessário passar alguma informação para o programa através de

alguma opção, ou vai se informar algum dado digitado para o programa, isto é
feito através do cartão DD *. Veja o exemplo abaixo:

//STEP0102 EXEC PGM=MYPROGXX,COND=(0,NE)

//ENTR03 DD DSN=GP.GPALU99.CADENT,DISP=SHR
//SAIDA03 DD DSN=GP.GPALU99.CADSAI(+1),DISP=(NEW,CATLG,DELETE),
// UNIT=SYSDA,SPACE=(TRK,(5,1),RLSE),
// DCB=(GDG,RECFM=FB,LRECL=120,BLKSIZE=0)
//SYSIN DD *
DATE=25052002
//

OUTRO EXEMPLO:

//STEP0102 EXEC PGM=MYPROGZZ,COND=(0,NE)

//SAIDA03 DD DSN=GP.GPALU99(+1),DISP=(NEW,CATLG,DELETE),
// UNIT=SYSDA,SPACE=(TRK,(5,1),RLSE),
// DCB=(GDG,RECFM=VB,LRECL=720,BLKSIZE=0)
//ENTR01 DD *
23MARIA RAIMUNDA AV. CASTELO BRANCO, 727, - RICAHO GRANDE
24CLAUDIO ORZIMBO RUA DOS QUIABOS, 432 – VILA MARIA – SALTO
//

Comando SYSOUT DD SYSOUT=* – indica a saída padrão para mensagens

emitidas pelo programa (exemplo DISPLAY).
//STEPLIB DD DSN=UPNGO.LOADLIB,DISP=SHR ou

Pág: 11
//JOBLIB DD DSN=UPNGO.LOADLIB,DISP=SHR

Os cartões STEPLIB e JOBLIB são opcionais. Determinam ao sistema que o

programa chamado pelo cartão exec, no caso do STEPLIB imediatamente
anterior, encontra-se compilado nesta biblioteca, e não na biblioteca default do
sistema. Se usarmos o JOBLIB após o cartão JOB a informação vale para todos
os STEPs do JOB. Isto corre, quando se tem uma biblioteca de testes ou
temporária.
Nota muito importante: ao contrário do que acontece em outras plataformas como
o Windows por exemplo, em que basta um duplo click para que um programa seja
executado, no OS/390 isto não acontece. Um programa só pode ser executado a
partir de uma biblioteca de programas préviamente totalmente controlada pelo
sistema operacional e os programas são compilados um a um. Antes da produção,
os programas passam por dois ambientes de teste e são supervisionadas pelo
Analista, Gerente de Sistemas e validadas pelo gerente de contas da unidade e
pelo Cliente. Uma biblioteca STEPLIB só pode ser usada em casos extremos e
com permissão adequada. Agora você já sabe por que vírus não ataca
mainframes.

CONCATENAÇÃO DE ARQUIVOS

Imagine que você tenha um arquivo de entrada que por um motivo qualquer não
foi processado anteriormente. Ex.: ontem o pessoal da contabilidade não
conseguiu enviar o movimento e por isso o processamento de fluxo de caixa não
foi processado. Neste momento você já poderá processar o job, só que agora
você tem dois arquivos de entrada. O que fazer ? Executar o job duas vezes, uma
para cada arquivo ? Não necessariamente. Você poderá concatenar os dois
arquivos e fazer um só processamento. Veja abaixo.

//STEP0102 EXEC PGM=MYPROGXX,COND=(0,NE)

//ENTR01 DD DSN=GP.GPALU99.FLUXOCX(-1),DISP=SHR
// DD DSN=GP.GPALU99.FLUXOCX(0),DISP=SHR
//SAIDA02 DD DSN=GP.GPALU99.GERAL(+1),DISP=(NEW,CATLG,DELETE),
// UNIT=SYSDA,SPACE=(TRK,(5,1),RLSE),
// DCB=(GDG,RECFM=FB,LRECL=120,BLKSIZE=0)
//RELATO DD SYSOUT=(R,,XPTO)

DICAS GERAIS SOBRE JCL

-Não se esqueça que JCL é uma série de comandos que você está passando para
o sistema operacional ‘entender’ o seu programa, como se fossem parâmetros.

Pág: 12
-JAMAIS confunda JCL ERROR com ABEND. O primeiro é erro de sintaxe ou
indisponibilidade de recursos. O segundo é falha de programa que em alguns caso
pode até mesmo ser causado por recursos do sistema.
-Em caso de erro de JCL, o programa em questão não foi executado.
-Os cartões ‘//’ nas colunas 1 e 2 são obrigatórios em todo o JCL, exceto se
houver algum parâmetro a ser passado pelo usuário (opção) ao programa. (Veja
regra 6)
-Existem parâmetros obrigatórios e parâmetros opcionais.
-Com exceção do Account e programer-name do cartão Job, todos os outros
parâmetros possuem o sinal ‘=’. O parâmetros vêm a esquerda e os sub-
parâmetros á direita do sinal.
-Os sub-parâmetros podem ser 1 ou mais de 1. Quando houver mais de 1 sub-
parâmetro deverá estar entre aspas.
-Se o seu programa tem opção de processamento (ex: listagem total ou parcial),
este opção (que na verdade também é um parâmetro), este poderá ser ‘passado’
após um cartão DD que contenha o comando ‘DD *’.
-Ao começar numa empresa peça sempre uma cópia da padronização da
empresa. Nem sempre você poder ‘batizar’ seu programa, jobname, stepname etc
com o nome que você quer. Existem regras, com certeza
-Assim como no programa, a identação no JCL também é muito importante.
-Nunca deixe de inserir comentário sucinto sobre a finalidade do programa que
você está passando para a produção.
-Para inserir um comentário, basta colocar ‘//*’ nas colunas 1 a 3, ao invés de
simplesmente ‘//’.
-Quando o comando não cabe na mesma linha, deve-se colocar uma vírgula após
o último parâmetro e continuar na linha de baixo, sempre começando com ‘//’ mas
sem cardname.

Pág: 13
OUTROS PARÂMETROS:
-Para se forçar a leitura de um arquivo num determinado dispositivo, como por
exemplo uma fita vinda de cliente externo que não consta no catálogo, ou um
arquivo que está na VTOC de um disco mas não no catálogo, usamos VOL=SER=
Modelo: //ENTRADA DD
DSN=GP.GPALU99.ALUNOS,DISP=SHR,VOL=SER=R00134
-Quando não queremos catalogar um arquivo e usar um arquivo temporário,
usamos no DSNAME o simbolo ‘&&’ antes do nome. O arquivo será deletado, logo
após a execução. Não se recomenda esta utilização. Ex.:
Modelo:

//SAIDA03 DD DSN=&&CADSAI,DISP=(NEW,PASS),
// UNIT=SYSDA,SPACE=(TRK,(5,1),RLSE),
// DCB=(GDG,RECFM=FB,LRECL=120,BLKSIZE=0)

Pág: 14
IF/THEN/ELSE/ENDIF

Comando IF (implementado a partir do OS/390 ou MVS/ESA v4);

Permite a construção de expressões relacionais para teste de condição
em um JOB;

Oferece alternativa de fácil compreensão para o uso do COND;

Sintaxe:

//nome IF condição THEN

step ou steps a executar se a condição for verdadeira
//nome [ELSE
step ou steps a executar se a condição for falsa]
//nome ENDIF

expressão relacional 1

GT
LT
NG
NL [AND]
[step.]RC EQ valor expressão 2 ... expressão n
NE [OR]
GE
LE

[step.]ABEND
[step.]RUN

Exemplo:

//JOBTESTE JOB MSGLEVEL=1,CLASS=A,MSGCLASS=X

//PASSO1 EXEC PGM=IEFBR14
//DD1 DD DSN=GP.GPAE99.PDS2,
// DISP=(OLD,CATLG,DELETE),SPACE=(TRK,(10,5,100)),
// DCB=(LRECL=80,BLKSIZE=0,RECFM=FB),UNIT=DISCO
//*
//IF0001 IF RC EQ 0 THEN
//*
//PASSO2 EXEC PGM=IEBGENER
//SYSIN DD DUMMY
//SYSPRINT DD SYSOUT=*
//SYSUT1 DD DSN=GP.GPAE99.FONTES(DADOS),DISP=SHR
//SYSUT2 DD DSN=GP.GPAE99.PDS2(DADOS),DISP=SHR
//*
//IF0001 ENDIF

Pág: 15
outros exemplos:

IF com ELSE – executará PASSO4 se algum step anterior terminou com RC 0 ou

cancelou, senão executará PASSO5

//IF001 IF RC > 0 OR ABEND THEN

//*
//PASSO4 EXEC PGM=IEBGENER
//SYSIN DD DUMMY
//SYSPRINT DD SYSOUT=*
//SYSUT1 DD DSN=GP.GPAE99.PDS(DADOS),DISP=SHR
//SYSUT2 DD SYSOUT=*
//*
//IF001 ELSE
//*
//PASSO5 EXEC PGM=IEBGENER
//SYSIN DD DUMMY
//SYSPRINT DD SYSOUT=*
//SYSUT1 DD DSN=GP.GPAE99.FONTES(DADOS),DISP=SHR
//SYSUT2 DD SYSOUT=*
//*
//IF001 ENDIF

IFs encadeados: (executará PASSO5 se PASSO4 terminar com RC = 0)

//IF001 IF (RC > 0 OR ABEND ) THEN
//*
//PASSO4 EXEC PGM=IEBGENER
//SYSIN DD DUMMY
//SYSPRINT DD SYSOUT=*
//SYSUT1 DD DSN=GP.GPAE99.PDS(DADOS),DISP=SHR
//SYSUT2 DD SYSOUT=*
//*
//IF002 IF PASSO4.RC = 0
//*
//PASSO5 EXEC PGM=IEBGENER
//SYSIN DD DUMMY
//SYSPRINT DD SYSOUT=*
//SYSUT1 DD DSN=GP.GPAE99.FONTES(DADOS),DISP=SHR
//SYSUT2 DD SYSOUT=*
//*
//IF002 ENDIF
//IF001 ENDIF

Executará PASSO5 se PASSO4 não foi executado

//IF002 IF (NOT PASSO4.RUN) THEN

//*
//PASSO5 EXEC PGM=IEBGENER
//SYSIN DD DUMMY
//SYSPRINT DD SYSOUT=*
//SYSUT1 DD DSN=GP.GPAE99.FONTES(DADOS),DISP=SHR
//SYSUT2 DD SYSOUT=*
//*
//IF002 ENDIF

Pág: 16
Utilitários

Programas fornecidos junto com o sistema operacional ou adquirido no mercado

para executar tarefas comuns a todas instalações.

Comandos de controle dos utilitários

-------------------------------------------------------------------------------------------------------
123456789012345678901234567890123456789012345678901234567890123456
7890123--------------------------------------------------------------------------------------------------
---------------------------
• Coluna 1 - A coluna 1 precisa estar em branco se um label não é
codificado.
• Coluna 16 – operação e continuação.A continuação de um comando
precisa começar na coluna 16
• Coluna 72 - Codifique um caracter não branco na coluna 72 para continuar
um comando

IEBGENER – utilizado para copiar arquivos sequenciais (SYSUT1 para

SYSUT2)

Exemplo:

//GPAE99EX JOB
//CONSTROI EXEC PGM=IEBGENER
//SYSPRINT DD SYSOUT=A
//SYSIN DD DUMMY
//SYSUT1 DD *
JOAO PAULO 53AF 87 5701, 23 DE MAIO
ANTONIO JOSE 78AF 34 320, SÃO BENTO
/*
//SYSUT2 DD DSN=GP.GPAE99.TEST,UNIT=SYSALLDA,
// SPACE=(TRK,(1,1)),DISP=(NEW,CATLG),
// DCB=(RECFM=FB,LRECL=80,BLKSIZE=0)

IEFBR14 – utilizado para crier ou excluir arquivos

Exemplo:

//GPAE99EX JOB
//STEPALOC EXEC PGM=IEFBR14
//VKSDS1 DD
DSN=DSVAABVS.LSG.A889.ALBERTO,DISP=(,CATLG,DELETE),
// SPACE=(CYL,(10,10)),DCB=(LRECL=100,RECFM=F)
//*
//STEPDEL EXEC PGM=IEFBR14

Pág: 17
//VKSDS1 DD
DSN=DSVAABVS.LSG.A889.ALBERTO,DISP=(OLD,DELETE),
// SPACE=(CYL,(10,10)),DCB=(LRECL=100,RECFM=F)

Pág: 18
Exercício de fixação – comando JOB e comando EXEC

Utilizando a biblioteca GP.GPATxx.FONTES, criar o membro JOB01,

conforme segue:

OBS.: GPATxx substituir por seu userid

1. Codificar (conforme indicado) e submeter par validação, o seguinte

JCL:

//GPATxxJ1 JOB CLASS=A,

// MSGCLASS=X,MSGLEVL=0
// NOTIFY=GPATXX 'PROGRAMADOR: BILL GATES'
//STEP1 EXEC PGM=IEFBR14,PARM='TOMARA QUE CAIA'
//STEP4 EXEC IEFBR14,PARM='100288'
// TEP3 EXEC PGM=IEFBR14 COMENTARIO
//STEP2 EXEC PGM=IEFBR15 PROGRAMA NOVO?
//STEP4 EXEQ IEFBR14,ACCT='ADMP,ATR2099,'

Com base no resultado da submissão responda:

1. Qual o número do JOB? ________________

2. Para que classe de entrada o JOB foi direcionado? _____
3. Para que classe de saída o JOB foi direcionado? _______
4. O JOB executou normalmente? _______
5. Vá a classe de saída indicada no parâmetro MSGCLASS
(via SDSF) e veja o resultado execução. O que aconteceu
com o JOB? ____________________________________________
6. Por que as mensagens sobre a execução não estão na
classe indicada do parâmetro MSGCLASS? ________________
7. Altere parâmetro MSGLEVEL para MSGLEVEL=1 e envie o JCL
para execução novamente.
8. Veja os diversos erros que ocorreram. Tente compreender
a mensagem de erro, corrija os problemas de codificação
apresentados e execute o JCL novamente. Refaça essa
operação até não existirem mais erros de JCL. O JOB
executou? O que ocorreu? ______________________________

Pág: 19
Exercício de fixação – parâmetro COND, comandos DD e
utilitários IEFBR14 e IEBGENER

Codificar, validar e executar o seguinte JCL. Salvar na biblioteca

GP.GPATxx.FONTES com o nome de JOB02

NOME DO JOB GPATxxJ2

Executar em classe A;
Enviar mensagens de execução para classe X (exibir sempre todos os
níveis de mensagens);
Notificar o usuário do TSO sobre o termino da execução.

PASSO1

Utilizando o IEFBR14 alocar um arquivo seqüencial, com registros fixos

blocados de 120 posições, reservando 2 trilhas de espaço primário, 1
trilhas de espaço secundário.
Deixar o sistema calcular o tamanho do bloco;
Nome do arquivo: GP.GPATxx.ARQUIVO1

PASSO2

Se o step anterior terminou com RC maior que 0 não execute.

Copiar com IEBGENER para o arquivo criado no step anterior o membro

DADOS da biblioteca GP.GERAL.EXEMPLOS

PASSO 3

Se o step 2 terminou com RC > 0 execute esse passo

Excluir o arquivo criado no step1 utilizando o IEFBR14.

PASSO 4

Se os steps 1 ou 2 terminaram normalmente execute esse step.

Utilizando o IEBGENER listar o conteúdo do arquivo criado no PASSO2

Pág: 20
Exercício de fixação – comando IF

Criar como JOB03 uma cópia do JOB02 e substituir o uso do COND pelo
comando IF.

Salvar e testar o novo JOB, garantindo que o resultado da execução

continuará sendo o mesmo obtido com o parâmetro COND.

Pág: 21