COBOL - Guida rapida

Introduzione a COBOL

COBOL è un linguaggio di alto livello. Bisogna capire il modo in cui funziona COBOL. I computer comprendono solo il codice macchina, un flusso binario di 0 e 1. Il codice COBOL deve essere convertito in codice macchina utilizzando un filecompiler. Eseguire il sorgente del programma tramite un compilatore. Il compilatore prima controlla eventuali errori di sintassi e poi lo converte in linguaggio macchina. Il compilatore crea un file di output noto comeload module. Questo file di output contiene codice eseguibile sotto forma di 0 e 1.

Evoluzione di COBOL

Durante gli anni '50, quando le aziende crescevano nella parte occidentale del mondo, c'era la necessità di automatizzare vari processi per facilitare le operazioni e questo diede vita a un linguaggio di programmazione di alto livello destinato all'elaborazione dei dati aziendali.

  • Nel 1959, COBOL è stato sviluppato da CODASYL (Conference on Data Systems Language).

  • La versione successiva, COBOL-61, fu rilasciata nel 1961 con alcune revisioni.

  • Nel 1968, COBOL è stato approvato dall'ANSI come linguaggio standard per uso commerciale (COBOL-68).

  • È stato nuovamente rivisto nel 1974 e nel 1985 per sviluppare versioni successive denominate rispettivamente COBOL-74 e COBOL-85.

  • Nel 2002 è stato rilasciato COBOL orientato agli oggetti, che poteva utilizzare oggetti incapsulati come parte normale della programmazione COBOL.

Importanza di COBOL

  • COBOL è stato il primo linguaggio di programmazione di alto livello ampiamente utilizzato. È una lingua simile all'inglese che è facile da usare. Tutte le istruzioni possono essere codificate in semplici parole inglesi.

  • COBOL è anche usato come linguaggio auto-documentante.

  • COBOL può gestire enormi elaborazioni di dati.

  • COBOL è compatibile con le sue versioni precedenti.

  • COBOL ha messaggi di errore efficaci e quindi la risoluzione dei bug è più semplice.

Caratteristiche di COBOL

Lingua standard

COBOL è un linguaggio standard che può essere compilato ed eseguito su macchine come IBM AS / 400, personal computer, ecc.

Orientato al business

COBOL è stato progettato per applicazioni orientate al business relative al dominio finanziario, al dominio della difesa, ecc. Può gestire enormi volumi di dati grazie alle sue capacità avanzate di gestione dei file.

Linguaggio robusto

COBOL è un linguaggio robusto poiché i suoi numerosi strumenti di debug e test sono disponibili per quasi tutte le piattaforme di computer.

Linguaggio strutturato

Le strutture di controllo logico sono disponibili in COBOL che ne facilitano la lettura e la modifica. COBOL ha diverse divisioni, quindi è facile eseguire il debug.

Installazione di COBOL su Windows / Linux

Sono disponibili molti emulatori mainframe gratuiti per Windows che possono essere utilizzati per scrivere e apprendere semplici programmi COBOL.

Uno di questi emulatori è Hercules, che può essere facilmente installato su Windows seguendo alcuni semplici passaggi come indicato di seguito:

  • Scarica e installa l'emulatore Hercules, disponibile dal sito principale di Hercules: www.hercules-390.eu

  • Dopo aver installato il pacchetto sulla macchina Windows, creerà una cartella come C:/hercules/mvs/cobol.

  • Eseguire il prompt dei comandi (CMD) e raggiungere la directory C: / hercules / mvs / cobol su CMD.

  • La guida completa sui vari comandi per scrivere ed eseguire programmi JCL e COBOL può essere trovata su:

    www.jaymoseley.com/hercules/installmvs/instmvs2.htm

Hercules è un'implementazione software open source delle architetture mainframe System / 370 ed ESA / 390, oltre alla più recente z / Architecture a 64 bit. Hercules funziona su Linux, Windows, Solaris, FreeBSD e Mac OS X.

Un utente può connettersi a un server mainframe in diversi modi, ad esempio thin client, terminale fittizio, Virtual Client System (VCS) o Virtual Desktop System (VDS). A ogni utente valido viene assegnato un ID di accesso per accedere all'interfaccia Z / OS (TSO / E o ISPF).

Compilazione di programmi COBOL

Per eseguire un programma COBOL in modalità batch utilizzando JCL, il programma deve essere compilato e viene creato un modulo di caricamento con tutti i sottoprogrammi. JCL utilizza il modulo di caricamento e non il programma effettivo al momento dell'esecuzione. Le librerie di caricamento vengono concatenate e fornite al JCL al momento dell'esecuzione utilizzandoJCLLIB o STEPLIB.

Sono disponibili molte utilità di compilazione mainframe per compilare un programma COBOL. Alcune società aziendali utilizzano strumenti di gestione del cambiamento comeEndevor, che compila e archivia ogni versione del programma. Ciò è utile per tenere traccia delle modifiche apportate al programma.

//COMPILE   JOB ,CLASS = 6,MSGCLASS = X,NOTIFY = &SYSUID             
//*            
//STEP1     EXEC IGYCRCTL,PARM = RMODE,DYNAM,SSRANGE
//SYSIN     DD DSN = MYDATA.URMI.SOURCES(MYCOBB),DISP = SHR
//SYSLIB    DD DSN = MYDATA.URMI.COPYBOOK(MYCOPY),DISP = SHR
//SYSLMOD   DD DSN = MYDATA.URMI.LOAD(MYCOBB),DISP = SHR
//SYSPRINT  DD SYSOUT=*
//*

IGYCRCTL è un'utilità di compilazione COBOL IBM. Le opzioni del compilatore vengono passate utilizzando il parametro PARM. Nell'esempio precedente, RMODE indica al compilatore di utilizzare la modalità di indirizzamento relativo nel programma. Il programma COBOL viene passato utilizzando il parametro SYSIN. Copybook è la libreria utilizzata dal programma in SYSLIB.

Esecuzione di programmi COBOL

Di seguito è riportato un esempio JCL in cui il programma MYPROG viene eseguito utilizzando il file di input MYDATA.URMI.INPUT e produce due file di output scritti nello spool.

//COBBSTEP  JOB CLASS = 6,NOTIFY = &SYSUID
//
//STEP10    EXEC PGM = MYPROG,PARM = ACCT5000
//STEPLIB   DD DSN = MYDATA.URMI.LOADLIB,DISP = SHR
//INPUT1    DD DSN = MYDATA.URMI.INPUT,DISP = SHR
//OUT1      DD SYSOUT=*
//OUT2      DD SYSOUT=*
//SYSIN     DD *
//CUST1     1000
//CUST2     1001
/*

Il modulo di caricamento di MYPROG si trova in MYDATA.URMI.LOADLIB. Ciò è importante per notare che il JCL sopra può essere utilizzato solo per un modulo COBOL non DB2.

Esecuzione di programmi COBOL-DB2

Per eseguire un programma COBOL-DB2, viene utilizzata un'utilità IBM specializzata in JCL e nel programma; La regione DB2 ei parametri richiesti vengono passati come input al programma di utilità.

I passaggi seguiti nell'esecuzione di un programma COBOL-DB2 sono i seguenti:

  • Quando viene compilato un programma COBOL-DB2, viene creato un DBRM (Database Request Module) insieme al modulo di caricamento. Il DBRM contiene le istruzioni SQL dei programmi COBOL con la sintassi verificata per essere corretta.

  • Il DBRM è associato alla regione (ambiente) DB2 in cui verrà eseguito COBOL. Questa operazione può essere eseguita utilizzando l'utilità IKJEFT01 in un JCL.

  • Dopo la fase di bind, il programma COBOL-DB2 viene eseguito utilizzando IKJEFT01 (di nuovo) con la libreria di caricamento e la libreria DBRM come input per JCL.

//STEP001  EXEC PGM = IKJEFT01
//*
//STEPLIB  DD DSN = MYDATA.URMI.DBRMLIB,DISP = SHR
//*
//input files
//output files
//SYSPRINT DD SYSOUT=*
//SYSABOUT DD SYSOUT=*
//SYSDBOUT DD SYSOUT=*
//SYSUDUMP DD SYSOUT=*
//DISPLAY  DD SYSOUT=*
//SYSOUT   DD SYSOUT=*
//SYSTSPRT DD SYSOUT=*
//SYSTSIN  DD *
   DSN SYSTEM(SSID)
   RUN PROGRAM(MYCOBB) PLAN(PLANNAME) PARM(parameters to cobol program) -
   LIB('MYDATA.URMI.LOADLIB')
   END
/*

Nell'esempio precedente, MYCOBB è il programma COBOL-DB2 eseguito utilizzando IKJEFT01. Si noti che il nome del programma, l'ID del sottosistema DB2 (SSID) e il nome del piano DB2 vengono passati all'interno dell'istruzione SYSTSIN DD. La libreria DBRM è specificata in STEPLIB.

Una struttura del programma COBOL è composta da divisioni come mostrato nell'immagine seguente:

Di seguito viene fornita una breve introduzione di queste divisioni:

  • Sectionssono la suddivisione logica della logica del programma. Una sezione è una raccolta di paragrafi.

  • Paragraphssono la suddivisione di una sezione o divisione. È un nome definito dall'utente o predefinito seguito da un punto e consiste di zero o più frasi / voci.

  • Sentencessono la combinazione di una o più dichiarazioni. Le frasi compaiono solo nella divisione Procedura. Una frase deve terminare con un punto.

  • Statements sono istruzioni COBOL significative che eseguono alcune elaborazioni.

  • Characters sono i più bassi nella gerarchia e non possono essere divisibili.

È possibile correlare i termini sopra menzionati con il programma COBOL nel seguente esempio:

PROCEDURE DIVISION.
A0000-FIRST-PARA SECTION.
FIRST-PARAGRAPH.
ACCEPT WS-ID            - Statement-1  -----|
MOVE '10' TO WS-ID      - Statement-2       |-- Sentence - 1
DISPLAY WS-ID           - Statement-3  -----|
.

Divisioni

Un programma COBOL è composto da quattro divisioni.

Divisione Identificazione

È la prima e unica divisione obbligatoria di ogni programma COBOL. Il programmatore e il compilatore utilizzano questa divisione per identificare il programma. In questa divisione, PROGRAM-ID è l'unico paragrafo obbligatorio. ID PROGRAMMA specifica il nome del programma che può essere composto da 1 a 30 caratteri.

Prova il seguente esempio usando il Live Demo opzione online.

IDENTIFICATION DIVISION.
PROGRAM-ID. HELLO.
PROCEDURE DIVISION.
DISPLAY 'Welcome to Tutorialspoint'.
STOP RUN.

Di seguito è riportato il file JCL per eseguire il programma COBOL di cui sopra.

//SAMPLE JOB(TESTJCL,XXXXXX),CLASS = A,MSGCLASS = C
//STEP1 EXEC PGM = HELLO

Quando compili ed esegui il programma sopra, produce il seguente risultato:

Welcome to Tutorialspoint

Divisione Ambiente

La divisione dell'ambiente viene utilizzata per specificare i file di input e di output per il programma. Consiste di due sezioni:

  • Configuration sectionfornisce informazioni sul sistema su cui il programma è scritto ed eseguito. Consiste di due paragrafi:

    • Computer di origine: sistema utilizzato per compilare il programma.

    • Computer oggetto: sistema utilizzato per eseguire il programma.

  • Input-Output sectionfornisce informazioni sui file da utilizzare nel programma. Consiste di due paragrafi:

    • Controllo file: fornisce informazioni sui set di dati esterni utilizzati nel programma.

    • Controllo IO - Fornisce informazioni sui file utilizzati nel programma.

ENVIRONMENT DIVISION.
CONFIGURATION SECTION.
   SOURCE-COMPUTER. XXX-ZOS.
   OBJECT-COMPUTER. XXX-ZOS.

INPUT-OUTPUT SECTION.
   FILE-CONTROL.
   SELECT FILEN ASSIGN TO DDNAME
   ORGANIZATION IS SEQUENTIAL.

Divisione dati

La divisione dei dati viene utilizzata per definire le variabili utilizzate nel programma. Consiste di quattro sezioni:

  • File section viene utilizzato per definire la struttura dei record del file.

  • Working-Storage section viene utilizzato per dichiarare variabili temporanee e strutture di file che vengono utilizzate nel programma.

  • Local-Storage sectionè simile alla sezione Working-Storage. L'unica differenza è che le variabili verranno allocate e inizializzate ogni volta che un programma inizia l'esecuzione.

  • Linkage section viene utilizzato per descrivere i nomi dei dati ricevuti da un programma esterno.

COBOL Program

IDENTIFICATION DIVISION.
PROGRAM-ID. HELLO.

ENVIRONMENT DIVISION.
   INPUT-OUTPUT SECTION.
   FILE-CONTROL.
   SELECT FILEN ASSIGN TO INPUT.
      ORGANIZATION IS SEQUENTIAL.
      ACCESS IS SEQUENTIAL.

DATA DIVISION.
   FILE SECTION.
   FD FILEN
   01 NAME PIC A(25).
   
   WORKING-STORAGE SECTION.
   01 WS-STUDENT PIC A(30).
   01 WS-ID PIC 9(5).

   LOCAL-STORAGE SECTION.
   01 LS-CLASS PIC 9(3).
   
   LINKAGE SECTION.
   01 LS-ID PIC 9(5).
   
PROCEDURE DIVISION.
   DISPLAY 'Executing COBOL program using JCL'.
STOP RUN.

Il JCL per eseguire il programma COBOL di cui sopra è il seguente:

//SAMPLE JOB(TESTJCL,XXXXXX),CLASS = A,MSGCLASS = C
//STEP1 EXEC PGM = HELLO
//INPUT DD DSN = ABC.EFG.XYZ,DISP = SHR

Quando compili ed esegui il programma sopra, produce il seguente risultato:

Executing COBOL program using JCL

Divisione Procedura

La divisione delle procedure viene utilizzata per includere la logica del programma. Consiste in istruzioni eseguibili che utilizzano variabili definite nella divisione dei dati. In questa divisione, i nomi dei paragrafi e delle sezioni sono definiti dall'utente.

Deve essere presente almeno una dichiarazione nella divisione procedura. L'ultima istruzione per terminare l'esecuzione in questa divisione è l'una o l'altraSTOP RUN che viene utilizzato nei programmi chiamanti o EXIT PROGRAM che viene utilizzato nei programmi chiamati.

IDENTIFICATION DIVISION.
PROGRAM-ID. HELLO.

DATA DIVISION.
   WORKING-STORAGE SECTION.
   01 WS-NAME PIC A(30).
   01 WS-ID PIC 9(5) VALUE 12345.

PROCEDURE DIVISION.
   A000-FIRST-PARA.
   DISPLAY 'Hello World'.
   MOVE 'TutorialsPoint' TO WS-NAME.
   DISPLAY "My name is : "WS-NAME.
   DISPLAY "My ID is : "WS-ID.
STOP RUN.

JCL per eseguire il programma COBOL di cui sopra -

//SAMPLE JOB(TESTJCL,XXXXXX),CLASS = A,MSGCLASS = C
//STEP1 EXEC PGM = HELLO

Quando compili ed esegui il programma sopra, produce il seguente risultato:

Hello World
My name is : TutorialsPoint
My ID is : 12345

Set di caratteri

I "caratteri" sono i più bassi nella gerarchia e non possono essere ulteriormente divisi. Il set di caratteri COBOL include 78 caratteri mostrati di seguito:

Sr.No. Carattere e descrizione
1

A-Z

Alfabeti (maiuscolo)

2

a-z

Alfabeti (minuscolo)

3

0-9

Numerico

4

 

Spazio

5

+

Segno più

6

-

Segno meno o trattino

7

*

Asterisco

8

/

Barra

9

$

Segno di valuta

10

,

Virgola

11

;

Punto e virgola

12

.

Punto decimale o punto

13

"

Virgolette

14

(

Parentesi sinistra

15

)

Parentesi destra

16

>

Più grande di

17

<

Meno di

18

:

Colon

19

'

Apostrofo

20

=

Segno di uguale

Foglio di codifica

Il programma sorgente di COBOL deve essere scritto in un formato accettabile per i compilatori. I programmi COBOL sono scritti su fogli di codifica COBOL. Ci sono 80 posizioni di carattere su ogni riga di un foglio di codifica.

Le posizioni dei caratteri sono raggruppate nei seguenti cinque campi:

Posizioni Campo Descrizione
1-6 Numeri di colonna Riservato per i numeri di riga.
7 Indicatore Può avere un asterisco (*) che indica i commenti, un trattino (-) che indica la continuazione e una barra (/) che indica l'avanzamento del modulo.
8-11 Area A Tutte le divisioni, sezioni, paragrafi e alcune voci speciali COBOL devono iniziare nell'Area A.
12-72 Area B Tutte le istruzioni COBOL devono iniziare nell'area B.
73-80 Area di identificazione Può essere utilizzato secondo necessità dal programmatore.

Esempio

L'esempio seguente mostra un foglio di codifica COBOL:

000100 IDENTIFICATION DIVISION.                                         000100
000200 PROGRAM-ID. HELLO.                                               000101
000250* THIS IS A COMMENT LINE                                          000102
000300 PROCEDURE DIVISION.                                              000103
000350 A000-FIRST-PARA.                                                 000104
000400     DISPLAY “Coding Sheet”.                                      000105
000500 STOP RUN.                                                        000106

JCL per eseguire il programma COBOL di cui sopra -

//SAMPLE JOB(TESTJCL,XXXXXX),CLASS = A,MSGCLASS = C
//STEP1 EXEC PGM = HELLO

Quando compili ed esegui il programma sopra, produce il seguente risultato:

Coding Sheet

Stringhe di caratteri

Le stringhe di caratteri vengono formate combinando singoli caratteri. Una stringa di caratteri può essere un file

  • Comment,
  • Letterale, o
  • Parola COBOL.

Tutte le stringhe di caratteri devono terminare con separators. Un separatore viene utilizzato per separare le stringhe di caratteri.

Separatori usati di frequente: spazio, virgola, punto, apostrofo, parentesi sinistra / destra e virgolette.

Commento

Un commento è una stringa di caratteri che non influisce sull'esecuzione di un programma. Può essere qualsiasi combinazione di caratteri.

Esistono due tipi di commenti:

Riga di commento

Una riga di commento può essere scritta in qualsiasi colonna. Il compilatore non controlla una riga di commento per la sintassi e la tratta per la documentazione.

Inserimento commento

Le voci di commento sono quelle incluse nei paragrafi opzionali di una divisione di identificazione. Sono scritti in Area B e i programmatori lo usano come riferimento.

Il testo evidenziato in Bold sono le voci commentate nel seguente esempio:

000100 IDENTIFICATION DIVISION.                                         000100
000150 PROGRAM-ID. HELLO.                                               000101 
000200 AUTHOR. TUTORIALSPOINT.                                          000102
000250* THIS IS A COMMENT LINE                                          000103
000300 PROCEDURE DIVISION.                                              000104
000350 A000-FIRST-PARA.                                                 000105  
000360/ First Para Begins - Documentation Purpose                       000106
000400     DISPLAY “Comment line”.                                      000107
000500 STOP RUN.                                                        000108

JCL per eseguire il programma COBOL sopra -

//SAMPLE JOB(TESTJCL,XXXXXX),CLASS = A,MSGCLASS = C
//STEP1 EXEC PGM = HELLO

Quando compili ed esegui il programma sopra, produce il seguente risultato:

Comment Line

Letterale

Il valore letterale è una costante direttamente codificata in un programma. Nell'esempio seguente, "Hello World" è letterale.

PROCEDURE DIVISION.
DISPLAY 'Hello World'.

Esistono due tipi di letterali come discusso di seguito:

Letterale alfanumerico

I letterali alfanumerici sono racchiusi tra virgolette o apostrofo. La lunghezza può essere fino a 160 caratteri. Un apostrofo o una citazione possono far parte di un letterale solo se sono associati. L'inizio e la fine del letterale dovrebbero essere gli stessi, apostrofo o citazione.

Example

L'esempio seguente mostra valori letterali alfanumerici validi e non validi:

Valid:
   ‘This is valid’
   "This is valid"
   ‘This isn’’t invalid’

Invalid:
   ‘This is invalid”
   ‘This isn’t valid’

Letterale numerico

Un valore letterale numerico è una combinazione di cifre comprese tra 0 e 9, +, - o punto decimale. La lunghezza può essere fino a 18 caratteri. Il segno non può essere il carattere più a destra. Il punto decimale non dovrebbe apparire alla fine.

Example

L'esempio seguente mostra valori letterali numerici validi e non validi:

Valid:
   100
   +10.9
   -1.9

Invalid:
   1,00
   10.
   10.9-

COBOL Word

COBOL Word è una stringa di caratteri che può essere una parola riservata o una parola definita dall'utente. La lunghezza può essere fino a 30 caratteri.

Definito dall'utente

Le parole definite dall'utente vengono utilizzate per denominare file, dati, record, nomi di paragrafi e sezioni. Alfabeti, cifre e trattini sono consentiti durante la formazione di parole definite dall'utente. Non è possibile utilizzare parole riservate COBOL.

Parole riservate

Le parole riservate sono parole predefinite in COBOL. I diversi tipi di parole riservate che usiamo frequentemente sono i seguenti:

  • Keywords come AGGIUNGI, ACCETTA, SPOSTA, ecc.

  • Special characters parole come +, -, *, <, <=, ecc

  • Figurative constants sono valori costanti come ZERO, SPAZI, ecc. Tutti i valori costanti delle costanti figurative sono menzionati nella tabella seguente.

Costanti figurative

Sr.No. Costanti figurative e descrizione
1

HIGH-VALUES

Uno o più caratteri che saranno nella posizione più alta in ordine decrescente.

2

LOW-VALUES

Uno o più caratteri hanno zeri nella rappresentazione binaria.

3

ZERO/ZEROES

Uno o più zero a seconda della dimensione della variabile.

4

SPACES

Uno o più spazi.

5

QUOTES

Virgolette singole o doppie.

6

ALL literal

Riempie l'elemento dati con Literal.

La divisione dei dati viene utilizzata per definire le variabili utilizzate in un programma. Per descrivere i dati in COBOL, è necessario comprendere i seguenti termini:

  • Nome dati
  • Numero di livello
  • Clausola di immagine
  • Clausola di valore
01            TOTAL-STUDENTS            PIC9(5)            VALUE '125'.
|                    |                    |                    |
|                    |                    |                    |
|                    |                    |                    | 
Level Number     Data Name           Picture Clause       Value Clause

Nome dati

I nomi dei dati devono essere definiti nella divisione dati prima di utilizzarli nella divisione procedure. Devono avere un nome definito dall'utente; le parole riservate non possono essere utilizzate. I nomi dei dati fanno riferimento alle posizioni di memoria in cui sono memorizzati i dati effettivi. Possono essere elementari o di gruppo.

Esempio

L'esempio seguente mostra nomi di dati validi e non validi:

Valid:
   WS-NAME
   TOTAL-STUDENTS
   A100
   100B

Invalid:
   MOVE            (Reserved Words)
   COMPUTE         (Reserved Words)
   100             (No Alphabet)
   100+B           (+ is not allowed)

Numero di livello

Il numero di livello viene utilizzato per specificare il livello di dati in un record. Sono usati per distinguere tra elementi elementari e elementi di gruppo. Gli elementi elementari possono essere raggruppati insieme per creare elementi di gruppo.

Sr.No. Numero e descrizione del livello
1

01

Inserimento della descrizione del record

2

02 to 49

Elementi di gruppo ed elementari

3

66

Rinomina gli elementi della clausola

4

77

Elementi che non possono essere suddivisi

5

88

Inserimento del nome della condizione

  • Elementary itemsnon può essere ulteriormente diviso. Il numero di livello, il nome dei dati, la clausola Picture e la clausola Value (opzionale) vengono utilizzati per descrivere un elemento elementare.

  • Group itemsconsistono in uno o più elementi elementari. Il numero di livello, il nome dei dati e la clausola del valore (facoltativa) vengono utilizzati per descrivere un elemento del gruppo. Il numero del livello di gruppo è sempre 01.

Esempio

L'esempio seguente mostra elementi di gruppo ed elementari:

DATA DIVISION.
WORKING-STORAGE SECTION.
01 WS-NAME    PIC X(25).                               ---> ELEMENTARY ITEM 
01 WS-CLASS   PIC 9(2)  VALUE  '10'.                   ---> ELEMENTARY ITEM

01 WS-ADDRESS.                                         ---> GROUP ITEM   
   05 WS-HOUSE-NUMBER    PIC 9(3).                     ---> ELEMENTARY ITEM
   05 WS-STREET          PIC X(15).                    ---> ELEMENTARY ITEM
   05 WS-CITY            PIC X(15).                    ---> ELEMENTARY ITEM
   05 WS-COUNTRY         PIC X(15)  VALUE 'INDIA'.     ---> ELEMENTARY ITEM

Clausola di immagine

La clausola Picture viene utilizzata per definire i seguenti elementi:

  • Data typepuò essere numerico, alfabetico o alfanumerico. Il tipo numerico è composto solo da cifre da 0 a 9. Il tipo alfabetico è composto da lettere dalla A alla Z e spazi. Il tipo alfanumerico è composto da cifre, lettere e caratteri speciali.

  • Signpuò essere utilizzato con dati numerici. Può essere + o -.

  • Decimal point positionpuò essere utilizzato con dati numerici. La posizione presunta è la posizione del punto decimale e non è inclusa nei dati.

  • Length definisce il numero di byte utilizzati dall'elemento dati.

Simboli utilizzati in una clausola Picture -

Sr.No. Simbolo e descrizione
1

9

Numerico

2

A

Alfabetico

3

X

Alfanumerico

4

V

Decimale implicito

5

S

Cartello

6

P

Presunto decimale

Esempio

L'esempio seguente mostra l'uso della clausola PIC:

IDENTIFICATION DIVISION.
PROGRAM-ID. HELLO.

DATA DIVISION.
   WORKING-STORAGE SECTION.
   01 WS-NUM1 PIC S9(3)V9(2).
   01 WS-NUM2 PIC PPP999.
   01 WS-NUM3 PIC S9(3)V9(2) VALUE -123.45.
   01 WS-NAME PIC A(6) VALUE 'ABCDEF'.
   01 WS-ID PIC X(5) VALUE 'A121$'.

PROCEDURE DIVISION.
   DISPLAY "WS-NUM1 : "WS-NUM1.
   DISPLAY "WS-NUM2 : "WS-NUM2.
   DISPLAY "WS-NUM3 : "WS-NUM3.
   DISPLAY "WS-NAME : "WS-NAME.
   DISPLAY "WS-ID : "WS-ID.
STOP RUN.

JCL per eseguire il programma COBOL di cui sopra -

//SAMPLE JOB(TESTJCL,XXXXXX),CLASS = A,MSGCLASS = C
//STEP1 EXEC PGM = HELLO

Quando compili ed esegui il programma sopra, produce il seguente risultato:

WS-NUM1 : +000.00
WS-NUM2 : .000000
WS-NUM3 : -123.45
WS-NAME : ABCDEF
WS-ID : A121$

Clausola di valore

La clausola Value è una clausola facoltativa utilizzata per inizializzare gli elementi di dati. I valori possono essere letterali numerici, letterali alfanumerici o costanti figurativi. Può essere utilizzato sia con elementi di gruppo che elementari.

Esempio

L'esempio seguente mostra l'uso della clausola VALUE -

IDENTIFICATION DIVISION.
PROGRAM-ID. HELLO.

DATA DIVISION.
   WORKING-STORAGE SECTION.
   01 WS-NUM1 PIC 99V9 VALUE IS 3.5.
   01 WS-NAME PIC A(6) VALUE 'ABCD'.
   01 WS-ID PIC 99 VALUE ZERO.

PROCEDURE DIVISION.
   DISPLAY "WS-NUM1 : "WS-NUM1.
   DISPLAY "WS-NAME : "WS-NAME.
   DISPLAY "WS-ID   : "WS-ID.
STOP RUN.

JCL per eseguire il programma COBOL di cui sopra -

//SAMPLE JOB(TESTJCL,XXXXXX),CLASS = A,MSGCLASS = C
//STEP1 EXEC PGM = HELLO

Quando compili ed esegui il programma sopra, produce il seguente risultato:

WS-NUM1 : 03.5
WS-NAME : ABCD
WS-ID   : 00

I verbi COBOL sono utilizzati nella divisione procedure per l'elaborazione dei dati. Un'istruzione inizia sempre con un verbo COBOL. Esistono diversi verbi COBOL con diversi tipi di azioni.

Verbi di input / output

I verbi di input / output vengono utilizzati per ottenere dati dall'utente e visualizzare l'output dei programmi COBOL. I seguenti due verbi vengono utilizzati per questo processo:

Accetta verbo

Il verbo Accetta viene utilizzato per ottenere dati come data, ora e giorno dal sistema operativo o direttamente dall'utente. Se un programma accetta dati dall'utente, deve essere passato tramite JCL. Durante il recupero dei dati dal sistema operativo, l'opzione FROM è inclusa come mostrato nell'esempio seguente:

ACCEPT WS-STUDENT-NAME.
ACCEPT WS-DATE FROM SYSTEM-DATE.

Display Verb

Il verbo di visualizzazione viene utilizzato per visualizzare l'output di un programma COBOL.

DISPLAY WS-STUDENT-NAME.
DISPLAY "System date is : " WS-DATE.

COBOL PROGRAM

IDENTIFICATION DIVISION.
PROGRAM-ID. HELLO.

DATA DIVISION.
   WORKING-STORAGE SECTION.
   01 WS-STUDENT-NAME PIC X(25).
   01 WS-DATE PIC X(10).

PROCEDURE DIVISION.
   ACCEPT WS-STUDENT-NAME.
   ACCEPT WS-DATE FROM DATE.
   DISPLAY "Name :  " WS-STUDENT-NAME.
   DISPLAY "Date : " WS-DATE.

STOP RUN.

JCL per eseguire il programma COBOL di cui sopra -

//SAMPLE JOB(TESTJCL,XXXXXX),CLASS = A,MSGCLASS = C
//STEP1 EXEC PGM = HELLO
//INPUT DD DSN=PROGRAM.DIRECTORY,DISP=SHR
//SYSIN DD *
TutorialsPoint
/*

Quando compili ed esegui il programma sopra, produce il seguente risultato:

Name : TutorialsPoint
Date : 200623

Inizializza verbo

Il verbo Initialize viene utilizzato per inizializzare un elemento di gruppo o un elemento elementare. I nomi dei dati con la clausola RENAME non possono essere inizializzati. I dati numerici vengono sostituiti da ZEROES. I dati alfanumerici o alfabetici sono sostituiti da SPAZI. Se includiamo il termine REPLACING, gli elementi di dati possono essere inizializzati al valore di sostituzione fornito come mostrato nell'esempio seguente:

IDENTIFICATION DIVISION.
PROGRAM-ID. HELLO.

DATA DIVISION.
   WORKING-STORAGE SECTION.
   01 WS-NAME PIC A(30) VALUE 'ABCDEF'.
   01 WS-ID PIC 9(5).
   01 WS-ADDRESS. 
   05 WS-HOUSE-NUMBER PIC 9(3).
   05 WS-COUNTRY PIC X(15).
   05 WS-PINCODE PIC 9(6) VALUE 123456.

PROCEDURE DIVISION.
   A000-FIRST-PARA.
   INITIALIZE WS-NAME, WS-ADDRESS.
   INITIALIZE WS-ID REPLACING NUMERIC DATA BY 12345.
   DISPLAY "My name is   : "WS-NAME.
   DISPLAY "My ID is     : "WS-ID.
   DISPLAY "Address      : "WS-ADDRESS.
   DISPLAY "House Number : "WS-HOUSE-NUMBER.
   DISPLAY "Country      : "WS-COUNTRY.
   DISPLAY "Pincode      : "WS-PINCODE.

STOP RUN.

JCL per eseguire il programma COBOL di cui sopra -

//SAMPLE JOB(TESTJCL,XXXXXX),CLASS = A,MSGCLASS = C
//STEP1 EXEC PGM = HELLO

Quando compili ed esegui il programma sopra, produce il seguente risultato:

My name is   :                               
My ID is     : 12345
Address      : 000               000000
House Number : 000
Country      :                
Pincode      : 000000

Move Verb

Il verbo Move viene utilizzato per copiare i dati dai dati di origine ai dati di destinazione. Può essere utilizzato su elementi di dati sia elementari che di gruppo. Per gli elementi di dati di gruppo, viene utilizzato MOVE CORRESPONDING / CORR. Nell'opzione try it, MOVE CORR non funziona; ma su un server mainframe, funzionerà.

Per spostare i dati da una stringa, viene utilizzato MOVE (x: l) dove x è la posizione iniziale el è la lunghezza. I dati verranno troncati se la clausola PIC dell'elemento di dati di destinazione è inferiore alla clausola PIC dell'elemento di dati di origine. Se la clausola PIC dell'elemento di dati di destinazione è maggiore della clausola PIC dell'elemento di dati di origine, nei byte aggiuntivi verranno aggiunti ZEROS o SPACES. Il seguente esempio lo rende chiaro.

IDENTIFICATION DIVISION.
PROGRAM-ID. HELLO.

DATA DIVISION.
   WORKING-STORAGE SECTION.
   01 WS-NUM1 PIC 9(9).
   01 WS-NUM2 PIC 9(9).
   01 WS-NUM3 PIC 9(5).
   01 WS-NUM4 PIC 9(6).
   01 WS-ADDRESS. 
   05 WS-HOUSE-NUMBER PIC 9(3).
   05 WS-COUNTRY PIC X(5).
   05 WS-PINCODE PIC 9(6).
   01 WS-ADDRESS1. 
   05 WS-HOUSE-NUMBER1 PIC 9(3).
   05 WS-COUNTRY1 PIC X(5).
   05 WS-PINCODE1 PIC 9(6).

PROCEDURE DIVISION.
   A000-FIRST-PARA.
   MOVE 123456789 TO WS-NUM1.
   MOVE WS-NUM1 TO WS-NUM2 WS-NUM3.
   MOVE WS-NUM1(3:6) TO WS-NUM4.
   MOVE 123 TO WS-HOUSE-NUMBER.
   MOVE 'INDIA' TO WS-COUNTRY.
   MOVE 112233 TO WS-PINCODE.
   MOVE WS-ADDRESS TO WS-ADDRESS1.

   DISPLAY "WS-NUM1     : " WS-NUM1
   DISPLAY "WS-NUM2     : " WS-NUM2
   DISPLAY "WS-NUM3     : " WS-NUM3
   DISPLAY "WS-NUM4     : " WS-NUM4
   DISPLAY "WS-ADDRESS  : " WS-ADDRESS
   DISPLAY "WS-ADDRESS1 : " WS-ADDRESS1

STOP RUN.

JCL per eseguire il programma COBOL di cui sopra.

//SAMPLE JOB(TESTJCL,XXXXXX),CLASS = A,MSGCLASS = C
//STEP1 EXEC PGM = HELLO

Quando compili ed esegui il programma sopra, produce il seguente risultato:

WS-NUM1     : 123456789
WS-NUM2     : 123456789
WS-NUM3     : 56789
WS-NUM4     : 345678
WS-ADDRESS  : 123INDIA112233
WS-ADDRESS1 : 123INDIA112233

Mosse legali

La tabella seguente fornisce informazioni sulle mosse legali:

Alfabetico Alfanumerico Numerico
Alfabetico Possibile Possibile Non possibile
Alfanumerico Possibile Possibile Possibile
Numerico Non possibile Possibile Possibile

Aggiungi verbo

Aggiungi verbo viene utilizzato per aggiungere due o più numeri e memorizzare il risultato nell'operando di destinazione.

Sintassi

Di seguito è riportata la sintassi per aggiungere due o più numeri:

ADD A B TO C D

ADD A B C TO D GIVING E

ADD CORR WS-GROUP1 TO WS-GROUP2

Nella sintassi-1 vengono aggiunti A, B, C e il risultato viene memorizzato in C (C = A + B + C). A, B, D vengono aggiunti e il risultato viene memorizzato in D (D = A + B + D).

Nella sintassi-2, vengono aggiunti A, B, C, D e il risultato viene memorizzato in E (E = A + B + C + D).

Nella sintassi-3, gli elementi del sottogruppo all'interno di WS-GROUP1 e WS-GROUP2 vengono aggiunti e il risultato viene memorizzato in WS-GROUP2.

Example

IDENTIFICATION DIVISION.
PROGRAM-ID. HELLO.

DATA DIVISION.
   WORKING-STORAGE SECTION.
   01 WS-NUM1 PIC 9(9) VALUE 10 .
   01 WS-NUM2 PIC 9(9) VALUE 10.
   01 WS-NUM3 PIC 9(9) VALUE 10.
   01 WS-NUM4 PIC 9(9) VALUE 10.
   01 WS-NUMA PIC 9(9) VALUE 10.
   01 WS-NUMB PIC 9(9) VALUE 10.
   01 WS-NUMC PIC 9(9) VALUE 10.
   01 WS-NUMD PIC 9(9) VALUE 10.
   01 WS-NUME PIC 9(9) VALUE 10.

PROCEDURE DIVISION.
   ADD WS-NUM1 WS-NUM2 TO WS-NUM3 WS-NUM4.
   ADD WS-NUMA WS-NUMB WS-NUMC TO WS-NUMD GIVING WS-NUME.
   DISPLAY "WS-NUM1     : " WS-NUM1
   DISPLAY "WS-NUM2     : " WS-NUM2
   DISPLAY "WS-NUM3     : " WS-NUM3
   DISPLAY "WS-NUM4     : " WS-NUM4
   DISPLAY "WS-NUMA     : " WS-NUMA
   DISPLAY "WS-NUMB     : " WS-NUMB
   DISPLAY "WS-NUMC     : " WS-NUMC
   DISPLAY "WS-NUMD     : " WS-NUMD
   DISPLAY "WS-NUME     : " WS-NUME

STOP RUN.

JCL per eseguire il programma COBOL di cui sopra -

//SAMPLE JOB(TESTJCL,XXXXXX),CLASS = A,MSGCLASS = C
//STEP1 EXEC PGM = HELLO

Quando compili ed esegui il programma sopra, produce il seguente risultato:

WS-NUM1     : 000000010
WS-NUM2     : 000000010
WS-NUM3     : 000000030
WS-NUM4     : 000000030
WS-NUMA     : 000000010
WS-NUMB     : 000000010
WS-NUMC     : 000000010
WS-NUMD     : 000000010
WS-NUME     : 000000040

Sottrai verbo

Il verbo Sottrai viene utilizzato per le operazioni di sottrazione.

Sintassi

Di seguito è riportata la sintassi per le operazioni di sottrazione:

SUBTRACT A B FROM C D

SUBTRACT A B C FROM D GIVING E

SUBTRACT CORR WS-GROUP1 TO WS-GROUP2

Nella sintassi-1, A e B vengono aggiunti e sottratti da C. Il risultato viene memorizzato in C (C = C- (A + B)). A e B vengono aggiunti e sottratti da D. Il risultato viene memorizzato in D (D = D- (A + B)).

Nella sintassi-2, A, B, C vengono aggiunti e sottratti da D. Il risultato viene memorizzato in E (E = D- (A + B + C))

Nella sintassi-3, gli elementi del sottogruppo all'interno di WS-GROUP1 e WS-GROUP2 vengono sottratti e il risultato viene memorizzato in WS-GROUP2.

Example

IDENTIFICATION DIVISION.
PROGRAM-ID. HELLO.

DATA DIVISION.
   WORKING-STORAGE SECTION.
   01 WS-NUM1 PIC 9(9) VALUE 10 .
   01 WS-NUM2 PIC 9(9) VALUE 10.
   01 WS-NUM3 PIC 9(9) VALUE 100.
   01 WS-NUM4 PIC 9(9) VALUE 100.
   01 WS-NUMA PIC 9(9) VALUE 10.
   01 WS-NUMB PIC 9(9) VALUE 10.
   01 WS-NUMC PIC 9(9) VALUE 10.
   01 WS-NUMD PIC 9(9) VALUE 100.
   01 WS-NUME PIC 9(9) VALUE 10.

PROCEDURE DIVISION.
   SUBTRACT WS-NUM1 WS-NUM2 FROM WS-NUM3 WS-NUM4.
   SUBTRACT WS-NUMA WS-NUMB WS-NUMC FROM WS-NUMD GIVING WS-NUME.

   DISPLAY "WS-NUM1     : " WS-NUM1
   DISPLAY "WS-NUM2     : " WS-NUM2
   DISPLAY "WS-NUM3     : " WS-NUM3
   DISPLAY "WS-NUM4     : " WS-NUM4
   DISPLAY "WS-NUMA     : " WS-NUMA
   DISPLAY "WS-NUMB     : " WS-NUMB
   DISPLAY "WS-NUMC     : " WS-NUMC
   DISPLAY "WS-NUMD     : " WS-NUMD
   DISPLAY "WS-NUME     : " WS-NUME

STOP RUN.

JCL per eseguire il programma COBOL di cui sopra -

//SAMPLE JOB(TESTJCL,XXXXXX),CLASS = A,MSGCLASS = C
//STEP1 EXEC PGM = HELLO

Quando compili ed esegui il programma sopra, produce il seguente risultato:

WS-NUM1     : 000000010
WS-NUM2     : 000000010
WS-NUM3     : 000000080
WS-NUM4     : 000000080
WS-NUMA     : 000000010
WS-NUMB     : 000000010
WS-NUMC     : 000000010
WS-NUMD     : 000000100
WS-NUME     : 000000070

Moltiplica il verbo

Il verbo Moltiplica viene utilizzato per le operazioni di moltiplicazione.

Sintassi

Di seguito è riportata la sintassi per moltiplicare due o più numeri:

MULTIPLY A BY B C

MULTIPLY A BY B GIVING E

Nella sintassi-1, A e B sono moltiplicati e il risultato viene memorizzato in B (B = A * B). A e C sono multiplate e il risultato viene memorizzato in C (C = A * C).

Nella sintassi-2, A e B sono multiplate e il risultato viene memorizzato in E (E = A * B).

Example

IDENTIFICATION DIVISION.
PROGRAM-ID. HELLO.

DATA DIVISION.
   WORKING-STORAGE SECTION.
   01 WS-NUM1 PIC 9(9) VALUE 10 .
   01 WS-NUM2 PIC 9(9) VALUE 10.
   01 WS-NUM3 PIC 9(9) VALUE 10.
   01 WS-NUMA PIC 9(9) VALUE 10.
   01 WS-NUMB PIC 9(9) VALUE 10.
   01 WS-NUMC PIC 9(9) VALUE 10.

PROCEDURE DIVISION.
   MULTIPLY WS-NUM1 BY WS-NUM2 WS-NUM3.
   MULTIPLY WS-NUMA BY WS-NUMB GIVING WS-NUMC.
   
   DISPLAY "WS-NUM1     : " WS-NUM1
   DISPLAY "WS-NUM2     : " WS-NUM2
   DISPLAY "WS-NUM3     : " WS-NUM3
   DISPLAY "WS-NUMA     : " WS-NUMA
   DISPLAY "WS-NUMB     : " WS-NUMB
   DISPLAY "WS-NUMC     : " WS-NUMC
   
STOP RUN.

JCL per eseguire il programma COBOL di cui sopra -

//SAMPLE JOB(TESTJCL,XXXXXX),CLASS = A,MSGCLASS = C
//STEP1 EXEC PGM = HELLO

Quando compili ed esegui il programma sopra, produce il seguente risultato:

WS-NUM1     : 000000010
WS-NUM2     : 000000100
WS-NUM3     : 000000100
WS-NUMA     : 000000010
WS-NUMB     : 000000010
WS-NUMC     : 000000100

Divide Verb

Il verbo Divide viene utilizzato per le operazioni di divisione.

Sintassi

Di seguito è riportata la sintassi per le operazioni di divisione:

DIVIDE A INTO B

DIVIDE A BY B GIVING C REMAINDER R

Nella sintassi-1, B è diviso per A e il risultato viene memorizzato in B (B = B / A).

Nella sintassi-2, A è diviso per B e il risultato è memorizzato in C (C = A / B) e il resto è memorizzato in R.

Example

IDENTIFICATION DIVISION.
PROGRAM-ID. HELLO.

DATA DIVISION.
   WORKING-STORAGE SECTION.
   01 WS-NUM1 PIC 9(9) VALUE 5.
   01 WS-NUM2 PIC 9(9) VALUE 250.
   01 WS-NUMA PIC 9(9) VALUE 100.
   01 WS-NUMB PIC 9(9) VALUE 15.
   01 WS-NUMC PIC 9(9).
   01 WS-REM PIC 9(9). 

PROCEDURE DIVISION.
   DIVIDE WS-NUM1 INTO WS-NUM2.
   DIVIDE WS-NUMA BY WS-NUMB GIVING WS-NUMC REMAINDER WS-REM.
   DISPLAY "WS-NUM1     : " WS-NUM1
   DISPLAY "WS-NUM2     : " WS-NUM2
   DISPLAY "WS-NUMA     : " WS-NUMA
   DISPLAY "WS-NUMB     : " WS-NUMB
   DISPLAY "WS-NUMC     : " WS-NUMC
   DISPLAY "WS-REM      : " WS-REM
   
STOP RUN.

JCL per eseguire il programma COBOL di cui sopra -

//SAMPLE JOB(TESTJCL,XXXXXX),CLASS = A,MSGCLASS = C
//STEP1 EXEC PGM = HELLO

Quando compili ed esegui il programma sopra, produce il seguente risultato:

WS-NUM1     : 000000005
WS-NUM2     : 000000050
WS-NUMA     : 000000100
WS-NUMB     : 000000015
WS-NUMC     : 000000006
WS-REM      : 000000010

Istruzione Compute

L'istruzione Compute viene utilizzata per scrivere espressioni aritmetiche in COBOL. Questo è un sostituto per Aggiungi, Sottrai, Moltiplica e Dividi.

Example

IDENTIFICATION DIVISION.
PROGRAM-ID. HELLO.

DATA DIVISION.
   WORKING-STORAGE SECTION.
   01 WS-NUM1 PIC 9(9) VALUE 10 .
   01 WS-NUM2 PIC 9(9) VALUE 10.
   01 WS-NUM3 PIC 9(9) VALUE 10.
   01 WS-NUMA PIC 9(9) VALUE 50.
   01 WS-NUMB PIC 9(9) VALUE 10.
   01 WS-NUMC PIC 9(9).

PROCEDURE DIVISION.
   COMPUTE WS-NUMC= (WS-NUM1 * WS-NUM2) - (WS-NUMA / WS-NUMB) + WS-NUM3.
   DISPLAY "WS-NUM1     : " WS-NUM1
   DISPLAY "WS-NUM2     : " WS-NUM2
   DISPLAY "WS-NUM3     : " WS-NUM3
   DISPLAY "WS-NUMA     : " WS-NUMA
   DISPLAY "WS-NUMB     : " WS-NUMB
   DISPLAY "WS-NUMC     : " WS-NUMC

STOP RUN.

JCL per eseguire il programma COBOL di cui sopra.

//SAMPLE JOB(TESTJCL,XXXXXX),CLASS = A,MSGCLASS = C
//STEP1 EXEC PGM = HELLO

Quando compili ed esegui il programma sopra, produce il seguente risultato:

WS-NUM1     : 000000010
WS-NUM2     : 000000010
WS-NUM3     : 000000010
WS-NUMA     : 000000050
WS-NUMB     : 000000010
WS-NUMC     : 000000105

Il layout COBOL è la descrizione dell'utilizzo di ogni campo e dei valori in esso presenti. Di seguito sono riportate le voci di descrizione dei dati utilizzate in COBOL:

  • Ridefinisce la clausola
  • Rinomina clausola
  • Clausola di utilizzo
  • Copybooks

Ridefinisce la clausola

La clausola Redefines viene utilizzata per definire una memoria con una descrizione dei dati diversa. Se uno o più elementi di dati non vengono utilizzati contemporaneamente, è possibile utilizzare la stessa memoria per un altro elemento di dati. Quindi la stessa memoria può essere riferita a diversi elementi di dati.

Sintassi

Di seguito è riportata la sintassi per la clausola Redefines:

01 WS-OLD PIC X(10).
01 WS-NEW1 REDEFINES WS-OLD PIC 9(8).
01 WS-NEW2 REDEFINES WS-OLD PIC A(10).

Di seguito sono riportati i dettagli dei parametri utilizzati:

  • WS-OLD è un articolo ridefinito
  • WS-NEW1 e WS-NEW2 stanno ridefinendo l'elemento

I numeri di livello dell'elemento ridefinito e l'elemento ridefinito devono essere gli stessi e non può essere un numero di livello 66 o 88. Non utilizzare la clausola VALUE con un elemento di ridefinizione. Nella sezione File, non utilizzare una clausola di ridefinizione con numero di livello 01. La definizione di ridefinizione deve essere la successiva descrizione dei dati che si desidera ridefinire. Un elemento ridefinito avrà sempre lo stesso valore di un elemento ridefinito.

Example

IDENTIFICATION DIVISION.
PROGRAM-ID. HELLO.

DATA DIVISION.
   WORKING-STORAGE SECTION.
   01 WS-DESCRIPTION.
   05 WS-DATE1 VALUE '20140831'.
   10 WS-YEAR PIC X(4).
   10 WS-MONTH PIC X(2).
   10 WS-DATE PIC X(2).
   05 WS-DATE2 REDEFINES WS-DATE1 PIC 9(8).

PROCEDURE DIVISION.
   DISPLAY "WS-DATE1 : "WS-DATE1.
   DISPLAY "WS-DATE2 : "WS-DATE2.

STOP RUN.

JCL per eseguire il programma COBOL di cui sopra -

//SAMPLE JOB(TESTJCL,XXXXXX),CLASS = A,MSGCLASS = C
//STEP1 EXEC PGM = HELLO

Quando compili ed esegui il programma sopra, produce il seguente risultato:

WS-DATE1 : 20140831
WS-DATE2 : 20140831

Rinomina clausola

La clausola Renames viene utilizzata per assegnare nomi diversi agli elementi di dati esistenti. Viene utilizzato per raggruppare nuovamente i nomi dei dati e dare loro un nuovo nome. I nuovi nomi di dati possono essere rinominati in gruppi o elementi elementari. Il livello numero 66 è riservato per le ridenominazioni.

Syntax

Di seguito è riportata la sintassi per la clausola Renames -

01 WS-OLD.
10 WS-A PIC 9(12).
10 WS-B PIC X(20).
10 WS-C PIC A(25).
10 WS-D PIC X(12).
66 WS-NEW RENAMES WS-A THRU WS-C.

È possibile rinominare solo allo stesso livello. Nell'esempio precedente, WS-A, WS-B e WS-C sono allo stesso livello. La definizione di ridenominazione deve essere la successiva descrizione dei dati che si desidera rinominare. Non utilizzare Rinomina con un numero di livello 01, 77 o 66. I nomi dei dati utilizzati per le ridenominazioni devono essere in sequenza. Non è possibile rinominare gli elementi di dati con clausola occorrenza.

Example

IDENTIFICATION DIVISION.
PROGRAM-ID. HELLO.

DATA DIVISION.
   WORKING-STORAGE SECTION.
   01 WS-DESCRIPTION.
   05 WS-NUM.
   10 WS-NUM1 PIC 9(2) VALUE 20.
   10 WS-NUM2 PIC 9(2) VALUE 56.
   05 WS-CHAR.
   10 WS-CHAR1 PIC X(2) VALUE 'AA'.
   10 WS-CHAR2 PIC X(2) VALUE 'BB'.
   66 WS-RENAME RENAMES WS-NUM2 THRU WS-CHAR2.

PROCEDURE DIVISION.
   DISPLAY "WS-RENAME : " WS-RENAME.
   
STOP RUN.

JCL per eseguire il programma COBOL di cui sopra -

//SAMPLE JOB(TESTJCL,XXXXXX),CLASS = A,MSGCLASS = C
//STEP1 EXEC PGM = HELLO

Quando compili ed esegui il programma sopra, produce il seguente risultato:

WS-RENAME : 56AABB

Clausola di utilizzo

La clausola di utilizzo specifica il sistema operativo in cui vengono archiviati i dati in formato. Non può essere utilizzato con i numeri di livello 66 o 88. Se la clausola di utilizzo è specificata in un gruppo, tutti gli elementi elementari avranno la stessa clausola di utilizzo. Le diverse opzioni disponibili con la clausola di utilizzo sono le seguenti:

Schermo

L'elemento di dati è memorizzato in formato ASCII e ogni carattere richiederà 1 byte. È l'utilizzo predefinito.

L'esempio seguente calcola il numero di byte richiesti:

01 WS-NUM PIC S9(5)V9(3) USAGE IS DISPLAY.
It requires 8 bytes as sign and decimal doesn't require any byte.

01 WS-NUM PIC 9(5) USAGE IS DISPLAY.
It requires 5 bytes as sign.

COMPUTAZIONALE / COMP

L'elemento dati è archiviato in formato binario. Qui, gli elementi di dati devono essere interi.

L'esempio seguente calcola il numero di byte richiesti:

01 WS-NUM PIC S9(n) USAGE IS COMP.

If 'n' = 1 to 4, it takes 2 bytes.
If 'n' = 5 to 9, it takes 4 bytes.
If 'n' = 10 to 18, it takes 8 bytes.

COMP-1

L'elemento dati è simile a Real o Float ed è rappresentato come un numero in virgola mobile a precisione singola. Internamente, i dati vengono archiviati in formato esadecimale. COMP-1 non accetta la clausola PIC. Qui 1 parola è uguale a 4 byte.

COMP-2

L'elemento dati è simile a Long o Double ed è rappresentato come numero in virgola mobile a doppia precisione. Internamente, i dati vengono archiviati in formato esadecimale. COMP-2 non specifica la clausola PIC. Qui 2 parole equivalgono a 8 byte.

COMP-3

L'elemento di dati viene memorizzato in formato decimale compresso. Ogni cifra occupa mezzo byte (1 nibble) e il segno viene memorizzato nel nibble più a destra.

L'esempio seguente calcola il numero di byte richiesti:

01 WS-NUM PIC 9(n) USAGE IS COMP.
Number of bytes = n/2 (If n is even)
Number of bytes = n/2 + 1(If n is odd, consider only integer part)

01 WS-NUM PIC 9(4) USAGE IS COMP-3 VALUE 21.
It requires 2 bytes of storage as each digit occupies half a byte.

01 WS-NUM PIC 9(5) USAGE IS COMP-3 VALUE 21.
It requires 3 bytes of storage as each digit occupies half a byte.

Quaderni

Un quaderno COBOL è una selezione di codice che definisce le strutture di dati. Se una particolare struttura dati viene utilizzata in molti programmi, invece di scrivere di nuovo la stessa struttura dati, possiamo usare i quaderni. Usiamo l'istruzione COPY per includere un quaderno in un programma. L'istruzione COPY viene utilizzata nella sezione WorkingStorage.

Il seguente esempio include un quaderno all'interno di un programma COBOL -

DATA DIVISION.
WORKING-STORAGE SECTION.
COPY ABC.

Qui ABC è il nome del quaderno. I seguenti elementi di dati nel quaderno ABC possono essere utilizzati all'interno di un programma.

01 WS-DESCRIPTION.
   05 WS-NUM.
      10 WS-NUM1 PIC 9(2) VALUE 20.
      10 WS-NUM2 PIC 9(2) VALUE 56.
   05 WS-CHAR.
      10 WS-CHAR1 PIC X(2) VALUE 'AA'.
      10 WS-CHAR2 PIC X(2) VALUE 'BB'.

Le istruzioni condizionali vengono utilizzate per modificare il flusso di esecuzione in base a determinate condizioni specificate dal programmatore. Le dichiarazioni condizionali restituiranno sempre vero o falso. Le condizioni vengono utilizzate nelle istruzioni IF, Evaluate e Perform. I diversi tipi di condizioni sono i seguenti:

  • Dichiarazione delle condizioni IF
  • Condizione di relazione
  • Condizione del segno
  • Condizione di classe
  • Condizione-nome Condizione
  • Condizione negata
  • Condizione combinata

Dichiarazione delle condizioni IF

L'istruzione IF verifica le condizioni. Se una condizione è vera, viene eseguito il blocco IF; e se la condizione è falsa, viene eseguito il blocco ELSE.

END-IFviene utilizzato per terminare il blocco IF. Per terminare il blocco IF, è possibile utilizzare un punto invece di END-IF. Ma è sempre preferibile utilizzare END-IF per più blocchi IF.

Nested-IF- Blocchi IF che compaiono all'interno di un altro blocco IF. Non c'è limite alla profondità delle istruzioni IF annidate.

Sintassi

Di seguito è riportata la sintassi delle istruzioni di condizione IF:

IF [condition] THEN
   [COBOL statements]
ELSE
   [COBOL statements]
END-IF.

Example

IDENTIFICATION DIVISION.
PROGRAM-ID. HELLO.

DATA DIVISION.
   WORKING-STORAGE SECTION.
   01 WS-NUM1 PIC 9(9).
   01 WS-NUM2 PIC 9(9).
   01 WS-NUM3 PIC 9(5).
   01 WS-NUM4 PIC 9(6).

PROCEDURE DIVISION.
   A000-FIRST-PARA.
   MOVE 25 TO WS-NUM1 WS-NUM3.
   MOVE 15 TO WS-NUM2 WS-NUM4.
   
   IF WS-NUM1 > WS-NUM2 THEN
      DISPLAY 'IN LOOP 1 - IF BLOCK'
      
      IF WS-NUM3 = WS-NUM4 THEN
         DISPLAY 'IN LOOP 2 - IF BLOCK'
      ELSE
         DISPLAY 'IN LOOP 2 - ELSE BLOCK'
      END-IF
      
   ELSE
      DISPLAY 'IN LOOP 1 - ELSE BLOCK'
   END-IF.
   
STOP RUN.

JCL per eseguire il programma COBOL di cui sopra -

//SAMPLE JOB(TESTJCL,XXXXXX),CLASS = A,MSGCLASS = C
//STEP1 EXEC PGM = HELLO

Quando compili ed esegui il programma sopra, produce il seguente risultato:

IN LOOP 1 - IF BLOCK
IN LOOP 2 - ELSE BLOCK

Condizione di relazione

La condizione di relazione confronta due operandi, uno dei quali può essere un identificatore, un'espressione letterale o aritmetica. Il confronto algebrico dei campi numerici viene eseguito indipendentemente dalle dimensioni e dalla clausola di utilizzo.

For non-numeric operands

Se vengono confrontati due operandi non numerici di uguale dimensione, i caratteri vengono confrontati da sinistra con le posizioni corrispondenti fino al raggiungimento della fine. L'operando contenente un numero maggiore di caratteri viene dichiarato maggiore.

Se vengono confrontati due operandi non numerici di dimensione diversa, l'elemento di dati più corto viene aggiunto con spazi alla fine fino a quando la dimensione degli operandi diventa uguale e quindi confrontato secondo le regole menzionate al punto precedente.

Sintassi

Di seguito è riportata la sintassi delle istruzioni sulle condizioni di relazione:

[Data Name/Arithmetic Operation]

   [IS] [NOT] 

[Equal to (=),Greater than (>), Less than (<), 
Greater than or Equal (>=), Less than or equal (<=) ]

[Data Name/Arithmetic Operation]

Example

IDENTIFICATION DIVISION.
PROGRAM-ID. HELLO.

DATA DIVISION.
   WORKING-STORAGE SECTION.
   01 WS-NUM1 PIC 9(9).
   01 WS-NUM2 PIC 9(9).

PROCEDURE DIVISION.
   A000-FIRST-PARA.
   MOVE 25 TO WS-NUM1.
   MOVE 15 TO WS-NUM2.
   
   IF WS-NUM1 IS GREATER THAN OR EQUAL TO WS-NUM2 THEN
      DISPLAY 'WS-NUM1 IS GREATER THAN WS-NUM2'
   ELSE
      DISPLAY 'WS-NUM1 IS LESS THAN WS-NUM2'
   END-IF.
   
STOP RUN.

JCL per eseguire il programma COBOL di cui sopra -

//SAMPLE JOB(TESTJCL,XXXXXX),CLASS = A,MSGCLASS = C
//STEP1 EXEC PGM = HELLO

Quando compili ed esegui il programma sopra, produce il seguente risultato:

WS-NUM1 IS GREATER THAN WS-NUM2

Condizione del segno

La condizione del segno viene utilizzata per controllare il segno di un operando numerico. Determina se un dato valore numerico è maggiore, minore o uguale a ZERO.

Sintassi

Di seguito è riportata la sintassi delle istruzioni sulla condizione dei segni:

[Data Name/Arithmetic Operation] 

   [IS] [NOT] 

[Positive, Negative or Zero]

[Data Name/Arithmetic Operation]

Example

IDENTIFICATION DIVISION.
PROGRAM-ID. HELLO.

DATA DIVISION.
   WORKING-STORAGE SECTION.
   01 WS-NUM1 PIC S9(9) VALUE -1234.
   01 WS-NUM2 PIC S9(9) VALUE 123456.

PROCEDURE DIVISION.
   A000-FIRST-PARA.
   IF WS-NUM1 IS POSITIVE THEN
      DISPLAY 'WS-NUM1 IS POSITIVE'.
      
   IF WS-NUM1 IS NEGATIVE THEN
      DISPLAY 'WS-NUM1 IS NEGATIVE'.
      
   IF WS-NUM1 IS ZERO THEN
      DISPLAY 'WS-NUM1 IS ZERO'.
      
   IF WS-NUM2 IS POSITIVE THEN
      DISPLAY 'WS-NUM2 IS POSITIVE'.

STOP RUN.

JCL per eseguire il programma COBOL di cui sopra -

//SAMPLE JOB(TESTJCL,XXXXXX),CLASS = A,MSGCLASS = C
//STEP1 EXEC PGM = HELLO

Quando compili ed esegui il programma sopra, produce il seguente risultato:

WS-NUM1 IS NEGATIVE
WS-NUM2 IS POSITIVE

Condizione di classe

La condizione della classe viene utilizzata per verificare se un operando contiene solo alfabeti o dati numerici. Gli spazi sono considerati in ALFABETICO, ALFABETICO-INFERIORE e ALFABETICO-SUPERIORE.

Sintassi

Di seguito è riportata la sintassi delle istruzioni di condizione della classe:

[Data Name/Arithmetic Operation>]

   [IS] [NOT] 

[NUMERIC, ALPHABETIC, ALPHABETIC-LOWER, ALPHABETIC-UPPER]

[Data Name/Arithmetic Operation]

Example

IDENTIFICATION DIVISION.
PROGRAM-ID. HELLO.

DATA DIVISION.
   WORKING-STORAGE SECTION.
   01 WS-NUM1 PIC X(9) VALUE 'ABCD '.
   01 WS-NUM2 PIC 9(9) VALUE 123456789.

PROCEDURE DIVISION.
   A000-FIRST-PARA.
   
   IF WS-NUM1 IS ALPHABETIC THEN
      DISPLAY 'WS-NUM1 IS ALPHABETIC'.
      
   IF WS-NUM1 IS NUMERIC THEN
      DISPLAY 'WS-NUM1 IS NUMERIC'.
      
   IF WS-NUM2 IS NUMERIC THEN
      DISPLAY 'WS-NUM2 IS NUMERIC'.
   
STOP RUN.

JCL per eseguire il programma COBOL di cui sopra -

//SAMPLE JOB(TESTJCL,XXXXXX),CLASS = A,MSGCLASS = C
//STEP1 EXEC PGM = HELLO

Quando compili ed esegui il programma sopra, produce il seguente risultato:

WS-NUM1 IS ALPHABETIC
WS-NUM2 IS NUMERIC

Condizione-nome Condizione

Un nome-condizione è un nome definito dall'utente. Contiene una serie di valori specificati dall'utente. Si comporta come le variabili booleane. Sono definiti con il numero di livello 88. Non avrà una clausola PIC.

Sintassi

Di seguito è riportata la sintassi delle istruzioni condizionali definite dall'utente:

88 [Condition-Name] VALUE [IS, ARE] [LITERAL] [THRU LITERAL].

Example

IDENTIFICATION DIVISION.
PROGRAM-ID. HELLO.

DATA DIVISION.
   WORKING-STORAGE SECTION.
   01 WS-NUM PIC 9(3).
   88 PASS VALUES ARE 041 THRU 100.
   88 FAIL VALUES ARE 000 THRU 40.

PROCEDURE DIVISION.
   A000-FIRST-PARA.
   MOVE 65 TO WS-NUM.
   
   IF PASS 
      DISPLAY 'Passed with ' WS-NUM ' marks'.
      
   IF FAIL 
      DISPLAY 'FAILED with ' WS-NUM 'marks'.
      
STOP RUN.

JCL per eseguire il programma COBOL di cui sopra -

//SAMPLE JOB(TESTJCL,XXXXXX),CLASS = A,MSGCLASS = C
//STEP1 EXEC PGM = HELLO

Quando compili ed esegui il programma sopra, produce il seguente risultato:

Passed with 065 marks

Condizione negata

La condizione negata viene fornita utilizzando la parola chiave NOT. Se una condizione è vera e abbiamo dato NON davanti ad essa, il suo valore finale sarà falso.

Sintassi

Di seguito è riportata la sintassi delle istruzioni di condizione negata:

IF NOT [CONDITION] 
   COBOL Statements
END-IF.

Example

IDENTIFICATION DIVISION.
PROGRAM-ID. HELLO.

DATA DIVISION.
   WORKING-STORAGE SECTION.
   01 WS-NUM1 PIC 9(2) VALUE 20.
   01 WS-NUM2 PIC 9(9) VALUE 25.

PROCEDURE DIVISION.
   A000-FIRST-PARA.
   
   IF NOT WS-NUM1 IS LESS THAN WS-NUM2 THEN
      DISPLAY 'IF-BLOCK'
   ELSE
      DISPLAY 'ELSE-BLOCK'
   END-IF.
   
STOP RUN.

JCL per eseguire il programma COBOL di cui sopra -

//SAMPLE JOB(TESTJCL,XXXXXX),CLASS = A,MSGCLASS = C
//STEP1 EXEC PGM = HELLO

Quando compili ed esegui il programma sopra, produce il seguente risultato:

ELSE-BLOCK

Condizione combinata

Una condizione combinata contiene due o più condizioni collegate tramite operatori logici AND o OR.

Sintassi

Di seguito è riportata la sintassi delle istruzioni di condizione combinate:

IF [CONDITION] AND [CONDITION]
   COBOL Statements
END-IF.

Example

IDENTIFICATION DIVISION.
PROGRAM-ID. HELLO.

DATA DIVISION.
   WORKING-STORAGE SECTION.
   01 WS-NUM1 PIC 9(2) VALUE 20.
   01 WS-NUM2 PIC 9(2) VALUE 25.
   01 WS-NUM3 PIC 9(2) VALUE 20.

PROCEDURE DIVISION.
   A000-FIRST-PARA.
   
   IF WS-NUM1 IS LESS THAN WS-NUM2 AND WS-NUM1=WS-NUM3 THEN
      DISPLAY 'Both condition OK'
   ELSE
      DISPLAY 'Error'
   END-IF.
   
STOP RUN.

JCL per eseguire il programma COBOL di cui sopra -

//SAMPLE JOB(TESTJCL,XXXXXX),CLASS = A,MSGCLASS = C
//STEP1 EXEC PGM = HELLO

Quando compili ed esegui il programma sopra, produce il seguente risultato:

Both condition OK

Valuta il verbo

Il verbo di valutazione è una sostituzione di una serie di istruzioni IF-ELSE. Può essere utilizzato per valutare più di una condizione. È simile all'istruzione SWITCH nei programmi C.

Example

IDENTIFICATION DIVISION.
PROGRAM-ID. HELLO.

DATA DIVISION.
   WORKING-STORAGE SECTION.
   01 WS-A PIC 9 VALUE 0.
   
PROCEDURE DIVISION.
   MOVE 3 TO WS-A.
   
   EVALUATE TRUE
      WHEN WS-A > 2
         DISPLAY 'WS-A GREATER THAN 2'

      WHEN WS-A < 0
         DISPLAY 'WS-A LESS THAN 0'

      WHEN OTHER
         DISPLAY 'INVALID VALUE OF WS-A'
   END-EVALUATE.
   
STOP RUN.

JCL per eseguire il programma COBOL di cui sopra -

//SAMPLE JOB(TESTJCL,XXXXXX),CLASS = A,MSGCLASS = C
//STEP1 EXEC PGM = HELLO

Quando compili ed esegui il programma sopra, produce il seguente risultato:

WS-A GREATER THAN 2

Ci sono alcune attività che devono essere ripetute più e più volte come leggere ogni record di un file fino alla sua fine. Le istruzioni del ciclo utilizzate in COBOL sono:

  • Esegui Thru
  • Esegui fino a
  • Esegui volte
  • Eseguire Varying

Esegui Thru

Perform Thru viene utilizzato per eseguire una serie di paragrafi assegnando il nome del primo e dell'ultimo paragrafo nella sequenza. Dopo aver eseguito l'ultimo paragrafo, il controllo viene restituito.

Performance in linea

Le istruzioni all'interno di PERFORM verranno eseguite fino al raggiungimento di END-PERFORM.

Sintassi

Di seguito è riportata la sintassi di In-line perform -

PERFORM 
   DISPLAY 'HELLO WORLD'
END-PERFORM.

Performance fuori linea

Qui, un'istruzione viene eseguita in un paragrafo e quindi il controllo viene trasferito a un altro paragrafo o sezione.

Sintassi

Di seguito è riportata la sintassi di Esecuzione fuori linea:

PERFORM PARAGRAPH1 THRU PARAGRAPH2

Example

IDENTIFICATION DIVISION.
PROGRAM-ID. HELLO.

PROCEDURE DIVISION.
   A-PARA.
   PERFORM DISPLAY 'IN A-PARA'
   END-PERFORM.
   PERFORM C-PARA THRU E-PARA.
   
   B-PARA.
   DISPLAY 'IN B-PARA'.
   STOP RUN.
   
   C-PARA.
   DISPLAY 'IN C-PARA'.
   
   D-PARA.
   DISPLAY 'IN D-PARA'.
   
   E-PARA.
   DISPLAY 'IN E-PARA'.

JCL per eseguire il programma COBOL di cui sopra.

//SAMPLE JOB(TESTJCL,XXXXXX),CLASS = A,MSGCLASS = C
//STEP1 EXEC PGM = HELLO

Quando compili ed esegui il programma sopra, produce il seguente risultato:

IN A-PARA
IN C-PARA
IN D-PARA
IN E-PARA
IN B-PARA

Esegui fino a

In "esegui fino a", un paragrafo viene eseguito finché la condizione data non diventa vera. 'With test before' è la condizione predefinita e indica che la condizione è verificata prima dell'esecuzione delle istruzioni in un paragrafo.

Sintassi

Di seguito è riportata la sintassi di eseguire fino a:

PERFORM A-PARA UNTIL COUNT=5

PERFORM A-PARA WITH TEST BEFORE UNTIL COUNT=5

PERFORM A-PARA WITH TEST AFTER UNTIL COUNT=5

Example

IDENTIFICATION DIVISION.
PROGRAM-ID. HELLO.

DATA DIVISION.
   WORKING-STORAGE SECTION.
   01 WS-CNT PIC 9(1) VALUE 0. 

PROCEDURE DIVISION.
   A-PARA.
   PERFORM B-PARA WITH TEST AFTER UNTIL WS-CNT>3.
   STOP RUN.
   
   B-PARA.
   DISPLAY 'WS-CNT : 'WS-CNT.
   ADD 1 TO WS-CNT.

JCL per eseguire il programma COBOL di cui sopra -

//SAMPLE JOB(TESTJCL,XXXXXX),CLASS = A,MSGCLASS = C
//STEP1 EXEC PGM = HELLO

Quando compili ed esegui il programma sopra, produce il seguente risultato:

WS-CNT : 0
WS-CNT : 1
WS-CNT : 2
WS-CNT : 3

Esegui volte

In "tempi di esecuzione", un paragrafo verrà eseguito il numero di volte specificato.

Sintassi

Di seguito è riportata la sintassi dei tempi di esecuzione:

PERFORM A-PARA 5 TIMES.

Example

IDENTIFICATION DIVISION.
PROGRAM-ID. HELLO.

PROCEDURE DIVISION.
   A-PARA.
   PERFORM B-PARA 3 TIMES.
   STOP RUN.
   
   B-PARA.
   DISPLAY 'IN B-PARA'.

JCL per eseguire il programma COBOL di cui sopra -

//SAMPLE JOB(TESTJCL,XXXXXX),CLASS = A,MSGCLASS = C
//STEP1 EXEC PGM = HELLO

Quando compili ed esegui il programma sopra, produce il seguente risultato:

IN B-PARA
IN B-PARA
IN B-PARA

Eseguire Varying

Nella variazione di esecuzione, verrà eseguito un paragrafo fino a quando la condizione in Until phrase diventa vera.

Sintassi

Di seguito è riportata la sintassi per eseguire variazioni:

PERFORM A-PARA VARYING A FROM 1 BY 1 UNTIL A = 5.

Example

IDENTIFICATION DIVISION.
PROGRAM-ID. HELLO.

DATA DIVISION.
   WORKING-STORAGE SECTION.
   01 WS-A PIC 9 VALUE 0.

PROCEDURE DIVISION.
   A-PARA.
   PERFORM B-PARA VARYING WS-A FROM 1 BY 1 UNTIL WS-A=5
   STOP RUN.
   
   B-PARA.
   DISPLAY 'IN B-PARA ' WS-A.

JCL per eseguire il programma COBOL di cui sopra -

//SAMPLE JOB(TESTJCL,XXXXXX),CLASS = A,MSGCLASS = C
//STEP1 EXEC PGM = HELLO

Quando compili ed esegui il programma sopra, produce il seguente risultato:

IN B-PARA 1
IN B-PARA 2
IN B-PARA 3
IN B-PARA 4

VAI A Statement

L'istruzione GO TO viene utilizzata per modificare il flusso di esecuzione in un programma. Nelle istruzioni VAI A, il trasferimento avviene solo in avanti. Viene utilizzato per uscire da un paragrafo. I diversi tipi di istruzioni GO TO utilizzati sono i seguenti:

Incondizionato VAI A

GO TO para-name.

Condizionale VAI A

GO TO para-1 para-2 para-3 DEPENDING ON x.

Se "x" è uguale a 1, il controllo verrà trasferito al primo paragrafo; e se "x" è uguale a 2, il controllo verrà trasferito al secondo paragrafo e così via.

Example

IDENTIFICATION DIVISION.
PROGRAM-ID. HELLO.

DATA DIVISION.
   WORKING-STORAGE SECTION.
   01 WS-A PIC 9 VALUE 2.
   
PROCEDURE DIVISION.
   A-PARA.
   DISPLAY 'IN A-PARA'
   GO TO B-PARA.
   
   B-PARA.
   DISPLAY 'IN B-PARA '.
   GO TO C-PARA D-PARA DEPENDING ON WS-A.
   
   C-PARA.
   DISPLAY 'IN C-PARA '.
   
   D-PARA.
   DISPLAY 'IN D-PARA '.
   STOP RUN.

JCL per eseguire il programma COBOL di cui sopra:

//SAMPLE JOB(TESTJCL,XXXXXX),CLASS = A,MSGCLASS = C
//STEP1 EXEC PGM = HELLO

Quando compili ed esegui il programma sopra, produce il seguente risultato:

IN A-PARA
IN B-PARA 
IN D-PARA

Le istruzioni per la gestione delle stringhe in COBOL vengono utilizzate per eseguire più operazioni funzionali sulle stringhe. Di seguito sono riportate le istruzioni per la gestione delle stringhe:

  • Inspect
  • String
  • Unstring

Ispezionare

Il verbo Inspect viene utilizzato per contare o sostituire i caratteri in una stringa. Le operazioni sulle stringhe possono essere eseguite su valori alfanumerici, numerici o alfabetici. Le operazioni di ispezione vengono eseguite da sinistra a destra. Le opzioni utilizzate per le operazioni sulle stringhe sono le seguenti:

Conteggio

L'opzione di conteggio viene utilizzata per contare i caratteri della stringa.

Syntax

Di seguito è riportata la sintassi dell'opzione Tallying:

INSPECT input-string
TALLYING output-count FOR ALL CHARACTERS

I parametri utilizzati sono:

  • input-string - La stringa i cui caratteri devono essere contati.
  • output-count - Elemento dati per contenere il conteggio dei caratteri.

Example

IDENTIFICATION DIVISION.
PROGRAM-ID. HELLO.

DATA DIVISION.
   WORKING-STORAGE SECTION.
   01 WS-CNT1 PIC 9(2) VALUE 0.
   01 WS-CNT2 PIC 9(2) VALUE 0.
   01 WS-STRING PIC X(15) VALUE 'ABCDACDADEAAAFF'.
   
PROCEDURE DIVISION.
   INSPECT WS-STRING TALLYING WS-CNT1 FOR CHARACTER.
   DISPLAY "WS-CNT1 : "WS-CNT1.
   INSPECT WS-STRING TALLYING WS-CNT2 FOR ALL 'A'.
   DISPLAY "WS-CNT2 : "WS-CNT2
   
STOP RUN.

JCL per eseguire il programma COBOL di cui sopra.

//SAMPLE JOB(TESTJCL,XXXXXX),CLASS = A,MSGCLASS = C
//STEP1 EXEC PGM = HELLO

Quando compili ed esegui il programma sopra, produce il seguente risultato:

WS-CNT1 : 15
WS-CNT2 : 06

Sostituzione

L'opzione di sostituzione viene utilizzata per sostituire i caratteri della stringa.

Syntax

Di seguito è riportata la sintassi dell'opzione Sostituzione:

INSPECT input-string REPLACING ALL char1 BY char2.

Il parametro utilizzato è -

  • input-string - La stringa i cui caratteri devono essere sostituiti da char1 a char2.

Example

IDENTIFICATION DIVISION.
PROGRAM-ID. HELLO.

DATA DIVISION.
   WORKING-STORAGE SECTION.
   01 WS-STRING PIC X(15) VALUE 'ABCDACDADEAAAFF'.

PROCEDURE DIVISION.
   DISPLAY "OLD STRING : "WS-STRING.
   INSPECT WS-STRING REPLACING ALL 'A' BY 'X'.
   DISPLAY "NEW STRING : "WS-STRING.
   
STOP RUN.

JCL per eseguire il programma COBOL di cui sopra.

//SAMPLE JOB(TESTJCL,XXXXXX),CLASS = A,MSGCLASS = C
//STEP1 EXEC PGM = HELLO

Quando compili ed esegui il programma sopra, produce il seguente risultato:

OLD STRING : ABCDACDADEAAAFF
NEW STRING : XBCDXCDXDEXXXFF

Corda

Il verbo String viene utilizzato per concatenare le stringhe. Utilizzando l'istruzione STRING, è possibile combinare due o più stringhe di caratteri per formare una stringa più lunga. La clausola "Delimitato da" è obbligatoria.

Syntax

Di seguito è riportata la sintassi del verbo String -

STRING ws-string1 DELIMITED BY SPACE
   ws-string2 DELIMITED BY SIZE
   INTO ws-destination-string
   WITH POINTER ws-count
   ON OVERFLOW DISPLAY message1
   NOT ON OVERFLOW DISPLAY message2
END-STRING.

Di seguito sono riportati i dettagli dei parametri utilizzati:

  • ws-string1 e ws-string2: stringhe di input da concatenare
  • ws-string: stringa di output
  • ws-count: usato per contare la lunghezza della nuova stringa concatenata
  • Delimitato specifica la fine della stringa
  • Il puntatore e l'overflow sono opzionali

Example

IDENTIFICATION DIVISION.
PROGRAM-ID. HELLO.

DATA DIVISION.
   WORKING-STORAGE SECTION.
   01 WS-STRING PIC A(30).
   01 WS-STR1 PIC A(15) VALUE 'Tutorialspoint'.
   01 WS-STR2 PIC A(7) VALUE 'Welcome'.
   01 WS-STR3 PIC A(7) VALUE 'To AND'.
   01 WS-COUNT PIC 99 VALUE 1.

PROCEDURE DIVISION.
   STRING WS-STR2 DELIMITED BY SIZE
      WS-STR3 DELIMITED BY SPACE
      WS-STR1 DELIMITED BY SIZE
      INTO WS-STRING 
      WITH POINTER WS-COUNT
      ON OVERFLOW DISPLAY 'OVERFLOW!' 
   END-STRING.
   
   DISPLAY 'WS-STRING : 'WS-STRING.
   DISPLAY 'WS-COUNT : 'WS-COUNT.

STOP RUN.

JCL per eseguire il programma COBOL di cui sopra -

//SAMPLE JOB(TESTJCL,XXXXXX),CLASS = A,MSGCLASS = C
//STEP1 EXEC PGM = HELLO

Quando compili ed esegui il programma sopra, produce il seguente risultato:

WS-STRING : WelcomeToTutorialspoint       
WS-COUNT : 25

Unstring

Il verbo Unstring viene utilizzato per dividere una stringa in più sottostringhe. La clausola Delimitato da è obbligatoria.

Syntax

Di seguito è riportata la sintassi del verbo Unstring -

UNSTRING ws-string DELIMITED BY SPACE
INTO ws-str1, ws-str2
WITH POINTER ws-count
ON OVERFLOW DISPLAY message
NOT ON OVERFLOW DISPLAY message
END-UNSTRING.

Example

IDENTIFICATION DIVISION.
PROGRAM-ID. HELLO.

DATA DIVISION.
   WORKING-STORAGE SECTION.
   01 WS-STRING PIC A(30) VALUE 'WELCOME TO TUTORIALSPOINT'.
   01 WS-STR1 PIC A(7).
   01 WS-STR2 PIC A(2).
   01 WS-STR3 PIC A(15).
   01 WS-COUNT PIC 99 VALUE 1.

PROCEDURE DIVISION.
   UNSTRING WS-STRING DELIMITED BY SPACE
      INTO WS-STR1, WS-STR2, WS-STR3
   END-UNSTRING.
   
   DISPLAY 'WS-STR1 : 'WS-STR1.
   DISPLAY 'WS-STR2 : 'WS-STR2.
   DISPLAY 'WS-STR3 : 'WS-STR3.
   
STOP RUN.

JCL per eseguire il programma COBOL di cui sopra -

//SAMPLE JOB(TESTJCL,XXXXXX),CLASS = A,MSGCLASS = C
//STEP1 EXEC PGM = HELLO

Quando compili ed esegui il programma sopra, produce il seguente risultato:

WS-STR1 : WELCOME
WS-STR2 : TO
WS-STR3 : TUTORIALSPOINT

Gli array in COBOL sono noti come tabelle. Un array è una struttura dati lineare ed è una raccolta di singoli elementi di dati dello stesso tipo. Gli elementi di dati di una tabella vengono ordinati internamente.

Dichiarazione della tabella

La tabella è dichiarata in Divisione dati. Occursla clausola viene utilizzata per definire una tabella. La clausola Occurs indica la ripetizione della definizione del nome dati. Può essere utilizzato solo con numeri di livello che vanno da 02 a 49. Non utilizzare la clausola si verifica con Redefines. La descrizione della tabella unidimensionale e bidimensionale è la seguente:

Tabella unidimensionale

In una tabella unidimensionale, occursla clausola viene utilizzata solo una volta nella dichiarazione. WSTABLE è l'elemento del gruppo che contiene la tabella. WS-B nomina gli elementi della tabella che ricorrono 10 volte.

Syntax

Di seguito è riportata la sintassi per la definizione di una tabella unidimensionale:

01 WS-TABLE.
   05 WS-A PIC A(10) OCCURS 10 TIMES.

Example

IDENTIFICATION DIVISION.
PROGRAM-ID. HELLO.

DATA DIVISION.
   WORKING-STORAGE SECTION.
   01 WS-TABLE.
      05 WS-A PIC A(10) VALUE 'TUTORIALS' OCCURS 5 TIMES.     

PROCEDURE DIVISION.
   DISPLAY "ONE-D TABLE : "WS-TABLE.
STOP RUN.

JCL per eseguire il programma COBOL di cui sopra -

//SAMPLE JOB(TESTJCL,XXXXXX),CLASS = A,MSGCLASS = C
//STEP1 EXEC PGM = HELLO

Quando compili ed esegui il programma sopra, produce il seguente risultato:

ONE-D TABLE : TUTORIALS TUTORIALS TUTORIALS TUTORIALS TUTORIALS

Tabella bidimensionale

Viene creata una tabella bidimensionale con entrambi gli elementi di dati a lunghezza variabile. Per riferimento, passare attraverso la sintassi e quindi provare ad analizzare la tabella. Il primo array (WS-A) può verificarsi da 1 a 10 volte e l'array interno (WS-C) può verificarsi da 1 a 5 volte. Per ogni voce di WS-A, ci saranno 5 voci corrispondenti di WS-C.

Syntax

Di seguito è riportata la sintassi per definire una tabella bidimensionale:

01 WS-TABLE.
   05 WS-A OCCURS 10 TIMES.
      10 WS-B PIC A(10).
      10 WS-C OCCURS 5 TIMES.
         15 WS-D PIC X(6).

Example

IDENTIFICATION DIVISION.
PROGRAM-ID. HELLO.

DATA DIVISION.
   WORKING-STORAGE SECTION.
   01 WS-TABLE.
      05 WS-A OCCURS 2 TIMES.
         10 WS-B PIC A(10) VALUE ' TUTORIALS'.
         10 WS-C OCCURS 2 TIMES.
            15 WS-D PIC X(6) VALUE ' POINT'.

PROCEDURE DIVISION.
   DISPLAY "TWO-D TABLE : "WS-TABLE.

STOP RUN.

JCL per eseguire il programma COBOL di cui sopra -

//SAMPLE JOB(TESTJCL,XXXXXX),CLASS = A,MSGCLASS = C
//STEP1 EXEC PGM = HELLO

Quando compili ed esegui il programma sopra, produce il seguente risultato:

TWO-D TABLE :  TUTORIALS POINT POINT TUTORIALS POINT POINT

Pedice

È possibile accedere ai singoli elementi della tabella utilizzando il pedice. I valori di pedice possono variare da 1 al numero di volte in cui si verifica la tabella. Un pedice può essere qualsiasi numero positivo. Non necessita di alcuna dichiarazione nella divisione dati. Viene creato automaticamente con la clausola si verifica.

Example

IDENTIFICATION DIVISION.
PROGRAM-ID. HELLO.

DATA DIVISION.
   WORKING-STORAGE SECTION.
   01 WS-TABLE.
      05 WS-A OCCURS 3 TIMES.
         10 WS-B PIC A(2).
         10 WS-C OCCURS 2 TIMES.
            15 WS-D PIC X(3).

PROCEDURE DIVISION.
   MOVE '12ABCDEF34GHIJKL56MNOPQR' TO WS-TABLE.
   DISPLAY 'WS-TABLE  : ' WS-TABLE.
   DISPLAY 'WS-A(1)   : ' WS-A(1).
   DISPLAY 'WS-C(1,1) : ' WS-C(1,1).
   DISPLAY 'WS-C(1,2) : ' WS-C(1,2).
   DISPLAY 'WS-A(2)   : ' WS-A(2).
   DISPLAY 'WS-C(2,1) : ' WS-C(2,1).
   DISPLAY 'WS-C(2,2) : ' WS-C(2,2).
   DISPLAY 'WS-A(3)   : ' WS-A(3).
   DISPLAY 'WS-C(3,1) : ' WS-C(3,1).
   DISPLAY 'WS-C(3,2) : ' WS-C(3,2).
   
STOP RUN.

JCL per eseguire il programma COBOL di cui sopra -

//SAMPLE JOB(TESTJCL,XXXXXX),CLASS = A,MSGCLASS = C
//STEP1 EXEC PGM = HELLO

Quando compili ed esegui il programma sopra, produce il seguente risultato:

WS-TABLE  : 12ABCDEF34GHIJKL56MNOPQR
WS-A(1)   : 12ABCDEF
WS-C(1,1) : ABC
WS-C(1,2) : DEF
WS-A(2)   : 34GHIJKL
WS-C(2,1) : GHI
WS-C(2,2) : JKL
WS-A(3)   : 56MNOPQR
WS-C(3,1) : MNO
WS-C(3,2) : PQR

Indice

È inoltre possibile accedere agli elementi della tabella utilizzando index. Un indice è uno spostamento di un elemento dall'inizio della tabella. Un indice viene dichiarato con la clausola Occurs utilizzando la clausola INDEXED BY. Il valore dell'indice può essere modificato utilizzando l'istruzione SET e l'opzione PERFORM Varying.

Syntax

Di seguito è riportata la sintassi per la definizione dell'indice in una tabella:

01 WS-TABLE.
   05 WS-A PIC A(10) OCCURS 10 TIMES INDEXED BY I.

Example

IDENTIFICATION DIVISION.
PROGRAM-ID. HELLO.

DATA DIVISION.
   WORKING-STORAGE SECTION.
   01 WS-TABLE.
      05 WS-A OCCURS 3 TIMES INDEXED BY I.
         10 WS-B PIC A(2).
         10 WS-C OCCURS 2 TIMES INDEXED BY J.
            15 WS-D PIC X(3).

PROCEDURE DIVISION.
   MOVE '12ABCDEF34GHIJKL56MNOPQR' TO WS-TABLE.
   PERFORM A-PARA VARYING I FROM 1 BY 1 UNTIL I >3 
   STOP RUN.
   
   A-PARA.
   PERFORM C-PARA VARYING J FROM 1 BY 1 UNTIL J>2.
   
   C-PARA.
   DISPLAY WS-C(I,J).

JCL per eseguire il programma COBOL di cui sopra -

//SAMPLE JOB(TESTJCL,XXXXXX),CLASS = A,MSGCLASS = C
//STEP1 EXEC PGM = HELLO

Quando compili ed esegui il programma sopra, produce il seguente risultato:

ABC
DEF
GHI
JKL
MNO
PQR

Set Statement

L'istruzione Set viene utilizzata per modificare il valore dell'indice. Set verbo viene utilizzato per inizializzare, aumentare o diminuire il valore dell'indice. Viene utilizzato con Cerca e Cerca tutto per individuare gli elementi nella tabella.

Syntax

Di seguito è riportata la sintassi per l'utilizzo di un'istruzione Set:

SET I J TO positive-number
SET I TO J
SET I TO 5
SET I J UP BY 1
SET J DOWN BY 5

Example

IDENTIFICATION DIVISION.
PROGRAM-ID. HELLO.

DATA DIVISION.
   WORKING-STORAGE SECTION.
   01 WS-TABLE.
      05 WS-A OCCURS 3 TIMES INDEXED BY I.
         10 WS-B PIC A(2).
         10 WS-C OCCURS 2 TIMES INDEXED BY J.
            15 WS-D PIC X(3).

PROCEDURE DIVISION.
   MOVE '12ABCDEF34GHIJKL56MNOPQR' TO WS-TABLE.
   SET I J TO 1.
   DISPLAY WS-C(I,J).
   SET I J UP BY 1.
   DISPLAY WS-C(I,J).
   
STOP RUN.

JCL per eseguire il programma COBOL di cui sopra.

//SAMPLE JOB(TESTJCL,XXXXXX),CLASS = A,MSGCLASS = C
//STEP1 EXEC PGM = HELLO

Quando compili ed esegui il programma sopra, produce il seguente risultato:

ABC
JKL

Ricerca

La ricerca è un metodo di ricerca lineare, utilizzato per trovare elementi all'interno della tabella. Può essere eseguito su tabelle ordinate e non ordinate. Viene utilizzato solo per le tabelle dichiarate dalla frase Indice. Inizia con il valore iniziale di index. Se l'elemento cercato non viene trovato, l'indice viene automaticamente incrementato di 1 e continua fino alla fine della tabella.

Example

IDENTIFICATION DIVISION.
PROGRAM-ID. HELLO.

DATA DIVISION.
   WORKING-STORAGE SECTION.
   01 WS-TABLE.
      05 WS-A PIC X(1) OCCURS 18 TIMES INDEXED BY I.
   01 WS-SRCH PIC A(1) VALUE 'M'.

PROCEDURE DIVISION.
   MOVE 'ABCDEFGHIJKLMNOPQR' TO WS-TABLE.
   SET I TO 1.
   SEARCH WS-A
      AT END DISPLAY 'M NOT FOUND IN TABLE'
      WHEN WS-A(I) = WS-SRCH
      DISPLAY 'LETTER M FOUND IN TABLE'
   END-SEARCH.  

STOP RUN.

JCL per eseguire il programma COBOL di cui sopra.

//SAMPLE JOB(TESTJCL,XXXXXX),CLASS = A,MSGCLASS = C
//STEP1 EXEC PGM = HELLO

Quando compili ed esegui il programma sopra, produce il seguente risultato:

LETTER M FOUND IN TABLE

Cerca in tutto

Cerca tutto è un metodo di ricerca binario, utilizzato per trovare elementi all'interno della tabella. La tabella deve essere ordinata per l'opzione Cerca tutto. L'indice non richiede inizializzazione. Nella ricerca binaria, la tabella è divisa in due metà e determina in quale metà è presente l'elemento cercato. Questo processo si ripete finché l'elemento non viene trovato o viene raggiunta la fine.

Example

IDENTIFICATION DIVISION.
PROGRAM-ID. HELLO.

DATA DIVISION.
   WORKING-STORAGE SECTION.
   01 WS-TABLE.
      05 WS-RECORD OCCURS 10 TIMES ASCENDING KEY IS WS-NUM INDEXED BY I.
      10 WS-NUM PIC 9(2).
      10 WS-NAME PIC A(3).

PROCEDURE DIVISION.
   MOVE '12ABC56DEF34GHI78JKL93MNO11PQR' TO WS-TABLE.
   SEARCH ALL WS-RECORD
     AT END DISPLAY 'RECORD NOT FOUND'
     WHEN WS-NUM(I) = 93
     DISPLAY 'RECORD FOUND '
     DISPLAY WS-NUM(I)
     DISPLAY WS-NAME(I)

END-SEARCH.

JCL per eseguire il programma COBOL di cui sopra -

//SAMPLE JOB(TESTJCL,XXXXXX),CLASS = A,MSGCLASS = C
//STEP1 EXEC PGM = HELLO

Quando compili ed esegui il programma sopra, produce il seguente risultato:

RECORD FOUND 
93
MNO

Il concetto di file in COBOL è diverso da quello in C / C ++. Durante l'apprendimento delle basi di "File" in COBOL, i concetti di entrambe le lingue non dovrebbero essere correlati. I file di testo semplici non possono essere utilizzati in COBOL, invecePS (Physical Sequential) e VSAMvengono utilizzati file. I file PS verranno discussi in questo modulo.

Per comprendere la gestione dei file in COBOL, è necessario conoscere i termini di base. Questi termini servono solo a comprendere i fondamenti della gestione dei file. La terminologia più approfondita sarà discussa nel capitolo "File Handling Verbs". Di seguito sono riportati i termini di base:

  • Field
  • Record
  • Record fisico
  • Record logico
  • File

Il seguente esempio aiuta a comprendere questi termini:

Campo

Il campo viene utilizzato per indicare i dati memorizzati su un elemento. Rappresenta un singolo elemento come mostrato nell'esempio precedente, come ID studente, nome, voti, voti totali e percentuale. Il numero di caratteri in qualsiasi campo è noto come dimensione del campo, ad esempio, il nome dello studente può contenere 10 caratteri. I campi possono avere i seguenti attributi:

  • Primary keyssono quei campi che sono univoci per ogni record e vengono utilizzati per identificare un record particolare. Ad esempio, nel file dei voti degli studenti, ogni studente avrà un ID studente univoco che forma la chiave primaria.

  • Secondary keyssono campi univoci o non univoci utilizzati per cercare dati correlati. Ad esempio, nel file dei voti degli studenti, il nome completo dello studente può essere utilizzato come chiave secondaria quando l'ID studente non è noto.

  • Descriptorsi campi vengono utilizzati per descrivere un'entità. Ad esempio, nel file dei voti degli studenti, i voti ei campi di percentuale che aggiungono significato al record sono descrittori noti.

Disco

Il record è una raccolta di campi utilizzata per descrivere un'entità. Uno o più campi insieme formano un record. Ad esempio, nel file dei voti degli studenti, ID studente, nome, voti, voti totali e percentuale formano un record. La dimensione cumulativa di tutti i campi in un record è nota come dimensione del record. I record presenti in un file possono essere di lunghezza fissa o variabile.

Record fisico

La registrazione fisica è l'informazione che esiste sul dispositivo esterno. È anche noto come blocco.

Record logico

Il record logico è l'informazione utilizzata dal programma. Nei programmi COBOL, un solo record può essere gestito in qualsiasi momento e viene chiamato record logico.

File

Il file è una raccolta di record correlati. Ad esempio, il file dei voti degli studenti è costituito dai record di tutti gli studenti.

L'organizzazione dei file indica come sono organizzati i record in un file. Esistono diversi tipi di organizzazioni per i file in modo da aumentare la loro efficienza di accesso ai record. Di seguito sono riportati i tipi di schemi di organizzazione dei file:

  • Organizzazione file sequenziale
  • Organizzazione di file sequenziali indicizzati
  • Organizzazione relativa dei file

Le sintassi in questo modulo, menzionate insieme ai rispettivi termini, si riferiscono solo al loro utilizzo nel programma. I programmi completi che utilizzano queste sintassi saranno discussi nel capitolo "Verbi per la gestione dei file".

Organizzazione dei file sequenziali

Un file sequenziale è costituito da record archiviati e a cui si accede in ordine sequenziale. Di seguito sono riportati gli attributi chiave dell'organizzazione sequenziale dei file:

  • I record possono essere letti in ordine sequenziale. Per leggere il 10 ° disco, tutti i precedenti record di 9 dovrebbero essere lette.

  • I record vengono scritti in ordine sequenziale. Non è possibile inserire un nuovo record in mezzo. Alla fine del file viene sempre inserito un nuovo record.

  • Dopo aver inserito un record in un file sequenziale, non è possibile eliminare, accorciare o allungare un record.

  • L'ordine dei record, una volta inseriti, non potrà mai essere modificato.

  • È possibile l'aggiornamento del record. Un record può essere sovrascritto, se la nuova lunghezza del record è uguale a quella del vecchio record.

  • I file di output sequenziali sono una buona opzione per la stampa.

Sintassi

Di seguito è riportata la sintassi dell'organizzazione dei file sequenziali:

INPUT-OUTPUT SECTION.
FILE-CONTROL.
   SELECT file-name ASSIGN TO dd-name-jcl
   ORGANIZATION IS SEQUENTIAL

Organizzazione dei file sequenziali indicizzati

Un file sequenziale indicizzato è costituito da record a cui è possibile accedere in sequenza. È possibile anche l'accesso diretto. Consiste di due parti:

  • Data File contiene record in uno schema sequenziale.

  • Index File contiene la chiave primaria e il suo indirizzo nel file di dati.

Di seguito sono riportati gli attributi chiave dell'organizzazione sequenziale dei file:

  • I record possono essere letti in ordine sequenziale proprio come nell'organizzazione di file sequenziali.

  • È possibile accedere ai record in modo casuale se la chiave primaria è nota. Il file di indice viene utilizzato per ottenere l'indirizzo di un record, quindi il record viene recuperato dal file di dati.

  • L'indice ordinato viene mantenuto in questo file system che collega il valore della chiave alla posizione del record nel file.

  • È inoltre possibile creare un indice alternativo per recuperare i record.

Sintassi

Di seguito è riportata la sintassi dell'organizzazione di file sequenziali indicizzati:

INPUT-OUTPUT SECTION.
FILE-CONTROL.
   SELECT file-name ASSIGN TO dd-name-jcl
   ORGANIZATION IS INDEXED
   RECORD KEY IS primary-key
   ALTERNATE RECORD KEY IS rec-key

Organizzazione relativa dei file

Un file relativo è costituito da record ordinati in base ai file relative address. Di seguito sono riportati gli attributi chiave della relativa organizzazione dei file:

  • I record possono essere letti in ordine sequenziale proprio come nell'organizzazione di file sequenziali e indicizzati.

  • È possibile accedere ai record utilizzando la relativa chiave. La chiave relativa rappresenta la posizione del record rispetto all'indirizzo di inizio del file.

  • I record possono essere inseriti utilizzando la relativa chiave. L'indirizzo relativo viene calcolato utilizzando la chiave relativa.

  • Il file relativo fornisce l'accesso più veloce ai record.

  • Il principale svantaggio di questo file system è che se mancano alcuni record intermedi, occuperanno anche spazio.

Sintassi

Di seguito è riportata la sintassi della relativa organizzazione dei file:

INPUT-OUTPUT SECTION.
FILE-CONTROL.
   SELECT file-name ASSIGN TO dd-name-jcl
   ORGANIZATION IS RELATIVE
   RELATIVE KEY IS rec-key

Fino ad ora, sono stati discussi schemi di organizzazione dei file. Per ogni schema di organizzazione dei file, è possibile utilizzare diverse modalità di accesso. Di seguito sono riportati i tipi di modalità di accesso ai file:

  • Accesso sequenziale
  • Accesso casuale
  • Accesso dinamico

Le sintassi in questo modulo, menzionate insieme ai rispettivi termini, si riferiscono solo al loro utilizzo nel programma. I programmi completi che utilizzano queste sintassi saranno discussi nel prossimo capitolo.

Accesso sequenziale

Quando la modalità di accesso è sequenziale, il metodo di recupero dei record cambia in base all'organizzazione del file selezionata.

  • Per sequential files, ai record si accede nello stesso ordine in cui sono stati inseriti.

  • Per indexed files, il parametro utilizzato per recuperare i record sono i valori della chiave del record.

  • Per relative files, le chiavi record relative vengono utilizzate per recuperare i record.

Sintassi

Di seguito è riportata la sintassi della modalità di accesso sequenziale:

ENVIRONMENT DIVISION.
INPUT-OUTPUT SECTION.
FILE-CONTROL.
   SELECT file-name ASSIGN TO dd-name
   ORGANIZATION IS SEQUENTIAL
   ACCESS MODE IS SEQUENTIAL
	
	
ENVIRONMENT DIVISION.
INPUT-OUTPUT SECTION.
   FILE-CONTROL.
   SELECT file-name ASSIGN TO dd-name
   ORGANIZATION IS INDEXED
   ACCESS MODE IS SEQUENTIAL
   RECORD KEY IS rec-key1
   ALTERNATE RECORD KEY IS rec-key2

		
ENVIRONMENT DIVISION.
INPUT-OUTPUT SECTION.
   FILE-CONTROL.
   SELECT file-name ASSIGN TO dd-name
   ORGANIZATION IS RELATIVE
   ACCESS MODE IS SEQUENTIAL
   RELATIVE KEY IS rec-key1

Accesso casuale

Quando la modalità di accesso è RANDOM, il metodo di recupero dei record cambia in base all'organizzazione del file selezionata.

  • Per indexed files, si accede ai record in base al valore inserito in un campo chiave che può essere chiave primaria o alternativa. Possono essere presenti uno o più indici alternativi.

  • Per relative files , i record vengono recuperati tramite le relative chiavi record.

Sintassi

Di seguito è riportata la sintassi della modalità di accesso casuale:

ENVIRONMENT DIVISION.
INPUT-OUTPUT SECTION.
   FILE-CONTROL.
   SELECT file-name ASSIGN TO dd-name
   ORGANIZATION IS INDEXED
   ACCESS MODE IS RANDOM
   RECORD KEY IS rec-key1
   ALTERNATE RECORD KEY IS rec-key2

		
ENVIRONMENT DIVISION.
INPUT-OUTPUT SECTION.
   FILE-CONTROL.
   SELECT file-name ASSIGN TO dd-name
   ORGANIZATION IS RELATIVE
   ACCESS MODE IS RANDOM
   RELATIVE KEY IS rec-key1

Accesso dinamico

L'accesso dinamico supporta l'accesso sequenziale e casuale nello stesso programma. Con l'accesso dinamico, una definizione di file viene utilizzata per eseguire l'elaborazione sia sequenziale che casuale come l'accesso ad alcuni record in ordine sequenziale e ad altri record tramite le loro chiavi.

Con i file relativi e indicizzati, la modalità di accesso dinamico consente di passare avanti e indietro tra la modalità di accesso sequenziale e la modalità di accesso casuale durante la lettura di un file utilizzando la frase NEXT nell'istruzione READ. Le funzionalità NEXT e READ saranno discusse nel prossimo capitolo.

Sintassi

Di seguito è riportata la sintassi della modalità di accesso dinamico:

ENVIRONMENT DIVISION.
INPUT-OUTPUT SECTION.
   FILE-CONTROL.
   SELECT file-name ASSIGN TO dd-name
   ORGANIZATION IS SEQUENTIAL
   ACCESS MODE IS DYNAMIC
   RECORD KEY IS rec-key1
   ALTERNATE RECORD KEY IS rec-key2

		
ENVIRONMENT DIVISION.
INPUT-OUTPUT SECTION.
   FILE-CONTROL.
   SELECT file-name ASSIGN TO dd-name
   ORGANIZATION IS RELATIVE
   ACCESS MODE IS DYNAMIC
   RELATIVE KEY IS rec-key1

I verbi per la gestione dei file vengono utilizzati per eseguire varie operazioni sui file. Di seguito sono riportati i verbi per la gestione dei file:

  • Open
  • Read
  • Write
  • Rewrite
  • Delete
  • Start
  • Close

Open Verb

Apri è la prima operazione sul file che deve essere eseguita. Se Open ha esito positivo, sono possibili solo ulteriori operazioni su un file. Solo dopo aver aperto un file, le variabili nella struttura del file sono disponibili per l'elaborazione.FILE STATUS variabile viene aggiornata dopo ogni operazione sul file.

Sintassi

OPEN "mode" file-name.

Qui, nome-file è una stringa letterale, che utilizzerai per denominare il tuo file. Un file può essere aperto nelle seguenti modalità:

Sr.No. Modalità e descrizione
1

Input

La modalità di input viene utilizzata per i file esistenti. In questa modalità, possiamo solo leggere il file, non sono consentite altre operazioni sul file.

2

Output

La modalità di output viene utilizzata per inserire record nei file. Se unasequential fileviene utilizzato e il file contiene alcuni record, quindi i record esistenti verranno prima eliminati e quindi verranno inseriti nuovi record nel file. Non succederà così in caso di un fileindexed file o a relative file.

3

Extend

La modalità di estensione viene utilizzata per aggiungere record in un file sequential file. In questa modalità, i record vengono inseriti alla fine. Se la modalità di accesso ai file èRandom o Dynamic, quindi la modalità di estensione non può essere utilizzata.

4

I-O

La modalità Input-Output viene utilizzata per leggere e riscrivere i record di un file.

Leggi verbo

Il verbo di lettura viene utilizzato per leggere i record del file. La funzione di lettura è recuperare i record da un file. Ad ogni verbo di lettura, solo un record può essere letto nella struttura del file. Per eseguire un'operazione di lettura, aprire il file in modalità INPUT o IO. Ad ogni istruzione di lettura, il puntatore del file viene incrementato e quindi vengono letti i record successivi.

Sintassi

Di seguito è riportata la sintassi per leggere i record quando la modalità di accesso ai file è sequenziale:

READ file-name NEXT RECORD INTO ws-file-structure
   AT END DISPLAY 'End of File'
   NOT AT END DISPLAY 'Record Details:' ws-file-structure
END-READ.

Di seguito sono riportati i parametri utilizzati:

  • NEXT RECORD è facoltativo e viene specificato quando un file sequenziale indicizzato viene letto in sequenza.

  • La clausola INTO è facoltativa. ws-file-structure è definito nella sezione WorkingStorage per ottenere i valori dall'istruzione READ.

  • La condizione AT END diventa True quando viene raggiunta la fine del file.

Example- Il seguente esempio legge un file esistente utilizzando l'organizzazione sequenziale di righe. Questo programma può essere compilato ed eseguito utilizzandoLive Demo opzione dove verranno visualizzati tutti i record presenti nel file.

IDENTIFICATION DIVISION.
PROGRAM-ID. HELLO.

ENVIRONMENT DIVISION.
   INPUT-OUTPUT SECTION.
      FILE-CONTROL.
      SELECT STUDENT ASSIGN TO 'input.txt'
      ORGANIZATION IS LINE SEQUENTIAL.            

DATA DIVISION.
   FILE SECTION.
   FD STUDENT.
   01 STUDENT-FILE.
      05 STUDENT-ID PIC 9(5).
      05 NAME PIC A(25).

   WORKING-STORAGE SECTION.
   01 WS-STUDENT.
      05 WS-STUDENT-ID PIC 9(5).
      05 WS-NAME PIC A(25).
   01 WS-EOF PIC A(1). 

PROCEDURE DIVISION.
   OPEN INPUT STUDENT.
      PERFORM UNTIL WS-EOF='Y'
         READ STUDENT INTO WS-STUDENT
            AT END MOVE 'Y' TO WS-EOF
            NOT AT END DISPLAY WS-STUDENT
         END-READ
      END-PERFORM.
   CLOSE STUDENT.
STOP RUN.

Supponiamo che i dati del file di input disponibili nel file input.txt file contiene quanto segue -

20003 Mohtashim M.
20004 Nishant Malik
20005 Amitabh Bachhan

Quando compili ed esegui il programma sopra, produce il seguente risultato:

20003 Mohtashim M.            
20004 Nishant Malik           
20005 Amitabh Bachhan

Sintassi

La seguente è la sintassi per leggere un record quando la modalità di accesso ai file è casuale:

READ file-name RECORD INTO ws-file-structure
   KEY IS rec-key
   INVALID KEY DISPLAY 'Invalid Key'
   NOT INVALID KEY DISPLAY 'Record Details: ' ws-file-structure
END-READ.

Example- L'esempio seguente legge un file esistente utilizzando l'organizzazione indicizzata. Questo programma può essere compilato ed eseguito utilizzandoJCLsu Mainframe dove verranno visualizzati tutti i record presenti nel file. Sul server Mainframes, non utilizziamo file di testo; invece usiamo file PS.

Supponiamo che il file presente sui Mainframe abbia lo stesso contenuto del file input.txt nell'esempio precedente.

IDENTIFICATION DIVISION.
PROGRAM-ID. HELLO.

ENVIRONMENT DIVISION.
   INPUT-OUTPUT SECTION.
   FILE-CONTROL.
   SELECT STUDENT ASSIGN TO IN1
      ORGANIZATION IS INDEXED
      ACCESS IS RANDOM
      RECORD KEY IS STUDENT-ID
      FILE STATUS IS FS.

DATA DIVISION.
   FILE SECTION.
   FD STUDENT.
      01 STUDENT-FILE.
      05 STUDENT-ID PIC 9(5).
      05 NAME PIC A(25).
     
   WORKING-STORAGE SECTION.
   01 WS-STUDENT.
      05 WS-STUDENT-ID PIC 9(5).
      05 WS-NAME PIC A(25).

PROCEDURE DIVISION.
   OPEN INPUT STUDENT.
      MOVE 20005 TO STUDENT-ID.
      
      READ STUDENT RECORD INTO WS-STUDENT-FILE
         KEY IS STUDENT-ID
         INVALID KEY DISPLAY 'Invalid Key'
         NOT INVALID KEY DISPLAY WS-STUDENT-FILE
      END-READ.
      
   CLOSE STUDENT.
STOP RUN.

JCL per eseguire il programma COBOL di cui sopra -

//SAMPLE JOB(TESTJCL,XXXXXX),CLASS = A,MSGCLASS = C
//STEP1 EXEC PGM = HELLO
//IN1 DD DSN = STUDENT-FILE-NAME,DISP=SHR

Quando compili ed esegui il programma sopra, produce il seguente risultato:

20005 Amitabh Bachhan

Scrivi verbo

Il verbo di scrittura viene utilizzato per inserire record in un file. Una volta che il record è stato scritto, non è più disponibile nel buffer del record. Prima di inserire i record nel file, spostare i valori nel buffer dei record e quindi eseguire il verbo di scrittura.

L'istruzione Write può essere utilizzata con FROMopzione per scrivere direttamente i record dalle variabili di archiviazione di lavoro. From è una clausola opzionale. Se la modalità di accesso è sequenziale, per scrivere un record, il file deve essere aperto in modalità di output o in modalità di estensione. Se la modalità di accesso è casuale o dinamica, per scrivere un record, il file deve essere aperto in modalità di output o in modalità IO.

Sintassi

Di seguito è riportata la sintassi per leggere un record quando l'organizzazione del file è sequenziale:

WRITE record-buffer [FROM ws-file-structure]
END-WRITE.

La seguente è la sintassi per leggere un record quando l'organizzazione del file è indicizzata o relativa -

WRITE record-buffer [FROM ws-file-structure]
   INVALID KEY DISPLAY 'Invalid Key'
   NOT INVALID KEY DISPLAY 'Record Inserted'
END-WRITE.

Example - L'esempio seguente mostra come inserire un nuovo record in un nuovo file quando l'organizzazione è sequenziale.

IDENTIFICATION DIVISION.
PROGRAM-ID. HELLO.

ENVIRONMENT DIVISION.
   INPUT-OUTPUT SECTION.
   FILE-CONTROL.
   SELECT STUDENT ASSIGN TO OUT1
      ORGANIZATION IS SEQUENTIAL
      ACCESS IS SEQUENTIAL
      FILE STATUS IS FS.

DATA DIVISION.
   FILE SECTION.
   FD STUDENT
   01 STUDENT-FILE.
      05 STUDENT-ID PIC 9(5).
      05 NAME PIC A(25).
      05 CLASS PIC X(3).

   WORKING-STORAGE SECTION.
   01 WS-STUDENT.
      05 WS-STUDENT-ID PIC 9(5).
      05 WS-NAME PIC A(25).
      05 WS-CLASS PIC X(3).

PROCEDURE DIVISION.
   OPEN EXTEND STUDENT.
      MOVE 1000 TO STUDENT-ID.
      MOVE 'Tim' TO NAME.
      MOVE '10' TO CLASS.
      WRITE STUDENT-FILE
      END-WRITE.	
   CLOSE STUDENT.
STOP RUN.

JCL per eseguire il programma COBOL di cui sopra -

//SAMPLE JOB(TESTJCL,XXXXXX),CLASS = A,MSGCLASS = C
//STEP1 EXEC PGM = HELLO
//OUT1 DD DSN = OUTPUT-FILE-NAME,DISP = (NEW,CATALOG,DELETE)

Quando compili ed esegui il programma sopra, aggiungerà un nuovo record al file di output.

1000 Tim         10

Riscrivi verbo

Il verbo Riscrivi viene utilizzato per aggiornare i record. Il file dovrebbe essere aperto in modalità IO per le operazioni di riscrittura. Può essere utilizzato solo dopo un'operazione di lettura riuscita. Il verbo Riscrivi sovrascrive l'ultimo record letto.

Sintassi

Di seguito è riportata la sintassi per leggere un record quando l'organizzazione del file è sequenziale:

REWRITE record-buffer [FROM ws-file-structure]
END-REWRITE.

La seguente è la sintassi per leggere un record quando l'organizzazione del file è indicizzata o relativa -

REWRITE record-buffer [FROM ws-file-structure]
   INVALID KEY DISPLAY 'Invalid Key'
   NOT INVALID KEY DISPLAY 'Record Updated'
END-REWRITE.

Example - Il seguente esempio mostra come aggiornare un record esistente che abbiamo inserito nella precedente fase di scrittura -

IDENTIFICATION DIVISION.
PROGRAM-ID. HELLO.

ENVIRONMENT DIVISION.
   INPUT-OUTPUT SECTION.
   FILE-CONTROL.
   SELECT STUDENT ASSIGN TO IN1
      ORGANIZATION IS INDEXED
      ACCESS IS RANDOM
      RECORD KEY IS STUDENT-ID
      FILE STATUS IS FS.

DATA DIVISION.
   FILE SECTION.
   FD STUDENT
   01 STUDENT-FILE.
      05 STUDENT-ID PIC 9(4).
      05 NAME PIC A(12).
      05 CLASS PIC X(3).
      
   WORKING-STORAGE SECTION.
   01 WS-STUDENT.
      05 WS-STUDENT-ID PIC 9(5).
      05 WS-NAME PIC A(25).
      05 WS-CLASS PIC X(3).

PROCEDURE DIVISION.
   OPEN I-O STUDENT.
   MOVE '1000' TO STUDENT-ID.
  
   READ STUDENT
      KEY IS STUDENT-ID
      INVALID KEY DISPLAY ‘KEY IS NOT EXISTING’
   END-READ.
  
   MOVE 'Tim Dumais' TO NAME.
   REWRITE STUDENT-FILE
   END-REWRITE.
   CLOSE STUDENT.
STOP RUN.

JCL per eseguire il programma COBOL di cui sopra -

//SAMPLE JOB(TESTJCL,XXXXXX),CLASS = A,MSGCLASS = C
//STEP1 EXEC PGM = HELLO
//IN1 DD DSN = OUTPUT-FILE-NAME,DISP = SHR

Quando compili ed esegui il programma sopra, aggiornerà il record -

1000 Tim Dumais  10

Elimina verbo

Il verbo di eliminazione può essere eseguito solo su file indicizzati e relativi. Il file deve essere aperto in modalità IO. Nell'organizzazione di file sequenziali, i record non possono essere eliminati. L'ultimo record letto dall'istruzione Read viene eliminato in caso di modalità di accesso sequenziale. In modalità di accesso casuale, specificare la chiave di registrazione e quindi eseguire l'operazione Elimina.

Sintassi

Di seguito è riportata la sintassi per eliminare un record:

DELETE file-name RECORD
   INVALID KEY DISPLAY 'Invalid Key'
   NOT INVALID KEY DISPLAY 'Record Deleted'
END-DELETE.

Example - per eliminare un record esistente -

IDENTIFICATION DIVISION.
PROGRAM-ID. HELLO.

ENVIRONMENT DIVISION.
   INPUT-OUTPUT SECTION.
   FILE-CONTROL.
   SELECT STUDENT ASSIGN TO OUT1
      ORGANIZATION IS INDEXED
      ACCESS IS RANDOM
      RECORD KEY IS STUDENT-ID
      FILE STATUS IS FS.

DATA DIVISION.
   FILE SECTION.
   FD STUDENT
   01 STUDENT-FILE.
      05 STUDENT-ID PIC 9(4).
      05 NAME PIC A(12).
      05 CLASS PIC X(3).
   WORKING-STORAGE SECTION.
   01 WS-STUDENT.
      05 WS-STUDENT-ID PIC 9(5).
      05 WS-NAME PIC A(25).
      05 WS-CLASS PIC X(3).

PROCEDURE DIVISION.
   OPEN I-O STUDENT.
   MOVE '1000' TO STUDENT-ID.
   
   DELETE STUDENT RECORD
      INVALID KEY DISPLAY 'Invalid Key'
      NOT INVALID KEY DISPLAY 'Record Deleted'
   END-DELETE.
   
   CLOSE STUDENT.
STOP RUN.

JCL per eseguire il programma COBOL di cui sopra -

//SAMPLE JOB(TESTJCL,XXXXXX),CLASS = A,MSGCLASS = C
//STEP1 EXEC PGM = HELLO
//OUT1 DD DSN = OUTPUT-FILE-NAME,DISP = SHR

Quando compili ed esegui il programma sopra, produce il seguente risultato:

Record Deleted

Avvia Verbo

Il verbo di avvio può essere eseguito solo su file indicizzati e relativi. Viene utilizzato per posizionare il puntatore del file su un record specifico. La modalità di accesso deve essere sequenziale o dinamica. Il file deve essere aperto in modalità I / O o Input.

Sintassi

Di seguito è riportata la sintassi per posizionare il puntatore su un record specifico:

START file-name KEY IS [=, >, <, NOT, <= or >=] rec-key
   INVALID KEY DISPLAY 'Invalid Key'
   NOT INVALID KEY DISPLAY 'File Pointer Updated'
END-START.

Chiudi Verbo

Il verbo Chiudi viene utilizzato per chiudere un file. Dopo aver eseguito l'operazione di chiusura, le variabili nella struttura del file non saranno disponibili per l'elaborazione. Il collegamento tra programma e file viene perso.

Sintassi

Di seguito è riportata la sintassi per chiudere un file:

CLOSE file-name.

La subroutine Cobol è un programma che può essere compilato indipendentemente ma non può essere eseguito indipendentemente. Esistono due tipi di subroutine:internal subroutines piace Perform dichiarazioni e external subroutine come il verbo CALL.

Call Verb

Il verbo Call viene utilizzato per trasferire il controllo da un programma a un altro programma. Il programma che contiene il verbo CALL è ilCalling Program e il programma chiamato è noto come Called Program. L'esecuzione del programma chiamato si interromperà finché il programma chiamato non termina l'esecuzione. L'istruzione Exit Program viene utilizzata nel programma Called per trasferire nuovamente il controllo.

Denominati vincoli di programma

Di seguito sono riportati i requisiti del programma chiamato:

  • Linkage sectiondeve essere definito nel programma chiamato. Consiste di elementi di dati passati nel programma. Gli elementi di dati non devono avere la clausola Value. La clausola PIC deve essere compatibile con le variabili passate attraverso il programma chiamante.

  • Procedure division using ha un elenco di variabili passate dal programma chiamante e l'ordine deve essere lo stesso menzionato nel verbo Call.

  • Exit programviene utilizzata nel programma chiamato per ritrasferire il controllo. Deve essere l'ultima istruzione nel programma chiamato.

I parametri possono essere passati da un programma all'altro in due modi:

  • Come riferimento
  • Per contenuto

Chiama per riferimento

Se i valori delle variabili nel programma chiamato vengono modificati, i loro nuovi valori si rifletteranno nel programma chiamante. SeBY la clausola non è specificata, quindi le variabili vengono sempre passate per riferimento.

Sintassi

Di seguito è riportata la sintassi per chiamare la subroutine per riferimento:

CALL sub-prog-name USING variable-1, variable-2.

Example

L'esempio seguente è il programma chiamante MAIN e UTIL è il programma chiamato -

IDENTIFICATION DIVISION.
PROGRAM-ID. MAIN.

DATA DIVISION.
   WORKING-STORAGE SECTION.
   01 WS-STUDENT-ID PIC 9(4) VALUE 1000.
   01 WS-STUDENT-NAME PIC A(15) VALUE 'Tim'.

PROCEDURE DIVISION.
   CALL 'UTIL' USING WS-STUDENT-ID, WS-STUDENT-NAME.
   DISPLAY 'Student Id : ' WS-STUDENT-ID
   DISPLAY 'Student Name : ' WS-STUDENT-NAME
STOP RUN.

Chiamato programma

IDENTIFICATION DIVISION.
PROGRAM-ID. UTIL.

DATA DIVISION.
   LINKAGE SECTION.
   01 LS-STUDENT-ID PIC 9(4).
   01 LS-STUDENT-NAME PIC A(15).

PROCEDURE DIVISION USING LS-STUDENT-ID, LS-STUDENT-NAME.
   DISPLAY 'In Called Program'.
   MOVE 1111 TO LS-STUDENT-ID.
EXIT PROGRAM.

JCL per eseguire il programma COBOL di cui sopra -

//SAMPLE JOB(TESTJCL,XXXXXX),CLASS = A,MSGCLASS = C
//STEP1 EXEC PGM = MAIN

Quando compili ed esegui il programma sopra, produce il seguente risultato:

In Called Program
Student Id : 1111
Student Name : Tim

Chiama per contenuto

Se i valori delle variabili nel programma chiamato vengono modificati, i loro nuovi valori non si rifletteranno nel programma chiamante.

Sintassi

Di seguito è riportata la sintassi per chiamare la subroutine in base al contenuto:

CALL sub-prog-name USING 
BY CONTENT variable-1, BY CONTENT variable-2.

Example

L'esempio seguente è il programma chiamante MAIN e UTIL è il programma chiamato -

IDENTIFICATION DIVISION.
PROGRAM-ID. MAIN.

DATA DIVISION.
   WORKING-STORAGE SECTION.
   01 WS-STUDENT-ID PIC 9(4) VALUE 1000.
   01 WS-STUDENT-NAME PIC A(15) VALUE 'Tim'.

PROCEDURE DIVISION.
   CALL 'UTIL' USING BY CONTENT WS-STUDENT-ID, BY CONTENT WS-STUDENT-NAME.
   DISPLAY 'Student Id : ' WS-STUDENT-ID
   DISPLAY 'Student Name : ' WS-STUDENT-NAME
STOP RUN.

Chiamato programma

IDENTIFICATION DIVISION.
PROGRAM-ID. UTIL.

DATA DIVISION.
   LINKAGE SECTION.
   01 LS-STUDENT-ID PIC 9(4).
   01 LS-STUDENT-NAME PIC A(15).

PROCEDURE DIVISION USING LS-STUDENT-ID, LS-STUDENT-NAME.
   DISPLAY 'In Called Program'.
   MOVE 1111 TO LS-STUDENT-ID.
EXIT PROGRAM.

JCL per eseguire il programma COBOL di cui sopra -

//SAMPLE JOB(TESTJCL,XXXXXX),CLASS = A,MSGCLASS = C
//STEP1 EXEC PGM = MAIN

Quando compili ed esegui il programma sopra, produce il seguente risultato:

In Called Program
Student Id : 1000
Student Name : Tim

Tipi di chiamata

Esistono due tipi di chiamate:

  • Static Callsi verifica quando un programma viene compilato con l'opzione del compilatore NODYNAM. Un programma chiamato statico viene caricato nella memoria in fase di compilazione.

  • Dynamic Callsi verifica quando un programma viene compilato con l'opzione del compilatore DYNAM e NODLL. Un programma chiamato dinamico viene caricato nella memoria in fase di esecuzione.

L'ordinamento dei dati in un file o l'unione di due o più file è una necessità comune in quasi tutte le applicazioni orientate al business. L'ordinamento viene utilizzato per disporre i record in ordine crescente o decrescente, in modo che sia possibile eseguire l'elaborazione sequenziale. Esistono due tecniche utilizzate per ordinare i file in COBOL:

  • External sortviene utilizzato per ordinare i file utilizzando l'utilità SORT in JCL. Ne abbiamo discusso nel capitolo JCL. A partire da ora, ci concentreremo sull'ordinamento interno.

  • Internal sort viene utilizzato per ordinare i file all'interno di un programma COBOL. SORT verbo viene utilizzato per ordinare un file.

Ordina verbo

Tre file vengono utilizzati nel processo di ordinamento in COBOL:

  • Input file è il file che dobbiamo ordinare in ordine crescente o decrescente.

  • Work fileviene utilizzato per conservare i record mentre è in corso il processo di ordinamento. I record del file di input vengono trasferiti al file di lavoro per il processo di ordinamento. Questo file dovrebbe essere definito nella sezione File sotto la voce SD.

  • Output fileè il file che otteniamo dopo il processo di ordinamento. È l'output finale del verbo Sort.

Sintassi

Di seguito è riportata la sintassi per ordinare un file:

SORT work-file ON ASCENDING KEY rec-key1
   [ON DESCENDING KEY rec-key2]
USING input-file GIVING output-file.

SORT esegue le seguenti operazioni:

  • Apre il file di lavoro in modalità IO, il file di input in modalità INPUT e il file di output in modalità OUTPUT.

  • Trasferisce i record presenti nel file di input nel file di lavoro.

  • Ordina il SORT-FILE in sequenza ascendente / discendente con il tasto rec.

  • Trasferisce i record ordinati dal file di lavoro al file di output.

  • Chiude il file di input e il file di output ed elimina il file di lavoro.

Example

Nell'esempio seguente, INPUT è il file di input che deve essere ordinato in ordine crescente -

IDENTIFICATION DIVISION.
PROGRAM-ID. HELLO.

ENVIRONMENT DIVISION.
   INPUT-OUTPUT SECTION.
   FILE-CONTROL.
      SELECT INPUT ASSIGN TO IN.
      SELECT OUTPUT ASSIGN TO OUT.
      SELECT WORK ASSIGN TO WRK.

DATA DIVISION.
   FILE SECTION.
   FD INPUT.
      01 INPUT-STUDENT.
         05 STUDENT-ID-I PIC 9(5).
         05 STUDENT-NAME-I PIC A(25).
   FD OUTPUT.
      01 OUTPUT-STUDENT.
         05 STUDENT-ID-O PIC 9(5).
         05 STUDENT-NAME-O PIC A(25).
   SD WORK.
      01 WORK-STUDENT.
         05 STUDENT-ID-W PIC 9(5).
         05 STUDENT-NAME-W PIC A(25).

PROCEDURE DIVISION.
   SORT WORK ON ASCENDING KEY STUDENT-ID-O
   USING INPUT GIVING OUTPUT.
   DISPLAY 'Sort Successful'.
STOP RUN.

JCL per eseguire il programma COBOL di cui sopra -

//SAMPLE JOB(TESTJCL,XXXXXX),CLASS = A,MSGCLASS = C
//STEP1 EXEC PGM = HELLO
//IN DD DSN = INPUT-FILE-NAME,DISP = SHR
//OUT DD DSN = OUTPUT-FILE-NAME,DISP = SHR
//WRK DD DSN = &&TEMP

Quando compili ed esegui il programma sopra, produce il seguente risultato:

Sort Successful

Unisci verbo

Due o più file in sequenza identica vengono combinati utilizzando l'istruzione Merge. File utilizzati nel processo di unione -

  • File di input - Input-1, Input-2
  • File di lavoro
  • File di uscita

Sintassi

Di seguito è riportata la sintassi per unire due o più file:

MERGE work-file ON ASCENDING KEY rec-key1
   [ON DESCENDING KEY rec-key2]

USING input-1, input-2 GIVING output-file.

Unisci esegue le seguenti operazioni:

  • Apre il file di lavoro in modalità IO, i file di input in modalità INPUT e il file di output in modalità OUTPUT.

  • Trasferisce i record presenti nei file di input al file di lavoro.

  • Ordina il SORT-FILE in sequenza ascendente / discendente con il tasto rec.

  • Trasferisce i record ordinati dal file di lavoro al file di output.

  • Chiude il file di input e il file di output ed elimina il file di lavoro.

Example

Nell'esempio seguente, INPUT1 e INPUT2 sono i file di input che devono essere uniti in ordine crescente -

IDENTIFICATION DIVISION.
PROGRAM-ID. HELLO.

ENVIRONMENT DIVISION.
   INPUT-OUTPUT SECTION.
   FILE-CONTROL.
      SELECT INPUT1 ASSIGN TO IN1.
      SELECT INPUT2 ASSIGN TO IN2.
      SELECT OUTPUT ASSIGN TO OUT.
      SELECT WORK ASSIGN TO WRK.

DATA DIVISION.
   FILE SECTION.
   FD INPUT1.
      01 INPUT1-STUDENT.
         05 STUDENT-ID-I1 PIC 9(5).
         05 STUDENT-NAME-I1 PIC A(25).
   FD INPUT2.
      01 INPUT2-STUDENT.
         05 STUDENT-ID-I2 PIC 9(5).
         05 STUDENT-NAME-I2 PIC A(25).
   FD OUTPUT.
      01 OUTPUT-STUDENT.
         05 STUDENT-ID-O PIC 9(5).
         05 STUDENT-NAME-O PIC A(25).
   SD WORK.
      01 WORK-STUDENT.
         05 STUDENT-ID-W PIC 9(5).
         05 STUDENT-NAME-W PIC A(25).

PROCEDURE DIVISION.
   MERGE WORK ON ASCENDING KEY STUDENT-ID-O
   USING INPUT1, INPUT2 GIVING OUTPUT.
   DISPLAY 'Merge Successful'.
STOP RUN.

JCL per eseguire il programma COBOL di cui sopra -

//SAMPLE JOB(TESTJCL,XXXXXX),CLASS = A,MSGCLASS = C
//STEP1 EXEC PGM = HELLO
//IN1 DD DSN=INPUT1-FILE-NAME,DISP=SHR
//IN2 DD DSN=INPUT2-FILE-NAME,DISP=SHR
//OUT DD DSN = OUTPUT-FILE-NAME,DISP=SHR
//WRK DD DSN = &&TEMP

Quando compili ed esegui il programma sopra, produce il seguente risultato:

Merge Successful

A partire da ora, abbiamo imparato l'uso dei file in COBOL. Ora discuteremo di come un programma COBOL interagisce con DB2. Comprende i seguenti termini:

  • SQL incorporato
  • Programmazione dell'applicazione DB2
  • Variabili host
  • SQLCA
  • Query SQL
  • Cursors

SQL incorporato

Le istruzioni SQL incorporate vengono utilizzate nei programmi COBOL per eseguire operazioni SQL standard. Le istruzioni SQL incorporate vengono preelaborate dal processore SQL prima che il programma applicativo venga compilato. COBOL è noto comeHost Language. Le applicazioni COBOL-DB2 sono quelle applicazioni che includono sia COBOL che DB2.

Le istruzioni SQL incorporate funzionano come normali istruzioni SQL con alcune piccole modifiche. Ad esempio, l'output di una query viene indirizzato a un insieme predefinito di variabili che vengono indicate comeHost Variables. Una clausola INTO aggiuntiva viene inserita nell'istruzione SELECT.

Programmazione dell'applicazione DB2

Di seguito sono riportate le regole da seguire durante la codifica di un programma COBOL-DB2:

  • Tutte le istruzioni SQL devono essere delimitate tra EXEC SQL e ENDEXEC..

  • Le istruzioni SQL devono essere codificate nell'Area B.

  • Tutte le tabelle utilizzate in un programma devono essere dichiarate nella sezione WorkingStorage. Questo viene fatto usando ilINCLUDE dichiarazione.

  • Tutte le istruzioni SQL diverse da INCLUDE e DECLARE TABLE devono essere visualizzate nella divisione Procedure.

Variabili host

Le variabili host vengono utilizzate per ricevere dati da una tabella o inserire dati in una tabella. Le variabili host devono essere dichiarate per tutti i valori che devono essere passati tra il programma e il DB2. Sono dichiarati nella sezione Working-Storage.

Le variabili host non possono essere elementi di gruppo, ma possono essere raggruppate insieme nella struttura host. Non possono essereRenamed o Redefined. Utilizzando variabili host con istruzioni SQL, anteponile acolon (:)..

Sintassi

Di seguito è riportata la sintassi per dichiarare le variabili host e includere tabelle nella sezione Working-Storage -

DATA DIVISION.
   WORKING-STORAGE SECTION.
   
   EXEC SQL
   INCLUDE table-name
   END-EXEC.

   EXEC SQL BEGIN DECLARE SECTION
   END-EXEC.
   
   01 STUDENT-REC.
      05 STUDENT-ID PIC 9(4).
      05 STUDENT-NAME PIC X(25).
      05 STUDENT-ADDRESS X(50).
   EXEC SQL END DECLARE SECTION
   END-EXEC.

SQLCA

SQLCA è un'area di comunicazione SQL attraverso la quale DB2 trasmette il feedback dell'esecuzione SQL al programma. Dice al programma se un'esecuzione ha avuto successo o meno. Ci sono un certo numero di variabili predefinite in SQLCA comeSQLCODEche contiene il codice di errore. Il valore "000" in SQLCODE indica un'esecuzione riuscita.

Sintassi

Di seguito è riportata la sintassi per dichiarare un SQLCA nella sezione Working-Storage:

DATA DIVISION.
WORKING-STORAGE SECTION.
	EXEC SQL
	INCLUDE SQLCA
	END-EXEC.

Query SQL

Supponiamo di avere una tabella denominata "Student" che contiene Student-Id, Student-Name e Student-Address.

La tabella STUDENT contiene i seguenti dati:

Student Id		Student Name		Student Address
1001 			   Mohtashim M.		Hyderabad
1002			   Nishant Malik		Delhi
1003 			   Amitabh Bachan		Mumbai
1004			   Chulbul Pandey		Lucknow

L'esempio seguente mostra l'utilizzo di SELECT query in un programma COBOL -

IDENTIFICATION DIVISION.
PROGRAM-ID. HELLO.

DATA DIVISION.
   WORKING-STORAGE SECTION.
   EXEC SQL
      INCLUDE SQLCA
   END-EXEC.
   
   EXEC SQL
      INCLUDE STUDENT
   END-EXEC.
   
   EXEC SQL BEGIN DECLARE SECTION
   END-EXEC.
      01 WS-STUDENT-REC.
         05 WS-STUDENT-ID PIC 9(4).
         05 WS-STUDENT-NAME PIC X(25).
         05 WS-STUDENT-ADDRESS X(50).
   EXEC SQL END DECLARE SECTION
   END-EXEC.

PROCEDURE DIVISION.
   EXEC SQL
      SELECT STUDENT-ID, STUDENT-NAME, STUDENT-ADDRESS
      INTO :WS-STUDENT-ID, :WS-STUDENT-NAME, WS-STUDENT-ADDRESS FROM STUDENT
      WHERE STUDENT-ID=1004
   END-EXEC.
   
   IF SQLCODE = 0 
      DISPLAY WS-STUDENT-RECORD
   ELSE DISPLAY 'Error'
   END-IF.
STOP RUN.

JCL per eseguire il programma COBOL di cui sopra -

//SAMPLE JOB(TESTJCL,XXXXXX),CLASS = A,MSGCLASS = C
//STEP001  EXEC PGM = IKJEFT01
//STEPLIB  DD DSN = MYDATA.URMI.DBRMLIB,DISP = SHR
//SYSPRINT DD SYSOUT=*
//SYSUDUMP DD SYSOUT=*
//SYSOUT   DD SYSOUT=*
//SYSTSIN  DD *
   DSN SYSTEM(SSID)
   RUN PROGRAM(HELLO) PLAN(PLANNAME) -
   END
/*

Quando compili ed esegui il programma sopra, produce il seguente risultato:

1004 Chulbul Pandey		Lucknow

L'esempio seguente mostra l'utilizzo di INSERT query in un programma COBOL -

IDENTIFICATION DIVISION.
PROGRAM-ID. HELLO.

DATA DIVISION.
   WORKING-STORAGE SECTION.
   EXEC SQL
   INCLUDE SQLCA
   END-EXEC.
   
   EXEC SQL
   INCLUDE STUDENT
   END-EXEC.
   
   EXEC SQL BEGIN DECLARE SECTION
   END-EXEC.
      01 WS-STUDENT-REC.
         05 WS-STUDENT-ID PIC 9(4).
         05 WS-STUDENT-NAME PIC X(25).
         05 WS-STUDENT-ADDRESS X(50).
   EXEC SQL END DECLARE SECTION
   END-EXEC.

PROCEDURE DIVISION.
   MOVE 1005 TO WS-STUDENT-ID.
   MOVE 'TutorialsPoint' TO WS-STUDENT-NAME.
   MOVE 'Hyderabad' TO WS-STUDENT-ADDRESS.
   
   EXEC SQL
      INSERT INTO STUDENT(STUDENT-ID, STUDENT-NAME, STUDENT-ADDRESS)
      VALUES (:WS-STUDENT-ID, :WS-STUDENT-NAME, WS-STUDENT-ADDRESS)
   END-EXEC.
   
   IF SQLCODE = 0 
      DISPLAY 'Record Inserted Successfully'
      DISPLAY WS-STUDENT-REC
   ELSE DISPLAY 'Error'
   END-IF.
STOP RUN.

JCL per eseguire il programma COBOL di cui sopra -

//SAMPLE JOB(TESTJCL,XXXXXX),CLASS = A,MSGCLASS = C
//STEP001  EXEC PGM = IKJEFT01
//STEPLIB  DD DSN = MYDATA.URMI.DBRMLIB,DISP=SHR
//SYSPRINT DD SYSOUT = *
//SYSUDUMP DD SYSOUT = *
//SYSOUT   DD SYSOUT = *
//SYSTSIN  DD *
   DSN SYSTEM(SSID)
   RUN PROGRAM(HELLO) PLAN(PLANNAME) -
   END
/*

Quando compili ed esegui il programma sopra, produce il seguente risultato:

Record Inserted Successfully
1005 TutorialsPoint		Hyderabad

L'esempio seguente mostra l'utilizzo di UPDATE query in un programma COBOL -

IDENTIFICATION DIVISION.
PROGRAM-ID. HELLO.

DATA DIVISION.
   WORKING-STORAGE SECTION.
   
   EXEC SQL
   INCLUDE SQLCA
   END-EXEC.
   
   EXEC SQL
   INCLUDE STUDENT
   END-EXEC.
   
   EXEC SQL BEGIN DECLARE SECTION
   END-EXEC.
      01 WS-STUDENT-REC.
         05 WS-STUDENT-ID PIC 9(4).
         05 WS-STUDENT-NAME PIC X(25).
         05 WS-STUDENT-ADDRESS X(50).
   EXEC SQL END DECLARE SECTION
   END-EXEC.

PROCEDURE DIVISION.
   MOVE 'Bangalore' TO WS-STUDENT-ADDRESS.
   EXEC SQL
      UPDATE STUDENT SET STUDENT-ADDRESS=:WS-STUDENT-ADDRESS
      WHERE STUDENT-ID = 1003
   END-EXEC.
   
   IF SQLCODE = 0 
      DISPLAY 'Record Updated Successfully'
   ELSE DISPLAY 'Error'
   END-IF.
STOP RUN.

JCL per eseguire il programma COBOL di cui sopra -

//SAMPLE JOB(TESTJCL,XXXXXX),CLASS = A,MSGCLASS = C
//STEP001  EXEC PGM = IKJEFT01
//STEPLIB  DD DSN = MYDATA.URMI.DBRMLIB,DISP = SHR
//SYSPRINT DD SYSOUT = *
//SYSUDUMP DD SYSOUT = *
//SYSOUT   DD SYSOUT = *
//SYSTSIN  DD *
   DSN SYSTEM(SSID)
   RUN PROGRAM(HELLO) PLAN(PLANNAME) -
   END
/*

Quando compili ed esegui il programma sopra, produce il seguente risultato:

Record Updated Successfully

Il seguente example mostra l'utilizzo di DELETE query in un programma COBOL -

IDENTIFICATION DIVISION.
PROGRAM-ID. HELLO.

DATA DIVISION.
WORKING-STORAGE SECTION.

   EXEC SQL
   INCLUDE SQLCA
   END-EXEC.
   
   EXEC SQL
   INCLUDE STUDENT
   END-EXEC.
   
   EXEC SQL BEGIN DECLARE SECTION
   END-EXEC.
      01 WS-STUDENT-REC.
         05 WS-STUDENT-ID PIC 9(4).
         05 WS-STUDENT-NAME PIC X(25).
         05 WS-STUDENT-ADDRESS X(50).
   EXEC SQL END DECLARE SECTION
   END-EXEC.

PROCEDURE DIVISION.
   MOVE 1005 TO WS-STUDENT-ID.
   
   EXEC SQL
      DELETE FROM STUDENT
      WHERE STUDENT-ID=:WS-STUDENT-ID
   END-EXEC.
   
   IF SQLCODE = 0 
      DISPLAY 'Record Deleted Successfully'
   ELSE DISPLAY 'Error'
   END-IF.
STOP RUN.

JCL per eseguire il programma COBOL di cui sopra -

//SAMPLE JOB(TESTJCL,XXXXXX),CLASS = A,MSGCLASS = C
//STEP001  EXEC PGM = IKJEFT01
//STEPLIB  DD DSN = MYDATA.URMI.DBRMLIB,DISP=SHR
//SYSPRINT DD SYSOUT = *
//SYSUDUMP DD SYSOUT = *
//SYSOUT   DD SYSOUT = *
//SYSTSIN  DD *
   DSN SYSTEM(SSID)
   RUN PROGRAM(HELLO) PLAN(PLANNAME) -
   END
/*

Quando compili ed esegui il programma sopra, produce il seguente risultato:

Record Deleted Successfully

Cursori

I cursori vengono utilizzati per gestire più selezioni di righe alla volta. Sono strutture di dati che contengono tutti i risultati di una query. Possono essere definiti nella sezione Working-Storage o nella Divisione Procedure. Di seguito sono riportate le operazioni associate al Cursore:

  • Declare
  • Open
  • Close
  • Fetch

Dichiara il cursore

La dichiarazione del cursore può essere effettuata nella sezione Working-Storage o nella Divisione Procedure. La prima istruzione è l'istruzione DECLARE che è un'istruzione non eseguibile.

EXEC SQL
   DECLARE STUDCUR CURSOR FOR
   SELECT STUDENT-ID, STUDENT-NAME, STUDENT-ADDRESS FROM STUDENT
   WHERE STUDENT-ID >:WS-STUDENT-ID
END-EXEC.

Aperto

Prima di utilizzare un cursore, è necessario eseguire l'istruzione Open. L'istruzione Open prepara SELECT per l'esecuzione.

EXEC SQL
   OPEN STUDCUR
END-EXEC.

Vicino

L'istruzione Close rilascia tutta la memoria occupata dal cursore. È obbligatorio chiudere un cursore prima di terminare un programma.

EXEC SQL
   CLOSE STUDCUR
END-EXEC.

Fetch

L'istruzione Fetch identifica il cursore e inserisce il valore nella clausola INTO. Un'istruzione Fetch è codificata in loop man mano che otteniamo una riga alla volta.

EXEC SQL
   FETCH STUDCUR
   INTO :WS-STUDENT-ID, :WS-STUDENT-NAME, WS-STUDENT-ADDRESS
END-EXEC.

Il seguente esempio mostra l'utilizzo del cursore per recuperare tutti i record dalla tabella STUDENT -

IDENTIFICATION DIVISION.
PROGRAM-ID. HELLO.

DATA DIVISION.
   WORKING-STORAGE SECTION.
   
   EXEC SQL
   INCLUDE SQLCA
   END-EXEC.
   
   EXEC SQL
   INCLUDE STUDENT
   END-EXEC.
   
   EXEC SQL BEGIN DECLARE SECTION
   END-EXEC.
      01 WS-STUDENT-REC.
         05 WS-STUDENT-ID PIC 9(4).
         05 WS-STUDENT-NAME PIC X(25).
         05 WS-STUDENT-ADDRESS X(50).
   EXEC SQL END DECLARE SECTION
   END-EXEC.
   
   EXEC SQL
      DECLARE STUDCUR CURSOR FOR
      SELECT STUDENT-ID, STUDENT-NAME, STUDENT-ADDRESS FROM STUDENT
      WHERE STUDENT-ID >:WS-STUDENT-ID
   END-EXEC.

PROCEDURE DIVISION.
   MOVE 1001 TO WS-STUDENT-ID.
   PERFORM UNTIL SQLCODE = 100
   
   EXEC SQL
      FETCH STUDCUR
      INTO :WS-STUDENT-ID, :WS-STUDENT-NAME, WS-STUDENT-ADDRESS
   END-EXEC
   
   DISPLAY WS-STUDENT-REC
END-PERFORM	
STOP RUN.

JCL per eseguire il programma COBOL di cui sopra -

//SAMPLE JOB(TESTJCL,XXXXXX),CLASS = A,MSGCLASS = C
//STEP001  EXEC PGM=IKJEFT01
//STEPLIB  DD DSN=MYDATA.URMI.DBRMLIB,DISP=SHR
//SYSPRINT DD SYSOUT=*
//SYSUDUMP DD SYSOUT=*
//SYSOUT   DD SYSOUT=*
//SYSTSIN  DD *
   DSN SYSTEM(SSID)
   RUN PROGRAM(HELLO) PLAN(PLANNAME) -
   END
/*

Quando compili ed esegui il programma sopra, produce il seguente risultato:

1001 Mohtashim M.		Hyderabad
1002 Nishant Malik		Delhi
1003 Amitabh Bachan		Mumbai
1004 Chulbul Pandey		Lucknow