Manuale per la programmazione Tivoli Service Desk 6.0 Developer's Toolkit Script
Questo capitolo introduce i tipi di dati utilizzati con maggiore frequenza in Developer's Toolkit. Oltre alle discussioni sui tipi di dati, è possibile trovare informazioni sulle costanti, sulle variabili ed espressioni.
Tipi di dati definisce le proprietà dei dati contenuti in una costante o in una variabile. Le possibili proprietà possono includere:
Developer's Toolkit ha sei tipi di dati semplici.
Una handle è una variabile contenente l'indirizzo di un'altra variabile. Un indirizzo è l'ubicazione di una variabile. Una handle consente a un programma di accedere a una risorsa specifica.
I tipi di handle hanno degli usi specifici e non derivano da nessun altro tipo. Gli sviluppatori utilizzano le handle per individuare un'entità logica su cui vengono effettuate le operazioni. Segue un elenco di tipi di handle:
I tipi di parametri esterni sono versioni con note di tipi semplici che aiutano il Developer's Toolkit Interpreter a convertire i valori del Developer's Toolkit nei tipi C o Pascal adeguati prima di richiamare una DLL esterna:
I tre tipi aggregati non devono stare da soli, ma possono essere utilizzati insieme a qualsiasi altro tipo per creare i tipi definiti dall'utente:
Le Costanti sono voci denominate che rimangono immutate, costanti, per tutta l'esecuzione di un programma. Tutte le dichiarazioni di costante vengono effettuate nella sezione CONSTANTS di un file .kb.
Per dichiarare una costante in un file .kb è necessario:
Le dichiarazioni di costante, come tutte le istruzioni Developer's Toolkit, terminano sempre con un punto e virgola (;).
Negli esempi seguenti vengono mostrate alcune dichiarazioni di costante che utilizzano tipi di dati differenti:
CONSTANTS (* string constants *) fileName IS 'MYFILE.DAT'; pathName IS 'EADVISOR\ADVISOR\DATA'; driveName IS 'E:';
(* integer constants *) MAX_EMPLOYEES IS 500; ERROR_CODE IS -1;
(* real constants *) PI_VALUE IS 3.14159; MAX_SALARY IS 999999.99; LO_VALUE IS -5134.1348;
(* Boolean constants *) SAVE_TO_DISK IS TRUE; OVERWRITE_FILE IS FALSE;
(* date constants *) CHRISTMAS IS {12,25,1996}: DATE; BIRTH_DAY IS {2,13,1956}: DATE;
(* time constants *) START_OF_DAY IS {8,30,0}: TIME; END_OF_DAY IS {18,0,0}: TIME;
Nota: E' necessario che gli utenti internazionali sappiano che l'ordine delle "parti" della data in una inizializzazione Developer's Toolkit è (mese, giorno, anno) e non cambia da locale a locale.
Le Variabili sono voci denominate contenenti i tipi di dati che è possibile modificare durante l'esecuzione del programma. Le variabili vengono dichiarate nella sezione VARIABLES di un file .kb.
Per dichiarare una variabile in un file .kb è necessario:
Come mostrato nell'esempio seguente, è possibile dichiarare più variabili dello stesso tipo separando i loro nomi con le virgole:
VARIABLES first_name, last_name : STRING; i,j : INTEGER; salary : REAL; married : BOOLEAN; entryDate : DATE; startTime : TIME;
I valori vengono assegnati alle variabili con l'operatore di assegnazione (:=).
Il frammento di codice seguente mostra alcune assegnazioni di variabile per le variabili definite nell'esempio precedente:
first_name := 'Amy'; last_name := 'Alec'; i := 7; j := 32; salary := 37500.00; married := FALSE; entryDate := {1,31,1991}: DATE; startTime := {10,30,0}: TIME;
Alcune volte si può voler convertire i tipi di dati. La conversione dei dati avviene quando si modifica il modo di rappresentare le informazioni. Ad esempio, è possibile modificare la rappresentazione binaria in rappresentazione decimale o esadecimale o numeri interi in stringhe.
Developer's Toolkit utilizza parentesi graffe {} per indicare il valore da convertire.
In questo esempio il valore all'interno delle parentesi graffe viene convertito in numero intero:
i := {s}: INTEGER;
Quando Developer's Toolkit incontra questa riga, esso:
La conversione di un valore non distrugge il valore originario.
Il seguente è un esempio più complesso di conversione di dati e mostra il modo in cui il Developer's Toolkit calcola il numero di giorni tra due date definite:
d1 := {1,1,1990}: DATE; d2 := $Today; daysBetween = {d2}: INTEGER - {d1}: INTEGER;
Per realizzare ciò, Developer's Toolkit utilizza i valori della data memorizzati in {d1} e {d2}, li converte nei loro valori Giuliani e sottrae questi valori.
In questo esempio si presume che {d1} e {d2} siano variabili della data e che la variabile daysBetween sia un numero intero.
Developer's Toolkit è un linguaggio definito per tipi, ciò significa che se si assegna una variabile di un tipo a una variabile di un altro tipo, si verifica un errore.
Ad esempio, se si presume che entryDate sia una variabile di data e che startTime sia una variabile dell'ora, l'assegnazione seguente crea un errore al tempo di esecuzione:
entryDate := startTime;
Developer's Toolkit converte i numeri interi e i numeri reali automaticamente. Ad esempio, supponendo che la variabile i sia un numero intero, l'istruzione
i := 37.0;
fa in modo che il valore 37 venga assegnato alla variabile i senza
che sia necessaria alcuna conversione esplicita del tipo.
Allo stesso modo, se r è un numero reale, l'istruzione
r := i;
assegna il valore 37.0 alla variabile r.
Le espressioni miste vengono considerate numeri reali fino a che non viene effettuata l'assegnazione per mantenere la precisione.
Inoltre, Developer's Toolkit, quando necessario, converte automaticamente tutti i tipi di dati in stringhe. Ad esempio, l'istruzione:
s := i;
assegna il valore di stringa 37 alla variabile s.
In Developer's Toolkit, una stringa è una sequenza di caratteri compresi tra singoli apici. Developer's Toolkit fornisce gli operatori e le istruzioni di gestione della stringa che consentono di effettuare delle operazioni per:
Le istruzioni e gli operatori di stringa vengono riassunti nell'esempio seguente.
s1 := 'F:\CODE'; s2 := 'PROGRAM.EXE'; s3 := s1 & '\' & s2;
In questo esempio, la variabile s3 contiene la stringa F:\CODE\PROGRAM.EXE.' Le variabili s1 e s2 non sono state modificate in alcun modo e mantengono i loro valori di origine. La congiunzione commerciale può essere utilizzata per concatenare un qualsiasi numero di costanti, variabili o espressioni per formare una nuova stringa. La congiunzione commerciale, inoltre, converte automaticamente i valori non stringa in stringhe prima di effettuare il concatenamento. Ad esempio:
s1 := 'La data è ' & $Today & 'e l'ora è ' & $Now;
Nell'esempio precedente, le costanti $Today (data del sistema) e $Now (ora del sistema) del Developer's Toolkit, vengono convertite automaticamente in moduli di stringa per il concatenamento.
s := 'LIB(ase) FILE(qrpgsrc); s := StrUpper(s); (* now s = 'LIB(ASE) FILE(QRPGSRC) *)
Nota: Per gli utenti internazionali, Developer's Toolkit segue le regole appropriate del carattere maiuscolo per la locale corrente. Ad esempio, "eclair" diventa "ECLAIR" in Francia e nelle zone di lingua francese del Canada.
s := 'LIB(ase) FILE(qrpgsrc); s := StrLower(s); (* now s = 'lib(ase) file(qrpgsrc) *)
Nota: Per gli utenti internazionali, Developer's Toolkit segue le regole del carattere appropriate per la locale corrente della workstation.
~ La variabile di stringa in cui viene inserita una nuova stringa
~ La stringa inserita
~ L'indice nel parametro di stringa in cui deve essere inserita la nuova stringa
Ad esempio:
s := StrInsert('LIB(ASE) MBR(MYPROG)', 'FILE(QRPGSRC) ',10); (* now s = 'LIB(ASE) FILE(QRPGSRC) MBR(MYPROG) *)
Nota: Gli utenti internazionali che scrivono il codice per più locale dovrebbero evitare di "assemblare" frasi con frammenti diversi. Se si assemblano frasi in questo modo, non vengono mantenuti il genere e la concordanza esistenti in molte lingue.
~ Il nome di un parametro di stringa
~ Un indice iniziale
~ Il numero di caratteri da cancellare
Ad esempio:
s := StrDelete('LIB(ASE) FILE(QRPGSRC) MBR(MYPROG)',10,14); (* now s = 'LIB(ASE) MBR(MYPROG)' *)
~ Nome della stringa di risorsa
~ L'indice iniziale all'interno di una stringa di risorsa
~ Il numero di caratteri da copiare
Ad esempio:
fileName := 'LIB(ASE) FILE(QRPGSRC) MBR(MYPROG)'; s := StrCopy(fileName,15,7); (* now S = 'QRPGSRC' *)
Nota: La inquiry StrPos non è inquiry. La prima posizione è sempre indicizzata su 1, invece che su 0 come in C e in altri linguaggi di programmazione.
Se non è possibile trovare la seconda stringa, viene restituito un valore "0". Ad esempio:
company := 'Tivoli Systems'; loc := StrPos(company, 'Sys'); (*loc = 8*)
Dopo l'esecuzione di questo codice, la variabile loc contiene il valore 8.
Ad esempio:
IF StrMatch(s,'*.BAK') THEN FErase(s); END;
Developer's Toolkit comprende altre manipolazioni di stringa StrToken (un dispositivi per l'assegnazione di token alle stringhe da cancellare) StrTrim, StrLTrim e StrLength.
Developer's Toolkit supporta operatori ed espressioni aritmetiche come riassunto nella seguente tabella.
Operatore Descrizione + Aggiunge due espressioni numeriche (i:=3+5) - Sottrae un'espressione numerica da un'altra (r:=3.7-2.0) * Moltiplica due espressioni numeriche (i:=3.0*6) / Divide due espressioni numeriche (r:=3.0/4.0) MOD Calcola il resto quando un numero intero viene diviso per un altro (6 MOD 4=2)
In aggiunta agli operatori, Developer's Toolkit supporta le seguenti funzioni:
Trigonometriche | Logaritmiche | Esponenziali |
Sen | Log | Esp |
Cos | Ln | Power |
Tan | Sqrt | n/a |
ACos | n/a | n/a |
ASin | n/a | n/a |
ATan | n/a | n/a |
CosH | n/a | n/a |
SenH | n/a | n/a |
TanH | n/a | n/a |
Gli operatori logici AND, OR e NOT possono essere utilizzati per creare espressioni booleane complesse come:
b := (i > 0) AND (j = 0);
Developer's Toolkit esegue la valutazione booleana di forma breve. Questa forma di valutazione garantisce che le espressioni booleane vengano valutate solo se è necessario stabilire il loro valore.
Nell'esempio precedente, se i è 0, la variabile b assume il valore FALSE prima di valutare j. Come regola:
Developer's Toolkit fornisce i seguenti operatori relazionali da utilizzare nelle espressioni booleane.
Operatore | Descrizione |
< | Minore di |
<= | Minore di o uguale a |
> | Maggiore di |
>= | Maggiore di o uguale a |
= | Uguale |
<> | Non uguale |
Nota: Gli operatori relazionali sopra elencati ignorano i caratteri quando confrontano due stringhe. Ciò indica che la seguente espressione è TRUE:
'F:\MYFILE' = 'f:\myfile'
I seguenti operatori rispettano il maiuscolo e il minuscolo quando confrontano due stringhe.
Operatore | Descrizione |
<< | Minore di |
<<== | Minore di o uguale a |
>> | Maggiore di |
>>== | Maggiore di o uguale a |
== | Uguale a |
<<>> | Non uguale |
Per un esempio, fare riferimento alla nota sulla pagina.
Sebbene sia un tipo di dati semplice, il valore della data utilizza una struttura non visibile che consente di ottenere valori mese, giorno e anno. Utilizzare note con punto come mostrato nell'esempio.
dayValue := $Today.day; monthValue := $Today.month; yearValue := $Today.year; (* $Today is the system date*)
Come mostrato, ogni espressione di data viene seguita da un punto e da una delle parole chiave (giorno, mese o anno) che accede al valore corrispondente della data. Nell'esempio precedente, dayValue, monthValue e yearValue sono variabili intere.
E' possibile verificare il valore del mese, del giorno o dell'anno di una variabile di data, come mostrato di seguito:
d := $Today; d.year := d.year + 1;
Nell'esempio precedente, una variabile di data d,
viene assegnata al valore della data del sistema attuale. L'anno per
d viene dunque incrementato di uno.
Developer's Toolkit tutela gli utenti dalle date non valide. Nell'esempio
seguente, la variabile della data utilizza un valore
"2/1/1999" (non "1/32/1999"):
d := {1,31,1999}: DATE; d.day := d.day + 1;
Developer's Toolkit fornisce una funzione DateDif per calcolare le differenze tra due date in mesi, giorni o anni.
DateDif richiede tre argomenti:
Ad esempio:
age := DateDif($Today,birthDate,$Years);
Developer's Toolkit fornisce varie funzionalità che consentono di gestire le espressioni di ora. Come la data, l'ora contiene più valori: ora, minuti e secondi.
E' possibile utilizzare annotazioni con punti (utilizzate anche nelle date) per accedere alle varie parti del valore ora:
currentHour := $Now.hour; currentMinute := $Now.minute; currentSecond := $Now.second; (* $Now is the system time*)
E' possibile modificare una parte specifica di una variabile ora:
t := $Now; t.hour := t.hour + 3;
La variabile ora, t, contiene il valore dell'ora a tre ore da adesso. I valori ora hanno un formato interno di 24 ore che tiene conto della mezzanotte. Il risultato dell'esempio seguente è che t contiene il valore {1,0,0}:TIME o 1.00 A.M.:
t := {23,0,0}: TIME; t.hour := t.hour + 2;
Developer's Toolkit fornisce una funzione TimeDif che calcola le differenze tra due ore. L'esempio seguente calcola le differenze tra l'ora corrente e uno startTime precedente in ore, minuti e secondi:
hoursDiff := TimeDif($Now,startTime,$Hours); minutesDiff := TimeDif($Now,startTime,$Minutes); secondsDiff := TimeDif($Now,startTime,$Seconds);
Una schiera è un elenco di valori di dati dello stesso tipo. E', inoltre, un tipo di dati strutturato. I tipi di dati strutturati consentono operazioni specifiche da eseguire sui dati.
E' possibile fare riferimento a ogni elemento singolo (valore dati) in una schiera tramite un'espressione composta dal nome della schiera seguita da un'espressione d'indice. Gli elementi in una schiera sono sequenziali e cominciano con (1). Per accedere a un elemento specifico viene utilizzato il valore o l'indice.
Nell'esempio seguente, ogni indice si trova racchiuso tra parentesi quadre:
VARIABLES name[10]: ARRAY OF String; ACTIONS name[1] := 'Tom'; name[2] := 'Dick'; name[3] := 'Harry';
In questo esempio, name è una schiera di stringhe. La variabile name può contenere fino a dieci valori di stringa in elementi numerati da 1 a 10.
Solitamente, è possibile accedere alle schiere con le variabili. L'esempio seguente mostra come la variabile intera i viene utilizzata per accedere a un dato elemento della schiera scrivendo tutti i dieci valori della schiera name su un file:
FOR i := 1 TO 10 DO FWriteLN(outputFile,name[i]); END;
Se si tenta di accedere a un elemento della schiera all'esterno dei limiti definiti della schiera, viene visualizzato un messaggio di errore al tempo di esecuzione. Gli errori verranno creati con le seguenti istruzioni:
name[-1] := 'Dick'; name[45] := 'Harry';
I valori di stringa possono essere trattati come schiere di caratteri. Al termine del seguente esempio di codice, la variabile s ha il valore G:\EADVISOR\ADVISOR\DATA.
VARIABLES s : STRING; ACTIONS s := 'F:\EADVISOR\ADVISOR\DATA'; s[1] := 'G';
Le schiere del Developer's Toolkit possono essere ridimensionate in modo dinamico. Cioè, è possibile modificare la dimensione di una schiera al tempo di esecuzione. L'istruzione SetArrayLength del Developer's Toolkit viene utilizzata per modificare la dimensione di ogni schiera. Ad esempio,
SetArrayLength(name,100);
aggiunge 90 nuovi elementi alla schiera a 10 slot dichiarata in precedenza. Non è interessata nessuna delle informazioni contenute nei primi 10 slot. E' possibile anche diminuire la dimensione di una schiera, nel modo indicato nell'esempio che segue:
SetArrayLength(name,5);
In questo caso, vengono persi tutti i valori negli slot da 6 a 10.
Come una schiera, un elenco Developer's Toolkit è un tipo di dati strutturato che contiene più valori dello stesso tipo. Inoltre, gli elenchi possono essere indicizzati con un numero intero contenuto in parentesi quadre.
In Developer's Toolkit, non sono necessari indirizzi, assegnazioni di memoria o annullamento dell'assegnazione di memoria per creare strutture di elenco collegate complete. Gli elenchi vengono dimensionati più facilmente delle schiere. Inoltre, è possibile inserire un nuovo valore nel mezzo di un elenco, processo considerato difficile in una schiera.
L'esempio seguente mostra come dichiarare e utilizzare gli elenchi:
VARIABLES name: List of String; ACTIONS ListInsert(name,'Tom'); ListInsert(name,'Dick'); ListInsert(name,'Harry');
Al termine di questo esempio di codice, name è un elenco contenente tre valori: 'Tom', 'Dick' e 'Harry'.
Ogni elenco dispone di un puntatore che indica l'elemento corrente in un elenco. Esso viene denominato puntatore elenco. Quando un nuovo elemento viene inserito in un elenco, il puntatore elenco indica l'ultimo elemento inserito. Al termine dell'esempio precedente, il puntatore corrente indica 'Harry'.
L'esempio successivo visualizza come inserire un nuovo elemento nel mezzo dell'elenco precedente.
ListSetPos(name,1); ListInsert(name,'Ellen');
Name ora contiene quattro valori: 'Tom,' 'Ellen,' 'Dick' e 'Harry'.
Nota: 'Ellen' si trova nella seconda posizione perché $ListInsert è impostato per default su $After. Il puntatore dell'elenco indica 'Ellen.' ListSetPos sposta il puntatore dell'elenco su un dato elemento.
Developer's Toolkit fornisce un numero di altre funzioni che consentono di gestire gli elenchi.
Funzione | Descrizione |
ListDelete | Rimuove un elemento da un elenco. (ListDelete(name,2) elimina 'Ellen' dall'esempio precedente). |
ListLength | Restituisce il numero di elementi nell'elenco. |
ListNext | Sposta il puntatore sull'elemento successivo dell'elenco. |
ListPrev | Sposta il puntatore sull'elemento precedente dell'elenco. |
ListPos | Restituisce l'indice dell'elemento corrente. |
ListFind | Sottopone a scansione l'elenco per un valore dato e restituisce TRUE se quel valore viene trovato. Il puntatore elenco viene spostato sul valore corrispondente. Ad esempio, ListFind(name,'Dick') restituisce TRUE e sposta il puntatore corrente su 'Dick'. |
ListSort | Ordina l'elenco in modo ascendente. |
ListPush | Aggiunge un nuovo elemento all'inizio dell'elenco. |
ListPop | Rimuove il primo elemento nell'elenco e lo restituisce. |
Poiché gli elenchi possono essere indicizzati come schiere, l'istruzione,
s:= nome[1];
assegna il valore 'Tom' alla variabile s.
Developer's Toolkit fornisce uno speciale costrutto di loop per gli elenchi. L'istruzione FOR viene utilizzata per ripetere i valori in un elenco. Le istruzioni nidificate nel blocco FOR...END vengono eseguite una volta per ogni elemento nell'elenco. Il puntatore elenco indica sempre il primo numero nell'elenco. La voce corrente nell'elenco viene incrementata di uno ogni volta che attraversa il loop.
L'esempio seguente illustra l'utilizzo dell'istruzione FOR:
FOR nome DO FWriteLN(outputFile,name[$Current]); END;
L'esempio precedente illustra anche l'utilizzo di una costante speciale denominata $Current. Questa costante può essere utilizzata per accedere agli elementi correnti di un elenco. Altre costanti di elenco sono:
Queste costanti vengono utilizzate per accedere, rispettivamente, al primo e all'ultimo elemento dell'elenco. Ad esempio, le righe
FWriteLN(outputFile,name[$First]); FWriteLN(outputFile,name[$Last]);
scrivono "Tom" e "Harry" sul file di output.
Molte istruzioni Developer's Toolkit supportano il "troncamento" automatico dell'elenco. Nel troncamento di elenco, le istruzioni accettano una voce singola di un tipo fornito o un elenco di voci.
Se si passa un elenco, l'istruzione viene applicata a tutti gli elementi dell'elenco. A ciò fa riferimento anche un'istruzione con un loop FOR implicito.
WinWriteLN è un esempio di una di queste istruzioni:
WinWriteLN(myWindow,name);
Tramite quest'istruzione ogni valore della variabile name viene scritto sulla finestra a cui si fa riferimento con myWindow. Molte delle istruzioni Window e SQL supportano i troncamenti di elenco.
Diversamente dalle schiere e dagli elenchi, che possono contenere più valori dello stesso tipo, un record può contenere più valori di tipo diverso.
La dichiarazione di una variabile tipo di record è un processo a due fasi:
Nota: Quando si dichiara una variabile tipo di record, si estende il linguaggio del Developer's Toolkit con il proprio tipo di dati.
Esaminare il seguente codice di esempio:
TYPES EmployeeRecord IS RECORD first_name, last_name: String; age : Integer; salary: Real; married : Boolean; hireDate : Date; startTime, stopTime : Time; END; VARIABLES employee: EmployeeRecord;
L'esempio precedente dichiara un nuovo tipo di record denominato EmployeeRecord. Questo record contiene otto campi, ognuno dei quali è un tipo di dati semplice.
Come per la data e per l'ora, è possibile utilizzare una annotazione con punti
<variabile>.<campo> per fare riferimento a ogni campo in un record.
Ad esempio, le righe seguenti possono essere utilizzate per
inizializzare la variabile employee dichiarata in precedenza:
employee.first_name := 'Calbert'; employee.last_name := 'Chaney'; employee.age := 21; employee.salary := 2500000.0; employee.married := FALSE; employee.hireDate := {2,15,1993}: DATE; employee.startTime := {8,30,0}: TIME; employee.stopTime := {17,30,0}: TIME;
Le variabili dello stesso tipo di record sono compatibili all'assegnazione. Se si è dichiarata una variabile, employee2, di tipo EmployeeRecord, l'aggiunta dell'istruzione seguente risulta in tutti i campi della variabile employee copiata nella variabile employee2:
employee2 := employee;
E' inoltre possibile creare elenchi e schiere di record:
employeeList: Elenco di EmployeeRecord;
Una dichiarazione di record può contenere schiere, elenchi e altri record. Ad esempio, la dichiarazione EmployeeRecord può essere modificata nel modo seguente:
EmployeeRecord IS RECORD first_name, last_name: String; age : Integer; salary: Real; married : Boolean; hireDate : Date; startTime, stopTime : Time; manages : List of String; END;
E' necessario utilizzare il valore manages per tenere traccia dei nomi degli employee gestiti da un employee specificato.
Developer's Toolkit fornisce varie istruzioni che eseguono immissioni ed emissioni del record del database.
Ad esempio, l'istruzione seguente può essere utilizzata per caricare una riga dalla tabella EMPLOYEES nella variabile employee precedentemente utilizzata:
SQLSelectInto('SELECT * FROM EMPLOYEES WHERE EMPLOYEE_ID=105',employee);
Developer's Toolkit:
In modo simile, Developer's Toolkit consente di definire i campi in un record su un modulo. Quando un utente preme il tasto INVIO dopo aver completato un modulo, le informazioni sullo schermo vengono salvate nei campi corrispondenti nel record che può essere esaminato e gestito.
In aggiunta ai record, è possibile creare altri tipi definiti dall'utente. Un tipo definito dall'utente è un tipo di dati che viene definito in un programma e solitamente consiste in una combinazione di tipi di dati. I tipi definiti dall'utente vengono spesso utilizzati per creare strutture di dati.
A ogni combinazione di elenchi, schiere, record e tipi di dati semplici, utilizzati in una dichiarazione di variabile, può essere assegnato un nome riutilizzabile in una dichiarazione del tipo di dati. Ad esempio, è possibile definire un nuovo tipo di dati, come mostrato nell'esempio seguente:
TYPES StringList = LIST OF STRING;
Una volta dichiarato il tipo, è possibile utilizzare StringList per dichiarare le variabili invece di LIST OF STRING.
Le regole seguenti si riferiscono alla compatibilità di assegnazione di tipi di dati strutturati e definiti dall'utente.
Quando si controlla la compatibilità di assegnazione tra due espressioni o variabili, Developer's Toolkit verifica solo se i nomi dei tipi corrispondono. Non verifica se le dichiarazioni dei record sono identiche.
L'inizializzazione di una variabile dichiarata indica che a essa viene assegnato un valore iniziale. Developer's Toolkit consente di inizializzare le variabili quando vengono dichiarate, come mostrato nell'esempio seguente:
VARIABLES i {1} : INTEGER; s {'F:\MYFILE'} : STRING; d {2,11,1956} : DATE; l {'Tom','Dick','Harry'} : LIST OF STRING; r {'Steve','Wantz',32,189000.00,TRUE, {3,30,1986} : DATE, {6,30,0} : TIME, {4,30,0} : TIME, {'Tom','Dick','Harry'} : LIST OF STRING : EmployeeRecord;
In generale, un nome variabile è seguito da:
E' inoltre possibile inizializzare variabili di tipi strutturati come elenchi, schiere e record allo stesso modo.
Notare che il valore d'inizializzazione viene associato alla variabile e non al tipo. Così nella riga,
VARIABLES i, j {27}: INTEGER;
solo la variabile j viene inizializzata; la variabile i non viene inizializzata. Ogni variabile deve essere inizializzata separatamente.
Tutte le variabili non inizializzate che non hanno un valore in Developer's Toolkit cominciano con un valore $Unknown. Diversamente da C e da Pascal, dove le variabili iniziano con valori casuali.
L'inizializzazione di tutte le variabili su zero, uno o una stringa vuota protegge dagli errori comuni. Ad esempio, se nel seguente:
newSalary := oldSalary*1.05;
la variabile oldSalary non è stata inizializzata su qualcosa di diverso da $Unknown, si verifica un errore al tempo di esecuzione perché 1.05 viene moltiplicato per $Unknown.
Manuale per la programmazione Tivoli Service Desk 6.0 Developer's Toolkit Script