Langage Z (Base)

 

 

Généralités sur le langage Z

Structure d'un Z-algorithme

Structures de contrôle

Actions élémentaires

Scalaires

Pointeurs

Expressions

Commentaires

Opérations de haut niveau

Fonctions standards

Fonctions de génération aléatoire

Fonctions sur chaînes de caractères

Définition d'une action composée

Définition d'une fonction

Exemple d'un Z-algorithme

 

Généralités sur le langage Z

 

  > Un Z-algorithmeIDH_struct est un ensemble de modules parallèles dont le premier est principal et les autres sont soient des actions composéesIDH_act soient des fonctionsIDH_fonct.

 

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

 

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

 

  > Le langage permet tout type de paramètres : scalaires, structures, file, vecteur, ..., et mêmes les types complexes.

 

  > Le langage Z admet les modules récursifs.

 

  > Le langage permet l'allocation dynamique de tableaux et de structures.

 

  > Le langage permet l'affectation globale de tout type.

 

  > Quatre types standards (scalaires) sont autorisés : ENTIER, BOOLEEN, CARACTERE, CHAINE.

 

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

 

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

 

  > On définit ainsi des machines abstraites sur

    - les structuresIDH_mstruct ou objets composés

    - les vecteursIDH_mvect

    - les listes mono directionnellesIDH_mlistes

    - les listes bidirectionnellesIDH_mlistebi

    - les pilesIDH_mpile

    - les files d'attenteIDH_mfile

    - les arbres de recherche binaireIDH_marb

    - les arbres de recherche m-aireIDH_marm

    - les fichiersIDH_mfich

 

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

 

  > Le langage peut être étendu avec d'autres machines abstraites dans les futures versions.

 

  > Le langage est doté des opérations de haut niveau permettant de construire des listes, des arbres, des files, ... à partir d'un ensemble de valeurs ( expressions entières )

 

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

 

  > Le langage offre également deux fonctions pour la manipulation des chaînes de caractères (LONGCHAINE et CARACTIDH_foncts3).

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

 

  > Le format d'écriture est libre.

 

Structure d'un Z-algorithme

 

 

    SOIENT                          

 

       Objets locaux et globaux    

       Annonce des modules         

                                    

    DEBUT                           

                                    

       Instructions                 

                                    

    FIN                             

                                    

    Module 1                         

    Module 2                        

    ...                             

    Modules n                       

  

Chaque module est soit une action composée soit une fonction.

 

Structures de contrôle

 

La boucle TANTQUE

 

    TANTQUE Exp[ : ]                

                                    

       Instructions                 

                                    

    FINTANTQUE                      

  

La boucle POUR

 

    POUR V : = Exp1, Exp2 [,Exp3] [ : ] 

                                       

       Instructions                     

                                        

    FINPOUR                             

  

  Exp3 désigne l'incrément du pas.   Par défaut, sa valeur est 1.

 

La conditionnelle

 

   SI Exp [ : ]                    

       Instructions                 

   FINSI                           

   L'alternative

 

    SI Exp [ : ]                    

                                    

       Instructions                 

                                    

    SINON                           

                                    

       Instructions                 

                                    

    FINSI                           

 

Actions élémentaires

 

Affectation

 

    V := Exp 

 

Affecte la valeur d'une expression à une variable.

 

Lecture

 

    LIRE  ( V1, V2, .... ) 

 

Introduit des données dans les variables V1, V2,...

 

Ecriture

 

   ECRIRE  ( Exp1, Exp2, ... )

 

Restitue les expressions Exp1, Exp2,....

(Expressions entières ou chaînes de caractères)

 

 

Scalaires

 

Quatre types standards sont autorisés : ENTIER, CARACTERE, CHAINE, BOOLEEN.

 

Définition des scalaires

 

  [SOIT/SOIENT] <li> Sep Type

 

<Li> : Liste d'identificateurs séparés par des virgules.

Sep dans  { :, UN, UNE, DES }

Type est un type standard.

 

 

Exemples

 

    A, B, Trouv : BOOLEENS ;

    X, Y, Z DES BOOLEENS ;

    A : ENTIERS ;

    X, Y, Z DES CHAINES ;

 

Objets "Pointeurs"

 

On définit des variables de type "Pointeur" pour la manipulation des structures de données.

 

  [SOIT/SOIENT] <li> Sep

  POINTEUR VERS [sep] [ DE Typec DE Typec DE  ....] [ DE Types]

 

<Li> : Liste d'identificateurs séparés par des virgules.

Sep dans  { :, UN, UNE, DES }

Typec dans  { vecteur, pile, liste, file, pile, arb, listebi, arm }

Types est un scalaire ou une structure simple.

 

Remarque

 

On peut s'en passer de ce type. En effet, les déclarations

"Soit L une liste" et

"soit L un pointeur vers une liste" sont équivalentes.

 

Exemples

 

  P1 : POINTEUR VERS LISTE DE PILE;

  P2, P2 DES POINTEURS VERS DES ARB;

 

Expressions Z

 

Comme dans les langages de programmation.

 

Expressions arithmétiques : + , - , / , *

Expressions logiques : ET, OU, NON

Expressions sur chaînes de caractères : +

Expressions relationnelles : <, <=, >, >=, =, <> (ou #)

 

Constantes logiques : VRAI, FAUX

Constante pointeur : NIL

 

Exemples

 

  B+C / F

  NON Trouv

  (X # 5) ET NON TROUV

  F(X) <> 5

  P = Nil

Commentaires

 

Les commentaires peuvent être insérés dans tout endroit oŚ on peut avoir un blanc.

Les commentaires sont entre { et } ou entre  /*   et  */.

 

 

Opérations de haut niveau

 

Elles permettent de remplir une structure de données  (ou initialiser une machine) à partir d'un ensemble d'expressions.

 

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

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

  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, ....] )

 

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

 

Exemple

      CREER_LISTE ( L, [12, 34, I, I+J, 45] )

 

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

 

Fonctions standards

 

     MOD (A, B)

         Reste de la division entière de A par B.

 

     MAX(A, B)

         Maximum entre A et B.

 

     MIN(A, B)

         Minimum entre A et B.

 

     EXP(A, B)

         A exposant B

 

Fonctions de génération aléatoire

 

     ALEACHAINE ( N )

Fournit une chaîne aléatoire de N caractères parmi les caractères alphabétiques majuscule et minuscule.

 

     ALEAENTIER ( N )

Fournit un nombre aléatoire entre 0 et N

 

Fonctions sur chaînes de caractères

 

     LONGCHAINE ( C )

Donne la longueur de la chaîne C

 

     CARACT(C, I)

Fournit le I-ième caractère de la chaîne  C

 

Définition d'une action composée  

    ACTION Nom ( P1, P2, ...Pn )    

                                    

     Objets locaux et paramètres    

                                    

    DEBUT                           

                                    

       Instructions                 

                                    

    FIN                             

  

Les paramètres sont appelés par "référence",  ce qui implique que les paramètres d'entrée ne sont pas protégés par l'action.

Une action composée doit être annoncée dans le module principal.

 

L'appel à une action se fait par

     APPEL nom de l'action (paramètres réels)

 

Définition d'une fonction

 

  FONCTION Nom ( P1, P2, ...Pn ) : type   

                                            

     Objets locaux et paramètres            

                                            

    DEBUT                                   

                                            

       Instructions                         

                                            

    FIN                                     

  

Les paramètres sont appelés par "référence", ce qui implique que les paramètres d'entrée ne sont pas protégés par l'action.

 

Une fonction utilisateur doit être annoncée dans le module principal en précisant son type.

 

Il doit y exister dans le corps d'une fonction une affectation du genre 

Nom := Expression.

 

Exemple d'un Z-algorithme

 

  SOIENT

     L1, L2 DES LISTES;

     Rech, Tous : 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

  /* Recherche de la valeur Val dans la liste L */

  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

 

  /* Détermine si tous les éléments de L1 sont dans L2 */

  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