home *** CD-ROM | disk | FTP | other *** search
/ Turbo Toolbox / Turbo_Toolbox.iso / dtx9101 / parser / regeln.pas < prev    next >
Encoding:
Pascal/Delphi Source File  |  1991-09-12  |  3.9 KB  |  122 lines
  1. (* ------------------------------------------------------ *)
  2. (*                       REGELN.PAS                       *)
  3. (*  enthält die Prozeduren zur Eingabe und Bearbeitung    *)
  4. (*  der als String vorliegenden Regeln und Satzformen.    *)
  5. (*        (c) 1991 Andreas Tengicki & DMV-Verlag          *)
  6. (* ------------------------------------------------------ *)
  7. UNIT Regeln;
  8.  
  9. INTERFACE
  10.  
  11. USES Zketten;
  12.  
  13. CONST
  14.   Regel_Max  = 50;
  15.  
  16. TYPE
  17.   Regel_Typ  = RECORD
  18.                  l, r : STRING;
  19.                END;
  20.   Regel_Feld = ARRAY [1..Regel_Max] OF Regel_Typ;
  21.  
  22.  
  23.   PROCEDURE Regeleingabe(VAR Anzahl : INTEGER;
  24.                          VAR Regeln : Regel_Feld);
  25.   PROCEDURE Ersetze     (VAR Satzform : STRING;
  26.                              Regel    : Regel_Typ;
  27.                              Pos      : INTEGER);
  28.  
  29.  
  30. IMPLEMENTATION
  31.  
  32.  
  33.   PROCEDURE Regeleingabe(VAR Anzahl : INTEGER;
  34.                          VAR Regeln : Regel_Feld);
  35.     (* Zur Eingabe eines Regelsatzes in Stringform. *)
  36.     (* Die Prozedur spaltet automatisch die ODER    *)
  37.     (* (|) auf und macht mehrere Regeln daraus.     *)
  38.     (* Die Eingabe kann über die Tastatur oder eine *)
  39.     (* Textdatei erfolgen.                          *)
  40.   VAR
  41.     Pos            : INTEGER;
  42.     Links, Rechts,
  43.     Regel, DatNam  : STRING;
  44.     Datei          : TEXT;
  45.     DatFlag        : BOOLEAN;
  46.     c              : CHAR;
  47.   BEGIN
  48.       (* Initialisierung ... *)
  49.     Anzahl := 0;
  50.     Write('Eingabe über Tastatur oder Datei (t/d): ');
  51.     InpChr(c);
  52.     DatFlag := (c = 'd');
  53.     IF DatFlag THEN BEGIN
  54.       Write('Dateiname: ');  InpStr(DatNam);
  55.       Assign(Datei, DatNam);
  56.       Reset(Datei);
  57.       ReadLn(Datei, Regel);
  58.       WriteLn(Anzahl+1:3, '.te Regel: ', Regel);
  59.     END ELSE BEGIN
  60.       Write(Anzahl+1:3, '.te Regel (# -> Ende Eingabe): ');
  61.       InpStr(Regel);
  62.     END;
  63.     WHILE (Regel[1] <> '#') AND (Anzahl < Regel_Max) DO BEGIN
  64.         (* Bestimmung des Gleichheitszeichens: *)
  65.       Pos := InStr('=', Regel);
  66.       IF Pos = 0 THEN
  67.         WriteLn('Syntaxfehler: = fehlt !')
  68.       ELSE BEGIN
  69.           (* Abtrennen der linken Seite ... *)
  70.         Links := TeilStr(Regel, 1, Pos-1);
  71.         Regel := TeilStr(Regel, Pos+1, LenStr(Regel));
  72.         REPEAT
  73.             (* Abtrennen der Alternativen ... *)
  74.           Pos := InStr('|', Regel);
  75.           IF Pos = 0 THEN
  76.               (* letzte Alternative ... *)
  77.             Rechts := TeilStr(Regel, 1, Lenstr(Regel))
  78.           ELSE BEGIN
  79.             Rechts := TeilStr(Regel, 1, Pos-1);
  80.             Regel  := TeilStr(Regel, Pos+1, LenStr(Regel));
  81.           END;
  82.            (* Regel abspeichern ... *)
  83.           INC(Anzahl);
  84.           IF Anzahl = Regel_Max THEN
  85.             WriteLn('Letzte Regel !');
  86.           Regeln[Anzahl].l := Links;
  87.           Regeln[Anzahl].r := Rechts;
  88.         UNTIL (Pos = 0) OR (Anzahl = Regel_Max);
  89.       END;
  90.       IF Anzahl < Regel_Max THEN BEGIN
  91.         IF DatFlag THEN BEGIN
  92.           ReadLn(Datei, Regel);
  93.           WriteLn(Anzahl+1:3, '.te Regel: ', Regel);
  94.         END ELSE BEGIN
  95.           Write(Anzahl+1:3, '.te Regel (# -> Ende Eingabe):');
  96.           InpStr(Regel);
  97.         END;
  98.       END;
  99.     END;
  100.     IF DatFlag THEN Close(Datei);
  101.   END;
  102.  
  103.   PROCEDURE Ersetze(VAR Satzform : STRING;
  104.                         Regel    : Regel_Typ;
  105.                         Pos      : INTEGER);
  106.     (* ersetzt in SATZFORM an der Position POS *)
  107.     (* gemäß REGEL.                            *)
  108.   VAR
  109.     Ergebnis : STRING;
  110.   BEGIN
  111.     Ergebnis := TeilStr(Satzform, 1, Pos-1);
  112.     Ergebnis := CatStr (Ergebnis, Regel.r);
  113.     Satzform := TeilStr(Satzform, Pos+LenStr(Regel.l),
  114.                         LenStr(Satzform));
  115.     Ergebnis := CatStr (Ergebnis, Satzform);
  116.     Satzform := Ergebnis;
  117.   END;
  118.  
  119. END.
  120. (* ------------------------------------------------------ *)
  121. (*                Ende von REGELN.PAS                     *)
  122.