elements syntaxiques.pdf

INTRODUCTION A PROGRESS ELEMENTS SYNTAXIQUES

NOM : ……………………….

PRENOM : ……………………….

©® Ce document est la propriété exclusive de Group DISCOVERY Il ne peut être

utilisé, reproduit ou communiqué sans une autorisation écrite préalable 1

Le L4G PROGRESS : Langage de 4ème Génération ................................................................................................. 3 Langage de 4ème génération ...................................................................................................................................... 3 Caractéristique du langage ....................................................................................................................................... 5

Models de programmation.......................................................................................................................................... 6 Quels sont les models de programmation en PROGRESS ? .................................................................................... 6 Exécution d’un programme procédural.................................................................................................................... 6 Exécution d’un programme évènementiel................................................................................................................ 7

Eléments du langage PROGRESS.............................................................................................................................. 8 Quelques Symboles spéciaux....................................................................................................................................... 9 Définition d’une Variable Simple ............................................................................................................................. 10

Les différents Types simples.................................................................................................................................. 10 Syntaxe................................................................................................................................................................... 10 Signification des mots clés..................................................................................................................................... 11

Définition d’une variable Complexe......................................................................................................................... 12 Définition d’une table temporaire .......................................................................................................................... 12 Syntaxe................................................................................................................................................................... 12 Définition d’une table de travail ............................................................................................................................ 12 Syntaxe................................................................................................................................................................... 12 Comparaison des différents types des tables.......................................................................................................... 13

Partage des données inter procédures externes....................................................................................................... 14 Partage des données inter procédures externes....................................................................................................... 14

Visibilité et Partage d’une variable ........................................................................................................................ 14 Utilisation d’une variable partagée par d’autres procédures externe...................................................................... 14

Type de blocs PROGRESS........................................................................................................................................ 15 Les Opérateurs PROGRESS .................................................................................................................................... 16

Opérateurs Arithmétiques ...................................................................................................................................... 16 Opérateurs logiques................................................................................................................................................ 16 Opérateurs de comparaison .................................................................................................................................... 16 Priorité ................................................................................................................................................................... 17

Les fonctions Système d’exploitation ....................................................................................................................... 18 Commandes indépendantes du système d’exploitation.......................................................................................... 18 Commande spécifique au système d’exploitation .................................................................................................. 18 Exemple ................................................................................................................................................................. 18

Les fonctions et opérations sur chaîne de caractères .............................................................................................. 19 concaténation de chaîne ......................................................................................................................................... 19 Fonctions caractères et opérations ......................................................................................................................... 19

Les fonctions Date...................................................................................................................................................... 20 Instruction IF …THEN …ELSE.............................................................................................................................. 21 Instruction CASE....................................................................................................................................................... 21 Les Frames PROGRESS........................................................................................................................................... 22

Frames : support d’affichage.................................................................................................................................. 22 PROGRESS utilise toujours des frames................................................................................................................. 22 Frame par défaut PROGRESS ............................................................................................................................... 22 Caractéristiques par défaut d’une frame................................................................................................................. 22 Définition d’une frame........................................................................................................................................... 22 Positionnement des éléments ................................................................................................................................. 23

Notion d’ INDEX en PROGRESS............................................................................................................................ 24 Définition ............................................................................................................................................................... 24 Types d’index......................................................................................................................................................... 24

Types des verrous PROGRESS ................................................................................................................................ 25 Niveau de locks PROGRESS................................................................................................................................. 25 Ce que les verrous permettent aux utilisateurs....................................................................................................... 25

Référence aux champs ............................................................................................................................................... 25 Recherche d’un enregistrement : FIND................................................................................................................... 26

Utiliser FIND ......................................................................................................................................................... 26 Syntaxe................................................................................................................................................................... 26 Utiliser AVAILABLE............................................................................................................................................ 27 Utiliser ................................................................................................................................................................... 27 AMBIGUOUS ....................................................................................................................................................... 27



Utiliser CURRENT................................................................................................................................................ 27 Existence d’un enregistrement : CAN-FIND() ........................................................................................................ 28

Utiliser CAN-FIND................................................................................................................................................ 28 Syntaxe................................................................................................................................................................... 28 exemple .................................................................................................................................................................. 28

Sélection des enregistrements : FOR........................................................................................................................ 29 Utiliser FOR........................................................................................................................................................... 29 Syntaxe................................................................................................................................................................... 29 Trier les enregistrements : BY ............................................................................................................................... 29 Jointure de plusieurs Tables ................................................................................................................................... 29 Grouper les enregistrements................................................................................................................................... 30

Manipulation des fichiers.......................................................................................................................................... 31 Notion des STREAM............................................................................................................................................. 31 Lecture d’un fichier................................................................................................................................................ 31 Ecriture dans un fichier .......................................................................................................................................... 31

Complément de ce document .................................................................................................................................... 32



Le L4G PROGRESS : Langage de 4ème Génération Langage de 4ème génération

PRORGRESS 4GL est un langage de développement qui vous permet de résoudre des différents problèmes d’applications avec beaucoup moins d’effort que les langages précédents



Exemple L’instruction FOR est une des outils PROGRESS les plus simple et les plus fort qui permet de la gestion de la lecture des enregistrements et leurs affichages d’une façon beaucoup plus facile par rapport aux autres langages.

FOR EACH Item: DISPLAY Item. END. L’instruction ci-dessus :

1. Lit chaque enregistrement de la table Item de la base sports fournie avec Progress .

2. Affiche tous les champs de chaque enregistrement dans une fenêtre par défaut.

3. Des libellés en colonnes s’ajoute à chaque champ affiché. 4. Si les champs sont remplis par les valeurs d’un enregistrement,

Elle donne la main à l’utilisateur pour passer à l’enregistrement suivant s’il existe.



Caractéristique du langage

Flexible : Développement et test rapide Consistance : Intégration de l’interface utilisateur, base de

données et la logique de développement dans un seul langage Sécurité : gestion de contrôle de l’accès multi-users Interopérabilité : Communique avec les composants externes,

distants et système Connectivité : Accès à des bases locales et distants

(clients/serveur) Portabilité : Les application PROGRESS peuvent tourner sur

différentes plate-formes. Mode de programmation Procédurale ou événementiel Syntaxe proche de la langue anglaise



Models de programmation Quels sont les models de programmation en PROGRESS ?

Deux models possibles en PROGRESS : Modèle procédural Modèle évènementiel

Exécution d’un programme procédural

l'exécution dans un programme procédural est de haut vers bas et linéaire ; l'interaction avec le programme est limitée ; l'utilisateur peut choisir de quelques tâches du quelques tâches

programmées à l’avance ; Chacun de ces tâches consiste en plusieurs actions qui ont été

arrangées à l'avance par le programmeur. La séquence de ces actions est aussi déterminée par le

programmeur; une fois un utilisateur sélectionne une tâche, L’application mène l'utilisateur pas à pas à travers les actions a

exigé pour compléter la tâche. Comme les actions sont exécutées, le programme peut fournir des

messages du statut à l'utilisateur.

Le schéma ci-dessus illustre l’exécution typique d’un programme procédural

Exemple

FOR EACH customer: DISPLAY cust-num name phone WITH 6 DOWN. PROMPT-FOR phone. IF INPUT phone NE phone THEN DO:

MESSAGE "Phone Number changed". BELL.

END. ASSIGN phone.

END.



Exécution d’un programme évènementiel

Dans le modèle événementiel, virtuellement toutes actions supportées par l’application sont disponible à l'utilisateur à tous moments. Le programmeur liste les triggers possibles sans imposer l’ordre

d’exécution. L'utilisateur peut réagir réciproquement avec le programme

librement, en choisissant des simple tâches et les combiner dans tout ordre pour accomplir un but désiré. Aussi, l'utilisateur peut changer ou annuler une action, sans

interrompre la tâche courante.

Le schéma ci-dessus illustre l’exécution typique d’un programme évènementiel

Exemple DEFINE BUTTON btn_1 LABEL "Next". DEFINE BUTTON btn_2 LABEL "Prev". FIND FIRST customer. DISPLAY cust-num name phone SKIP (0.5)

btn_2 TO 40 SPACE btn_1 SKIP (0.5)

WITH FRAME f SIDE-LABELS. ON CHOOSE OF btn_1 DO:

FIND NEXT customer NO-ERROR. IF NOT AVAILABLE customer THEN DO:

FIND LAST customer. BELL.

END. DISPLAY cust-num name phone WITH FRAME f.

END. ON CHOOSE OF btn_2 DO:

FIND PREV customer NO-ERROR. IF NOT AVAILABLE customer THEN DO:

FIND FIRST customer. BELL.

END. DISPLAY cust-num name phone WITH FRAME f.

END. ON LEAVE OF phone DO: IF INPUT customer.phone NE customer.phone THEN DO: ASSIGN customer.phone. BELL. MESSAGE "Phone Number changed." VIEW-AS ALERT-BOX INFORMATION. END. END. ENABLE phone btn_2 btn_1 WITH FRAME f. WAIT-FOR GO OF FRAME f.



Eléments du langage PROGRESS Le tableau suivant liste les composants de la syntaxe du langage PROGRESS

Type Description Symboles spéciaux Commentaires ou références spéciales Variable Zone mémoire contenant des valeurs pour traitement Instructions Spécifient une action ou un traitement Champs/Enregistrement Contiennent des données dans la base de données Opérateurs Symboles qui accomplissent des opérations mathématiques ou

logique Expressions Combinaison de variables, champs de base de données, et

opérateurs qui ensemble évaluent une valeur Block Unités d’exécution composée d’un ou plusieurs instructions Procédures Unité d’exécution qui peut être exécutée plusieurs fois par la

commande RUN Fonctions Unité d’exécution retournant une valeur qui peut être appelée

plusieurs fois même dans une expression Objets de l’interface utilisateur

Unité d’affichage sur l’écran, qui accepte des données de l’utilisateur, de variables de l’applications ou de fichiers, de la base de données.



Quelques Symboles spéciaux Le tableau suivant indique la signification PROGRESS de quelques caractères spéciaux

Caractères Description /* Début commentaire */ Fin commentaire Point (.) Fin d’instruction Deux points (:) Début d’un block

Fin d’étiquette Introduit un attribut (méthode) d’un objet

? Valeur inconnue ~ Activer / désactiver la signification spéciale du caractère suivant. ` ou ″ Délimite une chaîne de caractère {<filename>} Référence à un include {<entier numérique>} Paramètre d’un include

Exemple : {3} : 3ème paramètre d’un include

[] Manipulation des élément d’un tableau {&<nom>} Appel à une variable pré-processeur



Définition d’une Variable Simple Les différents Types simples

Les types des variables possibles dans PROGRESS sont : Type Caractéristiques

CHARACTER Chaîne de caractères NTERGER Nombre entier appartient à [-214748364, -214748364] DECIMAL Décimal DATE Date LOGICAL Booléenne HANDLE Pointeur vers un objet PROGRESS COM-HANDLE Pointeur vers un objet COM( ActiveX) RECID Identificateur unique d’un enregistrement MEMPTR Pointeur vers une adresse mémoire RAW Peut designer tout type de données même les données

no PROGRESS ROWID Comme RECID WIDGET-HANDLE

Comme HANDLE

Syntaxe DEFINE

[ [ NEW [ GLOBAL ] ] SHARED ] VARIABLE variable { AS datatype | LIKE field } [ NO-UNDO ] [ COLUMN-LABEL label ] [ DECIMALS n ] [ EXTENT n ] [ FORMAT string ] [ INITIAL { constant | { [ constant [ , constant ] ... ] } } ] [ LABEL string [ , string ] ... ] [ [ NOT ] CASE-SENSITIVE ]



Signification des mots clés

Le tableau suivant explique la signification de chaque mot clé de la syntaxe

Mot clé Signification AS datatype Variable de type « datatype » LIKE field Variable de même caractéristiques du « field », tel

que « field » est un champ ou variable déjà définie NO-UNDO N’annule pas les changements de la valeur de la

variable DESCIMALS n Pour le type DECIMAL, la variable est de précision n

chiffres après la virgule. FORMAT string Précise le format par défaut de la variable EXTENT n Définir un tableau de n éléments INITIAL Initialise la variable ou le tableau LABEL| COLUMN-LABEL

Définir les étiquettes par défauts de la variable lors de son affichage dans des frames

CASE-SENSITIVE Variable sensible aux majuscule et minuscule



Définition d’une variable Complexe Définition d’une table temporaire

Comme il a était indiqué précédemment, PROGRESS intègre les notions des bases de données. Pour cela, il vous permet de créer une table temporaire. Cette structure est une structure semblable à une table de base de données. Les données de cette structure peuvent être sauvegardées dans la mémoire vive ou le disque dur.

Syntaxe DEFINE [ [ NEW [ GLOBAL ] ] SHARED ] TEMP-TABLE temp-table-name [ NO-UNDO ] [ LIKE table-name [ VALIDATE ] [ USE-INDEX index-name [ AS PRIMARY ] ] ... ] [ FIELD field-name { AS data-type | LIKE field [ VALIDATE ] } [ field-options ] ] ... [ INDEX index-name [ IS [ UNIQUE ] [ PRIMARY ] [ WORD-INDEX ] ] { index-field [ ASCENDING | DESCENDING ] } ... ] ...

Définition d’une table de travail

Cette structure gère tous les données en utilisant seulement la mémoire vive. De plus, elle n’utilise pas la notion des indexes.

Syntaxe DEFINE [ [ NEW ] SHARED ] { WORK-TABLE | WORKFILE } work-table-name [ NO-UNDO ] [ LIKE tablename [ VALIDATE ] ] [ FIELD field-name { AS data-type | LIKE field } [ field-options ] ] ...



Comparaison des différents types des tables

Caractéristiques Progress Table base de données Table Temporaire Table de travail

Gestionnaire base de données

Progress utilise un gestionnaire base donnés en mono-utilisateur ou en multi-utilisateurss.

Progress utilise un gestionnaire base de données en mode mono-utilisateur pour accéder à une table temporaire.

Progress n’utilise pas un gestionnaire base de données car les Work tables se trouvent en mémoire vive.

Indexes Vous pouvez définir des indexes

Vous pouvez définir des indexes Vous ne pouvez pas définir des indexes

Suppression des enregistrements

Pour supprimer des enregistrement de la base de données, vous devez le demander explicitement par l’instruction DELETE

Si vous ne supprimez pas les enregistrements explicitement de la table temporaire, Progress, les élimine avec même la table temporaire une fois arrive à la fin de la procédure ou la session qu’elle l’a définie.

Si vous ne supprimez pas les enregistrements explicitement de la table de travail, Progress, les élimines avec même la table de travail une fois arrive à la fin de la procédure ou la session qu’elle l’a définie.

Mouvements des enregistrements

Peut déplacer les enregistrements entre record buffer et la base de données.

Ne peut pas déplacer les enregistrement vers et de record buffer

Ne peut pas déplacer les enregistrement vers et de record buffer

Accès multi-users

Possibilité d’accès multiple Deux utilisateurs différents ne peuvent pas accéder à une même table temporaire

Deux utilisateurs différents ne peuvent pas accéder à une même table de travail

Transactions

Automatiquement, Progress commence les transactions pour certains, blocs et instructions. Les tables de la base de données utilisent le before –image file pour valider les changement.

Vous devez commencer les transactions explicitement Les tables temporaires utilisent un fichier before-image local pour valider les changements..

Vous devez commencer les transactions explicitement. Les tables temporaires utilisent un fichier before-image local pour valider les changements..

Taille du Buffer

Utilise le paramètre «-B» Utilise –Bt pour spécifier la taille du buffer..

Taille dépends de la taille restante en mémoire vive

Localisation

Sauvegardée dans la base de données ( dans le disque dûr)

Sauvegarder dans des fichier temporaires se trouvant dans le répertoire de travail de la session Progress

Existent dans la mémoire vive

Triggers

Supporte les triggers Ne supporte pas les triggers Ne supporte pas les trigger



Partage des données inter procédures externes Visibilité et Partage d’une variable

En combinant les mots clés suivants : NEW, GLOBAL et SAHRED, vous spécifiez :

La visibilité de la variable La durée de vie de la variable

Le tableau ci-dessous explique la signification de chaque combinaison syntaxique possible en PROGRESS: Visibilité durée de vie DEFINE {VARIABLE| TEMP-TABLE| WORK-TABLE }

Programme principal

Egale à celle du programme principal

DEFINE NEW SHARED {VARIABLE| TEMP-TABLE| WORK-TABLE }

Tout programme appelé par le programme principal ou ses sous programmes

Même duré de vie que le programme principal

DEFINE NEW GLOBAL SHARED {VARIABLE| TEMP-TABLE| WORK-TABLE }

Tout programme lancé dans la session PROGRESS après le lancement du programme principal

Jusqu’à la fermeture de la session PROGRESS

Utilisation d’une variable partagée par d’autres procédures externe

Pour qu’une procédure Pext externe puisse accéder à une variable Vpar partagée par une autre procédure Pprin, il faut que:

La procédure Pprin soit exécutée avant la procédure Pext. La déclaration de Vpar au niveau de la procédure Pext a la

syntaxe suivante DEFINE SHARED VARIABLE Vpar <reste de la declaration similaire à celle indiqués dans la procédure Pprin>

Si la deuxième condition n’est pas remplie. La compilation se passe sans erreurs. Mais on aura une erreur PROGRESS pendant l’exécution.



Type de blocs PROGRESS Bloc Description

Procédure interne Traitement réutilisable défini à l’intérieur d’une procédure externe Trigger Groupe d’instruction qui définit l’action à accomplir suite à un

événement DO Ensemble d’instructions traitées comme une seule. DO .. var=first TO last : Itération conditionnée par une valeur DO While (condition) Groupe d’instructions qui s’exécute tant que condition est vraie REPEAT Répétition de l’exécution d’un groupe d’instructions FOR Boucle sur la lecture des enregistrements d’une table ou de

plusieurs tables



Les Opérateurs PROGRESS Opérateurs Arithmétiques

Signe Description + Positif unaire

Addition de type numérique ou de type date (date + entier)

- Négatif unaire Soustraction de type numérique Différence entre deux dates

* Multiplication de 2 opérandes numériques / Division de 2 opérandes numérique

Opérateurs logiques

Signe Description AND Positif unaire

Addition de type numérique ou de type date (date + entier)

OR Négatif unaire Soustraction de type numérique Différence entre deux dates

NOT Multiplication de 2 opérandes numériques

Opérateurs de comparaison

Signe Mot opérateur Description = EQ Egal

<> NE Différent > GT Supérieur < LT Inférieur

>= GE Supérieur ou égal <= LE Inférieur ou égal

BEGINS Vérifie si une chaîne de caractère commence par une autre chaîne de caractère

MATCHES Comparer une chaîne de caractère avec un modèle Exemple : ″abcd″matches ″a.c*″

CONTAINS



Priorité PROGRESS utilise l’ordre suivant pour évaluer une expression : Fonctions Expressions entre parenthèses (les plus interne en premier) Opérateurs : Unaire Multiplier, divise et modulo (*,/) Ajouter, soustraire Matches, BEGINS, opérateurs de comparaison NOT AND OR



Les fonctions Système d’exploitation Vous pouvez faire appel à une commande système à partir d’une procédure PROGRESS, en utilisant une combinaison d’instructions et de fonctions, ou une commande système spécifique . Commandes indépendantes du système d’exploitation

Syntaxe Description OPSYS Vérifier le système d’exploitation sur lequel le

programme s’exécute OS-COPY Copier un fichier OS-APPEND Fusionner deux Fichiers OS-RENAME Renommer un fichier OS-DELETE Supprimer un fichier OS-CREATE-DIR

Créer un répertoire

OS-GETENV Récupérer des informations de variables d’environnement

OS-DRIVES Lister les drivers disponibles OS-ERROR Vérifier le statut d’erreur après l’exécution d’une

commande

Commande spécifique au système d’exploitation

Pour utiliser une commande système, vous pouvez utiliser directement la commande système spécifique Syntaxe OS-Statement [SILENT] os-specific-command [arguments]

OS-STATEMENT peut être

BTOS CTOS DOS UNIX OS2 VMS

Exemple

OS-CREATE-DIR c:\test. DOS edit c:\test\myfile.txt. DOS SILENT copy c:\test\myfile.txt c:\test\newfile.txt.



Les fonctions et opérations sur chaîne de caractères concaténation de chaîne

Vous pouvez utiliser l’opérateur (+) pour concaténer deux ouplusieurs chaînes de caractères Syntaxe String1 + string2

Fonctions caractères et opérations

Le tableau suivant décrit certaines fonctions et opérations sur les chînes de caractères

Fonction Syntaxe Opération BEGINS String1 BEGINS string2 Vérifie si string1 commence par

string2 MATCHES String MATCHES pattern Vérifie si string correspond au

modèle qui peut contenir des jokers : Point(.) – représente un

caractère simple Asteriks (*)- représente

n’importe quel caractères, nul inclus

LENGTH LENGTH(string) Retourne le nombre de caractères ou octets dans la chaîne

INDEX INDEX(source, target[,starting]) Retourne la position de la chaîne cible (target) dans la chaîne source (source), optionnellement sans partir du début de la source

SUBSTRING (fonction)

SUBSTRING(string, position[,length]) Extrait une sous-chaîne de longueur length à partir de la position position dans la chaîne string

SUBSTRING (instruction)

SUBSTRING(target, position[,length]) = string

Remplace le contenu d’une variable ou d’un champ cible target avec string, à partir de la position position dans la cible target

CAPS CAPS(string) Convertit une chaîne string en majuscules

LC LC(string) Convertit une chaîne string en minuscules

FILL FILL(string, n ) Retourne une chaîne de n string concaténées Exemple : Fill(″etg″,3) égale à ″etgetgetg″

TRIM TRIM(string[,trim-chars]) Supprime les caractères constituants trim-chars de l’entête et la fin de string Par défaut trim-chars égale l’espace .



Fonction Syntaxe Opération LEFT-TRIM LEFT-TRIM(string[,trim-chars]) Supprime les caractères constituants

trim-chars de l’entête de string Par défaut trim-chars égale l’espace .

RIGTH-TRIM TRIM(string[,trim-chars]) Supprime les caractères constituants trim-chars de la fin de string Par défaut trim-chars égale l’espace .

OVERLAY OVERLAY(target,position[,length[,type]]) = expression

Remplace le contenu de la chaîne target à partir de la position position par la chaîne expression et ce sans modifier la longueur initiale de target

NUM-ENTRIES NUM-ENTRIES(list [ , character]) Retourne le nombre des éléments séparés par un séparateur character dans une liste list Le séparateur par défaut est la virgule

ENTRY ENTRY ( k , list [ , character ] ) Retourne si c’est possible le kème élément de la liste list telque le séparteur est character. Le séparateur par défaut est la virgule

Les fonctions Date Les fonctions relatives aux dates permettent de récupérer la date courante ou de manipuler des informations de date comme décrit ci-après :

Fonction Syntaxe Opération TODAY TODAY Retourne la date du jour DATE DATE(mois, jour, année)

Ou DATE(date-string))

Retourne une date à partir du triplet d’entier (mois, jour, année) ou bien d’une chaîne de caractères date-string

DAY DAY(date-expression) Retourne le jour d’une date. MONTH MONTH(date-expression) Retourne le mois d’une date YEAR YEAR(date-expression) Retourne l’année d’une date WEEKDAY WEEKDAY(date-expression) Retourne un entier de 1 à 7

représentant le jour de la semaine (1= dimanche,…7= samedi)

TIME TIME Retourne le nombre de secondes depuis minuit



Instruction IF …THEN …ELSE Utilisation L’instruction IF THEN …ELSE permet d’accomplir des actions

dépendantes d’une condition à l’exécution Syntaxe

IF <condition> THEN expression1 [ELSE expression2]

Plusieurs instructions PROGRESS vous permet d’utiliser plusieurs instructions dan une condition IF ou à l’intérieur de deux expressions. Pour cela, il faut regrouper les instructions dans un bloc DO ..END.

Exemple CONNECT C:\PROGRESS\WRK\sprots_pa –1 NO-ERROR. IF CONNECTED(″Sports_pa”) THEN

DISPLAY ″Vous êtes connecté à : ″ LDBNAME(1) SKIP(1) LDBNAME(1) ″ est une base ″ DBTYPE(1) .

ELSE DO : MESSAGE ″Connexion échouée à la base″. QUIT.

END.

Instruction CASE Utiliser CASE L’instruction CASE permet d’effectuer différentes actions en fonction

de la valeur d’une expression. Syntaxe

CASE <expression> : WHEN value1 [OR WHEN valuen …] THEN WHEN OTHEWISE

END [CASE].

Exemple Cet exemple affiche le contenu du répertoire suivant le type du système d’exploitation : DEFINE VARIABLE os AS CHARACTER. ASSIGN os = OPSYS. CASE os:

WHEN ″UNIX″ THEN UNIX ls.

WHEN ″WIN32″ OR WHEN ″MSDOS″ THEN OS-COMMAND dir.

OTHERWISE DISPLAY OPSYS ″est un système non supporté″.

END CASE.

Instructionbloc

Instructionbloc



Les Frames PROGRESS Frames : support d’affichage

Les frames sont des surfaces rectangulaires utilisées pour dessiner des variables, des champs, et autres objets de l’interface utilisateur sur écran feuille, autres périphériques de sortie, ou dans un fichier

PROGRESS utilise toujours des frames

Quand vous voulez restituer quelque chose à l’utilisateur, PROGRESS utilise une frame. SI vous ne spécifiez rien, PROGRESS utilise une frame par défaut, et il utilise des caractéristiques de frame par défaut pour déterminer les emplacements des élément que vous voulez restituer

Frame par défaut PROGRESS

Le fait que PROGRESS utilise une frame par défaut et quelques caractéristiques par défaut vous permet d’afficher des éléments sur l’écran, sans avoir à spécifier un emplacement pour chaque objet, comme il faut le faire dans d’autres langages. Toutefois ces caractéristiques par défaut, peuvent être ou non appropriées à vos besoins.

Caractéristiques par défaut d’une frame

Par défaut PROGRESS affiche les éléments dans une frame avec : Carde autour de la frame Labels des champs/variables comme entête de colonne,

soulignés, dans le haut de la frame Valeurs des champs/variables sous leurs entêtes de colonne

Définition d’une frame

PROGRESS permet de définir les frames par plusieurs façons :

Avec Form-item Field|variable [format-phrase]

[NO-LABEL] [at-phrase] [SPACE(n)] [SKIP(n)]

Frame-phrase [SIDE-LABEL|NO-LABEL] [STREAM-IO] [NO-UNDERLINE] [WIDTH n] [CENTRED] [NO-BOX] [TITLE string]

DEFINE [[NEW] SHARED] FRAME frame-name [form-item] [WITH [frame-phrase]].

FORM [form-item]

WITH FRAME frame-name [frame-phrase]. DEFINE [[NEW] SHARED] FRAME frame-name. FORM [form-item] WITH FRAME frame-name [frame-phrase].



Chaque procédure externe utilisant une frame partagée, doit contenir exactement la déclaration utilisée pour sa création.

Positionnement des éléments

Pour personnaliser les positions des éléments dans une frame , PROGRESS donne différentes méthodes. Le tableau suivant liste ces méthodes:

Syntaxe Description Var AT ROW n1 COLUMN n2 Positionne l’étiquette et la valeur de Var

dans la n1ème ligne (par rapport à la bordure supérieure) de la frame et dans la n2ème colonnes (en nombre de caractères , par rapport à la bordure gauche ) de la frame.

Var CONON n1 Positionne la valeur de Var à partir de la n1ème colonne (en nombre de caractères , par rapport à la bordure gauche ) de la frame. Positionne l’étiquette de Var jusqu’à la n1ème colonne(en nombre de caractères , par rapport à la bordure gauche ) de la frame

Var AT n1 Positionne l’étiquette et la valeur de Var à partir de la n1ème colonne (en nombre de caractères , par rapport à la bordure gauche ) de la frame.

Var AT n1 Positionne l’étiquette et la valeur de Var Jusqu’à la n1ème colonne (en nombre de caractères , par rapport à la bordure gauche ) de la frame.



Notion d’ INDEX en PROGRESS Définition L’index PROGRESS est une structure qui contient des données triées

d’un ou plusieurs champs. Un index sur un champ aide à accéder à un enregistrement plus rapidement si l’accès est basé sur ce champ. Pour illustrer, supposons que les numéros de clients dans la table client se situent de 3 à 50. le diagramme suivant montre comment l’index cust-num (numéro client) garde les numéros de client triés, et comment il pointe sur les enregistrement actuels dans la table.

Types d’index Un index peut être : Unique : c’est à dire que chaque combinaison des valeurs des

champs qui le constituent ne peut exister qu’une seule fois dans la table Primaire : Dans une même table, on peut définir plusieurs

indexes. L’index primaire est l’index par défaut si la requête de recherche ne précise pas l’index à utiliser.



Types des verrous PROGRESS Niveau de locks PROGRESS

PROGRESS utilise deux types de verrou : SHARE-LOCK pour lire un enregistrement et empêcher les

autres utilisateurs de le modifier pendant ce temps EXCLUSIVE-LOCK pour modifier la donnée et empêcher les

autres utilisateurs d’accéder à l’enregistrement pendant ce temps. PROGRESS fournit également une spécification NO-LOCK pour contourner les verrous placés par d’autres utilisateurs, et par conséquent permettre à l’utilisateur de lire un enregistrement, même si quelqu’un y a placé un verrou. Cependant, un utilisateur qui lit un enregistrement avec NO-LOCK ne pourra effectuer aucune modification sans avoir au préalable verrouillé l’enregistrement en EXCLUSIVE –LOCK.

Ce que les verrous permettent aux utilisateurs

Le tableau suivant décrit ce qui peut être fait lors de la spécification des différents types verrous, en opposition à ce que les utilisateurs peuvent faire avec le même enregistrement

Niveau de lock Ce que vous pouvez faire Autres utilisateursNO-LOCK Lecture, mais pas de

modification Lecture et modification

SHARE-LOCK Lecture, mais pas de modification

Lecture mais pas de modification

EXCLUSIVE-LOCK Lecture et modification Pas de modification.Uniquement lecture d’enregistrement en NO-LOCK

Référence aux champs Lorsque vous listez des noms de champs, spécifier seulement le nom du champ n’est parfois pas suffisant. Si plusieurs tables dans la base de données contiennent le même champ appelé cust-num, PROGRESS ne sait pas auquel se référer. Si le nom du champ est ambigu, vous devez spécifier le nom de la table. Pour une meilleur lecture du code, vous pouvez rajouter le nom de la table au nom du champ, même si le champ n’est pas ambigu. Si vous accédez à plus d’une base de données, vous devez spécifier le nom du champ avec le nom de la table, et le nom de la base de données, si les bases de données contiennent des tables et des champs similaires. Syntaxe

[[database-name.]table-name.]field-name



Recherche d’un enregistrement : FIND Utiliser FIND Cette commande permet de lancer une recherche d’un seul enregistrement

d’une TABLE. La recherche est basée sur une clause pour définir les critères de la recherche. Si cette commande réussie à trouver un enregistrement alors elle le charge dans le buffer code

Syntaxe La syntaxe simplifiée de FIND est la suivante FIND [ FIRST | LAST | NEXT | PREV ] Record [ WHERE expression ] [ USE-INDEX index ] [ SHARE-LOCK | EXCLUSIVE-LOCK | NO-LOCK ] [ NO-WAIT ] [ NO-ERROR ]

Le tableau suivant explique les mots clés de la syntaxe

Mot clé Fonction

USE-INDEX index Lancer la recherche en se basant sur l’index index

WHERE expression Précise les critères de recherche FIRST Pointe sur le premier enregistrement valide

suivant l’index utilisé LAST Pointe sur le dernier enregistrement valide

suivant l’index utilisé NEXT Pointe sur l’enregistrement qui suit

l’enregistrement qui existe dans le Record Buffer. Si il n’existe pas un enregistrement dans le Record Buffer, il se comporte comme FIRST.

PREV Pointe sur l’enregistrement qui précèdel’enregistrement qui existe dans le Record Buffer. Si il n’existe pas un enregistrement dans le Record Buffer, il se comporte comme LAST.

NO-WAIT Ne pas attendre la libération de l’enregistrement s’il est verrouillé

NO-ERROR Ne pas afficher de messages d'erreur à l’utilisateur. Passer les renseignements d'erreur à l’objet ERROR-STATUS. système manche. Les erreurs possibles incluent:

Pas d’enregistrement satisfaisant la clause. Plus qu’un enregistrement valide avec

une recherche FIND simple (sans first, last next ou prev).



Utiliser AVAILABLE

Pour savoir si il existe un enregistrement d’une table Table dans le Record Buffer. PROGRESS founit la fonction AVAILABLE qui retourne une booléenne. Syntaxe AVAILABLE Table

Exemple FIIND FIRST customer where country = ″USA″ NO-ERROR. IF AVAILABLE customer tTHEN DISPLAY cust-num.

Utiliser AMBIGUOUS

AMBIGUOUS est une fonction permettant de savoir si FIND à aboutir à un résultat ambigu (trouve plus qu’un enregistrement). Elle est utiliser surtout après une FIND sans FIRST, LAST, NEXT ou PREV. Syntaxe AMBIGUOUS Table

Exemple FIIND customer where country = ″USA″ NO-ERROR. IF AMBIGUOUS customer tTHEN DISPLAY cust-num.

Utiliser CURRENT

Pour utiliser un enregistrement déjà chargé dans le Record Buffer, vous pouvez le retrouver en utilisant un FIND CURRENT . FIND CURRENT permet aussi de changer le mode d’accès à un enregistrement dans leRecord Buffer. Syntaxe FIND CURRENT record [ SHARE-LOCK | EXCLUSIVE-LOCK | NO-LOCK ] [ NO-WAIT ] [ NO-ERROR ]



Existence d’un enregistrement : CAN-FIND() Utiliser CAN-FIND Cette fonction vérifie l’existence d’un enregistrement selon

des critères spécifiques. Elle recherche exactement de la même façon que FIND, mais

elle ne charge pas l’enregistrement trouvé dans le Record Buffer. Donc elle ne change pas les pointeur de Buffer Record. Elle retourne une booléenne TRUE ou FALSE

Syntaxe La syntaxe simplifiée de CAN-FIND est la suivante : CAN-FIND ( [ FIRST | LAST ] [ WHERE expression ] [ USE-INDEX index ] [ SHARE-LOCK | NO-LOCK ] [ NO-WAIT ] )

Notes Voir l’instruction FIND pour savoir la signification des mots clés . Il vaut mieux d’utiliser CAN-FIND avec NO-LOCK et FIRST ou LAST.

exemple REPEAT: CREATE customer. UPDATE cust-num name sales-rep VALIDATE(CAN-FIND(sales-rep WHERE salesrep.sales-rep customer.sales-rep), "Invalid sales rep -- please re-enter"). END.



Sélection des enregistrements : FOR Utiliser FOR Utiliser l’instruction FOR EACH pour accéder à un ensemble

d’enregistrement et pour : Utiliser le même critère de sélection pour tous le enregistrements Boucler sur une liste d’enregistrement et les traiter

individuellement à chaque itération du block FOR Afficher ou traiter ces enregistrements dans un seul sens, sans

revenir sur le précédent. Note : Chaque itération d’un FOR met un enregistrement dans Record Buffer

Syntaxe [ label: ] FOR { EACH | FIRST | LAST } record-phrase [ , [ EACH | FIRST | LAST ] record-phrase ] ... [ BREAK ] [ BY expression [ DESCENDING ] ] [ variable = expression1 TO expression2 [ BY k ] ] [ WHILE expression ] [ TRANSACTION ]

Mot clé Description Label : Etiquette attribuée au block FOR EACH Pour sélectionner tout enregistrement valide FIRST Pour sélectionner juste le premier

enregistrement valide LAST Pour sélectionner juste le dernier enregistrement

valide Trier les enregistrements : BY

Avec l’option BY de l’instruction FOR EACH vous demandez à PROGRESS de trier les enregistrements par un ou plusieurs champs, avant de les afficher ou de les manipuler. PROGRESS trie les valeurs des expressions en utilisant l’ordre croissant par défaut . avec l’option DESCENDING de BY vous spécifiez le tri en sen inverse. Exemple FOR EACH item BY price DESCENDING:

DISPLAY item EXCEPT cat-page cat-description. END.

Jointure de plusieurs Tables

Jusqu’à présent, nous avons accéder à une seule table. La plupart du temps, les données dont on aura besoin résideront dan plus d’une table. Pour extraire des données de plus d’une table, on a besoin d’effectuer ce qu’on appelle une jointure, ceci se fait par la combinaison des tables via un champ commun entre celles-ci.



Exemple FOR EACH invoice NO-LOCK , FIRST customer where customer.cust-num = invoice.cust-num NO-LOCK:

DISPLAY invoice-num amount. END . .

Grouper les enregistrements

Pour grouper les enregistrements sélectionnés d’une jointure de une ou plusieurs tables, PROGRESS fournie le mot clé BREAK. BREAK permet aussi de grouper les enregistrements en sous groupes. BREAK BY expr1 BY expr2

Suite à ce groupement, PROGRESS offre des fonctions à utiliser à l’intérieure du block FOR. Ces fonctions aident à détecter le début et la fin de chaque groupe et sous-groupe : Les fonctions sont :

First(expr1) : teste si l’enregistrement en cours de traitement est le premier enregistrement dans la sélection totale. First-of(expr1) : teste si l’enregistrement en cours de traitement

est le premier enregistrement d’un group expr1. Last-of(expr1) : teste si l’enregistrement en cours de traitement

est le dernier enregistrement d’un group expr1. Last(expr1) : teste si l’enregistrement en cours de traitement est le

dernier enregistrement dans la sélection totale.



Manipulation des fichiers Notion des STREAM

Chaque entité logique ou physique d’entrée/Sortie est un STREAM.. Donc chaque fichier est un STREAM. Chaque chemin d’une imprimante est un STREAM. Cette notion permet à attribuer à chaque fichier à manipuler un STREAM. Et ce pour pouvoir manipuler plusieurs fichier dans une même procédure PROGRESS. Pour définir un STREAM, la syntaxe est la suivante : DEFINE [ [ NEW [ GLOBAL ] ] SHARED ] STREAM stream-name.

On remarque qu’un stream peut être partagé.

Lecture d’un fichier

Pour lire d’un fichier 3 étapes sont à faire : 1. Ouverture du fichier pour lecture :

INPUT [STREAM name-stream] FROM VALUE(exp-nom-fichier).

2. lecture ligne par ligne La lecture d’un fichier se fait ligne par ligne, en utilisant l’instruction IMPORT.

IMPORT [ STREAM stream-name ] { [ DELIMITER character ] record [ EXCEPT field ... ] | UNFORMATTED field } [ NO-ERROR ].

3. Fermer le fichier

INPUT [STREAM name-stream] CLOSE. Note Dans WINDOWS, une ligne ne peut être lu que si elle se termine par un retour chariot.

Ecriture dans un fichier

Pour écrire dans un fichier 3 étapes sont à faire : 1. Ouvrir le fichier pour écriture

OUTPUT [ STREAM stream ] TO VALUE ( expression ). 2. Ecrire les informations Pour écrire dans un fichier nous pouvons utiliser trois instructions:

EXPORT EXPORT [ STREAM stream ] [ DELIMITER character ] { expression | record [ EXCEPT field ... ] }

PUT

PUT [ STREAM stream ] [ UNFORMATTED ] [ { expression [ FORMAT string ] [ { AT | TO } expression ] }



| SKIP [ ( expression ) ] | SPACE [ ( expression ) ] ] .

Mot clé Description

UNFORMATTED Indique que l’écriture doit se faire sans tenir compte du format des informations

FORMAT string Imposer un format même si on a utiliser UNFOMATTED

AT | TO Sert à positionner l’information à partir ou jusqu’à une colonne bien spécifique

SKIP [(expression)] Permet de faire de saut des lignes SPACE [(expression)] Permet d’injecter des espaces entre les

informations

DISPLAY Utile pour écrire les informations selon un format définie dans un frame. 3. Fermer le fichier

OUTPUT [STREAM stream] CLOSE.

Complément de ce document Pour compléter, nous vous conseillons de voir dans le HELP fournie par PROGRESS la fonction et la syntaxe des mots clés suivants :

SEARCH: Recherche dans le PROPATH CREATE: Création d’un enregistrement dans une table DELETE: suppression d’un enregistrement d’une table RELEASE: effacer un enregistrement du Record Buffer. PROCEDURE: Définition d’une procédure interne FUNCTION: Définition d’une fonction UPDATE, PROMPT-FOR et SET : Mise à jour par saisie utilisateur ASSIGN : Affectation multiple. WHEN: conditionner une saisie, affichage ou affectation ACCUMUILATE et ACCUM: Calculer la somme, la moyenne et le nombre

des expressions à l’intérieur d’un block FOR.

elements syntaxiques.pdf

Documents

langage progress

dfinition dune variable

l4g progress

diffrents types des

diffrents types simples

autorisation crite pralable

group discovery

tre utilis