Définitions lexicales d'Up ! 5GL

Commentaire

Le début d'un bloc de commentaires est signalé par /* et sa fin est signalée par */. Exemple :

I=1; /* Premiere ligne de commentaire. Deuxieme ligne de commentaire. */ J=1;

Pour mettre une seule ligne en commentaire, il suffit d'ajouter en début de celle-ci la marque //. Exemple :

I=1; // Ligne de commentaire. J=1;

Il est possible d'imbriquer les blocs de commentaires, et un bloc de commentaires peut contenir des lignes mises en commentaire à l'aide de //.

Constante entière

Une constante entière est composée par une succession de chiffres. Voici des exemples de constantes entières :

0, 1, 4567, 23487

Voici des contre-exemples de constantes entières :

-3, 0.5, -0.7, abcd

Constante réelle

Une constante réelle est composée d'une succession de chiffres, suivie du caractère point, suivi éventuellement d'une succession de chiffres. Un exposant peut être précisé.

Voici des exemples de constantes réelles :

0., 0.0, 2.3345, 23.487, 23E7, 45E-6

Voici des contre-exemples de constantes réelles :

8, -1, .5, -0.7, abcd, 45E

Identificateur

Un identificateur est composé d'une lettre suivie éventuellement par une succession de lettres, de chiffres, ou du caractère souligné.

Voici des exemples d'identificateur :

abcde, a123, def_ad167

Voici des contre-exemples d'identificateur :

18, 3.14, 123aa, _abcde, _aaa

Un identificateur comporte au plus 50 caractères.

Chaîne entre guillemets

Une chaîne de caractères constante est composée d'une succession de caractères encadrée par deux caractères guillemets.

Voici des exemples de chaînes de caractères entre guillemets :

"liste des employés", "pi=3.14159"

Voici des contre-exemples de chaînes de caractères :

'abcd', abcd, 12

Chaîne entre chevrons

Une chaîne de caractères peut-être également exprimée entre chevrons dans certains cas. Cela est particulièrement pertinent lorsqu'une instruction admet un fichier dont le chemin d'accès est relatif.

Voici des exemples de chaînes de caractères entre chevrons :

<essai.upi>, <graphique/camembert.upi>

Voici des contre-exemples de chaînes de caractères :

'abcd', abcd, 12

Nota bene

Signe des constantes numériques

Les constantes entières et les constantes réelles sont implicitement positives ou nulles. En fait le signe moins est interprété comme l'opérateur unaire changement de signe, ce qui revient sensiblement au même.

Caractères spéciaux dans les chaînes de caractères

Pour inclure dans une chaîne le caractère guillemet, il faut le précéder par le caractère division inversée \. Exemple :

"citation :\"essai\"."

Pour inclure dans une chaîne le caractère division inversée \, il faut le précéder par le caractère division inversée \. Exemple :

"c:\\tmp\\exemple.txt"

Chaînes de caractères sur plusieurs lignes

Si une chaîne de caractère doit être coupée parce qu'elle est trop longue, il suffit d'ajouter le caractère division inversée \ en fin des premières lignes composant la chaîne. Exemple :

ceci \ est un \ essai"

Opérateur accès distant

Employé sur un objet, l'opérateur accès distant @ introduit le serveur d'appartenance d'un objet. Il permet de référencer dans une expression les objets distants suivants :

Exception.
Module.
Entrepot.
Type.
Variable.

Ces objets peuvent être consultés et mis à jour comme s'il s'agissait d'objets appartenant à la tâche courante.

Employé sur un traitement, l'opérateur accès distant @ introduit le serveur implémentant un appel ou une méthode d'un type. Il permet de référencer dans une expression les traitements distants suivants :

Appel.
Méthode.

Ces appels sont exécutés par le serveur comme s'il s'agissait d'appels locaux à une des tâches du serveur. Ces appels sont déclenchés par la tâche courante.

Le serveur de rattachement est donnée par une expression de valeur non nulle dont le type doit être Serveur. La communication entre la tâche courante et le serveur distant est réalisée par Up ! Object Management System selon le protocol Up ! Network.

L'expression du serveur de rattachement est généralement une variable référençant :

Un serveur dont la machine d'hébergement est connue par avance.
En ce cas, Up ! Object Request Broker ne fait que vérifier que le serveur existe, qui est disponible et qu'il implémente bien le module demandé.
Un serveur dont la machine d'hébergement n'est par connue à l'avance.
En ce cas, Up ! Object Request Broker sélectionne un serveur disponible parmis ceux qui implémentent bien le module demandé et qui sont le moins chargés.

Exemple :

Source Composant "Exemple d'emploi de @" Version 1; Principal /*******/ Variable /******/


	MonServeur : Nul Ou Serveur;




Debut

MonServeur=Serveur("Andromede", "UpsKrn");

/* Le serveur est connu par avance. Il s'agit de 'Andromede'. */

Ecran@MonServeur.Ecrire("Bonjour le monde");

/* Ecriture sur la console du serveur s'appelant 'MonServeur'. */

/* L'objet distant est utilisé en local. Le traitement est donc local. */

Ecran.Ecrire@MonServeur("Bonjour le monde");

/* Ecriture sur la console du serveur s'appelant 'MonServeur'. */

/* La méthode est exécutée par le serveur distant à l'initiative de la tâche courante. */

Fin Principal

Opérateur mise en file d'attente

L'opérateur mise en file d'attente || permet de mettre un appel de procédure ou de fonction dans une file d'attente de type FileDAttente. Le résultat est une demande de travail de type Travail. L'exécution de l'appel est différée jusqu'à ce qu'une tâche desservant la file d'attente prélève la demande de travail et exécute l'appel demandé.

La demande de travail peut comporter une contrainte temporelle (date minimale de déclenchement ou date maximale de déclenchement) ou un ordre d'exécution vis-à-vis des autres travaux en attente. Une priorité d'exécution peut être spécifié pour le travail lors de son introduction dans la file d'attente.

Une tâche peut surveiller l'état d'une file d'attente ou l'état d'avancement d'un travail. Une fois le travail terminé, il est possible de savoir si cela s'est effectué avec succès et, le cas échéant, le problème survenu. En cas de succès, une tâche peut consulter le résultat d'une fonction ou les valeurs des paramètres de sortie.

Exemple :

Source Composant "Exemple d'emploi de ||" Version 1; FileDAttente /**********/


	MaFile(1);




/* Création d'une file d'attente 'MaFile' desservie par une tâche. */

Variable

/******/

	E : Entier;

	MonTravail : Nul Ou Travail;



Procedure P(A:Entier Entree Sortie)

/*********************************/

Debut

Ecran.Ecrire("P="+Caractere(A));

Fin Procedure



Principal

/*******/

Debut

E=10;

MonTravail=P(E)||MaFile;

/* Mise en file de l'appel de 'P' dans la file 'MaFile'. Le travail est 'MonTravail'. */

MonTravail.PlanifierAuPlusTard(DateSysteme()+10);

/* Le travail est à déclencher dans au plus 10 secondes. */

Ecran.Ecrire(MaFile.NbTachesServeur);

Ecran.Ecrire(MaFile.NbTravauxEnAttente());

TantQue (MonTravail.Etat!=TravailTermine) Et (MonTravail.Etat!=TravailEnErreur) Faire

/* Nous attendons que le travail soit accompli. */

	Attendre(5);

Fin TantQue

Si MonTravail.Etat==TravailEnErreur Alors

/* Il y a eu une erreur. */

	Ecran.Ecrire(MonTravail.MessageErreur);

Sinon

/* Lit la valeur de sortie correspondant au premier paramètre. */

	Ecran.Ecrire(MonTravail.LireValeurEntier(1));

Fin Si

Fin Principal

Caractère joker

Le caractère joker ? permet d'ignorer le résultat d'une expression. Ce caractère s'emploi lorsque le résultat d'une fonction ou les paramètres de sortie d'un appel ne sont pas utiles pour le reste du programme.

Il n'est pas possible d'employer une variable à la place d'un joker sinon Up ! Compiler signalerait que celle-ci est affectée sans être ensuite utilisée. Up ! Compiler impose d'employer le joker, ce qui permet d'identifier clairement lors de la lecture du programme que le résultat est inutile.

Exemple :

Source Composant "Exemple d'emploi de ?" Version 1; Fonction F() Retourner Entier /***************************/ Debut Ecran.Ecrire("Bonjour le monde"); Retourner 1; Fin Fonction Procedure P(A : Entier Sortie) Retourner Entier /*********************************************/ Debut Ecran.Ecrire("Bonjour le monde"); A=1; Fin Procedure Principal /*******/ Debut ?=F(); P(?); Fin Principal

Caractère sélection

Le caractère sélection . permet de sélectionner une propriété d'une objet d'un type ou il permet d'appliquer une méthode à un objet.

Seules les méthodes correspondant à un opérateur ne doivent pas être introduites par le caractère sélection ..

Exemple :

Source Composant "Exemple d'emploi de ." Version 1; Principal /*******/ Debut Ecran.Ecrire("Bonjour le monde en "+DateSysteme().Annee); Fin Principal