home *** CD-ROM | disk | FTP | other *** search
/ Power-Programmierung / CD1.mdf / modula2 / library / fst / mod2brd1 / rechner.mod < prev    next >
Text File  |  1990-04-08  |  4KB  |  134 lines

  1. MODULE Rechner9;
  2. (********************************************************************
  3.   Taschenrechner.
  4.   Dieses Programm ist ein kleiner Taschenrechner,der unter anderem
  5.   die "Punkt vor Strich"-Regel berücksichtigt.
  6.   Zur Verfügung stehende Operatoren sind:"+","-","*","/","(",")"
  7.   Bsp.: Eingabe: "5-3*(8+4/2)+1"
  8.         Ausgabe: " = -24 "
  9.  ********************************************************************)
  10.  
  11. FROM InOut IMPORT WriteCard,WriteLn,ReadString,WriteString,WriteInt,Write;
  12.  
  13. VAR i,oben:CARDINAL;        (* i: Index für String, oben: Index für Stack *)
  14.     next,x:CHAR;              (* enthält nächstes Zeichen *)
  15.     s:ARRAY[1..80] OF CHAR;    (* enthält Ausdrkücke *)
  16.     stack:ARRAY[1..40] OF INTEGER;   (* enthält Stack *)
  17.  
  18. PROCEDURE Fehler;
  19. (* Auftretende Fehler werden angezeigt *)
  20.   BEGIN
  21.     WriteLn;  WriteLn;
  22.     WriteString('      Term falsch eingegeben! ');
  23.     WriteLn;
  24.     WriteString('      Oder Division durch Null! ');
  25.     WriteString(s);
  26.     WriteLn;
  27.     FOR i:=1 TO i-1 DO Write(' '); END;
  28.     WriteLn;
  29.     HALT
  30.   END Fehler;
  31.  
  32. PROCEDURE Lese;
  33. (* nächstes Zeichen wird geholt *)
  34.   BEGIN
  35.     INC(i);
  36.     next:=s[i]
  37.   END Lese;
  38.  
  39. PROCEDURE LeseZahl;
  40. (* Zahlen werden eingelesen *)
  41.   VAR zahl:CARDINAL;
  42.       minus:BOOLEAN;         (* minus für negativ *)
  43.   BEGIN
  44.     minus:=FALSE;     (* am Anfang nicht Negativ *)
  45.     IF next="-" THEN minus:=TRUE;
  46.                      Lese;   (* falls "-", wird nächstes Zeichen gelesen *)
  47.     END;
  48.     IF next="+" THEN Lese END;  (* falls +, wird nächstes Zeichen gelesen *)
  49.     IF ((next<"0") OR (next>"9")) THEN Fehler END;  (* falls Keine Zahl *)
  50.                                                   (* --> Fehler       *)
  51.     zahl:=0;
  52.     REPEAT
  53.       zahl:=zahl*10 +(ORD(next))-(ORD("0"));
  54.       Lese;
  55.       IF ABS(zahl)>MAX(INTEGER) THEN Fehler END;
  56.     UNTIL (next<"0") OR (next>"9");
  57.  
  58.     IF minus THEN zahl:=-INTEGER(zahl) END;   (* falls minus, ist die Zahl negativ *)
  59.     INC(oben);                       (* Stack erhoben                     *)
  60.     stack[oben]:=zahl;               (* Zahl speichern                    *)
  61.     DEC(i)                           (* da next für i-1 sein soll         *)
  62.   END LeseZahl;
  63.  
  64. PROCEDURE Ausdruck;
  65. (* gemäß Skript *)
  66.   PROCEDURE Term;
  67.   (* gemäß Skript *)
  68.     PROCEDURE Faktor;
  69.     (* gemäß Skript *)
  70.       BEGIN     (* Faktor *)
  71.         CASE next OF
  72.           "0".."9","+","-":LeseZahl; Lese;  RETURN |
  73.           "(":  Lese;  Ausdruck;
  74.                 IF next=")" THEN Lese; RETURN
  75.                             ELSE Fehler
  76.                 END   (*IF*)
  77.           ELSE Fehler
  78.         END   (*CASE*)
  79.       END Faktor;
  80.  
  81.     BEGIN     (* Term  *)
  82.       Faktor;
  83.       LOOP
  84.         CASE next OF
  85.           "*": Lese;
  86.                Faktor;
  87.                DEC(oben);
  88.                stack[oben]:=stack[oben]*stack[oben+1];  |
  89.           "/": Lese;
  90.                Faktor;
  91.                IF stack[oben]=0 THEN Fehler END;
  92.                DEC(oben);
  93.                stack[oben]:=stack[oben] DIV stack[oben+1];   |
  94.           "-","+",")",0C: RETURN
  95.           ELSE Fehler
  96.         END  (*CASE*)
  97.       END   (*LOOP*)
  98.     END Term;
  99.  
  100.   BEGIN     (* Ausdruck *)
  101.     Term;
  102.     LOOP
  103.       CASE next OF
  104.         "+": Lese;
  105.              Term;
  106.              DEC(oben);
  107.              stack[oben]:=stack[oben]+stack[oben+1];  |
  108.         "-": Lese;
  109.              Term;
  110.              DEC(oben);
  111.              stack[oben]:=stack[oben]-stack[oben+1];   |
  112.         ")",0C: RETURN
  113.         ELSE Fehler
  114.       END  (*CASE*)
  115.     END   (*LOOP*)
  116.   END Ausdruck;
  117.  
  118.  
  119. BEGIN   (*MAIN*)
  120.  
  121.   WriteString('Dieses Programm stellt einen kleinen Taschenrechner dar, ');
  122.   WriteLn;
  123.   WriteString('zur Verfügung stehende Operatoren sind:"+","-","*","/","(",")"');
  124.   WriteLn;   WriteLn;
  125.   WriteString('Bitte geben Sie jetzt den zu berechnenden Term ein: ');
  126.   WriteLn;   WriteLn;
  127.   ReadString(s);                     (* Ausdrücke einlesen *)
  128.   oben:=0;
  129.   i:=0;                              (* initialisieren *)
  130.   Lese;                              (* erstes Zeichen holen *)
  131.   Ausdruck;                          (* berechnen *)
  132.   WriteString(' =   ');
  133.   WriteInt(stack[1],2);              (* Wert ausgeben *)
  134. END Rechner9.