home *** CD-ROM | disk | FTP | other *** search
/ Turbo Toolbox / Turbo_Toolbox.iso / dtx9101 / parser / topdown.pas < prev    next >
Encoding:
Pascal/Delphi Source File  |  1991-09-12  |  3.9 KB  |  142 lines
  1. (* ------------------------------------------------------ *)
  2. (*                      TOPDOWN.PAS                       *)
  3. (*  3.Programm: Top-Down-Parser, der auf den als Strings  *)
  4. (*              abgelegten Regeln operiert.               *)
  5. (*        (c) 1991 Andreas Tengicki & DMV-Verlag          *)
  6. (* ------------------------------------------------------ *)
  7. PROGRAM TopDown;
  8.  
  9. USES Regeln, Zketten;
  10.  
  11. CONST
  12.   Merk_Max     = 100;
  13.   Ana_Max      =  50;
  14.  
  15. TYPE
  16.   Merk_Element = RECORD
  17.                    Regel : STRING;
  18.                    Nr    : INTEGER;
  19.                  END;
  20.  
  21.   Merk_Feld    = ARRAY [1..Merk_Max] OF Merk_Element;
  22.  
  23. VAR
  24.   RegelAnz,
  25.   MerkAnz,
  26.   i            : INTEGER;
  27.   Regel        : Regel_Feld;
  28.   Satzform,
  29.   Wort,
  30.   StartSym     : STRING;
  31.   Fehler       : BOOLEAN;
  32.   Merk         : Merk_Feld;
  33.   c            : CHAR;
  34.  
  35.     (* Erweiterung für Ausgabe der Satzanalyse *)
  36.   AnaCount     : INTEGER;
  37.   Analyse      : ARRAY [1..Ana_Max] OF INTEGER;
  38.  
  39.  
  40.   PROCEDURE RegelCut(i : INTEGER);
  41.   VAR
  42.     j : INTEGER;
  43.   BEGIN
  44.     FOR j := i+1 TO MerkAnz DO
  45.       Merk[j-1] := Merk[j];
  46.     DEC(MerkAnz);
  47.   END;
  48.  
  49.   PROCEDURE Regelbestimmung;
  50.   VAR
  51.     i, j, n, add : INTEGER;
  52.     Speichere,
  53.     Result       : Merk_Element;
  54.     nonterm      : CHAR;
  55.     Flag         : BOOLEAN;
  56.   BEGIN
  57.     n := 0;
  58.     REPEAT
  59.       INC(n);
  60.       i := 1;
  61.       WHILE i <= MerkAnz DO
  62.         IF LenStr(Merk[i].Regel) < n THEN
  63.           RegelCut(i)
  64.         ELSE IF Merk[i].Regel[n] IN ['a'..'z'] THEN
  65.           IF (Merk[i].Regel[n] = Wort [n]) AND
  66.              (LenStr(Merk[i].Regel) <= LenStr(Wort)) THEN
  67.             INC(i)
  68.           ELSE BEGIN
  69.             RegelCut(i)
  70.           END
  71.         ELSE BEGIN   (* Nonterminal ... *)
  72.           add       := 0;
  73.           Speichere := Merk[i];
  74.           nonterm   := Merk[i].Regel[n];
  75.           FOR j := 1 TO RegelAnz DO
  76.             IF Regel[j].l[1] = nonterm THEN BEGIN
  77.               Result := Speichere;
  78.               Ersetze(Result.Regel, Regel[j], n);
  79.               IF add = 0 THEN
  80.                 Merk[i] := Result
  81.               ELSE
  82.                 Merk[Merkanz+add] := Result;
  83.               INC(add);
  84.             END;
  85.           MerkAnz := MerkAnz + add - 1;
  86.         END;
  87.     UNTIL (MerkAnz < 2) OR (n > LenStr(Wort));
  88.   END;
  89.  
  90. BEGIN
  91.   WriteLn;
  92.   WriteLn;
  93.   WriteLn('Parserstrategien 3.Programm');
  94.   WriteLn('      Top-Down-Parser');
  95.   Regeleingabe(Regelanz, Regel);
  96.   Write('Startsymbol: ');  InpStr(StartSym);
  97.   REPEAT
  98.     Write('zu parsendes Wort: '); InpStr(wort);
  99.     Fehler   := FALSE;
  100.     Satzform := StartSym;
  101.     AnaCount := 0;
  102.     REPEAT
  103.       MerkAnz := 0;
  104.       FOR i := 1 TO RegelAnz DO
  105.         IF Regel[i].l[1] = Satzform[1] THEN BEGIN
  106.           INC(MerkAnz);
  107.           Merk[MerkAnz].Regel := Regel[i].r;
  108.           Merk[MerkAnz].Nr    := i;
  109.         END;
  110.       Regelbestimmung;
  111.       IF Merkanz = 0 THEN
  112.         Fehler := TRUE
  113.       ELSE BEGIN
  114.         INC(AnaCount);
  115.         Analyse[AnaCount] := Merk[1].Nr;
  116.         Ersetze(Satzform, Regel[Merk[1].Nr], 1);
  117.         WHILE (Satzform[1] IN ['a'..'z']) AND NOT Fehler AND
  118.               (LenStr(Satzform)*LenStr(Wort) > 0) DO BEGIN
  119.           IF Satzform[1] = Wort[1] THEN BEGIN
  120.             Satzform := TeilStr(Satzform, 2, LenStr(Satzform));
  121.             Wort     := TeilStr(Wort    , 2, LenStr(Wort));
  122.           END ELSE
  123.             Fehler := TRUE;
  124.         END;
  125.       END;
  126.     UNTIL Fehler OR (LenStr(Satzform)*LenStr(Wort) = 0);
  127.     IF Fehler OR (LenStr(Wort)+LenStr(Satzform) > 0) THEN
  128.       WriteLn('Wort nicht erkannt.')
  129.     ELSE BEGIN
  130.       WriteLn('Wort erkannt.');
  131.       Write('Ersetzt durch die Regeln: ');
  132.       FOR i := 1 TO AnaCount DO Write(Analyse[i]:3);
  133.       WriteLn;
  134.     END;
  135.     Write('Nochmal [j/n]: ');  InpChr(c);
  136.   UNTIL c = 'n';
  137. END.
  138. (* ------------------------------------------------------ *)
  139. (*               Ende von TOPDOWN.PAS                     *)
  140.  
  141.  
  142.