Introduzione
FiutoPRO Scripting System (in breve FPSS) è in grado di eseguire script scritti in linguaggio Pascal. La sintassi del linguaggio Pascal supporta:
- dichiarazioni di procedure e function
- blocchi di istruzioni delimitati da begin e end
- istruzioni if .. then .. else
- istruzioni for .. to .. do .. step
- istruzioni while .. do
- istruzioni repeat .. until
- operatori ^, *, /, and, +, -, or, <>, >=, <=, =, >, <, div, mod, xor, shl, shr
- blocchi try .. except e try .. finally
- istruzioni case
- array ed array inizializzati
- istruzione exit
- accesso alle proprietà ed ai metodi di tutti gli oggetti che compongono la strategia di FiutoPRO.
La struttura dello script
La struttura degli script è costituita da due blocchi principali:
- dichiarazione di funzioni e procedure
- blocco principale
Entrambi questi blocchi sono opzionali, ma in uno script almeno uno dei due dovrebbe sempre essere presente. Il blocco principale non deve essere necessariamente definito tramite le istruzioni begin ed end, e può essere costituito anche da una sola riga. Ecco alcuni esempi.
SCRIPT 1:
procedure DoSomething;
begin
CallSomething;
end;
begin
CallSomethingElse;
end;
SCRIPT 2:
begin
CallSomethingElse;
end;
SCRIPT 3:
function MyFunction;
begin
result := 'Ok!';
end;
SCRIPT 4:
CallSomethingElse;
Le istruzioni devono essere terminate dal carattere ";". I blocchi Begin..end sono permessi per poter raggruppare più istruzioni.
Identificatori
I nomi degli identificatori negli script (nomi delle variabili, delle funzioni, delle procedure, ecc.) devono seguire le più comuni regole: devono iniziare con un carattere alfabetico (a..z o A..Z), oppure '_', seguito da un qualsiasi numero di caratteri alfanumerici o '_'. I nomi degli identificatori non possono contenere altri caratteri o spazi. Ecco alcuni esempi di nomi di identificatori validi:
VarName
_Some
V1A2
_____Some____
Ecco invece dei nomi di identificatori non validi:
2Var
My Name
Some-more
This,is,not,valid
L’istruzione di assegnamento
Le istruzioni di assegnamento (assegnare un valore o il risultato di una espressione ad una variabile o una proprietà di un oggetto) sono realizzate usando ":=". Alcuni esempi:
MyVar := 2;
Button.Caption := ' This ' + ' is ok. ';
Le stringhe di caratteri
Le stringhe (sequenze di caratteri) sono dichiarate in pascal usando il carettere ('). Il carattere (") non è usato. E’ inoltre possibile utilizzare la notazione #nn per definire un carattere all’interno di una stringa. Non è necessario usare l’operatore '+' per aggiungere caratteri ad una stringa. Alcuni esempi:
A := 'This is a text';
Str := 'Text '+'concat';
B := 'String with CR and LF char at the end'#13#10;
C := 'String with '#33#34' characters in the middle';
Commenti
FPSS supporta l’inserimento di commenti all’interno degli script. I commenti vengono individuati dai caratteri //, per un commento che termina alla fine della riga, oppure con le coppie (* e *) o { e } per dei commenti multi-linea. Alcuni esempi:
//This is a comment before ShowMessage
ShowMessage('Ok');
(* This is another comment *)
ShowMessage('More ok!');
{ And this is a comment
with two lines }
ShowMessage('End of okays');
Variabili
Negli script non è necessario dichiarare il tipo delle variabili, che pertanto si possono dichiarare usando solo la direttiva var ed il nome. Ecco alcuni esempi:
SCRIPT 1:
procedure Msg;
var S;
begin
S := 'Hello world!';
ShowMessage(S);
end;
SCRIPT 2:
var A;
begin
A := 0;
A := A + 1;
end;
SCRIPT 3:
var S: string;
begin
S := 'Hello World!';
ShowMessage(S);
end;
Indici
Stringhe ed array possono essere indicizzati usando i caratteri "[" e "]". Per esempio, se Str è una variabile che contiene una stringa di testo, l’espressione Str[3] restituisce il terzo carattere della stringa Str, mentre Str[I + 1] restituisce il carattere immediatamente successivo a quello indicizzato da I. Altri esempi:
MyChar := MyStr[2];
MyStr[1] := 'A';
MyArray[1, 2] := 1530;
Lines.Strings[2] := 'Some text';
Arrays
FPSS supporta la costruzione di array sia ad una singola dimensione che multi-dimensionali. Per costruire un array è necessario utilizzare i caratteri "[" e "]". La costruzione di array multi-dimensionali richiede di utilizzare la ricorsione. Gli array possono essere utilizzati tramite indici. Se l’array è multi-dimensionale, i diversi indici (uno per ogni dimensione) devono essere separati tramite il carattere ",". Gli array sono sempre indicizzati con base 0, cioè l’indice 0 permette di accedere al primo elemento dell’array. Alcuni esempi:
NewArray := [ 2,4,6,8 ];
Num := NewArray[1]; //Num receives "4"
MultiArray := [['green', 'red', 'blue'], ['apple', 'orange', 'lemon']];
Str := MultiArray[0, 2]; //Str receives 'blue'
MultiArray[1, 1] := 'new orange';
L’istruzione If
Esistono due sintassi per l’istruzione if: if...then e if...then...else. Se l’espressione compresa tra if e then è valutata come vera, allora l’istruzione o il blocco di istruzioni che seguono then viene eseguita. Se esiste la parte else e l’espressione compresa tra if e then è valutata come falsa, allora l’istruzione o blocco di istruzioni che segue else viene eseguita. Esempi:
if J <> 0 then Result := I/J;
if J = 0 then Exit else Result := I/J;
if J <> 0 then
begin
Result := I/J;
Count := Count + 1;
end
else
Done := True;
ATTENZIONE: l’istruzione immediatamente precedente else non deve mai essere terminata dal carattere ";".
L’istruzione While
L’istruzione while è usata per ripetere un’istruzione o un blocco di istruzioni fintanto che la condizione di controllo è vera. La condizione di controllo viene valutata prima di eseguire le istruzioni, quindi, se è falsa alla prima iterazione, le istruzioni non vengono mai eseguite. L’istruzione while esegue le istruzioni ripetutamente, verificando la condizione di controllo prima di ogni iterazione. Finché la condizione di controllo è vera l’esecuzione continua. Esempi:
while Data[I] <> X do I := I + 1;
while I > 0 do
begin
if Odd(I) then Z := Z * X;
I := I div 2;
X := Sqr(X);
end;
while not Eof(InputFile) do
begin
Readln(InputFile, Line);
Process(Line);
end;
L’istruzione Repeat
La sintassi dell’istruzione repeat è:
repeat
statement1;
...;
statementn;
until expression
dove expression ritorna un valore boolean vero/falso. L’istruzione repeat esegue le istruzioni continuamente, verificando la condizione di controllo dopo ogni iterazione. Quando la condizione di controllo è vera, l’istruzione repeat termina. La sequenza di istruzioni è sempre eseguita almeno una volta perchè la condizione di controllo viene valutata per la prima volta soltanto al termine della prima iterazione. Esempi:
repeat
K := I mod J;
I := J;
J := K;
until J = 0;
repeat
Write('Enter a value (0..9): ');
Readln(I);
until (I >= 0) and (I <= 9);
L’istruzione For
FPSS supporta l’istruzione for con la seguente sintassi:
for counter := initialValue to finalValue do
statement
L’istruzione for imposta la variabile di controllo (counter) al valore iniziale (initialValue), ripete l’esecuzione del blocco di istruzioni (statement) ed incrementa il valore della variabile di controllo fino a quando non raggiunge il valore finale (finalValue). Esempi:
SCRIPT 1:for c := 1 to 10 do
a := a + c;
SCRIPT 2:for i := a to b do
begin
j := i^2;
sum := sum + j;
end;
L’istruzione Case
FPSS supporta l’istruzione case con la seguente sintassi:
case selectorExpression of
caseexpr1: statement1;
...
caseexprn: statementn;
else
elsestatement;
end
Se l’espressione di selezione (selectorExpression) è uguale al risultato di una delle espressioni caseexprn, il rispettivo blocco di istruzioni viene eseguito, altrimenti, viene eseguito il blocco di istruzioni elsestatement. La parte else dell’istruzione case è opzionale. E’ possibile utilizzare espressioni che ritornano un qualsiasi tipo di dato come espressione di selezione. Esempio:
case uppercase(Fruit) of
'lime': ShowMessage('green');
'orange': ShowMessage('orange');
'apple': ShowMessage('red');
else
ShowMessage('black');
end;
Dichiarazione di funzioni e procedure
La dichiarazione delle funzioni e delle procedure segue le regole di base del Pascal/Object Pascal/Delphi, con la differenza che non è necessario dichiarare il tipo di dato utilizzato dai parametri. Nelle funzioni, per restituire il risultato è necessario utilizzare la variabile implicita result. E’ inoltre possibile utilizzare parametri per riferimento. Alcuni esempi:
procedure HelloWord;
begin
ShowMessage('Hello world!');
end;
procedure UpcaseMessage(Msg);
begin
ShowMessage(Uppercase(Msg));
end;
function TodayAsString;
begin
result := DateToStr(Date);
end;
function Max(A,B);
begin
if A > B then
result := A
else
result := B;
end;
procedure SwapValues(var A, B);
Var Temp;
begin
Temp := A;
A := B;
B := Temp;
end;
Inclusione di altri file sorgenti
Nei progetti di FPSS è possibile fare riferimento agli oggetti, funzioni e classi con visibilità pubblica definiti in altri file di script. Il meccanismo di inclusione di altri file sorgenti all’interno prevede l’utilizzo della clausola USES. Ecco un esempio:
SCRIPT 1 - Unit1:
function Test;
begin
Result := 1;
end;
SCRIPT 2 - Unit2:
USES Unit1
Var t;
t := Test();
E’ possibile includere più files contemporaneamente, separando i nomi con il carattere virgola (,).