Une déclaration de variables en C se fait par
Type <Li>;
où <Li> désigne une liste d'identificateurs.
Les objets simples
Equivalents des objets Z --> C
ENTIER se traduit par INT.
CAR se traduit par CHAR.
Au type "CHAINE" on associe le type construit Chaine que l'on définit par
typedef char Chaine[256]
En C le type Booléen n'existe pas.
Pour continuer à travailler toujours avec ce type, il suffit de rajouter au début du programme
typdef int Booleen
et de définir les valeurs True et False comme suit :
#define true 1
#define false 0
Les objet "structures"
Pour définir une structure S en C il faut choisir une implémentation.
Implémenter, c'est choisir une représentation mémoire ( généralement statique ou dynamique ) et traduire les opérations de la machine abstraite dans cette représentation.
Il suffit de remplacer la structure S par Pointeur et rajouter au niveau de l'en-tête du programme C l'implémentation désirée où l'on définira le type Pointeur.
La grammaire des Z-expressions est incluse dans la grammaire C.
Même syntaxe avec le '=' à la place de ':='.
-----------Z----------
TANTQUE Cond :
Instructions
FINTANTQUE
se traduit par :
-------------C-----------
WHILE ( Cond )
{
Instructions
}
--------------Z-----------------
POUR V:= Exp1, Exp2 [, Exp3] [:]
Instructions
FINPOUR
se traduit par ║
---------------C---------------
for (V=Exp1; V<=Exp2; V=V+Exp3)
{
Instructions
}
-----------Z------------
SI Cond :
Instructions
[SINON
Instruction ]
FSI
se traduit par :
----------------C--------------
IF ( Cond )
{
Instructions
}
[ELSE
{Instructions } ]
--------Z--------
LIRE(V1, V2, ...)
se traduit par :
-----------C---------------
scanf("...", &V1, &V2, ...)
--------Z----------
ECRIRE(E1, E2, ...)
se traduit par :
--------C---------
printf(E1, E2, ...)
------------Z-------------
ACTION Nom ( P1, P2, ...);
SOIENT
Définition des objets locaux
et des paramètres
DEBUT
Instructions
FIN
se traduit par :
-----------------C----------------
void Nom ( typ1 P1 , typ2 P2, ...)
{
Définition des objets locaux
Instructions
}
------------------Z------------------
FONCTION Nom ( P1, P2, ...) : type;
SOIENT
Définition des objets locaux
et des paramètres
DEBUT
Instructions
FIN
se traduit par
------------------C------------------
type Nom ( typ1 P1, typ2 P2, ...)
{
Définition des objets locaux
Instructions
}
MOD (a, b)
int Mod( int a, int b)
{ return ( a % b ); }
MIN (a, b)
int Min (int a, int b)
{
if (a < b) return(a);
else return(b);
}
MAX ( a, b )
int Max (int a, int b)
{
if (a > b) return(a);
else return(b);
}
EXP ( a, b )
int Exp (int a, int b)
{
int i; int Ex ;
Ex = 1;
for (i= 1; i<=b; i++)
Ex = Ex * a ;
return (Ex);
}
ALEANOMBRE ( N )
int
Aleanombre( int N )
{ return ( rand() % N ); }
ALEACHAINE
( N )
char *Aleachaine ( int N )
{
int k;
char * Chaine =
malloc(N);
char Chr1[26] = "abcdefghijklmnopqrstuvwxyz";
char Chr2[26] = "ABCDEFGHIJKLMNOPQRSTUVWXYZ";
for (k=0;k<N; k++)
switch ( rand() % 2 ){
case 0 : *(Chaine+k) = Chr1[rand() % 26] ; break ;
case 1 : *(Chaine+k) = Chr2[rand() % 26] ; break ;
}
Chaine[k] = '\0' ;
return (Chaine);
}
LONGCHAINE ( C )
int Longchaine (
string255 Ch )
{
return strlen(Ch);
}
CARACT(Ch, I)
char *Caract ( string255 Ch , int I )
{
char *s = malloc(2);
s[0] = Ch[I-1];
s[1] = '\0';
return s;
}
--------------------Z--------------------
SOIENT
Objets locaux et globaux
Annonce des modules
DEBUT
Instructions
FIN
Module 1
Module 2
...
Modules n
se traduit par :
-------------------C----------------------
Objets locaux et globaux
Définition des modules
Module 1
Module 2
...
Module n
main()
{
Instructions
}