Le langage Z Pr ZEGOUR DJAMEL EDDINE Ecole Supérieure d’Informatique (ESI) www.zegour.uuuq.com email: d_zegour@esi.dz

Le langage Z : 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). 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. Les paramètres peuvent être de n’importe quel type. Le langage permet l’affectation globale de tout type. Quatre types standards sont autorisés : ENTIER, BOOLEAN, CAR et CHAINE .

Le langage Z : Généralités Le langage est l'ensemble des algorithmes abstraits, écrits à base de modèles ( machines abstraites ).   On définit ainsi des machines de Turing : Machine-caractères et Machine-nombres permettant l’initiation à l’algorithmique. On définit des machines abstraites sur les structures, vecteurs et les listes permettant l’initiation aux structures élémentaires de données. On définit également une machine abstraite sur les fichiers permettant l’initiation aux structures simples de fichiers. Le langage peut être étendu avec d'autres machines abstraites.

Le langage Z : Généralités  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 (ALEANOMBRE). Le langage permet la lecture et l’écriture de scalaires, vecteurs de n’importe quelle dimension et des structures simples ou complexes.   Le format des instructions est libre. Pas de distinction entre majuscule et minuscule.

Le langage Z : Structure d’un algorithme SOIENT { Objets locaux et globaux } { Annonce des modules } DEBUT { Instructions } FIN   Module 1 Module 2 .... Module n Chaque module peut être soit une fonction soit une action.

Le langage Z : Définition d’une action ACTION Nom (P1, P2, ..., Pn) SOIT  { Objets locaux et paramètres } DEBUT { Instructions } FIN Les paramètres sont appelés par ‘référence’. Ils ne sont pas protégés par l’action.

Le langage Z : 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 dans une expression.

Le langage Z : Exemple d’un algorithme SOIENT Mot : CHAINE; C : CAR; M : MACHINE_CAR;  DEBUT   CREER_MCAR(M, [' Jhh Jsthd Lkql ifd ']); LIRECAR(M, C); TANTQUE C <> '.'   TQ (C=' ') ET (C <> '.') LIRECAR(M, C) FTQ ;   Mot := '';   TQ (C <> ' ') ET (C <> '.') Mot := Mot + C ; FTQ;   SI Mot <> '' ECRIRE(Mot) FSI   FINTANTQUE FIN

Le langage Z : Objets Les objets peuvent être des entiers (ENTIER), des booléens (BOOLEEN), des caractères (CAR) ou des chaînes de caractères ( CHAINE). Exemples : Les objets peuvent être des machines abstraites : Structures, Vecteurs, Listes linéaires chaînées, Machine caractères, Machine Nombre et Fichiers. Exemples Soit A, B, C DES BOOLEENS ; I, J : ENTIER ; Ch UNE CHAINE ; C UN CAR ; Soient L1, L2 DES LISTES ; V1 UN VECTEUR(10, 60) ;

Le langage Z : Objets Autres Exemples : Une structure peut être simple, cad composée uniquement de scalaires Une structure peut être complexe, cad composée de scalaires et|ou de vecteurs à une dimension de scalaires SOIENT V1 UN VECTEUR(10, 60) de (CAR, ENTIER); S UNE STRUCTURE (CHAINE, ENTIER); F UN FICHIER DE (CHAINE, VECTEUR(5) DE ENTIERS) BUFFER V1, V2

Le langage Z : Expressions Comme dans les langages de programmation. Exemples : (B+C) / F , NON Trouv, (X # 5) ET NON Trouv, F(x) <> 5 A OU B (A <= B) ET(A >5) Etc.

Le langage Z : Instructions Affectation  : V := E Lecture : LIRE(V1, V2, .....) Ecriture : ECRIRE(E1, E2, .....) Conditionnelle : SI E [ : ] { Instructions } [ SINON { Instructions } ] FSI Conventions: V désigne une variable, E une expression et Idf un nom de module. [ ] désigne une partie facultative, { } un ensemble.

Le langage Z : Instructions Appel : APPEL Idf [ ( E1, E2, ...) ] Répétitive (Forme 1 ) : TQ E [ : ] { Instructions } FTQ   Répétitive (Forme 2 ) : POUR V := E1, E2,E3 FPOUR E3 désigne le pas. Conventions: V désigne une variable, E une expression et Idf un nom de module. [ ] désigne une partie facultative, { } un ensemble.

Le langage Z : Machines abstraites Machine-caractères : LIRECAR, NBRCAR Machine-nombres : LIRENOMBRE, NBRNOMBRE Listes linéaires chaînées : ALLOUER , LIBERER , VALEUR, SUIVANT, AFF_ADR, AFF_VAL Vecteurs : ELEMENT, AFF_ELEMENT Structures : STRUCT, AFF_STRUCT Fichiers : OUVRIR, FERMER, LIRESEQ, ECRIRESEQ, LIREDIR, ECRIREDIR, RAJOUTER, FINFICH, ENTETE, AFF_ENTETE, ALLOC_BLOC

Le langage Z : Opérations de haut niveau Machine-caractères : CREER_MCAR CREER_MNOMBRE Listes : CREER_LISTE Structures : INIT_STRUCT Vecteurs INIT_VECTEUR(ou INIT_TABLEAU) Exemple   CREER-LISTE (L, [12, 23, 67, I, I+J] )

Le langage Z : Fonctions standards Nombres ALEACHAINE(Exp), ALEANOMBRE(Exp) Chaînes de caractères LONGCHAINE(Chaine) , CARACT(Chaine, Exp) Exemples   Aleachaine(5) ; {donne par exemple ‘bxrfd’} Aleanombre(1000); { donne par exemple 675} Longchaine(‘bcdgfd’) ; {donne 6} Caract(‘gfrd’, 3) {donne ‘r’}

Grammaire de Z: Notation EBNF Conventions ~ ---| --- ~  : Choix [ ----]  : Partie facultative [[  : Crochet ouvrant ]]  : Crochet fermant {---}*  : Répétition (  0 )  

Grammaire de Z: Déclarations Types dans {Entier, Booleen, Car, Chaine} Sep dans {:, Un, Une, Des} Cste désigne une constante numérique entière Idf désigne un identificateur Opr dans { <, <=, >, >=, =, <> } Opa dans { +, -, Ou } Opm dans { *, /, Et } Sign dans {+, -} Cstelog dans {Vrai, Faux} Chaîne  chaîne de caractères Tableau est synonyme de Vecteur Init_tableau est synonyme de Init_vecteur

Grammaire de Z: Déclarations <Algo Z>  [ ~ Soit|Soient ~ <Ps> ] Debut <Lis> Fin [;] { ~ <Act> | <Fonct> ~ [;] }*   <Act>  Action Idf [ ( <Li> ) ] [;] [ ~ Soit|Soient ~ <Ps> ] Debut <Lis> Fin <Fonct>  Fonction Idf ( <Li> ) : <Typ> [ ~Soit|Soient ~ <Ps> ] Debut <Lis> Fin <Ps>  <S>;{ [ ~Soit|Soient ~ ] <S>;}* <S>  <Li>[Sep ~ <Typ>| ~Action|Fonction(<Typ>)~ ~] <Li>  Idf {, Idf}*

Grammaire de Z: Déclarations <Typ>  Types | <Structsimple> | <Structcomplexe> | Machine_car | Machine_nombre | [Pointeur vers [Sep] ] Liste [ De ~Types | <Structsimple>~ | Tableau (<Lc>) [De~<Structsimple> | Types~ ] | Fichier De ~ Types | Vecteur(Cste) De ~Types | <Structsimple> | <Structcomplexe> ~ ~ Buffer <Li> [Entete] (Types {, types }*)   <Structsimple>  [Structure ](Types {, Types }*) <Structcomplexe> [Structure ]( ~ Types | Vecteur(Cste) De Types ~ {, ~ Types | Vecteur(Cste) De Types ~ }*)  <Lc>  Cste {, Cste}*

Grammaire de Z: Instructions < Lis >  < Inst > { ; < Inst > }*   <Inst>  Idf := <Exp> | Tantque <Exp> [ : ] <Lis> Fintantque | Si <Exp> [:] <Lis> [Sinon <Lis>] Fsi | Pour Idf:= <Exp>,<Exp> [, <Exp>][:] <Lis> Finpour | Appel Idf [(Exp {,<Exp>}*)] |   Lire ( Idf {, Idf }* ) |   Ecrire (<Exp> {,<Exp>}* ) |

Grammaire de Z: Instructions ~Liberer | Allouer | Fermer~ ( <Exp> ) | Ouvrir ((Idf, Chaine, Chaine) | ~Lirecar|Lirenombre|Lireseq|Ecrireseq|Rajouter~ (Idf, Idf) | ~ Aff_adr|Aff_val~ ( <Exp> , <Exp> ) |   ~ Creer_liste |Init_vecteur|Creer_mnombre| Init_struct ~ ( Idf , [[ ~<Exp>|[[<Exp> {, <Exp>}*]] ~ {, ~<Exp>|[[<Exp> {, <Exp>}*]]~}* ]] ) | Creer_mcar(Idf, [[ Chaine ]]) | Aff_element ( <Exp> [[ <Exp> {, <Exp> }* ]] ,<Exp> ) |   ~Aff_struct|Aff_entete~(Idf, Cste, <Exp>) | ~ Liredir | Ecriredir ~ (Idf, Cste, Idf)

Grammaire de Z: Expressions <Exp>  <Exps>[ Opr <Exps>]   <Exps>  [Sign] <Terme> { Opa <Terme> }* | <Terme>  <Facteur>{Opm <Facteur>}* <Facteur>  Idf [ ( <Exp> {, <Exp>} * ) ] | Cste | <Fonct> | NIL | ( <Exp>) | Chaine | Non <Facteur> | Cstelogic <Fonct>  ~Valeur|Suivant~ ( <Fonct> ) | Element ( <Fonct> [[ <Exp> {, <Exp> }* ]] ) ~Struct |Entete|Caract~ ( Idf, Cste) | ~ Aleachaine | Aleanombre | Longchaine~ ( <Exp> ) | ~Nbrcar|NbrNombre|Finfich|Alloc_bloc~ (Idf)

Grammaire de Z: Compléments Une chaîne de caractères est délimitée par le symbole ‘. Si ce dernier figure dans la chaîne, il est doublé. Les commentaires sont entre les symboles /* et */. Elles sont insérées là où un espace peut figurer.

Grammaire de Z: Expérimentation Bien comprendre la grammaire en expérimentant le langage Z