crp.pas

一个Pascal语言分析器

    c:         INTEGER;
    name:      CRTable.Name;
    s:         STRING;
  BEGIN
    IF (sym = 1) THEN BEGIN
      _Ident(name);
      c := CRTable.ClassWithName(name);
      IF c < 0
        THEN BEGIN SemError(115); Sets.Clear(oneSet) END
        ELSE CRTable.GetClass(c, oneSet);
    END ELSE IF (sym = 2) THEN BEGIN
      Get;
      CRS.GetName(CRS.pos, CRS.len, s);
      Sets.Clear(oneSet); i := 2;
      WHILE s[i] <> s[1] DO BEGIN
        IF CRTable.ignoreCase THEN s[i] := UpCase(s[i]);
        Sets.Incl(oneSet, ORD(s[i])); INC(i)
      END;
    END ELSE IF (sym = 27) THEN BEGIN
      _SingleChar(n1);
      Sets.Clear(oneSet); Sets.Incl(oneSet, n1);
      IF (sym = 25) THEN BEGIN
        Get;
        _SingleChar(n2);
        FOR i := n1 TO n2 DO Sets.Incl(oneSet, i);
      END;
    END ELSE IF (sym = 26) THEN BEGIN
      Get;
      Sets.Fill(oneSet);
    END ELSE BEGIN SynError(50);
    END;
  END;

PROCEDURE _Set (VAR oneSet: CRTable.CRTSet);
  VAR
    set2: CRTable.CRTSet;
  BEGIN
    _SimSet(oneSet);
    WHILE (sym = 23) OR (sym = 24) DO BEGIN
      IF (sym = 23) THEN BEGIN
        Get;
        _SimSet(set2);
        Sets.Unite(oneSet, set2);
      END ELSE BEGIN
        Get;
        _SimSet(set2);
        Sets.Differ(oneSet, set2);
      END;
    END;
  END;

PROCEDURE _TokenExpr (VAR gL, gR: INTEGER);
  VAR
    gL2, gR2: INTEGER;
    first:    BOOLEAN;
  BEGIN
    _TokenTerm(gL, gR);
    first := TRUE;
    WHILE WeakSeparator(30, 3, 4) DO BEGIN
      _TokenTerm(gL2, gR2);
      IF first THEN BEGIN
        CRTable.MakeFirstAlt(gL, gR); first := FALSE
      END;
      CRTable.ConcatAlt(gL, gR, gL2, gR2);
    END;
  END;

PROCEDURE _NameDecl;
  VAR
    name: CRTable.Name;
    str: STRING;
  BEGIN
    _Ident(name);
    Expect(10);
    IF (sym = 1) THEN BEGIN
      Get;
      CRS.GetName(CRS.pos, CRS.len, str);
    END ELSE IF (sym = 2) THEN BEGIN
      Get;
      CRS.GetName(CRS.pos, CRS.len, str);
      FixString(str, CRS.len);
    END ELSE BEGIN SynError(51);
    END;
    CRTable.NewName(name, str);
    Expect(11);
  END;

PROCEDURE _TokenDecl (typ: INTEGER);
  VAR
    kind:       INTEGER;
    name:       CRTable.Name;
    pos:        CRTable.Position;
    sp, gL, gR: INTEGER;
    sn:         CRTable.SymbolNode;
  BEGIN
    _Symbol(name, kind);
    IF CRTable.FindSym(name) <> CRTable.noSym
      THEN SemError(107)
      ELSE BEGIN
        sp := CRTable.NewSym(typ, name, CRS.line);
        CRTable.GetSym(sp, sn); sn.struct := CRTable.classToken;
        CRTable.PutSym(sp, sn)
      END;
    WHILE NOT ( _In(symSet[5], sym)) DO BEGIN SynError(52); Get END;
    IF (sym = 10) THEN BEGIN
      Get;
      _TokenExpr(gL, gR);
      IF kind <> ident THEN SemError(113);
      CRTable.CompleteGraph(gR);
      CRA.ConvertToStates(gL, sp);
      Expect(11);
    END ELSE IF _In(symSet[6], sym) THEN BEGIN
      IF kind = ident
        THEN CRTable.genScanner := FALSE
        ELSE MatchLiteral(sp);
    END ELSE BEGIN SynError(53);
    END;
    IF (sym = 42) THEN BEGIN
      _SemText(pos);
      IF typ = CRTable.t THEN SemError(114);
      CRTable.GetSym(sp, sn); sn.semPos := pos;
      CRTable.PutSym(sp, sn);
    END;
  END;

PROCEDURE _SetDecl;
  VAR
    c:    INTEGER;
    oneSet:  CRTable.CRTSet;
    name: CRTable.Name;
  BEGIN
    _Ident(name);
    c := CRTable.ClassWithName(name);
    IF c >= 0 THEN SemError(107);
    Expect(10);
    _Set(oneSet);
    c := CRTable.NewClass(name, oneSet);
    Expect(11);
  END;

PROCEDURE _Expression (VAR gL, gR: INTEGER);
  VAR
    gL2, gR2: INTEGER;
    first:    BOOLEAN;
  BEGIN
    _Term(gL, gR);
    first := TRUE;
    WHILE WeakSeparator(30, 1, 7) DO BEGIN
      _Term(gL2, gR2);
      IF first THEN BEGIN
        CRTable.MakeFirstAlt(gL, gR); first := FALSE
      END;
      CRTable.ConcatAlt(gL, gR, gL2, gR2);
    END;
  END;

PROCEDURE _SemText (VAR semPos: CRTable.Position);
  BEGIN
    Expect(42);
    semPos.beg := CRS.pos + 2; semPos.col := CRS.col + 2;
    WHILE _In(symSet[8], sym) DO BEGIN
      IF _In(symSet[9], sym) THEN BEGIN
        Get;
      END ELSE IF (sym = 3) THEN BEGIN
        Get;
        SemError(102);
      END ELSE BEGIN
        Get;
        SemError(109);
      END;
    END;
    Expect(43);
    semPos.len := (CRS.pos - semPos.beg);
  END;

PROCEDURE _Attribs (VAR attrPos: CRTable.Position);
  BEGIN
    IF (sym = 38) THEN BEGIN
      Get;
      attrPos.beg := CRS.pos + 1; attrPos.col := CRS.col + 1;
      WHILE _In(symSet[10], sym) DO BEGIN
        IF _In(symSet[11], sym) THEN BEGIN
          Get;
        END ELSE BEGIN
          Get;
          SemError(102);
        END;
      END;
      Expect(39);
      attrPos.len := (CRS.pos - attrPos.beg);
    END ELSE IF (sym = 40) THEN BEGIN
      Get;
      attrPos.beg := CRS.pos + 2; attrPos.col := CRS.col + 2;
      WHILE _In(symSet[12], sym) DO BEGIN
        IF _In(symSet[13], sym) THEN BEGIN
          Get;
        END ELSE BEGIN
          Get;
          SemError(102);
        END;
      END;
      Expect(41);
      attrPos.len := (CRS.pos - attrPos.beg);
    END ELSE BEGIN SynError(54);
    END;
  END;

PROCEDURE _Declaration;
  VAR
    gL1, gR1, gL2, gR2: INTEGER;
    nested:             BOOLEAN;
  BEGIN
    CASE sym OF
      13 : BEGIN
        Get;
        WHILE (sym = 1) DO BEGIN
          _SetDecl;
        END;
        END;
      14 : BEGIN
        Get;
        WHILE (sym = 1) OR (sym = 2) DO BEGIN
          _TokenDecl(CRTable.t);
        END;
        END;
      15 : BEGIN
        Get;
        WHILE (sym = 1) DO BEGIN
          _NameDecl;
        END;
        END;
      16 : BEGIN
        Get;
        WHILE (sym = 1) OR (sym = 2) DO BEGIN
          _TokenDecl(CRTable.pr);
        END;
        END;
      17 : BEGIN
        Get;
        Expect(18);
        _TokenExpr(gL1, gR1);
        Expect(19);
        _TokenExpr(gL2, gR2);
        IF (sym = 20) THEN BEGIN
          Get;
          nested := TRUE;
        END ELSE IF _In(symSet[14], sym) THEN BEGIN
          nested := FALSE;
        END ELSE BEGIN SynError(55);
        END;
        CRA.NewComment(gL1, gL2, nested);
        END;
      21 : BEGIN
        Get;
        IF (sym = 22) THEN BEGIN
          Get;
          CRTable.ignoreCase := TRUE;
        END ELSE IF (sym = 1) OR (sym = 2) OR (sym = 26) OR (sym = 27) THEN BEGIN
          _Set(CRTable.ignored);
          IF Sets.IsIn(CRTable.ignored, 0) THEN SemError(119);
        END ELSE BEGIN SynError(56);
        END;
        END;
    ELSE BEGIN SynError(57);
        END;
    END;
  END;

PROCEDURE _Ident (VAR name: CRTable.Name);
  VAR
    str: STRING;
  BEGIN
    Expect(1);
    CRS.GetName(CRS.pos, CRS.len, str);
    name := str;
  END;

PROCEDURE _CR;
  VAR
    ok, undef, hasAttrs: BOOLEAN;
    unknownSy,
    eofSy, gR:       INTEGER;
    gramLine, sp:    INTEGER;
    name, gramName:  CRTable.Name;
    sn:              CRTable.SymbolNode;
  BEGIN
    Expect(5);
    gramLine := CRS.line;
    eofSy := CRTable.NewSym(CRTable.t, 'EOF', 0);
    CRTable.genScanner := TRUE; CRTable.ignoreCase := FALSE;
    Sets.Clear(CRTable.ignored);
    _Ident(gramName);
    IF (sym = 6) THEN BEGIN
      Get;
      CRTable.useDeclPos.beg := CRS.nextPos;
      CRTable.hasUses := TRUE;
      Expect(1);
      WHILE (sym = 7) DO BEGIN
        Get;
        Expect(1);
      END;
      CRTable.useDeclPos.len := CRS.nextPos - CRTable.useDeclPos.beg;
      CRTable.useDeclPos.col := 0;
      Expect(8);
    END;
    CRTable.semDeclPos.beg := CRS.nextPos;
    WHILE _In(symSet[15], sym) DO BEGIN
      Get;
    END;
    CRTable.semDeclPos.len := CRS.nextPos - CRTable.semDeclPos.beg;
    CRTable.semDeclPos.col := 0;
    WHILE _In(symSet[16], sym) DO BEGIN
      _Declaration;
    END;
    WHILE NOT ( (sym = 0) OR (sym = 9)) DO BEGIN SynError(58); Get END;
    Expect(9);
    ok := Successful;
    IF ok AND CRTable.genScanner THEN CRA.MakeDeterministic(ok);
    IF NOT ok THEN SemError(127);
    CRTable.nNodes := 0;
    WHILE (sym = 1) DO BEGIN
      _Ident(name);
      sp := CRTable.FindSym(name); undef := sp = CRTable.noSym;
      IF undef
        THEN BEGIN
            sp := CRTable.NewSym(CRTable.nt, name, CRS.line);
            CRTable.GetSym(sp, sn)
          END
        ELSE BEGIN
          CRTable.GetSym(sp, sn);
          IF sn.typ = CRTable.nt
            THEN
              BEGIN IF sn.struct > 0 THEN SemError(107) END
            ELSE SemError(108);
          sn.line := CRS.line
        END;
      hasAttrs := sn.attrPos.beg >= 0;
      IF (sym = 38) OR (sym = 40) THEN BEGIN
        _Attribs(sn.attrPos);
        IF NOT undef AND NOT hasAttrs THEN SemError(105);
        CRTable.PutSym(sp, sn);
      END ELSE IF (sym = 10) OR (sym = 42) THEN BEGIN
        IF NOT undef AND hasAttrs THEN SemError(105);
      END ELSE BEGIN SynError(59);
      END;
      IF (sym = 42) THEN BEGIN
        _SemText(sn.semPos);
      END;
      ExpectWeak(10, 17);
      _Expression(sn.struct, gR);
      CRTable.CompleteGraph(gR); CRTable.PutSym(sp, sn);
      ExpectWeak(11, 18);
    END;
    Expect(12);
    _Ident(name);
    sp := CRTable.FindSym(gramName);
    IF sp = CRTable.noSym THEN SemError(111)
    ELSE BEGIN
      CRTable.GetSym(sp, sn);
      IF sn.attrPos.beg >= 0 THEN SemError(112);
      CRTable.root := CRTable.NewNode(CRTable.nt, sp, gramLine);
    END;
    IF name <> gramName THEN SemError(117);
    Expect(11);
    unknownSy := CRTable.NewSym(CRTable.t, 'not', 0);
  END;



PROCEDURE  Parse;
  BEGIN
    _Reset; Get;
    _CR;

  END;

BEGIN
  errDist := minErrDist;
  symSet[ 0, 0] := [0, 1, 2, 9, 10, 13, 14, 15];
  symSet[ 0, 1] := [0, 1, 5];
  symSet[ 0, 2] := [10];
  symSet[ 1, 0] := [1, 2, 11];
  symSet[ 1, 1] := [10, 12, 13, 14, 15];
  symSet[ 1, 2] := [0, 1, 2, 3, 4, 10];
  symSet[ 2, 0] := [1, 2];
  symSet[ 2, 1] := [10, 12, 15];
  symSet[ 2, 2] := [0, 2, 4, 10];
  symSet[ 3, 0] := [1, 2];
  symSet[ 3, 1] := [12];
  symSet[ 3, 2] := [0, 2];
  symSet[ 4, 0] := [9, 11, 13, 14, 15];
  symSet[ 4, 1] := [0, 1, 3, 4, 5, 13];
  symSet[ 4, 2] := [1, 3];
  symSet[ 5, 0] := [0, 1, 2, 9, 10, 13, 14, 15];
  symSet[ 5, 1] := [0, 1, 5];
  symSet[ 5, 2] := [10];
  symSet[ 6, 0] := [1, 2, 9, 13, 14, 15];
  symSet[ 6, 1] := [0, 1, 5];
  symSet[ 6, 2] := [10];
  symSet[ 7, 0] := [11];
  symSet[ 7, 1] := [13];
  symSet[ 7, 2] := [1, 3];
  symSet[ 8, 0] := [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15];
  symSet[ 8, 1] := [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15];
  symSet[ 8, 2] := [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 12];
  symSet[ 9, 0] := [1, 2, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15];
  symSet[ 9, 1] := [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15];
  symSet[ 9, 2] := [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 12];
  symSet[10, 0] := [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15];
  symSet[10, 1] := [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15];
  symSet[10, 2] := [0, 1, 2, 3, 4, 5, 6, 8, 9, 10, 11, 12];
  symSet[11, 0] := [1, 2, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15];
  symSet[11, 1] := [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15];
  symSet[11, 2] := [0, 1, 2, 3, 4, 5, 6, 8, 9, 10, 11, 12];
  symSet[12, 0] := [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15];
  symSet[12, 1] := [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15];
  symSet[12, 2] := [0, 1, 2, 3, 4, 5, 6, 7, 8, 10, 11, 12];
  symSet[13, 0] := [1, 2, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15];
  symSet[13, 1] := [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15];
  symSet[13, 2] := [0, 1, 2, 3, 4, 5, 6, 7, 8, 10, 11, 12];
  symSet[14, 0] := [9, 13, 14, 15];
  symSet[14, 1] := [0, 1, 5];
  symSet[14, 2] := [];
  symSet[15, 0] := [1, 2, 3, 4, 5, 6, 7, 8, 10, 11, 12];
  symSet[15, 1] := [2, 3, 4, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15];
  symSet[15, 2] := [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12];
  symSet[16, 0] := [13, 14, 15];
  symSet[16, 1] := [0, 1, 5];
  symSet[16, 2] := [];
  symSet[17, 0] := [0, 1, 2, 9, 10, 11, 13, 14, 15];
  symSet[17, 1] := [0, 1, 5, 10, 12, 14, 15];
  symSet[17, 2] := [0, 2, 4, 10];
  symSet[18, 0] := [0, 1, 2, 9, 10, 12, 13, 14, 15];
  symSet[18, 1] := [0, 1, 5];
  symSet[18, 2] := [10];
END. (* CRP *)