Présentation du langage Z (niveau II)

 

Généralités
Structure d’un Z-algorithme
Définition d'une action
Définition d'une fonction
Exemple d’un Z-algorithme
Objets
Expressions
Instructions
Opérations liées aux machines abstraites
Opérations de haut niveau
Fonctions standard
 

 

Généralités                                                                                                           

 

> Un Z-algorithme est un ensemble de modules parallèles dont le premier est principal et les autres sont soient des actions composées (ACTION) soient des fonctions de type quelconque (FONCTION).

> Le langage Z admet les modules récursifs.

> Les objets globaux sont déclarés dans le module principal.

> La communication entre les modules se fait via les paramètres et les variables globales.

> Le langage permet

- tout type de paramètres : scalaires, structures, listes , files, vecteurs, piles, arbres et même les type complexes.

- l'allocation dynamique de tableaux et de structures

- l'affectation globale de tout type

> Quatre types standard ( scalaires ) sont autorisés : ENTIER, BOOLEAN, CAR, CHAINE .

> Certaines fonctions usuelles sont pré-définies: MOD, MAX et MIN.

> Le langage est l'ensemble des algorithmes abstraits, écrits à base de modèles ( machines abstraites ).

> On définit ainsi des machines abstraites sur les objets composés (structures), les vecteurs de dimension quelconque, les piles, les files d'attentes, les arbres de recherche binaire, les arbres de recherche m-aire, les listes mono-directionnelles, les listes bidirectionnelles.

> On définit également une machine abstraite sur les fichiers permettant leur utilisation et la construction aussi bien de structures simples de fichiers que les structures les plus complexes.

> Le langage permet les types composés du genre PILE DE FILES DE LISTES DE ....dont la dernière citée est de type scalaire ou structure simple.

> Le langage est doté des opérations de haut niveau permettant de construire des listes, des arbres, des files d’attente, etc. à partir d'un ensemble de valeurs ( expressions ) ou de structures.

> le langage offre deux fonctions très utiles permettant de générer aléatoirement des chaînes de caractères (ALEACHAINE) et des entiers (ALEAENTIER).

> Le langage permet la lecture et l’écriture de scalaires, de vecteurs de n’importe quelle dimensions de scalaires et des structures simples ou complexes.

Structure d’un Z-algorithme                                                                                        


    SOIENT
        { Objets locaux et globaux }
        { Annonce des modules }
    DEBUT
        { Instructions }
    FIN
    Module 1
    ....
    Module n

Chaque module peut être soit une fonction soit une action.

Définition d'une action                                                             

    ACTION Nom (P1, P2, ..., Pn)
   
        { Objets locaux et paramètres }
    DEBUT
        { Instructions }
    FIN

L’appel à une action se fait par l’opération APPEL suivi du nom de l’action suivi des paramètres.

Les paramètres ne sont pas protégés par l’action composée.

Définition d'une fonction                                                     

    FONCTION Nom (P1, P2, ...,Pn) : Type
        { Objets locaux et paramètres }
    DEBUT
        { Instructions }
    FIN

Type peut être quelconque.

Une fonction est utilisée directement dans une expression.

Les paramètres ne sont pas protégés par la fonction.

Exemple d’un Z-algorithme                                           


SOIENT
    L1, L2 DES LISTES;
    Rech, Tous DES FONCTION(BOOLEEN);
DEBUT
    CREER_LISTE(L1, [2, 5, 9, 8, 3, 6 ]);
    CREER_LISTE(L2, [12, 5, 19, 8, 3, 6, 2,9]);
    ECRIRE( Tous(L1, L2) )
FIN

FONCTION Rech ( L, Val ) : BOOLEEN
SOIENT
    L UNE LISTE; Val UN ENTIER;
DEBUT
    SI L = NIL : Rech := FAUX
    SINON
        SI VALEUR(L) = Val :    
            Rech := VRAI
        SINON
        Rech := Rech(SUIVANT(L), Val )
        FSI
    FSI
FIN
FONCTION Tous ( L1, L2 ) : BOOLEEN
SOIENT
    L1, L2 DES LISTES;
DEBUT
    SI L1 = NIL : Tous := VRAI
    SINON
        SI NON Rech(L2, VALEUR(L1) )
        Tous := FAUX
        SINON
        Tous := Tous(SUIVANT(L1), L2)
        FSI
    FSI
FIN

 

Objets                                                                     

Les objets peuvent être des scalaires : ENTIER, BOOLEEN, CAR, CHAINE.

Les objets peuvent être des machines abstraites :

Structures, Vecteurs, Listes linéaires chaînées monodirectionnelles et bidirectionnelles, Files d’attente, Piles, Arbres de recherche binaire, Arbres de recherche m-aire, fichiers.

Exemples :

L1, L2 DES LISTES ;

A UNE STRUCTURE(CHAINE, ENTIER) ;

V1 UN VECTEUR(10, 60) DE (CAR, ENTIER)  ;

Y UNE LISTE DE PILES DE VECTEUR(10) ;

F1 UN FICHIER DE (CHAINE, VECTEUR(5) DE ENTIERS)

BUFFER V1, V2

Le type par défaut est le type ENTIER.

Structures :

Une structure peut être simple, c’est à dire composée uniquement de scalaire ou complexe et dans ce cas elle peut contenir des scalaires et/ou des vecteurs à une dimension de scalaires.

Une définition de structure spécifie un ensemble de types. Chaque type peut être un scalaire ou un vecteur à une dimension de scalaires.

Fichiers :

Une définition de fichier comporte 3 parties :

** La première partie (FICHIER) précise la nature des éléments du fichier.

Un élément ( article ) d'un fichier peut être

- un scalaire, c’est à dire de type simple ( ENTIER, BOOLEEN, CAR, CHAINE ),

- un vecteur à une dimension de scalaires

- une structure pouvant contenir des scalaires ou des vecteurs à une dimension de scalaires.

** La deuxième partie définit les variables ( articles ou bloc ) utilisées dans les opérations de lecture et d'écriture.

** La troisième partie définit les caractéristiques du fichier en précisant le type de chaque caractéristiques. Cette partie est surtout utilisée pour

la création de structures de fichiers utilisateur et servent à mémoriser toutes les informations utiles pour l'exploitation du fichier.

Expressions                                                                                                       

Comme dans les langages de programmation.

Exemples :

(B+C) / F , NON Trouv, (X # 5) ET NON Trouv, F(x) <> 5

Instructions                                                                                        

V désigne une variable, E une expression et Idf un nom de module.

[ ] désigne une partie facultative, { } un ensemble.

Affectation  : V := E

Lecture : LIRE(V1, V2, .....)

Les variables peuvent être des scalaires, des structures ou des vecteurs de n’importe quelle dimension.

Ecriture : ECRIRE(E1, E2, .....)

Les expression peuvent être des scalaires, des structures ou des vecteurs de n’importe quelle dimension.

Appel : APPEL Idf [ ( E1, E2, ...) ]

L’appel à une action utilisateur se fait par l’ordre APPEL.

Conditionnelle :

    SI E [ : ]
        { Instructions }
    [ SINON
        { Instructions } ]
    FSI

Répétitive ( Forme 1)

    TQ E [ : ]
        { Instructions }
    FTQ

Répétitive ( Forme 2)

    POUR V := E1, E2 [,E3]
        { Instructions }
    FPOUR                

E3, si présent, désigne le pas.

 

Opérations liées aux machines abstraites                                 

Listes : ALLOUER , LIBERER , VALEUR, SUIVANT, AFF_ADR, AFF_VAL

Listes bidirectionnelles : ALLOUER , LIBERER , VALEUR, SUIVANT, AFF_VAL, PRECEDENT, AFF_ADRD, AFF_ADRG

Piles : CREERPILE, EMPILER, DEPILER, PILEVIDE

Files : CREERFILE, ENFILER, DEFILER, FILEVIDE.

Arbres de recherche binaire : CREERNOEUD, FG, FD, PERE, LIBERERNOEUD, AFF_FG, AFF_FD, AFF_PERE, INFO, AFF_INFO.

Fichiers : OUVRIR, FERMER, LIRESEQ, LIREDIR, ECRIRESEQ, ECRIREDIR, RAJOUTER, FINFICH, ENTETE, AFF_ENTETE, ALLOC_BLOC.

Arbres de recherche m-aire : CREERNOEUD, FILS, LIBERERNOEUD, AFF_FILS, INFOR, AFF_INFO, DEGRE, AFF_DEGRE, PERE, AFF_PERE.

Vecteurs : ELEMENT, AFF_ELEMENT,

ALLOC_TAB, LIBER_TAB (si tableau dynamique)

Structures : Struct, Aff_struct,

ALLOC_STRUCT, LIBER_STRUCT (si structure dynamique)

Opérations de haut niveau                                                 

Le langage Z est pourvu des opérations de haut niveau permettant de remplir ou d’initialiser une structure de données à partir d'un ensemble de valeurs.

CREER_ARB, CREER_LISTE, CREER_LISTEBI,CREER_ARM, CREER_PILE, CREER_FILE, INIT_VECTEUR (ou INIT_TABLEAU), INIT_STRUCT

Syntaxe :

CREER_LISTE ( L, [Exp1, Exp2, ....] )

CREER_LISTEBI ( LB, [Exp1, Exp2, ....] )

CREER_ARB ( A, [Exp1, Exp2, ....] )

CREER_ARM ( M, [Exp1, Exp2, ....] )

CREER_FILE ( F, [Exp1, Exp2, ....] )

CREER_PILE ( P, [Exp1, Exp2, ....] )

INIT_STRUCT(S, [Exp1, Exp2, ....])

INIT_VECTEUR ( T, [Exp1, Exp2, ....] )

Exp1, Exp2, .... sont des expressions scalaires ou des structures

Exemple

CREER-LISTE (L, [12, 23, 67, I, I+J] )

crée la liste linéaire chaînée L avec les valeurs entre crochets dans l’ordre indiqué.

Si L1 et L2 sont deux listes d’entiers et Ll une liste de listes, on pourra écrire :

CREER_LISTE ( L1 , [ 2 , 4 , 67 , 778 ] ) ;

CREER_LISTE ( L2 , [ 12 , 14 , 167 , 1778 ] ) ;

CREER_LISTE ( Ll , [ L1 , L2 ] ) ;

Fonctions standards                                                                                

MOD (A, B)  : Donne le reste de la division entière de A par B.

MAX(A, B)  : Donne le maximum entre A et B.

MIN(A, B) : Donne le minimum entre A et B.

ALEACHAINE : Produit une chaîne alphanumérique de 4 caractères.

ALEAENTIER  : Produit un entier compris entre 0 et 10000.