program PHILO;

(*----------------------------------------------------------------*)
(*----------------------------------------------------------------*)
(*               PROGRAMME SIMULANT LE PROBLEME                   *)
(*              DES PHILOSOPHES ET DES SPAGHETTIS                 *)
(*----------------------------------------------------------------*)
(*----------------------------------------------------------------*)


 UNIT ecran : IIUWGRAPH PROCESS (n:integer);
 (*--------------------------------------------*)
 (* - -     PROCESSUS SIMULANT L'ECRAN     - - *)
 (*--------------------------------------------*)
  VAR k :integer;

  (*---------------------------------------------------*)
  (* PROCEDURE permettant d'utiliser le mode GRAPHIQUE *)
  (*---------------------------------------------------*)
  UNIT initgraph : PROCEDURE;
   BEGIN
     CALL GRON(1);
   END initgraph;

  (*---------------------------------------------------*)
  (* PROCEDURE permettant de fermer le mode GRAPHIQUE  *)
  (*---------------------------------------------------*)
  UNIT closegraph : PROCEDURE;
   BEGIN
     CALL GROFF;
   END closegraph;

  (*----------------------------------------------------------------*)
  (* AFFICHAGE en (x,y) d'un RECTANGLE de longueur l et de hauteur h *)
  (*-----------------------------------------------------------------*)
  UNIT rectangle : PROCEDURE(x,y,l,h : INTEGER);
   BEGIN
    CALL MOVE (x,y);
    CALL DRAW (x+l,y);
    CALL DRAW(x+l,y+h);
    CALL DRAW(x,y+h);
    CALL DRAW(x,y);
   END rectangle;


  (*--------------------------------------------------------------------*)
  (* ECRITURE d'une CHAINE de caracteres sur l'ecran graphique en (x,y) *)
  (*--------------------------------------------------------------------*)
  UNIT ecrit_text : PROCEDURE(xy,x,y : INTEGER;str : string);
   VAR ch : ARRAYOF CHARACTER,
       lg,i : INTEGER;
   BEGIN
    call color (xy);
    CALL move (x,y);
    ch := UNPACK(str);
    lg := UPPER(ch) - LOWER(ch) + 1;
    FOR i := 1 TO lg DO
      CALL HASCII(0);
      CALL HASCII(ORD(ch(i)));
    OD;
   END;

  (*---------------------------------*)
  (* LECTURE d'une touche au clavier *)
  (*---------------------------------*)
  UNIT inchar : FUNCTION : INTEGER;
   VAR i : INTEGER;
   BEGIN
    DO
      i := INKEY;
      IF i =/= 0 THEN EXIT;
      FI;
    OD;
    result := i;
   END inchar;



  UNIT finir : PROCEDURE;
   var car : integer;
   BEGIN
    k:=k+1;
    IF k = 5
      THEN call color(4);
           CALL ecrit_text (12,500,320,"TOUCHE");
           car:= inchar;
           (* FERMETURE DU MODE GRAPHIQUE *)
           CALL closegraph;
           CALL endrun;
    FI;
   END finir;

  BEGIN
    RETURN;
    DO
      ACCEPT initgraph,closegraph,rectangle,ecrit_text,inchar,finir;
    OD;
  END ecran;

(*-------------------------------------------------------------------------*)

UNIT philosophe:PROCESS(node,nr,x,y:integer,gardien:garde,fourl,
                        fourr:fourchette,e:ecran);
  (*-------------------------------------------------*)
  (* - -     PROCESSUS SIMULANT UN PHILOSOPHE    - - *)
  (*-------------------------------------------------*)

 var i,fin,car : integer, bol,bor:boolean;

  BEGIN
   RETURN;
   fin:=1;

   (* TANT QUE LE PHILOSOPHE N'EST PAS RENTRE 4 FOIS DANS LA SALLE *)
   WHILE (fin<=4)
    DO

     (* 1ER TEMPS IL PENSE *)
     CALL e.ecrit_text (14,x,y,"PENS");
     FOR i:=1 TO 80
      DO
      OD;

     (* 2 EME TEMPS IL DEMANDE AU GARDIEN L'AUTORISATION POUR RENTRER *)
     CALL gardien.entree;
     CALL e.ecrit_text (10,x,y,"ENTR");

     (* 3EME TEMPS IL PREND LA FOURCHETTE DE GAUCHE ET LA CELLE DE DROITE *)
     WHILE ((NOT bol) OR (NOT bor))
      DO
       IF (not bol) THEN
            CALL fourl.prendre(bol);
            IF bol THEN CALL e.ecrit_text (11,x,y,"FGAU"); FI;
       FI;
       IF (not bor) THEN
        CALL fourr.prendre(bor);
        IF bor THEN CALL e.ecrit_text (11,x,y,"FDRO"); FI;
       FI;
      OD;

     (* 4EME TEMPS IL MANGE PENDANT UN TEMPS FINI *)
     CALL e.ecrit_text (12,x,y,"MANG");

     FOR i:=1 TO 40
      DO
      OD;

     (* 5EME TEMPS IL DEPOSE LES FOURCHETTES *)
     CALL fourl.poser(bol);
     CALL fourr.poser(bor);
     CALL e.ecrit_text (13,x,y,"LIBE");

     (* 6EME TEMPS IL SORT DE LA SALLE *)
     CALL gardien.sortie;
     CALL e.ecrit_text (14,x,y,"SORT");
     fin:=fin+1;
   OD;

   (* ENFIN IL VA SE COUCHER *)
   CALL e.ecrit_text (9,x,y,"DORT");
   CALL e.finir;
  END philosophe;

(*-------------------------------------------------------------------------*)

  UNIT garde : PROCESS(node : integer,level : integer);
  (*-------------------------------------------------*)
  (* - -     PROCESSUS SIMULANT LE GARDIEN       - - *)
  (*-------------------------------------------------*)
    UNIT entree : PROCEDURE;
    (*-------------------------------------------*)
    (* PROCEDURE permettant de gerer les entrees *)
    (*        dans la SALLE A MANGER             *)
    (*-------------------------------------------*)
     BEGIN
       IF level > 0 THEN
            level := level - 1;
            IF level = 0 THEN
               return DISABLE entree;
            FI;
       FI;
     END entree;

    UNIT sortie : PROCEDURE;
    (*-------------------------------------------*)
    (* PROCEDURE permettant de gerer les sorties *)
    (*          de la SALLE A MANGER             *)
    (*-------------------------------------------*)
     BEGIN
         level:=level+1;
         return ENABLE entree;
     END sortie;

    BEGIN
     ENABLE entree,sortie;
     RETURN;
     DO

     OD;
    END garde;

(*-------------------------------------------------------------------------*)

  UNIT fourchette : PROCESS (node : integer);
  (*-------------------------------------------------*)
  (* - -     PROCESSUS SIMULANT UNE FOURCHETTE   - - *)
  (*-------------------------------------------------*)

   var aux : boolean;

    UNIT prendre : PROCEDURE (output bo : boolean);
    (*---------------------------------------------------*)
    (* PROCEDURE retournant un booleen qui indique si la *)
    (*     fourchette qui est demandee est disponible    *)
    (*---------------------------------------------------*)
     BEGIN
      IF aux THEN
        bo := true;
        aux := false;
       ELSE
        bo:= false;
      FI;
     END prendre;

    UNIT poser : PROCEDURE (output b : boolean);
    (*---------------------------------------------------*)
    (* PROCEDURE permettant de rendre disponible  la     *)
    (*                    fourchette                     *)
    (*---------------------------------------------------*)
     BEGIN
      aux := true;
      b:= false;
     END poser;

    BEGIN
     aux := true;
     ENABLE prendre,poser;
     RETURN;
     DO

     OD;
    END fourchette;


(*-------------------------------------------------------------------------*)


   var
   i,j:integer,                (* Variable de travail et Indice de tableau *)
   gardien : garde,            (* Gardien de la salle a manger             *)
   f : arrayof fourchette,     (* Tableau des cinq processus fourchettes   *)
   f0:fourchette,              (* Variable intermediaire permettant de     *)
                               (*     remplir le tableau precedent         *)
   ph : arrayof philosophe,    (* Tableau des cinq processus philosophe    *)
   ph0:philosophe,             (* Variable intermediaire permettant de     *)
                               (*     remplir le tableau precedent         *)
   e:ecran,                    (* Variable de type processus ECRAN         *)
   car:integer;                (* Variable de travail pour une attente     *)
                               (*     avant la suite de deroulement du     *)
                               (*                 programme                *)


(*-------------------------------------------------------------------------*)

 BEGIN

    (* CREATION DU PROCESSUS ECRAN *)
    e:=NEW ecran(0);

    (* PROCESSUS ECRAN RENDU ACTIF *)
    RESUME (e);

    (* OUVERTURE DE L'ENVIRONEMENT GRAPHIQUE *)
    CALL e.initgraph;

    (* EFFACEMENT DE L'ECRAN *)
    CALL e.cls;

    (* AFFICHAGE DE LA PRESENTATION *)
    CALL e.rectangle (1,1,635,348);
    CALL e.rectangle (100,50,435,100);
    CALL e.ecrit_text (15,160,95,"LES 5 PHILOSOPHES ET LES SPAGHETTIS");
    CALL e.ecrit_text (15,140,200,"PROGRAMME REALISE PAR CHASTANET STEPHANIE");
    CALL e.ecrit_text (15,160,300, "<TAPER SUR UNE TOUCHE POUR CONTINUER>");
    car:=e.inchar;

    (* AFFICHAGE DE LA SALLE A MANGER ET DE LA DISPOSITION DES PHILOSOPHES *)
    CALL e.cls;
    CALL e.rectangle(1,1,600,348);
    CALL e.ecrit_text(15,245,15,"LA SALLE A MANGER");
    CALL e.CIRB(300,170,170,0,0,1,1,1,1);
    CALL e.color(1);
    CALL e.cirb(215,90,25,0,0,1,1,1,1);
    CALL e.color(3);
    CALL e.ecrit_text(15,160,70,"1");
    CALL e.color(1);
    CALL e.cirb(165,200,25,0,0,1,1,1,1);
    CALL e.color(3);
    CALL e.ecrit_text(15,110,200,"2");
    CALL e.color(1);
    CALL e.cirb(390,90,25,0,0,1,1,1,1);
    CALL e.color(3);
    CALL e.ecrit_text(15,430,70,"5");
    CALL e.color(1);
    CALL e.cirb(435,200,25,0,0,1,1,1,1);
    CALL e.color(3);
    CALL e.ecrit_text(15,470,200,"4");
    CALL e.color(1);
    CALL e.cirb(300,270,25,0,0,1,1,1,1);
    CALL e.color(3);
    CALL e.ecrit_text(15,295,300,"3");

    (* AFFICHAGE DU GARDIEN *)
    CALL e.color(15);
    CALL e.cirb(615,92,5,0,0,1,1,1,1);
    CALL e.move (615,100);
    CALL e.draw (615,125);
    CALL e.move (610,110);
    CALL e.draw (620,110);

    (* CREATION D'UN PROCESSUS GARDIEN *)
    gardien := NEW garde(0,4);

    (* DECLARATION ET CREATION DU TABLEAU DES PROCESSUS PHILOSOPHES *)
    ARRAY ph DIM (1:5);

    (* DECLARATION ET CREATION DU TABLEAU DES PROCESSUS FOURCHETTES *)
    ARRAY f DIM (0:4);

    (* INITIALISATION DU TABLEAU DES PROCESSUS FOURCHETTES *)
    FOR i:= 0 TO 4
     DO

      (* CREATION D'UN PROCESSUS FOURCHETTE *)
      f0 := NEW fourchette(0);
      f(i) :=f0;

      (* PROCESSUS FOURCHETTE RENDU ACTIF *)
      RESUME (f(i));
     OD;

    (* PROCESSUS GARDIEN RENDU ACTIF *)
    RESUME (gardien);

    (* POUR LES 5 PROCESSUS PHILOSOPHES, CREATION DU PROCESSUS *)
    i:=1;
    ph0 := NEW philosophe (0,1,120,70,gardien,f(i-1),f(i mod 5),e);
    ph(1) := ph0;
    i:=2;
    ph0 := NEW philosophe (0,2,70,200,gardien,f(i-1),f(i mod 5),e);
    ph(2) := ph0;
    i:=3;
    ph0 := NEW philosophe (0,3,290,320,gardien,f(i-1),f(i mod 5),e);
    ph(3) := ph0;
    i:=4;
    ph0 := NEW philosophe (0,4,500,200,gardien,f(i-1),f(i mod 5),e);
    ph(4) := ph0;
    i:=5;
    ph0 := NEW philosophe (0,5,460,70,gardien,f(i-1),f(i mod 5),e);
    ph(5) := ph0;

    (* POUR CHAQUE PROCESSUS PHILOSOPHE DU TABLEAU *)
    FOR i:=1 TO 5
     DO
      FOR j:=1 TO 700 DO  OD;

      (* PROCESSUS PHILOSOPHE RENDU ACTIF *)
      RESUME (ph(i));
     OD;

 END PHILO.