home *** CD-ROM | disk | FTP | other *** search
/ Turbo Toolbox / Turbo_Toolbox.iso / 1991 / 06 / titel / turing.pas < prev    next >
Encoding:
Pascal/Delphi Source File  |  1991-03-11  |  19.3 KB  |  551 lines
  1. (* ------------------------------------------------------ *)
  2. (*                      TURING.PAS                        *)
  3. (*               Turing-Maschinen-Interpreter             *)
  4. (*          (c) 1991 Burkhard R. Wittek & TOOLBOX         *)
  5. (* ------------------------------------------------------ *)
  6. PROGRAM Turing;
  7.  
  8. USES Crt;
  9.  
  10. CONST
  11.   UMBRUCH = 20000;
  12.  
  13. TYPE
  14.   Band_Fortsetzung = ^Band_Stelle;
  15.   Band_Stelle      = RECORD
  16.                        St    : STRING [10];   { Stelle     }
  17.                        St_Nr : INTEGER;       { Stellen_Nr }
  18.                        right : Band_Fortsetzung;
  19.                        left  : Band_Fortsetzung;
  20.                      END;
  21.   saetze           = RECORD
  22.                        regel       : STRING [3];
  23.                        afiller     : STRING [1];
  24.                        Code        : CHAR;
  25.                        bfiller     : STRING [1];
  26.                        anweisung   : CHAR;
  27.                        cfiller     : STRING [1];
  28.                        verzweigung : STRING [3];
  29.                      END;
  30.   asaetze          = ARRAY [1..100] OF saetze;
  31.  
  32. VAR
  33.   Datei                               : Text;
  34.   Dosdatei                            : STRING [14];
  35.   Befehl                              : asaetze;
  36.   Band_Anfang, Schreibkopf, Band_Ende,
  37.   Drucken, DruckStelle, Before, Next,
  38.   Neues_Element                       : Band_Fortsetzung;
  39.   Ende, Abbruch                       : BOOLEAN;
  40.   c, i, j, x1, y1, x2, y2             : INTEGER;
  41.   Laenge, Modus, Anzahl, Frequenz,
  42.   Anz_Regeln, Anz_Regeln_TOTAL,
  43.   Anz_Stellen_TOTAL, Plus_Stellen,
  44.   Befehl_Nr, Max_Befehle,
  45.   Band_Stellenzahl, SchreibkopfStelle : INTEGER;
  46.   l, m, aa, Art                       : CHAR;
  47.   Art_str                             : STRING [1];
  48.   k, Regel_Nr                         : STRING [3];
  49.  
  50.   PROCEDURE SetColor(i : INTEGER);
  51.   BEGIN
  52.     CASE i OF
  53.       1: BEGIN TextColor(White); TextBackground(Black); END;
  54.       2: BEGIN TextColor(Black); TextBackground(White); END;
  55.     END;
  56.   END;
  57.  
  58.   PROCEDURE Set_Window(i : INTEGER);
  59.   BEGIN
  60.     Window(1,1,80,25);
  61.     CASE i OF
  62.       0 : Window(1,1,80,25);
  63.       1 : BEGIN
  64.             Window(2,2,25,22); LowVideo;
  65.             GotoXY(1,11); Write('==>            <== Kopf');
  66.           END;
  67.       2 : Window(26, 2,44, 4);
  68.      22 : Window(26, 5,44, 9);
  69.       3 : Window(47, 2,62, 4);
  70.      33 : Window(47, 6,62, 9);
  71.      34 : Window(65, 2,79, 4);
  72.      35 : Window(65, 6,79, 9);
  73.       4 : Window(28,11,79,22);
  74.       5 : BEGIN
  75.             Window(1,24,80,25); SetColor(1);
  76.             GotoXY(1,1); Write('>> '); ClrEol;
  77.           END;
  78.       6 : BEGIN
  79.             Window(1,24,80,25); GotoXY(1,1);
  80.             SetColor(1); Write('>> '); ClrEol;
  81.             SetColor(2); GotoXY(1,2);  ClrEol;
  82.           END;
  83.      11 : BEGIN
  84.             Window(6,2,16,22); LowVideo;
  85.           END;
  86.     END;
  87.   END;
  88.  
  89.   PROCEDURE Kommentar(Spalte, Zeile : INTEGER;
  90.                       Satz          : STRING);
  91.   BEGIN
  92.     Window(1,24,80,25); GotoXY(1,1);
  93.     SetColor(1); Write('>> '); ClrEol;
  94.     SetColor(2); GotoXY(1,2);  ClrEol;
  95.     GotoXY(Spalte, Zeile); Write(Satz); SetColor(1);
  96.   END;
  97.  
  98.   PROCEDURE SetRahmen(x1, y1, x2, y2 : INTEGER);
  99.   BEGIN
  100.     GotoXY(x1, y1);  Write(Chr(218));
  101.     FOR j := x1+1 TO x2-1 DO Write(Chr(196));
  102.     Write(Chr(191));
  103.     FOR j := y1+1 TO y2-1 DO BEGIN
  104.       GotoXY(x1,j); Write(Chr(179));
  105.       GotoXY(x2,j); Write(Chr(179));
  106.     END;
  107.     GotoXY(x1,y2); Write(Chr(192));
  108.     FOR j := x1+1 TO x2-1 DO Write(Chr(196));
  109.     Write(Chr(217));
  110.   END;
  111.  
  112.   PROCEDURE Install_Windows;
  113.   BEGIN
  114.     HighVideo;     SetRahmen(1,1,26,23);
  115.     GotoXY(7,1);   Write(' Turing-Band ');
  116.     SetRahmen(27,1,45,5);
  117.     GotoXY(29,1);  Write(' Regel-Anzeige ');
  118.     SetRahmen(27,5,45,9);
  119.     GotoXY(29,5);  Write(' Regel-Zähler ');
  120.     SetRahmen(46,1,63,5);
  121.     GotoXY(47,1);  Write(' Lauf-Frequenz ');
  122.     SetRahmen(46,5,63,9);
  123.     GotoXY(48,5);  Write(' Band-Stelle ');
  124.     SetRahmen(64,1,80,5);   GotoXY(66,1); Write('');
  125.     SetRahmen(64,5,80,9);   GotoXY(66,5); Write('');
  126.     SetRahmen(27,10,80,23);
  127.     GotoXY(45,10); Write(' Turing-Maschine ');  LowVideo;
  128.   END;
  129.  
  130.   PROCEDURE Set_Menue(i : INTEGER);
  131.   BEGIN
  132.     CASE i OF
  133.       1 : Kommentar(3, 2, 'BAND-GENERIERUNG:      ' +
  134.                           '1:Band nur aus Nullen     ' +
  135.                           '2:Individuelle Band-Eingabe');
  136.       2 : Kommentar(1, 2, 'MENÜ:  F1:Lauf-Frequenz   ' +
  137.                           'Cursor hoch/abwärts   ' +
  138.                           'PgUp/PgDn   e:Menü-  ' +
  139.                           'E:Prg-Ende');
  140.     END;
  141.   END;
  142.  
  143.   FUNCTION Datei_einlesen(VAR Max_Befehle : INTEGER;
  144.                           VAR Befehl : asaetze) : BOOLEAN;
  145.   VAR flag : BOOLEAN;
  146.   BEGIN
  147.     Datei_einlesen := FALSE; flag := FALSE; i := 0;
  148.     REPEAT
  149.       Kommentar(20,2,
  150.                'Datei der auszuführenden Turing-Maschine?');
  151.       SetColor(1); GotoXY(4,1); ReadLn(Dosdatei);
  152.       Assign(Datei, Dosdatei); {$I-} Reset(Datei); {$I+}
  153.       IF IOResult = 0 THEN BEGIN
  154.         WHILE NOT(EOF(Datei)) DO BEGIN
  155.           INC(Max_Befehle);
  156.           WITH Befehl[Max_Befehle] DO
  157.             ReadLn(Datei, regel, afiller, Code, bfiller,
  158.                           anweisung, cfiller, verzweigung);
  159.         END;
  160.         Close(Datei);
  161.         flag := TRUE; Datei_einlesen := TRUE;
  162.       END ELSE BEGIN
  163.         Set_Window(5); GotoXY(4,1);
  164.         Write(' Turing-Maschine: ', Dosdatei, ' ist auf ');
  165.         Write('Diskette/Platte nicht verfügbar!');
  166.         INC(i); IF i = 3 THEN Abbruch := TRUE;  Delay(3000);
  167.       END;
  168.     UNTIL flag OR Abbruch;
  169.   END;
  170.  
  171.   PROCEDURE BandStellenDruck(DruckStelle : Band_Fortsetzung;
  172.                              Art         : CHAR);
  173.   BEGIN
  174.     CASE Art OF
  175.       'r' : BEGIN
  176.          Set_Window(11); GotoXY(1,1); InsLine;
  177.          IF DruckStelle^.St_Nr MOD 5 = 0 THEN
  178.            Write(DruckStelle^.St, '  ', DruckStelle^.St_Nr)
  179.          ELSE Write(DruckStelle^.St);
  180.        END;
  181.       'l' : BEGIN
  182.          Set_Window(11); GotoXY(1,1); DelLine;
  183.          IF (Schreibkopf^.St_Nr-10>=DruckStelle^.St_Nr) AND
  184.               NOT (Band_Anfang^.St_Nr=DruckStelle^.St_Nr)
  185.               THEN BEGIN
  186.            Set_Window(11); GotoXY(1,21);
  187.            IF DruckStelle^.St_Nr MOD 5 = 0 THEN
  188.              Write(DruckStelle^.St, '  ',DruckStelle^.St_Nr)
  189.            ELSE Write(DruckStelle^.St);
  190.          END ELSE
  191.            IF Band_Anfang^.St_Nr=DruckStelle^.St_Nr THEN { }
  192.         END;
  193.       '0' : BEGIN
  194.           Set_Window(11); GotoXY(1,11);
  195.           IF DruckStelle^.St_Nr MOD 5 = 0 THEN
  196.             Write(DruckStelle^.St, '  ', DruckStelle^.St_Nr)
  197.           ELSE Write(DruckStelle^.St);
  198.         END;
  199.       '1' : BEGIN
  200.           Set_Window(11); GotoXY(1,11);
  201.           IF DruckStelle^.St_Nr MOD 5 = 0 THEN
  202.             Write(DruckStelle^.St, '  ', DruckStelle^.St_Nr)
  203.           ELSE Write(DruckStelle^.St);
  204.         END;
  205.       'g' : BEGIN
  206.           Set_Window(11); GotoXY(1,1);
  207.           IF DruckStelle^.St_Nr MOD 5 = 0 THEN BEGIN
  208.             InsLine;
  209.             Write(DruckStelle^.St, '  ', DruckStelle^.St_Nr);
  210.             Delay(100);
  211.           END ELSE BEGIN
  212.             InsLine;
  213.             Write(DruckStelle^.St); Delay(100);
  214.           END;
  215.         END;
  216.     ELSE
  217.       Set_Window(11); GotoXY(1,11);
  218.       IF DruckStelle^.St_Nr MOD 5 = 0 THEN
  219.         Write(DruckStelle^.St,'  ',DruckStelle^.St_Nr)
  220.       ELSE Write(DruckStelle^.St);
  221.     END;
  222.   END;
  223.  
  224.   PROCEDURE Band_Generierung(Anzahl  : INTEGER;
  225.                              Art_str : STRING);
  226.   BEGIN
  227.     FOR i := 1 TO Anzahl DO BEGIN
  228.       New(Next);
  229.       Schreibkopf^.right := Next;
  230.       Next^.left := Schreibkopf; Schreibkopf := Next;
  231.       INC(Band_Stellenzahl);
  232.       Schreibkopf^.St    := Art_str;
  233.       Schreibkopf^.St_Nr := Band_Stellenzahl;
  234.       Next               := NIL;
  235.       BandStellenDruck(Schreibkopf, 'g');
  236.     END;
  237.   END;
  238.  
  239.   PROCEDURE Band_Eingabe;
  240.   VAR Antwort : STRING [1];
  241.   BEGIN
  242.     Antwort := '';
  243.     Set_Menue(1); Set_Window(5); GotoXY(4,1); ReadLn(Modus);
  244.     CASE Modus OF
  245.       1 : BEGIN
  246.             Anzahl := 21; Art_str := '0';
  247.             Band_Generierung(Anzahl, Art_str); Delay(500);
  248.           END;
  249.       2 : BEGIN
  250.             REPEAT
  251.               Art_str:=' ';
  252.               Kommentar(11,2,
  253.                         'Welches Zeichen:   ''0'' für ' +
  254.                         'Nullen   bzw.  ''1'' für Einsen');
  255.               Set_Window(5);
  256.               GotoXY(4,1); ReadLn(Art_str);
  257.               GotoXY(4,1); ClrEol;
  258.               Kommentar(28,2,'Anzahl dieses Zeichens?');
  259.               Set_Window(5); GotoXY(4,1); ReadLn(Anzahl);
  260.               GotoXY(4,1); ClrEol;
  261.               Band_Generierung(Anzahl, Art_str);
  262.               Kommentar(15,2,'Band-Erstellen beenden ' +
  263.                         '(''J'',''j'') weiter mit RETURN');
  264.               Set_Window(5); GotoXY(4,1); ReadLn(Antwort);
  265.             UNTIL (Antwort = 'J') OR (Antwort = 'j');
  266.             Set_Window(5); GotoXY(1,2); ClrEol;
  267.           END;
  268.     END;
  269.     Kommentar(22, 2, 'Geben Sie den Anfangszustand an ');
  270.     Set_Window(5); GotoXY(4,1); ReadLn(SchreibkopfStelle);
  271.     Kommentar(12, 2, 'Geben Sie die Pausenzeit an ' +
  272.                      '(0 - 60 Zehntel-Sekunden)');
  273.     REPEAT
  274.       Set_Window(5); GotoXY(4,1); ReadLn(Frequenz);
  275.     UNTIL Frequenz IN [0..60];
  276.     Frequenz := Frequenz * 100;
  277.   END;
  278.  
  279.   PROCEDURE Turing_Maschine(Befehl      : asaetze;
  280.                             Max_Befehle : INTEGER);
  281.   VAR j, Zeile, Spalte : INTEGER;
  282.   BEGIN
  283.     LowVideo; Set_Window(4);
  284.     Zeile := 1; Spalte := 2; j := 0;
  285.     FOR j := 1 TO Max_Befehle DO BEGIN
  286.       Delay(50); GotoXY(Spalte, Zeile); INC(Zeile);
  287.       WITH Befehl[j] DO IF j <= 48 THEN
  288.         Write(regel, afiller, Code, bfiller,
  289.                      anweisung, cfiller, verzweigung);
  290.       IF Zeile = 13 THEN BEGIN
  291.         Zeile := 1;  Spalte := Spalte + 13;
  292.       END;
  293.     END;
  294.     HighVideo;
  295.   END;
  296.  
  297.   PROCEDURE Drucken_Turingmaschine
  298.             (VAR Spalte, Zeile, j_Merker : INTEGER;
  299.                  Befehl : asaetze; Befehl_Nr : INTEGER);
  300.   BEGIN
  301.     Set_Window(4); GotoXY(Spalte,Zeile); LowVideo;
  302.     WITH Befehl[j_Merker] DO
  303.       Write(regel, afiller, Code, bfiller,
  304.                    anweisung, cfiller, verzweigung);
  305.     HighVideo;
  306.     CASE Befehl_Nr OF
  307.        0..12 : Spalte :=  2;  13..24 : Spalte := 15;
  308.       25..36 : Spalte := 28;  37..48 : Spalte := 41;
  309.     END;
  310.     CASE Befehl_Nr OF
  311.        1..12 : Zeile := Befehl_Nr;
  312.       13..24 : Zeile := Befehl_Nr-12;
  313.       25..36 : Zeile := Befehl_Nr-24;
  314.       37..48 : Zeile := Befehl_Nr-36;
  315.     END;
  316.     Set_Window(4); GotoXY(Spalte,Zeile);
  317.     WITH Befehl[Befehl_Nr] DO
  318.       Write(regel, afiller, Code, bfiller,
  319.                    anweisung, cfiller, verzweigung);
  320.     LowVideo; j_Merker := Befehl_Nr;
  321.   END;
  322.  
  323.   PROCEDURE RegelZaehler(VAR Anz_Regeln : INTEGER);
  324.   BEGIN
  325.     INC(Anz_Regeln);
  326.     Set_Window(22);  GotoXY(9,3);  Write(Anz_Regeln);
  327.     IF Anz_Regeln = UMBRUCH THEN BEGIN
  328.       INC(Anz_Regeln_TOTAL);
  329.       GotoXY(9,3);  ClrEol;  GotoXY(6,4);
  330.       Write('(', Anz_Regeln_TOTAL:0, ' x ', UMBRUCH, ')');
  331.       Anz_Regeln := 0;
  332.     END;
  333.   END;
  334.  
  335.   PROCEDURE Bandstelle(Stelle : INTEGER);
  336.   BEGIN
  337.     Set_Window(33);
  338.     CASE Stelle OF
  339.       9,99,999,9999 : BEGIN
  340.                         GotoXY(7,2); Write('     ');
  341.                       END;
  342.     END;
  343.     IF Stelle = UMBRUCH THEN BEGIN
  344.       Anz_Stellen_TOTAL := Anz_Stellen_TOTAL + 1;
  345.       GotoXY(8,2); ClrEol; GotoXY(3,3);
  346.       Write('(', Anz_Stellen_TOTAL:0, ' x ', UMBRUCH, ')');
  347.       Stelle := 0;
  348.     END;
  349.     GotoXY(8,2); Write(Stelle);
  350.   END;
  351.  
  352.   PROCEDURE RegelAnzeige(Befehl : asaetze;
  353.                          Befehl_Nr : INTEGER);
  354.   BEGIN
  355.     Set_Window(2); GotoXY(6,2);
  356.     WITH Befehl[Befehl_Nr] DO
  357.       Write(regel, afiller, Code, bfiller,
  358.                    anweisung, cfiller, verzweigung);
  359.   END;
  360.  
  361.   PROCEDURE Lauf_Frequenz(Frequenz : INTEGER);
  362.   BEGIN
  363.     LowVideo; Set_Window(3); GotoXY(8,2); Write('      ');
  364.     IF Frequenz > 900 THEN BEGIN
  365.       GotoXY(5,2); Write(Frequenz/1000:0:0, '  Sek.');
  366.     END ELSE BEGIN
  367.       GotoXY(5,2); Write(Frequenz/100:0:0,'/10  Sek.');
  368.     END; HighVideo;
  369.   END;
  370.  
  371.   PROCEDURE Programmlauf(Befehl                 : asaetze;
  372.                          Befehl_Nr, Max_Befehle,
  373.                          Frequenz               : INTEGER);
  374.   VAR Spalte, Zeile, j_Merker : INTEGER;
  375.   BEGIN
  376.     j_Merker := 1;  Spalte := 2;  Zeile := 1;
  377.     Regel_Nr := '000';  m := '0';  c := 0;
  378.     Set_Window(11); GotoXY(1,1);
  379.     FOR j := 1 TO 21 DO DelLine;   { Window-Inhalt löschen }
  380.     Delay(500); Set_Window(1);
  381.     Delay(700); Set_Window(11);
  382.     DruckStelle := Band_Anfang;
  383.          { Banddruck bis zur oberen Window-Grenze, Zeile 1 }
  384.     FOR j := DruckStelle^.St_Nr TO
  385.              SchreibkopfStelle+9 DO BEGIN
  386.       IF DruckStelle^.St_Nr < Band_Ende^.St_Nr THEN BEGIN
  387.         DruckStelle := DruckStelle^.right;
  388.         BandStellenDruck(DruckStelle, 'g');
  389.       END ELSE
  390.         IF DruckStelle^.St_Nr=Band_Ende^.St_Nr THEN BEGIN
  391.           New(Next);  Band_Ende^.right := Next;
  392.                       Next^.left       := Band_Ende;
  393.                       Band_Ende        := Next;
  394.                       INC(Band_Stellenzahl);
  395.           Band_Ende^.St_Nr := Band_Stellenzahl;
  396.           Band_Ende^.St    := '0';
  397.           DruckStelle := Next;   Next := NIL;
  398.           BandStellenDruck(DruckStelle, 'g');
  399.         END ELSE BEGIN
  400.           Set_Window(5); GotoXY(4,1);
  401.           Write('Lauf-Fehler! Abbruch des Programms!');
  402.           Abbruch := TRUE;
  403.         END;
  404.      END;
  405.      IF NOT Abbruch THEN BEGIN
  406.        Schreibkopf := Band_Anfang;
  407.        WHILE SchreibkopfStelle > Schreibkopf^.St_Nr DO
  408.          Schreibkopf := Schreibkopf^.right;
  409.        Next := Schreibkopf;  Before := Schreibkopf;
  410.        FOR j := 1 TO 10 DO
  411.          IF NOT (Next^.St_Nr = Band_Ende^.St_Nr) THEN
  412.            Next := Next^.right;
  413.        FOR j := 1 TO 10 DO
  414.          IF NOT (Before^.St_Nr = Band_Anfang^.St_Nr) THEN
  415.            Before := Before^.left;
  416.        Set_Window(5); GotoXY(4,1); ClrEol;
  417.        Kommentar(29, 2, ' START mit beliebiger Taste ');
  418.        REPEAT aa := ReadKey; UNTIL aa <> '?';
  419.        Set_Window(5);  GotoXY(4,1);  ClrEol;
  420.        Kommentar(29, 2, ' HALT mit beliebiger Taste ');
  421.        LowVideo;  Set_Window(22);
  422.        GotoXY(6,4);    Write('(0 x ',UMBRUCH,')');
  423.        Set_Window(33);
  424.        GotoXY(3,3);    Write('(0 x ',UMBRUCH,')');
  425.        Lauf_Frequenz(Frequenz);  HighVideo;
  426.      END;
  427.      REPEAT
  428.        Delay(Frequenz); Befehl_Nr := 0; c := 0;
  429.        Abbruch := FALSE;
  430.        REPEAT
  431.          INC(Befehl_Nr);  INC(c);
  432.          IF c > 1000 THEN Abbruch := TRUE;
  433.          IF Befehl_Nr > Max_Befehle THEN Befehl_Nr := 1;
  434.          k := Befehl[Befehl_Nr].regel;
  435.          l := Befehl[Befehl_Nr].Code;
  436.        UNTIL ((Regel_Nr = k) AND
  437.               (Schreibkopf^.St=l)) OR Abbruch;
  438.        IF NOT Abbruch THEN BEGIN
  439.          Drucken_Turingmaschine(Spalte, Zeile, j_Merker,
  440.                                 Befehl, Befehl_Nr);
  441.          RegelZaehler(Anz_Regeln);
  442.          RegelAnzeige(Befehl, Befehl_Nr);
  443.          CASE Befehl[Befehl_Nr].anweisung OF
  444.            'r' : BEGIN
  445.               IF Next^.St_Nr = Band_Ende^.St_Nr THEN BEGIN
  446.                 New(Neues_Element);
  447.                 Band_Ende^.right    := Neues_Element;
  448.                 Neues_Element^.left := Band_Ende;
  449.                 Band_Ende           := Neues_Element;
  450.                 Neues_Element       := NIL;
  451.                 INC(Band_Stellenzahl);
  452.                 Band_Ende^.St       := '0';
  453.                 Band_Ende^.St_Nr    := Band_Stellenzahl;
  454.               END;
  455.               IF Schreibkopf^.St_Nr-10 = Before^.St_Nr THEN
  456.                 Before := Before^.right;
  457.               Next        := Next^.right;
  458.               Schreibkopf := Schreibkopf^.right;
  459.               Art         := 'r';
  460.               BandStellenDruck(Next, Art);
  461.               Bandstelle(Schreibkopf^.St_Nr);
  462.             END;
  463.            'l' : BEGIN
  464.               IF Schreibkopf^.St_Nr-1 = Band_Anfang^.St_Nr
  465.                                                   THEN BEGIN
  466.                 Kommentar(19, 2,
  467.                 'Unteres Band-Ende ist erreicht! ABBRUCH!');
  468.                 REPEAT aa := ReadKey; UNTIL aa <> '?';
  469.                 Set_Window(0);  Abbruch := TRUE;
  470.               END ELSE
  471.                 IF Before^.St_Nr = Band_Anfang^.St_Nr
  472.                                                   THEN BEGIN
  473.                   Next        := Next^.left;
  474.                   Before      := Before;
  475.                   Schreibkopf := Schreibkopf^.left;
  476.                 END ELSE BEGIN
  477.                   Next        := Next^.left;
  478.                   Before      := Before^.left;
  479.                   Schreibkopf := Schreibkopf^.left;
  480.                 END;
  481.               Art := 'l';
  482.               BandStellenDruck(Before, Art);
  483.               Bandstelle(Schreibkopf^.St_Nr);
  484.             END;
  485.            's' : BEGIN
  486.               Kommentar(26,2,'Halten der Turing-Maschine!');
  487.               REPEAT aa := ReadKey; UNTIL aa <> '?';
  488.               Ende := TRUE;
  489.             END;
  490.         ELSE
  491.           Art := Befehl[Befehl_Nr].anweisung;
  492.           Schreibkopf^.St := Befehl[Befehl_Nr].anweisung;
  493.           BandStellenDruck(Schreibkopf, Art);
  494.         END;
  495.         Regel_Nr := Befehl[Befehl_Nr].verzweigung;
  496.       END;
  497.     UNTIL KeyPressed OR Abbruch;
  498.     Ende := FALSE;
  499.     IF Abbruch THEN BEGIN
  500.       Kommentar(20, 2,
  501.                 'Vorzeitiges Halten der Turing-Maschine!');
  502.       REPEAT aa := ReadKey; UNTIL aa <> '?';
  503.     END;
  504.   END;
  505.  
  506.   PROCEDURE Initialisieren;
  507.   BEGIN
  508.     Ende          := FALSE;   Abbruch       := FALSE;
  509.     aa            := ' ';     l             := ' ';
  510.     m             := ' ';     Art           := ' ';
  511.     c             := 0;       i             := 0;
  512.     j             := 0;       x1            := 0;
  513.     y1            := 0;       x2            := 0;
  514.     y2            := 0;       Laenge        := 0;
  515.     Modus         := 0;       Anzahl        := 0;
  516.     Frequenz      := 0;       Dosdatei      := '';
  517.     Art_str       := '';      k             := '';
  518.     Regel_Nr      := '';
  519.     New(Band_Anfang);
  520.     Schreibkopf        := Band_Anfang;
  521.     Band_Anfang^.St    := '0';
  522.     Band_Anfang^.St_Nr := 0;       Band_Stellenzahl   := 0;
  523.     Max_Befehle        := 0;       Befehl_Nr          := 0;
  524.     SchreibkopfStelle  := 0;       Anz_Regeln         := 0;
  525.     Anz_Regeln_TOTAL   := 0;       Anz_Stellen_TOTAL  := 0;
  526.     Plus_Stellen       := 0;
  527.   END;
  528.  
  529. BEGIN
  530.   Set_Window(0);  ClrScr;  LowVideo;
  531.   Initialisieren;  Install_Windows;  Delay(100);
  532.   IF Datei_Einlesen(Max_Befehle, Befehl) THEN BEGIN
  533.     Delay(50); Turing_Maschine(Befehl, Max_Befehle);
  534.   END ELSE BEGIN
  535.     Set_Window(5); GotoXY(4,1);
  536.     Write('Keine Datei kann eingelesen werden!');
  537.     Delay(2000);
  538.   END;
  539.   IF NOT Abbruch THEN BEGIN
  540.     Delay(600);  Band_Eingabe;
  541.     Band_Ende   := NIL;   Band_Ende   := Schreibkopf;
  542.     Schreibkopf := NIL;   Schreibkopf := Band_Anfang;
  543.     Next        := NIL;   Next        := Band_Anfang;
  544.     Next        := Next^.right;
  545.     Programmlauf(Befehl, Befehl_Nr, Max_Befehle, Frequenz);
  546.   END;
  547.   Set_Window(0);  GotoXY(1,1);
  548. END.
  549. (* ------------------------------------------------------ *)
  550. (*               Ende von TURING.PAS                      *)
  551.