Capitulo 2 - JCL
Job control Language
O JCL (Job control Language) é um bicho de 7 cabeças e isso não apenas para quem nunca teve contato com ele.
A "linguagem" não é necessariamente difícil, o problema é o copia e cola que é utilizado indiscriminadamente sendo por vezes utilizados parametros e comandos que o programador sequer tem a noção do porque ! O JCL não se parece com nada, um analogo - forçando a barra - na microinformatica seria um config.sys acoplado ao autoexec.bat (arquivos de configuração essenciais para inicializacao de versoes antigas do MS DOS, antecessor do windows para quem é muito novo).
O JCL existe desde 1960 e devido a compatibilidade que os mainframes apresentam continuará existindo por muitos e muitos anos. Nossa tarefa é entende-lo para poder doma-lo. Nunca duvide de um erro de JCL, com certeza você esta vendo algo errado!
Praticamente tudo que acontece no mainframe foi solicitado via JCL, o JCL precisa informar ao mainframe todos os dados essenciais para realização de uma determinada tarefa. Não se programa em JCL. JCL não é uma linguagem de programação é um coadjuvante realizando o meio de campo entre um programa, o sistema operacional e o hardware do mainframe.
O mainframe executa programas via JCL. Entenda-se aqui por programa:
programa simples (em Cobol, Assembler, PL1, C, Fortran)
um produto como o TSO, CICS, DB2, NATURAL, ROSCOE etc
uma aplicação como o sistema de gerenciamento de estoque de um grande supermercado
Digamos que seu programa simples citado acima foi escrito em cobol (COmmon Business Oriented Language - Linguagem Orientada aos Negócios) e é um simples "hello world" , algo como o codigo (fonte) abaixo
12345678901234567890123456789012345678901234567890123456789012345678901234567890
000010 IDENTIFICATION DIVISION.
000020 PROGRAM-ID. HELLO000.
000030 ENVIRONMENT DIVISION.
000040 DATA DIVISION.
000050 PROCEDURE DIVISION.
000060 DISPLAY 'Hello World em COBOL !'.
000070 STOP RUN.
000080Colunas de 1 a 7 -> padrão COBOL explicacao detalhada no capitulo sobre essa linguagem.
| Linha | Descrição |
|-------------|--------------------------------------------------------------|
| 000010 | Informações de identificação do programa |
| 000020 | Nome do programa (8 caracteres no mainframe) |
| 000030 | Dados do ambiente que o programa sera executado |
| 000040 | Variaveis" utilizadas |
| 000050 | Seu conteudo é o programa propriamente, indica o entry point |
| 000060 | Comando para enviar mensagem |
| 000070 | Encerra a execução do programa. |Entry point - é onde se inicia a execucao de um programa, isto significa que após a chamada, quando o controle é passado do chamador para o chamado o processamento se inicia nesse ponto. O mainframe possui regras rigidas de controle de chamada entre chamadores e chamados, mas não se preocupe no momento com isso, em momento oportuno exemplos surgirão.
ou em C
12345678901234567890123456789012345678901234567890123456789012345678901234567890
main() 1
{ 2
printf("Hello World em C !\n"); 3
} 41 definicao da funcao inicial/principal do programa (entry point). 2 e 4 delimitam a função. 3 Comando para enviar mensagem nem precisa do #include <stdio.h>, tem um lance de trigraphs que era o demonio, mas ja devem ter arrumado isso hoje em dia! Enfim, se precisar o } é ??< e o } é ??>, ta aqui uma tabelinha se precisar
|----------|----------------------|-------------------------|
| Trigraph | Caractere Equivalente| Descrição |
|----------|----------------------|-------------------------|
| `??=` | `#` | Cerquilha (hash) |
| `??(` | `[` | Colchete esquerdo |
| `??)` | `]` | Colchete direito |
| `??<` | `{` | Chave esquerda |
| `??>` | `}` | Chave direita |
| `??/` | `\` | Barra invertida |
| `??'` | `^` | Acento circunflexo |
| `??!` | `|` | Barra vertical (pipe) |
| `??-` | `~` | Til |
|----------|----------------------|-------------------------|ou em HLASM (High Level Assembler)
12345678901234567890123456789012345678901234567890123456789012345678901234567890
HELLO CSECT 1
USING *,15 2
WTO 'Hello World em HLASM !' 3
BR 14 4
END HELLO 51 identifica o início ou a continuação de uma Control Sect 2 indica que o registrador base é o 15 registrador 15 contem o endereço do entry point 3 "comando" para enviar mensagem pro operador WTO - write to operator é uma "macro" 4 Retorna pro registrador 14, isto é, volta pro chamador 5 Fim da CSECT (do nosso programa propriament dito. Especifica o entry point para o link editor ou loader
ou mesmo em PL/1
12345678901234567890123456789012345678901234567890123456789012345678901234567890
HELLO: PROCEDURE OPTIONS(MAIN); 1
PUT SKIP LIST('Hello World em PL/I !'); 2
END HELLO; 31 Identificação do programa, procedimento principal (entry point). 2 "Escreve" o que esta contido no argumento 3 Encerra o programa
Ou ainda em REXX
12345678901234567890123456789012345678901234567890123456789012345678901234567890
/* REXX - OLA#004 - Programa Hello World em REXX */ 1
Say 'Hello World em REXX !' 2
Exit 0 31 - "Cabeçalho" - obrigatorio conter a palavra REXX 2 - Say é o comando para emitir mensagens 3 - Encerra bonito
Para executar seu programa você precisa antes, basicamente, compila-lo e linkedita-lo. Mas como ? Se você acabou de dizer que o JCL precisa dizer tudo que o mainframe precisa saber para realizar isso, esqueceu que não sei JCL ainda ? Boa pergunta !
Mas como aqui em cima eu dei um exemplo de hello world em REXX, vou aproveitar e ensinar você a rodar programas REXX direto do TSO, é extremamente simples, na tela de edição de datasets por exemplo, você só precisa colocar um EX do lado do dataset que ele executara o seu programa em REXX!
┌───────────────────────────────────────────────────────────────────────────────┐
│ Menu Options View Utilities Compilers Help │
├───────────────────────────────────────────────────────────────────────────────┤
│ DSLIST - Data Sets Matching BUGA.HELLO.REXX Row 1 of 4 │
│ Command ===> Scroll ===> PAGE│
├───────────────────────────────────────────────────────────────────────────────┤
│ Name ↓ Created Changed Size Format │
│ ───────────────────────────────────────────────────────────────────────────── │
│ BUGA *ALIAS │
│ BUGA.S0W1.ISPF.ISPPROF MTM005 │
│ BUGA.S0W1.SPFLOG1.LIST VPWRKA │
│ EX BUGA.HELLO.REXX EX RC=0 VPWRKB <-- Seu programa REXX │
├───────────────────────────────────────────────────────────────────────────────┤
│ ************************** End of Data Set list ************************** │
├───────────────────────────────────────────────────────────────────────────────┤
└───────────────────────────────────────────────────────────────────────────────┘Na tela aparece ----------------------------- ISPF/PDF -----------------------------
BUGA.HELLO.REXX - Lines 1-3
===>
000001 /* REXX */
000002 Say 'Hello World em REXX!'
000003 Exit 0
--------------------------------------------------------------------┌──────────────────────────────────┐
│ │
│ Hello World em REXX │
│ │
└──────────────────────────────────┘você tambem pode executar via comando (geralmente tela 6 do TSO) ou prompt mesmo, mais ou menos assim:
TSO EXEC ‘BUGA.HELLO.REXX’
┌─────────────────────────── TSO/ISPF Command Execution ──────────────────────┐
│ OPTIONS ===> │
│ │
│ Enter TSO or Workstation commands below: │
│ ===> EX 'BUGA.HELLO.REXX' │
│ │
│ ***************************** TOP OF DATA ******************************** │
│ READY │
│ RUNNING - Hello World em REXX! │
│ │
│ READY │
│ │
│ **************************** BOTTOM OF DATA ****************************** │
│ │
│ │
└─────────────────────────────────────────────────────────────────────────────┘E também pode rodar via JCL sem nenhum problema chamando o utilitário IRXJCL ou mesmo chamando o IKJ e executando o comando igual na tela 6, ja ja quando montarmos um JCL vai dar pra entender.
No sistema que você estiver acessando existem procedures padrão que realizam muitas das tarefas que deparamos no dia-a-dia. Compilar um programa, linkedita-lo e executa-lo é uma delas ! Essas procedures ficam em bibliotecas do proprio sistema operacional, em sua empresa devem existir procedures especificas para esse mesmo fim porém customizadas para as suas necessidades.
Para executar essas procedures você também precisa utilizar o JCL ! Em termos simplistas quando utilizamos o JCL com poucas instruções chamamos o conjunto da obra de JOB, o que causa confusao num primeiro momento porque o "cabeçalho de um" job é tecnicamente conhecido como JOB, ao longo do texto tentaremos utilizar cabeçalho a job, mas não garanto que não passe algum job com sentido de cabeçalho. Se a parada for mais aprimorada costuma-se chamar de procedure, procedimento catalogado ou simplesmente PROC.
Mas fica a gosto do fregues como chamar o conjunto de instruções JCL, sugiro seguir o padrão de nome que sua empresa utiliza.
O processo de como um codigo fonte se torna um programa executável ocorre em etapas e isso se faz necessário pois, todas as linguagens dos nossos hello wold são linguagens do tipo compilada e é necessário - minimalisticamente falando - primeiro compilar seu codigo fonte do programa e na sequencia linkedita-lo gerando um carga (executavel) e depois executar esse carga.
Um JOB consiste de parâmetros individuais com utilizacao, exemplos e sintaxe descritas com detalhamento impar nos manuais de JCL da IBM. O JCL é chato, tudo deve ser dito exatamente como manda o figurino, o posicionamento de espaços, virgulas, segue um padrao, onde deve ficar cada elemento também e caso algo não esteja conforme o esperado um erro será apresentado na submissão desse JOB.
Vamos supor, apenas supor que você já tem o codigo executavel (carga) de nosso hello world em COBOL e deseja executa-lo, com o JOB abaixo isso é possivel
12345678901234567890123456789012345678901234567890123456789012345678901234567890
//JOB00000 JOB 'EXECUTA HELLO WORLD', 1
// NOTIFY=&SYSUID,MSGCLASS=H 2
//* Esse Job executa o programa cobol HELLO0000 3
//EXECUTA EXEC PGM=HELLO000 *** COMENTARIO DIDATICO *** 4
//SYSOUT DD SYSOUT=A,HOLD=YES 5
// 6você foi formalmente apresentado ao JCL !
Recaptulando e tentando nao deixar nada pra trás nessa introdução.
O JCL informa pro sistema operacional um monte de 'coisas' que sao necessárias pra execução da tarefa que esta sendo submetida, temos por exemplo, o nome do programa ou mesmo de outro JCL , o DD Name (8 bytes internos ao programa e linka com o jcl) além do arquivo em si com todos seus qualificadores, que é o DS name (até 44 caracteres), informa o tamanho dos registros, se o arquivo é novo, se já existe, o que fazer em caso de erro anormal no processamento, quanto tempo deve ser o maximo pra rodar o job, se é pra avisar alguem quando terminar a execução, se deleta os arquivos temporarios, se começa o processamento do começo ou à partir de algum outro ponto, enfim, um mar de 'coisas' devem ser repassadas pra tudo rodar redondinho. A parte do sistema operacional que faz o bem bolado dos JCLs é o JES (Job Entry System) , falaremos dele ainda nesse capitulo.
Last updated