Le langage étendu ST (ExST) prend en charge plusieurs instructions Pragma conditionnelles, qui affectent la génération du code lors de la compilation ou précompilation.
NOTE : n'ajoutez aucun pragma conditionnel dans la partie déclaration. Ces pragmas sont ignorés.
Le code d'implémentation pris en compte pour la compilation varie en fonction des conditions suivantes :
oUn type de données ou une variable spécifique a-t-il été déclaré ?
oUn attribut spécifique est-il associé à un type ou une variable ?
oUne variable est-elle associée à un type de données spécifique ?
oUn POU ou une tâche spécifique est-il disponible ou fait-il partie de l'arborescence d'appels, etc.
NOTE : un POU ou une GVL déclaré(e) dans l'arborescence POU ne peut pas utiliser de {define...} déclaré au sein d'une application. Les définitions des applications n'affectent que les interfaces insérées sous l'application correspondante.
|
{define identifier string} |
Lors du prétraitement, toutes les instances suivantes de l'identificateur sont remplacées par la séquence indiquée de jetons, dans le cas où la chaîne de jeton n'est pas vide (ce qui est autorisé et clairement défini). L'identificateur reste défini et dans le domaine de validité jusqu'à la fin de l'objet ou jusqu'à ce qu'une directive {undefine} annule sa définition. Usage : compilation conditionnelle. |
|
{undefine identifier} |
La définition de l'identifier au sein du préprocesseur (par {define}, voir première ligne du présent tableau) est supprimée ; l'identificateur n'est donc plus défini. Lorsque l'identificateur indiqué n'est pas défini, ce pragma est ignoré. |
|
{IF expr} ... {ELSIF expr} … {ELSE} ... {END_IF} |
Ces pragmas s'appliquent au processus de compilation conditionnelle. Les expressions exprs doivent être constantes lors de la compilation. Leur évaluation s'effectue selon leur ordre d'affichage, jusqu'à ce que l'une des expressions renvoie une valeur non nulle. Le texte associé à cette directive est alors prétraité et compilé normalement, les autres étant ignorés. Les sections doivent s'afficher dans un ordre bien spécifique. Notons néanmoins que les sections elsif et else sont facultatives et que la section elsif peut se répéter plus souvent de façon arbitraire. Vous pouvez utiliser plusieurs opérateurs de compilation conditionnelle au sein de l'expression constante expr. |
|
<expr> |
L'expression constante expr d'un pragma de compilation conditionnelle ({if} ou {elsif}, voir tableau précédent) accepte plusieurs opérateurs. La définition de ces opérateurs peut ne pas être annulée ou revue via {undefine} ou {define}, respectivement. |
Vous pouvez aussi utiliser ces expressions et la définition réalisée par {define} dans la zone de texte Définitions compilateur de la boîte de dialogue Propriétés d'un objet (Afficher > Propriétés > Compiler).
Opérateurs de compilation conditionnelle
Les opérateurs suivants sont pris en charge :
ohasattribute (pou: pou-name, attribute)
ohasattribute (variable: variable, attribute)
ohastype (variable:variable, type-spec)
ohasvalue (define-ident, char-string)
Avec cet opérateur, l'expression prend la valeur TRUE lorsque l'identifier est défini via une instruction {define} et que cette définition n'est pas annulée ultérieurement par une instruction {undefine} . Sinon, elle prend la valeur FALSE.
Exemple d'opérateur defined (identifier) :
Prérequis : deux applications App1 et App2 existent. L'identificateur pdef1 est défini dans App2, mais pas dans 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}
Un exemple de pragma de message est également inclus :
Seules les informations pdef1 defined s'affichent dans la vue Messages lors de la compilation de l'application, car pdef1 est défini. Le message pdef1 non défini s'affiche si pdef1 n'est pas défini.
Lorsque l'opérateur s'applique à une variable, l'expression prend la valeur TRUE si la variable est déclarée au sein du domaine de validité en cours. Sinon, elle prend la valeur FALSE.
Exemple d'opérateur defined (variable:variable) :
Prérequis : deux applications App1 et App2 existent. La variable g_bTest est déclarée dans App2, mais pas dans App1.
{IF defined (variable:g_bTest)}
(* the following code is only processed in application App2 *)
g bTest := x > 300;
{END_IF}
Lorsque l'opérateur s'applique à un identificateur de type, l'expression prend la valeur TRUE si un type portant ce nom est déclaré. Sinon, elle prend la valeur FALSE.
Exemple d'opérateur defined (type:identifier) :
Prérequis : deux applications App1 et App2 existent. Le type de données DUT est défini dans App2, mais pas dans App1.
{IF defined (type:DUT)}
(* the following code is only processed in application App1 *)
bDutDefined := TRUE;
{END_IF}
Lorsque l'opérateur s'applique à un nom de POU, l'expression prend la valeur TRUE si un POU ou une action portant ce nom est déclaré. Sinon, elle prend la valeur FALSE.
Exemple d'opérateur defined (pou: pou-name) :
Prérequis : deux applications App1 et App2 existent. Le POU CheckBounds est disponible dans App2, mais pas dans 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)
Lorsque l'opérateur s'applique à un POU, l'expression prend la valeur TRUE si l'attribut (attribute) en question est indiqué sur la première ligne de la déclaration des POU.
Exemple d'opérateur (opérateur hasattribute (pou: pou-name, attribute)) :
Prérequis : deux applications App1 et App2 existent. La fonction fun1 est définie dans App1 et App2, et possède un attribut vision dans App1 :
Définition de fun1 dans App1 :
{attribute 'vision'}
FUNCTION fun1 : INT
VAR_INPUT
i : INT;
END_VAR
VAR
END_VAR
Définition de fun1 dans App2 :
FUNCTION fun1 : INT
VAR_INPUT
i : INT;
END_VAR
VAR
END_VAR
Instruction Pragma
{IF hasattribute (pou: fun1, 'vision')}
(* the following code is only processed in application App1 *)
ergvar := fun1 ivar);
{END_IF}
hasattribute (variable: variable, attribute)
Lorsque l'opérateur s'applique à une variable, l'expression prend la valeur TRUE si l'attribut en question est indiqué via l'instruction {attribute} sur une ligne précédant la déclaration de la variable.
Exemple d'opérateur hasattribute (variable: variable, attribute) :
Prérequis : deux applications App1 et App2 existent. La variable g_globalInt est utilisée dans App1 et App2, et possède un attribut DoCount dans App1 :
Déclaration de g_globalInt dans App1
VAR_GLOBAL
{attribute 'DoCount'}
g_globalInt : INT;
g_multiType : STRING;
END_VAR
Déclaration de g_globalInt dans App2
VAR_GLOBAL
g_globalInt : INT;
g_multiType : STRING;
END_VAR
Instruction 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)
Lorsque l'opérateur s'applique à une variable, l'expression prend la valeur TRUE si la variable en question correspond au type (type-spec) indiqué. Sinon, elle prend la valeur FALSE.
Types de données disponibles pour type-spec
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
Exemple d'opérateur hastype (variable: variable, type-spec) :
Prérequis : deux applications App1 et App2 existent. La variable g_multitype est déclarée dans App1 sous le type LREAL, et dans l'application App2 sous le type 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)
Lorsque la variable (define-ident) est définie et possède la valeur indiquée (char-string), l'expression prend la valeur TRUE. Sinon, elle prend la valeur FALSE.
Exemple d'opérateur hasvalue (define-ident, char-string) :
Prérequis : la variable test est utilisée dans les applications App1 et App2. Elle prend la valeur 1 dans App1 et la valeur 2 dans 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'expression prend la valeur TRUE lorsque la valeur inversée de l'opérateur (operator) est TRUE. L'opérateur (operator) correspond à l'un des opérateurs décrits dans ce chapitre.
Exemple d'opérateur NOT operator :
Prérequis : deux applications App1 et App2 existent. Le POU PLC_PRG1 est utilisé dans App1 et App2. Le POU CheckBounds est uniquement disponible dans 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'expression prend la valeur TRUE lorsque les deux opérateurs sont TRUE. L'opérateur (operator) correspond à l'un des opérateurs répertoriés dans ce tableau.
Exemple d'opérateur AND operator :
Prérequis : deux applications App1 et App2 existent. Le POU PLC_PRG1 est utilisé dans les applications App1 et App2. Le POU CheckBounds est uniquement disponible dans 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'expression prend la valeur TRUE lorsque l'un des opérateurs est TRUE. L'opérateur (operator) correspond à l'un des opérateurs décrits dans ce chapitre.
Exemple d'opérateur OR operator :
Prérequis : le POU PLC_PRG1 est utilisé dans les applications App1 et App2. Le POU CheckBounds est uniquement disponible dans 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) englobe l'opérateur.
