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:
oÈ stato dichiarato un certo tipo di dati o variabile?
oUn tipo o una variabile hanno un determinato attributo?
oUna variabile ha un determinato tipo di dati?
oSono 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. |
Tenere presente che si possono anche 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:
ohasattribute (pou: pou-name, attribute)
ohasattribute (variable: variable, attribute)
ohastype (variable:variable, type-spec)
ohasvalue (define-ident, char-string)
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):
Prerequisito: vi sono 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.
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):
Prerequisito: vi sono 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}
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) :
Prerequisito: vi sono 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}
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):
Prerequisito: vi sono 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):
Prerequisito: vi sono 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):
Prerequisito: vi sono 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
oLREAL
oREAL
oLINT
oDINT
oINT
oSINT
oULINT
oUDINT
oUINT
oUSINT
oTIME
oLWORD
oDWORD
oWORD
oBYTE
oBOOL
oSTRING
oWSTRING
oDATE_AND_TIME
oDATE
oTIME_OF_DAY
Esempio relativo a all'operatore hastype (variable: variable, type-spec):
Prerequisito: vi sono 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):
Prerequisito: la variabile test è utilizzata nelle applicazioni App1 e App2. Assume il valore 1 in App1 e il 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}
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:
Prerequisito: vi sono 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}
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:
Prerequisito: vi sono 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}
L'espressione è TRUE se uno degli operatori è TRUE. operator può essere uno degli operatori descritti in questo capitolo.
Esempio su OR operator:
Prerequisito: 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) racchiude l'operatore.
