Passage de Z vers PASCAL

 

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 PASCAL se fait par

     VAR <Li> : Type;

où <Li> désigne une liste d'identificateurs.

 

  SOIT (SOIENT) se traduit par VAR.

 

Les objets simples

    

Equivalents des objets Z --> PASCAL

      Z          PASCAL

 

      ENTIER     INTEGER

      BOOLEEN    BOOLEAN

 

 

Expressions

 

La grammaire des Z-expressions est incluse dans la grammaire PASCAL

 

Affectation

 

 Même syntaxe

 

 

Boucle "TANTQUE"

 

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

 TANTQUE  Cond :              

                                 

      instructions   

                                 

 FINTANTQUE

 

-------PASCAL------

 WHILE ( Cond ) DO

   BEGIN

     Instructions

   END

 

Boucle "POUR" 

 

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

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

       Instructions

  FINPOUR

 

  Si Exp3 est absent ou égale à 1

 

Se traduit par :

 

  --------PASCAL---------

  FOR V:= Exp1 TO Exp2 DO

    BEGIN

        Instructions

    END

 

  Si Exp3 <> 1 :

 

  ----------PASCAL------

  V := Exp1;

  WHILE ( V <= Exp2 ) DO

    BEGIN

       Instructions  ;

      V := V + Exp3

    END;

 

L'alternative "SI"

 

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

  SI Cond :                    

                                  

       Instructions              

 

  [SINON                

                        

       Instruction  ]   

  FSI                   

 

Se traduit par :

 

  -------PASCAL---------

 IF Cond

 THEN

   BEGIN

     Instructions

   END

 [ELSE

    BEGIN

      Instructions

    END]

 

Lecture

  

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

    LIRE(V1, V2, ...)    

 

Se traduit par :

 

    ------PASCAL------

    READLN(V1, V2, ...)

 

 

Ecriture

 

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

   ECRIRE(Exp1, Exp2, ...)  

 Se traduit par

 

   --------PASCAL----------

   WRITELN(Exp1, Exp2, ...)

 

 

Action composée

 

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

  ACTION Nom ( P1, P2, ...)

  SOIENT

        Définition des objets locaux

         et des paramètres

  DEBUT

        Instructions

  FIN

 

Se traduit par :

 

  --------------------PASCAL--------------------

  PROCEDURE Nom ( VAR P1: typ; VAR P2:typ, ...);

  VAR

         Définition des objets locaux

  BEGIN

         Instructions

  END

 

Fonctions

 

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

  FONCTION Nom ( P1, P2, ...) : Type

  SOIENT

        Définition des objets locaux

         et des paramètres

  DEBUT

        Instructions

  FIN

 

Se traduit par :

 

  ---------------------PASCAL------------------------

  FUNCTION Nom ( VAR P1: typ; VAR P2:typ, ...) : Type;

  VAR

         Définition des objets locaux

  BEGIN

         Instructions

  END

 

Fonctions prédéfinies

 

  MOD (a, b)

 

FUNCTION Mod (a, b : INTEGER) : INTEGER;

  BEGIN

    Mod := a Mod b

  END;

 

  MIN (a, b)

 

FUNCTION Min (a, b: INTEGER) : INTEGER;

  BEGIN

    Min := a; IF b < a THEN Min := b;

  END;

 

  MAX ( a, b )

 

FUNCTION Max (a, b: INTEGER) : INTEGER;

  BEGIN

    Max := a; IF b > a THEN Max := b;

  END;

 

  EXP ( a, b )

 

FUNCTION Exp (a, b: INTEGER) : INTEGER;

  VAR I : INTEGER;

  BEGIN

    Exp := 1;

    FOR I:= 1 TO b DO Exp := Exp * a

  END;

 

  ALEAENTIER ( N )

 

FUNCTION Aleaentier (N: INTEGER) : INTEGER;

  BEGIN

    Aleaentier := Random( N );

  END;

 

  ALEACHAINE ( N )

 

FUNCTION Aleachaine(N: INTEGER) : STRING;

  VAR

    K : BYTE;

    Chaine : STRING;

  BEGIN

    Chaine := '';

    FOR K:=1 TO N DO

      CASE Random(2) OF

      0 : Chaine := Chaine + CHR(97+Random(26) ) ;

      1 : Chaine := Chaine + CHR(65+Random(26) )

      END;

    Aleachaine := Chaine;

  END;

 

  LONGCHAINE ( C )

 

FUNCTION Longchaine(C : STRING): INTEGER;

  BEGIN

    Min := a; IF b < a THEN Min := b;

  END;

 

Algorithme

 

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

  SOIENT

 

      Objets locaux et globaux

      Annonce des modules

 

  DEBUT

 

      Instructions

 

  FIN

 

  Module 1

  Module 2

  ...

  Modules n

 

Se traduit par :

 

 ------------------PASCAL---------------

 PROGRAM  Pascal;

   VAR

         Objets locaux et globaux

 

   { Définition des modules }

   Module 1

   Module 2

   ...

   Module n

 

   BEGIN

         Instructions

   END.