home *** CD-ROM | disk | FTP | other *** search
/ Power-Programmierung / CD1.mdf / modula2 / library / fst / modula1 / compiler.mod < prev    next >
Text File  |  1993-07-28  |  4KB  |  132 lines
  1. MODULE Compiler;
  2. (****************************************************************************
  3.    Dieses Programm ist ein "recursive descent"-Compiler für Wertzuweisungen
  4.    "Punkt vor Strich"-Regel wird berücksichtigt
  5.    Eingabebsp.: a:= b-c*d
  6.        Ausgabe:         Erklärung:
  7.        --------         ----------
  8.         LOAD b           ,b wird vom Speicher in den Stack geholt
  9.         LOAD c           ,c wird vom Speicher in den Stack geholt
  10.         LOAD d           ,d wird vom Speicher in den Stack geholt
  11.         MULT             ,die oberen beiden Elemente werden vom Stack
  12.                           in die Arithmethik-Einheit geholt, dort
  13.                           miteinander multipliziert und das Ergebnis
  14.                           im Stack oben abgespeichert
  15.         SUB              ,die oberen beiden Elemente werden vom Stack
  16.                           in die Arithmethik-Einheit geholt, dort
  17.                           voneinander subtrahiert und das Ergebnis
  18.                           im Stack oben abgespeichert
  19.         STORE a          ,das sich im Stack befindliche Ergebnis wird
  20.                           in der Speichereinheit unter a abgelegt
  21.  ****************************************************************************)
  22.  
  23. FROM InOut IMPORT WriteCard,WriteLn,ReadString,WriteString;
  24. FROM IO    IMPORT WrStr,WrLn;
  25.  
  26. VAR i:CARDINAL;
  27.     next:CHAR;
  28.     s:ARRAY[1..80] OF CHAR;
  29.  
  30. PROCEDURE Faktor;FORWARD;
  31. PROCEDURE Ausdruck;FORWARD;
  32.  
  33. PROCEDURE Lese;
  34.   BEGIN
  35.     INC(i);
  36.     next:=s[i]
  37.   END Lese;
  38.  
  39. PROCEDURE Ausgabe(n:CARDINAL; c:CHAR);
  40.   BEGIN
  41.     CASE n OF
  42.       1: WriteString('ADD'); |
  43.       2: WriteString('SUB');|
  44.       3: WriteString('MULT');|
  45.       4: WriteString('DIV');|
  46.       5: WriteString('LOAD');  WriteString(c); |
  47.       6: WriteString('STORE');  WriteString(c)
  48.     END;   (*CASE*)
  49.     WriteLn;
  50.   END Ausgabe;
  51.  
  52. PROCEDURE Fehler;
  53.   BEGIN
  54.     WriteLn;
  55.     WriteString('Fehler in Position ');
  56.     WriteCard(i,2);
  57.     HALT
  58.   END Fehler;
  59.  
  60. PROCEDURE Faktor;
  61.   BEGIN
  62.     CASE next OF
  63.       "a".."z": Ausgabe(5,next);  Lese;  RETURN |
  64.       "(":  Lese;  Ausdruck;
  65.             IF next=")" THEN Lese; RETURN
  66.                         ELSE Fehler
  67.             END   (*IF*)
  68.       ELSE Fehler
  69.     END   (*CASE*)
  70.   END Faktor;
  71.  
  72. PROCEDURE Term;
  73.   BEGIN
  74.     Faktor;
  75.     LOOP
  76.       CASE next OF
  77.         "*": Lese;   Faktor;   Ausgabe(3," "); |
  78.         "/": Lese;   Faktor;   Ausgabe(4," "); |
  79.         "-","+",")",0C: RETURN
  80.         ELSE Fehler
  81.       END  (*CASE*)
  82.     END   (*LOOP*)
  83.   END Term;
  84.  
  85. PROCEDURE Ausdruck;
  86.   BEGIN
  87.     Term;
  88.     LOOP
  89.       CASE next OF
  90.         "+": Lese;  Term;   Ausgabe(1," ");|
  91.         "-": Lese;  Term;   Ausgabe(2," ");|
  92.         ")",0C: RETURN
  93.         ELSE Fehler
  94.       END  (*CASE*)
  95.     END   (*LOOP*)
  96.   END Ausdruck;
  97.  
  98.  
  99.  
  100.  
  101.  
  102. PROCEDURE Wertzuweisung;
  103.   VAR ch:CHAR;
  104.   BEGIN
  105.     CASE next OF
  106.       "a".."z": ch:=next;
  107.                 Lese;
  108.                 IF next <> ":" THEN Fehler END;
  109.                 Lese;
  110.                 IF next <> "=" THEN Fehler END;
  111.                 Lese;
  112.                 Ausdruck;
  113.                 Ausgabe(6,ch);
  114.       ELSE Fehler
  115.     END
  116.   END Wertzuweisung;
  117.  
  118.  
  119.  
  120.  
  121.  
  122. BEGIN   (*MAIN*)
  123.    WrStr('Dieses Programm ist ein "recursive descent"-Compiler für');WrLn;
  124.    WrStr('Wertzuweisungen.');WrLn;
  125.    WrStr('"Punkt vor Strich"-Regel wird berücksichtigt.');WrLn;
  126.    WrStr('Eingabe: ');
  127.   ReadString(s);
  128.   i:=0;
  129.   Lese;
  130.   WriteLn;
  131.   Wertzuweisung
  132. END Compiler.