home *** CD-ROM | disk | FTP | other *** search
/ OS/2 Shareware BBS: 10 Tools / 10-Tools.zip / mod201j.zip / modula2.exe / os2demo / filosoof / filosoof.mod next >
Text File  |  1996-01-04  |  5KB  |  183 lines
  1. (********************************************************************
  2.   FILOSOOF.MOD    Cooperative multitasking sample program.
  3.  
  4.                   This program demonstrates how to use
  5.                   Modula-2 coroutines to implement a simple
  6.                   cooperative multitasking application.
  7.  
  8.                   Compile and link as follows:
  9.  
  10.                   MOD FILOSOOF -O -B -V
  11.                   LINK386 @FILOSOOF.RSP
  12.  
  13.  
  14.   Copyright (c) 1995 by Johan Terryn (CompuServe 100421,3024)
  15. *********************************************************************)
  16.  
  17. MODULE Filosoof;
  18. FROM   InOut       IMPORT   Write,WriteCard, WriteLn, WriteString;
  19. FROM   Semaphore   IMPORT   Init, PSem, SIGNAL, StartP, VSem;
  20.  
  21. CONST ESC   = 33C;
  22.       Delay = 100;
  23.  
  24. PROCEDURE GotoXY (colon, line : CARDINAL);
  25. (* positions the cursor at the given colon and line *)
  26. BEGIN
  27.   Write (ESC); Write ('[');
  28.   WriteCard (line,0);
  29.   Write (';');
  30.   WriteCard (colon,0);
  31.   Write ('H');
  32. END GotoXY;
  33.  
  34. PROCEDURE ClrScr;
  35. (* the screen is erased and the cursor set in the top left corner *)
  36. BEGIN
  37.   Write (ESC); WriteString ('[2J');
  38.   Write (ESC); WriteString ('[H');
  39. END ClrScr;
  40.  
  41. CONST MaxAantal = 5;
  42.  
  43. TYPE Aantal = [1..MaxAantal];
  44.  
  45. VAR Vorken : ARRAY Aantal OF Aantal;
  46.     Hongerig : ARRAY Aantal OF BOOLEAN;
  47.     Begin, Eeuwigheid, OK, ETEN, DENKEN : SIGNAL;
  48.     Nummer : CARDINAL;
  49.     SigVork, SigFilosoof : ARRAY Aantal OF SIGNAL;
  50.     Plaats : ARRAY Aantal,[1..2] OF CARDINAL;
  51.  
  52. PROCEDURE ZetVork(vork: Aantal; filosoof :Aantal);
  53.  
  54. BEGIN
  55.   PSem(SigVork[vork]);
  56.   Vorken[vork] := filosoof;
  57.   VSem(SigVork[vork]);
  58. END ZetVork;
  59.  
  60. PROCEDURE Vork(vork: Aantal):Aantal;
  61.  
  62. VAR aantal : Aantal;
  63.  
  64. BEGIN
  65.   PSem(SigVork[vork]);
  66.   aantal := Vorken[vork];
  67.   VSem(SigVork[vork]);
  68.   RETURN aantal
  69. END Vork;
  70.  
  71.  
  72. PROCEDURE KrijgtHonger(filosoof: Aantal; honger : BOOLEAN);
  73.  
  74. BEGIN
  75.   PSem(SigFilosoof[filosoof]);
  76.   Hongerig[filosoof] := honger;
  77.   VSem(SigFilosoof[filosoof]);
  78. END KrijgtHonger;
  79.  
  80. PROCEDURE HeeftHonger(filosoof: Aantal): BOOLEAN;
  81.  
  82. VAR honger : BOOLEAN;
  83.  
  84. BEGIN
  85.   PSem(SigFilosoof[filosoof]);
  86.   honger := Hongerig[filosoof];
  87.   VSem(SigFilosoof[filosoof]);
  88.   RETURN honger
  89. END HeeftHonger;
  90.  
  91. PROCEDURE Philosoof;
  92.  
  93. VAR Ik, RechtsVanMij,LinksVanMij : Aantal;
  94.     Tel ,i : CARDINAL;
  95.  
  96. BEGIN
  97.   Ik := Nummer;
  98.   KrijgtHonger(Ik,FALSE);
  99.   RechtsVanMij := (Ik MOD MaxAantal) + 1;
  100.   LinksVanMij  := ((Ik + (MaxAantal-2)) MOD MaxAantal) +1;
  101.   ZetVork(Ik,Ik);
  102.   VSem(OK);
  103.   PSem(Begin);
  104.   Tel := 0;
  105.   LOOP
  106.     INC(Tel);
  107.     IF Tel = 100 THEN VSem(Eeuwigheid) END;
  108.     KrijgtHonger(Ik,TRUE);
  109.     WHILE HeeftHonger(LinksVanMij)  OR HeeftHonger(RechtsVanMij) DO
  110.       WHILE  (HeeftHonger(LinksVanMij) AND (Vork(Ik) # Ik))
  111.           OR (HeeftHonger(RechtsVanMij) AND (Vork(RechtsVanMij) # Ik))DO
  112.         KrijgtHonger(Ik,FALSE);
  113.       END (* while *);
  114.       KrijgtHonger(Ik,TRUE);
  115.     END (* while *);
  116.     GotoXY(Plaats[Ik][1],Plaats[Ik][2]);
  117.     WriteString("(<.>) (<.>)");
  118.     GotoXY(Plaats[Ik][1],Plaats[Ik][2]+1);
  119.     WriteString("     ^     ");
  120.     GotoXY(Plaats[Ik][1],Plaats[Ik][2]+2);
  121.     WriteString("    ≤=≥    ");
  122.     VSem(ETEN);
  123.     FOR  i := 1 TO Delay DO
  124.       GotoXY(0,0);
  125.     END (* for *);
  126.     PSem(ETEN);
  127.     GotoXY(Plaats[Ik][1],Plaats[Ik][2]);
  128.     WriteString("(<°>) (<°>)");
  129.     GotoXY(Plaats[Ik][1],Plaats[Ik][2]+1);
  130.     WriteString(" (   ^   ) ");
  131.     GotoXY(Plaats[Ik][1],Plaats[Ik][2]+2);
  132.     WriteString("     O     ");
  133.     KrijgtHonger(Ik,FALSE);
  134.     ZetVork(Ik,LinksVanMij);
  135.     ZetVork(RechtsVanMij,RechtsVanMij);
  136.     GotoXY(Plaats[Ik][1],Plaats[Ik][2]);
  137.     WriteString("(───) (───)");
  138.     GotoXY(Plaats[Ik][1],Plaats[Ik][2]+1);
  139.     WriteString(" (   ^   ) ");
  140.     GotoXY(Plaats[Ik][1],Plaats[Ik][2]+2);
  141.     WriteString("    ───    ");
  142.     VSem(DENKEN);
  143.     FOR  i := 1 TO Delay DO
  144.       GotoXY(0,0);
  145.     END (* for *);
  146.     PSem(DENKEN);
  147.     GotoXY(Plaats[Ik][1],Plaats[Ik][2]);
  148.     WriteString("(<≈>) (<≈>)");
  149.     GotoXY(Plaats[Ik][1],Plaats[Ik][2]+1);
  150.     WriteString("   ) ^ (   ");
  151.     GotoXY(Plaats[Ik][1],Plaats[Ik][2]+2);
  152.     WriteString("     ≈     ");
  153.   END (* loop *);
  154. END Philosoof;
  155.  
  156. BEGIN
  157.   Plaats[1][1] := 10; Plaats[1][2] := 5;
  158.   Plaats[2][1] := 50; Plaats[2][2] := 5;
  159.   Plaats[5][1] := 10; Plaats[5][2] := 13;
  160.   Plaats[3][1] := 50; Plaats[3][2] := 13;
  161.   Plaats[4][1] := 30; Plaats[4][2] := 21;
  162.   Init(Begin);
  163.   Init(ETEN);
  164.   Init(DENKEN);
  165.   Init(Eeuwigheid);
  166.   Init(OK);
  167.   ClrScr;
  168.   FOR Nummer := 1 TO MaxAantal DO
  169.     Init(SigVork[Nummer]);
  170.     Init(SigFilosoof[Nummer]);
  171.     VSem(SigVork[Nummer]);
  172.     VSem(SigFilosoof[Nummer]);
  173.   END; (* for*)
  174.   FOR Nummer := 1 TO MaxAantal DO
  175.      StartP(Philosoof,4096);
  176.      PSem(OK);
  177.   END; (* for*)
  178.   FOR Nummer := 1 TO MaxAantal DO
  179.      VSem(Begin);
  180.   END; (* for*)
  181.   PSem(Eeuwigheid);
  182. END Filosoof.
  183.