Le langage Z Pr ZEGOUR DJAMEL EDDINE

Présentation au sujet: "Le langage Z Pr ZEGOUR DJAMEL EDDINE"— Transcription de la présentation:

1 Le langage Z Pr ZEGOUR DJAMEL EDDINE
Ecole Supérieure d’Informatique (ESI)

2 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 .

3 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.

4 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.

5 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.

6 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.

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

8 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

9 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) ;

10 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

11 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.

12 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.

13 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.

14 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

15 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] )

16 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’}

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

18 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

19 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}*

20 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}*

21 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>}* ) |

22 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)

23 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)

24 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.

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