Remarques
[ ] désigne une partie facultative
{ .... } désigne ensemble
V désigne une variable et Exp une expression.
> Un Z-algorithme est un ensemble de modules parallèles dont le premier est principal et les autres sont soient des actions composées soient des fonctions.
> 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.
> Le langage permet l'affectation globale de tout type.
> Quatre types standards (scalaires )sont autorisés : ENTIER, BOOLEEN, CARACTERE, CHAINE.
> Le langage est l'ensemble des algorithmes abstraits, écrits base de modèles ou machines abstraites.
> On définit ainsi des machines de TURING : machine-caractères et machine-nombres permettant l'initiation à l'algorithmique.
> On définit également des machines abstraites sur
- les structures ou objets composés
- les vecteurs
- les listes mono directionnelles
- les fichiers
permettant l'initiation aux structures élémentaires de données et de fichiers.
> Le langage peut être étendu avec d'autres machines abstraites.
> Le langage est doté des opérations de haut niveau permettant de construire des listes ou d'initialiser les structures ou les vecteurs partir d'un ensemble de valeurs.
> Le langage offre deux fonctions très utiles pour l'expérimentation sur les fichiers permettant de générer aléatoirement des chaines de caractères (ALEACHAINE) et des entiers (ALEANOMBRE).
> 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 est libre.
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
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
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 chaines de caractères )
Elle permettent de remplir une structure de données (ou initialiser une machine) à partir d'un ensemble d'expressions.
INIT_VECTEUR ( T, [Exp1, Exp2, ....] ) Ou INIT_TABLEAU
INIT_STRUCT ( S, [Exp1, Exp2, ....] )
CREER_LISTE ( L, [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é.
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)
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.
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 }
Exemples
SOIENT
A, B, Trouv : BOOLEENS ;
X, Y, Z DES BOOLEENS ;
A : ENTIERS ;
X, Y, Z DES CHAINES ;
Voir aussi
Tableaux Structures Listes linéaires chaînées Fichiers
On définit aussi des variables de type "Pointeur" pour la manipulation des listes linéaires chaînées.
[SOIT/SOIENT] <li> Sep POINTEUR VERS Sep <type>
Exemple
P1 : POINTEUR VERS LISTE DE CAR;
P2, P2 DES POINTEURS VERS LISTE;
Voir aussi Scalaires
Une structure est un ensemble d'éléments hétérogènes.
Une structure peut être simple, c'est dire composée uniquement de scalaires.
Une structure peut être complexe, c'est dire composée de scalaires et/ou de vecteurs une dimension de scalaires.
Définition des structures
[SOIT/SOIENT] <Li> Sep [STRUCTURE] ( Type1, type2, ... )
<Li> : Liste d'identificateurs séparés par des virgules.
Sep dans { :, Un, Une, Des }
Typei est soit un type scalaire soit un tableau une dimension de scalaires.
Exemples
SOIENT
S1 : (ENTIER, CHAINE) ;
S2 UNE STRUCTURE ( CHAINE, ENTIER, BOOLEEN) ;
S3 UN ( ENTIER, VECTEUR(5) DE CHAINE);
Voir {machine sur les Structures:mstruct}
Voir aussi
Scalaires Tableaux Listes linéaires chaînées Fichiers
Un tableau est un ensemble d'éléments homogènes.
Un tableau ( ou vecteur) peut être simple, c'est dire composée uniquement de scalaires.
Un tableau peut être complexe, c'est dire composée de structures simples.
Définition des tableaux
[SOIT/SOIENT] <Li> sep VECTEUR (Dim1, Dim2, ... ) de Types
<Li> : Liste d'identificateurs séparés par des virgules.
Sep dans { :, Un, Une, Des }
Si le type n'est pas spécifié, il s'agit des entiers.
sinon Types est un scalaire ou une structure simple.
Exemples
SOIENT
S1 UN TABLEAU (5);
S2, S3 DES VECTEURS (3, 8) DE CHAINES;
Voir aussi
Scalaires Structures Listes linéaires chaînées Fichiers
Une liste linéaire chaînée est un ensemble de maillons alloués dynamiquement.
Un élément possède deux champs : Valeur et Adresse.
Le champ 'Valeur' peut être quelconque.
Définition des listes
[SOIT/SOIENT] <Li> Sep
LISTE [ DE Types ]
<Li> : Liste d'identificateurs séparés par des virgules.
Sep dans { :, Un, Une, Des }
Types est un scalaire ou une structure simple.
Exemples
L1 UNE LISTE DE (CHAINE, ENTIER);
L2 UNE LISTE DE PILE DE CHAINE ;
L3 UNE LISTE DE CHAINES;
Voir machine sur les Listes linéaires chaînées
Voir aussi
Scalaires Tableaux Structures Fichiers
Un fichier est un ensemble d'enregistrements ( ou structures ) rangés généralement sur un disque.
Les enregistrements peuvent être des articles pour un utilisateur.
Les enregistrements peuvent être des blocs pour un concepteur.
Le fichier renferme une partie indispensable ( En-tête ) pour la conception de structures de fichiers.
Définition des fichiers
[SOIT/SOIENT] <Li> sep
FICHIER DE type
BUFFER <Li>
[ENTETE ( Type1, Type2, .... ) ]
<Li> : Liste d'identificateurs séparés par des virgules.
Sep dans { :, Un, Une, Des }
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 ou bloc) du fichier peut être
- un scalaire
- un vecteur une dimension de scalaires
- une structure complexe ( pouvant contenir des scalaires
et/ou des vecteurs une dimension de scalaires)
La deuxième partie (ENTETE) définit les caractéristiques du fichier en précisant le type de chacune d'entre elles.
Cette partie est facultative et est surtout utilisée pour la création de structures de fichiers. elle sert mémoriser toutes
les informations utiles pour l'exploitation du fichier.
La troisième partie (BUFFER) définit les variables Tampon utilisées dans les opérations de lecture/écriture.
Exemples
SOIENT
F1 UN FICHIER DE CHAINES BUFFER V1, V2;
F2 UN FICHIER DE VECTEUR(5) DE ENTIER BUFFER V ;
F3 UN FICHIER DE (ENTIER, VECTEUR(3) DE CAR) ;
BUFFER V ENTETE(ENTIER,ENTIER) ;
F4 UN FICHIER DE CAR BUFFER V ENTETE (ENTIER, CHAINE, BOOLEEN) ;
Voir aussi
Scalaires Tableaux Structures Listes linéaires chaînées
Comme dans les langages de programmation.
Expressions arithmétiques : + , - , / , *
Expressions logiques : ET, OU, NON
Expressions sur chaines 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
on définit deux machines de Turing permettant de développer des algorithmes sur les chaines de caractères et les suites de nombres.
Machine-caractères Machine-nombres
C'est l'ensemble des opérations suivantes :
CREER_MCAR (M, [' cccccc ']);
Initialise la machine-caractères M avec la chaine de caractères se trouvant entre crochets.
LIRECAR ( M, C)
Récupère dans la variable caractère C le prochain caractère de la machine M.
NBRCAR(M)
Fournit le nombre total de caractères dans la machine M.
C'est l'ensemble des opérations suivantes :
CREER_MNOMBRE (M, [ Exp1, Exp2, ....]);
Initialise la machine-nombres M avec les valeurs des expressions Exp1, Exp2, ...
LIRENOMBRE ( M, Nombre)
Récupère dans la variable entière Nombre le prochain entier de la machine M.
NBRNOMBRE(M)
Fournit le nombre total de caractères contenus dans la machine M.
On définit :
- des machines sur les structures élémentaires de données
- des machines de TURING
Définition des machines relatives aux structures élémentaires de données
[SOIT/SOIENT] <li> Sep <Machine> DE Types
<Li> : Liste d'identificateurs séparés par des virgules.
Sep dans { :, Un, Une, Des }
Machine dans { VECTEUR, LISTE, STRUCTURE, FICHIER}
Types étant un scalaire ou une structure simple.
Définition des machines de TURING
[SOIT/SOIENT] <li> Sep Machine_Car ( ou Machine_nombre)
Exemples
L1, L2 DES LISTES;
V1 UN VECTEUR(10, 60);
S UNE STRUCTURE (ENTIER, BOOLEEN);
L3 UNE LISTE DE STRUCTURES (CHAINE, ENTIER );
Machine abstraite sur les listes linéaires chaînées
ALLOUER ( P )
Crée un maillon et retourne son adresse dans P.
LIBERER ( P )
Libère le nœud d'adresse P.
SUIVANT ( P )
Accès au champ d'adresse' du nœud référencé par P.
VALEUR ( P )
Accès au champ 'Valeur' du nœud référencé par P.
AFF_ADR ( P, Q )
Affecter au champ 'Adresse' du nœud référencé par P, l'adresse Q.
AFF_VAL( P, Val )
Affecter au champ 'Valeur' du nœud référencé par P, la valeur Val.
Voir aussi
Machine abstraite sur les structures
STRUCT ( S, i)
Accès au i-ème champ de la structure S
AFF_STRUCT ( S, i, Exp )
Affecter la structure S dans son i-ème champ l'expression Exp.
Voir aussi
Listes mono directionnelles Vecteurs Fichiers
Machine abstraite sur les vecteurs
ELEMENT ( T [i, j, ...] )
Accès l'élément T[i, j, ...] du vecteur T.
AFF_ELEMENT ( T [I, J, ...], Val )
Affecter l'élément T[i, j, ...] la valeur Val.
Voir aussi
Listes mono directionnelles Structures Fichiers
Machine abstraite sur les fichiers
OUVRIR (Fl, Fp, Mode)
Ouvrir le fichier logique Fl et l'associer au fichier physique Fp en précisant le mode
( fichier nouveau('N') ou ancien 'A') )
FERMER (Fl)
Fermer le fichier Fl.
LIRESEQ (Fl, V)
Lire dans la variable tampon V le bloc (ou l'article) se trouvant la position courante.
ECRIRESEQ (Fl, V)
Ecrire le contenu de la variable tampon V la position courante du fichier Fl.
LIREDIR (Fl, V, N) :
Lire le N-ième bloc (ou article) du fichier Fl dans la variable tampon V.
ECRIREDIR (Fl, V, N)
Ecrire le contenu de la variable tampon V la N-ième position du fichier Fl.
RAJOUTER(Fl, V)
Ecrire le contenu de la variable tampon la fin du fichier Fl.
FINFICH(Fl)
Prédicat égal vrai si la fin du fichier Fl est rencontrée, faux sinon.
ALLOC_BLOC(Fl)
fournit un bloc (ou article) du fichier dans lequel on pourra écrire.
ENTETE(Fl, I)
Récupérer la I-ième caractéristique du fichier Fl.
AFF_ENTETE(Fl, I, Exp)
Affecter Exp comme la I-ème caractéristique du fichier.
Voir aussi
Listes mono directionnelles Structures Vecteurs
ALEACHAINE (n)
fournit une chaine aléatoire de n caractères parmi les caractères alphabétiques majuscule et
minuscule.
ALEANOMBRE(n)
fournit un nombre aléatoire entre 0 et n-1
LONGCHAINE(s)
retourne la longueur de la chaine s.
CARACT(s, i)
retourne le i-ème caractère de la chaine s.
Les commentaires peuvent être insérés dans tout endroit où on peut avoir un blanc.
Les commentaires sont entre { et } ou /* et */.
{ A5 : Nombre de mots }
SOIENT
Mot : CHAINE;
C : CAR;
DEBUT
CREER_MCAR(M, [' Jhjh Jsthd Lkqlsjsh Mlqmlifd .']);
LIRECAR(M, C);
TANTQUE C <> '.'
TANTQUE (C=' ') ET (C <> '.')
LIRECAR(M, C)
FINTANTQUE ;
Mot := '';
TQ (C <> ' ') ET (C <> '.')
Mot := Mot + C ;
LIRECAR(M, C)
FTQ;
SI Mot <> '' ECRIRE(Mot) FSI
FINTANTQUE
FIN
A
B
C
D
E
F
I
L
M
N
O
P
R
S
T
U
V