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 premierest 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 etCHAINE .

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 1Module 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

SOIENTMot : 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 ; LIRECAR(M, 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

{ Instructions }

FPOURE3 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, NBRCARMachine-nombres :

LIRENOMBRE, NBRNOMBREListes linéaires chaînées :

ALLOUER , LIBERER , VALEUR, SUIVANT, AFF_ADR, AFF_VAL

Vecteurs :

ELEMENT, AFF_ELEMENTStructures :

STRUCT, AFF_STRUCTFichiers :

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_MCARMachine-caractères :

CREER_MNOMBREListes :

CREER_LISTEStructures :

INIT_STRUCTVecteurs

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

<Inst> ~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