Concepts d'Up ! 5th Generation Language

Up ! 5GL est construit autour de différents concepts qui sont présentés dans cette rubrique. Certains vous sont déjà connus puisqu'ils existent dans différents langages, d'autres ont été étendus ou sont nouveaux.

Constante

Une constante permet d'identifier une valeur par un symbole. L'objectif est d'employer ce symbole au lieu d'employer directement la valeur dans les programmes. En centralisant les constantes dans un ou plusieurs fichiers sources, cela permet de retoucher les définitions du programme sans à revoir tout le code.

Une constante sert par exemple à :

Définir la taille maximale d'une zone mémoire telle la taille d'un tableau.
Représenter des libellés constants mais pouvant évoluer dans le temps tel un numéro de téléphone ou une adresse.
Identifier la version d'un composant logiciel.
Définir des directives d'exécution (version run-time, version de production, etc).

Il existe des constantes standards telles e et Pi et vous pouvez également déclarer vos propres constantes.

Constante /*******/


	CO_TailleTableauMax=100;

	CO_TelephoneSupportTechnique="01.02.03.04.05";

	CO_Version="2.2.A";

La syntaxe complète pour déclarer des constantes est présentée dans la rubrique Syntaxe de la définition d'une constante.

Enuméré

Un énuméré permet de déclarer un ensemble de symboles. Généralement, un énuméré est utilisé pour définir une codification.

A ces symboles peut être optionnellement associée une valeur. En ce cas, les valeurs de l'énuméré s'apparentent à des constantes.

Alors qu'il n'existe pas de relation entre deux constantes, il existe une relation entre deux valeurs de deux énumérés : soit elles font partie du même ensemble i.e. elles sont rattachées au même énuméré, soit elles ne font pas partie du même ensemble.

Cette notion d'ensemble permet d'apporter un contrôle de cohérence dans l'écriture d'un programme. Lorsqu'il s'agit d'employer une valeur d'un énuméré, il est vérifié que la valeur fait bien partie du bon ensemble et non d'un autre.

En centralisant les énumérés dans un ou plusieurs fichiers sources, cela permet également de retoucher les codifications du programme sans à revoir tout le code.

Une énuméré sert par exemple à :

Définir la codification des métiers (ouvrier, employé, technicien, cadre, dirigeant, commerçant, profession liberalle)
Définir un ensemble de valeurs constantes représentant la même idée : les couleurs de la palette, et la valeur d'une couleur est son codage des composantes Rouge Vert Bleu.
Il existe des énumérés standards tels Booleen et vous pouvez également déclarer vos propres énumérés.

Enumere /*****/


	Metier Dans (Ouvrier, Employe, Technicien, Cadre, Dirigeant, Commercant, ProfessionLiberale);
	Couleur Dans (Blanc=0xFFFFFF, Noir=0x000000, Rouge=0xFF0000, Vert=0x00FF00, Bleu=0x0000FF);

La syntaxe complète pour déclarer des énumérés est présentée dans la rubrique Syntaxe de la définition d'un énuméré.

Type

Un type de données est un modèle d'un élément employé par le programme. Un type peut avoir une signification fonctionnelle (les voitures de la société) et les éléments sont en ce cas concrets (les deux Clio du service marketing, les six 205 du service après-vente). Il représente directement alors tout ou partie des entités du système d'information.

Un type peut également avoir une signification technique servant par exemple à accélérer un calcul.

Un type de données peut être plus ou moins complexe selon le problème à résoudre :

Il peut uniquement comporter des caractéristiques telles l'immatriculation pour une voiture.
Il s'agit d'un type structuré simple.
Il peut comporter en plus des traitements qui lui sont spécifiques telle l'acte de réserver un véhicule.
Ces traitements sont appelés des méthodes. Le type est alors appelé une classe et un élément un objet.
Il peut uniquement comporter des caractéristiques qui sont cachées.
Ces caractéristiques sont dites encapsulées au moyen d'une protection.
Les types de données peuvent être organisés en hiérarchie
De façon générale, il y a les véhicules. Parmi les véhicules, il y a les voitures et les motocyclettes. Parmi les voitures, il y a les voitures à essence et celles roulant au diesel.
Le principe de la hiérarchie est appelé l'héritage entre les types.
Un type ne représente pas forcément un élément.
Il peut représenter une partie commune de plusieurs éléments mais n'avoir aucun sens concret. Si cette partie commune comporte notamment des traitements génériques, il s'agit d'une interface.

Il existe des types standards tels Entier, Reel, Date, Caractere et vous pouvez également déclarer vos propres types.

Type TypVille /***********/


	Ville : Caractere;

	CodePostal : Entier;


Fin Type



Type TypImmatriculation

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

	Prefecture : TypVille;

	Immatriculation : Caractere;


Fin Type



Type TypVehicule

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

	Immatriculation : TypImmatriculation;

	Procedure Reserver(NomPersonne : Caractere);


Fin Type



Type TypVoiture HeriteDe TypVehicule

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

	Modele : Caractere;


Fin Type



Type TypVoiture HeriteDe TypVehicule

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

	Puissance : Entier;

	Modele : Caractere;

	CapaciteReservoir : Caractere;


Fin Type



Type TypVoitureEssence HeriteDe TypVoiture

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

	UtiliseDuSuper95 : Booleen;


Fin Type



Type TypVoitureDiesel HeriteDe TypVoiture

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

	EstUnVehiculeLeger : Booleen;


Fin Type



Type TypMotocyclette HeriteDe TypVehicule

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

	Cylindree : Entier;


Fin Type

La syntaxe complète pour déclarer des types est présentée dans la rubrique Syntaxe de la définition d'un type.

Variable

Une variable est une entité conservant une valeur dans la mémoire de l'ordinateur. Cette valeur peut être le résultat d'un calcul, un paramétrage, l'effet de l'action de l'utilisateur, etc.

Les valeurs admissibles par une variable sont définies par le type de la variable. Par exemple, si la variable est de type Entier, les valeurs possibles sont uniquement des valeurs entières.

Il existe des variables standards tels Ecran et vous pouvez également déclarer vos propres variables.

Variable /******/


	MaVoiture : TypVoitureEssence;

	LaMotoDeMonOncle : TypMotocyclette;

La syntaxe complète pour déclarer des variables est présentée dans la rubrique Syntaxe de la définition d'une variable.

Exception

Une exception est une entité traduisant un phénomène inattendu dans le déroulement du programme. Ce phénomène provient généralement d'une erreur, que ce soit dans le programme ou dans l'environnement de fonctionnement du programme.

Il existe des exceptions standards tels PlusDeMemoire, OuvertureLecture, OuvertureEcriture et vous pouvez également déclarer vos propres exceptions.

Une exception peut être attrapée avant que son effet ne soit désastreux pour le programme. Cela permet de mettre des sécurités dans le programme afin de prévenir les situations inattendues, ce qui améliore sa robustesse.

Exception /*******/


	PlusDeVehiculeALouer("PlusDeVehiculeALouer", 506);

La syntaxe complète pour déclarer des exceptions est présentée dans la rubrique Syntaxe de la définition d'une exception.

File d'attente

Une file d'attente est une entité exécutant des travaux en tâche de fond au sein du programme. Généralement, il s'agit de travaux d'exploitation lourds et non urgents pour l'utilisateur qui sont exécutés par un serveur, tels l'impression d'un gros document.

FileDAttente /**********/


	FileDImpression(3);

La syntaxe complète pour déclarer des files d'attente est présentée dans la rubrique Syntaxe de la définition d'une file d'attente.

Expression

Une expression est la définition d'un calcul. Un calcul peut aller du plus simple, tel une addition, au plus compliqué, telle la résolution d'un système d'équations différentielles.

Les expressions sont notamment construites à partir d'opérateurs tels +, -, *, / ou à partir de fonctions opérant sur des types standards et vous pouvez également déclarer vos propres opérateurs et vos propres fonctions.

La syntaxe complète pour déclarer des expressions est présentée dans la rubrique Syntaxe de la définition d'une expression.

Instruction

Une instruction est l'entité de base permettant de définir le fonctionnement du programme. Le programme est donc une suite d'instructions dont l'ordre d'exécution est défini par leur enchaînement.

Une instruction peut être l'évaluation d'une expression d'un calcul et le rangement du résultat dans une variable.

Il existe des instructions standards tels Si, TantQue, Pour, AttraperException et vous pouvez également déclarer vos propres instructions.

La syntaxe complète pour déclarer des instructions est présentée dans la rubrique Syntaxe de la définition d'une instruction.