home *** CD-ROM | disk | FTP | other *** search
/ Turbo Toolbox / Turbo_Toolbox.iso / 1989 / 12 / algorith / atnbox.inc next >
Encoding:
Text File  |  1989-10-02  |  23.0 KB  |  735 lines
  1. (********************************************************)
  2. (*                       ATNBOX.INC                     *)
  3. (*   Include-Datei mit den Prozeduren für eine          *)
  4. (*   natürlichsprachliche Schnittstelle von "KARTEI"    *)
  5. (*   2.) Erweiterungen zur Handhabung von Anaphorismen  *)
  6. (*           (C) 1989 Stephan Diehl & TOOLBOX           *)
  7.  
  8.  
  9. FUNCTION match : BOOLEAN;
  10. (* Sucht die nächste Karteikarte, die zu den *)
  11. (* aktuellen Suchbegriffen paßt              *)
  12.  
  13. VAR bb:BOOLEAN;
  14.  
  15. BEGIN
  16.   bb:=FALSE;
  17.   IF karte<>NIL THEN
  18.   WHILE (((suchbegriff[inh4]^.begriff
  19.            <>karte^.inhalt[ 4])
  20.           AND (suchbegriff[inh4]^.begriff
  21.                <>wildcard))
  22.       OR ((suchbegriff[inh3]^.begriff
  23.            <>karte^.inhalt[3])
  24.           AND (suchbegriff[inh3]^.begriff
  25.                <>wildcard))
  26.       OR ((suchbegriff[inh2]^.begriff
  27.            <>karte^.inhalt[2])
  28.           AND (suchbegriff[inh2]^.begriff
  29.                <>wildcard))
  30.       OR ((suchbegriff[inh1]^.begriff
  31.            <>karte^.inhalt[1])
  32.           AND (suchbegriff[inh1]^.begriff
  33.                <>wildcard)) )
  34.           AND NOT bb
  35.     DO BEGIN
  36.       IF karte<>NIL THEN
  37.         karte:=karte^.naechste
  38.       ELSE
  39.         bb:=TRUE;
  40.     END
  41.     ELSE bb:=TRUE;
  42.   match:=NOT bb;
  43. END;
  44.  
  45.  
  46.  
  47. PROCEDURE aktionen_ausfuehren;
  48. BEGIN
  49.   befehl:=erster_befehl;
  50.   IF befehl=NIL THEN feld_mit_inhalt_ausgeben(z)
  51.   ELSE
  52.     REPEAT
  53.       CASE befehl^.anw OF
  54.         monitor  : feld_mit_inhalt_ausgeben(z);
  55.         drucker  : BEGIN
  56.                      feld_mit_inhalt_ausdrucken(z);
  57.                      auf_drucker:=TRUE;
  58.                    END;
  59.         loeschen : BEGIN
  60.                      Write('Sind Sie sicher,daß diese ');
  61.                      Write('Karte gelöscht ');
  62.                      WriteLn('werden soll:');
  63.                      FOR u:=1 TO 4 DO
  64.                        feld_mit_inhalt_ausgeben(u);
  65.                      WriteLn;WriteLn('j/n');
  66.                      IF ant='j' THEN BEGIN
  67.                        IF karte=erste_karte THEN
  68.                          erste_karte:=karte^.naechste
  69.                        ELSE BEGIN
  70.                          ksuch2:=NIL;
  71.                          ksuch1:=erste_karte;
  72.                          WHILE ksuch1<>karte DO BEGIN
  73.                            ksuch2:=ksuch1;
  74.                            ksuch1:=ksuch1^.naechste;
  75.                          END;
  76.                          ksuch2^.naechste
  77.                            :=karte^.naechste;
  78.                        END;
  79.                        Dispose(karte); kartanz:=kartanz-1;
  80.                        cty:=inh4;
  81.                        (* => kein weiteres feld *)
  82.                        WriteLn('Karte gelöscht !!!');
  83.                      END;
  84.                    END;
  85.        editieren : BEGIN
  86.                      IF no_feld
  87.                         OR  (no_feld2 AND zweite_anfrage)
  88.                         THEN BEGIN
  89.                        editiere_karteikarte(karte);
  90.                        cty:=inh4;
  91.                       END
  92.                       ELSE BEGIN
  93.                         feld_mit_inhalt_ausgeben(z);
  94.                         WriteLn;
  95.                         WriteLn(
  96.                           'Wollen Sie dies ändern ?');
  97.                         WriteLn('j/n'); ReadLn(ant);
  98.                         WriteLn;
  99.                         IF ant='j' THEN BEGIN
  100.                           Write(feldnamen[karte^.
  101.                                           kartentyp,z],
  102.                                           ': ');
  103.                           ReadLn(karte^.inhalt[z]);
  104.                         END;
  105.                       END;
  106.                     END;
  107.      kartedrucken : BEGIN
  108.                       FOR u:=1 TO 4 DO BEGIN
  109.                         feld_mit_inhalt_ausdrucken(u);
  110.                         WriteLn(LST);
  111.                       END;
  112.                       WriteLn(LST);WriteLn(LST);
  113.                       WriteLn(LST,feldnamen[karte^.
  114.                                             kartentyp,
  115.                                             5],': ');
  116.                       WriteLn(LST);
  117.                       FOR u:=1 TO 7 DO
  118.                         WriteLn(LST,karte^.inhalt5[u]);
  119.                       WriteLn(LST); WriteLn(LST);
  120.                       WriteLn(LST); WriteLn(LST);
  121.                       WriteLn(LST);
  122.                       cty:=inh4;
  123.                (* => kein weiteres feld bearbeiten *)
  124.                     END;
  125.       END;
  126.       befehl:=befehl^.naechste;
  127.     UNTIL befehl=NIL;
  128. END;
  129.  
  130.  
  131. PROCEDURE feldinhalt_ausgeben;
  132. (* Die Aktionen werden mit allen Feldinhalten *)
  133. (* durchgeführt, nach denen gefragt wurde     *)
  134. BEGIN
  135.   suchbegriff[feld]:=erster_begriff[feld];
  136.   REPEAT
  137.     cty:=inh1;
  138.     REPEAT
  139.       z:=Ord(cty);
  140.       IF (suchbegriff[feld]^.begriff=wildcard)
  141.          OR (feldnamen[karte^.kartentyp,z]
  142.              =suchbegriff[feld]^.begriff) THEN
  143.         aktionen_ausfuehren;
  144.       cty:=Succ(cty);
  145.     UNTIL cty=inh5;
  146.     suchbegriff[feld]:=suchbegriff[feld]^.naechste;
  147.   UNTIL suchbegriff[feld]=NIL;
  148. END;
  149.  
  150.  
  151. PROCEDURE drucke_antwort;
  152. (* Die Karteikarten werden nach allen  *)
  153. (* Kombinationen von Suchbegriffen der *)
  154. (* verschiedenen Felder durchsucht     *)
  155.  
  156. VAR xyi:INTEGER;
  157.  
  158. BEGIN
  159.   schwarzaufweiss;
  160.   FOR xyi:=3 TO 5 DO BEGIN
  161.     resetfenster;
  162.     fenster(xyi,xyi,81-xyi,26-xyi);
  163.     ClrScr;
  164.   END;
  165.   weissaufschwarz;
  166.   ClrScr;
  167.   suchbegriff[inh1]:=erster_begriff[inh1];
  168.   WHILE suchbegriff[inh1]<>NIL DO BEGIN
  169.     suchbegriff[inh2]:=erster_begriff[inh2];
  170.     WHILE suchbegriff[inh2]<>NIL DO BEGIN
  171.       suchbegriff[inh3]:=erster_begriff[inh3];
  172.       WHILE suchbegriff[inh3]<>NIL DO BEGIN
  173.         suchbegriff[inh4]:=erster_begriff[inh4];
  174.         WHILE suchbegriff[inh4]<>NIL DO BEGIN
  175.           karte:=erste_karte;
  176.           WHILE match AND (karte<>NIL) DO BEGIN
  177.             auf_drucker:=FALSE;
  178.             feldinhalt_ausgeben;
  179.             IF auf_drucker THEN WriteLn(LST)
  180.             ELSE WriteLn;
  181.             IF karte<>NIL THEN karte:=karte^.naechste;
  182.           END;
  183.           suchbegriff[inh4]
  184.             :=suchbegriff[inh4]^.naechste;
  185.         END;
  186.         suchbegriff[inh3]:=suchbegriff[inh3]^.naechste;
  187.       END;
  188.       suchbegriff[inh2]:=suchbegriff[inh2]^.naechste;
  189.     END;
  190.     suchbegriff[inh1]:=suchbegriff[inh1]^.naechste;
  191.   END;
  192.   weissaufschwarz;
  193.   resetfenster;
  194. END;
  195.  
  196.  
  197. (*-------------------------------------------------------*)
  198. (* Prozeduren zum Zugriff auf die vorherige Antwort      *)
  199. PROCEDURE merke_letzte_antwort;
  200.  
  201. VAR ct:kategorien;
  202.     temp : wlistzeiger;
  203.  
  204. BEGIN
  205.   FOR ct:=feld TO inh5 DO BEGIN
  206.     suchbegriff[ct]:=letzte_antwort_suchbegriffe[ct];
  207.     WHILE suchbegriff[ct]<>NIL DO BEGIN
  208.       letzter_begriff[ct]:=suchbegriff[ct];
  209.       suchbegriff[ct]:=suchbegriff[ct]^.naechste;
  210.       Dispose(letzter_begriff[ct]);
  211.     END;
  212.   END;
  213.   FOR ct:=feld TO inh5 DO BEGIN
  214.     letzte_antwort_suchbegriffe[ct]:=erster_begriff[ct];
  215.     letzter_begriff[ct]:=NIL;
  216.     erster_begriff[ct]:=NIL;
  217.   END;
  218.   befehl:=letzte_antwort_befehle;
  219.   (* Lösche die Befehlsliste *)
  220.   WHILE befehl<>NIL DO BEGIN
  221.     letzter_befehl:=befehl;
  222.     befehl:=befehl^.naechste;
  223.     Dispose(letzter_befehl);
  224.   END;
  225.   letzte_antwort_befehle:=erster_befehl;
  226.   erster_befehl:=NIL;
  227.   merke_sortierer:=sortierer;
  228.   merke_nach:=nach;
  229.   merke_no_feld2:=no_feld2;
  230.   merke_no_feld:=no_feld;
  231. END;
  232.  
  233. PROCEDURE nimm_letzte_befehle;
  234.  
  235. VAR bfhl:befehlszeiger;
  236.  
  237. BEGIN
  238.   sortierer:=merke_sortierer;
  239.   no_feld:=merke_no_feld;
  240.   no_feld2:=merke_no_feld2;
  241.   bfhl:=erster_befehl;
  242.   (* Lösche die Befehlsliste *)
  243.   WHILE bfhl<>NIL DO BEGIN
  244.     letzter_befehl:=bfhl;
  245.     bfhl:=bfhl^.naechste;
  246.     Dispose(letzter_befehl);
  247.   END;
  248.   bfhl:=letzte_antwort_befehle;
  249.   erster_befehl:=NIL;
  250.   WHILE bfhl<>NIL DO BEGIN
  251.     New(befehl);
  252.     IF erster_befehl=NIL THEN
  253.       erster_befehl:=befehl
  254.     ELSE
  255.       letzter_befehl^.naechste:=befehl;
  256.     befehl^.anw:=bfhl^.anw;
  257.     befehl^.naechste:=NIL;
  258.     letzter_befehl:=befehl;
  259.     bfhl:=bfhl^.naechste;
  260.   END;
  261. END;
  262.  
  263. PROCEDURE kopiere(ct:kategorien);
  264. BEGIN
  265.   begriff[ct]:=erster_begriff[ct];
  266.   WHILE begriff[ct]<>NIL DO BEGIN
  267.     letzter_begriff[ct]:=begriff[ct];
  268.     begriff[ct]:=begriff[ct]^.naechste;
  269.   END;
  270.   begriff[ct]:=letzte_antwort_suchbegriffe[ct];
  271.   WHILE begriff[ct]<>NIL DO BEGIN
  272.     New(suchbegriff[ct]);
  273.     IF erster_begriff[ct]=NIL THEN
  274.       erster_begriff[ct]:=suchbegriff[ct]
  275.     ELSE
  276.       letzter_begriff[ct]^.naechste:=suchbegriff[ct];
  277.     suchbegriff[ct]^.naechste:=NIL;
  278.     suchbegriff[ct]^.begriff:=begriff[ct]^.begriff;
  279.     letzter_begriff[ct]:=suchbegriff[ct];
  280.     begriff[ct]:=begriff[ct]^.naechste;
  281.   END;
  282. END;
  283.  
  284.  
  285. PROCEDURE nimm_letzte_suchbegriffe;
  286.  
  287. VAR  ct: kategorien;
  288.  
  289. BEGIN
  290.   IF NOT merke_no_feld THEN no_feld:=FALSE;
  291.   no_feld2:=FALSE;
  292.   FOR ct:=feld TO inh5 DO  kopiere(ct);
  293. END;
  294.  
  295.  
  296. PROCEDURE nimm_letzte_suchinhalte;
  297.  
  298. VAR ct:kategorien;
  299.  
  300. BEGIN
  301.   FOR ct:=inh1 TO inh5 DO kopiere(ct);
  302. END;
  303.  
  304.  
  305. PROCEDURE nimm_letzte_suchfelder;
  306. BEGIN
  307.   IF NOT merke_no_feld THEN no_feld:=FALSE;
  308.   no_feld2:=FALSE;
  309.   kopiere(feld);
  310. END;
  311.  
  312.  
  313. PROCEDURE getcategory;
  314. (* Liefert die Kategorie des      *)
  315. (* nächsten Wortes in der Eingabe *)
  316.  
  317. VAR bb, is_bdl:BOOLEAN;
  318.  
  319. BEGIN
  320.   REPEAT
  321.     IF eingabe='' THEN category:=pop
  322.     ELSE BEGIN
  323.       u:=Length(eingabe);
  324.       z:=1;
  325.       IF eingabe[1]='"' THEN BEGIN
  326.         wort:=Copy(eingabe,2,
  327.                    Pos('"',Copy(eingabe,2,u-1))-1);
  328.         z:=Length(wort)+4;
  329.       END
  330.       ELSE BEGIN
  331.         wort:=Copy(eingabe,1,Pos(' ',eingabe)-1);
  332.         z:=Length(wort)+2;
  333.       END;
  334.       eingabe:=Copy(eingabe,z,u-z+1);
  335.       kt:=nix;
  336.       is_bdl:=FALSE;
  337.       anweis:=keine;
  338.       category:=bdl;
  339.       IF (wort='nach') OR (wort='NACH') THEN nach:=TRUE
  340.       ELSE IF (wort='und') OR (wort='UND') THEN und:=TRUE
  341.            ELSE BEGIN (* Ist das Wort eine Anweisung ? *)
  342.              FOR z:=1 TO bdlanz DO
  343.                IF wort=bdlos[z] THEN is_bdl:=TRUE;
  344.              FOR z:=1 TO PRaePANZ DO
  345.                IF wort=PRaeP[z] THEN
  346.                  category:=PRaePOSITION;
  347.              FOR z:=1 TO MARKANZ DO
  348.                IF wort=Mark[z] THEN category:=MARKER;
  349.              FOR z:=1 TO ARTANZ DO
  350.                IF wort=ART[z] THEN category:=ARTIKEL;
  351.              IF category IN [MARKER,ARTIKEL] THEN
  352.                REFLEXIV:=TRUE;
  353.              FOR z:=1 TO sortanz DO
  354.                IF wort=sort[z] THEN anweis:=sortieren;
  355.              IF anweis=keine THEN
  356.                FOR z:=1 TO monanz DO
  357.                  IF wort=mon[z] THEN anweis:=monitor;
  358.              IF anweis=keine THEN
  359.                FOR z:=1 TO druckanz DO
  360.                  IF wort=druck[z] THEN anweis:=drucker;
  361.              IF anweis=keine THEN
  362.                FOR z:=1 TO editanz DO
  363.                  IF wort=edit[z] THEN anweis:=editieren;
  364.              IF anweis=keine THEN
  365.                FOR z:=1 TO loeschanz DO
  366.                  IF wort=loesch[z] THEN anweis:=loeschen;
  367.              IF anweis=keine THEN
  368.                FOR z:=1 TO kdruckanz DO
  369.                  IF wort=kartdruck[z] THEN
  370.                    anweis:=kartedrucken;
  371.              IF (anweis<>keine) AND (category=bdl) THEN
  372.                category:=anweisung
  373.              ELSE IF category=bdl THEN BEGIN
  374.                (* Ist das Wort ein Feldname ? *)
  375.                bb:=FALSE;
  376.                REPEAT
  377.                  kt:=Succ(kt); z:=0;
  378.                  REPEAT
  379.                    z:=z+1;
  380.                    hilfstr:=feldnamen[kt,z];
  381.                    IF enthalten_in(wort,hilfstr) THEN
  382.                      bb:=TRUE;
  383.                  UNTIL bb OR (z=5);
  384.                UNTIL (kt=letzter_typ) OR bb;
  385.               IF bb THEN BEGIN
  386.                 category:=feld;
  387.                 no_feld2:=no_feld;
  388.                 no_feld:=FALSE;
  389.               END
  390.               ELSE BEGIN (* Ist das Wort ein Feldinhalt ?*)
  391.                 category:=bdl;
  392.                 hilf:=erste_karte;
  393.                 REPEAT
  394.                   z:=0;
  395.                   REPEAT
  396.                     z:=z+1;
  397.                     hilfstr:=hilf^.inhalt[z];
  398.                     IF enthalten_in(wort,hilfstr) THEN
  399.                       bb:=TRUE;
  400.                   UNTIL bb OR (z=4);
  401.                   IF bb THEN
  402.                     CASE z OF
  403.                       1: category:=inh1;
  404.                       2: category:=inh2;
  405.                       3: category:=inh3;
  406.                       4: category:=inh4;
  407.                     END;
  408.                   hilf:=hilf^.naechste;
  409.                   (* Bedeutungslose Wörter *)
  410.                   (* werden überlesen      *)
  411.                 UNTIL (hilf=NIL) OR (category<>bdl);
  412.               END;
  413.             END;
  414.       END;
  415.     END;
  416.   UNTIL category<>bdl;
  417. END;
  418.  
  419.  
  420. FUNCTION richtig_verstanden:BOOLEAN;
  421.  
  422. VAR begriffe:begriffsfeld;
  423.     befehle:befehlszeiger;
  424.     cty:kategorien;
  425.     xi:INTEGER;
  426. BEGIN
  427.   schwarzaufweiss;
  428.   resetfenster;
  429.   IF hga THEN
  430.     Move(speichere_bildschirm,bildschirm_hga,4000)
  431.   ELSE
  432.     Move(speichere_bildschirm,bildschirm_cga,4000);
  433.   fenster(10,5,70,19);
  434.   ClrScr;
  435.   GotoXY(10,9);
  436.   WriteLn(' Ich soll folgendes tun : ');
  437.   begriffe:=erster_begriff;
  438.   befehle:=erster_befehl;
  439.   WriteLn;
  440.   IF begriffe[feld]^.begriff<>wildcard THEN BEGIN
  441.     IF begriffe[feld]^.naechste<>NIL THEN
  442.       WriteLn(' folgende Felder:')
  443.     ELSE
  444.       WriteLn(' folgendes Feld:');
  445.     WHILE begriffe[feld]<>NIL DO BEGIN
  446.       Write('':10);
  447.       weissaufschwarz;
  448.       Write(begriffe[feld]^.begriff);
  449.       schwarzaufweiss;
  450.       WriteLn;
  451.       begriffe[feld]:=begriffe[feld]^.naechste;
  452.     END;
  453.   END
  454.   ELSE
  455.     WriteLn(' alle Karteikarten ');
  456.   WriteLn;
  457.   IF (begriffe[inh1]^.begriff<>wildcard)
  458.      OR (begriffe[inh2]^.begriff<>wildcard)
  459.      OR (begriffe[inh3]^.begriff<>wildcard)
  460.      OR (begriffe[inh4]^.begriff<>wildcard) THEN BEGIN
  461.     WriteLn(' mit folgenden Feldinhalten:');
  462.     FOR cty:=inh1 TO inh4 DO BEGIN
  463.       WHILE begriffe[cty]<>NIL DO BEGIN
  464.         Write('':10);
  465.         weissaufschwarz;
  466.         IF begriffe[cty]^.begriff<> wildcard THEN
  467.           Write(begriffe[cty]^.begriff);
  468.         schwarzaufweiss;
  469.         WriteLn;
  470.         begriffe[cty]:=begriffe[cty]^.naechste;
  471.       END;
  472.     END;
  473.   END;
  474.   Write(' soll ich ');
  475.   IF befehle=NIL THEN
  476.     WriteLn('auf dem Bildschirm ausgeben !');
  477.   WHILE befehle<>NIL DO BEGIN
  478.     IF befehle<>erster_befehl THEN
  479.       Write(' und ');
  480.     CASE befehle^.anw OF
  481.             monitor  : WriteLn(
  482.                        'auf dem Bildschirm ausgeben');
  483.             drucker  : WriteLn(
  484.                        'auf dem Drucker ausgeben');
  485.             loeschen : WriteLn(
  486.                        'aus der Kartei streichen');
  487.            editieren : WriteLn('editieren');
  488.         kartedrucken : WriteLn(
  489.                        'formatiert auf dem ',
  490.                        'Drucker ausgeben');
  491.             sortieren : IF (sortierer<>wildcard)
  492.                            AND (sortierer<>'') THEN
  493.                           WriteLn('nach ',sortierer,
  494.                                   ' sortieren')
  495.                          ELSE
  496.                            WriteLn('sortieren');
  497.     END;
  498.     befehle:=befehle^.naechste;
  499.   END;
  500.   resetfenster;
  501.   resetfenster;TextColor(blink);
  502.   fenster(19,22,62,23);
  503.   TextColor(white);ClrScr;
  504.   Write(' Ist diese Interpretation richtig ?  ');
  505.   schwarzaufweiss;
  506.   REPEAT
  507.     Read(KBD,ant);
  508.     IF ant=Chr(27) THEN hilfe(8);
  509.   UNTIL ant IN ['j','J','n','N']; WriteLn; WriteLn;
  510.   richtig_verstanden :=  (ant IN ['j','J']);
  511.   weissaufschwarz;
  512.   resetfenster;
  513.   ClrScr;
  514. END;
  515.  
  516.  
  517.  
  518.  
  519. PROCEDURE anfragen;
  520. VAR x,y:INTEGER;
  521. BEGIN
  522.   resetfenster;
  523.   fenster(2,22,79,23);
  524.   eingabe:=''; zeile:=1;
  525.   ClrScr;WriteLn('Ihre Anfrage: ');
  526.   x:=WhereX;y:=WhereY;
  527.   weissaufschwarz;
  528.   Write('':62);
  529.   schwarzaufweiss;   GotoXY(x,y);
  530.   my_readln(eingabe,76,3);
  531.   merke_eingabe:=eingabe;
  532.   IF eingabe<>'' THEN BEGIN
  533.     eingabe:=eingabe+' ';
  534.     antworten:=1;
  535.     getcategory;
  536.     (* Einfaches ATN mit einer Aktion, nämlich *)
  537.     (* dem Erkennen einer zweiten Anfrage      *)
  538.     REPEAT
  539.       sortierer:=''; nach:=FALSE; no_feld:=TRUE;
  540.       zustand:=za; (* Anfangszustand *)
  541.      zweite_anfrage:=FALSE; no_feld2:=no_feld;
  542.      REFLEXIV:=FALSE; und:=FALSE;
  543.      LETZTES_WORT:=bdl;
  544.      (* Initialisiere die Befehlsliste *)
  545.      erster_befehl:=NIL; letzter_befehl:=NIL; befehl:=NIL;
  546.      (* Initialisiere die Listen der Suchbegriffe *)
  547.      FOR cty:=feld TO inh5 DO BEGIN
  548.        suchbegriff[cty]:=NIL;
  549.        erster_begriff[cty]:=NIL;
  550.        letzter_begriff[cty]:=NIL;
  551.      END;
  552.      REPEAT
  553.        (* Sonderbehandlung von UND *)
  554.        IF und AND (category<>bdl)
  555.           AND (category<>LETZTES_WORT) THEN
  556.          zweite_anfrage:=TRUE
  557.       ELSE BEGIN
  558.         IF und AND (category=LETZTES_WORT) THEN und:=FALSE;
  559.         LETZTES_WORT:=category;
  560.         (* Kante von za,zc,zf,zd nach zb *)
  561.         IF (zustand IN [za,zc,zf,zd])
  562.             AND (category IN [inh1..inh4]) THEN zustand:=zb
  563.         ELSE (* Kante von zb,zd oder ze nach za mit *)
  564.              (* Aufruf  Aktion "Beantworte erste Anfrage" *)
  565.           IF (zustand IN [zb,zd,ZE])
  566.               AND (category=feld) THEN zweite_anfrage:=TRUE
  567.         ELSE (* Kante von za nach zc *)
  568.           IF (zustand=za)
  569.              AND (category=PRaePOSITION) THEN zustand:=zc
  570.         ELSE (* Kanten von zc nach za *)
  571.           IF (zustand =zc) AND (category=feld) THEN
  572.             zustand:=za
  573.         ELSE (* Kanten von za nach zf *)
  574.           IF (zustand=za)
  575.              AND (category IN [ARTIKEL,MARKER]) THEN
  576.             zustand:=zf
  577.         ELSE (* Kante von zf nach ze *)
  578.           IF (zustand=zf) AND (category=PRaePOSITION) THEN
  579.            zustand:=ZE
  580.         ELSE (* Kante von zf nach zb *)
  581.           IF (zustand=zf)
  582.              AND (category IN [inh1..inh4]) THEN
  583.            zustand:=zb
  584.         ELSE (* kanten von zf nach za *)
  585.           IF (zustand=zf) AND
  586.              (category IN [ARTIKEL,anweisung,feld,MARKER])
  587.             THEN zustand:=za
  588.         ELSE (* kanten von zb nach zd *)
  589.           IF (zustand=zb)
  590.              AND (category IN [MARKER,ARTIKEL]) THEN
  591.             zustand:=zd
  592.         ELSE (* kante von zd nach zb *)
  593.           IF (zustand=zd)
  594.              AND (category IN [inh1..inh4]) THEN
  595.             zustand:=zb
  596.         ELSE (* kante von zd nach ze *)
  597.           IF (zustand=zd) AND (category=PRaePOSITION) THEN
  598.             zustand:=ZE
  599.         ELSE (* kante von ze nach zb *)
  600.           IF (zustand =ZE)
  601.              AND (category IN [inh1..inh4]) THEN BEGIN
  602.             nimm_letzte_suchfelder;
  603.             REFLEXIV:=FALSE;
  604.             zustand:=zb;
  605.           END
  606.         ELSE
  607.           IF (zustand=ZE) AND (category=MARKER) THEN BEGIN
  608.             nimm_letzte_suchfelder;
  609.             nimm_letzte_suchinhalte;
  610.             zustand:=zb;
  611.             REFLEXIV:=FALSE;
  612.           END
  613.         ELSE (* kanten von zc nach za *)
  614.           IF (zustand = zc) AND (category=MARKER) THEN
  615.           BEGIN
  616.             nimm_letzte_suchinhalte;
  617.             zustand:=za;
  618.             REFLEXIV:=FALSE;
  619.           END;
  620.  
  621.         (* Anweisung wird in die    *)
  622.         (* Befehlsliste aufgenommen *)
  623.         IF category=anweisung THEN BEGIN
  624.           (* kante von zc nach za *)
  625.           IF zustand=zc THEN zustand:=za;
  626.           (* kanten von zd und ze nach zb *)
  627.           IF zustand IN [zd,ZE] THEN zustand:=zb;
  628.           New(befehl);
  629.           IF erster_befehl=NIL THEN erster_befehl:=befehl
  630.           ELSE letzter_befehl^.naechste:=befehl;
  631.           befehl^.anw:=anweis;
  632.           befehl^.naechste:=NIL;
  633.           letzter_befehl:=befehl;
  634.           getcategory;
  635.         END
  636.         ELSE BEGIN (* Sonderfall: Sortiere nach ... *)
  637.           IF (category=feld) AND nach THEN BEGIN
  638.             sortierer:=wort;
  639.             nach:=FALSE;
  640.             getcategory;
  641.           END
  642.           ELSE BEGIN
  643.             (* Das Wort ist ein Feldname oder Feldinhalt *)
  644.             (* und wird in die entsprechende Liste der   *)
  645.             (* Suchbegriffe aufgenommen                  *)
  646.             IF category IN [MARKER,ARTIKEL,PRaePOSITION]
  647.             THEN getcategory
  648.             ELSE IF  (category <> pop)
  649.                      AND NOT zweite_anfrage THEN BEGIN
  650.               New(suchbegriff[category]);
  651.               IF erster_begriff[category]=NIL THEN
  652.                 erster_begriff[category]
  653.                   :=suchbegriff[category]
  654.               ELSE
  655.                 letzter_begriff[category]^.naechste
  656.                   :=suchbegriff[category];
  657.                 suchbegriff[category]^.naechste:=NIL;
  658.                 suchbegriff[category]^.begriff:=wort;
  659.                 letzter_begriff[category]
  660.                   :=suchbegriff[category];
  661.                 getcategory;
  662.               END;
  663.             END;
  664.           END;
  665.         END;
  666.       UNTIL (category=pop) OR zweite_anfrage;
  667.       (* Steht in einer der Listen kein Suchbegriff, *)
  668.       (* dann sei der Suchbegriff die Wildcard       *)
  669.       KEIN_SUCHBEGRIFF:=TRUE;
  670.       FOR cty:=feld TO inh4 DO
  671.         IF erster_begriff[cty]<>NIL THEN
  672.           KEIN_SUCHBEGRIFF:=FALSE;
  673.       IF REFLEXIV AND KEIN_SUCHBEGRIFF THEN
  674.         nimm_letzte_suchbegriffe
  675.       ELSE BEGIN
  676.         FOR cty:=feld TO inh5 DO
  677.           IF erster_begriff[cty]=NIL THEN BEGIN
  678.             New(erster_begriff[cty]);
  679.             erster_begriff[cty]^.begriff:=wildcard;
  680.             erster_begriff[cty]^.naechste:=NIL;
  681.           END;
  682.       END;
  683.       (* Lösche Anweisungen, die mehrfach in *)
  684.       (* der Befehlsliste vorkommen          *)
  685.       ctrlmenge:=[];
  686.       IF REFLEXIV AND (erster_befehl=NIL) THEN
  687.         nimm_letzte_befehle;
  688.       befehl:=erster_befehl;
  689.       WHILE befehl<>NIL DO BEGIN
  690.         IF befehl^.anw IN ctrlmenge THEN BEGIN
  691.           letzter_befehl^.naechste:=befehl^.naechste;
  692.           Dispose(befehl);
  693.         END
  694.         ELSE BEGIN
  695.           ctrlmenge:=ctrlmenge+[befehl^.anw];
  696.           letzter_befehl:=befehl;
  697.           (* Lautet eine Anweisung 'sortieren', *)
  698.           (* so fuehre sie sofort aus           *)
  699.           IF befehl^.anw=sortieren THEN bubble_sort;
  700.         END;
  701.         befehl:=letzter_befehl^.naechste;
  702.       END;
  703.       WriteLn;WriteLn;
  704.       (* Das ATN ist für eine Anfrage      *)
  705.       (* durchlaufen, nun beantworte diese *)
  706.       IF richtig_verstanden THEN BEGIN
  707.         drucke_antwort;
  708.         merke_letzte_antwort;
  709.         ReadLn;
  710.       END
  711.       ELSE BEGIN
  712.         (* Lösche die Liste der Suchbegriffe,  *)
  713.         (* nachdem die Frage beantwortet wurde *)
  714.         FOR cty:=feld TO inh5 DO BEGIN
  715.           suchbegriff[cty]:=erster_begriff[cty];
  716.           WHILE suchbegriff[cty]<>NIL DO BEGIN
  717.             letzter_begriff[cty]:=suchbegriff[cty];
  718.             suchbegriff[cty]:=suchbegriff[cty]^.naechste;
  719.             Dispose(letzter_begriff[cty]);
  720.           END;
  721.         END;
  722.         befehl:=erster_befehl;
  723.         (* Lösche die Befehlsliste *)
  724.         WHILE befehl<>NIL DO BEGIN
  725.           letzter_befehl:=befehl;
  726.           befehl:=befehl^.naechste;
  727.           Dispose(letzter_befehl);
  728.         END;
  729.       END;
  730.     UNTIL category=pop;
  731.     (* Die Eingabe ist abgearbeitet *)
  732.   END;
  733.   resetfenster;
  734. END;
  735.