cr.atg

一个Pascal语言分析器

| "ANY"                        (. Sets.Fill(oneSet) .)
.

(*----------------------------------------------------------------------------*)

SingleChar <VAR n: INTEGER>    (. VAR
                                    i: INTEGER;
                                    s: STRING; .)
  =
    "CHR" "(" number           (. CRS.GetName(CRS.pos, CRS.len, s);
                                  Val(s, n, i);
                                  IF n > 255 THEN BEGIN SemError(118); n := n MOD 256 END;
                                  IF CRTable.ignoreCase THEN n := ORD(UpCase(CHR(n))) .)
     ")" .

(*----------------------------------------------------------------------------*)

TokenDecl <typ: INTEGER>       (. VAR
                                    kind:       INTEGER;
                                    name:       CRTable.Name;
                                    pos:        CRTable.Position;
                                    sp, gL, gR: INTEGER;
                                    sn:         CRTable.SymbolNode; .)
= 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 .)
  SYNC
  ( "="
    TokenExpr <gL, gR>         (. IF kind <> ident THEN SemError(113);
                                  CRTable.CompleteGraph(gR);
                                  CRA.ConvertToStates(gL, sp) .)
    "."
  |                            (. IF kind = ident
                                    THEN CRTable.genScanner := FALSE
                                    ELSE MatchLiteral(sp)  .)
  )
  [ SemText <pos>              (. IF typ = CRTable.t THEN SemError(114);
                                  CRTable.GetSym(sp, sn); sn.semPos := pos;
                                  CRTable.PutSym(sp, sn) .)
  ].

(*----------------------------------------------------------------------------*)

Expression <VAR gL, gR: INTEGER>
                               (. VAR
                                    gL2, gR2: INTEGER;
                                    first:    BOOLEAN; .)
= Term <gL, gR>                (. first := TRUE .)
  { WEAK "|"
    Term <gL2, gR2>            (. IF first THEN BEGIN
                                    CRTable.MakeFirstAlt(gL, gR); first := FALSE
                                  END;
                                  CRTable.ConcatAlt(gL, gR, gL2, gR2) .)
  }
.

(*----------------------------------------------------------------------------*)

Term<VAR gL, gR: INTEGER>      (. VAR
                                    gL2, gR2: INTEGER; .)
=                              (. gL := 0; gR := 0 .)
( Factor <gL, gR>
    { Factor <gL2, gR2>        (. CRTable.ConcatSeq(gL, gR, gL2, gR2) .)
    }
  |                            (. gL := CRTable.NewNode(CRTable.eps, 0, 0); gR := gL .)
  ).

(*----------------------------------------------------------------------------*)

Factor <VAR gL, gR: INTEGER>   (. VAR
                                    sp, kind:    INTEGER;
                                    name:        CRTable.Name;
                                    gn:          CRTable.GraphNode;
                                    sn:          CRTable.SymbolNode;
                                    oneSet:      CRTable.CRTSet;
                                    undef, weak: BOOLEAN;
                                    pos:         CRTable.Position; .)
=                              (. gL :=0; gR := 0; weak := FALSE .)
( [ "WEAK"                     (. weak := TRUE .)
  ]
  Symbol <name, kind>          (. sp := CRTable.FindSym(name); undef := sp = CRTable.noSym;
                                  IF undef THEN
                                    IF kind = ident
                                      THEN  (* forward nt *)
                                        sp := CRTable.NewSym(CRTable.nt, name, 0)
                                      ELSE IF CRTable.genScanner THEN
                                        BEGIN
                                          sp := CRTable.NewSym(CRTable.t, name, CRS.line);
                                          MatchLiteral(sp)
                                        END
                                      ELSE BEGIN (* undefined string in production *)
                                        SemError(106); sp := 0
                                      END;
                                  CRTable.GetSym(sp, sn);
                                  IF (sn.typ <> CRTable.t) AND (sn.typ <> CRTable.nt) THEN SemError(104);
                                  IF weak THEN
                                    IF sn.typ = CRTable.t
                                      THEN sn.typ := CRTable.wt
                                      ELSE SemError(123);
                                  gL := CRTable.NewNode(sn.typ, sp, CRS.line); gR := gL .)
  ( Attribs <pos>              (. CRTable.GetNode(gL, gn); gn.pos := pos;
                                  CRTable.PutNode(gL, gn);
                                  CRTable.GetSym(sp, sn);
                                  IF sn.typ <> CRTable.nt THEN SemError(103);
                                  IF undef THEN
                                    BEGIN sn.attrPos := pos; CRTable.PutSym(sp, sn) END
                                    ELSE IF sn.attrPos.beg < 0 THEN SemError(105) .)
  |                            (. CRTable.GetSym(sp, sn);
                                  IF sn.attrPos.beg >= 0 THEN SemError(105) .)
  )
| "(" Expression <gL, gR> ")"
| "[" Expression <gL, gR> "]"  (. CRTable.MakeOption(gL, gR) .)
| "{" Expression <gL, gR> "}"  (. CRTable.MakeIteration(gL, gR) .)

| SemText <pos>                (. gL := CRTable.NewNode(CRTable.sem, 0, 0); gR := gL;
                                  CRTable.GetNode(gL, gn);
                                  gn.pos := pos;
                                  CRTable.PutNode(gL, gn) .)
| "ANY"                        (. Sets.Fill(oneSet); Sets.Excl(oneSet, CRTable.eofSy);
                                  gL := CRTable.NewNode(CRTable.any, CRTable.NewSet(oneSet), 0); gR := gL .)
| "SYNC"                       (. gL := CRTable.NewNode(CRTable.sync, 0, 0); gR := gL .)
).

(*----------------------------------------------------------------------------*)

TokenExpr <VAR gL, gR: INTEGER>
                               (. VAR
                                    gL2, gR2: INTEGER;
                                    first:    BOOLEAN; .)
= TokenTerm <gL, gR>           (. first := TRUE .)
  { WEAK "|"
    TokenTerm <gL2, gR2>       (. IF first THEN BEGIN
                                    CRTable.MakeFirstAlt(gL, gR); first := FALSE
                                  END;
                                  CRTable.ConcatAlt(gL, gR, gL2, gR2) .)
  }.

(*----------------------------------------------------------------------------*)

TokenTerm <VAR gL, gR: INTEGER>
                               (. VAR
                                    gL2, gR2: INTEGER; .)
= TokenFactor <gL, gR>
  { TokenFactor <gL2, gR2>     (. CRTable.ConcatSeq(gL, gR, gL2, gR2) .)
  }
  [ "CONTEXT"
    "(" TokenExpr <gL2, gR2>   (. SetCtx(gL2); CRTable.ConcatSeq(gL, gR, gL2, gR2) .)
    ")"
  ].

(*----------------------------------------------------------------------------*)

TokenFactor <VAR gL, gR: INTEGER>
                               (. VAR
                                    kind, c: INTEGER;
                                    oneSet:  CRTable.CRTSet;
                                    name:    CRTable.Name; .)
=                              (. gL :=0; gR := 0 .)
( Symbol <name, kind>          (. IF kind = ident
                                    THEN
                                      BEGIN
                                        c := CRTable.ClassWithName(name);
                                        IF c < 0 THEN BEGIN
                                          SemError(115);
                                          Sets.Clear(oneSet); c := CRTable.NewClass(name, oneSet)
                                        END;
                                        gL := CRTable.NewNode(CRTable.class, c, 0); gR := gL
                                      END
                                    ELSE (* string *)
                                      CRTable.StrToGraph(name, gL, gR)  .)
| "(" TokenExpr <gL, gR> ")"
| "[" TokenExpr <gL, gR> "]"   (. CRTable.MakeOption(gL, gR) .)
| "{" TokenExpr <gL, gR> "}"   (. CRTable.MakeIteration(gL, gR) .)
).

(*----------------------------------------------------------------------------*)

Ident <VAR name: CRTable.Name> (. VAR
                                    str: STRING; .)
  = ident                      (. CRS.GetName(CRS.pos, CRS.len, str);
                                  name := str .).

(*----------------------------------------------------------------------------*)

Symbol <VAR name: CRTable.Name; VAR kind: INTEGER>
                               (. VAR
                                    myName: STRING; .)
  =
  ( Ident <name>               (. kind := ident .)
  | string                     (. CRS.GetName(CRS.pos, CRS.len, myName);
                                  kind := stringSym;
                                  FixString(myName, CRS.len);
                                  name := myName .)
  ).

(*----------------------------------------------------------------------------*)

Attribs <VAR attrPos: CRTable.Position> =
    "<"                        (. attrPos.beg := CRS.pos + 1; attrPos.col := CRS.col + 1 .)
    { ANY | badstring          (. SemError(102) .)
    }
    ">"                        (. attrPos.len := (CRS.pos - attrPos.beg) .)
  |
    "<."                       (. attrPos.beg := CRS.pos + 2; attrPos.col := CRS.col + 2 .)
    { ANY | badstring          (. SemError(102) .)
    }
    ".>"                       (. attrPos.len := (CRS.pos - attrPos.beg) .).

(*----------------------------------------------------------------------------*)

SemText <VAR semPos: CRTable.Position> =
  "(."                         (. semPos.beg := CRS.pos + 2; semPos.col := CRS.col + 2 .)
  {   ANY
    | badstring                (. SemError(102) .)
    | "(."                     (. SemError(109) .)
  }
  ".)"                         (. semPos.len := (CRS.pos - semPos.beg) .).


(*----------------------------------------------------------------------------*)

NameDecl                       (. VAR
                                    name: CRTable.Name;
                                    str: STRING; .)
  = Ident <name> "="
    ( ident                    (. CRS.GetName(CRS.pos, CRS.len, str) .)
      | string                 (. CRS.GetName(CRS.pos, CRS.len, str);
                                  FixString(str, CRS.len) .)
       )                       (. CRTable.NewName(name, str) .)
  ".".

(*----------------------------------------------------------------------------*)

END CR.