info@playoptions.it Chiedi un consulto
+39 0425 792923 Lunedì - Venerdì, 9.00 - 18.00
Contattaci
toggle menu
info@playoptions.it Chiedi un consulto
+39 0425 792923 Lunedì - Venerdì, 9.00 - 18.00
Contattaci
toggle menu
  1. #1
    L'avatar di Francario Massimiliano
    Data Registrazione
    Jul 2008
    Messaggi
    772

    Post Sintassi e struttura del linguaggio Pascal

    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:
    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. 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 (,).
    Ultima modifica di Francario Massimiliano; 14-01-13 alle 15:43

Permessi di Scrittura

  • Tu non puoi inviare nuove discussioni
  • Tu non puoi inviare risposte
  • Tu non puoi inviare allegati
  • Tu non puoi modificare i tuoi messaggi
  •  
Contattaci

Chiama gli esperti
+39 0425 792923

Chiamaci
Email

Richiedi informazioni via E-MAIL
info@playoptions.it

Scrivici
Nostri Uffici

Vieni a trovarci
45100 Rovigo

Contattaci

Serve Aiuto?

Contattaci per maggiori informazioni.

Denis MorettoSpecialista Finanziario
Contattaci