MANUALE COBOL

INDICE
NOTE SUL LINGUAGGIO COBOL..........................................................................................................................................................5 CAPITOLO 1.CARATTERISTICHE DEL LINGUAGGIO COBOL....................................................................................................................6

1.1 Organizzazione del programma in forma sorgente ..............................................................................6 1.2 Insieme dei caratteri .............................................................................................................................6 1.3 Struttura del linguaggio .......................................................................................................................7 1.3.1 Separatori ......................................................................................................................................7 1.3.2 Stringhe: character-string ..........................................................................................................8 1.3.3 Parole ............................................................................................................................................8 1.3.4 Parole definite dall'utente ..............................................................................................................8 1.3.5 Parole riservate ..............................................................................................................................9 1.3.6 Costanti figurative .........................................................................................................................9 1.3.7 Parole di caratteri speciali ...........................................................................................................10 1.3.8 Rappresentazione delle costanti ..................................................................................................10 1.4 Notazione sintattica ............................................................................................................................11
CAPITOLO 2.STRUTTURA DEL SORGENTE..............................................................................................................................................12

2.1 Indicatore ...........................................................................................................................................12 2.2 Area A e area B ..................................................................................................................................13 2.3 Interpunzione .....................................................................................................................................13
CAPITOLO 3.DIVISIONE IDENTIFICATION DIVISION ...........................................................................................................15

3.1 Struttura .............................................................................................................................................15 3.2 Codifica della divisione .....................................................................................................................15

CAPITOLO 4.DIVISIONE ENVIRONMENT DIVISION ..............................................................................................................17

4.1 Struttura .............................................................................................................................................17 4.2 Sezione CONFIGURATION SECTION .......................................................................................17 4.2.1 Paragrafo SOURCE-COMPUTER .........................................................................................17 4.2.2 Paragrafo OBJECT-COMPUTER ..........................................................................................18 4.2.3 Paragrafo SPECIAL-NAMES ................................................................................................18 4.3 Sezione INPUT-OUTPUT SECTION ...........................................................................................19 4.3.1 Paragrafo FILE-CONTROL ...................................................................................................20 4.3.2 File fisici e file logici ..............................................................................................................20 4.3.3 Istruzione SELECT per i file sequenziali ...............................................................................21
CAPITOLO 5.DIVISIONE DATA DIVISION ..................................................................................................................................23

5.1 Sezione FILE SECTION ...............................................................................................................23 5.1.1 Indicatore di livello FD ...........................................................................................................24 5.1.2 Descrizione del record ................................................................................................................24 5.2 Sezione WORKING-STORAGE SECTION .................................................................................27 5.3 Altri livelli speciali ............................................................................................................................27
CAPITOLO 6.DESCRIZIONE DELLE VARIABILI ........................................................................................................................................29

6.1 Oggetto della dichiarazione ...............................................................................................................30 6.2 Ridefinizione di una variabile ............................................................................................................30 6.3 Opzione PICTURE ........................................................................................................................31 6.4 Opzione USAGE ............................................................................................................................31 6.5 Opzione OCCURS .........................................................................................................................32 6.6 Opzione VALUE ...........................................................................................................................33
CAPITOLO 7.TABELLE .......................................................................................................................................................................34

7.1 Dichiarazione di una tabella ...............................................................................................................34 7.2 Riferimento al contenuto di una tabella .............................................................................................35 7.3 Indice .................................................................................................................................................35 2

CAPITOLO 8.VARIABILI 88.................................................................................................................................................................37

468.1 Nomi di condizione ........................................................................................................................37

CAPITOLO 9.MODELLO DI DEFINIZIONE DELLA VARIABILE .....................................................................................................................39

9.1 Dichiarazione del modello di definizione della variabile ..................................................................39 9.2 Variabili alfanumeriche .....................................................................................................................40 9.3 Variabili alfanumeriche modificate ...................................................................................................41 9.4 Variabili numeriche ...........................................................................................................................42 9.5 Variabili numeriche modificate .........................................................................................................44
CAPITOLO 10.NOTE SULL'UTILIZZO DELL'INSIEME DI CARATTERI UNIVERSALE CON IL COBOL ..............................................................48

10.1 Gruppi di istruzioni e istruzioni condizionali ..................................................................................48 10.2 Sezioni, paragrafi e qualificazione ...................................................................................................48 10.3 Espressioni aritmetiche ....................................................................................................................49 10.4 Espressioni condizionali ..................................................................................................................49 10.4.1 Condizioni di relazione .............................................................................................................49 10.4.2 Condizioni di classe ..................................................................................................................50 10.4.3 Nomi di condizione ...................................................................................................................50 10.4.4 Condizioni composte e negate .................................................................................................51 10.5 Avverbi comuni ...............................................................................................................................51
CAPITOLO 11.ISTRUZIONI...................................................................................................................................................................51

11.1 Istruzione ACCEPT .....................................................................................................................51 11.2 Istruzione ADD ............................................................................................................................53 11.3 Istruzione CLOSE ........................................................................................................................54 11.4 Istruzione COMPUTE .................................................................................................................54 11.5 Istruzione DISPLAY ....................................................................................................................55 11.6 Istruzione DIVIDE .......................................................................................................................55 11.7 Istruzione IF .................................................................................................................................57 11.8 Istruzione INSPECT ....................................................................................................................57 11.9 Istruzione MOVE .........................................................................................................................62 11.10 Istruzione MULTIPLY ..............................................................................................................64 11.11 Istruzione OPEN ........................................................................................................................64 11.12 Istruzione PERFORM ................................................................................................................65 11.12.1 Chiamata semplice ..................................................................................................................65 11.12.2 Chiamata ripetuta con condizione di uscita ..........................................................................66 11.12.3 Chiamata ripetuta con condizione di uscita e incremento di contatori .................................68 11.13 Istruzione READ ........................................................................................................................72 11.14 Istruzione STOP RUN ...............................................................................................................73 11.15 Istruzione STRING ....................................................................................................................73 11.16 Istruzione SUBTRACT ..............................................................................................................74 11.17 Istruzione WRITE ......................................................................................................................76
CAPITOLO 12.COBOL: PREPARAZIONE .............................................................................................................................................77

12.1 Problema del modulo di programmazione .......................................................................................77 12.2 Riepilogo di alcuni concetti importanti del linguaggio ....................................................................78
CAPITOLO 13.COBOL: ESEMPI ELEMENTARI .....................................................................................................................................80

13.1 ELM0100: prodotto tra due numeri .................................................................................................80 13.2 ELM0200: prodotto tra due numeri .................................................................................................80 13.3 ELM0300: prodotto tra due numeri .................................................................................................81 13.4 ELM0400: prodotto tra due numeri .................................................................................................82 13.5 ELM0500: prodotto tra due numeri .................................................................................................84 13.6 ELM0600: inserimento dati in un vettore (ARRAY).......................................................................85 13.7 ELM0700: inserimento dati in un vettore (ARRAY).......................................................................86 13.8 ELM0800: inserimento dati in un vettore (ARRAY).......................................................................87 3

13.9 ELM0900: ricerca sequenziale all'interno di un vettore (ARRAY).................................................89 13.10 ELM1000: ricerca sequenziale all'interno di un vettore (ARRAY)...............................................90 13.11 ELM1100: ricerca sequenziale all'interno di un vettore (ARRAY)...............................................92 13.12 ELM1300: creazione di un file sequenziale ...................................................................................94 13.13 ELM1500: lettura di un file sequenziale ......................................................................................95
CAPITOLO 14.COBOL: ESEMPI ELEMENTARI CON I FILE .....................................................................................................................98

14.1 AGO-83-1: estensione di un file sequenziale ..................................................................................98 14.2 AGO-83-2: lettura sequenziale e ricerca di una chiave ...................................................................99 14.3 AGO-83-13: creazione di un file sequenziale con dati da rielaborare ...........................................100 14.4 AGO-83-14: lettura e riscrittura di un file sequenziale .................................................................101

Note sul linguaggio COBOL

Il linguaggio COBOL nasce nel 1959, come linguaggio standard per l'amministrazione degli uffici e il nome sta per Common business oriented language, descrivendo precisamente il suo obiettivo. L'origine cos lontana del linguaggio COBOL responsabile della prolissit della sua sintassi e dei vincoli di forma nella struttura che il programma sorgente deve avere. Tuttavia, questo linguaggio eccezionale nella gestione dei dati, avvicinandosi alle funzionalit di un sistema di gestione di basi di dati (ovvero un DBMS). Il linguaggio COBOL nato da un comitato di utenti e di produttori di elaboratori, con lo scopo di rimanere uniforme, il pi possibile, su tutte le piattaforme. Generalmente si considera, correttamente, che il C rappresenti l'esempio di linguaggio di programmazione standard per definizione, ma i contesti sono differenti: il linguaggio C serve a consentire la migrazione di un sistema operativo da una macchina all'altra, mentre il linguaggio COBOL fatto per consentire la migrazione di programmi applicativi su architetture fisiche e sistemi operativi differenti. Il linguaggio COBOL fatto per poter funzionare su sistemi operativi che possono anche essere privi di qualunque astrazione dell'hardware; pertanto, una porzione apposita nella struttura del sorgente riservata alla dichiarazione delle unit fisiche per lo scambio dei dati (la divisione ENVIRONMENT DIVISION). Utilizzando il COBOL in un ambiente abbastanza evoluto, quanto pu esserlo un sistema Unix, molte informazioni diventano inutili e implicite, ma il fatto che con questo linguaggio ci sia la possibilit di operare con la maggior parte degli elaboratori fabbricati dal 1959 in poi, lo rende speciale e degno di apprezzamento per lungo tempo. Il linguaggio COBOL ha subito nel tempo diverse revisioni, indicate generalmente attraverso l'anno di edizione; un punto di riferimento abbastanza comune lo standard del 1985, a cui questo manuale, in parte, cerca di adeguarsi. Per quanto riguarda l'ente ISO, disponibile lo standard ISO 1989.

Capitolo 1.Caratteristiche del linguaggio COBOL

Il linguaggio COBOL si basa convenzionalmente sulla lingua inglese ed composto sommariamente da parole, istruzioni, gruppi di istruzioni, paragrafi e sezioni. 1.1 Organizzazione del programma in forma sorgente Ogni programma COBOL deve contenere quattro divisioni, anche se queste dovessero essere vuote, rispettando l'ordine seguente:

1. 2. 3. 4.

IDENTIFICATION DIVISION ENVIRONMENT DIVISION DATA DIVISION PROCEDURE DIVISION

La divisione IDENTIFICATION DIVISION serve a identificare il programma. Vi si possono includere informazioni generali, come il nome del programma stesso, la data di edizione, la data di compilazione, il nome dell'elaboratore per il quale stato scritto e altre annotazioni. La divisione ENVIRONMENT DIVISION specifica le apparecchiature usata e i file che servono al programma. La divisione DATA DIVISION contiene la descrizione dei file e dei record relativi, creati o utilizzati dal programma, assieme a tutte le altre variabili e costanti che servono al programma. La divisione PROCEDURE DIVISION specifica il procedimento elaborativo da applicare ai dati. Le azioni descritte nel programma COBOL sono espresse in termini di istruzioni, che possono essere riunite in gruppi di istruzioni e poi in paragrafi. 1.2 Insieme dei caratteri I compilatori tradizionali del linguaggio COBOL adottano, a seconda dei casi, il codice ASCII o il codice EBCDIC per la rappresentazione interna dei caratteri; inoltre, in un programma sorgente si pu usare soltanto un insieme ristretto di simboli, con l'eccezione del contenuto delle costanti alfanumeriche, che invece abbastanza libero. Tabella 461.1. I simboli disponibili nel linguaggio, in generale. Simboli Descrizione Simboli Descrizione 0..9 cifre numeriche A..Z lettere maiuscole dell'alfabeto inglese (latino) spazio + segno pi segno meno o trattino * / asterisco barra obliqua $ dollaro o segno di valuta , virgola ; . punto e virgola punto fermo ( ) parentesi aperta parentesi chiusa < > minore maggiore Si osservi che il segno di valuta, rappresentato normalmente dal dollaro, pu essere ridefinito e rappresentato da un altro simbolo. Tabella 461.2. Caratteri usati per l'interpunzione. Simboli Descrizione spazio bianco , virgola . punto fermo ( parentesi aperta Simboli Descrizione ; " ) punto e virgola virgolette parentesi chiusa

Tabella 461.3. Caratteri usati per formulare le parole. Simboli Descrizione Simboli Descrizione A..Z lettere alfabetiche maiuscole, senza accenti 0..9 cifre numeriche trattino Tabella 461.4. Caratteri usati come operatori aritmetici. Simboli Descrizione Simboli Descrizione + addizione sottrazione * / moltiplicazione divisione ( ) aperta parentesi chiusa parentesi Tabella 461.5. Caratteri usati nelle relazioni. Simboli Descrizione Simboli Descrizione = uguale a < > minore di maggiore di Si osservi che, al contrario di tanti altri linguaggi, nati per in momenti successivi, il COBOL non prevede l'uso del trattino basso (_). 1.3 Struttura del linguaggio Il testo di un programma sorgente COBOL costruito con stringhe di caratteri e separatori, secondo le regole descritte nelle sezioni successive. 1.3.1 Separatori Un separatore una stringa composta da uno o pi caratteri di interpunzione, rispettando le regole seguenti. Si osservi che queste regole non si applicano al contenuto delle costanti non numeriche (le stringhe letterali) e naturalmente non si applicano ai commenti. La virgola e il punto e virgola sono separatori, tranne quando appaiono nel modello di definizione di una variabile (PICTURE), dove invece sono trattati come parte del modello stesso. La virgola e il punto e virgola, se usati come separatori, possono essere impiegati al posto dello spazio. Un punto fermo, seguito da uno spazio, un separatore. Il punto fermo pu apparire soltanto dove ci permesso esplicitamente dalle regole grammaticali del linguaggio. Le parentesi tonde, usate in coppia, aperta e chiusa, sono separatori. Possono essere usate per delimitare indici, espressioni aritmetiche e condizioni. Le virgolette sono separatori. Le virgolette di apertura devono essere precedute da uno spazio o da una parentesi aperta; le virgolette di chiusura devono essere seguite, alternativamente da: uno spazio, una virgola, un punto e virgola, un punto fermo oppure una parentesi chiusa. Le virgolette possono apparire solo in coppia, per delimitare costanti alfanumeriche, tranne quando le costanti continuano nella riga successiva. Lo spazio usato come separatore pu precedere o seguire tutti gli altri separatori, tranne nei casi previsti dalle altre regole grammaticali del linguaggio. Uno spazio compreso tra una coppia di virgolette una costante alfanumerica e non costituisce un separatore.

I caratteri di interpunzione che appaiono all'interno di un modello di definizione di una variabile (PICTURE) o di una costante numerica, non sono considerati caratteri di interpunzione, piuttosto sono simboli usati per caratterizzare il modello relativo o la costante (le regole per la dichiarazione di un modello di definizione di una variabile sono descritte nel capitolo 469). I modelli di definizione delle variabili sono delimitati solo dallo spazio, dalla virgola, dal punto e virgola

o dal punto fermo. 1.3.2 Stringhe: character-string Nei modelli sintattici, una stringa di caratteri (character-string) pu essere: un carattere o una sequenza di caratteri contigui, che forma una parola per il linguaggio COBOL; il modello di definizione di una variabili (PICTURE); un commento. Una stringa di caratteri di questi contesti delimitata da separatori. 1.3.3 Parole Una parola per il linguaggio COBOL una stringa composta al massimo da 30 caratteri, che pu essere: una parola definita dall'utente, ovvero user-defined word; un nome di sistema, ovvero system-name; una parola riservata, ovvero reserved word.

Le parole riservate o di sistema non possono essere utilizzate per fini diversi, pertanto non possono essere ridefinite dall'utente. 1.3.4 Parole definite dall'utente Una parola definita dall'utente una parola COBOL che deve essere fornita per soddisfare la sintassi di un'istruzione. Tale parola pu essere composta utilizzando soltanto le lettere alfabetiche maiuscole, le cifre numeriche e il trattino (-), tenendo conto che il trattino non pu trovarsi all'inizio o alla fine di tali parole. Si osservi che in alcuni casi le parole sono costituite esclusivamente da cifre numeriche, mentre in tutti gli altri, le parole devono iniziare con una lettera alfabetica. Tabella 461.6. Classificazione parziale delle parole definite dall'utente. Definizione tradizionale Descrizione Il nome di condizione un nome al quale viene assegnato un valore o un insieme di valori o un intervallo di valori, scelti fra tutti quelli che una variabile pu assumere. La variabile stessa viene chiamata variabile di condizione. I nomi di condizione vengono definiti nella divisione DATA DIVISION. Un nome di condizione pu essere usato solo nelle espressioni condizionali, dove viene trattato come un'abbreviazione di una condizione di relazione. Il valore restituito dal nome di condizione Vero se il valore della variabile di condizione associata uguale a uno di quei valori che sono stati assegnati al nome di condizione. Si tratta del nome di una variabile descritta nella divisione DATA DIVISION. Una variabile di questo tipo rappresenta normalmente un componente che non pu essere suddiviso ulteriormente. Si tratta del nome di un file descritto all'interno della divisione DATA DIVISION e pu appartenere sia alla sezione FD (File description), sia alla sezione SD (Sort description). Si tratta del nome di un indice associato a una certa tabella, usato per selezionare una voce dalla tabella stessa. Un nome di questo tipo si dichiara nella divisione DATA DIVISION. Si tratta di un numero che indica la posizione nella struttura gerarchica di un record logico, oppure di un numero speciale che rappresenta convenzionalmente delle propriet speciali di una variabile. Il numero di livello espresso esclusivamente con una o due cifre numeriche; inoltre, i numeri che vanno da 01 a 49 indicano la posizione in un record, mentre i numeri 66, 77 e 88 identificano propriet speciali. Normalmente il numero di livello si scrive sempre utilizzando due cifre, aggiungendo eventualmente uno zero iniziale. Il numero di livello si usa nella divisione DATA DIVISION. Si tratta di un nome che serve a individuare una libreria di sorgenti COBOL, da usare per importare codice contenuto in altri file. Si tratta di un nome che fa riferimento a qualcosa, che dipende dall'ambiente in cui si vuole compilare o eseguire il programma. Questo tipo di parole si usa nella divisione ENVIRONMENT DIVISION, precisamente nel paragrafo SPECIAL-NAMES, con lo scopo di poter sostituire facilmente tali associazioni, senza intervenire in altre parti del programma. Si tratta del nome che dichiara l'inizio di un paragrafo nella divisione PROCEDURE DIVISION.

conditionname

data-name file-name index-name

level-number

library-name mnemonicname paragraphname

Definizione tradizionale program-name

Descrizione

Si tratta del nome del programma sorgente, come specificato nella divisione IDENTIFICATION DIVISION. Si tratta del nome di un record di un file. Associando idealmente il file a una tabella di dati, il record equivale record-name alla riga di tale tabella. La dichiarazione dei record avviene nella divisione DATA DIVISION. section-name Si tratta del nome che delimita l'inizio di una sezione nella divisione PROCEDURE DIVISION. text-name Si tratta del nome di identificazione di un componente all'interno della libreria di sorgenti. Tutte le parole definite dall'utente, a esclusione dei numeri di livello, possono appartenere soltanto a uno dei vari raggruppamenti previsti e devono essere uniche; tuttavia, in alcuni casi prevista la possibilit di qualificare dei nomi, che non sono univoci, in modo da attribuirli al loro contesto preciso (sezione 468.3). 1.3.5 Parole riservate Le parole riservate sono quelle parole del linguaggio che fanno parte di un elenco prestabilito e che hanno un significato speciale. Queste parole sono classificate in gruppi in base al loro utilizzo. Tabella 461.7. Classificazione sintetica delle parole riservate. Classificazione Descrizione Una parola chiave una parola riservata la cui presenza richiesta all'interno di un'istruzione (al contrario parole chiave di altre che possono essere usate soltanto per migliorare l'estetica o la leggibilit delle istruzioni). Le parole chiave devono essere inserite per specificare quel tipo di istruzione. Una parola opzionale una parola riservata facoltativa, che si pu usare nelle istruzioni per facilitarne la parole opzionali lettura. La parola opzionale non obbligatoria, ma se usata va applicata secondo la sintassi prevista. Una registro speciale identifica un'area di memoria con funzioni speciali. I registri speciali dipendono registri speciali generalmente dalle caratteristiche del compilatore e non sono standard. Una costante figurativa un nome che identifica un certo valore costante, come alternativa alla costanti figurative rappresentazione letterale. parole di caratteri Alcuni caratteri speciali, nell'ambito del contesto appropriato, possono essere rappresentati attraverso speciali parole particolari. Si tratta precisamente degli operatori di relazione. 1.3.6 Costanti figurative Per fare riferimento a valori costanti specifici si possono usare alcune parole riservate, note come costanti figurative. Di queste parole chiave esistono sia versioni al singolare, sia al plurale, ma rappresentano sempre la stessa cosa, ovvero un valore singolo o un valore ripetuto, in base al contesto. Tabella 461.8. Costanti figurative. Nome ZERO ZEROS ZEROES SPACE SPACES HIGHVALUE HIGHVALUES LOWVALUE LOWVALUES QUOTE QUOTES ALL valore Descrizione Rappresenta il valore numerico zero o la stringa 0 ripetuta pi volte. Rappresenta uno o pi spazi bianchi. Rappresenta uno o pi caratteri con un valore massimo, in base a qualche criterio, legato alla sequenza di collazione (collating sequence) o alla codifica. Generalmente si tratta del valore FF16.

Rappresenta uno o pi caratteri con un valore minimo, in base a qualche criterio, legato alla sequenza di collazione (collating sequence) o alla codifica. Generalmente si tratta del valore 0016. Rappresenta una o pi virgolette. Questa costante figurativa non pu sostituire le virgolette che delimitano le costanti alfanumeriche. Rappresenta la ripetizione indefinita del valore indicato. Tale valore pu essere specificato anche attraverso una

Nome

Descrizione costante letterale o una costante figurativa.

1.3.7 Parole di caratteri speciali Gli operatori di relazione si possono rappresentare con i simboli previsti (<, >, e =) oppure attraverso parole speciali, ovvero parole di caratteri speciali, note come special character word. La tabella successiva riepiloga l'uso degli operatori di relazione, in tutte le loro forme. Tabella 461.9. Modelli sintattici per l'uso degli operatori di relazione. Operatore Descrizione IS [NOT] GREATER THEN maggiore di, non maggiore di IS [NOT] > maggiore di, non maggiore di IS [NOT] LESS THEN minore di, non minore di IS [NOT] < minore di, non minore di IS [NOT] EQUAL TO uguale a, diverso da IS [NOT] = uguale a, diverso da IS GREATER THAN OR EQUAL TO maggiore o uguale a IS >= maggiore o uguale a IS LESS THAN OR EQUAL TO minore o uguale a IS <= minore o uguale a 1.3.8 Rappresentazione delle costanti Le costanti possono essere stringhe di caratteri, il cui valore implicito in base ai caratteri di cui sono composte, oppure sono costanti figurative, che rappresentano un valore in base al significato verbale che hanno. Una costante pu essere di tipo numerico o alfanumerico e non sono previsti altri tipi. Una costante numerica letterale una stringa composta da cifre numeriche ed eventualmente anche dai segni +, - e dal punto per la separazione tra la parte intera e la parte decimale (a meno che il punto sia da sostituire con la virgola, avendone scambiato le funzionalit con un'istruzione apposita). Una costante numerica deve contenere almeno una cifra e ha una dimensione massima di cifre che dipende dal compilatore. Una costante numerica non pu contenere pi di un segno. Se viene usato il segno, questo deve collocarsi nella posizione pi a sinistra; se non appare alcun segno, il valore si intende positivo. Una costante numerica non pu contenere pi di un punto decimale e pu apparire in qualunque posizione. Se non viene usato il punto decimale, la costante rappresenta un numero intero. Se nel paragrafo SPECIAL-NAMES della divisione ENVIRONMENT DIVISION specificata la dichiarazione DECIMAL-POINT IS COMMA, la rappresentazione dei valori numerici avviene scambiando il significato del punto e della virgola (in pratica secondo le convenzioni europee). Una costante alfanumerica una stringa di caratteri delimitata da virgolette. La stringa pu contenere qualsiasi carattere previsto dalla codifica utilizzata dal compilatore; in generale ammesso almeno l'uso delle lettere minuscole dell'alfabeto latino. Per rappresentare le virgolette (") all'interno di una stringa si usa il concatenamento con la costante figurativa QUOTE, come nell'esempio seguente: 000000 DISPLAY "Il file ", QUOTE, "mio.txt", QUOTE,

10

000000 " e` impegnato!". Una costante alfanumerica deve contenere almeno un carattere all'interno delle virgolette. La lunghezza massima di un valore alfanumerico dipende dal compilatore, ma in generale dovrebbe essere garantita la rappresentazione di almeno 200 caratteri. 1.4 Notazione sintattica I manuali COBOL adottano generalmente una forma particolare di notazione per descriverne la sintassi, a cui si adegua anche questo. Nella sintassi le parole chiave, secondo la definizione del COBOL, sono rappresentate sottolineate, a indicare la loro obbligatoriet, mentre le parole facoltative non sono sottolineate. Nell'esempio seguente, le parole IF, NOT, NUMERIC e ALPHABETIC sono parole chiave, mentre la parole IS facoltativa: / \ | NUMERIC | IF identifier IS [NOT] < > | ALPHABETIC | \ / Tutte le parole scritte con lettere minuscole rappresentano delle metavariabili sintattiche che devono essere espresse dal programmatore in quella posizione. Nell'esempio precedente appare una sola metavariabile denominata identifier. Le parentesi graffe servono a rappresentare la scelta tra alternative differenti. Nell'esempio precedente si deve scegliere tra due parole chiave: NUMERIC o ALPHABETIC. Le parentesi quadre rappresentano parti opzionali di un'istruzione; tuttavia si osservi che non si tratta di parole facoltative, secondo la definizione del linguaggio COBOL, perch l'uso o meno di tali porzioni di codice implica un risultato differente dell'istruzione. La presenza di tre punti consecutivi indica che i dati che precedono la notazione possono essere ripetuti successivamente, in funzione delle esigenze del problema che si intende risolvere. MOVE identifier-1 TO identifier2 ... Nell'esempio mostrato, i puntini di sospensione indicano che si possono inserire pi variabili (precisamente ci che rappresentato come identifier-2). In questo caso, il contenuto della prima variabile viene copiato all'interno di tutte quelle che sono annotate dopo la parola chiave TO. Quando appare il punto fermo nello schema sintattico, l'istruzione reale deve contenerlo nella stessa posizione relativa.

11

Capitolo 2.Struttura del sorgente

Figura 462.2. Suddivisione delle colonne.

In pratica, il codice COBOL si scrive in un file di testo di 80 colonne, rispettando le convenzioni descritte nella tabella successiva. Tabella 462.3. Colonne riservate nel codice COBOL. Colonne Utilizzo Le prime sei colonne servono a indicare un numero di sequenza delle righe. Il numero pu essere discontinuo, purch 1..6 progressivo. Generalmente si utilizzava una sequenza maggiore dell'unit, per consentire l'inserzione successiva di righe ulteriori, che si sarebbero tradotte nell'aggiunta di schede, senza dover perforare nuovamente tutto. La settima colonna serve a inserire un simbolo indicatore. Generalmente si tratta dell'asterisco, per specificare che 7 si tratta di una riga di commento, del trattino per la continuazione delle stringhe, oppure di una barra obliqua per richiedere un salto pagina in fase di stampa del sorgente. Le colonne dall'ottava all'undicesima rappresentano l'area A, nella quale devono iniziare le dichiarazioni pi 8..11 importanti. Le colonne dalla dodicesima alla settantaduesima rappresentano l'area B, nella quale si mettono tutte le direttive 12..72 che non possono partire dall'area A. 73..80 Le ultime otto colonne sono riservate per inserire un'etichetta facoltativa di identificazione del programma. 2.1 Indicatore La settima colonna serve per diverse funzioni, distinte in base alla presenza di un simbolo speciale; se in questa colonna si trova uno spazio, la riga viene usata per le funzioni normali. La tabella successiva riepiloga i simboli che possono apparire nella settima colonna e come questi dovrebbero essere interpretati dal compilatore. Indicatore Descrizione $ Il dollaro viene usato per specificare delle opzioni in fase di compilazione. L'asterisco stabilisce che, la riga in cui appare, contiene un commento che il compilatore deve ignorare * completamente. Il commento pu essere collocato solo nello spazio complessivo dell'area A e B, ovvero dalla colonna 8 alla colonna 72. La barra obliqua serve a richiedere un salto pagina quando gli strumenti di compilazione vengono usati per / stampare il sorgente. Ci che dovesse apparire nell'area A e B di una riga che ha la barra obliqua nella settima colonna viene considerato come un commento. La lettera D serve a indicare al compilatore che la riga in questione deve essere presa in considerazione solo se D l'opzione WITH DEBUGGING viene utilizzata nel paragrafo SOURCE COMPUTER; in caso contrario la riga deve essere trattata come un commento. Un trattino indica che, sulla riga precedente, l'ultima parola o costante non completa, ma continua sulla riga in cui appare il trattino stesso. Per quanto riguarda la continuazione di parole e di costanti numeriche su pi righe, il troncamento pu avvenire in qualsiasi punto, mettendo un trattino nella settima colonna della riga successiva, continuando l la parola o la costante, a partire dalla colonna 12 fino alla colonna 72 (area B). Gli spazi finali nella riga interrotta e quelli iniziali della riga che riprende, vengono ignorati.

12

Le costanti alfanumeriche delimitate da virgolette, si separano in modo differente. Sulla riga spezzata, si considerano tutte le informazioni dalle virgolette di apertura fino alla colonna 72 inclusa, mentre nella riga successiva, la costante deve riprendere aggiungendo altre virgolette di apertura. Si osservi che ci sono compilatori che si limitano a riconosce solo l'asterisco per i commenti, ignorando tutto il resto. Per questo motivo, bene evitare l'uso di ogni altro simbolo in questa colonna, quando si vuole scrivere un programma abbastanza compatibile, tenendo conto che si pu evitare la continuazione nella riga successiva, perch le istruzioni possono collocarsi su pi righe senza spezzare le parole, mentre le costanti alfanumeriche si possono dividere in porzioni pi piccole da concatenare. 2.2 Area A e area B Le intestazioni dei paragrafi, delle sezioni e delle divisioni devono iniziare nell'area A. L'intestazione di una divisione consiste nel nome della divisione (IDENTIFICATION, ENVIRONMENT, DATA o PROCEDURE), seguito da uno spazio bianco e dalla parola DIVISION, seguita a sua volta da un punto fermo. L'intestazione di una sezione consiste di un nome di sezione seguito da uno spazio bianco e dalla parola SECTION, seguita a sua volta da un punto fermo. L'intestazione di un paragrafo consiste di un nome di paragrafo seguito da un punto fermo e da uno spazio bianco; il primo gruppo di istruzioni del paragrafo pu apparire anche sulla stessa riga. All'interno delle divisioni IDENTIFICATION DIVISION e ENVIRONMENT DIVISION, le sezioni e i paragrafi sono fissi e sono ammessi solo i nomi previsti espressamente, mentre nella divisione PROCEDURE DIVISION i nomi dei paragrafi e delle sezioni sono stabiliti liberamente. All'interno della divisione DATA DIVISION, le sezioni FD e SD, cos come i numeri di livello 01 e 77, devono iniziare nell'area A, mentre gli altri numeri di livello devono iniziare nell'area B. Nell'area B inizia tutto quello che non pu iniziare nell'area A. 2.3 Interpunzione La scrittura di un programma COBOL sottoposta alle regole seguenti che riguardano l'uso dei caratteri di interpunzione. Un gruppo di istruzioni termina con un punto seguito da uno spazio bianco. Un punto pu apparire in un'altra posizione solo se fa parte di una costante alfanumerica, se si tratta del punto decimale di una costante numerica o se viene usato in un modello di definizione di una variabile (PICTURE). Una virgola pu essere usata fra le istruzioni per facilitare la leggibilit del programma; diversamente, una virgola pu apparire solo dove indicato nello schema sintattico. L'uso delle virgole non obbligatorio. Il punto e virgola pu essere usato al posto della virgola. Uno spazio delimita sempre una parola o una costante, a meno che tale spazio sia parte di una costante alfanumerica. Lo spazio inteso come delimitatore pu essere ridondante; inoltre, quando il testo di un'istruzione termina esattamente alla fine dell'area B (colonna 72), lo spazio successivo viene a mancare.

Listato 462.5. Un esempio preso da un programma sorgente, dove si mette in evidenza come si continua una parola o una costante alfanumerica nella riga successiva. 000100 000200 000300 000400 000500 000600 000700 000800 000900 001000 001100 001200 001300 IDENTIFICATION DIVISION. PROGRAM-ID. ESEMPIO0. AUTHOR. DANIELE GIACOMINI. DATE-WRITTEN. 2005-02-13. ENVIRONMENT DIVISION. INPUT-OUTPUT SECTION. FILE-CONTROL. ESEMPIO0 ESEMPIO0 ESEMPIO0 ESEMPIO0 ESEMPIO0

ESEMPIO0

ESEMPIO0 ESEMPIO0 ESEMPIO0

ESEMPIO0 ESEMPIO0 ESEMPIO0 ESEMPIO0

13

001400 SELECT FILE-DA-LEGGERE ASSIGN TO DISK ESEMPIO0 001500 ORGANIZATION IS SEQUENTIAL. ESEMPIO0 001600 ESEMPIO0 001700 DATA DIVISION. ESEMPIO0 001800 ESEMPIO0 001900 FILE SECTION. ESEMPIO0 002000 ESEMPIO0 002100 FD FILE-DA-LEGGERE ESEMPIO0 002200 LABEL RECORD IS STANDARD ESEMPIO0 002300 VALUE OF FILE-ID IS "input.txt". ESEMPIO0 002400 ESEMPIO0 002500 01 RECORD-DA-LEGGERE PIC X(30). ESEMPIO0 002600 ESEMPIO0 002700 WORKING-STORAGE SECTION. ESEMPIO0 002800 01 EOF PIC 9 VALUE ZERO. ESEMPIO0 002900/ ESEMPIO0 003000 PROCEDURE DIVISION. ESEMPIO0 003100* ESEMPIO0 003200* Qui inizia il paragrafo "MAIN". ESEMPIO0 003300* ESEMPIO0 003400 MAIN. ESEMPIO0 003500 OPEN INPUT FILE-DA-LEG ESEMPIO0 003600GERE. ESEMPIO0 003700 READ FILE-DA-LEG ESEMPIO0 003800GERE ESEMPIO0 003900 AT END ESEMPIO0 004000 MOVE 1 TO EOF. ESEMPIO0 004100 DISPLAY "Ho aperto il file input.txt e sto per emettere il suESEMPIO0 004200"o contenuto sullo schermo:". ESEMPIO0 004300 PERFORM LETTURA UNTIL EOF = 1. ESEMPIO0 004400 CLOSE FILE-DA-LEGGERE. ESEMPIO0 004500 ESEMPIO0 004600 STOP RUN. ESEMPIO0 004700* ESEMPIO0 004800* Qui inizia un altro paragrafo. ESEMPIO0 004900* ESEMPIO0 005000 LETTURA. ESEMPIO0 005100 DISPLAY RECORD-DA-LEGGERE. ESEMPIO0 005200 READ FILE-DA-LEGGERE ESEMPIO0 005300 AT END ESEMPIO0 005400 MOVE 1 TO EOF. ESEMPIO0 005500/ ESEMPIO0 Figura 462.6. Esempio di un modulo di programmazione COBOL.

14

Capitolo 3.Divisione IDENTIFICATION DIVISION

La divisione IDENTIFICATION DIVISION costituisce la prima parte di un programma COBOL. Il suo scopo quello di contenere delle informazioni sul programma, secondo una classificazione ben stabilita. Le informazioni tipiche che si inseriscono in questa divisione sono il nome del programma (nome che non coincide necessariamente con il nome del file che contiene il sorgente), il nome dell'autore, la data di scrittura del programma, la data di compilazione. 3.1 Struttura La struttura della divisione IDENTIFICATION DIVISION sintetizzabile nello schema sintattico seguente: IDENTIFICATION DIVISION. [PROGRAM-ID. program-name]. [AUTHOR. [comment-entry]...]. [INSTALLATION. [commententry]...]. [DATE-WRITTEN. [commententry]...]. [DATE-COMPILED. [commententry]...]. [SECURITY. [comment-entry]...]. La divisione deve iniziare scrivendo IDENTIFICATION DIVISION a partire dall'area A, ricordando di aggiungere il punto fermo finale. Tutti i nomi di paragrafo di questa divisione devono iniziare nell'area A e devono terminare con un punto fermo. Il nome del programma (program-name) deve essere una parola COBOL e serve a identificare il programma sorgente, ma non corrisponde necessariamente al nome del file su disco che contiene il sorgente. Le voci di commento (comment-entry), secondo lo schema sintattico, possono essere costituite da una sequenza qualunque di caratteri e possono occupare anche pi righe, senza bisogno di indicare il simbolo di continuazione nella settima colonna, avendo cura per di utilizzare per tali voci solo l'area B e di terminarle comunque con un punto fermo. La data di compilazione , o dovrebbe essere, posta automaticamente dal compilatore, quando prevista la stampa del sorgente da parte di questo strumento. A parte il caso della data di compilazione, che dovrebbe essere fornita dal compilatore, tutte le altre informazioni rimangono invariate. 3.2 Codifica della divisione Il listato successivo d un'idea di come pu essere codificata la divisione IDENTIFICATION DIVISION. 000100 IDENTIFICATION DIVISION. 000200 PROGRAM-ID. PROVA-INTESTAZIONE. 000300 AUTHOR. DANIELE GIACOMINI. 000400 INSTALLATION. NANOLINUX IV, 000500 TINYCOBOL 0.61, 000600 OPENCOBOL 0.31. 000700 DATE-WRITTEN. 2005-02-14. 000800 DATE-COMPILED. 000900 SECURITY. SEGRETISSIMO, LIVELLO

15

III. 001000* 001100 ENVIRONMENT DIVISION. 001200 DATA DIVISION. 001300 PROCEDURE DIVISION. 001400 MAIN. 001500 DISPLAY "CIAO A TUTTI!". 001600 STOP RUN.

16

Capitolo 4.Divisione ENVIRONMENT DIVISION

La divisione ENVIRONMENT DIVISION costituisce la seconda parte di un programma COBOL. La divisione si compone di due sezioni: CONFIGURATION SECTION e INPUT-OUTPUT SECTION. La sezione CONFIGURATION SECTION serve per indicare delle informazioni relative all'elaboratore usato per la compilazione del programma sorgente e a quello nel quale deve essere eseguito il programma, una volta compilato; inoltre, questa sezione permette di stabilire delle sostituzioni, come nel caso della virgola al posto del punto per separare la parte intera di un numero dalla parte decimale. La sezione INPUT-OUTPUT SECTION serve per associare i file usati dal programma con le unit fisiche relative, a indicare le caratteristiche di tali file e a stabilire altri aspetti dello scambio di dati. 4.1 Struttura La struttura della divisione ENVIRONMENT DIVISION sintetizzabile nello schema sintattico seguente: ENVIRONMENT DIVISION. .-- --. | CONFIGURATION SECTION. | | | | [SOURCE-COMPUTER. source-computerentry]. | | | | [OBJECT-COMPUTER. object-computerentry]. | | | | [SPECIAL-NAMES. special-names-entry]. | `-- --' .---. | INPUT-OUTPUT SECTION. | | | | FILE-CONTROL. file-control-entry... | | | | [I-O-CONTROL. input-output-control-entry...]. | `-- --' 4.2 Sezione CONFIGURATION SECTION La sezione CONFIGURATION SECTION contiene le informazioni sul sistema usato per la compilazione del programma (nel paragrafo SOURCE-COMPUTER), il sistema nel quale il programma deve essere eseguito (nel paragrafo OBJECT-COMPUTER) e il paragrafo SPECIALNAMES che consente di effettuare alcune sostituzioni a dei valori che altrimenti resterebbero al loro stato predefinito. CONFIGURATION SECTION. [SOURCE-COMPUTER. source-computerentry]. [OBJECT-COMPUTER. object-computerentry]. [SPECIAL-NAMES. special-names-entry]. 4.2.1 Paragrafo SOURCE-COMPUTER

17

Il paragrafo SOURCE-COMPUTER identifica l'elaboratore presso il quale si intende compilare il programma. Si utilizza secondo lo schema sintattico seguente: SOURCE-COMPUTER. computer-name [WITH DEBUGGING MODE]. Al posto della metavariabile computer-name deve essere indicata una parola COBOL, che serve solamente a titolo informativo nel sorgente. Se si specifica l'opzione DEBUGGING MODE si richiede al compilatore di prendere in considerazione, nel sorgente, tutte le righe annotate con la lettera D nella settima colonna e le istruzioni USE FOR DEBUGGING, che altrimenti verrebbero semplicemente ignorate. 4.2.2 Paragrafo OBJECT-COMPUTER Il paragrafo OBJECT COMPUTER identifica l'elaboratore presso il quale deve essere utilizzato il programma, una volta compilato. Lo schema sintattico per l'utilizzo di questo paragrafo quello seguente: OBJECT-COMPUTER. computername... . Il nome dell'elaboratore (computer name) deve essere una parola COBOL e ha un significato puramente informativo. Alla fine dell'indicazione dell'ultimo nome, deve apparire un punto fermo. 4.2.3 Paragrafo SPECIAL-NAMES Il paragrafo SPECIAL-NAMES serve ad associare un valore a dei nomi prestabiliti, quando si vuole che la funzione loro associata sia diversa da quella predefinita, oppure ad attribuire un nome mnemonico a un nome usato dal compilatore, che per non fa parte dello standard. Le dichiarazioni che possono apparire in questo paragrafo dipendono molto dalle caratteristiche del compilatore; quello che si vede nello schema sintattico seguente il minimo che dovrebbe essere disponibile nella maggior parte dei casi: SPECIAL-NAMES. implementor-name IS mnemonicname [CURRENCY SIGN IS literal] [DECIMAL-POINT IS COMMA]. Si utilizza la dichiarazione CURRENTY SIGN IS per fissare il simbolo predefinito da usare come segno di valuta; si usa la dichiarazione DECIMAL-POINT IS COMMA per rappresentare i valori numerici secondo la forma europea, dove la virgola indica la separazione tra la parte intera e quella decimale. Il segno di valuta pu essere costituito da un solo carattere e sono molto pochi i simboli che si possono usare. Per la precisione, sono esclusi tutti i simboli che invece possono essere usati nei modelli di definizione delle variabili oltre a quelli che si usano come delimitatori. In linea di massima sono da escludere: tutte le cifre numeriche (da 0 a 9); lo spazio; le lettere alfabetiche A, B, C, D, J, L, N, P, R, S, V, X, Z; i caratteri speciali *, +, -, ,, ., ;, %, (, ), ", ?. Si osservi che anche nel modello di definizione di una variabile (PICTURE), quando si usa la dichiarazione DECIMAL-POINT IS COMMA, il punto e la virgola si scambiano i ruoli. L'esempio seguente mostra un pezzo di programma in cui si vede l'uso di queste opzioni. Per la precisione, si assegna la lettera E per rappresentare la valuta: 000000 ENVIRONMENT DIVISION. 000000 CONFIGURATION SECTION. 000000 SPECIAL-NAMES. DECIMAL-POINT IS COMMA 000000 CURRENCY SIGN IS "E". L'attribuzione di un nome mnemonico a una parola non standard che per fa parte delle funzionalit specifiche del compilatore utilizzato, consente di limitare a questa sezione le modifiche per

18

l'adattamento del programma a un compilatore che ha funzioni simili, ma descritte da parole diverse. Nell'esempio seguente, compilabile con OpenCOBOL, si sostituisce la parola CONSOLE con STANDARD-INPUT, per identificare la fonte dei dati in ingresso per l'istruzione ACCEPT: 000100 IDENTIFICATION DIVISION. 000200 PROGRAM-ID. TEST-ACCEPT. 000300 AUTHOR. DANIELE GIACOMINI. 000400 DATE-WRITTEN. 2005-02-27. 000500* 000600 ENVIRONMENT DIVISION. 000700 CONFIGURATION SECTION. 000800 SOURCE-COMPUTER. 000900 OPENCOBOL. 001000 SPECIAL-NAMES. 001100 CONSOLE IS STANDARD-INPUT. 001200* 001300 DATA DIVISION. 001400* 001500 WORKING-STORAGE SECTION. 001600 77 MESSAGGIO PIC X(30). 001700* 001800 PROCEDURE DIVISION. 001900* 002000 MAIN. 002100 DISPLAY "INSERISCI IL MESSAGGIO". 002200 ACCEPT MESSAGGIO FROM STANDARDINPUT. 002300 DISPLAY "HAI INSERITO: ", MESSAGGIO. 002400* 002500 STOP RUN. 002600* Nell'esempio appena mostrato sono evidenziate le righe pi importanti per la comprensione del meccanismo; si pu comprendere che l'istruzione ACCEPT avrebbe potuto essere scritta semplicemente cos: 002200 ACCEPT MESSAGGIO FROM CONSOLE. Tuttavia, avendo utilizzato il nome mnemonico STANDARD-INPUT, se con un altro compilatore la console fosse identificata dalla sigla SPO (Supervisory printer output, come avveniva nel COBOL CMS (Computer management system della Burroughs negli anni 1980), basterebbe modificare la dichiarazione iniziale: 001000 SPECIAL-NAMES. 001100 SPO IS STANDARDINPUT. Per chiarezza, il caso di sottolineare che STANDARD-INPUT ha valore per il compilatore solo in quanto viene dichiarato come nome mnemonico, dal momento che il linguaggio, nella sua veste ufficiale, non prevede la gestione dei flussi standard dei sistemi Unix. 4.3 Sezione INPUT-OUTPUT SECTION La sezione INPUT-OUTPUT SECTION si suddivide in due paragrafi: FILE-CONTROL e I-OCONTROL. Il paragrafo FILE-CONTROL specifica l'organizzazione e l'accesso dei file che vengono usati dal programma e le informazioni correlate a tali file; il paragrafo I-O-CONTROL serve a specificare informazioni aggiuntive sui file gi dichiarati nell'altro paragrafo. INPUT-OUTPUT SECTION. FILE-CONTROL. file-control-entry... [I-O-CONTROL. input-output-controlentry...].

19

4.3.1 Paragrafo FILE-CONTROL Il paragrafo FILE-CONTROL serve a dichiarare i file utilizzati dal programma e a definire alcune loro caratteristiche. Tutti i file dichiarati nel paragrafo FILE-CONTROL devono essere descritti nella divisione DATA DIVISION; nello stesso modo, tutti i file descritti nella divisione DATA DIVISION, devono essere dichiarati nel paragrafo FILE-CONTROL. Il linguaggio COBOL prevede una gestione dei file molto sofisticata, anche se non detto che i compilatori mettano a disposizione sempre tutte le funzionalit standard. Si distinguono generalmente i tipi, in base alla loro organizzazione, come sintetizzato nella tabella successiva. Per il linguaggio COBOL i file sono sempre composti da record, pertanto l'accesso a un file si riferisce sempre a dei record. Tabella 464.11. Classificazione dei file in base all'organizzazione. Organizzazione Descrizione Il file sequenziale consente un accesso ai record in modo seriale, dal primo all'ultimo. Generalmente, si sequenziale dichiara un accesso sequenziale ai file quando l'unit di memorizzazione nella quale sono memorizzati per sua natura sequenziale, come per i nastri magnetici. relativa Si tratta di un file ad accesso diretto, dove i record si possono raggiungere specificandone il numero, a partire (relative) da uno, avendo anche la possibilit di richiedere qualche spostamento relativo rispetto al record attuale. Si tratta di un file associato a un indice dei record. Attraverso l'indice possibile raggiungere direttamente i a indice record associati, senza bisogno di eseguire delle scansioni di ricerca. L'organizzazione del file definisce le potenzialit di accesso, ma in generale sono disponibili diverse varianti nel modo particolare di accedere ai record. Il paragrafo FILE CONTROL si articola in dichiarazioni SELECT, una per ogni file, secondo lo schema sintattico sintetico seguente: FILE-CONTROL. SELECT file-name ASSIGN TO hardware-name [altreopzioni]. ... Il modo in cui l'istruzione SELECT si articola, dipende dall'organizzazione del file e dal metodo di accesso specifico che si vuole attuare sullo stesso. Nella logica originale del linguaggio, in questa fase non viene ancora indicato il nome del file reale, secondo il sistema operativo, perch generalmente per questa informazione si agisce nella divisione DATA DIVISION; tuttavia, spesso il compilatore permette, o richiede, di specificare il nome del file reale proprio nell'istruzione SELECT. 4.3.2 File fisici e file logici L'organizzazione di un file una caratteristica immutabile, che stabilisce, oltre che le potenzialit di accesso, anche la sua forma fisica reale, ovvero quella che viene gestita attraverso l'astrazione del sistema operativo. L'organizzazione sequenziale quella pi semplice, dove normalmente i record logici del linguaggio corrispondono esattamente al contenuto del file fisico che li contiene. L'organizzazione relativa richiede la capacit di abbinare delle informazioni ai record logici, per esempio per poter annotare che un record stato cancellato. Per fare questo, il compilatore pu inserire tutte le informazioni necessarie in un file solo, oppure pu avvalersi di due file reali: uno per i dati, l'altro per le informazioni sui record. L'organizzazione a indice richiede tutte le funzionalit di quella relativa, con l'aggiunta di poter gestire l'accesso in base a una o pi chiavi. Nei compilatori COBOL attuali, molto probabile che tutte le informazioni necessarie vengano gestite in un file fisico soltanto, ma originariamente era frequente l'uso di un file per i dati e di altri file per le chiavi (uno per ogni chiave). In base a questa premessa, si deve intendere che un file che viene creato con una certa organizzazione, pu essere usato solo con quella; inoltre, si pu contare sul fatto che un file creato con un programma realizzato attraverso un certo compilatore COBOL, non pu essere utilizzato con un programma generato con un altro. Di fronte a questo problema di compatibilit dei dati, i file organizzati in modo sequenziale sono sempre l'unica garanzia per un trasferimento dei dati. D'altra parte, negli anni in cui il linguaggio

20

COBOL aveva il suo massimo splendore, i nastri magnetici rappresentavano l'unit di memorizzazione standard tra le varie architetture proprietarie. 4.3.3 Istruzione SELECT per i file sequenziali Lo schema sintattico semplificato per l'istruzione SELECT, da usare nel paragrafo FILE-CONTROL, per dichiarare un file sequenziale quello che si pu vedere nella figura successiva: / \ | hardware-name | SELECT file-name ASSIGN TO < > | literal-file-name | \ / .-.-- --. --. Il file sequenziale pu essere letto o scritto soltanto in modo sequenziale, a partire dall'inizio. Se l'unit di memorizzazione che lo contiene sequenziale per sua natura, come avviene per un nastro o un lettore di schede perforate, si pu avere solo una fase di lettura o una fase di scrittura, senza la possibilit di mescolare le due operazioni, mentre se si dispone di un'unit di memorizzazione ad accesso diretto, come nel caso di un disco, si pu leggere e poi sovrascrivere lo stesso record. Nello schema sintattico, la metavariabile file-name deve essere sostituita con il nome che si vuole attribuire al file nell'ambito del programma (non si tratta del nome che questo ha eventualmente per il sistema operativo). La metavariabile hardware-name va sostituita con un nome che serve a identificare l'unit di memorizzazione che contiene il file; questo nome dipende dal compilatore ma generalmente si mette DISK per indicare un file su disco. Altri nomi per la metavariabile hardwarename potrebbero essere: TAPE, PRINTER, PUNCH, READER (gli ultimi due sarebbero un perforatore e un lettore di schede). Il linguaggio COBOL fatto per poter essere adattato a sistemi operativi molto diversi. In un sistema Unix, l'accesso alle unit di memorizzazione avviene attraverso dei file di dispositivo, pertanto, a seconda del compilatore, potrebbe anche essere superfluo dichiarare il tipo di unit di memorizzazione in questo modo, anche se in passato il linguaggio obbligava a farlo. Proprio per questo motivo, ci sono compilatori che, al posto di indicare il tipo di unit fisica attraverso un nome prestabilito, richiedono di mettere subito il percorso del file a cui si vuole fare riferimento, nonostante il linguaggio preveda per questo una dichiarazione separata nella divisione DATA DIVISION. In questo senso, nello schema sintattico appare la possibilit di indicare una stringa alfanumerica con il percorso del file (literal-filename). La dichiarazione FILE STATUS IS data-name consente di indicare una variabile (da specificare nella sezione WORKING-STORAGE SECTION della divisione DATA DIVISION) da usare eventualmente per conoscere lo stato dell'ultima operazione svolta sul file. Questa variabile deve poter rappresentare un valore di due caratteri (il modello di definizione della variabile deve essere XX) e quando contiene il valore zero indica che l'ultima operazione stata eseguita con successo (si vedano le tabelle 464.28 e 464.29, che appaiono alla fine del capitolo). Il punto fermo che conclude l'istruzione SELECT appare una volta sola, alla fine; tutta l'istruzione deve risiedere nell'area B. Viene mostrato un esempio completo di un programma COBOL che legge un file sequenziale: Listato 464.14. Programma elementare che legge un file sequenziale. 000100 IDENTIFICATION DIVISION. 000200 PROGRAM-ID. ESEMPIO-SEQUENZIALE. 000300 AUTHOR. DANIELE GIACOMINI. 000400 INSTALLATION. NANOLINUX IV, 000500 TINYCOBOL 0.61. 000600 DATE-WRITTEN. 2005-02-16. 000700 ENVIRONMENT DIVISION. 000800 INPUT-OUTPUT SECTION. 000900* 001000 FILE-CONTROL. 001100 SELECT FILE-NAME ASSIGN TO DISK 001500* 001600 DATA DIVISION.

21

001700 FILE SECTION. 001800 FD FILE-NAME 001900 LABEL RECORD IS STANDARD 002000 VALUE OF FILE-ID IS "input.seq". 002100 01 RECORD-NAME PIC X(20). 002200 WORKING-STORAGE SECTION. 002300 01 DATA-NAME PIC XX. 002400 PROCEDURE DIVISION. 002500 MAIN. 002600 OPEN INPUT FILE-NAME. 002700 DISPLAY "FILE STATUS: ", DATA-NAME. 002800 PERFORM READ-FILE UNTIL DATA-NAME NOT = ZERO. 002900 CLOSE FILE-NAME. 003000 STOP RUN. 003100 READ-FILE. 003200 READ FILE-NAME. 003300 DISPLAY "FILE STATUS: " DATA-NAME, " RECORD: ", RECORDNAME. Il file indicato come FILE-NAME associato in pratica al file input.seq. Si pu supporre che questo file abbia il contenuto seguente, senza alcun codice di interruzione di riga: aaaaaaaaaaaaaaaaaaaabbbbbbbbbbbbbbbbbbbbccccccccccccccccccccdddddddddddd dddddddd

22

Capitolo 5.Divisione DATA DIVISION

La divisione DATA DIVISION costituisce la terza parte, la pi complessa, di un programma COBOL e ha lo scopo di descrivere tutti i dati (variabili e costanti) utilizzati nel programma. Si distinguono in particolare: i record dei file a cui si vuole accedere, altre variabili e valori costanti creati o utilizzati dal programma. La divisione si articola normalmente in tre sezioni: FILE SECTION, per tutte le informazioni riguardanti i file dichiarati nella divisione ENVIRONMENT DIVISION, soprattutto per quanto riguarda la struttura del record; WORKING-STORAGE SECTION per tutte le variabili (che possono essere sia scalari, sia strutturate, ma in questo secondo caso vengono chiamate ugualmente record, anche se non sono associate direttamente ad alcun file) e le costanti necessarie per l'elaborazione; LINKAGE SECTION, per la dichiarazione dei dati condivisi con altri programmi. In questo manuale la descrizione della sezione LINKAGE SECTION viene omessa del tutto; pertanto, lo schema sintattico seguente non la riporta: DATA-DIVISION. .-| | FILE SECTION. | `-.---. --. | file-description-entry record-description-entry... | | | |... | | sort-merge-description-entry record-descriptionentry... | | `---' --' .-| | WORKING-STORAGE SECTION. | `-.---. --. | 77-level-description-entry | | | |... | | record-description-entry | | `---' --' Sulla base della terminologia usata nello schema sintattico, si pu intuire il fatto che per il linguaggio COBOL, il termine record ha un significato particolare: si tratta di una variabile strutturata, che pertanto pu essere scomposta in campi, in modo pi o meno articolato. In questo senso, il contenuto della sezione WORKING-STORAGE SECTION viene suddiviso in due tipi di dichiarazioni: variabili scalari non suddivisibili (la metavariabile 77-level-description-entry) e variabili strutturate, ovvero record. Naturalmente, una variabile strutturata (dichiarata come record) pu essere gestita e usata tranquillamente come se fosse uno scalare puro e semplice, ma questo fatto ha eventualmente delle ripercussioni nell'efficienza del programma che si ottiene dalla compilazione. 5.1 Sezione FILE SECTION La sezione FILE SECTION ha lo scopo di definire le caratteristiche fisiche dei file e la struttura dei record. Tradizionalmente sarebbe in questa sezione che si specifica il nome o il percorso dei file in base al sistema operativo in cui si deve utilizzare il programma, salvo il caso in cui il compilatore voglia questa indicazione direttamente nella divisione ENVIRONMENT DIVISION, precisamente nell'istruzione SELECT della sezione FILE CONTROL. La descrizione di un file nella sezione FILE SECTION inizia con l'indicatore di livello FD. Si osservi che questa istruzione inizia nell'area A del modulo di programmazione, continuando poi nell'area B, ma importante sottolineare che gi il nome del file, evidenziato nello schema sintattico con il nome file-name, deve iniziare nell'area B: / \

23

| FD file-name | < > .---. | entry-item |... . `---' Dopo ogni indicatore di livello FD deve apparire la dichiarazione della variabile strutturata che rappresenta il record del file; tale dichiarazione inizia con il livello 01. 5.1.1 Indicatore di livello FD I file comuni, ovvero quelli che non sono stati dichiarati esplicitamente per eseguire delle operazioni di riordino o di fusione, si descrivono nella sezione FILE SECTION con l'indicatore di livello FD (File description), che in pratica un'istruzione singola. Si ricordi che il nome del file che segue la parola chiave FD deve iniziare nell'area B del modulo di programmazione: FD file-name .-/ \ --. | | RECORDS | | | BLOCK CONTAINS [integer-1 TO] integer-2 < > | | | CHARACTERS | | `-\ / --' [ RECORD CONTAINS [integer-3 TO] integer-4 CHARACTERS ] .-/ \ / \ --. | | RECORD IS | | OMITTED | | | LABEL < > < > | | | RECORDS ARE | | STANDARD | | `-\ / \ / --' .-/ / \ \ --. | | | data-name-1 | | | | VALUE OF < label-info-1 IS < > >... | | | | literal-1 | | | `-\ \ / / --' .-/ \ --. | | RECORD IS | | | DATA < > data-name-2 [data-name-3]... | | | RECORDS ARE | | `-\ / --' [ CODE-SET IS alphabet-name ]. Si osservi che, a seconda del compilatore e del sistema operativo per il quale il programma viene compilato, diverse dichiarazioni inserite nell'indicatore di livello FD potrebbero essere ignorate in pratica. 5.1.2 Descrizione del record Dopo ogni indicatore di livello (FD) si deve descrivere il record attraverso una variabile strutturata, che si dichiara con quelli che sono noti come livelli. I livelli sono in pratica delle dichiarazioni che costituiscono ognuna delle istruzioni singole, ma in tal caso, a differenza delle istruzioni comuni, iniziano con un numero: il numero di livello. Il livello 01 obbligatorio e dichiara il nome della variabile strutturata che descrive il record nella sua interezza; qualunque numero superiore serve a descrivere una porzione inferiore del record, con la possibilit di scomposizioni successive. I numeri di livello che possono essere usati per questo scopo

24

sono limitati all'intervallo da 01 a 49, tenendo conto che, a parte l'obbligo di iniziare da 01, i livelli inferiori possono utilizzare incrementi superiori all'unit. Si osservi l'esempio seguente che contiene un estratto dalla sezione FILE SECTION: 001600 DATA DIVISION. 001700 FILE SECTION. 001800 FD SALES-FILE 001830 LABEL RECORD IS STANDARD 001860 VALUE OF FILE-ID IS "sales". 001900 01 SALES-RECORD. 002000 05 SALES-VENDOR-NAME PIC X(20). 002100 05 SALES-VALUE PIC S9(6). 002200 05 SALES-NUMBER PIC X(13). 002300 05 SALES-TYPE PIC X. 002400 05 SALES-VENDOR-REGION PIC X(17). 002500 05 SALES-VENDOR-CITY PIC X(20). 002600 05 SALES-COMMENTS PIC X(60). Il file individuato dal nome SALES-FILE si compone di record a cui si pu fare riferimento con la variabile strutturata SALES-RECORD. Il record si suddivide in sette campi con caratteristiche diverse. Il record nella sua interezza corrisponde al livello 01, evidenziato dalla sigla 01 che si trova nell'area A del modulo di programmazione. Come si vede nel livello 01 dell'esempio, la variabile strutturata che rappresenta tutto il record viene solo nominata, senza altre indicazioni, perch la sua dimensione si determina dalla somma dei campi che contiene. I numeri di livello, mano a mano che si annidano in sottolivelli successivi, devono crescere: non importante se il numero cresce di una o di pi unit. Tradizionalmente, i livelli vengono incrementati con un passo maggiore di uno, per facilitare la modifica del sorgente quando dovesse presentarsi l'esigenza di ristrutturare i livelli. Per comprendere meglio il senso della descrizione del record attraverso il sistema dei livelli, conviene dare un'occhiata allo schema successivo:

Quello che appare nello schema vuole rappresentare il record di un file da usare per memorizzare carichi e scarichi di un magazzino. Si pu osservare inizialmente un campo per numerare le registrazioni (ogni registrazione occupa un record), successivamente, appare la data dell'operazione suddivisa in tre parti (anno, mese e giorno), quindi viene indicato il carico, suddividendo la quantit caricata e il costo unitario di carico, quindi lo scarico, anche questo diviso in quantit scaricata e valore unitario di scarico, infine appare un campo descrittivo dell'operazione. Un record di questo tipo potrebbe essere descritto utilizzando i livelli nel modo seguente: 000000 01 RECORD-MOVIMENTI-DI-MAGAZZINO. 000000 10 MM-NUMERO-REGISTRAZIONE PIC 99999. 000000 10 MM-DATA-REGISTRAZIONE. 000000 20 MM-DATA-REGISTRAZIONE-ANNO PIC 9999. 000000 20 MM-DATA-REGISTRAZIONE-MESE PIC 99. 000000 20 MM-DATA-REGISTRAZIONE-GIORNO PIC 99. 000000 10 MM-CARICO. 000000 20 MM-CARICO-QUANTITA PIC 9(8)V999. 000000 20 MM-CARICO-COSTO-UNITARIO PIC 999999V99. 000000 10 MM-SCARICO. 000000 20 MM-SCARICO-QUANTITA PIC 9(8)V999. 000000 20 MM-SCARICO-VALORE-UNITARIO PIC 999999V99. 000000 10 MM-DESCRIZIONE PIC X(200).

25

Come si pu comprendere dall'esempio e come gi accennato in precedenza, per le porzioni di record che non si scompongono ulteriormente, si devono specificare le dimensioni, sommando le quali si ottiene la dimensione dei vari raggruppamenti e infine del record complessivo. La sintassi per rappresentare i livelli si potrebbe semplificare in questa fase nel modo seguente, dove per non si usa la notazione standard del linguaggio COBOL: nn nome-campo [PIC[TURE] [IS] modello_della_variabile [opzioni]]. Ci che non stato descritto fino a questo punto la parte di dichiarazione successiva al nome del campo, che inizia con la parola chiave PICTURE, spesso abbreviata soltanto con PIC. Ci che appare qui serve a definire il modello della variabile, ovvero la sua dimensione e le sue caratteristiche. Il modello di definizione della variabile una stringa che va composta seguendo regole precise. Con questo modello si specifica se la variabile di tipo numerico o alfanumerico, la sua dimensione, la presenza eventuale di una virgola (ovviamente per i valori numerici), il segno ed eventualmente una maschera di trasformazione. Dopo il modello di definizione della variabile possono apparire delle opzioni, in forma di dichiarazioni ulteriori, che servono a precisare la modalit con cui la variabile deve essere rappresentata internamente alla memoria centrale. Quando si dichiara una variabile numerica, importante chiarire quale rappresentazione deve avere. A seconda del compilatore, la variabile numerica potrebbe essere gestita in forma binaria oppure in forma BCD (Binary coded decimal), che a sua volta pu essere normale, dove ogni cifra occupa un byte, oppure packed, dove ogni cifra occupa mezzo byte (4 bit, noto anche come nibble). Questa caratteristica della variabile si definisce con le dichiarazioni opzionali che seguono il modello di definizione della variabile. Il modo in cui si dichiara il modello di definizione della variabile descritto nel capitolo 469, mentre per una visione complessiva del modo in cui si dichiara una variable, si deve consultare il capitolo 466; tuttavia, in questa fase si pu cominciare ugualmente a interpretare l'esempio mostrato in precedenza, osservando in particolare i campi seguenti: il campo MM-NUMERO-REGISTRAZIONE pu contenere un numero intero senza segno di cinque cifre: da zero a 99 999; il campo MM-CARICO-QUANTITA pu contenere un numero senza segno con otto cifre per la parte intera e tre cifre per la parte decimale; il campo MM-COSTO-UNITARIO pu contenere un numero senza segno con sei cifre per la parte intera e due cifre per la parte decimale; il campo MM-DESCRIZIONE pu contenere caratteri alfanumerici di qualunque tipo (nell'ambito di una rappresentazione in byte), per una dimensione di 200 caratteri.

Nell'esempio del magazzino si pu notare che tutti i nomi usati per individuare le varie componenti del record sono unici, ma oltre a questo stata usata l'accortezza di mettere un prefisso (MM-) per distinguerli rispetto a campi di altri file che potrebbero avere una struttura del record simile. Tuttavia, non strettamente necessario che tali nomi siano univoci per tutto il programma, perch prevista la possibilit di qualificarli in modo gerarchico. La qualificazione descritta nella sezione 468.3. Esiste anche la possibilit di ridefinire la struttura di un record, assegnando un nome alternativo a un certo livello che si vuole descrivere diversamente. Si osservi l'esempio seguente: 000000 01 MIO-RECORD. 000000 02 CAMPO-A PIC X(20). 000000 02 RIDEFINITO-A REDEFINES CAMPOA. 000000 03 DATA. 000000 04 ANNO PIC 9999. 000000 04 MESE PIC 99. 000000 04 GIORNO PIC 99. 000000 03 DESCRIZIONE PIC X(12). 000000 02 CAMPO-B ... ... Nell'esempio si vede un record denominato MIO-RECORD, che inizialmente composto dal campo CAMPO-A fatto per contenere 20 caratteri. Questo campo viene ridefinito nella riga successiva con il nome RIDEFINITO-A, che si articola in sottocampi, con i quali si vuole descrivere in modo alternativo la variabile CAMPO-A. In base al contesto si intende che i primi otto caratteri possano essere

26

interpretati come le cifre numeriche di una data (anno, mese e giorno), individuando il resto come una descrizione non meglio qualificabile. Generalmente, la ridefinizione di un campo che non suddiviso di scarsa utilit, mentre pi interessante quando si applica a campi che hanno gi una suddivisione, che per si vuole gestire anche in modo differente: 000000 01 MIO-RECORD. 000000 02 A 000000 03 B PIC X(10). 000000 03 C PIC X(10). 000000 02 D REDEFINES A. 000000 03 E PIC X(5). 000000 03 F PIC X(10). 000000 03 G PIC X(5). 000000 02 H ... ... In questo caso, il campo A composto complessivamente da 20 caratteri, a cui si accede con i campi B e C per i primi 10 e gli ultimi 10 rispettivamente. La ridefinizione successiva, consente di accedere a una porzione centrale, a cavallo dei campi B e C, con il campo F. 5.2 Sezione WORKING-STORAGE SECTION La sezione WORKING-STORAGE SECTION serve a dichiarare le variabili, strutturate o scalari, utilizzate dal programma, che non si riferiscono direttamente alla descrizione dei record dei file: WORKING-STORAGE SECTION. .---. | 77-level-descriptionentry | | |... | record-description-entry | `---' A differenza della sezione FILE SECTION, oltre alla dichiarazione di variabili strutturate, possibile dichiarare delle variabili scalari (non suddivisibili), utilizzando il livello speciale numero 77. 000000 WORKING-STORAGE SECTION. 000000 01 DATA-DA-SCOMPORRE. 000000 02 ANNO PIC 9999. 000000 02 MESE PIC 99. 000000 02 GIORNO PIC 99. 000000 77 FINE-DEL-FILE PIC 9. 000000 77 A PIC X(10). 000000 77 B PIC 9999V99. Il livello 77 viene dichiarato mettendo il numero relativo nella colonna dell'area A del modulo di programmazione, cos come si fa per il livello 01; nello stesso modo, il nome della variabile scalare si scrive nell'area B. L'esempio che appare sopra dovrebbe essere sufficiente a comprendere l'uso della sezione WORKING-STORAGE SECTION, tenendo conto che vale quanto descritto a proposito delle variabili strutturate che descrivono i record nella sezione FILE SECTION, compresa la ridefinizione. La dichiarazione di una variabile scalare con il livello 77 consente di specificare dei tipi numerici binari (come USAGE IS INDEX), per i quali non si pu prevedere la dimensione in modo standard. L'uso di questi tipi numerici speciali non ammesso nei campi di una variabile scalare descrittiva di un record. 5.3 Altri livelli speciali

27

Oltre ai livelli che servono a descrivere le variabili strutturate (da 01 a 49) e le variabili scalari (77), sono previsti due livelli speciali: 66 e 88. Questi livelli speciali servono a definire dei raggruppamenti di variabili appartenenti alla stessa struttura o a definire dei nomi di condizione. La descrizione di questi ulteriori livelli speciali viene fatta nel capitolo 468.

28

Capitolo 6.Descrizione delle variabili

Lo schema sintattico seguente descrive la dichiarazione delle variabili per i livelli da 01 a 49 e per il livello 77: .---. | data-name-1 | level-number | | [REDEFINES data-name-2] | FILLER | `-- --' .-| | | `-/ \ --. | PICTURE | | < > IS character-string | | PIC | | \ / --'

.-/ \ --. | | COMPUTATIONAL | | | | | | | | COMP | | | [USAGE IS] < > | | | DISPLAY | | | | | | | | INDEX | | `-\ / --' .-/ \ --. | | integer-2 TIMES | | | OCCURS < > | | | integer-1 TO integer-2 TIMES [DEPENDING ON data-name| | | | | | | | | `-\ .-| | | `- / | | |

3] |

/ \ --. | ASCENDING | | | < > KEY IS {data-name-4}... |... | DESCENDING | | | \ / --' | | [ INDEXED BY {index-name-1}... ] --'

Formato per il livello 88: / \/ .-- / \ --. \ | VALUE IS | | | | THROUGH | || 88 condition-name < > < literal-1 | < > literal-2 | >... . | VALUES ARE | | | | THRU | || \ /\ `-- \ / --' / Nel primo schema, l'indicazione del nome della variabile, che si vede in alternativa alla parola chiave FILLER, deve apparire immediatamente dopo il numero di livello; inoltre, se si usa la parola chiave REDEFINES, questa segue immediatamente il nome della variabile. Il resto delle opzioni pu essere inserito con l'ordine che si preferisce, rispettando comunque lo schema e l'eventuale interdipendenza che c' tra le opzioni stesse. L'opzione che definisce il modello di definizione della variabile, introdotta dalla parola chiave PICTURE, deve essere usata per ogni variabile che non si scompone ulteriormente e non pu essere usata negli altri casi.

29

La descrizione dei nomi di condizione (livello 88) disponibile nella sezione 468.1, mentre per quella riguardante i raggruppamenti alternativi di variabili si pu consultare la sezione 468.2. 6.1 Oggetto della dichiarazione La dichiarazione di una variabile (livelli da 01 a 49 e 77) avviene indicandone il nome subito dopo il numero di livello. Il nome della variable pu non essere univoco nell'ambito del programma, purch sia possibile individuare correttamente la variabile attraverso la qualificazione (sezione 468.3). Al posto di indicare il nome di una variabile, possibile mettere la parola chiave FILLER, quando il campo a cui fa riferimento non viene mai utilizzato direttamente. Naturalmente, l'uso di questa parola chiave non ammissibile in un livello 77, perch non avrebbe senso dichiarare una variabile scalare, indipendente da qualunque altra, senza avere poi la possibilit di utilizzarla nel programma. 6.2 Ridefinizione di una variabile L'opzione REDEFINES pu essere usata soltanto quando si dichiara una variabile, nell'ambito dei livelli da 01 a 49 (si esclude quindi l'uso della parola chiave FILLER), allo scopo di ridefinire la struttura di un'altra variabile che si trova allo stesso livello. 000000 01 MIO-RECORD. 000000 02 A 000000 03 B PIC X(10). 000000 03 C PIC X(10). 000000 02 D REDEFINES A. 000000 03 E PIC X(5). 000000 03 F PIC X(10). 000000 03 G PIC X(5). 000000 02 H ... ... L'esempio mostra che il campo A composto complessivamente da 20 caratteri, a cui si accede con i campi B e C per i primi 10 e gli ultimi 10 rispettivamente. La ridefinizione successiva, consente di accedere a una porzione centrale, a cavallo dei campi B e C, con il campo F. 000100 IDENTIFICATION DIVISION. 000200 PROGRAM-ID. PICTURE-REDEFINES. 000300 AUTHOR. DANIELE GIACOMINI. 000400 DATE-WRITTEN. 2005-02-25. 000500* 000600 ENVIRONMENT DIVISION. 000700* 000800 DATA DIVISION. 000900* 001000 WORKING-STORAGE SECTION. 001100 01 RECORD-A. 001200 02 P PICTURE X(10) USAGE IS DISPLAY. 001300 02 Q PICTURE X(10) USAGE IS DISPLAY. 001400 01 RECORD-B REDEFINES RECORD-A. 001500 02 R PICTURE X(5) USAGE IS DISPLAY. 001600 02 S PICTURE X(10) USAGE IS DISPLAY. 001700 02 T PICTURE X(5) USAGE IS DISPLAY. 001800* 001900 PROCEDURE DIVISION. 002000* 002100 MAIN. 002200 MOVE "ABCDEFGHIJKLMNOPQRST" TO RECORDA. 002300 DISPLAY "P: ", P.

30

002400 DISPLAY "Q: ", Q. 002500 DISPLAY "R: ", R. 002600 DISPLAY "S: ", S. 002700 DISPLAY "T: ", T. 002800* 002900 STOP RUN. 003000* Questo esempio ulteriore mostra un piccolo programma completo, che dimostra il funzionamento della ridefinizione, visualizzando le variabili associate a RECORD-A e a RECORD-B, che ridefinisce il primo. Se si compila questo programma con TinyCOBOL o con OpenCOBOL, l'avvio dell'eseguibile che si ottiene genera il risultato seguente: P: ABCDEFGHIJ Q: KLMNOPQRST R: ABCDE S: FGHIJKLMNO T: PQRST 6.3 Opzione PICTURE Attraverso l'opzione PICTURE, che obbligatoria per le variabili che non si scompongono in livelli inferiori, si definisce precisamente come fatta la variabile. L'argomento dell'opzione una stringa che descrive la variabile. Il modo in cui si rappresenta il modello delle variabili molto articolato e viene descritto nel capitolo 469. 6.4 Opzione USAGE Per il linguaggio COBOL, il contenuto di una variabile pu essere solo di due tipi: alfanumerico o numerico. Una variabile dichiarata per contenere valori alfanumerici, utilizza un formato a caratteri (normalmente si tratta della codifica ASCII o EBCDIC), mentre per i valori numerici ci sono delle alternative. Attraverso l'opzione USAGE si pu specificare il modo in cui la variabile deve contenere i dati. / \ | COMPUTATIONAL | | | | COMP | [USAGE IS] < > | DISPLAY | | | | INDEX | \ / Il formato definito dalla parola chiave DISPLAY corrisponde a un'organizzazione a caratteri. Si tratta evidentemente del formato necessario per le variabili alfanumeriche, ma pu essere usato anche per le variabili numeriche. Il formato COMPUTATIONAL, abbreviabile anche con COMP, pu essere usato soltanto per i valori numerici e richiede l'utilizzo di 4 bit per ogni cifra numerica e anche per il segno (se specificato). Il formato INDEX serve a dichiarare una variabile speciale, che pu rappresentare soltanto numeri interi senza segno. Non si pu associare un modello di definizione della variabile quando il formato INDEX, perch la dimensione fissa e dipende dal compilatore. L'uso di queste variabili anche limitato a certi contesti (di solito ne ammesso l'uso negli indici delle tabelle ed eventualmente nei contatori delle iterazioni) e queste variabili si dichiarano soltanto con un livello 77 in modo da essere svincolati da una struttura a record. L'opzione USAGE va usata principalmente nella descrizione di variabili terminali; teoricamente si pu indicare l'opzione USAGE anche per variabili che si suddividono in campi e in tal caso i livelli gerarchicamente inferiori ereditano l'opzione da quelli superiori. Tuttavia, meglio evitare questa pratica e limitarsi a usare l'opzione USAGE soltanto sui campi terminali, tenendo conto che cos i campi composti sono implicitamente di tipo DISPLAY. Volendo assegnare a una variabile strutturata un tipo diverso da DISPLAY, si otterrebbe solamente di

31

assegnare questa caratteristica ai livelli inferiori, perch una variabile strutturata, ammesso che la si voglia utilizzare direttamente, nel suo complesso, pu funzionare soltanto come DISPLAY. Come conseguenza, una variabile strutturata pu essere formata soltanto da un numero intero di byte. Quando si dichiarano su uno stesso livello variabili numeriche organizzate secondo il formato COMPUTATIONAL, queste utilizzano regolarmente lo spazio loro assegnato, condividendo eventualmente i byte che dovessero trovarsi a cavallo tra una e l'altra; tuttavia, nell'ambito della variabile composta che contiene questi livelli, i dati devono occupare una quantit di byte intera, pertanto si pu perdere eventualmente un po' di spazio alla fine. Figura 466.8. Confronto fra due variabili strutturate. 01 A. 01 B. 02 I. 03 P PIC 9 COMP. 03 P PIC 9 COMP. 02 J. 03 Q PIC S99 COMP. 03 Q PIC S99 COMP. 02 K. 03 R PIC 999 COMP. 03 R PIC 999 COMP. 02 L. 03 S PIC 9 COMP. 03 S PIC 9 COMP. 03 T PIC X. 03 T PIC X. ------------------------------------------------------------9 S 9 9 9 9 9 9 0 -X9 0 S 9 9 0 9 9 9 0 9 0 -X|_|_____|_____|_| |___| |_| |_____| |_____| |_| |___| | | | | | | | | | | P Q R S T P Q R S T |_____________________| |___|_______|_______| _______| | | | | | A I J K L |___________________________| | B La figura dovrebbe essere sufficiente per capire come viene utilizzata la memoria per la rappresentazione delle variabili COMPUTATIONAL. Si pu osservare che la variabile strutturata A ha soltanto uno spreco di una cifra COMPUTATIONAL, ovvero 4 bit, mentre la variabile B, avendo un'organizzazione differente nella sua struttura sottostante, spreca pi spazio. Molti compilatori COBOL considerano anche il tipo numerico COMPUTATIONAL-3, o COMP-3. Si tratta di una variante del tipo COMPUTATIONAL, con l'indicazione del segno o dell'assenza del segno, nel gruppo di 4 bit meno significativo (quello pi a destra). La maggior parte dei manuali COBOL sottolinea il fatto che per eseguire delle elaborazioni numeriche (dei calcoli matematici di qualunque tipo) bene che le variabili utilizzate siano di tipo COMPUTATIONAL, perch se le variabili sono ti tipo DISPLAY, prima di poter essere utilizzate devono essere convertite. 6.5 Opzione OCCURS La parola chiave OCCURS introduce un gruppo di informazioni che consentono di indicare che la variabile a cui fanno riferimento viene ripetuta secondo certe modalit. Attraverso questo meccanismo si creano quelle che per il COBOL sono delle tabelle. / \ | integer-2 TIMES | OCCURS < > | integer-1 TO integer-2 TIMES [DEPENDING ON dataname-3] | \ /

32

.-| | | `--

/ \ --. | ASCENDING | | < > KEY IS {data-name-4}... |... | DESCENDING | | \ / --'

[ INDEXED BY {index-name-1}... ] La variabile ricorrente di una tabella pu ripetersi per un numero fisso di elementi (integer-2), oppure per un numero variabile, nell'ambito di un intervallo stabilito (da integer-1 a integer-2), sotto il controllo di un'altra variabile (data-name-3). Se l'insieme degli elementi della tabella dichiarata con l'opzione OCCURS ordinato in base a una chiave, questa pu essere specificata (index-name-1); inoltre, l'indice per accedere agli elementi pu essere dichiarato contestualmente gi in questa fase (index-name-1). Per maggiori dettagli, si veda il capitolo 467, che dedicato solo alle tabelle del COBOL. 6.6 Opzione VALUE Convenzionalmente, una variabile che viene dichiarata nei livelli da 01 a 49 e 77, non ha inizialmente un valore prestabilito, ma solo casuale. Per stabilire un valore da attribuire a una variabile nel momento della sua creazione, si usa l'opzione VALUE: VALUE IS literal1 La costante che nello schema sintattico indicata come literal-1, il valore che viene attribuito inizialmente. Si osservi che possibile stabilire un valore iniziale per una variabile, soltanto quando si tratta di qualcosa che viene dichiarato nella sezione WORKING-STORAGE SECTION, perch nella sezione FILE SECTION ci non possibile e non avrebbe senso. L'opzione VALUE si usa anche per la dichiarazione dei nomi di condizione, ma in tal caso la funzione di questa opzione ha un valore differente e non c' pi la discriminazione tra le sezioni in cui si pu utilizzare.

33

Capitolo 7.Tabelle
Il linguaggio COBOL offre la gestione di array attraverso la definizione di variabili multiple, all'interno di variabili strutturate (record); tuttavia, la denominazione usata nel COBOL per queste rappresentazioni dei dati di tabella. level-number data-name-1 [omissis] / \ | integer-2 TIMES | OCCURS < > | integer-1 TO integer-2 TIMES [DEPENDING ON dataname-3] | \ .-| | | `- /

/ \ --. | ASCENDING | | < > KEY IS {data-name-4}... |... | DESCENDING | | \ / --'

[ INDEXED BY {index-name-1}... ] [omissis] . 7.1 Dichiarazione di una tabella Si dichiara che un campo composto da pi elementi dello stesso tipo aggiungendo in coda l'opzione OCCURS n TIMES. Lo schema sintattico completo dell'opzione il seguente: / \ | integer-2 TIMES | OCCURS < > | integer-1 TO integer-2 TIMES [DEPENDING ON dataname-3] | \ / .-| | | `-/ \ --. | ASCENDING | | < > KEY IS {data-name-4}... |... | DESCENDING | | \ / --'

[ INDEXED BY {index-name-1}... ] Le tabelle pi semplici sono quelle che hanno un numero fisso di elementi. Si osservi l'esempio seguente: 000000 01 A. 000000 02 B PIC 9999. 000000 02 C OCCURS 10 TIMES. 000000 03 D PIC X(10). 000000 03 E PIC 99 OCCURS 7 TIMES. 000000 02 F PIC X(10). Nell'esempio viene dichiarata una variabile strutturata denominata A, che si articola nelle variabili B, C e F. La variabile C ripetuta per 10 volte e si articola ogni volta nella variabile D e nella variabile E. La variabile E si ripete per sette volte.

34

La variabile E una tabella a due dimensioni, perch inclusa nelle ripetizioni della variabile C, mentre la variabile C una tabella a una sola dimensione. evidente che per fare riferimento ai valori contenuti nelle tabelle sia necessario utilizzare un indice. L'opzione OCCURS si pu utilizzare per tutte le variabili dichiarate con un numero di livello da 02 a 49. In pratica vengono esclusi i livelli 01 (record), 66 (usato per il raggruppamento delle variabili), 77 (usato esclusivamente per le variabili scalari) e 88 (nomi di condizione). Lo standard del 1974 del linguaggio COBOL pone come limite un massimo di tre dimensioni per le tabelle. 7.2 Riferimento al contenuto di una tabella Per fare riferimento a un elemento di una tabella, nelle istruzioni della divisione PROCEDURE DIVISION si usa una forma descritta dallo schema sintattico seguente: data-name (subscript-1 [subscript-2 [subscript-3...]]) In pratica, si scrive il nome della variabile ripetuta, seguita dall'indice o dagli indici tra parentesi tonde. Il primo indice riguarda la prima dimensione, intesa come quella pi esterna; l'ultimo riguarda l'annidamento pi interno. L'indice un numero intero positivo che va da uno fino al massimo della dimensione che lo riguarda. Seguendo l'esempio apparso nella sezione precedente, E (1 7) rappresenta la settima occorrenza della variabile E nell'ambito della prima della variabile C. Pertanto, il nome da usare per indicare l'elemento quello della variabile pi interna che si vuole individuare, mentre gli indici partono dalla posizione pi esterna. Si noti che convenzione comune inserire delle virgole per separare gli indici, anche se si tratta di una forma di rappresentazione facoltativa. Viene mostrato un altro esempio di tabella a tre dimensioni: 000000 01 ENCICLOPEDIA. 000000 05 VOLUME OCCURS 10 TIMES. 000000 10 TITOLO-VOLUME PIC X(30). 000000 10 PARTE OCCURS 20 TIMES. 000000 15 TITOLO-PARTE PIC X(30). 000000 15 CAPITOLO OCCURS 30 TIMES. 000000 20 TITOLO-CAPITOLO PIC (30). 000000 20 TESTO PIC (200). Si tratta di una variabile strutturata che serve a contenere delle informazioni su un'enciclopedia. L'elemento VOLUME (5) contiene le informazioni su tutto il volume quinto; l'elemento TITOLOVOLUME (5) contiene il titolo del volume quinto; l'elemento TITOLO-PARTE (5, 3) contiene il titolo della terza parte del volume quinto; l'elemento TESTO (5, 3, 25) contiene il testo del venticinquesimo capitolo contenuto nella terza parte del quinto volume. Naturalmente, in questo esempio si intende che la numerazione delle parti ricominci da uno all'inizio di ogni volume; cos si intende che all'inizio di ogni parte la numerazione dei capitoli riprenda da uno. 7.3 Indice L'indice di una tabella pu essere indicato attraverso una costante numerica, una variabile numerica a cui sia stato attribuito preventivamente un valore appropriato o attraverso un'espressione elementare che risulta in un numero intero appropriato. Quando si usa una variabile per la gestione di un indice, possibile ed consigliabile che il tipo numerico di tale variabile sia INDEX. In pratica, nella sezione WORKING-STORAGE SECTION un indice potrebbe essere dichiarato come nell'esempio seguente, dove se ne vedono due, il primo, denominato INDICE, dichiarato come variabile scalare di livello 77, il secondo, denominato INDICEC, sempre costituito da una variabile scalare, che per fa parte di una variabile strutturata: 000000 77 INDICE USAGE IS INDEX. 000000 000000 01 A.

35

000000 02 B PIC X(30). 000000 02 INDICE-C USAGE IS INDEX. Si pu osservare che questo tipo di variabile numerica non prevede la definizione della sua dimensione che stabilita invece dal compilatore, in base alle caratteristiche dell'elaboratore e del sistema operativo. In alternativa, l'indice pu essere dichiarato contestualmente alla dichiarazione della variabile ricorrente; in tal caso, il compilatore pu aggiungere dei controlli tali da impedire che si possa assegnare alla variabile un valore al di fuori dell'ambito della dimensione della tabella: 000000 01 ENCICLOPEDIA. 000000 05 VOLUME OCCURS 10 TIMES 000000 INDEX IS INDVOLUME. 000000 10 TITOLO-VOLUME PIC X(30). 000000 10 PARTE OCCURS 20 TIMES 000000 INDEX IS INDPARTE. 000000 15 TITOLO-PARTE PIC X(30). 000000 15 CAPITOLO OCCURS 30 TIMES 000000 INDEX IS INDCAPITOLO. 000000 20 TITOLO-CAPITOLO PIC (30). 000000 20 TESTO PIC (200). Qui viene ripreso e modificato un esempio gi apparso in una sezione precedente. La differenza consiste nell'assegnare l'indice a ogni variabile ricorrente. Pertanto si hanno gli indici: IND-VOLUME, IND-PARTE e IND-CAPITOLO. Come accennato, si pu fare riferimento a un elemento di una tabella indicando un indice costituito da un'espressione matematica elementare. Si parla in questo caso di indici relativi, perch si possono sommare o sottrarre dei valori a partire da una posizione di partenza. Per esempio, supponendo che la variabile I contenga il numero 15, l'elemento indicato come ELE (I - 4) corrisponderebbe alla notazione ELE (11); nello stesso modo, l'elemento indicato come ELE (I + 4) corrisponderebbe alla notazione ELE (19). 467.

36

Capitolo 8.Variabili 88
468.1 Nomi di condizione Attraverso il livello 88 possibile definire una costante speciale, con lo scopo di rappresentare la possibilit che una variabile contenga certi valori. In pratica, si dichiara una variabile, con i livelli da 01 a 49 o anche con il livello 77. A questa variabile si abbinano una o pi costanti dichiarate con il livello 88, che descrivono la possibilit che la variabile a cui si riferiscono contenga un certo insieme di valori. Le costanti di livello 88, dichiarate in questo modo, si usano poi nelle condizioni. / \ / .-- / \ --. \ | VALUE IS | | | | THROUGH | || 88 condition-name < > < literal-1 | < > literal-2 | >... . | VALUES ARE | | | | THRU | || \ / \ `-- \ / --' / Nello schema sintattico si vede soltanto la dichiarazione del livello 88, ma si deve tenere conto che si tratta di istruzioni che vanno collocate a partire dalla riga successiva a quella di dichiarazione della variabile a cui si riferiscono. La parola chiave THROUGH o THRU si usa per specificare un intervallo di valori (dalla costante literal-1 a literal-2. Il valore singolo o l'intervallo di valori, pu essere seguito da altri. Nell'esempio seguente, si vede la dichiarazione della variabile VERNICIATURA che pu contenere una stringa di 30 caratteri (alfanumerica). A questa variabile si associano due nomi di condizione, VERNICE-CHIARA e VERNICE-SCURA, che servono a definire due gruppi di colori, descritti per nome. Da questo si intuisce che nella parte procedurale del programma venga attribuito alla variabile VERNICIATURA il nome di un colore (scritto con lettere maiuscole); poi, per verificare il tipo di colore si pu usare uno di questi nomi di condizione, per esprimere il fatto che la variabile contenga uno dei nomi del gruppo a cui quel nome fa riferimento. 000000 01 VERNICIATURA PIC X(30). 000000 88 VERNICE-CHIARA "ARANCIO", "GIALLO", "VERDE", 000000 "AZZURRO", "GRIGIO", "BIANCO". 000000 88 VERNICE-SCURA "NERO", "MARRONE", "ROSSO", 000000 "BLU", "VIOLA". L'esempio seguente descrive la variabile CODICE che pu contenere una sola cifra numerica. A questa variabile si associano dei nomi di condizione, che descrivono raggruppamenti diversi delle cifre che possono essere contenute nella variabile. 000000 02 CODICE PIC 9. 000000 88 PARI 0, 2, 4, 6, 8. 000000 88 DISPARI 1, 3, 5, 7, 9. 000000 88 BASSO 0 THRU 4. 000000 88 ALTO 5 THRU 9. Nella divisione PROCEDURE DIVISION potrebbero apparire righe come quelle successive, per verificare che la variabile CODICE contenga certi valori: 000000 IF PARI 000000 THEN 000000 PERFORM ...; 000000 ELSE 000000 ... In questo modo si evita di scrivere un'espressione condizionale complessa come nell'esempio seguente: 000000 IF CODICE IS EQUAL TO 0 000000 OR CODICE IS EQUAL TO

37

2 000000 OR CODICE IS EQUAL TO 4 000000 OR CODICE IS EQUAL TO 6 000000 OR CODICE IS EQUAL TO 8 000000 THEN 000000 PERFORM ... 000000 ELSE 000000 ... I nomi di condizione si possono associare a variabili che hanno un contenuto alfabetico, alfanumerico e numerico, ma nell'ultimo caso, deve trattarsi di valori rappresentati in forma di stringhe di caratteri (pertanto sono escluse le rappresentazioni compatte che usano quattro bit per cifra e quelle binarie). Un nome di condizione pu essere associato a una variabile che costituisce una tabella, oppure che contenuta in una struttura tabellare. Per fare riferimento al nome di condizione nella cella giusta, occorre utilizzare gli indici, cos come si fa normalmente in queste situazioni.

38

Capitolo 9.Modello di definizione della variabile

Il COBOL gestisce soltanto due tipi di dati: numerici e alfanumerici. Tuttavia, nel momento in cui si dichiara il modello, le variabili scalari (ovvero quelle che non sono scomposte) si distinguono in classi e in categorie, secondo lo schema che si vede nella tabella successiva. Tabella 469.1. Classi e categorie delle variabili COBOL.

Le variabili che appartengono alla classe numerica contengono dei valori che si possono utilizzare per eseguire delle espressioni numeriche; mentre quelle che appartengono alla classe alfanumerica si possono utilizzare soltanto come sequenze di caratteri. Si osservi che una variabile strutturata sempre solo alfanumerica, ma ci non toglie che i campi che contiene possano essere di una classe e di una categoria differente. Le variabili che appartengono alle categorie edited, modificate, servono per ricevere un valore, numerico o alfanumerico, da modificare nell'atto stesso della ricezione. Una variabile di questo tipo fa sempre parte della classe alfanumerica, perch, una volta ricevuti i dati e modificati in base al modello di definizione della variabile, questi sono semplicemente una sequenza di caratteri senza pi alcun valore numerico. 9.1 Dichiarazione del modello di definizione della variabile Il modello di definizione della variabile introdotto dalla parola chiave PICTURE, o PIC: / \ | PICTURE | < > IS characterstring | PIC | \ / La metavariabile character-string costituisce il modello vero e proprio, che pu essere composto da un massimo di 30 caratteri, anche se in questo modo si possono comunque rappresentare modelli di variabili di dimensioni molto pi grandi. Si osservi che l'indicazione di un modello di definizione della variabile obbligatorio per tutte le variabili scalari (pertanto riguarda potenzialmente i livelli da 01 a 49 e 77), mentre non consentito per le variabili strutturate. La stringa che costituisce il modello di definizione della variabile composta di simboli che descrivono ognuno le caratteristiche di un carattere, di una cifra, di un segno, oppure inseriscono qualcosa che nel dato originale assente, ma spesso possono essere ripetuti mettendo un numero intero tra parentesi: x(n)

39

Una notazione del genere indica che il simbolo x va inteso come se fosse ripetuto n volte; per esempio, 9(3)V9(5) equivalente a 999V99999. attraverso questo meccanismo che si possono descrivere variabili molto grandi, pur avendo un modello di definizione limitato a soli 30 caratteri. Nelle sezioni successive vengono descritti i simboli utilizzabili per i modelli di definizione delle variabili scalari. Lo standard del linguaggio COBOL annovera pi possibilit di quelle indicate, ma i compilatori non si comportano sempre allo stesso modo e spesso ignorano l'uso di alcuni simboli, oppure li interpretano in modo inesatto. Questo problema riguarda soprattutto i simboli che applicano delle modifiche al valore ricevuto nella variabile, che quindi vanno usati con estrema parsimonia se si vuole scrivere un programma abbastanza compatibile. 9.2 Variabili alfanumeriche Sono variabili alfanumeriche pure e semplici quelle che possono rappresentare qualunque carattere delle codifica prevista, limitatamente al fatto che la rappresentazione in forma di byte (ASCII o EBCDIC). Il modello di definizione di una variabile alfanumerica prevede simboli speciali che limitano l'inserimento di soli caratteri alfabetici o di sole cifre numeriche, ma in pratica, succede spesso che i compilatori non applichino alcuna restrizione. Tabella 469.3. Simboli del modello di definizione di una variabile alfanumerica. Simbolo Descrizione 9 Rappresenta una cifra numerica. A Rappresenta una lettera dell'alfabeto latino, non accentata, maiuscola o minuscola. X Rappresenta un carattere qualsiasi. Si osservi che il modello di definizione di una variabile alfanumerica deve contenere almeno un simbolo X o A, altrimenti, un modello che contenga soltanto il simbolo 9 verrebbe interpretato come numerico. A titolo di esempio, viene mostrato un piccolo programma con tre variabili scalari alfanumeriche, aventi modelli diversi, abbinate ognuna a una variabile strutturata. Alle variabili scalari viene assegnato lo stesso valore, in modo da poter confrontare come questo valore viene inteso e rappresentato. 000100 IDENTIFICATION DIVISION. 000200 PROGRAM-ID. PICTURE-ALPHANUMERIC. 000300 AUTHOR. DANIELE GIACOMINI. 000400 DATE-WRITTEN. 2005-02-23. 000500* 000600 ENVIRONMENT DIVISION. 000700* 000800 DATA DIVISION. 000900* 001000 WORKING-STORAGE SECTION. 001100 01 RECORD-A. 001200 02 A PICTURE X(15) USAGE IS DISPLAY. 001300 01 RECORD-B. 001400 02 B PICTURE 9(5)A(5)X(5) USAGE IS DISPLAY. 001500 01 RECORD-C. 001600 02 C PICTURE A(5)X(5)9(5) USAGE IS DISPLAY. 001700* 001800 PROCEDURE DIVISION. 001900* 002000 MAIN. 002100 MOVE " 1234567890ABCDEFGHIJKLMNOPQRSTUVWXYZ" TO A. 002200 MOVE " 1234567890ABCDEFGHIJKLMNOPQRSTUVWXYZ" TO B. 002300 MOVE " 1234567890ABCDEFGHIJKLMNOPQRSTUVWXYZ" TO C. 002400 DISPLAY "SOURCE VALUE IS: ", QUOTE, 002500 " 1234567890ABCDEFGHIJKLMNOPQRSTUVWXYZ",

40

QUOTE. 002600 DISPLAY "PICTURE: X(15) VALUE: ", QUOTE, A, QUOTE, 002700 " DATA: ", QUOTE, RECORD-A, QUOTE. 002800 DISPLAY "PICTURE: 9(5)A(5)X(5) VALUE: ", QUOTE, B, QUOTE, 002900 " DATA: ", QUOTE, RECORD-B, QUOTE. 003000 DISPLAY "PICTURE: A(5)X(5)9(5) VALUE: ", QUOTE, C, QUOTE, 003100 " DATA: ", QUOTE, RECORD-C, QUOTE. 003200* Compilando il programma con TinyCOBOL, l'avvio dell'eseguibile che si ottiene genera il risultato seguente, dove si pu vedere che l'uso dei simboli A e 9 non comporta alcuna differenza di funzionamento rispetto a X; tuttavia, un compilatore pi sofisticato potrebbe segnalare qualche tipo di errore: SOURCE VALUE IS: " 1234567890ABCDEFGHIJKLMNOPQRSTUVWXYZ" PICTURE: X(15) VALUE: " 1234567890ABCD" DATA: " 1234567890ABCD" PICTURE: 9(5)A(5)X(5) VALUE: " 1234567890ABCD" DATA: " 1234567890ABCD" PICTURE: A(5)X(5)9(5) VALUE: " 1234567890ABCD" DATA: " 1234567890ABCD" 9.3 Variabili alfanumeriche modificate Il modello di definizione di una variabile alfanumerica pu contenere simboli che applicano una modifica al valore stesso. La modifica avviene nel momento in cui il valore viene ricevuto. Tabella 469.6. Simboli del modello di definizione di una variabile alfanumerica che descrivono una modifica del valore ricevuto. Simbolo B 0 / Descrizione Richiede l'inserimento di uno spazio. Richiede l'inserimento di uno zero. Se il compilatore lo permette, inserisce una barra obliqua. Se il compilatore lo permette, inserisce una virgola. Si osservi comunque che non pu apparire la virgola come , simbolo conclusivo del modello, perch in tal caso assumerebbe il significato di un delimitatore. Teoricamente, ogni altro simbolo che non abbia un significato preciso per la realizzazione dei modelli di definizione delle variabili, dovrebbe essere aggiunto tale e quale; in pratica, molto dipende dalle caratteristiche del compilatore. A titolo di esempio, viene mostrato un piccolo programma con due variabili scalari alfanumeriche, aventi modelli diversi, abbinate ognuna a una variabile strutturata. Alle variabili scalari viene assegnato lo stesso valore, in modo da poter confrontare come questo viene inteso e rappresentato. Nell'esempio si tenta in particolare di inserire in un modello una barra obliqua e una virgola. 000100 IDENTIFICATION DIVISION. 000200 PROGRAM-ID. PICTURE-ALPHANUMERIC-EDITED. 000300 AUTHOR. DANIELE GIACOMINI. 000400 DATE-WRITTEN. 2005-02-23. 000500* 000600 ENVIRONMENT DIVISION. 000700* 000800 DATA DIVISION. 000900* 001000 WORKING-STORAGE SECTION. 001100 01 RECORD-A. 001200 02 A PICTURE X(15) USAGE IS DISPLAY. 001300 01 RECORD-B. 001400 02 B PICTURE ABX09,/X(8) USAGE IS DISPLAY. 001500* 001600 PROCEDURE DIVISION. 001700* 001800 MAIN.

41

001900 MOVE "ABCDEFGHIJKLMNOPQRSTUVWXYZ" TO A. 002000 MOVE "ABCDEFGHIJKLMNOPQRSTUVWXYZ" TO B. 002100 DISPLAY "SOURCE VALUE IS: ", QUOTE, 002200 "ABCDEFGHIJKLMNOPQRSTUVWXYZ", QUOTE. 002300 DISPLAY "PICTURE: X(15) VALUE: ", QUOTE, A, QUOTE, 002400 " DATA: ", QUOTE, RECORD-A, QUOTE. 002500 DISPLAY "PICTURE: ABX09,/X(8) VALUE: ", QUOTE, B, QUOTE, 002600 " DATA: ", QUOTE, RECORD-B, QUOTE. 002700* Compilando il programma con TinyCOBOL, l'avvio dell'eseguibile che si ottiene genera il risultato seguente: SOURCE VALUE IS: "ABCDEFGHIJKLMNOPQRSTUVWXYZ" PICTURE: X(15) VALUE: "ABCDEFGHIJKLMNO" DATA: "ABCDEFGHIJKLMNO" PICTURE: ABX09,/X(8) VALUE: "A B0C,/DEFGHIJK" DATA: "A B0C,/DEFGHIJK" 9.4 Variabili numeriche Le variabili numeriche pure e semplici, sono quelle il cui valore pu essere usato per calcolare delle espressioni numeriche. Nel modello di definizione di una variabile di questo tipo, possono apparire solo simboli che descrivono la dimensione del valore rappresentabile, distinguendo la parte intera da quella decimale e specificando eventualmente la presenza del segno. Tabella 469.9. Simboli del modello di definizione di una variabile numerica. Simbolo Descrizione 9 Rappresenta una cifra numerica singola. Rappresenta la separazione tra la parte intera e la parte decimale del numero e di conseguenza pu apparire una sola volta nel modello. Questo simbolo non incrementa la dimensione della variabile, in quanto serve solo a sapere dove si V intende che debba trovarsi la separazione tra la parte intera e quella decimale, ai fini dei calcoli che si possono eseguire. Se questo simbolo appare alla fine del modello, come se non fosse inserito, perch la sua presenza non aggiunge alcuna informazione. Se si utilizza questo simbolo, pu essere collocato soltanto all'estrema sinistra del modello, allo scopo di specificare che il numero provvisto di segno. A seconda del modo in cui l'informazione numerica viene codificata nella S variabile (DISPLAY, COMPUTATIONAL e altre opzioni eventuali), il segno pu occupare una posizione separata oppure no. Il simbolo P pu essere usato soltanto alla sinistra o alla destra del modello e pu apparire ripetuto, tenendo conto che se appare alla sinistra incompatibile con il simbolo V. Questo simbolo non incrementa la dimensione della P variabile, ma serve a far s che il valore contenuto nella variabile sia interpretato in modo differente. L'uso di questo simbolo sconsigliabile, perch altera il comportamento della variabile in un modo che non facile da interpretare correttamente. A titolo di esempio, viene mostrato un piccolo programma con cinque variabili scalari numeriche, aventi modelli diversi, abbinate ognuna a una variabile strutturata. Alle variabili scalari viene assegnato lo stesso valore, in modo da poter confrontare come questo valore viene inteso e rappresentato. Nell'esempio appare anche l'uso del simbolo P a dimostrazione della difficolt che questo comporta nell'interpretare l'esito degli assegnamenti alle variabili. 000100 IDENTIFICATION DIVISION. 000200 PROGRAM-ID. PICTURE-NUMERIC. 000300 AUTHOR. DANIELE GIACOMINI. 000400 DATE-WRITTEN. 2005-02-22. 000500* 000600 ENVIRONMENT DIVISION. 000700* 000800 DATA DIVISION. 000900* 001000 WORKING-STORAGE SECTION. 001100 01 RECORD-A. 001200 02 A PICTURE 99999 USAGE IS DISPLAY.

42

001300 01 RECORD-B. 001400 02 B PICTURE 999V99 USAGE IS DISPLAY. 001500 01 RECORD-C. 001600 02 C PICTURE S999V99 USAGE IS DISPLAY. 001700 01 RECORD-D. 001800 02 D PICTURE 999V99PP USAGE IS DISPLAY. 001900 01 RECORD-E. 002000 02 E PICTURE PP99999 USAGE IS DISPLAY. 002100* 002200 PROCEDURE DIVISION. 002300* 002400 MAIN. 002500 MOVE -1234.5678 TO A. 002600 MOVE -1234.5678 TO B. 002700 MOVE -1234.5678 TO C. 002800 MOVE -1234.5678 TO D. 002900 MOVE -1234.5678 TO E. 003000 DISPLAY "SOURCE VALUE IS -1234.5678". 003100 DISPLAY "PICTURE: 99999 VALUE: ", A, 003200 " DATA: ", RECORD-A. 003300 DISPLAY "PICTURE: 999V99 VALUE: ", B, 003400 " DATA: ", RECORD-B. 003500 DISPLAY "PICTURE: S999V99 VALUE: ", C, 003600 " DATA: ", RECORD-C. 003700 DISPLAY "PICTURE: 999V99PP VALUE: ", D, 003800 " DATA: ", RECORD-D. 003900 DISPLAY "PICTURE: PP99999 VALUE: ", E, 004000 " DATA: ", RECORD-E. 004100 STOP RUN. 004200* Compilando il programma con TinyCOBOL, l'avvio dell'eseguibile che si ottiene genera il risultato seguente: SOURCE VALUE IS -1234.5678 PICTURE: 99999 VALUE: 01234 DATA: 01234 PICTURE: 999V99 VALUE: 234.56 DATA: 23456 PICTURE: S999V99 VALUE: -234.56 DATA: 2345O PICTURE: 999V99PP VALUE: 004.5678 DATA: 45678 PICTURE: PP99999 VALUE: .0078000 DATA: 78000 Facendo la stessa cosa con OpenCOBOL: SOURCE VALUE IS -1234.5678 PICTURE: 99999 VALUE: 01234 DATA: 01234 PICTURE: 999V99 VALUE: 234.56 DATA: 23456 PICTURE: S999V99 VALUE: -234.56 DATA: 2345v PICTURE: 999V99PP VALUE: 004.5678 DATA: 45678 PICTURE: PP99999 VALUE: .0078000 DATA: 78000 Si osservi che nell'esempio le variabili scalari numeriche sono state dichiarate con l'opzione USAGE IS DISPLAY, che comunque sarebbe stata implicita, in modo da assicurare la visibilit del contenuto leggendo il livello 01.

43

9.5 Variabili numeriche modificate Il modello di definizione di una variabile fatta per ricevere un valore numerico, pu contenere simboli che applicano una modifica all'apparenza del valore. Nel momento in cui una variabile del genere riceve un valore, ci che la variabile fornisce un'informazione alfanumerica, che non pu pi essere usata per elaborazioni matematiche; al massimo, una variabile del genere pu ricevere il risultato di un'espressione che generi un valore numerico. Tabella 469.13. Alcuni simboli del modello di definizione di una variabile numerica che descrivono una trasformazione in formato alfanumerico. Simbolo B 0 Z * Descrizione Richiede l'inserimento di uno spazio. Richiede l'inserimento di uno zero. Si usa soltanto nella parte sinistra del modello e richiede di indicare uno spazio al posto di una cifra zero. Si usa soltanto nella parte sinistra del modello e richiede di indicare un asterisco al posto di una cifra zero. In condizioni normali inserisce una virgola letterale. Si osservi che non pu apparire la virgola come simbolo , conclusivo del modello, perch in tal caso assumerebbe il valore di un delimitatore. In condizioni normali rappresenta il punto di separazione tra la parte intera e la parte decimale. Si osservi che in un . modello che prevede la modifica, non si pu usare il simbolo V. Il segno + o il segno - indicano la posizione in cui si vuole appaia il segno del numero; se il segno viene ripetuto, le + occorrenze successive alla prima rappresentano implicitamente la posizione di una cifra numerica, con soppressione degli zeri anteriori. Usando il segno - si dovrebbe ottenere la rappresentazione di un numero senza segno, quando questo ha un valore positivo. Questi simboli, che occupano due caratteri, vengono inseriti tali e quali nella rappresentazione della variabile. Sono CR utili queste sigle per la contabilit dei paesi di lingua inglese (credit, debit); a ogni modo bene ricordare che non DB sono influenzate dal segno del valore numerico che viene ricevuto nella variabile. $ Si usa per mostrare il simbolo del dollaro, quando la valuta prevista nel sorgente del programma quella predefinita. / Se il compilatore lo permette, inserisce una barra obliqua. Teoricamente, ogni altro simbolo che non abbia un significato preciso per la realizzazione dei modelli di definizione delle variabili, dovrebbe essere aggiunto tale e quale; in pratica, molto dipende dalle caratteristiche del compilatore. Come esempio viene mostrato un piccolo programma con alcune variabili scalari numeriche modificate (edited), aventi modelli diversi, abbinate ognuna a una variabile strutturata. Alle variabili scalari viene assegnato lo stesso valore, in modo da poter confrontare come questo valore viene inteso e rappresentato. 000100 IDENTIFICATION DIVISION. 000200 PROGRAM-ID. PICTURE-NUMERIC-EDITED. 000300 AUTHOR. DANIELE GIACOMINI. 000400 DATE-WRITTEN. 2005-02-25. 000500* 000600 ENVIRONMENT DIVISION. 000700* 000800 DATA DIVISION. 000900* 001000 WORKING-STORAGE SECTION. 001100 01 RECORD-A. 001200 02 A PICTURE S9(10)V9(5) USAGE IS DISPLAY. 001300 01 RECORD-B. 001400 02 B PICTURE +Z(9)9.9(5) USAGE IS DISPLAY. 001500 01 RECORD-C. 001600 02 C PICTURE CR+Z(7)9.9(5) USAGE IS DISPLAY. 001700 01 RECORD-D. 001800 02 D PICTURE +Z(7)9.9(5)DB USAGE IS DISPLAY. 001900 01 RECORD-E. 002000 02 E PICTURE *(9)9.9(5)+ USAGE IS DISPLAY.

44

002100 01 RECORD-F. 002200 02 F PICTURE +*(9)9.9(4)$ USAGE IS DISPLAY. 002300 01 RECORD-G. 002400 02 G PICTURE +*(9)9,9(4)$ USAGE IS DISPLAY. 002500 01 RECORD-H. 002600 02 H PICTURE -(10)9,9(4)$ USAGE IS DISPLAY. 002700 01 RECORD-I. 002800 02 I PICTURE +(10)9,9(4)$ USAGE IS DISPLAY. 002900* 003000 PROCEDURE DIVISION. 003100* 003200 MAIN. 003300 MOVE +123456.789 TO A. 003400 MOVE +123456.789 TO B. 003500 MOVE +123456.789 TO C. 003600 MOVE +123456.789 TO D. 003700 MOVE +123456.789 TO E. 003800 MOVE +123456.789 TO F. 003900 MOVE +123456.789 TO G. 004000 MOVE +123456.789 TO H. 004100 MOVE +123456.789 TO I. 004200 DISPLAY "SOURCE VALUE IS: +123456.789". 004300 DISPLAY "PICTURE: S9(10)V9(5) VALUE: ", A, 004400 " DATA: ", RECORD-A. 004500 DISPLAY "PICTURE: +Z(9)9.9(5) VALUE: ", B, 004600 " DATA: ", RECORD-B. 004700 DISPLAY "PICTURE: CR+Z(7)9.9(5) VALUE: ", C, 004800 " DATA: ", RECORD-C. 004900 DISPLAY "PICTURE: +Z(7)9.9(5)DB VALUE: ", D, 005000 " DATA: ", RECORD-D. 005100 DISPLAY "PICTURE: *(9)9.9(5)+ VALUE: ", E, 005200 " DATA: ", RECORD-E. 005300 DISPLAY "PICTURE: +*(9)9.9(4)$ VALUE: ", F, 005400 " DATA: ", RECORD-F. 005500 DISPLAY "PICTURE: +*(9)9,9(4)$ VALUE: ", G, 005600 " DATA: ", RECORD-G. 005700 DISPLAY "PICTURE: -(10)9,9(4)$ VALUE: ", H, 005800 " DATA: ", RECORD-H. 005900 DISPLAY "PICTURE: +(10)9,9(4)$ VALUE: ", I, 006000 " DATA: ", RECORD-I. 006100 STOP RUN. 006200* Compilando il programma con TinyCOBOL, l'avvio dell'eseguibile che si ottiene genera il risultato seguente: SOURCE VALUE IS: +123456.789 PICTURE: S9(10)V9(5) VALUE: 0000123456.78900 DATA: 00001234567890{ PICTURE: +Z(9)9.9(5) VALUE: + 123456.78900 DATA: + 123456.78900 PICTURE: CR+Z(7)9.9(5) VALUE: CR+ 123456.78900 DATA: CR+ 123456.78900 PICTURE: +Z(7)9.9(5)DB VALUE: + 123456.78900DB DATA: + 123456.78900DB PICTURE: *(9)9.9(5)+ VALUE: ****123456.78900+ DATA: ****123456.78900+ PICTURE: +*(9)9.9(4)$ VALUE: +****123456.7890$ DATA: +****123456.7890$

45

PICTURE: +*(9)9,9(4)$ VALUE: +********12,3456$ DATA: +********12,3456$ PICTURE: -(10)9,9(4)$ VALUE: 12,3456$ DATA: 12,3456$ PICTURE: +(10)9,9(4)$ VALUE: +12,3456$ DATA: +12,3456$ Tra i vari risultati, si pu osservare che la virgola stata interpretata come un segno senza un ruolo preciso, pertanto si colloca semplicemente prima delle ultime quattro cifre, secondo la previsione del modello. Intervenendo nella sezione CONFIGURATION SECTION possibile invertire il ruolo del punto e della virgola, nella rappresentazione dei numeri; nello stesso modo, possibile attribuire un simbolo differente per la valuta. L'esempio seguente una variante di quello appena mostrato, con le modifiche necessarie per questo scopo. Si osservi che come simbolo di valuta stata scelta la lettera E. 000100 IDENTIFICATION DIVISION. 000200 PROGRAM-ID. PICTURE-NUMERIC-EDITED-BIS. 000300 AUTHOR. DANIELE GIACOMINI. 000400 DATE-WRITTEN. 2005-02-25. 000500* 000600 ENVIRONMENT DIVISION. 000700 CONFIGURATION SECTION. 000800 SPECIAL-NAMES. DECIMAL-POINT IS COMMA 000900 CURRENCY SIGN IS "E". 001000* 001100 DATA DIVISION. 001200* 001300 WORKING-STORAGE SECTION. 001400 01 RECORD-A. 001500 02 A PICTURE S9(10)V9(5) USAGE IS DISPLAY. 001600 01 RECORD-B. 001700 02 B PICTURE +Z(9)9.9(5) USAGE IS DISPLAY. 001800 01 RECORD-C. 001900 02 C PICTURE CR+Z(7)9.9(5) USAGE IS DISPLAY. 002000 01 RECORD-D. 002100 02 D PICTURE +Z(7)9.9(5)DB USAGE IS DISPLAY. 002200 01 RECORD-E. 002300 02 E PICTURE *(9)9.9(5)+ USAGE IS DISPLAY. 002400 01 RECORD-F. 002500 02 F PICTURE +*(9)9.9(4)E USAGE IS DISPLAY. 002600 01 RECORD-G. 002700 02 G PICTURE +*(9)9,9(4)E USAGE IS DISPLAY. 002800 01 RECORD-H. 002900 02 H PICTURE -(10)9,9(4)E USAGE IS DISPLAY. 003000 01 RECORD-I. 003100 02 I PICTURE +(10)9,9(4)E USAGE IS DISPLAY. 003200* 003300 PROCEDURE DIVISION. 003400* 003500 MAIN. 003600 MOVE +123456,789 TO A. 003700 MOVE +123456,789 TO B. 003800 MOVE +123456,789 TO C. 003900 MOVE +123456,789 TO D. 004000 MOVE +123456,789 TO E.

46

004100 MOVE +123456,789 TO F. 004200 MOVE +123456,789 TO G. 004300 MOVE +123456,789 TO H. 004400 MOVE +123456,789 TO I. 004500 DISPLAY "SOURCE VALUE IS: +123456.789". 004600 DISPLAY "PICTURE: S9(10)V9(5) VALUE: ", A, 004700 " DATA: ", RECORD-A. 004800 DISPLAY "PICTURE: +Z(9)9.9(5) VALUE: ", B, 004900 " DATA: ", RECORD-B. 005000 DISPLAY "PICTURE: CR+Z(7)9.9(5) VALUE: ", C, 005100 " DATA: ", RECORD-C. 005200 DISPLAY "PICTURE: +Z(7)9.9(5)DB VALUE: ", D, 005300 " DATA: ", RECORD-D. 005400 DISPLAY "PICTURE: *(9)9.9(5)+ VALUE: ", E, 005500 " DATA: ", RECORD-E. 005600 DISPLAY "PICTURE: +*(9)9.9(4)E VALUE: ", F, 005700 " DATA: ", RECORD-F. 005800 DISPLAY "PICTURE: +*(9)9,9(4)E VALUE: ", G, 005900 " DATA: ", RECORD-G. 006000 DISPLAY "PICTURE: -(10)9,9(4)E VALUE: ", H, 006100 " DATA: ", RECORD-H. 006200 DISPLAY "PICTURE: +(10)9,9(4)E VALUE: ", I, 006300 " DATA: ", RECORD-I. 006400 STOP RUN. 006500* Compilando il programma con TinyCOBOL, l'avvio dell'eseguibile che si ottiene genera il risultato seguente: SOURCE VALUE IS: +123456.789 PICTURE: S9(10)V9(5) VALUE: 0000123456,78900 DATA: 00001234567890{ PICTURE: +Z(9)9.9(5) VALUE: + 1.23456 DATA: + 1.23456 PICTURE: CR+Z(7)9.9(5) VALUE: CR+ 1.23456 DATA: CR+ 1.23456 PICTURE: +Z(7)9.9(5)DB VALUE: + 1.23456DB DATA: + 1.23456DB PICTURE: *(9)9.9(5)+ VALUE: *********1.23456+ DATA: *********1.23456+ PICTURE: +*(9)9.9(4)E VALUE: +********12.3456E DATA: +********12.3456E PICTURE: +*(9)9,9(4)E VALUE: +****123456,7890E DATA: +****123456,7890E PICTURE: -(10)9,9(4)E VALUE: 123456,7890E DATA: 123456,7890E PICTURE: +(10)9,9(4)E VALUE: +123456,7890E DATA: +123456,7890E Questa volta si pu osservare che nel modello il punto che perde il suo significato, apparendo nel risultato soltanto nella posizione prevista, allineando le cifre numeriche originali alla destra.

47

Capitolo 10.Note sull'utilizzo dell'insieme di caratteri universale con il COBOL

Lo standard COBOL del 1985 prevede sostanzialmente che si possano gestire informazioni alfanumeriche composte di simboli rappresentabili in byte, appartenenti pertanto al codice ASCII o EBCDIC. Con l'introduzione dell'insieme di caratteri universale, si pone il problema di gestire codifiche di tipo diverso, ben pi grandi del solito byte. Purtroppo, per, le soluzioni adottate non sono semplici e lineari come nel passato. 470.1 10.1 Gruppi di istruzioni e istruzioni condizionali Un gruppo di istruzioni si evidenzia per la presenza del punto fermo conclusivo (seguito da uno spazio). Le istruzioni che non costituiscono gruppi singoli possono essere separate, oltre che con lo spazio, con la virgola, il punto e virgola, e con la parola THEN. Le istruzioni condizionali sono quelle che alterano la sequenza normale dell'esecuzione delle istruzioni, sulla base della verifica di una condizione. L'istruzione condizionale tipica IF, ma molte altre istruzioni prevedono delle parole opzionali per descrivere un'azione da compiere al verificarsi di una certa condizione. / \ .-/ \ --. | { statement-1 }... | | | { statement-2 }... | | IF condition-1 < > | ELSE < > | | NEXT SENTENCE | | | NEXT SENTENCE | | \ / `-\ / --' Quello che si vede sopra lo schema sintattico dell'istruzione IF, che incorpora a sua volta altre istruzioni. Naturalmente, le istruzioni incorporate possono contenere altre istruzioni condizionali annidate; in ogni caso, non possibile suddividere una struttura del genere in gruppi di istruzioni pi piccoli, pertanto il punto fermo finale pu apparire solo alla fine della struttura pi esterna. 000000 IF ALTEZZA IS GREATER THAN 190 000000 THEN 000000 DISPLAY "LA PERSONA E` MOLTO ALTA!", 000000 PERFORM PERSONA-MOLTO-ALTA; 000000 ELSE 000000 IF ALTEZZA IS GREATER THAN 170 000000 THEN 000000 DISPLAY "LA PERSONA E` ABBASTANZA ALTA.", 000000 PERFORM PERSONA-ALTA; 000000 ELSE 000000 DISPLAY "LA PERSONA HA UN'ALTEZZA MEDIA O BASSA". L'esempio mostra un'istruzione IF annidata, dove sono stati usati i vari separatori disponibili, per facilitare la lettura: la parola THEN non fa parte dell'istruzione, ma introduce qui le istruzioni da eseguire nel caso la condizione si avveri; la virgola viene usata per terminare le istruzioni singole, mentre il punto e virgola si usa per concludere quelle istruzioni dopo le quali si passa all'alternativa (introdotta dalla parola chiave ELSE). Il punto fermo finale molto importante, perch rappresenta l'unico modo per stabilire dove finisca tutta la struttura, dal momento che nel linguaggio non previsto l'uso di parole come end if. 10.2 Sezioni, paragrafi e qualificazione Quando la parte procedurale del programma si suddivide in sezioni, i nomi dei paragrafi devono essere univoci soltanto nell'ambito della sezione in cui vengono dichiarati. Quando si deve fare riferimento al nome di un paragrafo che non unico nel programma, si deve usare la qualificazione per distinguere a quale sezione si sta facendo riferimento; eccezionalmente, se si tratta della sezione in cui ci si trova gi, la qualificazione implicita. La qualificazione si ottiene aggiungendo la parola OF, oppure IN, seguita dal nome della sezione.

48

/ \ | IN | paragraph-name < > sectionname | OF | \ / 10.3 Espressioni aritmetiche L'espressione aritmetica ci che si traduce in un valore numerico, eventualmente attraverso l'uso di operatori. Gli operatori aritmetici disponibili nel linguaggio COBOL sono molto pochi, limitando le possibilit alle quattro operazioni. importante osservare che gli operatori aritmetici, tranne nel caso delle parentesi, vanno separati dai loro argomenti; diversamente, il segno - verrebbe confuso come carattere che compone una parola. Per esempio, A - B un'espressione che rappresenta una sottrazione, mentre A-B una parola. Tabella 471.12. Espressioni aritmetiche. Espressione +x -x x+y x-y x*y x/y Descrizione Non modifica il segno di x. Inverte il segno di x. Somma i due operandi. Sottrae da x il valore di y. Moltiplica i due operandi. Divide il primo operando per il secondo. Cambia la precedenza stabilendo che quanto contenuto tra parentesi va calcolato prima di ci che si trova ( ... ) all'esterno. L'ordine di precedenza nelle espressioni aritmetiche quello consueto: prima gli operatori unari, che si applicano a un operando singolo, poi la moltiplicazione e la divisione, quindi la somma e la sottrazione. 10.4 Espressioni condizionali Nel linguaggio COBOL si distinguono diversi tipi di espressioni condizionali elementari, che vengono descritte nelle sezioni successive. Le espressioni elementari, a loro volta, si possono combinare in espressioni composte, con l'uso di operatori booleani ed eventualmente con l'aiuto di parentesi tonde per modificare l'ordine di valutazione. 10.4.1 Condizioni di relazione Le condizioni di relazione stabiliscono un confronto tra due valori, che possono essere rappresentati da variabili, costanti o da espressioni aritmetiche. Segue lo schema sintattico: / IS [NOT] GREATER THAN \ | | | IS [NOT] LESS THAN | / identifier-1 \ | | / identifier-2 \ | | | IS [NOT] EQUAL TO | | | < literal-1 > < > < literal-2 > | | | IS [NOT] > | | | \ arith-expression-1 / | | \ arithexpression-2 / | IS [NOT] < | | | \ IS [NOT] = / Tabella 471.14. Significato degli operatori di relazione.

49

Operatore Descrizione IS [NOT] GREATER THEN maggiore di, non maggiore di IS [NOT] > maggiore di, non maggiore di IS [NOT] LESS THEN minore di, non minore di IS [NOT] < minore di, non minore di IS [NOT] EQUAL TO uguale a, diverso da IS [NOT] = uguale a, diverso da IS GREATER THAN OR EQUAL TO maggiore o uguale a -------------IS >= maggiore o uguale a -IS LESS THAN OR EQUAL TO minore o uguale a ----------IS <= minore o uguale a -Quando gli operandi sono entrambi numerici, indipendentemente dal fatto che la loro rappresentazione sia in forma di indice (INDEX), compatta (COMPUTATIONAL) o in forma di byte (DISPLAY), il confronto si basa sul valore numerico che esprimono, tenendo conto del segno, se c', considerando positivi i valori senza segno. Quando si confrontano operandi alfanumerici, o quando anche uno solo di tipo alfanumerico, il confronto avviene in modo lessicografico (in base all'ordinamento previsto dalla codifica adottata). 10.4.2 Condizioni di classe La condizione di classe serve a stabilire se l'operando a cui si applica numerico o alfabetico. numerico un operando che composto soltanto di cifre da 0 a 9, con il segno eventuale; alfabetico un operando composto soltanto dal lettere alfabetiche ed eventualmente da spazi. La condizione di classe si utilizza solo per verificare il contenuto di variabili che sono state dichiarate con una rappresentazione in byte (USAGE IS DISPLAY). Segue lo schema sintattico per esprimere la condizione di classe: / \ | NUMERIC | identifier IS [NOT] < > | ALPHABETIC | \ / Naturalmente, se si usa la parola chiave NOT, si intende invertire il significato della condizione. 10.4.3 Nomi di condizione I nomi di condizione, che si dichiarano nella divisione DATA DIVISION con il numero di livello 88, servono a descrivere il confronto della variabile a cui si riferiscono con i valori che rappresentano. Supponendo di avere dichiarato il nome di condizione PARI nel modo seguente: 000000 02 CODICE PIC 9. 000000 88 PARI 0, 2, 4, 6, 8. 000000 88 DISPARI 1, 3, 5, 7, 9. 000000 88 BASSO 0 THRU

50

4. 000000 88 ALTO 5 THRU 9. Nella divisione PROCEDURE DIVISION potrebbero apparire righe come quelle successive, per verificare che la variabile CODICE contenga un valore pari: 000000 IF PARI 000000 THEN 000000 PERFORM ...; 000000 ELSE 000000 ... 10.4.4 Condizioni composte e negate Attraverso gli operatori booleani comuni, si possono definire delle condizioni composte, oppure negate. Si utilizzano le parole chiave AND, OR e NOT per esprimere gli operatori booleani noti con lo stesso nome. Con l'ausilio delle parentesi tonde si possono modificare le precedenze nella valutazione delle espressioni. Il linguaggio COBOL prevede una forma abbreviata per esprimere delle condizioni di relazione composte. Si osservi l'espressione seguente: A > B OR A > C OR A < D Questa potrebbe essere abbreviata cos: A > B OR > C OR < D Tuttavia, si comprende che l'abbreviazione comporta maggiore difficolt interpretativa nella lettura umana del programma sorgente. 10.5 Avverbi comuni Per avverbi comuni qui si intendono delle parole chiave che possono far parte di varie istruzioni, fornendo per lo stesso tipo di funzionalit. Tabella 471.19. Alcuni avverbi comuni. Avverbio Descrizione Quando una variabile deve ricevere il risultato di un'espressione aritmetica e non ha la possibilit di ROUNDED rappresentare in modo esatto i decimali, con l'uso dell'avverbio ROUNDED si chiede di assegnare un valore arrotondato nella cifra meno significativa. Quando una variabile deve ricevere il risultato di un'espressione aritmetica e non ha la possibilit di rappresentare alcune cifre pi significative, si verifica un errore, che pu essere espresso dalla SIZE ERROR condizione SIZE ERROR. La verifica di questa condizione implica l'indicazione di un'istruzione da eseguire se si verifica questo tipo di errore. Alcune istruzioni prevedono l'uso dell'avverbio CORRESPONDING per fare riferimento a variabili CORRESPONDING strutturate che contengono campi con lo stesso nome, pur non avendo la stessa struttura. Generalmente si usa per assegnare un gruppo di variabili a un altro gruppo, con lo stesso nome, in un'altra struttura.

Capitolo 11.Istruzioni
11.1 Istruzione ACCEPT L'istruzione ACCEPT permette di ricevere un'informazione da una fonte esterna al programma e di assegnarla a una variabile. Generalmente si usa questa istruzione per consentire all'utente l'inserimento di un valore attraverso il terminale che sta utilizzando, ma, a seconda delle possibilit offerte dal compilatore, pu servire anche per l'acquisizione di altri dati. .-/ mnemonic-name \ --.

51

| | | | | | implementor-name | | | | | | ACCEPT identifier | FROM < DATE > | | | | | | | DAY | | | | | | `-\ TIME / --' La fonte di dati per l'istruzione ACCEPT pu essere dichiarata attraverso un nome mnemonico, definito nel paragrafo SPECIAL-NAMES della sezione INPUT-OUTPUT SECTION (sezione 464.3), un nome particolare che dipende da funzionalit speciali del compilatore, oppure un nome che fa riferimento alla data o all'orario attuale (le parole chiave DATE, DAY, TIME). Tabella 472.2. Parole chiave standard per definire l'accesso alle informazioni data-orario. Parola chiave DATE Descrizione

Fornisce la data attuale, formata da sei cifre numeriche, secondo la forma yymmdd (due cifre per l'anno, due per il mese e due per il giorno). Fornisce il giorno attuale, formato da cinque cifre numeriche, secondo la forma yyddd (due cifre per l'anno e tre DAY cifre per il giorno, espresso in quantit di giorni trascorsi dall'inizio dell'anno). Fornisce l'orario attuale, formato da otto cifre numeriche, secondo la forma hhmmsscc (due cifre per l'ora, due per i TIME minuti, due per i secondi e due per i centesimi di secondo). L'esempio seguente dimostra il funzionamento e l'utilizzo di queste parole chiave standard: 000100 IDENTIFICATION DIVISION. 000200 PROGRAM-ID. TEST-ACCEPT-DATETIME. 000300 AUTHOR. DANIELE GIACOMINI. 000400 DATE-WRITTEN. 2005-02-27. 000500* 000600 ENVIRONMENT DIVISION. 000700* 000800 DATA DIVISION. 000900* 001000 WORKING-STORAGE SECTION. 001100 77 MY-DATE PIC X(30). 001200 77 MY-DAY PIC X(30). 001300 77 MY-TIME PIC X(30). 001400* 001500 PROCEDURE DIVISION. 001600* 001700 MAIN. 001800 ACCEPT MY-DATE FROM DATE. 001900 ACCEPT MY-DAY FROM DAY. 002000 ACCEPT MY-TIME FROM TIME. 002100 DISPLAY "DATE: ", MY-DATE. 002200 DISPLAY "DAY: ", MY-DAY. 002300 DISPLAY "TIME: ", MY-TIME. 002400* 002500 STOP RUN. 002600* Avviando questo programma il giorno 27 gennaio 2005, alle ore 13:30.45, si dovrebbe ottenere il risultato seguente: DATE: 050227 DAY: 05058 TIME: 13304500 Tabella 472.5. Parole chiave non standard.

52

Parola chiave

Descrizione Quando non si specifica la fonte dei dati per l'istruzione ACCEPT, si intende il terminale dal quale il CONSOLE programma stato avviato; spesso, i compilatori considerano l'uso della parola chiave CONSOLE, o di SYSIN SYSIN, come sinonimo di questo comportamento, anche se quello predefinito. COMMAND- I compilatori per i sistemi Unix consentono spesso di accedere al contenuto della riga di comando usata per LINE avviare il programma, attraverso l'uso di questa parola chiave. L'esempio successivo dimostra l'uso di un nome mnemonico per dichiarare l'origine dei dati. Sono evidenziate le righe pi significative: 000100 IDENTIFICATION DIVISION. 000200 PROGRAM-ID. TEST-ACCEPT. 000300 AUTHOR. DANIELE GIACOMINI. 000400 DATE-WRITTEN. 2005-02-27. 000500* 000600 ENVIRONMENT DIVISION. 000700 CONFIGURATION SECTION. 000800 SOURCE-COMPUTER. 000900 OPENCOBOL. 001000 SPECIAL-NAMES. 001100 CONSOLE IS STANDARD-INPUT. 001200* 001300 DATA DIVISION. 001400* 001500 WORKING-STORAGE SECTION. 001600 77 MESSAGGIO PIC X(30). 001700* 001800 PROCEDURE DIVISION. 001900* 002000 MAIN. 002100 DISPLAY "INSERISCI IL MESSAGGIO". 002200 ACCEPT MESSAGGIO FROM STANDARDINPUT. 002300 DISPLAY "HAI INSERITO: ", MESSAGGIO. 002400* 002500 STOP RUN. 002600* 11.2 Istruzione ADD L'istruzione ADD consente di eseguire delle somme. Sono previsti diversi formati per l'utilizzo di questa istruzione. / \ | identifier-1 | ADD < >... TO { identifier-n [ROUNDED] }... | literal-1 | \ / [ ON SIZE ERROR imperative-statement ] Nello schema sintattico appena mostrato, si vede che dopo la parola chiave ADD si elencano una serie di costanti o variabili con valore numerico, da sommare assieme, sommando poi quanto ottenuto al contenuto delle variabili specificate dopo la parola chiave TO. L'opzione ROUNDED richiede di eseguire un arrotondamento se la variabile ricevente non pu rappresentare in modo esatto il valore; l'opzione SIZE ERROR serve a eseguire un'istruzione nel caso una delle variabili riceventi non possa accogliere la porzione pi significativa del valore ottenuto dalla somma. Si osservi l'esempio seguente: 000000 ADD 1, 2, 3, TO A. Supponendo che la variabile A, prima della somma contenga il valore 10, dopo la somma contiene il valore 16 (1+2+3+10).

53

/ \ / \ | identifier-1 | | identifier-2 | ADD < > < >... | literal-1 | | literal-2 | \ / \ / GIVING { identifier-n [ROUNDED] }... [ ON SIZE ERROR imperativestatement ] Quando al posto della parola chiave TO, si usa GIVING, la somma dei valori che precede tale parola chiave viene assegnata alle variabili indicate dopo, senza tenere in considerazione il loro valore iniziale nella somma. Valgono le stesse considerazioni gi fatte a proposito delle opzioni ROUNDED e SIZE ERROR. Si osservi l'esempio seguente: 000000 ADD 1, 2, 3, GIVING A. Qualunque sia il valore iniziale della variabile A, dopo la somma questa contiene il valore 6 (1+2+3). / \ | CORR | ADD < > identifier-1 TO identifier-2 [ROUNDED] | CORRESPONDING | \ / [ ON SIZE ERROR imperative-statement ] In questo ultimo caso, la somma fa riferimento a variabili strutturate, dove i campi della prima variabile devono essere sommati ai campi della seconda variabile che hanno lo stesso nome della prima. Valgono le stesse considerazioni gi fatte a proposito delle opzioni ROUNDED e SIZE ERROR. 11.3 Istruzione CLOSE Attraverso l'istruzione CLOSE si pu chiudere un file aperto. / .-/ \ --. \ |CLOSE < file-name-1 \ `-\ / --' / 11.4 Istruzione COMPUTE L'istruzione COMPUTE consente di calcolare un'espressione aritmetica, assegnando il risultato a una o pi variabili: COMPUTE { identifier [ROUNDED] }... = arithmeticexpression [ ON SIZE ERROR imperative-statement ] La variabile che nello schema sintattico appare con il nome identifier deve essere scalare e di tipo numerico, anche se pu contenere una maschera di modifica. Possono essere indicate pi variabili a sinistra del segno = e ognuna riceve una copia del risultato dell'espressione alla destra. L'opzione ROUNDED serve a richiedere un arrotondamento se la variabile ricevente non pu rappresentare il risultato con la stessa precisione ottenuta dal calcolo dell'espressione; l'opzione SIZE ERROR consente di richiamare un'istruzione nel caso una delle variabili riceventi non fosse in grado di contenere la parte pi significativa del valore ottenuto calcolando l'espressione. 000000 COMPUTE D = A * B + C.

54

L'esempio mostra che si vuole assegnare alla variabile D il risultato dell'espressione A * B + C (A moltiplicato B, sommato a C). 472.5 11.5 Istruzione DISPLAY L'istruzione DISPLAY consente di emettere un messaggio attraverso un dispositivo che consenta di farlo. Generalmente, se usata senza opzioni, la visualizzazione avviene attraverso il terminale dal quale stato avviato il programma. / \ .-/ \ --. | literal | | | implementor-name | | DISPLAY < >... | UPON < > | | identifier | | | mnemonic-name | | \ / `-\ / --' Osservando lo schema sintattico si vede che dopo la parola chiave DISPLAY si possono mettere delle costanti letterali o dei nomi di variabile. Questi elementi possono rappresentare sia valori alfanumerici, sia numerici (tuttavia, il compilatore potrebbe rifiutarsi di accettare delle variabili di tipo INDEX): il compilatore che provvede a eseguire le conversioni necessarie. L'elenco di costanti o di variabili viene concatenato prima della visualizzazione. L'aggiunta dell'opzione UPON consente di specificare dove deve essere emesso il messaggio. Si pu indicare una parola chiave definita dal compilatore, che identifica qualche tipo di dispositivo, oppure un nome mnemonico, da specificare nel paragrafo SPECIAL-NAMES della sezione INPUT-OUTPUT SECTION (sezione 464.3). Tabella 472.17. Parole chiave non standard. Parola chiave Descrizione Quando non si specifica la fonte dei dati per l'istruzione ACCEPT, si intende il terminale dal quale il CONSOLE programma stato avviato; spesso, i compilatori considerano l'uso della parola chiave CONSOLE, o di SYSOUT SYSOUT, come sinonimo di questo comportamento, anche se quello predefinito. L'esempio successivo mostra un uso abbastanza comune dell'istruzione DISPLAY: 000000 DISPLAY "ATTENZIONE: ", A, " + ", B, " = ", C. L'esempio mostra in particolare il concatenamento che si vuole ottenere. Si ricorda che non importante se le variabili utilizzate nell'istruzione sono alfanumeriche o numeriche, perch il compilatore che provvede a convertire tutto nel modo pi appropriato al tipo di dispositivo che deve emettere il messaggio. 11.6 Istruzione DIVIDE L'istruzione DIVIDE consente di eseguire delle divisioni, fornendone il risultato ed eventualmente il resto. Sono previsti diversi formati per l'utilizzo di questa istruzione. / \ | identifier-1 | DIVIDE < > INTO { identifier-2 [ROUNDED] }... | literal-1 | \ / [ ON SIZE ERROR imperative-statement ] Nello schema sintattico appena mostrato, si vede che dopo la parola chiave DIVIDE viene indicato un valore, in forma costante o attraverso una variabile; questo valore viene diviso per la variabile indicata dopo la parola chiave INTO e il risultato viene assegnato alla stessa variabile che funge da divisore. Se appaiono pi variabili dopo la parola INTO, la divisione viene ripetuta per ognuna di quelle, assegnando rispettivamente il risultato.

55

L'opzione ROUNDED richiede di eseguire un arrotondamento se la variabile ricevente non pu rappresentare in modo esatto il valore; l'opzione SIZE ERROR serve a eseguire un'istruzione nel caso una delle variabili riceventi non possa accogliere la porzione pi significativa del valore ottenuto dalla somma. Si osservi l'esempio seguente: 000000 DIVIDE 100 INTO A. Supponendo che la variabile A, prima della divisione contenga il valore 5, dopo l'operazione contiene il valore 20 (100/5). Si potrebbe scrivere la stessa cosa utilizzando l'istruzione COMPUTE: 000000 COMPUTE A = 100 / A. Lo schema sintattico successivo mostra l'utilizzo di DIVIDE in modo da non alterare i valori utilizzati come divisori: / \ / \ / \ | identifier-1 | | INTO | | identifier2| DIVIDE < > < > < > | literal-1 | | BY | | literal-2 | \ / \ / \ / GIVING identifier-3 [ROUNDED] [ REMAINDER identifier-4 [ROUNDED] ] [ ON SIZE ERROR imperativestatement ] Nella forma appena mostrata, dove le parole INTO e BY sono equivalenti, la divisione avviene immettendo il risultato dell'operazione nella variabile indicata dopo la parola GIVING. Valgono le stesse considerazioni gi fatte a proposito delle opzioni ROUNDED e SIZE ERROR. Si osservi l'esempio seguente che ripete sostanzialmente l'esempio gi mostrato in precedenza: 000000 DIVIDE 100 BY 5 GIVING A. Utilizzando l'opzione REMAINDER, si fa in modo che il resto della divisione venga inserito nella variabile che segue tale parola. Tuttavia, si osservi che per resto si intende ci che rimane moltiplicando il quoziente ottenuto (identifier-3) per il divisore (identifier-2 o literal-2), sottraendo poi questo valore ottenuto dal dividendo (identifier-1 o literal-1). Si osservi l'esempio che segue: 000100 IDENTIFICATION DIVISION. 000200 PROGRAM-ID. TEST-DIVIDE. 000300 AUTHOR. DANIELE GIACOMINI. 000400 DATE-WRITTEN. 2005-02-27. 000500* 000600 ENVIRONMENT DIVISION. 000700* 000800 DATA DIVISION. 000900* 001000 WORKING-STORAGE SECTION. 001100 77 A PIC 9(10)V99. 001200 77 B PIC 9(10)V99. 001400* 001500 PROCEDURE DIVISION. 001600* 001700 MAIN. 001800 DIVIDE 100 BY 3 GIVING A REMAINDER B. 001900 DISPLAY "100 / 3 = ", A, " CON IL RESTO DI ", B. 002000* 002100 STOP RUN.

56

002200* Una volta compilato questo programma, se viene messo in funzione si dovrebbe ottenere il risultato seguente, che dovrebbe chiarire di che tipo di resto si parla con questa istruzione: 100 / 3 = 0000000033.33 CON IL RESTO DI 0000000000.01

11.7 Istruzione IF L'istruzione IF consente di eseguire un gruppo di istruzioni solo se si verifica una condizione, o se questa non si verifica. Il formato di questa istruzione visibile nello schema seguente: / \ .-/ \ --. | { statement-1 }... | | | { statement-2 }... | | IF condition < > | ELSE < > | | NEXT SENTENCE | | | NEXT SENTENCE | | \ / `-\ / --' Le istruzioni che seguono immediatamente la condizione (statement-1), vengono eseguite se la condizione si avvera; le istruzioni del gruppo che segue la parola ELSE vengono eseguite se la condizione non si avvera. Le istruzioni del primo e del secondo gruppo, possono contenere altre istruzioni IF. Si osservi che la parola THEN un separatore, ma viene usata spesso per migliorare la lettura di un'istruzione IF: 000000 IF ALTEZZA IS GREATER THAN 190 000000 THEN 000000 DISPLAY "LA PERSONA E` MOLTO ALTA!", 000000 PERFORM PERSONA-MOLTO-ALTA; 000000 ELSE 000000 IF ALTEZZA IS GREATER THAN 170 000000 THEN 000000 DISPLAY "LA PERSONA E` ABBASTANZA ALTA.", 000000 PERFORM PERSONA-ALTA; 000000 ELSE 000000 DISPLAY "LA PERSONA HA UN'ALTEZZA MEDIA O BASSA". L'esempio mostra un'istruzione IF che ne contiene un'altra dopo la parola ELSE. Si pu osservare che il punto fermo che conclude il gruppo di istruzioni appare solo alla fine della prima istruzione IF e costituisce l'unico modo per poter comprendere dove finisce tutta la struttura. Si osservi che la rappresentazione della struttura con dei rientri appropriati serve per individuare facilmente i livelli di annidamento esistenti. Data la particolarit di questo esempio, i rientri potrebbero essere gestiti in modo diverso, per sottolineare la presenza di una serie di condizioni alternative (ELSE IF): 000000 IF ALTEZZA IS GREATER THAN 190 000000 THEN 000000 DISPLAY "LA PERSONA E` MOLTO ALTA!", 000000 PERFORM PERSONA-MOLTO-ALTA; 000000 ELSE IF ALTEZZA IS GREATER THAN 170 000000 THEN 000000 DISPLAY "LA PERSONA E` ABBASTANZA ALTA.", 000000 PERFORM PERSONA-ALTA; 000000 ELSE 000000 DISPLAY "LA PERSONA HA UN'ALTEZZA MEDIA O BASSA". 11.8 Istruzione INSPECT L'istruzione INSPECT consente di scandire una variabile contenente una stringa alfanumerica, allo scopo di contare alcuni caratteri o di rimpiazzare alcuni dei caratteri della stringa. Sono previsti tre

57

schemi sintattici per l'uso di questa istruzione, per il conteggio, la sostituzione, oppure per entrambe le cose simultaneamente. Conteggio dei caratteri INSPECT identifier-1 TALLYING / / .-- / \ / \ --. \ \ | | | | BEFORE | | identifier-4 | | | | | | CHARACTERS | < > INITIAL < > | | | | | | | AFTER | | literal-2 | | | | | | `-- \ / \ / --' | | < identifier-2 FOR < >... >... | | / \ / \ .-- / \ / \ --. | | | | | ALL | | identifier-3 | | | BEFORE | | identifier-4 | | | | | | < > < > | < > INITIAL < > | | | | | | LEADING | | literal-1 | | | AFTER | | literal-2 | | | | \ \ \ / \ / `-- \ / \ / --' / / Sostituzione di caratteri INSPECT identifier-1 REPLACING / / \ .-- / \ / \ --. \ | | identifier-5 | | | BEFORE | | identifier-4 | | | | CHARACTERS BY < > | < > INITIAL < > | | | | literal-3 | | | AFTER | | literal-2 | | | | \ / `-- \ / \ / --' | < > | / ALL \ / \ / \ .-- / \ / \ --. | | | | | identifier-3 | | identifier-5 | | | BEFORE | | identifier-4 | | | | < LEADING > < > BY < > | < > INITIAL < > | | | | | | literal-1 | | literal-3 | | | AFTER | | literal-2 | | | \ \ FIRST / \ / \ / `-- \ / \ / --' / Conteggio e sostituzione INSPECT identifier-1 TALLYING / / .-- / \ / \ --. \ \ | | | | BEFORE | | identifier-4 | | | | | | CHARACTERS | < > INITIAL < > | | | | | | | AFTER | | literal-2 | | | | | | `-- \ / \ / --' | | < identifier-2 FOR < >... >... | | / \ / \ .-- / \ / \ --. | | | | | ALL | | identifier-3 | | | BEFORE | | identifier-4 | | | | | | < > < > | < > INITIAL < >

58

| | | | | | \ REPLACING / |

| | LEADING | | literal-1 \ \ / \

| | | AFTER | \

| literal-2 / --' /

| | /

/ `-- \ /

/ \ .-- / \ / | identifier-5 | | | BEFORE |

\ --. \ | identifier-4 | |

| CHARACTERS BY < > | < > INITIAL < > | | | | literal-3 | | | AFTER | | literal-2 | | | | \ / `-- \ / \ / --' | < > | / ALL \ / \ / \ .-- / \ / \ --. | | | | | identifier-3 | | identifier-5 | | | BEFORE | | identifier-4 | | | | < LEADING > < > BY < > | < > INITIAL < > | | | | | | literal-1 | | literal-3 | | | AFTER | | literal-2 | | | \ \ FIRST / \ / \ / `-- \ / \ / --' / In tutti gli schemi sintattici, la variabile indicata dopo la parola INSPECT, che viene annotata come identifier-1, deve contenere una stringa di caratteri, da scandire. L'opzione BEFORE o AFTER, permette di individuare una posizione nella stringa, da prendere come limite finale, o come punto iniziale, per l'elaborazione. In pratica, la variabile identifier-4, o la costante letterale literal-2, serve a rappresentare una sottostringa (anche un solo carattere), che all'interno della stringa complessiva si trova per prima (a partire da sinistra); se si usa la parola BEFORE, l'elaborazione deve avvenire nella parta iniziale della stringa, fino a quella sottostringa di riferimento esclusa; se si usa la parola AFTER, l'elaborazione deve avvenire nella parta finale della stringa, subito dopo quella sottostringa. Naturalmente, se la sottostringa indicata non esiste nella stringa, come se l'opzione BEFORE o AFTER non fosse stata aggiunta. Con il primo schema sintattico, si vogliono contare i caratteri della stringa che soddisfano certe condizioni. Il conteggio viene eseguito incrementando il valore contenuto nella variabile indicata nello schema come identifier-2, che deve essere numerica. Si osservi che la variabile non viene azzerata automaticamente, pertanto il suo valore iniziale viene sommato al conteggio eseguito. Il conteggio pu riguardare tutti i caratteri della stringa o della porzione iniziale o finale selezionata, utilizzando la parola CHARACTERS. Si osservi l'esempio successivo che utilizza solo questo tipo di conteggio. Listato 472.36. Programma elementare che scandisce una stringa e conta i caratteri contenuti. 000100 IDENTIFICATION DIVISION. 000200 PROGRAM-ID. TEST-INSPECT-TALLYING-1. 000300 AUTHOR. DANIELE GIACOMINI. 000400 INSTALLATION. NANOLINUX IV, 000500 OPENCOBOL 0.31, 000600 DATE-WRITTEN. 2005-03-15. 000700* 000800 ENVIRONMENT DIVISION. 000900* 001000 DATA DIVISION. 001100* 001200 WORKING-STORAGE SECTION. 001300 77 STRINGA-DI-CARATTERI PIC X(30). 001400 77 CONTATORE-1 PIC 99 VALUE IS 0. 001500 77 CONTATORE-2 PIC 99 VALUE IS 0. 001600 77 CONTATORE-3 PIC 99 VALUE IS 0.

59

001700* 001800 PROCEDURE DIVISION. 001900*------------------------- LIVELLO 0 ----------------------------002000 MAIN. 002100 MOVE "ABCDEFGHIJKLMNOPQRSTUVWXYZ0123" 002200 TO STRINGA-DI-CARATTERI. 002300 INSPECT STRINGA-DI-CARATTERI 002400 TALLYING CONTATORE-1 002500 FOR CHARACTERS, 002600 TALLYING CONTATORE-2 002700 FOR CHARACTERS BEFORE INITIAL "H", 002800 TALLYING CONTATORE-3 002900 FOR CHARACTERS AFTER INITIAL "H". 003000 DISPLAY "CONTATORI: ", CONTATORE-1, " ", CONTATORE-2, " ", 003100 CONTATORE-3. 003200 STOP RUN. L'esempio appena mostrato utilizza un'istruzione INSPECT per contare tre cose in una stringa, con una sola scansione: i caratteri contenuti in tutta la stringa; i caratteri fino alla comparsa della prima lettera H; i caratteri che si trovano dopo la lettera H: 30 caratteri <----------------------------> ABCDEFGHIJKLMNOPQRSTUVWXYZ0123 <-----> <--------------------> 7 caratteri 22 caratteri Compilando l'esempio e avviando il programma eseguibile che si ottiene, si dovrebbe vedere il risultato seguente: CONTATORI: 30 07 22 Con la parola ALL si intendono contare tutte le corrispondenze con una certa sottostringa (identifier3 o literal-1), contenuta nella stringa complessiva o nella porzione specificata successivamente. Con la parola LEADING, si vogliono contare solo le corrispondenze che avvengono in modo contiguo, purch inizino dal principio della zona di interesse. Listato 472.39. Programma elementare che scandisce una stringa e conta i caratteri che corrispondono a delle sottostringhe. 000100 IDENTIFICATION DIVISION. 000200 PROGRAM-ID. TEST-INSPECT-TALLYING-2. 000300 AUTHOR. DANIELE GIACOMINI. 000400 INSTALLATION. NANOLINUX IV, 000500 OPENCOBOL 0.31, 000600 DATE-WRITTEN. 2005-03-15. 000700* 000800 ENVIRONMENT DIVISION. 000900* 001000 DATA DIVISION. 001100* 001200 WORKING-STORAGE SECTION. 001300 77 STRINGA-DI-CARATTERI PIC X(30). 001400 77 CONTATORE-1 PIC 99 VALUE IS 0. 001500 77 CONTATORE-2 PIC 99 VALUE IS 0. 001600 77 CONTATORE-3 PIC 99 VALUE IS 0. 001700* 001800 PROCEDURE DIVISION. 001900*------------------------- LIVELLO 0 ----------------------------002000 MAIN. 002100 MOVE "ABCDEFGHIAAAABBBBCCCCDDDDEEEEF" 002200 TO STRINGA-DI-CARATTERI. 002300 INSPECT STRINGA-DI-CARATTERI 002400 TALLYING CONTATORE-1

60

002500 FOR ALL "E", 002600 TALLYING CONTATORE-2 002700 FOR LEADING "A" AFTER INITIAL "I", 002800 TALLYING CONTATORE-3 002900 FOR LEADING "B" BEFORE INITIAL "I". 003000 DISPLAY "CONTATORI: ", CONTATORE-1, " ", CONTATORE-2, " ", 003100 CONTATORE-3. 003200 STOP RUN. In questo esempio viene cercata la corrispondenza con tutte le lettere E; le lettere A adiacenti che iniziano a partire dalla prima apparizione della lettera I; le lettere B adiacenti e iniziali, che si trovano prima di quella stessa lettera I. 5 lettere E ------------------------| |||| ABCDEFGHIAAAABBBBCCCCDDDDEEEEF |\\\\ | 4 lettere A adiacenti e iniziali | lettera I di riferimento Non ci sono lettere B adiacenti e iniziali prima del riferimento. Compilando l'esempio e avviando il programma eseguibile che si ottiene, si dovrebbe vedere il risultato seguente: CONTATORI: 05 04 00 Il secondo schema sintattico mostra l'uso di INSPECT per rimpiazzare delle sottostringhe. L'interpretazione dello schema simile a quella del conteggio, con la differenza che si aggiunge la parola chiave BY, che ha alla sinistra la sottostringa da rimpiazzare e alla destra il suo nuovo valore. Quando si usa la parola CHARACTERS, si intende rimpiazzare tutta la stringa (o tutta la porzione prima o dopo un certo riferimento), con qualcosa con un carattere; le parole ALL e LEADING funzionano sostanzialmente come nel conteggio, riferendosi a tutte le sottostringhe di un certo tipo o a tutte le sottostringhe iniziali e adiacenti, dello stesso tipo. In questo schema, si aggiunge la parola FIRST, che identifica solo una prima corrispondenza, non ripetuta. Listato 472.42. Programma che scandisce una stringa e sostituisce alcuni suoi contenuti. Il programma sfrutta un'estensione al linguaggio standard, che permette di eseguire pi sostituzioni in una sola istruzione INSPECT. 000100 IDENTIFICATION DIVISION. 000200 PROGRAM-ID. TEST-INSPECT-REPLACING. 000300 AUTHOR. DANIELE GIACOMINI. 000400 INSTALLATION. NANOLINUX IV, 000500 OPENCOBOL 0.31, 000600 DATE-WRITTEN. 2005-03-15. 000700* 000800 ENVIRONMENT DIVISION. 000900* 001000 DATA DIVISION. 001100* 001200 WORKING-STORAGE SECTION. 001300 77 STRINGA-DI-CARATTERI PIC X(30). 001400* 001500 PROCEDURE DIVISION. 001600*------------------------- LIVELLO 0 ----------------------------001700 MAIN. 001800 MOVE "AAAAAABBBBBBCCCCCCDDDDDDEEEEEE" 001900 TO STRINGA-DI-CARATTERI. 002000 INSPECT STRINGA-DI-CARATTERI

61

REPLACING 002100 CHARACTERS BY "X" AFTER INITIAL "DDD", 002200 LEADING "BB" BY "YZ" AFTER INITIAL "AAAAAA", 002300 FIRST "C" BY "W", 002400 ALL "C" BY "P". 002500 DISPLAY STRINGA-DI-CARATTERI. 002600 STOP RUN. L'esempio appena mostrato sfrutta un'estensione al linguaggio tradizionale, in modo da ottenere pi sostituzioni con una sola passata. L'esempio fatto in questo modo permette di capire cosa succede in queste situazioni particolari. AAAAAABBBBBBCCCCCCDDDDDDEEEEEE XXXXXXXXX CHARACTERS BY "X" AFTER INITIAL "DDD" YZYZYZ LEADING "BB" BY "YZ" AFTER INITIAL "AAAAAA" W FIRST "C" BY "W" PPPPP ALL "C" BY "P" AAAAAAYZYZYZWPPPPPDDDXXXXXXXXX Compilando l'esempio e avviando il programma eseguibile che si ottiene, si dovrebbe vedere il risultato seguente che rappresenta soltanto il contenuto finale della variabile elaborata: AAAAAAYZYZYZWPPPPPDDDXXXXXXXXX

11.9 Istruzione MOVE L'istruzione MOVE copia o assegna un valore in una o pi variabili di destinazione. Sono disponibili due modi di usare questa istruzione: / \ | identifier-1 | MOVE < > TO { identifier-2 }... | literal-1 | \ / Oppure: / \ | CORRESPONDING | MOVE < > identifier-1 TO { identifier-2 }... | CORR | \ / Nel primo caso, ci che appare dopo la parola chiave MOVE pu essere il nome di una variabile, oppure una costante. Il valore contenuto nella variabile o rappresentato dalla costante, viene copiato in tutte le variabili indicate dopo la parola TO, rispettando eventualmente le regole di modifica stabilite dai modelli di definizione delle variabili. Nel secondo caso, avendo aggiunto la parola CORRESPONDING (o soltanto CORR), si copia il contenuto di una variabile strutturata in una o pi variabili strutturate, abbinando per i campi aventi lo stesso nome. In pratica, con il secondo schema si vogliono copiare i campi della prima variabile strutturata che hanno gli stessi nomi di quelli contenuti nella seconda variabile strutturata. Diversamente, per una copia di una variabile strutturata in altre variabili, mantenendo inalterata la struttura originale dei dati, si usa il primo schema sintattico. bene ricordare che in alcuni casi la copia dei dati non pu essere eseguita; per esempio non si pu assegnare a una variabile numerica un'informazione alfanumerica (tenendo conto che una variabile numerica che contiene delle regole di modifica, all'atto della sua lettura offre un'informazione alfanumerica).

62

000100 IDENTIFICATION DIVISION. 000200 PROGRAM-ID. TEST-MOVE. 000300 AUTHOR. DANIELE GIACOMINI. 000400 DATE-WRITTEN. 2005-02-28. 000500 000600 ENVIRONMENT DIVISION. 000700 000800 DATA DIVISION. 000900 001000 WORKING-STORAGE SECTION. 001100 01 RECORD-1. 001200 02 A PIC 999V99. 001300 02 B PIC X(10). 001400 02 C PIC 99999. 001500 001600 01 RECORD-2. 001700 02 C PIC 9999999. 001800 02 B PIC X(12). 001900 02 A PIC 9999V999. 002000 002100 PROCEDURE DIVISION. 002200 002300 MAIN. 002400 MOVE 123.45 TO A OF RECORD-1. 002500 MOVE "ABCDEFGHIJ" TO B OF RECORD-1. 002600 MOVE 12345 TO C OF RECORD-1. 002700 DISPLAY "RECORD-1: ", RECORD-1. 002800 DISPLAY " A: ", A OF RECORD-1. 002900 DISPLAY " B: ", B OF RECORD-1. 003000 DISPLAY " C: ", C OF RECORD-1. 003100 003200 MOVE RECORD-1 TO RECORD-2. 003300 DISPLAY "RECORD-2: ", RECORD-2 003400 DISPLAY " A: ", A OF RECORD-2. 003500 DISPLAY " B: ", B OF RECORD-2. 003600 DISPLAY " C: ", C OF RECORD-2. 003700 003800 MOVE CORRESPONDING RECORD-1 TO RECORD2. 003900 DISPLAY "RECORD-2: ", RECORD-2 004000 DISPLAY " A: ", A OF RECORD-2. 004100 DISPLAY " B: ", B OF RECORD-2. 004200 DISPLAY " C: ", C OF RECORD-2. 004300 004400 STOP RUN. L'esempio mostra un programma in cui ci sono due variabili strutturate, contenenti campi, simili, con lo stesso nome, ordinati in modo differente. Dopo aver assegnato dei valori ai campi della prima variabile, il contenuto della variabile viene copiato nella seconda; successivamente, viene ripetuta la copia in modo corrispondente. Se si compila il programma con OpenCOBOL e si avvia ci che si ottiene, si dovrebbe vedere un risultato simile a quello seguente, dove si pu notare la differenza tra un tipo di copia e l'altra: RECORD-1: 12345ABCDEFGHIJ12345 A: 123.45 B: ABCDEFGHIJ C: 12345 RECORD-2: 12345ABCDEFGHIJ12345 A: 5 .000 B: CDEFGHIJ1234 C: 12345A RECORD-2: 0012345ABCDEFGHIJ 0123450

63

A: 0123.450 B: ABCDEFGHIJ C: 0012345 Si osservi che una variabile di tipo INDEX non pu essere usata con l'istruzione MOVE. Per assegnare un valore a una tale variabile occorre servirsi dell'istruzione SET. 11.10 Istruzione MULTIPLY L'istruzione MULTIPLY consente di eseguire delle moltiplicazioni. Sono previsti due diversi formati per l'utilizzo di questa istruzione. / \ | identifier-1 | MULTIPLY < > BY { identifier-2 [ROUNDED] }... | literal-1 | \ / [ ON SIZE ERROR imperative-statement ] Nello schema sintattico appena mostrato, si vede che dopo la parola chiave MULTIPLY viene indicato un valore, in forma costante o attraverso una variabile; questo valore viene moltiplicato per la variabile indicata dopo la parola chiave BY e il risultato viene assegnato alla stessa variabile che funge da moltiplicatore. Se appaiono pi variabili dopo la parola BY, la moltiplicazione viene ripetuta per ognuna di quelle, assegnando rispettivamente il risultato. L'opzione ROUNDED richiede di eseguire un arrotondamento se la variabile ricevente non pu rappresentare in modo esatto il valore; l'opzione SIZE ERROR serve a eseguire un'istruzione nel caso una delle variabili riceventi non possa accogliere la porzione pi significativa del valore ottenuto dalla somma. Si osservi l'esempio seguente: 000000 MULTIPLY 100 BY A. Supponendo che la variabile A, prima della divisione contenga il valore 5, dopo l'operazione contiene il valore 500 (1005). Si potrebbe scrivere la stessa cosa utilizzando l'istruzione COMPUTE: 000000 COMPUTE A = 100 * A. Lo schema sintattico successivo mostra l'utilizzo di MULTIPLY in modo da non alterare i valori utilizzati come moltiplicatori: / \ / \ | identifier-1 | | identifier-2 | MULTIPLY < > BY < > | literal-1 | | literal-2 | \ / \ / GIVING identifier-3 [ROUNDED] [ ON SIZE ERROR imperativestatement ] Nella forma appena mostrata, la moltiplicazione avviene immettendo il risultato dell'operazione nella variabile indicata dopo la parola GIVING. Valgono le stesse considerazioni gi fatte a proposito delle opzioni ROUNDED e SIZE ERROR. Si osservi l'esempio seguente che ripete sostanzialmente l'esempio gi mostrato in precedenza: 000000 MULTIPLY 100 BY 5 GIVING A. 11.11 Istruzione OPEN L'istruzione OPEN serve ad aprire un file, o un gruppo di file, specificando la modalit di accesso. Quando l'accesso a un file richiede l'esecuzione di alcune procedure meccaniche preliminari, questa

64

istruzione serve a eseguirle. L'istruzione OPEN non riguarda i file dichiarati esplicitamente per il riordino e la fusione. / INPUT { file-name \ | | | OUTPUT { file-name... | OPEN < >... | I-O { file-name }... | | | \ EXTEND { file-name }... / Dopo la parola chiave OPEN inizia l'elenco dei file che si vogliono aprire, cominciando con la parola chiave che definisce la modalit di accesso desiderata: INPUT richiede un accesso in lettura; OUTPUT un accesso in scrittura; L'apertura in lettura che si ottiene con la parola chiave READ serve ad accedere a un file esistente in modo da poter leggere il suo contenuto; l'apertura fa s che la posizione relativa, iniziale, all'interno del file, corrisponda al primo record logico. Se il file non esiste, si presenta una condizione di errore. L'apertura in scrittura che si ottiene con la parola chiave OUTPUT serve a creare un file, ma se il file esiste gi, questo viene azzerato completamente. 11.12 Istruzione PERFORM L'istruzione PERFORM consente di eseguire un gruppo di istruzioni, contenute all'interno di sezioni o di paragrafi della divisione PROCEDURE DIVISION, riprendendo poi il funzionamento nell'istruzione successiva. Sono disponibili schemi sintattici diversi, perch la chiamata di queste procedure pu essere gestita in maniere differenti. In effetti, questa istruzione il mezzo con cui realizzare delle iterazioni, normali e con enumerazione, pertanto si rende necessaria questa flessibilit da parte dell'istruzione PERFORM. Nelle sezioni successive vengono descritte le varie forme di utilizzo dell'istruzione PERFORM, per livelli successivi di complessit. Si tenga conto che la spiegazione riguardo al funzionamento per un certo livello, riguarda anche quelli pi complessi successivi. 11.12.1 Chiamata semplice .-- / \

--.

| | | PERFORM procedure-name-1 | `-- \ / --' Secondo la forma di utilizzo pi semplice dell'istruzione PERFORM, la chiamata esegue una volta sola l'intervallo di procedure indicate. Per procedure qui si intendono dei paragrafi, oppure delle sezioni intere della divisione PROCEDURE DIVISION. Se si indica soltanto un nome (di paragrafo o di sezione), si intende eseguire solo la procedura relativa; se si indica la parola THROUGH o THRU seguita da un altro nome, si intendono eseguire tutti i paragrafi o tutte le sezioni dal primo al secondo nome incluso (e preferibile usare la versione senza THRU). Il fatto che la chiamata di una procedura avvenga in modo cos libero, implica la necessit di stabilire delle restrizioni alle chiamate annidate: una procedura, o un insieme di procedure chiamate attraverso l'istruzione PERFORM, possono contenere delle chiamate annidate. Queste chiamate interne, per poter essere eseguite correttamente, devono riguardare delle procedure pi interne, oppure completamente esterne. Figura 472.60. Schematizzazione delle forme di annidamento consentite e di quella non consentita (sbarrata).

65

La figura mostra schematicamente i vari modi in cui le istruzioni PERFORM possono annidarsi, o possono in qualche modo riguardare le stesse porzioni di codice. L'ultimo esempio, in basso a destra, non ammissibile perch la chiamata dei paragrafi da D a F verrebbe interrotta alla conclusione del paragrafo D, con il rientro dalla prima istruzione PERFORM. 472.15.2

11.12.2

Chiamata ripetuta con condizione di uscita

66

.-- / \ --. | | THROUGH | | PERFORM procedure-name-1 | < > procedurename-2 | | | THRU | | `-- \ / --' UNTIL condition-1 Quando nell'istruzione PERFORM compare la parola chiave UNTIL, seguita da una condizione, si intende eseguire il gruppo di procedure indicate ripetutamente, fino a quando la condizione specificata restituisce il valore Falso. La condizione di uscita viene verificata prima di eseguire ogni iterazione, pertanto, se risulta Vero all'inizio, le procedure non vengono eseguite. Rispetto ai linguaggi di programmazione comuni, il COBOL attribuisce alla parola UNTIL un significato opposto, anche se logico: si esegue il ciclo fino a quanto si verifica la condizione. Il problema che nel senso comune ci significa che il ciclo va ripetuto in quanto la condizione continua ad avverarsi, mentre secondo il senso del COBOL il ciclo va ripetuto fino a quando si verifica la condizione di uscita, nel senso che il verificarsi della condizione di uscita fa terminare il ciclo. Figura 472.63. Diagramma di flusso dell'istruzione PERFORM iterativa con una condizione di uscita.

67

11.12.3

Chiamata ripetuta con condizione di uscita e incremento di contatori .-- / \ | | THROUGH | procedure-name-1 | | | THRU `-- \ / | --.

PERFORM name-2 |

| < > procedure--' |

/ \ / identifier-3 \ / \ | identifier-2 | | | | identifier-4 | VARYING < > FROM < index-name-2 > BY < > | index-name-1 | | \ / \ literal-1 / UNTIL condition-1 / \ / identifier-6 \ | identifier-5 | | | \ | | literal-2 / |

/ |

/ \\ | identifier-7 | |

68

>| | >... | | \

| AFTER <

> FROM < index-name-4 > BY < | | literal-4 \ | /|

< | index-name-3 | | \ / \ literal-3 /

UNTIL condition-2 / Con l'aggiunta della parola chiave VARYING, si intende gestire un contatore numerico (rappresentato nello schema da identifier-2 o da index-name-1, che pertanto pu essere una variabile numerica o un indice di una tabella), specificando il valore di partenza dopo la parola FROM, l'incremento a ogni ciclo dopo la parola BY e la condizione di uscita dopo la parola UNTIL. Possono essere gestiti pi contatori, con un limite che dipende dal compilatore. A ogni modo, per aggiungere un contatore si usa la parola AFTER, che ne introduce la descrizione, cos come per la parola VARYING. Il contatore che viene incrementato a ogni ciclo, quello pi interno, ovvero quello descritto dall'ultima parola AFTER. Quando per quel contatore si verifica la condizione di uscita, viene incrementato il contatore del livello precedente (la penultima parola AFTER o direttamente VARYING in mancanza di quella) e azzerato quello interno. Il ciclo termina quando sono scattate tutte le condizioni di uscita dei vari contatori. Il linguaggio non pone vincoli alla gestione dei contatori indicati nell'istruzione PERFORM, che possono essere alterati durante l'esecuzione delle procedure chiamate dall'istruzione stessa e in qualche modo possono contaminarsi tra di loro. Sta evidentemente al programmatore evitare di creare confusione nel programma, osservando anche che la sequenza esatta delle operazioni di incremento e azzeramento dei contatori cambia leggermente da uno standard all'altro del linguaggio. Figura 472.65. Diagramma di flusso dell'istruzione PERFORM iterativa con l'incremento di un solo contatore.

69

70

Figura 472.66. Diagramma di flusso dell'istruzione PERFORM iterativa con la gestione di due contatori.

L'esempio seguente mostra in modo molto semplice la gestione di tre contatori, che scandiscono valori interi da zero a due, senza fare nulla altro di particolare. Listato 472.67. Programma chiama un paragrafo incrementando tre contatori.

71

000100 IDENTIFICATION DIVISION. 000200 PROGRAM-ID. TEST-PERFORM. 000300 AUTHOR. DANIELE GIACOMINI. 000400 INSTALLATION. NANOLINUX IV, 000500 OPENCOBOL 0.31, 000600 DATE-WRITTEN. 2005-03-17. 000700* 000800 ENVIRONMENT DIVISION. 000900* 001000 DATA DIVISION. 001100* 001200 WORKING-STORAGE SECTION. 001300 77 CONTATORE-1 PIC 99. 001400 77 CONTATORE-2 PIC 99. 001500 77 CONTATORE-3 PIC 99. 001600* 001700 PROCEDURE DIVISION. 001800*------------------------- LIVELLO 0 ----------------------------001900 MAIN. 002000 PERFORM VISUALIZZA-CONTATORI 002100 VARYING CONTATORE-1 FROM 0 BY 1 002200 UNTIL CONTATORE-1 >= 2, 002300 AFTER CONTATORE-2 FROM 0 BY 1 002400 UNTIL CONTATORE-2 >= 2, 002500 AFTER CONTATORE-3 FROM 0 BY 1 002600 UNTIL CONTATORE-3 >= 2. 002700* 002800 STOP RUN. 002900*------------------------- LIVELLO 1 ----------------------------003000 VISUALIZZA-CONTATORI. 003100 DISPLAY CONTATORE-1, " ", CONTATORE-2, " ", CONTATORE-3. 003200* Una volta compilato questo programma, avviando ci che si ottiene, si pu vedere il risultato seguente: 00 00 00 00 00 01 00 01 00 00 01 01 01 00 00 01 00 01 01 01 00 01 01 01 11.13 Istruzione READ L'istruzione READ serve a ottenere un record logico da un file, che risulta essere gi stato aperto, in modo tale da consentire la lettura (INPUT o I-O). Sono disponibili formati diversi per l'utilizzo di questa istruzione, che dipendono dall'organizzazione del file a cui si accede. Organizzazione sequenziale READ file-name [NEXT] RECORD [ INTO identifier ]

72

 [ AT END { imperative-statement }... ] In tutti gli schemi sintattici che riguardano l'istruzione READ, si pu vedere che viene indicato immediatamente il nome del file (gi aperto) che si vuole leggere. Successivamente, appare una parola chiave opzionale, INTO, che precede il nome di una variabile; se viene specificata questa informazione, si intende fare in modo che il record logico ottenuto dal file, oltre che essere disponibile nella variabile strutturata dichiarata appositamente per questo, dopo l'indicatore di livello FD relativo, sia anche copiato in un'altra variabile. Inoltre, le istruzioni imperative (imperative-statement) che si possono inserire dopo le parole AT END, serve a dichiarare cosa deve fare il programma nel caso la lettura finisca per qualche motivo. Quando si accede sequenzialmente, si pu verificare un errore che consiste nel tentativo di leggere oltre la fine del file. Se ci accade e se stata specificata l'opzione AT END, vengono eseguite le istruzioni che seguono tali parole. 11.14 Istruzione STOP RUN L'istruzione STOP RUN conclude il funzionamento del programma; pertanto, pu trovarsi soltanto alla fine di un gruppo di istruzioni. STOP RUN. Storicamente esiste una versione alternativa, ma obsoleta, dell'istruzione STOP, alla quale si associa una costante, allo scopo di mostrare tale valore attraverso il terminale principale. In quella situazione, l'esecuzione del programma veniva sospesa e poteva essere fatta riprendere dall'utente. Considerato che esiste la possibilit di usare istruzioni come DISPLAY e ACCEPT, meglio utilizzare esclusivamente l'istruzione STOP RUN per l'arresto del programma, senza altre varianti. 11.15 Istruzione STRING L'istruzione STRING consente di riempire delle variabili alfanumeriche specificando un punto di inizio, espresso in caratteri. / / \ / identifier-2 \ \ | | identifier-1 | | | | STRING < < >... DELIMITED BY < literal-2 > >... | | literal-1 | | | | \ \ / \ SIZE / / INTO identifier-3 [ WITH POINTER identifier-4 ] [ ON OVERFLOW { imperative-statement-1 }... ] Quello che si mette dopo la parola chiave STRING un elenco di valori che si traducono in informazioni alfanumeriche, che vengono considerati come se fossero concatenati tra di loro. Dopo la parola DELIMITED si deve specificare un modo per delimitare la stringa complessiva indicata a sinistra. Se si usa la parola chiave SIZE, si intende considerare tutta la stringa alfanumerica complessiva, altrimenti, si seleziona solo la parte che si trova a sinistra, prima di ci che viene indicato come riferimento. La stringa complessiva, eventualmente ridotta a destra in qualche modo, viene copiata all'interno della variabile indicata dopo la parola INTO. La stringa viene copiata a partire dalla prima posizione, oppure dalla posizione specificata dal numero indicato dopo la parola POINTER. Dopo la parola POINTER va indicata una variabile numerica, che, oltre a indicare la posizione iniziale dell'inserimento della stringa, viene incrementata di conseguenza, per i caratteri che vengono inseriti effettivamente. Se si utilizza la parola OVERFLOW, le istruzioni che appaiono subito dopo tale parola vengono eseguite se l'inserimento nella variabile di destinazione va oltre la fine della variabile stessa.

73

L'esempio successivo mostra un piccolo programma completo che compila in pi fasi una variabile ricevente. La variabile ricevente contiene inizialmente una serie di simboli #, per consentire di vedere facilmente cosa succede al suo interno, durante le varie fasi. Listato 472.92. Programma elementare che dimostra il funzionamento di STRING. 000100 IDENTIFICATION DIVISION. 000200 PROGRAM-ID. TEST-STRING. 000300 AUTHOR. DANIELE GIACOMINI. 000400 INSTALLATION. NANOLINUX IV, 000500 OPENCOBOL 0.31, 000600 DATE-WRITTEN. 2005-03-16. 000700* 000800 ENVIRONMENT DIVISION. 000900* 001000 DATA DIVISION. 001100* 001200 WORKING-STORAGE SECTION. 001300 77 TESTO-RICEVENTE PIC X(40) VALUE ALL "#". 001400 77 PUNTATORE PIC 99. 001500* 001600 PROCEDURE DIVISION. 001700*------------------------- LIVELLO 0 ----------------------------001800 MAIN. 001900 MOVE 1 TO PUNTATORE. 002000 DISPLAY PUNTATORE, " ", TESTO-RICEVENTE. 002100 STRING "CIAO", SPACE, DELIMITED BY SIZE 002200 INTO TESTO-RICEVENTE WITH POINTER PUNTATORE. 002300 DISPLAY PUNTATORE, " ", TESTO-RICEVENTE. 002400 STRING "COME STAI?" DELIMITED BY SIZE 002500 INTO TESTO-RICEVENTE WITH POINTER PUNTATORE. 002600 DISPLAY PUNTATORE, " ", TESTO-RICEVENTE. 002700 MOVE 11 TO PUNTATORE. 002800 STRING "VA LA VITA?" DELIMITED BY SIZE 002900 INTO TESTO-RICEVENTE WITH POINTER PUNTATORE. 003000 DISPLAY PUNTATORE, " ", TESTO-RICEVENTE. 003100* 003200 STOP RUN. 003300* Dopo aver compilato il programma, eseguendo ci che si ottiene, di dovrebbe vedere il risultato seguente attraverso il terminale: 01 ############################# ########### 06 CIAO ############################# ###### 16 CIAO COME STAI? ######################### 22 CIAO COME VA LA VITA? ################### Come si pu vedere leggendo il sorgente del programma, dopo l'inserimento della stringa CIAO , la variabile usata come puntatore all'interno della variabile di destinazione, si trova a essere gi posizionata sulla sesta colonna, in modo che un inserimento ulteriore si trovi gi nella posizione necessaria. Dopo, viene riposizionato il puntatore per sovrascrivere la parola STAI. 11.16 Istruzione SUBTRACT

74

L'istruzione SUBTRACT consente di eseguire delle sottrazioni. Sono previsti diversi formati per l'utilizzo di questa istruzione. / \ .---. | identifier-1 | | identifier-2 | SUBTRACT < > | |... | literal-1 | | literal-2 | \ / `---' FROM { identifier-m [ROUNDED] }... [ ON SIZE ERROR imperativestatement ] Nello schema sintattico appena mostrato, si vede che dopo la parola chiave SUBTRACT si elencano una serie di costanti o variabili con valore numerico, che vengono sommate assieme inizialmente, per poi sottrarre tale valore dal contenuto delle variabili specificate dopo la parola chiave FROM. L'opzione ROUNDED richiede di eseguire un arrotondamento se la variabile ricevente non pu rappresentare in modo esatto il valore; l'opzione SIZE ERROR serve a eseguire un'istruzione nel caso una delle variabili riceventi non possa accogliere la porzione pi significativa del valore ottenuto dalla somma. Si osservi l'esempio seguente: 000000 SUBTRACT 1, 2, 3, FROM A. Supponendo che la variabile A, prima della somma contenga il valore 10, dopo la somma contiene il valore 4 (10-1-2-3). / \ .-- / \ --. | identifier-1 | | | identifier-2 | | SUBTRACT < > | < > |... | literal-1 | | | literal-2 | | \ / `-- \ / --' / \ | identifier-3 | FROM < > [ROUNDED] ... | identifier-3 | \ / GIVING { identifier-n [ROUNDED] }... [ ON SIZE ERROR imperativestatement ] Quando si utilizza la parola chiave GIVING, si pu indicare un solo valore dopo la parola chiave FROM e il risultato della sottrazione viene assegnato alle variabili che sono elencate dopo la parola GIVING, senza tenere in considerazione il loro valore iniziale. Valgono le stesse considerazioni gi fatte a proposito delle opzioni ROUNDED e SIZE ERROR. Si osservi l'esempio seguente: 000000 SUBTRACT 1, 2, 3, FROM 10 GIVING A. Qualunque sia il valore iniziale della variabile A, dopo la somma questa contiene il valore 4 (10-1-23). / \ | CORR | SUBTRACT < > identifier-1 FROM identifier-2 [ROUNDED] | CORRESPONDING | \ / [ ON SIZE ERROR imperative-statement ]

75

In questo ultimo caso, la sottrazione fa riferimento a variabili strutturate, dove i campi della prima variabile devono essere sottratti ai campi della seconda variabile che hanno lo stesso nome della prima. Valgono le stesse considerazioni gi fatte a proposito delle opzioni ROUNDED e SIZE ERROR. 11.17 Istruzione WRITE L'istruzione WRITE scrive un record logico in un file, aperto in modo appropriato. Nel caso di un file organizzato in modo sequenziale, il file pu essere aperto in scrittura (OUTPUT) o in estensione (EXTEND); nel caso di un file ad accesso diretto, organizzato in modo relativo o a indice, questo pu essere stato aperto in scrittura (OUTPUT) o in lettura e scrittura (I-O), inoltre, se si usa l'accesso sequenziale, consentito anche in caso di apertura in estensione (EXTEND). L'istruzione WRITE viene usata con due schemi sintattici alternativi: uno per i file organizzati in modo sequenziale e l'altro per tutti gli altri casi. Il formato adatto ai file sequenziali contiene, in particolare, opzioni specifiche per l'avanzamento della carta di una stampante. File organizzati in modo sequenziale WRITE record-name [ FROM identifier1] `---' Gli schemi sintattici mostrati hanno in comune la prima parte: il nome della variabile che fa riferimento al record, serve a individuare implicitamente il file; la variabile indicata dopo la parola opzionale FROM, permette di copiare tale variabile su quella del record, prima di procedere alla scrittura, come se si usasse l'istruzione MOVE prima di WRITE: MOVE identifier-1 TO recordname; WRITE record-name [ omissis ] Quando la scrittura avviene con successo, il contenuto del record non pi disponibile in memoria, a meno di averne una copia per altri motivi (per esempio a causa dell'utilizzo dell'opzione FROM).

76

Capitolo 12.COBOL: preparazione

Il linguaggio COBOL nasce quando l'inserimento dei dati in un elaboratore avveniva principalmente attraverso schede perforate, pertanto, da questo derivano una serie di limitazioni nel modo in cui vanno scritte le sue direttive. 12.1 Problema del modulo di programmazione Il linguaggio COBOL nasce imponendo dei vincoli al modo di utilizzare gli spazi orizzontali nel file del sorgente. Questi vincoli consentivano di amministrare con un certo criterio la procedura di perforazione e riutilizzo delle schede perforate. Terminata l'era delle schede perforate, i compilatori hanno cominciato a essere pi disponibili e ad accettare codice COBOL scritto senza rispettare i vincoli del modulo di programmazione tradizionale (normalmente viene eliminato l'obbligo della numerazione delle righe e l'area in cui possibile scrivere le istruzioni si estende per un numero indefinito di colonne, cancellando la funzione della zona identificativa del programma); tuttavia, il suggerimento che qui viene dato di continuare a usare il modello originale, considerata la particolarit del linguaggio di programmazione, che perderebbe la sua logica estetica. Il listato successivo mostra l'esempio di un programma COBOL molto breve, dove si pu vedere l'utilizzo delle varie aree secondo il criterio del modulo di programmazione del linguaggio. 000100 IDENTIFICATION DIVISION. 000200 PROGRAM-ID. ELM0100. 000300 AUTHOR. DANIELE GIACOMINI. 000400 DATE-WRITTEN. 1985-02-12. 000500* 000600 ENVIRONMENT DIVISION. 000700* 000800 DATA DIVISION. 000900* 001000 WORKING-STORAGE SECTION. WSS0000 001100 01 A PIC 9(7). WSS-0000 001200 01 B PIC 9(7). WSS-0000 001300 01 C PIC 9(14). WSS-0000 001400* 001500 PROCEDURE DIVISION. 001600*----------------------------------------------------------------001700 MAIN. 001800 DISPLAY "MOLTIPLICAZIONE DI DUE NUMERI". 001900 DISPLAY "INSERISCI IL PRIMO ELEMENTO". 002000 ACCEPT A. 002100 DISPLAY "INSERISCI IL SECONDO ELEMENTO". 002200 ACCEPT B. 002300 COMPUTE C = A * B. 002400 DISPLAY C. 002500* 002600 STOP RUN. 002700* Nell'esempio si pu osservare: l'uso dell'asterisco nella settima colonna per indicare un commento; la presenza di direttive che iniziano a dalla colonna ottava e di altre che iniziano dalla colonna dodicesima; l'indicazione di un'etichetta distintiva nelle otto colonne finali (WSS-0000), in corrispondenza di alcune righe (probabilmente per ricordare che quella porzione proviene da un altro programma). Si osservi che quanto appare nelle ultime otto colonne non ha valore per il linguaggio di programmazione, ma rappresenta un modo per individuare gruppi di righe che possono avere qualche tipo di importanza, oppure qualunque altro tipo di annotazione. Generalmente, i compilatori consentono di specificare con quale formato viene fornito il file sorgente; la scelta normalmente tra un formato fisso (tradizionale), oppure libero (senza vincoli particolari).

77

Dal momento che attualmente la numerazione delle righe divenuta puramente un fatto estetico, ci si pu aiutare con uno script per rinumerare il sorgente. Il listato successivo mostra uno script molto semplice, che presuppone di ricevere dallo standard input un file sorgente con i numeri di riga, anche se errati, emettendo lo stesso sorgente attraverso lo standard output, ma con una numerazione progressiva uniforme. #!/bin/sh # # cobol-line-renumber INCREMENT < SOURCE_COB > NEW_SOURCE_COB # INCREMENT="$1" LINE="" NUMBER="0" NUMBER_FORMATTED="" # while read LINE do NUMBER=$(($NUMBER+$INCREMENT)) NUMBER_FORMATTED=`printf %000006d $NUMBER` LINE=`echo "$LINE" | sed s/^[0-9][0-9][0-9][0-9][0-9][0-9]//` LINE="$NUMBER_FORMATTED$LINE" echo "$LINE" done In pratica, supponendo che lo script si chiami cobol-line-renumber, si potrebbe usare come nell'esempio seguente: $ cobol-line-renumber < sorgente.cob > rinumerato.cob[Invio] 12.2 Riepilogo di alcuni concetti importanti del linguaggio In generale, le istruzioni del linguaggio COBOL sono da intendere come frasi scritte in inglese, che terminano con un punto fermo. In certe situazioni, si riuniscono pi istruzioni in un'unica frase, che termina con un punto, ma in tal caso, spesso si usa la virgola e il punto e virgola per concludere le istruzioni singole. Le istruzioni del linguaggio si compongono in linea di massima di parole chiave, costanti letterali e operatori matematici. Le parole chiave sono scritte usando lettere maiuscole (dell'alfabeto inglese) e il trattino normale (-). In generale, i simboli che si possono usare nel linguaggio sono abbastanza limitati, con l'eccezione del contenuto delle costanti alfanumeriche letterali, che teoricamente potrebbero contenere qualunque simbolo (escluso quello che si usa come delimitatore) secondo le potenzialit del compilatore particolare. Tabella 474.5. I simboli disponibili nel linguaggio. Simboli Descrizione Simboli Descrizione 0..9 A..Z cifre numeriche lettere maiuscole dell'alfabeto inglese (latino) spazio + segno pi segno meno o trattino * / asterisco barra obliqua $ dollaro o segno di valuta , virgola ; . punto e virgola punto fermo ( ) parentesi aperta parentesi chiusa < > minore maggiore Le parole chiave pi importanti del linguaggio sono dei verbi imperativi, che descrivono un comando che si vuole sia eseguito. Un gruppo interessante di parole chiave rappresentato dalle costanti figurative, che servono a indicare verbalmente delle costanti di uso comune. Per esempio, la parola chiave ZERO rappresenta uno o pi zeri, in base al contesto. Le stringhe sono delimitate da virgolette (apici doppi) e di solito non sono previste forme di protezione per incorporare le virgolette stesse all'interno delle stringhe: per questo occorre suddividere le stringhe, concatenandole con la costante figurativa QUOTE. La gestione numerica del COBOL speciale rispetto ai linguaggi di programmazione comuni, perch le variabili vengono dichiarate con la loro dimensione di cifre esatta, stabilendo anche la quantit di

78

decimali e il modo in cui l'informazione deve essere gestita. In pratica, si stabilisce il modo in cui il valore deve essere rappresentato, lasciando al compilatore il compito di eseguire ogni volta tutte le conversioni necessarie. Sotto questo aspetto, un programma COBOL ha una gestione per i valori numerici molto pesante, quindi pi lenta rispetto ad altri linguaggi, dove i valori numerici sono gestiti in base alle caratteristiche fisiche della CPU e le conversioni di tipo devono essere dichiarate esplicitamente. Le variabili usate nel linguaggio sono sempre globali e come tali vanno dichiarate in una posizione apposita. Tali variabili, salvo situazioni eccezionali, fanno sempre parte di un record, inteso come una raccolta di campi di informazioni. Questa gestione particolare costringe a stabilire esattamente le dimensioni che ogni informazione deve avere se registrata nella memoria di massa (dischi, nastri o altro) o se stampata. In un certo senso, questa caratteristica pu impedire o rendere difficile l'uso di una forme di codifica dei caratteri che preveda una dimensione variabile degli stessi, considerato che i record possono essere rimappati, trattando anche valori numerici come insiemi di cifre letterali. Questo particolare, che non affatto di poco conto, suggerisce di usare il linguaggio per gestire dati rappresentabili con il codice ASCII tradizionale, ovvero con i primi 127 punti di codifica (da U+0000 a U+007F). Naturalmente sono disponibili compilatori che permettono di superare questo problema, ma in tal caso occorre verificare come vengono gestiti effettivamente i dati. Le istruzioni COBOL possono essere scritte usando pi righe, avendo l'accortezza di continuare a partire dall'area B; in generale non c' bisogno di indicare esplicitamente che l'istruzione sta continuando nella riga successiva, perch si usa il punto fermo per riconoscere la loro conclusione. Tuttavia, in situazioni eccezionali, si pu spezzare una parola chiave o anche una stringa letterale; in tal caso, nella settima colonna delle riga che continua, va inserito il segno -, inoltre, se si tratta di una stringa, la sua ripresa va iniziata nuovamente con le virgolette. A ogni modo, considerato che difficilmente si devono scrivere parole chiave molto lunghe e che le stringhe letterali si possono concatenare, auspicabile che la continuazione nella riga successiva con l'indicatore nella settima colonna sia evitata del tutto. I commenti nel sorgente si indicano inserendo un asterisco nella settima colonna; se invece si mette una barra obliqua (/) si vuole richiedere un salto pagina, in fase di stampa, ammesso che il compilatore preveda questo.

79

Capitolo 13.COBOL: esempi elementari

Questo capitolo raccoglie degli esempi elementari di programmi COBOL. Questi esempi risalgono a un lavoro didattico del 1985, realizzato con un minicomputer Burroughs B91 del 1981. Salvo dove indicato in maniera differente, gli esempi mostrati funzionano regolarmente se compilati con OpenCOBOL 0.31. 13.1 ELM0100: prodotto tra due numeri Variabili A il moltiplicando; B il moltiplicatore; C il risultato. Descrizione Il calcolo viene eseguito attraverso l'istruzione COMPUTE. Paragrafo MAIN Il programma si svolge unicamente all'interno di questo paragrafo. Il programma riceve dall'esterno i valori per le variabili A e B, esegue il prodotto tramite l'istruzione COMPUTE mettendo il risultato nella variabile C. Viene visualizzato il contenuto della variabile C con l'istruzione DISPLAY. Il programma si arresta perch incontra l'istruzione STOP RUN. 000100 IDENTIFICATION DIVISION. 000200 PROGRAM-ID. ELM0100. 000300 AUTHOR. DANIELE GIACOMINI. 000400 DATE-WRITTEN. 1985-02-12. 000500* 000600 ENVIRONMENT DIVISION. 000700* 000800 DATA DIVISION. 000900* 001000 WORKING-STORAGE SECTION. 001100 01 A PIC 9(7). 001200 01 B PIC 9(7). 001300 01 C PIC 9(14). 001400* 001500 PROCEDURE DIVISION. 001600*----------------------------------------------------------------001700 MAIN. 001800 DISPLAY "MOLTIPLICAZIONE DI DUE NUMERI". 001900 DISPLAY "INSERISCI IL PRIMO ELEMENTO". 002000 ACCEPT A. 002100 DISPLAY "INSERISCI IL SECONDO ELEMENTO". 002200 ACCEPT B. 002300 COMPUTE C = A * B. 002400 DISPLAY C. 002500* 002600 STOP RUN. 002700* 13.2 ELM0200: prodotto tra due numeri Variabili A il moltiplicando; B il moltiplicatore; C il risultato; questa variabile viene inizializzata a zero in fase di dichiarazione. Descrizione

80

Il calcolo viene eseguito sommando alla variabile C la variabile A per B volte. Paragrafo MAIN Il programma riceve dall'esterno i valori per le variabili A e B. Attraverso l'istruzione PERFORM viene eseguito il paragrafo SOMMA per B volte; al termine di questo ciclo il risultato della moltiplicazione si trova nella variabile C, che viene visualizzato con l'istruzione DISPLAY. Il programma si arresta perch incontra l'istruzione STOP RUN. Paragrafo SOMMA Il paragrafo somma al contenuto della variabile C il contenuto della variabile A. Dal momento che questo paragrafo viene eseguito B volte, la variabile C finisce con il contenere il risultato del prodotto di AB. 000100 IDENTIFICATION DIVISION. 000200 PROGRAM-ID. ELM0200. 000300 AUTHOR. DANIELE GIACOMINI. 000400 DATE-WRITTEN. 1985-02-14. 000500* 000600 ENVIRONMENT DIVISION. 000700* 000800 DATA DIVISION. 000900* 001000 WORKING-STORAGE SECTION. 001100 01 A PIC 9(7). 001200 01 B PIC 9(7). 001300 01 C PIC 9(14) VALUE ZERO. 001400* 001500 PROCEDURE DIVISION. 001600*------------------------LIVELLO 0 ----------------------------001700 MAIN. 001800 DISPLAY "MOLTIPLICAZIONE DI DUE NUMERI". 001900 DISPLAY "INSERISCI IL PRIMO ELEMENTO". 002000 ACCEPT A. 002100 DISPLAY "INSERISCI IL SECONDO ELEMENTO". 002200 ACCEPT B. 002300 PERFORM SOMMA B TIMES. 002400 DISPLAY C. 002500* 002600 STOP RUN. 002700*------------------------LIVELLO 1 ----------------------------002800 SOMMA. 002900 COMPUTE C = C + A. 003000* 13.3 ELM0300: prodotto tra due numeri Variabili A il moltiplicando; B il moltiplicatore; C il risultato. Descrizione Il calcolo viene eseguito sommando alla variabile C la variabile A per B volte. Per ogni esecuzione di tale somma, la variabile B viene diminuita di una unit, cosicch il ciclo delle somme viene arrestato quando B ormai a zero. Paragrafo MAIN Vengono ricevuti dall'esterno i valori per le variabili A e B. Viene eseguito tramite l'istruzione PERFORM il paragrafo SOMMA fino a quando la variabile B raggiunge lo zero. A quel punto la variabile C contiene il risultato del prodotto, che viene visualizzato con l'istruzione DISPLAY. Il programma si arresta perch incontra l'istruzione STOP RUN.

81

Paragrafo SOMMA Inizialmente viene decrementato di una unit il contenuto della variabile B, quindi viene sommato al contenuto di C il valore di A. 000100 IDENTIFICATION DIVISION. 000200 PROGRAM-ID. ELM0300. 000300 AUTHOR. DANIELE GIACOMINI. 000400 DATE-WRITTEN. 1985-04-13. 000500* 000600 ENVIRONMENT DIVISION. 000700* 000800 DATA DIVISION. 000900* 001000 WORKING-STORAGE SECTION. 001100 01 A PIC 9(7). 001200 01 B PIC 9(7). 001300 01 C PIC 9(14) VALUE ZERO. 001400* 001500 PROCEDURE DIVISION. 001600*------------------------LIVELLO 0 ----------------------------001700 MAIN. 001800 DISPLAY "MOLTIPLICAZIONE DI DUE NUMERI". 001900 DISPLAY "INSERISCI IL PRIMO ELEMENTO". 002000 ACCEPT A. 002100 DISPLAY "INSERISCI IL SECONDO ELEMENTO". 002200 ACCEPT B. 002300 PERFORM SOMMA UNTIL B = 0. 002400 DISPLAY C. 002500* 002600 STOP RUN. 002700*------------------------LIVELLO 1 ----------------------------002800 SOMMA. 002900 COMPUTE B = B - 1. 003000 COMPUTE C = C + A. 003100* 13.4 ELM0400: prodotto tra due numeri Variabili A il moltiplicando; B il moltiplicatore; C il risultato; EOJ quando assume il valore 1 il programma si arresta; RISPOSTA la variabile che riceve la risposta, un SI o un NO, per la continuazione o meno con un altro calcolo. Descrizione Il calcolo viene eseguito sommando alla variabile C la variabile A per B volte. Per ogni esecuzione di tale somma, la variabile B viene diminuita di una unit, cosicch il ciclo delle somme viene arrestato quando B ormai a zero. Il programma si arresta solo se gli viene dato un comando apposito, altrimenti continua a richiedere altri dati per l'esecuzione di un altro prodotto. Paragrafo MAIN Vengono ricevuti dall'esterno i valori per le variabili A e B tramite il paragrafo INSERIMENTODATI. Viene eseguito il paragrafo LAVORO ripetutamente, terminando il ciclo quando la variabile EOJ contiene il valore uno. Il programma si arresta perch incontra l'istruzione STOP RUN. Paragrafo LAVORO

82

Viene eseguito tramite l'istruzione PERFORM il paragrafo SOMMA ripetutamente, terminando il ciclo quando la variabile B contiene il valore zero. A quel punto, la variabile C contiene il risultato del prodotto, che viene visualizzato con l'istruzione DISPLAY. Il programma riceve dall'esterno una parola: un SI o un NO; se viene fornita la stringa SI (scritta con lettere maiuscole) il programma azzera il contenuto della variabile C ed esegue il paragrafo INSERIMENTO-DATI, altrimenti, viene messo il valore uno nella variabile EOJ. Paragrafo INSERIMENTO-DATI Il paragrafo riceve dall'esterno i valori per le variabili A e B. Paragrafo SOMMA Inizialmente viene decrementato di una unit il contenuto della variabile B, quindi viene sommato al contenuto di C il valore di A. 000100 IDENTIFICATION DIVISION. 000200 PROGRAM-ID. ELM0400. 000300 AUTHOR. DANIELE GIACOMINI. 000400 DATE-WRITTEN. 1985-02-14. 000500* 000600 ENVIRONMENT DIVISION. 000700* 000800 DATA DIVISION. 000900* 001000 WORKING-STORAGE SECTION. 001100 01 A PIC 9(7). 001200 01 B PIC 9(7). 001300 01 C PIC 9(14) VALUE ZERO. 001400 01 EOJ PIC 9 VALUE ZERO. 001500 01 RISPOSTA PIC XX. 001600* 001700 PROCEDURE DIVISION. 001800*------------------------LIVELLO 0 ----------------------------001900 MAIN. 002000 PERFORM INSERIMENTO-DATI. 002100 PERFORM LAVORO UNTIL EOJ = 1. 002200* 002300 STOP RUN. 002400*------------------------LIVELLO 1 ----------------------------002500 LAVORO. 002600 PERFORM SOMMA UNTIL B = 0. 002700 DISPLAY C. 002800* 002900 DISPLAY "VUOI CONTINUARE? SI O NO". 003000 ACCEPT RISPOSTA. 003100* 003200 IF RISPOSTA = "SI" 003300 THEN 003400 MOVE ZERO TO C, 003500 PERFORM INSERIMENTO-DATI; 003600 ELSE 003700 MOVE 1 TO EOJ. 003800*------------------------LIVELLO 2 ----------------------------003900 INSERIMENTO-DATI. 004000 DISPLAY "INSERISCI IL PRIMO ELEMENTO". 004100 ACCEPT A. 004200 DISPLAY "INSERISCI IL SECONDO ELEMENTO". 004300 ACCEPT B. 004400*----------------------------------------------------------------004500 SOMMA. 004600 COMPUTE B = B - 1.

83

004700 004800*

COMPUTE C = C + A.

13.5 ELM0500: prodotto tra due numeri Variabili A il moltiplicando; B il moltiplicatore; C il risultato; EOJ quando assume il valore 1 il programma si arresta; RISPOSTA la variabile che riceve la risposta, un SI o un NO, per la continuazione o meno con un altro calcolo. Descrizione Il calcolo viene eseguito sommando alla variabile C la variabile A per B volte. Il controllo di questa somma viene effettuato da un ciclo PERFORM VARYING che decrementa di una unit la variabile B, partendo dal suo valore iniziale, fino a quando si riduce a zero, nel qual caso il ciclo si arresta. Paragrafo MAIN Vengono ricevuti dall'esterno i valori per le variabili A e B tramite il paragrafo INSERIMENTODATI. Viene eseguito il paragrafo LAVORO ripetutamente, terminando il ciclo quando la variabile EOJ contiene il valore uno. Il programma si arresta perch incontra l'istruzione STOP RUN. Paragrafo LAVORO Viene eseguito tramite l'istruzione PERFORM il paragrafo SOMMA ripetutamente, decrementando il valore della variabile B, fino a zero, quando il ciclo termina. A quel punto, la variabile C contiene il risultato del prodotto, che viene visualizzato con l'istruzione DISPLAY. Il programma riceve dall'esterno una parola: un SI o un NO; se viene fornita la stringa SI (scritta con lettere maiuscole) il programma azzera il contenuto della variabile C ed esegue il paragrafo INSERIMENTO-DATI, altrimenti, viene messo il valore uno nella variabile EOJ. Paragrafo INSERIMENTO-DATI Il paragrafo riceve dall'esterno i valori per le variabili A e B. Paragrafo SOMMA Viene sommato al contenuto di C il valore di A. 000100 IDENTIFICATION DIVISION. 000200 PROGRAM-ID. ELM0500. 000300 AUTHOR. DANIELE GIACOMINI. 000400 DATE-WRITTEN. 1985-02-14. 000500* 000600 ENVIRONMENT DIVISION. 000700* 000800 DATA DIVISION. 000900* 001000 WORKING-STORAGE SECTION. 001100 01 A PIC 9(7). 001200 01 B PIC 9(7). 001300 01 C PIC 9(14) VALUE ZERO. 001400 01 EOJ PIC 9 VALUE ZERO. 001500 01 RISPOSTA PIC XX. 001600* 001700 PROCEDURE DIVISION. 001800*------------------------- LIVELLO 0 ----------------------------001900 MAIN. 002000 PERFORM INSERIMENTO-DATI. 002100 PERFORM LAVORO UNTIL EOJ = 1. 002200* 002300 STOP RUN. 002400*------------------------- LIVELLO 1 ----------------------------002500 LAVORO. 002600 PERFORM SOMMA VARYING B FROM B BY -1 UNTIL B =

84

0. 002700 DISPLAY C. 002800* 002900 DISPLAY "VUOI CONTINUARE? SI O NO". 003000 ACCEPT RISPOSTA. 003100* 003200 IF RISPOSTA = "SI" 003300 THEN 003400 MOVE ZERO TO C, 003500 PERFORM INSERIMENTO-DATI; 003600 ELSE 003700 MOVE 1 TO EOJ. 003800*------------------------- LIVELLO 2 ----------------------------003900 INSERIMENTO-DATI. 004000 DISPLAY "INSERISCI IL PRIMO ELEMENTO". 004100 ACCEPT A. 004200 DISPLAY "INSERISCI IL SECONDO ELEMENTO". 004300 ACCEPT B. 004400*----------------------------------------------------------------004500 SOMMA. 004600 COMPUTE C = C + A. 004700* 13.6 ELM0600: inserimento dati in un vettore (ARRAY) Variabili RECORD-ELEMENTI una variabile che si scompone in un array; ELEMENTO l'array che costituisce RECORD-ELEMENTI; INDICE l'indice usato per scandire gli elementi; EOJ quando assume il valore 1 il programma si arresta; RISPOSTA la variabile che riceve la risposta, un SI o un NO, per la continuazione o meno con un altro calcolo. Descrizione Il programma esegue semplicemente un inserimento di dati all'interno degli elementi dell'array, con un accesso libero (bisogna ricordare che l'indice del primo elemento uno), specificando prima l'indice e poi il valore (il carattere) da attribuire all'elemento. Paragrafo MAIN Viene eseguito una volta il paragrafo INSERIMENTO-INDICE, che serve a ricevere il valore dell'indice di inserimento dall'utente. Viene eseguito il paragrafo LAVORO ripetutamente, terminando il ciclo quando la variabile EOJ contiene il valore uno. Viene visualizzato il valore di tutta la variabile RECORD-ELEMENTI, attraverso l'istruzione DISPLAY. Il programma si arresta perch incontra l'istruzione STOP RUN. Paragrafo LAVORO Il programma riceve dall'esterno il valore per ELEMENTO(INDICE). Il programma riceve dall'esterno l'assenso o il dissenso riguardo alla continuazione dell'esecuzione; se l'intenzione di proseguire, viene eseguito il paragrafo INSERIMENTOINDICE, altrimenti viene messo il valore uno nella variabile EOJ. Paragrafo INSERIMENTO-INDICE Il programma riceve dall'esterno il valore per la variabile INDICE. 000100 IDENTIFICATION DIVISION. 000200 PROGRAM-ID. ELM0600. 000300 AUTHOR. DANIELE GIACOMINI. 000400 DATE-WRITTEN. 1985-02-14. 000500* 000600 ENVIRONMENT DIVISION. 000700* 000800 DATA DIVISION. 000900*

85

001000 WORKING-STORAGE SECTION. 001100 01 RECORD-ELEMENTI. 001200 02 ELEMENTO PIC X OCCURS 9 TIMES. 001300 01 INDICE PIC 9. 001400 01 EOJ PIC 9 VALUE ZERO. 001500 01 RISPOSTA PIC XX. 001600* 001700 PROCEDURE DIVISION. 001800*------------------------- LIVELLO 0 ----------------------------001900 MAIN. 002000 PERFORM INSERIMENTO-INDICE. 002100 PERFORM LAVORO UNTIL EOJ = 1. 002200 DISPLAY RECORD-ELEMENTI. 002300* 002400 STOP RUN. 002500*------------------------- LIVELLO 1 ----------------------------002600 LAVORO. 002700 DISPLAY "INSERISCI I DATI DI UN ELEMENTO (UN SOLO CARATTERE)". 002800 ACCEPT ELEMENTO(INDICE). 002900* 003000 DISPLAY "VUOI CONTINUARE? SI O NO". 003100 ACCEPT RISPOSTA. 003200* 003300 IF RISPOSTA = "SI" 003400 THEN 003500 PERFORM INSERIMENTO-INDICE; 003600 ELSE 003700 MOVE 1 TO EOJ. 003800*------------------------- LIVELLO 2 ----------------------------003900 INSERIMENTO-INDICE. 004000 DISPLAY "INSERISCI L'INDICE". 004100 ACCEPT INDICE. 004200* 13.7 ELM0700: inserimento dati in un vettore (ARRAY) Variabili RECORD-ELEMENTI una variabile che si scompone in un array; ELEMENTO l'array che costituisce RECORD-ELEMENTI; INDICE l'indice usato per scandire gli elementi; EOJ quando assume il valore 1 il programma si arresta; RISPOSTA la variabile che riceve la risposta, un SI o un NO, per la continuazione o meno con un altro calcolo. Descrizione Il programma esegue semplicemente un inserimento di dati all'interno degli elementi dell'array, con un accesso libero (bisogna ricordare che l'indice del primo elemento uno), specificando prima l'indice e poi il valore (il carattere) da attribuire all'elemento. Se l'indice che si inserisce zero, viene richiesto nuovamente di fornire un dato valido. Paragrafo MAIN Viene eseguito paragrafo INSERIMENTO-INDICE, che serve a ricevere il valore dell'indice di inserimento dall'utente, ripetendo l'operazione se il valore fornito minore o uguale a zero. Viene eseguito il paragrafo LAVORO ripetutamente, terminando il ciclo quando la variabile EOJ contiene il valore uno. Viene visualizzato il valore di tutta la variabile RECORD-ELEMENTI, attraverso l'istruzione DISPLAY. Il programma si arresta perch incontra l'istruzione STOP RUN. Paragrafo LAVORO Il programma riceve dall'esterno il valore per ELEMENTO(INDICE). Il programma riceve dall'esterno l'assenso o il dissenso riguardo alla continuazione dell'esecuzione; se l'intenzione di proseguire, dopo l'azzeramento della variabile INDICE

86

viene eseguito il paragrafo INSERIMENTO-INDICE, ripetutamente, ponendo come condizione di conclusione il fatto che la variabile INDICE abbia un valore maggiore di zero. Se invece l'utente rinuncia a proseguire, viene messo il valore uno nella variabile EOJ. Paragrafo INSERIMENTO-INDICE Il programma riceve dall'esterno il valore per la variabile INDICE. 000100 IDENTIFICATION DIVISION. 000200 PROGRAM-ID. ELM0700. 000300 AUTHOR. DANIELE GIACOMINI. 000400 DATE-WRITTEN. 1985-02-14. 000500* 000600 ENVIRONMENT DIVISION. 000700* 000800 DATA DIVISION. 000900* 001000 WORKING-STORAGE SECTION. 001100 01 RECORD-ELEMENTI. 001200 02 ELEMENTO PIC X OCCURS 9 TIMES. 001300 01 INDICE PIC 9. 001400 01 EOJ PIC 9 VALUE ZERO. 001500 01 RISPOSTA PIC XX. 001600* 001700 PROCEDURE DIVISION. 001800*------------------------- LIVELLO 0 ----------------------------001900 MAIN. 002000 PERFORM INSERIMENTO-INDICE UNTIL INDICE > ZERO. 002100 PERFORM LAVORO UNTIL EOJ = 1. 002200 DISPLAY RECORD-ELEMENTI. 002300* 002400 STOP RUN. 002500*------------------------- LIVELLO 1 ----------------------------002600 LAVORO. 002700 DISPLAY "INSERISCI I DATI DI UN ELEMENTO (UN SOLO CARATTERE)". 002800 ACCEPT ELEMENTO(INDICE). 002900* 003000 DISPLAY "VUOI CONTINUARE? SI O NO". 003100 ACCEPT RISPOSTA. 003200* 003300 IF RISPOSTA = "SI" 003400 THEN 003500 MOVE ZERO TO INDICE, 003600 PERFORM INSERIMENTO-INDICE UNTIL INDICE > ZERO; 003700 ELSE 003800 MOVE 1 TO EOJ. 003900*------------------------- LIVELLO 2 ----------------------------004000 INSERIMENTO-INDICE. 004100 DISPLAY "INSERISCI L'INDICE". 004200 ACCEPT INDICE. 004300* 13.8 ELM0800: inserimento dati in un vettore (ARRAY) Variabili RECORD-ELEMENTI una variabile che si scompone in un array; ELEMENTO l'array che costituisce RECORD-ELEMENTI; INDICE l'indice usato per scandire gli elementi; EOJ quando assume il valore 1 il programma si arresta; RISPOSTA la variabile che riceve la risposta, un SI o un NO, per la continuazione o meno con un altro calcolo. Descrizione

87

Il programma esegue semplicemente un inserimento di dati all'interno degli elementi dell'array, con un accesso libero (bisogna ricordare che l'indice del primo elemento uno), specificando prima l'indice e poi il valore (il carattere) da attribuire all'elemento. Se l'indice che si inserisce zero, viene richiesto nuovamente di fornire un dato valido. Paragrafo MAIN Viene eseguito paragrafo INSERIMENTO-INDICE, che serve a ricevere il valore dell'indice di inserimento dall'utente. Viene eseguito il paragrafo LAVORO ripetutamente, terminando il ciclo quando la variabile EOJ contiene il valore uno. Viene visualizzato il valore di tutta la variabile RECORD-ELEMENTI, attraverso l'istruzione DISPLAY. Il programma si arresta perch incontra l'istruzione STOP RUN. Paragrafo LAVORO Il programma riceve dall'esterno il valore per ELEMENTO(INDICE). Il programma riceve dall'esterno l'assenso o il dissenso riguardo alla continuazione dell'esecuzione; se l'intenzione di proseguire viene eseguito il paragrafo INSERIMENTOINDICE, in caso contrario, viene messo il valore uno nella variabile EOJ. Paragrafo INSERIMENTO-INDICE Il programma riceve dall'esterno il valore per la variabile INDICE, quindi controlla che questo sia diverso da zero; in caso contrario, si ha una chiamata dello stesso paragrafo, in modo ricorsivo. A causa della caratteristica ricorsiva del paragrafo INSERIMENTO-INDICE, nel programma originale era riportato in un commento: attenzione! pu essere nocivo. 000100 IDENTIFICATION DIVISION. 000200 PROGRAM-ID. ELM0800. 000300 AUTHOR. DANIELE GIACOMINI. 000400 DATE-WRITTEN. 1985-02-14. 000500* 000600 ENVIRONMENT DIVISION. 000700* 000800 DATA DIVISION. 000900* 001000 WORKING-STORAGE SECTION. 001100 01 RECORD-ELEMENTI. 001200 02 ELEMENTO PIC X OCCURS 9 TIMES. 001300 01 INDICE PIC 9. 001400 01 EOJ PIC 9 VALUE ZERO. 001500 01 RISPOSTA PIC XX. 001600* 001700 PROCEDURE DIVISION. 001800*------------------------LIVELLO 0 ----------------------------001900 MAIN. 002000 PERFORM INSERIMENTO-INDICE. 002100 PERFORM LAVORO UNTIL EOJ = 1. 002200 DISPLAY RECORD-ELEMENTI. 002300* 002400 STOP RUN. 002500*------------------------LIVELLO 1 ----------------------------002600 LAVORO. 002700 DISPLAY "INSERISCI I DATI DI UN ELEMENTO", 002800 " (UN SOLO CARATTERE)". 002900 ACCEPT ELEMENTO(INDICE). 003000* 003100 DISPLAY "VUOI CONTINUARE? SI O NO". 003200 ACCEPT RISPOSTA. 003300* 003400 IF RISPOSTA = "SI" 003500 THEN

88

003600 PERFORM INSERIMENTO-INDICE; 003700 ELSE 003800 MOVE 1 TO EOJ. 003900*------------------------LIVELLO ----------------------------004000 INSERIMENTO-INDICE. 004100 DISPLAY "INSERISCI L'INDICE". 004200 ACCEPT INDICE. 004300 IF INDICE = 0 004400 THEN 004500 PERFORM INSERIMENTO-INDICE. 004600*

13.9 ELM0900: ricerca sequenziale all'interno di un vettore (ARRAY) Variabili RECORD-ELEMENTI una variabile usata per accogliere una stringa; ELEMENTO un array che scompone RECORD-ELEMENTI in caratteri singoli; POSIZIONE l'indice usato per scandire gli elementi della stringa; EOJ quando assume il valore 1 il programma si arresta; RISPOSTA la variabile che riceve la risposta, un SI o un NO, per la continuazione o meno con un altro calcolo; LETTERA la variabile che contiene la lettera da cercare nella stringa. Descrizione Il programma riceve dall'esterno il contenuto di una stringa e di una lettera che dovrebbe essere contenuta nella stringa stessa; successivamente il programma scandisce la stringa come vettore di caratteri e individua la prima posizione in cui appare la lettera cercata. Paragrafo MAIN Viene eseguito paragrafo INSERIMENTO-DATI. Viene eseguito il paragrafo LAVORO ripetutamente, terminando il ciclo quando la variabile EOJ contiene il valore uno. Il programma si arresta perch incontra l'istruzione STOP RUN. Paragrafo LAVORO Il programma esegue il paragrafo RICERCA. A questo punto la variabile POSIZIONE contiene la posizione della lettera contenuta nella variabile LETTERA e viene visualizzata. Il programma riceve dall'esterno l'assenso o il dissenso riguardo alla continuazione dell'esecuzione; se l'intenzione di proseguire, viene eseguito il paragrafo INSERIMENTODATI, in caso contrario, viene messo il valore uno nella variabile EOJ. Paragrafo INSERIMENTO-DATI Il programma riceve dall'esterno una stringa da inserire nella variabile RECORD-ELEMENTI e la lettera da ricercare nella stringa. Paragrafo RICERCA Viene eseguito un paragrafo che non esegue alcunch (l'istruzione EXIT) scandendo l'indice POSIZIONE a partire da uno, con passo unitario, terminando quando il contenuto di ELEMENTO(POSIZIONE) coincide con il valore di LETTERA, ovvero quando la posizione della lettera nella stringa stata trovata. In pratica, il paragrafo EXIT-PARAGRAPH una scusa per utilizzare la scansione dell'istruzione PERFORM VARYING. Paragrafo EXIT-PARAGRAPH Il paragrafo non fa alcunch. 000100 IDENTIFICATION DIVISION. 000200 PROGRAM-ID. ELM0900. 000300 AUTHOR. DANIELE GIACOMINI. 000400 DATE-WRITTEN. 1985-02-15. 000500* 000600 ENVIRONMENT DIVISION. 000700* 000800 DATA DIVISION. 000900*

89

001000 WORKING-STORAGE SECTION. 001100 01 RECORD-ELEMENTI. 001200 02 ELEMENTO PIC X OCCURS 60 TIMES. 001300 01 POSIZIONE PIC 99. 001500 01 EOJ PIC 9 VALUE ZERO. 001600 01 RISPOSTA PIC XX. 001700 01 LETTERA PIC X. 001800* 001900 PROCEDURE DIVISION. 002000*------------------------LIVELLO 0 ----------------------------002100 MAIN. 002200 PERFORM INSERIMENTO-DATI. 002300 PERFORM LAVORO UNTIL EOJ = 1. 002400* 002500 STOP RUN. 002600*------------------------LIVELLO 1 ----------------------------002700 LAVORO. 002800 PERFORM RICERCA. 002900 DISPLAY "LA LETTERA ", LETTERA, 003000 " E' NELLA POSIZIONE ", POSIZIONE. 003100* 003200 DISPLAY "VUOI CONTINUARE? SI O NO". 003300 ACCEPT RISPOSTA. 003400* 003500 IF RISPOSTA = "SI" 003600 THEN 003700 PERFORM INSERIMENTO-DATI; 003800 ELSE 003900 MOVE 1 TO EOJ. 004000*------------------------LIVELLO 2 ----------------------------004100 INSERIMENTO-DATI. 004200 DISPLAY "INSERISCI LA FRASE". 004300 ACCEPT RECORD-ELEMENTI. 004400* 004500 DISPLAY "INSERISCI LA LETTERA DA TROVARE". 004600 ACCEPT LETTERA. 004700*----------------------------------------------------------------004800 RICERCA. 004900 PERFORM EXIT-PARAGRAPH 005000 VARYING POSIZIONE FROM 1 BY 1 005100 UNTIL ELEMENTO(POSIZIONE) = LETTERA. 005200*------------------------LIVELLO 3 ----------------------------005300 EXIT-PARAGRAPH. 005400 EXIT. 005500* 13.10 ELM1000: ricerca sequenziale all'interno di un vettore (ARRAY) Variabili RECORD-ELEMENTI una variabile usata per accogliere una stringa; ELEMENTO un array che scompone RECORD-ELEMENTI in caratteri singoli; POSIZIONE l'indice usato per scandire gli elementi della stringa; EOJ quando assume il valore 1 il programma si arresta; RISPOSTA la variabile che riceve la risposta, un SI o un NO, per la continuazione o meno con un altro calcolo;

90

LETTERA la variabile che contiene la lettera da cercare nella stringa. Descrizione Il programma riceve dall'esterno il contenuto di una stringa e di una lettera che dovrebbe essere contenuta nella stringa stessa; successivamente il programma scandisce la stringa come vettore di caratteri e individua la prima posizione in cui appare la lettera cercata. Rispetto a ELM0900 la scansione della stringa si arresta anche se non viene trovata alcuna corrispondenza. Paragrafo MAIN Viene eseguito paragrafo INSERIMENTO-DATI. Viene eseguito il paragrafo LAVORO ripetutamente, terminando il ciclo quando la variabile EOJ contiene il valore uno. Il programma si arresta perch incontra l'istruzione STOP RUN. Paragrafo LAVORO Il programma esegue il paragrafo RICERCA. A questo punto la variabile POSIZIONE contiene la posizione della lettera contenuta nella variabile LETTERA e viene visualizzata. Il programma riceve dall'esterno l'assenso o il dissenso riguardo alla continuazione dell'esecuzione; se l'intenzione di proseguire, viene eseguito il paragrafo INSERIMENTODATI, in caso contrario, viene messo il valore uno nella variabile EOJ. Paragrafo INSERIMENTO-DATI Il programma riceve dall'esterno una stringa da inserire nella variabile RECORD-ELEMENTI e la lettera da ricercare nella stringa. Paragrafo RICERCA Viene eseguito un paragrafo che non esegue alcunch (l'istruzione EXIT) scandendo l'indice POSIZIONE a partire da uno, con passo unitario, terminando quando si supera la dimensione della stringa oppure quando il contenuto di ELEMENTO(POSIZIONE) coincide con il valore di LETTERA, ovvero quando la posizione della lettera nella stringa stata trovata. In pratica, il paragrafo EXIT-PARAGRAPH una scusa per utilizzare la scansione dell'istruzione PERFORM VARYING. Paragrafo EXIT-PARAGRAPH Il paragrafo non fa alcunch. 000100 IDENTIFICATION DIVISION. 000200 PROGRAM-ID. ELM1000. 000300 AUTHOR. DANIELE GIACOMINI. 000400 DATE-WRITTEN. 1985-02-15. 000500* 000600 ENVIRONMENT DIVISION. 000700* 000800 DATA DIVISION. 000900* 001000 WORKING-STORAGE SECTION. 001100 01 RECORD-ELEMENTI. 001200 02 ELEMENTO PIC X OCCURS 60 TIMES. 001300 01 POSIZIONE PIC 99. 001400 01 EOJ PIC 9 VALUE ZERO. 001500 01 RISPOSTA PIC XX. 001600 01 LETTERA PIC X. 001700* 001800 PROCEDURE DIVISION. 001900*------------------------LIVELLO 0 ----------------------------002000 MAIN. 002100 PERFORM INSERIMENTO-DATI. 002200 PERFORM LAVORO UNTIL EOJ = 1. 002300* 002400 STOP RUN. 002500*------------------------LIVELLO 1 ----------------------------002600 LAVORO. 002700 PERFORM RICERCA. 002800 DISPLAY "LA LETTERA ", LETTERA,

91

002900 " E' NELLA POSIZIONE ", POSIZIONE. 003000* 003100 DISPLAY "VUOI CONTINUARE? SI O NO". 003200 ACCEPT RISPOSTA. 003300* 003400 IF RISPOSTA = "SI" 003500 THEN 003600 PERFORM INSERIMENTO-DATI; 003700 ELSE 003800 MOVE 1 TO EOJ. 003900*------------------------LIVELLO 2 ----------------------------004000 INSERIMENTO-DATI. 004100 DISPLAY "INSERISCI LA FRASE". 004200 ACCEPT RECORD-ELEMENTI. 004300* 004400 DISPLAY "INSERISCI LA LETTERA DA TROVARE". 004500 ACCEPT LETTERA. 004600*----------------------------------------------------------------004700 RICERCA. 004800 PERFORM EXIT-PARAGRAPH 004900 VARYING POSIZIONE FROM 1 BY 1 005000 UNTIL POSIZIONE > 60 005100 OR ELEMENTO(POSIZIONE) = LETTERA. 005200*------------------------LIVELLO 3 ----------------------------005300 EXIT-PARAGRAPH. 005400 EXIT. 005500* 13.11 ELM1100: ricerca sequenziale all'interno di un vettore (ARRAY) Variabili RECORD-ELEMENTI una variabile usata per accogliere una stringa; ELEMENTO un array che scompone RECORD-ELEMENTI in caratteri singoli; POSIZIONE l'indice usato per scandire gli elementi della stringa; EOJ quando assume il valore 1 il programma si arresta; RISPOSTA la variabile che riceve la risposta, un SI o un NO, per la continuazione o meno con un altro calcolo; LETTERA la variabile che contiene la lettera da cercare nella stringa. Descrizione Il programma riceve dall'esterno il contenuto di una stringa e di una lettera che dovrebbe essere contenuta nella stringa stessa; successivamente il programma scandisce la stringa come vettore di caratteri e individua la prima posizione in cui appare la lettera cercata. Rispetto a ELM1000 si ottiene un avvertimento quando si indica una lettera che non contenuta nella frase. Paragrafo MAIN Viene eseguito paragrafo INSERIMENTO-DATI. Viene eseguito il paragrafo LAVORO ripetutamente, terminando il ciclo quando la variabile EOJ contiene il valore uno. Il programma si arresta perch incontra l'istruzione STOP RUN. Paragrafo LAVORO Il programma esegue il paragrafo RICERCA. A questo punto la variabile POSIZIONE contiene la posizione della lettera contenuta nella variabile LETTERA: se il valore della posizione supera la dimensione massima dell'array, si ottiene un avvertimento dell'impossibilit di trovare la corrispondenza, altrimenti viene visualizzata la posizione trovata. Il programma riceve dall'esterno l'assenso o il dissenso riguardo alla continuazione dell'esecuzione; se l'intenzione di proseguire, viene eseguito il paragrafo INSERIMENTODATI, in caso contrario, viene messo il valore uno nella variabile EOJ.

92

Paragrafo INSERIMENTO-DATI Il programma riceve dall'esterno una stringa da inserire nella variabile RECORD-ELEMENTI e la lettera da ricercare nella stringa. Paragrafo RICERCA Viene eseguito un paragrafo che non esegue alcunch (l'istruzione EXIT) scandendo l'indice POSIZIONE a partire da uno, con passo unitario, terminando quando si supera la dimensione della stringa oppure quando il contenuto di ELEMENTO(POSIZIONE) coincide con il valore di LETTERA, ovvero quando la posizione della lettera nella stringa stata trovata. In pratica, il paragrafo EXIT-PARAGRAPH una scusa per utilizzare la scansione dell'istruzione PERFORM VARYING. Paragrafo EXIT-PARAGRAPH Il paragrafo non fa alcunch. 000100 IDENTIFICATION DIVISION. 000200 PROGRAM-ID. ELM1100. 000300 AUTHOR. DANIELE GIACOMINI. 000400 DATE-WRITTEN. 1985-02-15. 000500* 000600 ENVIRONMENT DIVISION. 000700* 000800 DATA DIVISION. 000900* 001000 WORKING-STORAGE SECTION. 001100 01 RECORD-ELEMENTI. 001200 02 ELEMENTO PIC X OCCURS 60 TIMES. 001300 01 POSIZIONE PIC 99. 001400 01 EOJ PIC 9 VALUE ZERO. 001500 01 RISPOSTA PIC XX. 001600 01 LETTERA PIC X. 001700* 001800 PROCEDURE DIVISION. 001900*------------------------LIVELLO 0 ----------------------------002000 MAIN. 002100 PERFORM INSERIMENTO-DATI. 002200 PERFORM LAVORO UNTIL EOJ = 1. 002300* 002400 STOP RUN. 002500*------------------------LIVELLO 1 ----------------------------002600 LAVORO. 002700 PERFORM RICERCA. 002800* 002900 IF POSIZIONE < 61 003000 THEN 003100 DISPLAY "LA LETTERA ", LETTERA, 003200 " E' NELLA POSIZIONE ", POSIZIONE; 003300 ELSE 003400 DISPLAY "LA LETTERA ", LETTERA, 003500 " NON E' CONTENUTA NELLA FRASE". 003600* 003700 DISPLAY "VUOI CONTINUARE? SI O NO". 003800 ACCEPT RISPOSTA. 003900* 004000 IF RISPOSTA = "SI" 004100 THEN 004200 PERFORM INSERIMENTO-DATI; 004300 ELSE 004400 MOVE 1 TO EOJ. 004500*------------------------LIVELLO 2 ----------------------------004600 INSERIMENTO-DATI.

93

004700 DISPLAY "INSERISCI LA FRASE". 004800 ACCEPT RECORD-ELEMENTI. 004900* 005000 DISPLAY "INSERISCI LA LETTERA DA TROVARE". 005100 ACCEPT LETTERA. 005200*----------------------------------------------------------------005300 RICERCA. 005400 PERFORM EXIT-PARAGRAPH 005500 VARYING POSIZIONE FROM 1 BY 1 005600 UNTIL POSIZIONE > 60 005700 OR ELEMENTO(POSIZIONE) = LETTERA. 005800*------------------------LIVELLO 3 ----------------------------005900 EXIT-PARAGRAPH. 006000 EXIT. 006100* 13.12 ELM1300: creazione di un file sequenziale File FILE-DA-SCRIVERE rappresenta il file che viene creato dal programma (il nome del file output.seq). Il file di tipo sequenziale, dove la riga ha una dimensione fissa; non si prevede l'inserimento di un codice di interruzione di riga alla fine delle righe. Variabili RECORD-DA-SCRIVERE la riga del file da creare; EOJ quando assume il valore 1 il programma si arresta. Descrizione Il programma riceve dall'esterno il contenuto di ogni riga e di volta in volta lo registra nel file. Il programma termina il lavoro quando la stringa inserita contiene solo asterischi (almeno 30, pari alla larghezza massima prevista di ogni riga). Paragrafo MAIN Viene aperto in scrittura il file da creare. Viene eseguito il paragrafo INSERIMENTO-DATI. Viene eseguito il paragrafo LAVORO ripetutamente, concludendo il ciclo quando la variabile EOJ contiene il valore uno. Viene chiuso il file da creare. Il programma si arresta perch incontra l'istruzione STOP RUN. Paragrafo LAVORO Si controlla se la stringa inserita contiene soltanto asterischi; se cos viene messo il valore uno nella variabile EOJ, altrimenti viene scritta la riga inserita nel file da scrivere e subito dopo viene eseguito nuovamente il paragrafo INSERIMENTO-DATI. Paragrafo INSERIMENTO-DATI Il paragrafo riceve dall'esterno il contenuto di una riga da registrare nel file, tenendo conto che vengono prese in considerazione al massimo i primi 30 caratteri, pari alla dimensione della variabile che deve accogliere i dati. 000100 IDENTIFICATION DIVISION. 000200 PROGRAM-ID. ELM1300. 000300 AUTHOR. DANIELE GIACOMINI. 000400 DATE-WRITTEN. 1985-02-20. 000500* 000600 ENVIRONMENT DIVISION. 000700* 000800 INPUT-OUTPUT SECTION. 000900* 001000 FILE-CONTROL. 001100* 001200 SELECT FILE-DA-SCRIVERE ASSIGN TO "output.seq" 001300 ORGANIZATION IS SEQUENTIAL.

94

001400* 001500 DATA DIVISION. 001600* 001700 FILE SECTION. 001800* 001900 FD FILE-DA-SCRIVERE 002000 LABEL RECORD IS STANDARD. 002100* 002200 01 RECORD-DA-SCRIVERE PIC X(30). 002300* 002400 WORKING-STORAGE SECTION. 002500 01 EOJ PIC 9 VALUE ZERO. 002600* 002700 PROCEDURE DIVISION. 002800*------------------------- LIVELLO 0 ----------------------------002900 MAIN. 003000 OPEN OUTPUT FILE-DA-SCRIVERE. 003100 PERFORM INSERIMENTO-DATI. 003200 PERFORM LAVORO UNTIL EOJ = 1. 003300 CLOSE FILE-DA-SCRIVERE. 003400* 003500 STOP RUN. 003600*------------------------- LIVELLO 1 ----------------------------003700 LAVORO. 003800 IF RECORD-DA-SCRIVERE = ALL "*" 003900 THEN 004000 MOVE 1 TO EOJ; 004100 ELSE 004200 WRITE RECORD-DA-SCRIVERE, 004300 PERFORM INSERIMENTO-DATI. 004400*------------------------- LIVELLO 2 ----------------------------004500 INSERIMENTO-DATI. 004600 DISPLAY "INSERISCI IL RECORD". 004700 DISPLAY "PER FINIRE INSERISCI TUTTI ASTERISCHI". 004800 ACCEPT RECORD-DA-SCRIVERE. 004900* Per fare in modo che le righe del file siano concluse come avviene di solito nei file di testo, con un codice di interruzione di riga, occorre specificare nell'istruzione SELECT un accesso di tipo LINE SEQUENTIAL. 475. 13.13 File FILE-DA-LEGGERE rappresenta il file che viene letto dal programma (il nome del file input.seq). Il file di tipo sequenziale, dove ogni riga ha una dimensione fissa e non si fa affidamento sulla presenza di un codice di interruzione di riga. Variabili RECORD-DA-LEGGERE la riga del file da leggere; EOF quando assume il valore 1 indica che la lettura ha superato la fine del file. Descrizione Il programma visualizza il contenuto di un file. La lettura avviene a blocchi di 30 caratteri, indipendentemente dal fatto che siano presenti dei codici di interruzione di riga. Diversamente, per fare in modo che la lettura sia al massimo di 30 caratteri, ma rispettando anche i codici di interruzione di riga, occorre specificare nell'istruzione SELECT un accesso di tipo LINE SEQUENTIAL. Paragrafo MAIN Viene aperto in lettura il file da leggere. ELM1500: lettura di un file sequenziale

95

Viene eseguita la lettura di un primo blocco, pari alla dimensione della variabile RECORD-DALEGGERE; se si verifica la condizione AT END, ovvero se il file vuoto, viene messo il valore uno nella variabile EOF. Viene eseguito il paragrafo LETTURA, ripetutamente, utilizzando come condizione di arresto il fatto che la variabile EOF contenga il valore uno. Viene chiuso il file da leggere. Il programma si arresta perch incontra l'istruzione STOP RUN. Paragrafo LETTURA Viene visualizzata la porzione di file appena letta. Viene eseguita la lettura del file da leggere; se si verifica la condizione AT END, ovvero se la lettura non ha acquisito alcunch, viene messo il valore uno nella variabile EOF. 000100 IDENTIFICATION DIVISION. 000200 PROGRAM-ID. ELM1500. 000300 AUTHOR. DANIELE GIACOMINI. 000400 DATE-WRITTEN. 1985-02-20. 000500* 000600 ENVIRONMENT DIVISION. 000700* 000800 INPUT-OUTPUT SECTION. 000900* 001000 FILE-CONTROL. 001100* 001200 SELECT FILE-DA-LEGGERE ASSIGN TO "input.seq" 001300 ORGANIZATION IS SEQUENTIAL. 001400* 001500 DATA DIVISION. 001600* 001700 FILE SECTION. 001800* 001900 FD FILE-DA-LEGGERE 002000 LABEL RECORD IS STANDARD. 002100* 002200 01 RECORD-DA-LEGGERE PIC X(30). 002300* 002400 WORKING-STORAGE SECTION. 002500 01 EOF PIC 9 VALUE ZERO. 002600* 002700 PROCEDURE DIVISION. 002800*------------------------LIVELLO 0 ----------------------------002900 MAIN. 003000 OPEN INPUT FILE-DA-LEGGERE. 003100 READ FILE-DA-LEGGERE 003200 AT END 003300 MOVE 1 TO EOF. 003400 PERFORM LETTURA UNTIL EOF = 1. 003500 CLOSE FILE-DA-LEGGERE. 003600* 003700 STOP RUN. 003800*------------------------LIVELLO 1 ----------------------------003900 LETTURA. 004000 DISPLAY RECORD-DA-LEGGERE. 004100 READ FILE-DA-LEGGERE 004200 AT END 004300 MOVE 1 TO EOF. 004400* Figura 475.15. Foto ricordo della festa conclusiva di un corso sul linguaggio COBOL realizzato con un l'elaboratore Burroughs B91, presumibilmente tra il 1982 e il 1983. Nell'immagine, l'ingegnere che ha tenuto il corso compila un diploma preparato per scherzo dagli studenti che hanno frequentato il

96

corso.

97

Capitolo 14.COBOL: esempi elementari con i file

Questo capitolo raccoglie degli esempi elementari di programmi COBOL per l'accesso ai file. Questi esempi risalgono a un lavoro didattico del 1983, realizzato con un minicomputer Burroughs B91 del 1981. Salvo dove indicato in maniera differente, gli esempi mostrati funzionano regolarmente se compilati con OpenCOBOL 0.31. 14.1 AGO-83-1: estensione di un file sequenziale 000100 IDENTIFICATION DIVISION. 000200 PROGRAM-ID. AGO-83-1. 000300 AUTHOR. DANIELE GIACOMINI. 000400 DATE-WRITTEN. 2005-03-20. 000500* 000600 ENVIRONMENT DIVISION. 000700* 000800 INPUT-OUTPUT SECTION. 000900* 001000 FILE-CONTROL. 001100* 001200 SELECT FILE-DA-SCRIVERE ASSIGN TO "file.seq" 001300 ORGANIZATION IS SEQUENTIAL. 001400* 001500 DATA DIVISION. 001600* 001700 FILE SECTION. 001800* 001900 FD FILE-DA-SCRIVERE 002000 LABEL RECORD IS STANDARD. 002100* 002200 01 RECORD-DA-SCRIVERE. 002300 02 CODICE-FILE PIC 9(10) COMP. 002400 02 TESTO PIC X(75). 002500* 002600 WORKING-STORAGE SECTION. 002700* 002800 01 CAMPI-SCALARI. 002900 02 EOJ PIC 9 COMP VALUE IS 0. 003000* 003100 PROCEDURE DIVISION. 003200*------------------------- LIVELLO 0 ----------------------------003300 MAIN. 003400 OPEN EXTEND FILE-DA-SCRIVERE. 003500 PERFORM INSERIMENTO-DATI UNTIL EOJ = 1. 003600 CLOSE FILE-DA-SCRIVERE. 003700 STOP RUN. 003800*------------------------- LIVELLO 1 ----------------------------003900 INSERIMENTO-DATI. 004000 DISPLAY "INSERISCI PRIMA IL CODICE NUMERICO, POI IL TESTO" 004100 ACCEPT CODICE-FILE. 004200 IF CODICE-FILE = 0 004300 THEN 004400 MOVE 1 TO EOJ, 004500 ELSE 004600 ACCEPT TESTO, 004700 WRITE RECORD-DA-SCRIVERE. 004800*

98

14.2 AGO-83-2: lettura sequenziale e ricerca di una chiave 000100 IDENTIFICATION DIVISION. 000200 PROGRAM-ID. AGO-83-1. 000300 AUTHOR. DANIELE GIACOMINI. 000400 DATE-WRITTEN. 1983-08. 000500* 000600 ENVIRONMENT DIVISION. 000700* 000800 INPUT-OUTPUT SECTION. 000900* 001000 FILE-CONTROL. 001100* 001200 SELECT FILE-DA-LEGGERE ASSIGN TO "file.seq" 001300 ORGANIZATION IS SEQUENTIAL. 001400* 001500 DATA DIVISION. 001600* 001700 FILE SECTION. 001800* 001900 FD FILE-DA-LEGGERE 002000 LABEL RECORD IS STANDARD. 002100* 002200 01 RECORD-DA-LEGGERE. 002300 02 CODICE-FILE PIC 9(10) COMP. 002400 02 TESTO PIC X(75). 002500* 002600 WORKING-STORAGE SECTION. 002700* 002800 01 CAMPI-SCALARI. 002900 02 EOF PIC 9 COMP VALUE IS 0. 003000 02 EOJ PIC 9 COMP VALUE IS 0. 003100 02 CODICE-RECORD PIC 9(10) COMP VALUE IS 0. 003200* 003300 PROCEDURE DIVISION. 003400*------------------------- LIVELLO 0 ----------------------------003500 MAIN. 003600 OPEN INPUT FILE-DA-LEGGERE. 003700 READ FILE-DA-LEGGERE 003800 AT END MOVE 1 TO EOF. 003900 PERFORM DOMANDA UNTIL EOF = 1 OR EOJ = 1. 004000 CLOSE FILE-DA-LEGGERE. 004100 STOP RUN. 004200*------------------------- LIVELLO 1 ----------------------------004300 DOMANDA. 004400 DISPLAY "INSERISCI IL CODICE DEL RECORD, DI 10 CIFRE" 004500 ACCEPT CODICE-RECORD. 004600 IF CODICE-RECORD = 0 004700 THEN 004800 MOVE 1 TO EOJ. 004900 PERFORM RICERCA UNTIL EOF = 1 OR EOJ = 1. 005000 CLOSE FILE-DA-LEGGERE. 005100 MOVE ZERO TO EOF. 005200 OPEN INPUT FILE-DA-LEGGERE. 005300 READ FILE-DA-LEGGERE 005400 AT END MOVE 1 TO EOF. 005500*------------------------- LIVELLO 2 ----------------------------005600 RICERCA. 005700 IF CODICE-FILE = CODICE-RECORD 005800 THEN

99

005900 006000 006100 006200*

DISPLAY CODICE-FILE, " ", TESTO. READ FILE-DA-LEGGERE AT END MOVE 1 TO EOF.

14.3 AGO-83-13: creazione di un file sequenziale con dati da rielaborare Questo esempio serve a creare un file sequenziale, contenente dei calcoli da eseguire, successivamente, con un altro programma. 000100 IDENTIFICATION DIVISION. 000200 PROGRAM-ID. AGO-83-13. 000300 AUTHOR. DANIELE GIACOMINI. 000400 DATE-WRITTEN. 2005-03-22. 000500* 000600 ENVIRONMENT DIVISION. 000700* 000800 INPUT-OUTPUT SECTION. 000900* 001000 FILE-CONTROL. 001100* 001200 SELECT FILE-DA-SCRIVERE ASSIGN TO "calc.seq" 001300 ORGANIZATION IS SEQUENTIAL. 001400* 001500 DATA DIVISION. 001600* 001700 FILE SECTION. 001800* 001900 FD FILE-DA-SCRIVERE 002000 LABEL RECORD IS STANDARD. 002100* 002200 01 RECORD-DA-SCRIVERE. 002300 02 NUMERO-1 PIC 9(15). 002400 02 TIPO-CALCOLO PIC X. 002500 02 NUMERO-2 PIC 9(15). 002600 02 FILLER PIC X. 002700 02 RISULTATO PIC 9(15). 002800 02 FILLER PIC X. 002900 02 RESTO PIC 9(15). 003000 02 NOTE PIC X(18). 003100* 003200 WORKING-STORAGE SECTION. 003300* 003400 01 CAMPI-SCALARI. 003500 02 EOJ PIC 9 COMP VALUE IS 0. 003600* 003700 PROCEDURE DIVISION. 003800*------------------------- LIVELLO 0 ----------------------------003900 MAIN. 004000 OPEN EXTEND FILE-DA-SCRIVERE. 004100 PERFORM INSERIMENTO-DATI UNTIL EOJ = 1. 004200 CLOSE FILE-DA-SCRIVERE. 004300 STOP RUN. 004400*------------------------- LIVELLO 1 ----------------------------004500 INSERIMENTO-DATI. 004600 DISPLAY "INSERISCI, IN SEQUENZA, IL PRIMO NUMERO, ", 004700 "IL SIMBOLO DELL'OPERAZIONE, IL SECONDO NUMERO". 004800 ACCEPT NUMERO-1. 004900 ACCEPT TIPO-CALCOLO. 005000 ACCEPT NUMERO-2. 005100 IF NUMERO-1 = 0 AND NUMERO-2 = 0 AND TIPO-CALCOLO =

100

SPACE 005200 005300 005400 005500 005600*

THEN MOVE 1 TO EOJ, ELSE WRITE RECORD-DA-SCRIVERE.

14.4 AGO-83-14: lettura e riscrittura di un file sequenziale Questo esempio legge e riscrive il file generato con l'esempio precedente, eseguendo i calcoli previsti e mostrando anche il risultato a video. 000100 IDENTIFICATION DIVISION. 000200 PROGRAM-ID. AGO-83-14. 000300 AUTHOR. DANIELE GIACOMINI. 000400 DATE-WRITTEN. 1983-08. 000500* 000600 ENVIRONMENT DIVISION. 000700* 000800 INPUT-OUTPUT SECTION. 000900* 001000 FILE-CONTROL. 001100* 001200 SELECT FILE-DA-ELABORARE ASSIGN TO "calc.seq" 001300 ORGANIZATION IS SEQUENTIAL. 001400* 001500 DATA DIVISION. 001600* 001700 FILE SECTION. 001800* 001900 FD FILE-DA-ELABORARE 002000 LABEL RECORD IS STANDARD. 002100* 002200 01 RECORD-DA-ELABORARE. 002300 02 NUMERO-1 PIC 9(15). 002400 02 TIPO-CALCOLO PIC X. 002500 02 NUMERO-2 PIC 9(15). 002600 02 UGUALE PIC X. 002700 02 RISULTATO PIC 9(15). 002800 02 SEPARAZIONE PIC X. 002900 02 RESTO PIC 9(15). 003000 02 NOTE PIC X(18). 003100* 003200 WORKING-STORAGE SECTION. 003300* 003400 01 CAMPI-SCALARI. 003500 02 EOF PIC 9 COMP VALUE IS 0. 003600 02 EOJ PIC 9 COMP VALUE IS 0. 003700* 003800 PROCEDURE DIVISION. 003900*------------------------- LIVELLO 0 ----------------------------004000 MAIN. 004100 OPEN I-O FILE-DA-ELABORARE. 004200 READ FILE-DA-ELABORARE 004300 AT END MOVE 1 TO EOF. 004400 PERFORM ELABORAZIONE UNTIL EOF = 1. 004500 CLOSE FILE-DA-ELABORARE. 004600 STOP RUN. 004700*------------------------- LIVELLO 1 ----------------------------004800 ELABORAZIONE. 004900 MOVE SPACES TO NOTE.

101

005000 MOVE ZERO TO RESTO. 005100 IF TIPO-CALCOLO = "+" 005200 THEN 005300 COMPUTE RISULTATO = NUMERO-1 + NUMERO-2; 005400 ELSE IF TIPO-CALCOLO = "-" 005500 THEN 005600 COMPUTE RISULTATO = NUMERO-1 - NUMERO-2; 005700 ELSE IF TIPO-CALCOLO = "*" 005800 THEN 005900 COMPUTE RISULTATO = NUMERO-1 * NUMERO-2; 006000 ELSE IF TIPO-CALCOLO = "/" 006100 THEN 006200 DIVIDE NUMERO-1 BY NUMERO-2 GIVING RISULTATO, 006300 REMAINDER RESTO; 006400 ELSE 006500 MOVE ZERO TO RISULTATO, 006600 MOVE "CALCOLO ERRATO" TO NOTE. 006700 006800 MOVE "=" TO UGUALE. 006900 MOVE SPACE TO SEPARAZIONE. 007000 DISPLAY RECORD-DA-ELABORARE. 007100 REWRITE RECORD-DA-ELABORARE. 007200 READ FILE-DA-ELABORARE 007300 AT END MOVE 1 TO EOF. 007400*

102