Pragmas condizionali

Panoramica

Il linguaggio ExST (Extended ST) supporta numerose istruzioni Pragma condizionali, che influiscono sulla generazione del codice durante il processo di precompilazione e compilazione.

NOTA: Non utilizzare pragma condizionali nella parte di dichiarazione. Non vengono considerati.

Il codice di implementazione che verrà osservato per la compilazione può dipendere dalle seguenti condizioni:

  • È stato dichiarato un certo tipo di dati o variabile?

  • Un tipo o una variabile hanno un determinato attributo?

  • Una variabile ha un determinato tipo di dati?

  • Sono disponibili un POU o un task specifico come parte della struttura di chiamata, ecc...

NOTA: Una POU o un GVL dichiarati nella Struttura POU non possono utilizzare un {define...} dichiarato in un'applicazione. Le definizioni nelle applicazioni influenzeranno solo le interfacce inserite sotto la rispettiva applicazione.

{define identifier string}

Durante la pre-elaborazione, tutte le istanze successive dell'identificativo verranno sostituite con la sequenza data di token se la stringa di token non è vuota (consentita e definita correttamente). L'identificativo rimane definito e compreso nell'ambito fino alla fine dell'oggetto o finché non viene annullata la definizione in una direttiva {undefine} . Utilizzato per la compilazione condizionale

{undefine identifier}

La definizione del preprocessore di identifier (per {define}, vedere la prima riga di questa tabella) verrà rimossa e l'identificativo pertanto non è definito. Se l'identificativo specificato non è correntemente definito, questa istruzione pragma verrà ignorata.

{IF expr}

...

{ELSIF expr}

...

{ELSE}

...

{END_IF}

Queste sono istruzioni pragmas per la compilazione condizionale. Le espressioni specificate exprs devono essere costanti al momento della compilazione; vengono valutate nell'ordine in cui compaiono finché una delle espressioni viene valutata a un valore diverso da zero. Il testo associato alla direttiva viene pre-elaborato e compilato normalmente; gli altri vengono ignorati. L'ordine delle sessioni è specificato; tuttavia, le sezioni elsif e else sono opzionali e le sezioni elsif possono, arbitrariamente, comparire con maggior frequenza.

Nell'ambito della costante expr, è possibile utilizzare diversi operatori di compilazione condizionali.

<expr>

Nell'ambito dell'espressione costante expr di una compilazione condizionale pragma ({if} o {elsif}) (vedere la tabella precedente), si possono utilizzare vari operatori. Questi operatori non possono essere indefiniti o ridefiniti tramite {undefine} o {define}, rispettivamente.

È inoltre possibile utilizzare queste espressioni oltre alla definizione completata da {define} nel campo di testo Definizioni del compilatore: nella finestra di dialogo Proprietà di un oggetto (Visualizza > Proprietà > Compila).

Operatori di compilazione condizionali

Sono supportati i seguenti operatori:

defined (identifier)

Questo operatore definisce che l'espressione assuma il valore TRUE non appena è stato definito l'identifier con un'istruzione {define} se la definizione non è stata successivamente annullata da un'istruzione {undefine} . Altrimenti il suo valore è FALSE.

Esempio su defined (identifier):

Precondizione: esistono 2 applicazioni App1 e App2. L'identificatore pdef1 è definito in App2, ma non in App1. 

{IF defined (pdef1)}
    (* this code is processed in App1 *)
    {info 'pdef1 defined'}
    hugo := hugo + SINT#1;
{ELSE}
    (* the following code is only processed in application App2 *)
    {info 'pdef1 not defined'}
    hugo := hugo - SINT#1;
{END_IF}

Inoltre, è incluso un esempio relativo a un'istruzione messaggio pragma:

Solo le informazioni pdef1 defined verranno visualizzate nella vista Messaggi durante la compilazione dell'applicazione perché pdef1 è definito. Il messaggio pdef1 non definito verrà visualizzato quando pdef1 non è definito.

defined (variable:variable)

Quando è applicato a una variabile, il suo valore è TRUE se questa particolare variabile viene dichiarata nell'ambito corrente. Altrimenti è FALSE.

Esempio su defined (variable:variable):

Precondizione: esistono 2 applicazioni App1 e App2. La variabile g_bTest viene dichiarata in App2, ma non in App1. 

{IF defined (variable:g_bTest)}
(* the following code is only processed in application App2 *)
g bTest := x > 300;
{END_IF}

defined (type:identifier)

Se applicato a un identificativo del tipo, il suo valore è TRUE se viene dichiarato un tipo con quel dato nome. Altrimenti è FALSE.

Esempio su defined (type:identifier) :

Precondizione: esistono 2 applicazioni App1 e App2. Il tipo di dati DUT è definito in App2, ma non in App1. 

{IF defined (type:DUT)}
(* the following code is only processed in application App1 *)
bDutDefined := TRUE;
{END_IF}

defined (pou:pou-name)

Se applicato a un nome POU, il suo valore è TRUE se è definito un POU o un'azione con quel nome di POU specifico. Altrimenti è FALSE.

Esempio su defined (pou: pou-name):

Precondizione: esistono 2 applicazioni App1 e App2. La POU CheckBounds è disponibile in App2, ma non in App1. 

{IF defined (pou:CheckBounds)}
(* the following code is only processed in application App1 *)
arrTest[CheckBounds(0,i,10)] := arrTest[CheckBounds(0,i,10)] + 1;
{ELSE}
(* the following code is only processed in application App2 *)
arrTest[i] := arrTest[i]+1;
{END_IF}

hasattribute (pou: pou-name, attribute)

Se applicato a una POU, il suo valore è TRUE se questo specifico attribute è specificato nella prima riga della parte di dichiarazione della POU.

Esempio su hasattribute (pou: pou-name, attribute):

Precondizione: esistono 2 applicazioni App1 e App2. La funzione fun1 è definita in App1 e App2, ma in App1 ha un attributo vision:

Definizione di fun1 in App1: 

{attribute 'vision'}
FUNCTION fun1 : INT
VAR_INPUT
i : INT;
END_VAR
VAR
END_VAR

Definizione di fun1 in App2: 

FUNCTION fun1 : INT
VAR_INPUT
i : INT;
END_VAR
VAR
END_VAR

Istruzione Pragma 

{IF hasattribute (pou: fun1, 'vision')}
(* the following code is only processed in application App1 *)
ergvar := fun1 ivar);
{END_IF}

hasattribute (variable: variable, attribute)

Se applicato a variable, il suo valore è TRUE se questo particolare attributo viene specificato tramite l'istruzione {attribute} in una riga prima della dichiarazione della variabile.

Esempio su hasattribute (variable: variable, attribute):

Precondizione: esistono 2 applicazioni App1 e App2. La variabile g_globalInt è utilizzata in App1 e App2, ma in App1 ha un attributo DoCount:

Dichiarazione di g_globalInt in App1 

VAR_GLOBAL
{attribute 'DoCount'}
g_globalInt : INT;
g_multiType : STRING;
END_VAR

Dichiarazione di g_globalInt in App2 

VAR_GLOBAL
g_globalInt : INT;
g_multiType : STRING;
END_VAR

Istruzione Pragma 

{IF hasattribute (variable: g_globalInt, 'DoCount')}
(* the following code line will only be processed in App1, because there variable g_globalInt has got the attribute 'DoCount' *)
g_globalInt := g_globalInt + 1;
{END_IF}

hastype (variable:variable, type-spec)

Se applicato a variable, il suo valore è TRUE se questa particolare variabile ha specificato come tipo type-spec. Altrimenti è FALSE.

Tipi di dati type-spec disponibili

  • BOOL

  • BYTE

  • DATE

  • DATE_AND_TIME

  • DINT

  • DWORD

  • INT

  • LDATE

  • LDATE_AND_TIME (LDT)

  • LINT

  • LREAL

  • LTIME

  • LTIME_OF_DAY (LTOD)

  • LWORD

  • REAL

  • SINT

  • STRING

  • TIME

  • TIME_OF_DAY (TOD)

  • UDINT

  • UINT

  • ULINT

  • USINT

  • WORD

  • WSTRING

Esempio relativo a all'operatore hastype (variable: variable, type-spec):

Precondizione: esistono 2 applicazioni App1 e App2. La variabile g_multitype è dichiarata in App1 con il tipo LREAL e nell'applicazione App2 con il tipo STRING: 

{IF (hastype (variable: g_multitype, LREAL))}
(* the following code line will be processed only in App1 *)
g_multitype := (0.9 + g_multitype) * 1.1;
{ELSIF (hastype (variable: g_multitype, STRING))}
(* the following code line will be processed only in App2 *)
g_multitype := 'this is a multitalent';
{END_IF}

hasvalue (define-ident, char-string)

Se la definizione (define-ident) è definita e ha il valore specificato (char-string), il suo valore è TRUE. Altrimenti è FALSE.

Esempio su hasvalue (define-ident, char-string):

Precondizione: il test della variabile viene utilizzato nelle applicazioni App1 e App2. Ottiene valore 1 in App1 e valore 2 in App2: 

{IF hasvalue(test,'1')}
(* the following code line will be processed in App1, because there variable test has value 1 *)
x := x + 1;
{ELSIF hasvalue(test,'2')}
(* the following code line will be processed in App1, because there variable test has value 2 *)
x := x + 2;
{END_IF}

hasconstantvalue(<variable>, <literal expression>)

Utilizzare questo operatore per richiedere il valore dichiarato di una costante.

Esempio: 

{IF hasconstantvalue(test,1)}
(*  the following code is only processed in App1 *)
    x := x + 1;
{ELSIF hasconstantvalue(test,2)}
(*  the following code is only processed in App2 *)
    x := x + 2;
{END_IF}

NOT operator

L'espressione assume il valore TRUE quando il valore inverso di operator è TRUE. operator può essere uno degli operatori descritti in questo capitolo.

Esempio su NOT operator:

Precondizione: esistono 2 applicazioni App1 e App2. La POU PLC_PRG1 è utilizzata in App1 e App2. La POU CheckBounds è disponibile solo in App1: 

{IF defined (pou: PLC_PRG1) AND NOT (defined (pou: CheckBounds))}
(* the following code line is only executed in App2 *)
bANDNotTest := TRUE;
{END_IF}

AND operator

L'espressione assume il valore TRUE se entrambi gli operatori sono TRUE. operator può essere uno degli operatori elencati in questa tabella.

Esempio su AND operator:

Precondizione: esistono 2 applicazioni App1 e App2. La POU PLC_PRG1 è utilizzata nelle applicazioni App1 e App2. La POU CheckBounds è disponibile solo in App1: 

{IF defined (pou: PLC_PRG1) AND (defined (pou: CheckBounds))}
(* the following code line will be processed only in applications App1, because only there "PLC_PRG1" and "CheckBounds" are defined *)
bORTest := TRUE;
{END_IF}

OR operator

L'espressione è TRUE se uno degli operatori è TRUE. operator può essere uno degli operatori descritti in questo capitolo.

Esempio su OR operator:

Precondizione: La POU PLC_PRG1 è utilizzata nelle applicazioni App1 e App2. La POU CheckBounds è disponibile solo in App1: 

{IF defined (pou: PLC_PRG1) OR (defined (pou: CheckBounds))}
(* the following code line will be processed in applications App1 and App2, because both contain at least one of the POUs "PLC_PRG1" and "CheckBounds" *)
bORTest := TRUE;
{END_IF}

(operator)

(operator) racchiude l'operatore.