Passage de Z vers C

 

Déclarations                                

Expressions

Affectation                                                         

La boucle Tantque                           

La boucle Pour                             

L'alternative Si                           

Lecture                        

Ecriture                                 

Action composée                             

Fonction                                     

Fonctions standards                  

            Algorithme

 

 

 

Déclaration des variables

 

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.

 

Expressions

 

 

La grammaire des Z-expressions est incluse dans la grammaire C.

 

 

Affectation

 

Même syntaxe avec le '=' à la place de ':='.

 

 

Boucle "TANTQUE"

 

  -----------Z----------       

  TANTQUE  Cond :               

        Instructions

  FINTANTQUE

 

se traduit par :

 

  -------------C-----------

  WHILE ( Cond )

    {

      Instructions

    }

 

Boucle "POUR"

 

  --------------Z-----------------

  POUR V:= Exp1, Exp2 [, Exp3] [:]

       Instructions

  FINPOUR

 

se traduit par          

 

  ---------------C---------------

  for (V=Exp1; V<=Exp2; V=V+Exp3)

    {

       Instructions

    }

 

L'alternative "SI"

 

   -----------Z------------    

  SI Cond :                                                  

       Instructions                                             

  [SINON                                                     

       Instruction  ]            

  FSI                            

 

se traduit par :

 

----------------C--------------

IF ( Cond )

 {

   Instructions

 }

[ELSE

 {Instructions } ]

 

 

Lecture

 

  --------Z--------           

  LIRE(V1, V2, ...)    

 

 

se traduit par :

 

  -----------C---------------

  scanf("...", &V1, &V2, ...)

 

Ecriture

 

  --------Z----------         

  ECRIRE(E1, E2, ...)  

 

se traduit par :

  --------C---------

  printf(E1, E2, ...)

 

 

Action composée

 

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

    }

 

Fonctions

 

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

    }

 

Fonctions prédéfinies

 

  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;
       }

 

 

Algorithme

 

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

   }