Sintassi e struttura del linguaggio Basic

[Francario Massimiliano]

Introduzione
FiutoPRO Scripting System (in breve FPSS) è in grado di eseguire script scritti in linguaggio Basic. La sintassi del linguaggio Basic supporta:

• dichiarazioni sub .. end e function .. end
• direttive byref e dim
• istruzioni if .. then .. else .. end
• istruzioni for .. to .. step .. next
• istruzioni do .. while .. loop e do .. loop .. while
• istruzioni do .. until .. loop e do .. loop .. until
• operatori ^, *, /, and, +, -, or, <>, >=, <=, =, >, <, div, mod, xor, shl, shr
• blocchi try .. except e try .. finally
• blocchi try .. catch .. end try e try .. finally .. end try
• istruzioni select case .. end select
• array ed array inizializzati
• istruzione exit
• accesso alle proprietà ed ai metodi di tutti gli oggetti che compongono la strategia di FiutoPRO.

Struttura degli script
La struttura degli script è costituita da due blocchi principali:

1. dichiarazione di funzioni e procedure
2. blocco principale

Entrambi questi blocchi sono opzionali, ma in uno script almeno uno dei due dovrebbe sempre essere presente. Ecco alcuni esempi.

SCRIPT 1:

SUB DoSomething
    CallSomething
END SUB
CallSomethingElse

SCRIPT 2:

CallSomethingElse

SCRIPT 3:

FUNCTION MyFunction
    MyFunction = "Ok!"
END FUNCTION

E’ anche possibile scrivere più istruzioni su una singola riga, separandole tra loro usando il carattere “:”.


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 il simbolo "=". Alcuni esempi:

MyVar = 2
Button.Caption = "This " + "is ok."

L’istruzione new
FPSS supporta l’istruzione "new" per creare nuovi oggetti. L’istruzione new specifica la classe di appartenenza del nuovo oggetto che si sta creando. Ogni oggetto creato all’interno di un progetto di FPSS deve essere anche “distrutto” prima della conclusione dell’esecuzione dello script stesso, usando la funzione Free. Ecco alcuni esempi:

MyLabel = new TLabel(Form1)
MyFont = new TFont
MyLabel.Free
MyFont.Free

Se previsto, è possibile anche fornire dei parametri durante la costruzione di nuovi oggetti tramite l’istruzione new, come nell’esempio precedente dove il nuovo oggetto TLabel viene creato usando come parametro l’oggetto Form1.


Stringhe di testo
Le stringhe (sequenze di caratteri) sono dichiarate in basic usando il carettere ("). Alcuni esempi:

A = "This is a text"
Str = "Text "+"concat"

Commenti
FPSS supporta l’inserimento di commenti all’interno degli script. E’ possibile utilizzare il carattere \' oppure la direttiva REM. I commenti terminano sempre alla fine della riga. Esempi:

\' This is a comment before ShowMessage
ShowMessage("Ok")
REM 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 DIM ed il nome. Ecco alcuni esempi:
SCRIPT 1:

SUB Msg
    DIM S
    S = "Hello world!"
    ShowMessage(S)
END SUB

SCRIPT 2:

DIM A
A = 0
A = A+1
ShowMessage(A)

Le variabili globali possono essere dichiarate anche come private o pubbliche. Una variabile globale è una variabile dichiarata nello script non all’interno di funzioni o procedure. Una variabile globale dichiarata come privata è visibile soltanto all’interno dello script dove è dichiarata. Una variabile globale dichiarata come pubblica è visibile all’interno di tutti gli script che compongono un progetto. Esempi:
SCRIPT 2:

PRIVATE A
PUBLIC B
B = 0
A = B + 1
ShowMessage(A)

Le variabili dichiarate tramite la direttiva DIM sono considerate come pubbliche. Le variabili possono anche essere inizializzate in fase di dichiarazione, usando la sintassi degli esempi che seguono:

DIM A = "Hello world"
DIM B As Integer = 5

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..end e if...then...else..end if. Se l’espressione compresa tra if e then è vera, allora vengono eseguite le istruzioni comprese tra then ed end if o tra then ed else. Se l’espressione compresa tra if e then è falsa ed è stata usata la sintassi con else, allora le istruzioni comprese tra else ed end if vengono eseguite. Ecco alcuni esempi:

IF J <> 0 THEN Result = I/J END IF
IF J = 0 THEN Exit ELSE Result = I/J END IF
IF J <> 0 THEN
    Result = I/J
    Count = Count + 1
ELSE
    Done = True
END IF

Se l’istruzione if termina su una stessa riga, allora non è necessario chiudere l’istruzione con end if:

IF J <> 0 THEN Result = I/J
IF J = 0 THEN Exit ELSE Result = I/J

L’istruzione While
L’istruzione while è usata per ripetere un blocco di istruzioni, finché una condizione di controllo (espressione) viene valutata come vera. La condizione di controllo viene valuta prima di iniziare ad eseguire il blocco di istruzioni. Di conseguenza, se la condizione di controllo viene valutata come falsa alla prima iterazione, il blocco di istruzioni non viene mai eseguito. L’istruzione while esegue continuamente il blocco di istruzioni, verificando l’espressione della condizione di controllo prima di ogni iterazione. Finchè l’espressione della condizione di controllo viene valutata come vera, l’esecuzione continua. Alcuni esempi:

WHILE (Data[I] <> X) I = I + 1 END WHILE
WHILE (I > 0)
    IF Odd(I) THEN Z = Z * X END IF
    X = Sqr(X)
END WHILE
WHILE (not Eof(InputFile))
    Readln(InputFile, Line)
    Process(Line)
END WHILE

Le istruzioni di ciclo
FPSS supporta le istruzioni di ciclo. Le sintassi riconosciute sono le seguenti:

DO WHILE expr statements LOOP
DO UNTIL expr statements LOOP
DO statements LOOP WHILE expr
DO statement LOOP UNTIL expr

Le istruzioni (statements) saranno eseguite fintanto che (WHILE) l’espressione (expr) è vera, oppure fino a quando (UNTIL) l’espressione (expr) non diventa vera. Se l’espressione è scritta prima delle istruzioni, la condizione di controllo viene valutata prima dell’esecuzione delle istruzioni, altrimenti la condizione di controllo viene valutata dopo l’iterazione del ciclo. Esempi:

DO
    K = I mod J
    I = J
    J = K
LOOP UNTIL J = 0
DO UNTIL I >= 0
    Write("Enter a value (0..9): ")
    Readln(I)
LOOP
DO
    K = I mod J
    I = J
    J = K
LOOP WHILE J <> 0
DO WHILE I < 0
    Write("Enter a value (0..9): ")
    Readln(I)
LOOP

L’istruzione For
FPSS supporta l’istruzione for con la seguente sintassi:

FOR counter = initialValue TO finalValue STEP stepValue 
    statements 
NEXT

L’istruzione for imposta il contatore (counter) al valore iniziale (initialValue), ripete l’esecuzione delle istruzioni (statements) fino all’istruzione NEXT, ed incrementa il valore del contatore (counter) di stepValue, finché il contatore non raggiunge il valore finale (finalValue). La sezione Step è opzionale: se omessa stepValue è paria 1. Esempi:
SCRIPT 1:

FOR c = 1 TO 10 STEP 2
    a = a + c
NEXT

SCRIPT 2:

FOR I = a TO b
    j = i ^ 2
    sum = sum + j
NEXT

L’istruzione Select Case
FPSS supporta le istruzioni support select con la seguente sintassi:

SELECT CASE selectorExpression
    CASE caseexpr1
        statement1
    …
    CASE caseexprn
        statementn
    CASE ELSE
        elsestatement
END SELECT

Se l’espressione di selezione (selectorExpression) è uguale ad una delle espressioni di controllo (caseexprn), il rispettivo blocco di istruzioni (statements) viene eseguito, altrimenti, il blocco di istruzioni elsestatement viene eseguito. La parte else dell’istruzione può essere omessa. Esempi:

SELECT CASE uppercase(Fruit)
    CASE "lime" ShowMessage("green")
    CASE "orange"
        ShowMessage("orange")
    CASE "apple" ShowMessage("red")
    CASE ELSE
        ShowMessage("black")
END SELECT

Dichiarazione delle funzioni e delle procedure
Una funzione (function) è un blocco di istruzioni che restituisce un risultato. Una procedura (sub) è un blocco di istruzioni che non restituisce alcun risultato. Per restituire il risultato in una funziona, è necessario assegnare il valore alla variabile implicita individuata dal nome stesso della funzione, oppure usare l’istruzione Return. Sia le funzioni che le procedure possono accettare dei valori in ingresso, chiamati parametri. I parametri vengono normalmente inviati alle funzioni ed alle procedure come valori, mentre per poterli inviare per riferimento, è necessario usare la direttiva ByRef nella dichiarazione del parametro della funzione o procedura. Alcuni esempi:

SUB HelloWord
    ShowMessage("Hello world!")
END SUB
SUB UpcaseMessage(Msg)
    ShowMessage(Uppercase(Msg))
END SUB
FUNCTION TodayAsString
    TodayAsString = DateToStr(Date)
END FUNCTION
FUNCTION Max(A,B)
    IF A>B THEN
    MAX = A
        ELSE
        MAX = B
    END IF
END FUNCTION
SUB SwapValues(BYREF A, B)
    DIM TEMP
    TEMP = A
    A = B
    B = TEMP
END SUB

Funzioni e procedure possono essere dichiarate come private o pubbliche, esattamente come avviene per le variabili, con lo stesso significato.

PRIVATE SUB Hello
END SUB
PUBLIC FUNCTION Hello
END FUNCTION

Funzioni e procedure, se non specificato, sono considerate come pubbliche. Funzioni e procedure private non sono accessibili da altri script. E’ possibile utilizzare l’istruzione Return per uscire dalle procedure e dalle funzioni. Esempi:

SUB UpcaseMessage(Msg)
    ShowMessage(Uppercase(Msg))
    Return
    \'This line will be never reached
    ShowMessage("never displayed")
END SUB
FUNCTION TodayAsString
    Return DateToStr(Date)
END FUNCTION

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:

Public Function Test()
    Test = 1
End Function

SCRIPT 2 - Unit2:

USES Unit1
DIM t
t = Test()

E’ possibile includere più files contemporaneamente, separando i nomi con il carattere virgola (,).