M2compiler-V1/M2cP.mod

IMPLEMENTATION MODULE M2cP;

(* Parser generated by Coco/R - assuming ISO IO library will be available. *)

IMPORT M2cS, FileIO;

IMPORT SymTab, MGen;



CONST 
  maxT = 69;
  minErrDist  =  2;  (* minimal distance (good tokens) between two errors *)
  setsize     = 16;  (* sets are stored in 16 bits *)

TYPE
  SymbolSet = ARRAY [0 .. maxT DIV setsize] OF BITSET;

VAR
  symSet:  ARRAY [0 ..   6] OF SymbolSet; (*symSet[0] = allSyncSyms*)
  errDist: CARDINAL;   (* number of symbols recognized since last error *)
  sym:     CARDINAL;   (* current input symbol *)

PROCEDURE SemError (errNo: INTEGER);
  BEGIN
    IF errDist >= minErrDist THEN
      M2cS.Error(errNo, M2cS.line, M2cS.col, M2cS.pos);
    END;
    errDist := 0;
  END SemError;

PROCEDURE SynError (errNo: INTEGER);
  BEGIN
    IF errDist >= minErrDist THEN
      M2cS.Error(errNo, M2cS.nextLine, M2cS.nextCol, M2cS.nextPos);
    END;
    errDist := 0;
  END SynError;

PROCEDURE Get;
  VAR
    s: ARRAY [0 .. 31] OF CHAR;
  BEGIN
    REPEAT
      M2cS.Get(sym);
      IF sym <= maxT THEN
        INC(errDist);
      ELSE
        
      END;
    UNTIL sym <= maxT
  END Get;

PROCEDURE In (VAR s: SymbolSet; x: CARDINAL): BOOLEAN;
  BEGIN
    RETURN x MOD setsize IN s[x DIV setsize];
  END In;

PROCEDURE Expect (n: CARDINAL);
  BEGIN
    IF sym = n THEN Get ELSE SynError(n) END
  END Expect;

PROCEDURE ExpectWeak (n, follow: CARDINAL);
  BEGIN
    IF sym = n
      THEN Get
      ELSE SynError(n); WHILE ~ In(symSet[follow], sym) DO Get END
    END
  END ExpectWeak;

PROCEDURE WeakSeparator (n, syFol, repFol: CARDINAL): BOOLEAN;
  VAR
    s: SymbolSet;
    i: CARDINAL;
  BEGIN
    IF sym = n
      THEN Get; RETURN TRUE
      ELSIF In(symSet[repFol], sym) THEN RETURN FALSE
      ELSE
        i := 0;
        WHILE i <= maxT DIV setsize DO
          s[i] := symSet[0, i] + symSet[syFol, i] + symSet[repFol, i]; INC(i)
        END;
        SynError(n); WHILE ~ In(s, sym) DO Get END;
        RETURN In(symSet[syFol], sym)
    END
  END WeakSeparator;

PROCEDURE LexName (VAR Lex: ARRAY OF CHAR);
  BEGIN
    M2cS.GetName(M2cS.pos, M2cS.len, Lex)
  END LexName;

PROCEDURE LexString (VAR Lex: ARRAY OF CHAR);
  BEGIN
    M2cS.GetString(M2cS.pos, M2cS.len, Lex)
  END LexString;

PROCEDURE LookAheadName (VAR Lex: ARRAY OF CHAR);
  BEGIN
    M2cS.GetName(M2cS.nextPos, M2cS.nextLen, Lex)
  END LookAheadName;

PROCEDURE LookAheadString (VAR Lex: ARRAY OF CHAR);
  BEGIN
    M2cS.GetString(M2cS.nextPos, M2cS.nextLen, Lex)
  END LookAheadString;

PROCEDURE Successful (): BOOLEAN;
  BEGIN
    RETURN M2cS.errors = 0
  END Successful;

(* ----- FORWARD not needed in multipass compilers

PROCEDURE Elem (VAR t: SymTab.TypeIndex; VAR lx: MGen.LitStr;
                 VAR lx2: MGen.LitStr; VAR hasR: BOOLEAN); FORWARD;
PROCEDURE SetLit (VAR t: SymTab.TypeIndex); FORWARD;
PROCEDURE MulOp (VAR op: INTEGER); FORWARD;
PROCEDURE Fact (VAR t: SymTab.TypeIndex; VAR lx: MGen.LitStr;
                 VAR v: BOOLEAN; VAR vn: SymTab.Name); FORWARD;
PROCEDURE AddOp (VAR op: INTEGER); FORWARD;
PROCEDURE Term (VAR t: SymTab.TypeIndex; VAR lx: MGen.LitStr;
                 VAR v: BOOLEAN; VAR vn: SymTab.Name); FORWARD;
PROCEDURE Rel (VAR op: INTEGER); FORWARD;
PROCEDURE SimExpr (VAR t: SymTab.TypeIndex; VAR lx: MGen.LitStr;
                    VAR v: BOOLEAN; VAR vn: SymTab.Name); FORWARD;
PROCEDURE Design (VAR t: SymTab.TypeIndex; VAR k: INTEGER;
                   VAR bn: SymTab.Name; doLoad: BOOLEAN; VAR lx: MGen.LitStr); FORWARD;
PROCEDURE ByLit (VAR v: INTEGER); FORWARD;
PROCEDURE Labels (sel: SymTab.TypeIndex; tmp: INTEGER; bodyL: INTEGER); FORWARD;
PROCEDURE LabelList (sel: SymTab.TypeIndex; tmp: INTEGER;
                      VAR lB: INTEGER; VAR lN: INTEGER); FORWARD;
PROCEDURE Case (sel: SymTab.TypeIndex; tmp: INTEGER; endL: INTEGER); FORWARD;
PROCEDURE CallTail (pn: SymTab.Name; sfx: BOOLEAN; inExpr: BOOLEAN;
                     VAR ok: BOOLEAN; hasDead: BOOLEAN); FORWARD;
PROCEDURE DesignTail (VAR t: SymTab.TypeIndex; VAR k: INTEGER;
                       VAR bn: SymTab.Name; doLoad: BOOLEAN; VAR lx: MGen.LitStr;
                       VAR sfx: BOOLEAN); FORWARD;
PROCEDURE DesignHead (VAR t: SymTab.TypeIndex; VAR k: INTEGER;
                       VAR bn: SymTab.Name; doLoad: BOOLEAN; VAR lx: MGen.LitStr); FORWARD;
PROCEDURE ReturnStat; FORWARD;
PROCEDURE WithStat; FORWARD;
PROCEDURE ForStat; FORWARD;
PROCEDURE LoopStat; FORWARD;
PROCEDURE RepeatStat; FORWARD;
PROCEDURE WhileStat; FORWARD;
PROCEDURE CaseStat; FORWARD;
PROCEDURE IfStat; FORWARD;
PROCEDURE AssignOrCall; FORWARD;
PROCEDURE Stat; FORWARD;
PROCEDURE FieldIdents (rt: SymTab.TypeIndex); FORWARD;
PROCEDURE Field (rt: SymTab.TypeIndex); FORWARD;
PROCEDURE FieldSeq (rt: SymTab.TypeIndex); FORWARD;
PROCEDURE Enum (VAR t: SymTab.TypeIndex); FORWARD;
PROCEDURE PointerType (VAR t: SymTab.TypeIndex); FORWARD;
PROCEDURE SetType (VAR t: SymTab.TypeIndex); FORWARD;
PROCEDURE RecordType (VAR t: SymTab.TypeIndex); FORWARD;
PROCEDURE ArrayType (VAR t: SymTab.TypeIndex); FORWARD;
PROCEDURE SimpleType (VAR t: SymTab.TypeIndex); FORWARD;
PROCEDURE FPSection; FORWARD;
PROCEDURE QualIdent (VAR t: SymTab.TypeIndex); FORWARD;
PROCEDURE FormalParams; FORWARD;
PROCEDURE VarIdents; FORWARD;
PROCEDURE Type (VAR t: SymTab.TypeIndex); FORWARD;
PROCEDURE Expr (VAR t: SymTab.TypeIndex; VAR lx: MGen.LitStr;
                 VAR v: BOOLEAN; VAR vn: SymTab.Name); FORWARD;
PROCEDURE ConstExpr (VAR t: SymTab.TypeIndex; VAR lx: MGen.LitStr); FORWARD;
PROCEDURE ProcedureDecl; FORWARD;
PROCEDURE VarDecl; FORWARD;
PROCEDURE TypeDecl; FORWARD;
PROCEDURE ConstDecl; FORWARD;
PROCEDURE StatSeq; FORWARD;
PROCEDURE Declaration; FORWARD;
PROCEDURE ImportList; FORWARD;
PROCEDURE Block (isProc: BOOLEAN); FORWARD;
PROCEDURE Import; FORWARD;
PROCEDURE GetIdent (VAR n: SymTab.Name); FORWARD;
PROCEDURE M2c; FORWARD;

----- *)

PROCEDURE Elem (VAR t: SymTab.TypeIndex; VAR lx: MGen.LitStr;
                 VAR lx2: MGen.LitStr; VAR hasR: BOOLEAN);
  VAR t2: SymTab.TypeIndex;
    vD, vD2: BOOLEAN;
    vnD, vnD2: SymTab.Name;
  BEGIN
    Expr(t, lx, vD, vnD);
    hasR := FALSE;
    lx2[0] := 0C;;
    IF (sym = 23) THEN
      Get;
      Expr(t2, lx2, vD2, vnD2);
      IF ~SymTab.SetElemCheck(t, t2) THEN
      SemError(222) END;
      hasR := TRUE;;
    END;
  END Elem;

PROCEDURE SetLit (VAR t: SymTab.TypeIndex);
  VAR first, et: SymTab.TypeIndex;
    lxE, lxE2: MGen.LitStr;
    vE, vE2: BOOLEAN;
    vnE, vnE2: SymTab.Name;
    hasR: BOOLEAN;
  BEGIN
    Expect(67);
    MGen.PushInt(0);
    t := SymTab.SetFor(SymTab.IntType());;
    IF In(symSet[1], sym) THEN
      Elem(et, lxE, lxE2, hasR);
      first := et;
      t := SymTab.SetFor(et);
      IF hasR THEN MGen.FieldMask
      ELSE MGen.Power2 END;
      MGen.Or;;
      WHILE (sym = 10) DO
        Get;
        Elem(et, lxE, lxE2, hasR);
        IF ~SymTab.SetElemCheck(first, et) THEN
        SemError(222) END;
        IF hasR THEN MGen.FieldMask
        ELSE MGen.Power2 END;
        MGen.Or;;
      END;
    END;
    Expect(68);
  END SetLit;

PROCEDURE MulOp (VAR op: INTEGER);
  BEGIN
    CASE sym OF
      59 :
        Get;
        op := SymTab.OpTimes;;
    | 60 :
        Get;
        op := SymTab.OpSlash;;
    | 61 :
        Get;
        op := SymTab.OpDiv;;
    | 62 :
        Get;
        op := SymTab.OpMod;;
    | 63 :
        Get;
        op := SymTab.OpAnd;;
    | 64 :
        Get;
        op := SymTab.OpAnd;;
    ELSE SynError(70);
    END;
  END MulOp;

PROCEDURE Fact (VAR t: SymTab.TypeIndex; VAR lx: MGen.LitStr;
                 VAR v: BOOLEAN; VAR vn: SymTab.Name);
  VAR s: ARRAY [0 .. 255] OF CHAR;
    t2, et, dt, st: SymTab.TypeIndex;
    dk: INTEGER;
    bnF: SymTab.Name;
    lxD, lx2: MGen.LitStr;
    v2: BOOLEAN;
    vn2: SymTab.Name;
    vi: INTEGER;
    c: CARDINAL;
    b: LONGCARD;
    sfxF: BOOLEAN;
    okF: BOOLEAN;
  BEGIN
    CASE sym OF
      2 :
        Get;
        LexString(s);
        MGen.CopyName(s, lx);
        v := FALSE;
        IF MGen.ParseInt(s, vi) THEN
          MGen.PushInt(vi)
        ELSIF MGen.ParseCard(s, c) THEN
          MGen.PushBits(
            VAL(LONGCARD, c))
        ELSE MGen.PushInt(0)
        END;
        t := SymTab.IntType();;
    | 3 :
        Get;
        LexString(s);
        MGen.CopyName(s, lx);
        v := FALSE;
        IF MGen.ParseReal(s, b) THEN
          MGen.PushBits(b)
        ELSE MGen.PushBits(0H)
        END;
        t := SymTab.RealType();;
    | 4 :
        Get;
        LexString(s);
        v := FALSE;
        IF SymTab.StrLen(s) <= 3 THEN
          t := SymTab.CharType();
          MGen.CopyName(s, lx);
          MGen.PushInt(
            MGen.CharOrd(s))
        ELSE t := SymTab.NewStr();
          SemError(230);
          lx[0] := 0C;
          MGen.PushInt(0)
        END;;
    | 1 :
        DesignHead(dt, dk, bnF, TRUE, lxD);
        DesignTail(dt, dk, bnF, TRUE, lxD, sfxF);
        t := dt;
        MGen.CopyName(lxD, lx);
        v := ~sfxF
             & ((dk = SymTab.KindVar)
             OR (dk = SymTab.KindParam)
             OR (dk
                 = SymTab.KindVarPar));
        MGen.CopyName(bnF, vn);;
        IF (sym = 19) THEN
          CallTail(bnF, sfxF, TRUE, okF, TRUE);
          IF okF THEN
            IF SymTab.SymKind(bnF)
               = SymTab.KindProc THEN
              t := SymTab.ProcRet(bnF)
            ELSE
              t := SymTab.InvalidType
            END
          ELSE t := SymTab.InvalidType
          END;
          lx[0] := 0C; v := FALSE;;
        END;
    | 19 :
        Get;
        Expr(et, lx, v, vn);
        Expect(20);
        t := et;;
    | 65, 66 :
        IF (sym = 65) THEN
          Get;
        ELSE
          Get;
        END;
        Fact(t2, lx2, v2, vn2);
        lx[0] := 0C; v := FALSE;
        IF SymTab.BoolCheck(t2) THEN
          t := SymTab.BoolType()
        ELSE SemError(212);
          t := SymTab.InvalidType END;
        MGen.Not;;
    | 67 :
        SetLit(st);
        lx[0] := 0C; v := FALSE;
        t := st;;
    ELSE SynError(71);
    END;
  END Fact;

PROCEDURE AddOp (VAR op: INTEGER);
  BEGIN
    IF (sym = 57) THEN
      Get;
      op := SymTab.OpAdd;;
    ELSIF (sym = 46) THEN
      Get;
      op := SymTab.OpSub;;
    ELSIF (sym = 58) THEN
      Get;
      op := SymTab.OpOr;;
    ELSE SynError(72);
    END;
  END AddOp;

PROCEDURE Term (VAR t: SymTab.TypeIndex; VAR lx: MGen.LitStr;
                 VAR v: BOOLEAN; VAR vn: SymTab.Name);
  VAR t2, res2: SymTab.TypeIndex;
    op: INTEGER;
    lx2: MGen.LitStr;
    v2: BOOLEAN;
    vn2: SymTab.Name;
    isR: BOOLEAN;
    mt: INTEGER;
  BEGIN
    Fact(t, lx, v, vn);
    WHILE In(symSet[2], sym) DO
      MulOp(op);
      Fact(t2, lx2, v2, vn2);
      lx[0] := 0C; v := FALSE;
      IF op = SymTab.OpAnd THEN
        IF SymTab.BoolCheck(t) & SymTab.BoolCheck(t2) THEN
          t := SymTab.BoolType()
        ELSE SemError(212); t := SymTab.InvalidType END;
        MGen.And
      ELSE
        IF SymTab.ArithCheck(t, t2,
             (op = SymTab.OpDiv) OR (op = SymTab.OpMod),
             res2) THEN t := res2
        ELSE SemError(211); t := SymTab.InvalidType END;
        isR := (t # SymTab.InvalidType)
               & (SymTab.ClassOf(t) = SymTab.ClReal);
        IF op = SymTab.OpTimes THEN
          IF isR THEN MGen.RealMul ELSE MGen.MulU END
        ELSIF op = SymTab.OpSlash THEN
          IF isR THEN MGen.RealDiv ELSE MGen.DivI END
        ELSIF op = SymTab.OpDiv THEN
          MGen.DivI
        ELSE
          mt := MGen.TempGlobal();
          MGen.ModI(mt)
        END
      END;;
    END;
  END Term;

PROCEDURE Rel (VAR op: INTEGER);
  BEGIN
    CASE sym OF
      16 :
        Get;
        op := SymTab.OpEq;;
    | 50 :
        Get;
        op := SymTab.OpNeq1;;
    | 51 :
        Get;
        op := SymTab.OpNeq2;;
    | 52 :
        Get;
        op := SymTab.OpLt;;
    | 53 :
        Get;
        op := SymTab.OpLe;;
    | 54 :
        Get;
        op := SymTab.OpGt;;
    | 55 :
        Get;
        op := SymTab.OpGe;;
    | 56 :
        Get;
        op := SymTab.OpIn;;
    ELSE SynError(73);
    END;
  END Rel;

PROCEDURE SimExpr (VAR t: SymTab.TypeIndex; VAR lx: MGen.LitStr;
                    VAR v: BOOLEAN; VAR vn: SymTab.Name);
  VAR t2, res2: SymTab.TypeIndex;
    op: INTEGER;
    lx2: MGen.LitStr;
    v2: BOOLEAN;
    vn2: SymTab.Name;
    neg, isR: BOOLEAN;
  BEGIN
    neg := FALSE;;
    IF (sym = 46) OR (sym = 57) THEN
      IF (sym = 57) THEN
        Get;
      ELSE
        Get;
        neg := TRUE;;
      END;
    END;
    Term(t, lx, v, vn);
    IF neg THEN
    v := FALSE;
    IF MGen.IsLit(lx) THEN
      MGen.NegFold(lx, lx)
    ELSE lx[0] := 0C
    END;
    IF SymTab.ClassOf(t)
       = SymTab.ClReal THEN
      MGen.NegReal
    ELSE MGen.NegInt
    END
    END;;
    WHILE (sym = 46) OR (sym = 57) OR (sym = 58) DO
      AddOp(op);
      Term(t2, lx2, v2, vn2);
      lx[0] := 0C; v := FALSE;
      IF op = SymTab.OpOr THEN
        IF SymTab.BoolCheck(t) & SymTab.BoolCheck(t2) THEN
          t := SymTab.BoolType()
        ELSE SemError(212); t := SymTab.InvalidType END;
        MGen.Or
      ELSE
        IF SymTab.ArithCheck(t, t2, FALSE, res2) THEN t := res2
        ELSE SemError(211); t := SymTab.InvalidType END;
        isR := (t # SymTab.InvalidType)
               & (SymTab.ClassOf(t) = SymTab.ClReal);
        IF op = SymTab.OpAdd THEN
          IF isR THEN MGen.RealAdd ELSE MGen.Add END
        ELSE
          IF isR THEN MGen.RealSub ELSE MGen.Sub END
        END
      END;;
    END;
  END SimExpr;

PROCEDURE Design (VAR t: SymTab.TypeIndex; VAR k: INTEGER;
                   VAR bn: SymTab.Name; doLoad: BOOLEAN; VAR lx: MGen.LitStr);
  VAR sfxD: BOOLEAN;
  BEGIN
    DesignHead(t, k, bn, doLoad, lx);
    DesignTail(t, k, bn, doLoad, lx, sfxD);
  END Design;

PROCEDURE ByLit (VAR v: INTEGER);
  VAR s: ARRAY [0 .. 255] OF CHAR;
  BEGIN
    IF (sym = 2) THEN
      Get;
      LexString(s);
      IF ~MGen.ParseInt(s, v) THEN
        v := 1
      END;;
    ELSIF (sym = 46) THEN
      Get;
      Expect(2);
      LexString(s);
      IF MGen.ParseInt(s, v) THEN
        v := -v
      ELSE v := -1
      END;;
    ELSE SynError(74);
    END;
  END ByLit;

PROCEDURE Labels (sel: SymTab.TypeIndex; tmp: INTEGER; bodyL: INTEGER);
  VAR t, t2: SymTab.TypeIndex;
    lx1, lx2: MGen.LitStr;
    v1, v2: BOOLEAN;
    vn1, vn2: SymTab.Name;
    ta, tb, chunk: INTEGER;
    r, hasRange: BOOLEAN;
  BEGIN
    ConstExpr(t, lx1);
    IF ~SymTab.EqCheck(t, sel) THEN
    SemError(213) END;
    r := (SymTab.ClassOf(sel)
          = SymTab.ClReal)
         & (SymTab.ClassOf(t)
            = SymTab.ClReal);
    ta := MGen.TempGlobal();
    MGen.StoreTemp(ta);
    hasRange := FALSE;;
    IF (sym = 23) THEN
      Get;
      ConstExpr(t2, lx2);
      IF ~SymTab.EqCheck(t2, sel) THEN
      SemError(213) END;
      tb := MGen.TempGlobal();
      MGen.StoreTemp(tb);
      hasRange := TRUE;;
    END;
    IF hasRange THEN
      MGen.LoadTemp(tmp);
      MGen.LoadTemp(ta);
      IF r THEN MGen.RealGe
      ELSE MGen.IGe END;
      MGen.LoadTemp(tmp);
      MGen.LoadTemp(tb);
      IF r THEN MGen.RealLe
      ELSE MGen.ILe END;
      MGen.And
    ELSE
      MGen.LoadTemp(tmp);
      MGen.LoadTemp(ta);
      IF r THEN MGen.RealEq
      ELSE MGen.Eq END
    END;
    chunk := MGen.NewLabel();
    MGen.Jz(chunk);
    MGen.Jmp(bodyL);
    MGen.DefLabel(chunk);;
  END Labels;

PROCEDURE LabelList (sel: SymTab.TypeIndex; tmp: INTEGER;
                      VAR lB: INTEGER; VAR lN: INTEGER);
  BEGIN
    lB := MGen.NewLabel();
    lN := MGen.NewLabel();;
    Labels(sel, tmp, lB);
    WHILE (sym = 10) DO
      Get;
      Labels(sel, tmp, lB);
    END;
    MGen.Jmp(lN);;
  END LabelList;

PROCEDURE Case (sel: SymTab.TypeIndex; tmp: INTEGER; endL: INTEGER);
  VAR lB, lN: INTEGER;
  BEGIN
    IF In(symSet[1], sym) THEN
      LabelList(sel, tmp, lB, lN);
      Expect(17);
      MGen.DefLabel(lB);;
      StatSeq;
      MGen.Jmp(endL);
      MGen.DefLabel(lN);;
    END;
  END Case;

PROCEDURE CallTail (pn: SymTab.Name; sfx: BOOLEAN; inExpr: BOOLEAN;
                     VAR ok: BOOLEAN; hasDead: BOOLEAN);
  VAR t: SymTab.TypeIndex;
    lx: MGen.LitStr;
    v: BOOLEAN;
    vn: SymTab.Name;
  BEGIN
    Expect(19);
    ok := FALSE;
    IF hasDead THEN MGen.Drop END;
    MGen.ActBegin(pn);;
    IF In(symSet[1], sym) THEN
      Expr(t, lx, v, vn);
      IF MGen.ActValue(t, v, vn) # 0 THEN
      SemError(233)
      END;;
      WHILE (sym = 10) DO
        Get;
        Expr(t, lx, v, vn);
        IF MGen.ActValue(t, v, vn) # 0 THEN
        SemError(233)
        END;;
      END;
    END;
    Expect(20);
    IF MGen.ActEnd(pn, sfx, inExpr) # 0
    THEN SemError(233)
    ELSE ok := TRUE
    END;;
  END CallTail;

PROCEDURE DesignTail (VAR t: SymTab.TypeIndex; VAR k: INTEGER;
                       VAR bn: SymTab.Name; doLoad: BOOLEAN; VAR lx: MGen.LitStr;
                       VAR sfx: BOOLEAN);
  VAR m: SymTab.Name;
    it: SymTab.TypeIndex;
    lxI: MGen.LitStr;
    vI: BOOLEAN;
    vnI: SymTab.Name;
  BEGIN
    sfx := FALSE;;
    WHILE (sym = 7) OR (sym = 22) OR (sym = 49) DO
      IF (sym = 7) THEN
        Get;
        sfx := TRUE; lx[0] := 0C;;
        GetIdent(m);
        IF t = SymTab.InvalidType THEN
        ELSIF SymTab.ClassOf(t) #
              SymTab.ClRecord THEN
          SemError(215);
          t := SymTab.InvalidType
        ELSIF ~SymTab.FieldExists(t, m) THEN
          SemError(216);
          t := SymTab.InvalidType
        ELSE t := SymTab.FieldType(t, m);
          SemError(230)
        END;
        IF doLoad THEN
          MGen.Drop; MGen.PushInt(0)
        END;;
      ELSIF (sym = 22) THEN
        Get;
        sfx := TRUE; lx[0] := 0C;;
        Expr(it, lxI, vI, vnI);
        MGen.Drop;
        IF t = SymTab.InvalidType THEN
        ELSIF SymTab.ClassOf(t) #
              SymTab.ClArray THEN
          SemError(217);
          t := SymTab.InvalidType
        ELSIF (it #
               SymTab.InvalidType)
          & ~SymTab.IsIntFamily(it) THEN
          SemError(218);
          t := SymTab.InvalidType
        ELSE t :=
          SymTab.ArrayElem(t);
          SemError(230)
        END;
        IF doLoad THEN
          MGen.Drop; MGen.PushInt(0)
        END;;
        WHILE (sym = 10) DO
          Get;
          Expr(it, lxI, vI, vnI);
          MGen.Drop;
          IF (it # SymTab.InvalidType)
          & ~SymTab.IsIntFamily(it) THEN
          SemError(218) END;;
        END;
        Expect(24);
      ELSE
        Get;
        sfx := TRUE; lx[0] := 0C;;
        IF t = SymTab.InvalidType THEN
        ELSIF SymTab.ClassOf(t) #
              SymTab.ClPtr THEN
          SemError(219);
          t := SymTab.InvalidType
        ELSE t := SymTab.PtrBase(t);
          SemError(230)
        END;
        IF doLoad THEN
          MGen.Drop; MGen.PushInt(0)
        END;;
      END;
    END;
  END DesignTail;

PROCEDURE DesignHead (VAR t: SymTab.TypeIndex; VAR k: INTEGER;
                       VAR bn: SymTab.Name; doLoad: BOOLEAN; VAR lx: MGen.LitStr);
  VAR n: SymTab.Name;
    cls: INTEGER;
  BEGIN
    GetIdent(n);
    MGen.CopyName(n, bn);
    lx[0] := 0C;
    IF ~SymTab.Lookup(n) THEN
      SemError(201);
      t := SymTab.InvalidType; k := -1;
      IF doLoad THEN
        MGen.PushInt(0)
      END
    ELSE
      t := SymTab.SymType(n);
      k := SymTab.SymKind(n);
      IF k = SymTab.KindConst THEN
        IF SymTab.Equal(n, "TRUE") THEN
          t := SymTab.BoolType();
          MGen.CopyName("TRUE", lx);
          IF doLoad THEN
            MGen.PushInt(1)
          END
        ELSIF SymTab.Equal(n,
                "FALSE") THEN
          t := SymTab.BoolType();
          MGen.CopyName("FALSE", lx);
          IF doLoad THEN
            MGen.PushInt(0)
          END
        ELSE
          cls :=
            SymTab.ClassOf(t);
          IF (t #
              SymTab.InvalidType)
             & (cls # SymTab.ClStr)
             & ((cls = SymTab.ClInt)
             OR (cls = SymTab.ClReal)
             OR (cls = SymTab.ClBool)
             OR (cls = SymTab.ClChar)
             OR (cls
                 = SymTab.ClEnum)) THEN
            IF doLoad THEN
              MGen.LoadVar(n)
            END
          ELSIF doLoad THEN
            MGen.PushInt(0)
          END
        END
      ELSIF (k = SymTab.KindVar)
         OR (k = SymTab.KindParam)
         OR (k
             = SymTab.KindVarPar) THEN
        cls := SymTab.ClassOf(t);
        IF (cls = SymTab.ClInt)
           OR (cls = SymTab.ClReal)
           OR (cls = SymTab.ClBool)
           OR (cls = SymTab.ClChar)
           OR (cls
               = SymTab.ClEnum)
           OR (cls
               = SymTab.ClSet) THEN
          IF doLoad THEN
            MGen.PushVar(n)
          END
        ELSE SemError(230);
          IF doLoad THEN
            MGen.PushInt(0)
          END
        END
      ELSE
        IF doLoad THEN
          MGen.PushInt(0)
        END;
        IF k = SymTab.KindField THEN
          IF ~MGen.NoSup() THEN
            SemError(230)
          END
        ELSIF k
              = SymTab.KindImport THEN
          SemError(230)
        END
      END
    END;;
  END DesignHead;

PROCEDURE ReturnStat;
  VAR t: SymTab.TypeIndex;
    lx: MGen.LitStr;
    v: BOOLEAN;
    vn: SymTab.Name;
    hasE, doRet, conv: BOOLEAN;
  BEGIN
    Expect(48);
    hasE := FALSE;;
    IF In(symSet[1], sym) THEN
      Expr(t, lx, v, vn);
      hasE := TRUE;
      doRet := FALSE;
      IF ~SymTab.InProc() THEN
        SemError(232)
      ELSIF ~SymTab.InFunction() THEN
        SemError(232)
      ELSIF ~SymTab.Assignable(
                t, SymTab.CurRet()) THEN
        SemError(232)
      ELSE doRet := TRUE
      END;
      conv := doRet
              & SymTab.IsIntFamily(t)
              & (SymTab.ClassOf(
                   SymTab.CurRet())
                 = SymTab.ClReal);
      IF doRet THEN
        IF conv THEN
          MGen.IntToReal
        END;
        MGen.Leave(
          SymTab.CurNPar(), TRUE)
      ELSE MGen.Drop
      END;;
    END;
    IF ~hasE THEN
      IF ~SymTab.InProc() THEN
        SemError(232)
      ELSIF SymTab.InFunction() THEN
        SemError(232)
      ELSE MGen.Leave(
        SymTab.CurNPar(), FALSE)
      END
    END;;
  END ReturnStat;

PROCEDURE WithStat;
  VAR dt: SymTab.TypeIndex;
    dk: INTEGER;
    bnW: SymTab.Name;
    lxW: MGen.LitStr;
    pushed: BOOLEAN;
  BEGIN
    Expect(47);
    Design(dt, dk, bnW, FALSE, lxW);
    pushed := FALSE;
    IF dt # SymTab.InvalidType THEN
      pushed :=
        SymTab.PushRecord(dt);
      IF ~pushed THEN
        SemError(215)
      END
    END;
    IF pushed THEN
      MGen.NoSupEnter;
      SemError(230)
    END;;
    Expect(40);
    StatSeq;
    Expect(12);
    IF pushed THEN
      SymTab.PopScope;
      MGen.NoSupExit
    END;;
  END WithStat;

PROCEDURE ForStat;
  VAR n, lv: SymTab.Name;
    fk: INTEGER;
    lo, hi: SymTab.TypeIndex;
    lxLo, lxHi: MGen.LitStr;
    vLo, vHi: BOOLEAN;
    vnLo, vnHi: SymTab.Name;
    byV, ht: INTEGER;
    lTop, lChk, lEnd: INTEGER;
    neg, storable: BOOLEAN;
  BEGIN
    Expect(44);
    GetIdent(n);
    IF ~SymTab.Lookup(n) THEN
     SemError(201);
     fk := -1
    ELSIF (SymTab.SymKind(n) #
          SymTab.KindVar)
     & (SymTab.SymKind(n) #
        SymTab.KindParam)
     & (SymTab.SymKind(n) #
        SymTab.KindVarPar)
     & (SymTab.SymKind(n) #
        SymTab.KindField) THEN
     SemError(220);
     fk := -1
    ELSIF (SymTab.SymType(n) #
          SymTab.InvalidType)
     & ~SymTab.IsIntFamily(
         SymTab.SymType(n)) THEN
     SemError(220);
     fk := -1
    ELSE
     fk := SymTab.SymKind(n)
    END;
    MGen.CopyName(n, lv);
    storable := (fk = SymTab.KindVar)
     OR (fk = SymTab.KindParam)
     OR (fk = SymTab.KindVarPar);
    IF storable THEN
     MGen.StoreSetup(lv)
    END;;
    Expect(32);
    Expr(lo, lxLo, vLo, vnLo);
    IF (lo # SymTab.InvalidType)
    & ~SymTab.IsIntFamily(lo) THEN
    SemError(220) END;
    IF storable THEN
      MGen.StoreFinish(lv)
    ELSE MGen.Drop
    END;;
    Expect(30);
    Expr(hi, lxHi, vHi, vnHi);
    IF (hi # SymTab.InvalidType)
    & ~SymTab.IsIntFamily(hi) THEN
    SemError(220) END;
    ht := MGen.TempGlobal();
    MGen.StoreTemp(ht);
    byV := 1; neg := FALSE;;
    IF (sym = 45) THEN
      Get;
      ByLit(byV);
      neg := byV < 0;;
    END;
    Expect(40);
    lTop := MGen.NewLabel();
    lChk := MGen.NewLabel();
    lEnd := MGen.NewLabel();
    MGen.Jmp(lChk);
    MGen.DefLabel(lTop);;
    StatSeq;
    Expect(12);
    MGen.PushVar(lv);
    MGen.PushInt(byV);
    MGen.Add;
    IF storable THEN
      MGen.StoreFinish(lv)
    ELSE MGen.Drop
    END;
    MGen.DefLabel(lChk);
    MGen.PushVar(lv);
    MGen.LoadTemp(ht);
    IF neg THEN MGen.IGe
    ELSE MGen.ILe END;
    MGen.Jz(lEnd);
    MGen.Jmp(lTop);
    MGen.DefLabel(lEnd);;
  END ForStat;

PROCEDURE LoopStat;
  VAR topL, exitL: INTEGER;
  BEGIN
    Expect(43);
    topL := MGen.NewLabel();
    exitL := MGen.NewLabel();
    MGen.DefLabel(topL);
    MGen.PushLoop(exitL);;
    StatSeq;
    Expect(12);
    MGen.Jmp(topL);
    MGen.DefLabel(exitL);
    MGen.PopLoop;;
  END LoopStat;

PROCEDURE RepeatStat;
  VAR t: SymTab.TypeIndex;
    lxC: MGen.LitStr;
    vC: BOOLEAN;
    vnC: SymTab.Name;
    topL: INTEGER;
  BEGIN
    Expect(41);
    topL := MGen.NewLabel();
    MGen.DefLabel(topL);;
    StatSeq;
    Expect(42);
    Expr(t, lxC, vC, vnC);
    IF ~SymTab.BoolCheck(t) THEN
    SemError(214) END;
    MGen.Jz(topL);;
  END RepeatStat;

PROCEDURE WhileStat;
  VAR t: SymTab.TypeIndex;
    lxC: MGen.LitStr;
    vC: BOOLEAN;
    vnC: SymTab.Name;
    topL, endL: INTEGER;
  BEGIN
    Expect(39);
    topL := MGen.NewLabel();
    endL := MGen.NewLabel();
    MGen.DefLabel(topL);;
    Expr(t, lxC, vC, vnC);
    IF ~SymTab.BoolCheck(t) THEN
    SemError(214) END;
    MGen.Jz(endL);;
    Expect(40);
    StatSeq;
    Expect(12);
    MGen.Jmp(topL);
    MGen.DefLabel(endL);;
  END WhileStat;

PROCEDURE CaseStat;
  VAR st: SymTab.TypeIndex;
    lxS: MGen.LitStr;
    vS: BOOLEAN;
    vnS: SymTab.Name;
    tmp, endL: INTEGER;
  BEGIN
    Expect(37);
    Expr(st, lxS, vS, vnS);
    tmp := MGen.TempGlobal();
    MGen.StoreTemp(tmp);
    endL := MGen.NewLabel();;
    Expect(26);
    Case(st, tmp, endL);
    WHILE (sym = 38) DO
      Get;
      Case(st, tmp, endL);
    END;
    IF (sym = 36) THEN
      Get;
      StatSeq;
    END;
    Expect(12);
    MGen.DefLabel(endL);;
  END CaseStat;

PROCEDURE IfStat;
  VAR t: SymTab.TypeIndex;
    lxC: MGen.LitStr;
    vC: BOOLEAN;
    vnC: SymTab.Name;
    elseL, endL: INTEGER;
    hasElse: BOOLEAN;
  BEGIN
    Expect(33);
    Expr(t, lxC, vC, vnC);
    IF ~SymTab.BoolCheck(t) THEN
    SemError(214) END;
    elseL := MGen.NewLabel();
    endL := MGen.NewLabel();
    MGen.Jz(elseL);
    hasElse := FALSE;;
    Expect(34);
    StatSeq;
    WHILE (sym = 35) DO
      Get;
      MGen.Jmp(endL);
      MGen.DefLabel(elseL);;
      Expr(t, lxC, vC, vnC);
      IF ~SymTab.BoolCheck(t) THEN
      SemError(214) END;
      elseL := MGen.NewLabel();
      MGen.Jz(elseL);;
      Expect(34);
      StatSeq;
    END;
    IF (sym = 36) THEN
      Get;
      MGen.Jmp(endL);
      MGen.DefLabel(elseL);
      hasElse := TRUE;;
      StatSeq;
    END;
    Expect(12);
    IF ~hasElse THEN
    MGen.DefLabel(elseL)
    END;
    MGen.DefLabel(endL);;
  END IfStat;

PROCEDURE AssignOrCall;
  VAR dt, et: SymTab.TypeIndex;
    dk: INTEGER;
    bn: SymTab.Name;
    lxD, lxe: MGen.LitStr;
    vE: BOOLEAN;
    vnE: SymTab.Name;
    sfx: BOOLEAN;
    okC: BOOLEAN;
    isR, conv,
    storable: BOOLEAN;
  BEGIN
    sfx := FALSE;;
    DesignHead(dt, dk, bn, FALSE, lxD);
    IF (sym = 7) OR (sym = 22) OR (sym = 32) OR (sym = 49) THEN
      DesignTail(dt, dk, bn, FALSE, lxD, sfx);
      Expect(32);
      storable :=
        (dk = SymTab.KindVar)
        OR (dk = SymTab.KindParam)
        OR (dk = SymTab.KindVarPar);
      IF storable THEN
        MGen.StoreSetup(bn)
      END;;
      Expr(et, lxe, vE, vnE);
      IF (dt # SymTab.InvalidType)
      & (dk # SymTab.KindVar)
      & (dk # SymTab.KindParam)
      & (dk # SymTab.KindVarPar)
      & (dk # SymTab.KindField)
      & (dk # SymTab.KindImport) THEN
      SemError(210)
      ELSIF ~SymTab.Assignable(et, dt) THEN
      SemError(210) END;
      IF dk = SymTab.KindImport THEN
      SemError(230)
      END;
      isR := (dt # SymTab.InvalidType)
           & (SymTab.ClassOf(dt)
              = SymTab.ClReal);
      conv := isR
            & SymTab.IsIntFamily(et);
      IF storable THEN
      IF conv THEN
        MGen.IntToReal
      END;
      MGen.StoreFinish(bn)
      ELSE MGen.Drop
      END;;
    ELSIF (sym = 19) THEN
      CallTail(bn, sfx, FALSE, okC, FALSE);
    ELSIF In(symSet[3], sym) THEN
      MGen.ActBegin(bn);
      IF MGen.ActEnd(bn, FALSE, FALSE) # 0 THEN
        SemError(233)
      END;;
    ELSE SynError(75);
    END;
  END AssignOrCall;

PROCEDURE Stat;
  VAR lx: INTEGER;
  BEGIN
    IF In(symSet[4], sym) THEN
      CASE sym OF
        1 :
          AssignOrCall;
      | 33 :
          IfStat;
      | 37 :
          CaseStat;
      | 39 :
          WhileStat;
      | 41 :
          RepeatStat;
      | 43 :
          LoopStat;
      | 44 :
          ForStat;
      | 47 :
          WithStat;
      | 48 :
          ReturnStat;
      | 31 :
          Get;
          IF MGen.TopLoop(lx) THEN
            MGen.Jmp(lx)
          ELSE SemError(230) END;;
      END;
    END;
  END Stat;

PROCEDURE FieldIdents (rt: SymTab.TypeIndex);
  VAR n: SymTab.Name;
  BEGIN
    GetIdent(n);
    IF ~SymTab.FieldPending(rt, n)
    THEN SemError(200) END;
    WHILE (sym = 10) DO
      Get;
      GetIdent(n);
      IF ~SymTab.FieldPending(rt, n)
      THEN SemError(200) END;
    END;
  END FieldIdents;

PROCEDURE Field (rt: SymTab.TypeIndex);
  VAR et: SymTab.TypeIndex;
  BEGIN
    IF (sym = 1) THEN
      FieldIdents(rt);
      Expect(17);
      Type(et);
      SymTab.FixPendingF(rt, et);;
    END;
  END Field;

PROCEDURE FieldSeq (rt: SymTab.TypeIndex);
  BEGIN
    Field(rt);
    WHILE (sym = 6) DO
      Get;
      Field(rt);
    END;
  END FieldSeq;

PROCEDURE Enum (VAR t: SymTab.TypeIndex);
  VAR n: SymTab.Name;
    ord: INTEGER;
  BEGIN
    Expect(19);
    t := SymTab.NewEnum();
    ord := 0;;
    GetIdent(n);
    IF ~SymTab.Enter(n,
      SymTab.KindConst)
    THEN SemError(200) END;
    SymTab.SetSymType(n, t);
    MGen.DeclConstInt(n, ord);
    INC(ord);;
    WHILE (sym = 10) DO
      Get;
      GetIdent(n);
      IF ~SymTab.Enter(n,
        SymTab.KindConst)
      THEN SemError(200) END;
      SymTab.SetSymType(n, t);
      MGen.DeclConstInt(n, ord);
      INC(ord);;
    END;
    Expect(20);
  END Enum;

PROCEDURE PointerType (VAR t: SymTab.TypeIndex);
  VAR b: SymTab.TypeIndex;
  BEGIN
    Expect(29);
    Expect(30);
    Type(b);
    t := SymTab.NewPtr(b);;
  END PointerType;

PROCEDURE SetType (VAR t: SymTab.TypeIndex);
  VAR s: SymTab.TypeIndex;
  BEGIN
    Expect(28);
    Expect(26);
    SimpleType(s);
    IF (s # SymTab.InvalidType)
     & (SymTab.ClassOf(s) #
        SymTab.ClInt)
     & (SymTab.ClassOf(s) #
        SymTab.ClChar)
     & (SymTab.ClassOf(s) #
        SymTab.ClEnum) THEN
     SemError(224) END;
    t := SymTab.NewSet(s);;
  END SetType;

PROCEDURE RecordType (VAR t: SymTab.TypeIndex);
  BEGIN
    Expect(27);
    t := SymTab.NewRecord();;
    FieldSeq(t);
    Expect(12);
  END RecordType;

PROCEDURE ArrayType (VAR t: SymTab.TypeIndex);
  VAR s, s2, e: SymTab.TypeIndex;
  BEGIN
    Expect(25);
    SimpleType(s);
    IF (s # SymTab.InvalidType)
     & (SymTab.ClassOf(s) #
        SymTab.ClInt)
     & (SymTab.ClassOf(s) #
        SymTab.ClChar)
     & (SymTab.ClassOf(s) #
        SymTab.ClEnum) THEN
     SemError(224) END;;
    WHILE (sym = 10) DO
      Get;
      SimpleType(s2);
      IF (s2 # SymTab.InvalidType)
       & (SymTab.ClassOf(s2) #
          SymTab.ClInt)
       & (SymTab.ClassOf(s2) #
          SymTab.ClChar)
       & (SymTab.ClassOf(s2) #
          SymTab.ClEnum) THEN
       SemError(224) END;;
    END;
    Expect(26);
    Type(e);
    t := SymTab.NewArray(e);;
  END ArrayType;

PROCEDURE SimpleType (VAR t: SymTab.TypeIndex);
  VAR t1, t2: SymTab.TypeIndex;
    lx1, lx2: MGen.LitStr;
    vD: BOOLEAN;
    vnD: SymTab.Name;
  BEGIN
    IF (sym = 1) THEN
      QualIdent(t);
      IF (sym = 22) THEN
        Get;
        MGen.NoEmitEnter;;
        ConstExpr(t1, lx1);
        IF (t1 # SymTab.InvalidType)
        & (SymTab.ClassOf(t1) #
           SymTab.ClInt)
        & (SymTab.ClassOf(t1) #
           SymTab.ClChar)
        & (SymTab.ClassOf(t1) #
           SymTab.ClEnum) THEN
        SemError(224) END;;
        Expect(23);
        ConstExpr(t2, lx2);
        IF (t2 # SymTab.InvalidType)
        & (SymTab.ClassOf(t2) #
           SymTab.ClInt)
        & (SymTab.ClassOf(t2) #
           SymTab.ClChar)
        & (SymTab.ClassOf(t2) #
           SymTab.ClEnum) THEN
        SemError(224) END;;
        Expect(24);
        t := SymTab.NewSub(t1);
        MGen.NoEmitExit;;
      END;
    ELSIF (sym = 22) THEN
      Get;
      MGen.NoEmitEnter;;
      ConstExpr(t1, lx1);
      IF (t1 # SymTab.InvalidType)
       & (SymTab.ClassOf(t1) #
          SymTab.ClInt)
       & (SymTab.ClassOf(t1) #
          SymTab.ClChar)
       & (SymTab.ClassOf(t1) #
          SymTab.ClEnum) THEN
       SemError(224) END;;
      Expect(23);
      ConstExpr(t2, lx2);
      IF (t2 # SymTab.InvalidType)
       & (SymTab.ClassOf(t2) #
          SymTab.ClInt)
       & (SymTab.ClassOf(t2) #
          SymTab.ClChar)
       & (SymTab.ClassOf(t2) #
          SymTab.ClEnum) THEN
       SemError(224) END;;
      Expect(24);
      t := SymTab.NewSub(t1);
      MGen.NoEmitExit;;
    ELSIF (sym = 19) THEN
      Enum(t);
    ELSE SynError(76);
    END;
  END SimpleType;

PROCEDURE FPSection;
  VAR isV: BOOLEAN;
    nn, i: CARDINAL;
    pn: ARRAY [0 .. 15] OF SymTab.Name;
    n: SymTab.Name;
    t: SymTab.TypeIndex;
  BEGIN
    isV := FALSE; nn := 0;;
    IF (sym = 15) THEN
      Get;
      isV := TRUE;;
    END;
    GetIdent(n);
    IF nn <= HIGH(pn) THEN
      MGen.CopyName(n, pn[nn])
    END;
    INC(nn);;
    WHILE (sym = 10) DO
      Get;
      GetIdent(n);
      IF nn <= HIGH(pn) THEN
        MGen.CopyName(n, pn[nn])
      END;
      INC(nn);;
    END;
    Expect(17);
    Type(t);
    i := 0;
    WHILE i < nn DO
      IF i <= HIGH(pn) THEN
        IF ~SymTab.EnterParam(
             pn[i], isV, t) THEN
          SemError(200)
        END
      END;
      INC(i)
    END;;
  END FPSection;

PROCEDURE QualIdent (VAR t: SymTab.TypeIndex);
  VAR n, m: SymTab.Name;
  BEGIN
    GetIdent(n);
    IF ~SymTab.Lookup(n) THEN
      SemError(201);
      t := SymTab.InvalidType
    ELSIF (SymTab.SymKind(n) #
           SymTab.KindType)
      & (SymTab.SymKind(n) #
         SymTab.KindPredef)
      & (SymTab.SymKind(n) #
         SymTab.KindImport) THEN
      SemError(221);
      t := SymTab.InvalidType
    ELSE t := SymTab.SymType(n) END;;
    WHILE (sym = 7) DO
      Get;
      GetIdent(m);
      t := SymTab.InvalidType;;
    END;
  END QualIdent;

PROCEDURE FormalParams;
  BEGIN
    FPSection;
    WHILE (sym = 6) DO
      Get;
      FPSection;
    END;
  END FormalParams;

PROCEDURE VarIdents;
  VAR n: SymTab.Name;
  BEGIN
    GetIdent(n);
    IF ~SymTab.EnterPending(n,
      SymTab.KindVar)
    THEN SemError(200) END;
    WHILE (sym = 10) DO
      Get;
      GetIdent(n);
      IF ~SymTab.EnterPending(n,
        SymTab.KindVar)
      THEN SemError(200) END;
    END;
  END VarIdents;

PROCEDURE Type (VAR t: SymTab.TypeIndex);
  BEGIN
    IF (sym = 1) OR (sym = 19) OR (sym = 22) THEN
      SimpleType(t);
    ELSIF (sym = 25) THEN
      ArrayType(t);
    ELSIF (sym = 27) THEN
      RecordType(t);
    ELSIF (sym = 28) THEN
      SetType(t);
    ELSIF (sym = 29) THEN
      PointerType(t);
    ELSE SynError(77);
    END;
  END Type;

PROCEDURE Expr (VAR t: SymTab.TypeIndex; VAR lx: MGen.LitStr;
                 VAR v: BOOLEAN; VAR vn: SymTab.Name);
  VAR t2: SymTab.TypeIndex;
    tc, op: INTEGER;
    lx2: MGen.LitStr;
    v2: BOOLEAN;
    vn2: SymTab.Name;
    r: BOOLEAN;
  BEGIN
    SimExpr(t, lx, v, vn);
    IF In(symSet[5], sym) THEN
      Rel(op);
      SimExpr(t2, lx2, v2, vn2);
      lx[0] := 0C; v := FALSE;
      IF op = SymTab.OpIn THEN
        IF SymTab.InCheck(t, t2) THEN
          t := SymTab.BoolType();
          MGen.BitIn
        ELSE SemError(222);
          t := SymTab.InvalidType;
          MGen.Drop; MGen.Drop; MGen.PushInt(0)
        END
      ELSE
        tc := SymTab.ClassOf(t);
        IF SymTab.RelCheck(t, t2, op) THEN
          t := SymTab.BoolType()
        ELSE SemError(213); t := SymTab.InvalidType END;
        IF t # SymTab.InvalidType THEN
          r := tc = SymTab.ClReal;
          IF r THEN
            IF op = SymTab.OpEq THEN MGen.RealEq
            ELSIF (op = SymTab.OpNeq1)
                  OR (op = SymTab.OpNeq2) THEN MGen.RealNe
            ELSIF op = SymTab.OpLt THEN MGen.RealLt
            ELSIF op = SymTab.OpLe THEN MGen.RealLe
            ELSIF op = SymTab.OpGt THEN MGen.RealGt
            ELSE MGen.RealGe END
          ELSE
            IF op = SymTab.OpEq THEN MGen.Eq
            ELSIF (op = SymTab.OpNeq1)
                  OR (op = SymTab.OpNeq2) THEN MGen.Neq
            ELSIF op = SymTab.OpLt THEN MGen.ILt
            ELSIF op = SymTab.OpLe THEN MGen.ILe
            ELSIF op = SymTab.OpGt THEN MGen.IGt
            ELSE MGen.IGe END
          END
        ELSE MGen.Drop; MGen.Drop; MGen.PushInt(0)
        END
      END;;
    END;
  END Expr;

PROCEDURE ConstExpr (VAR t: SymTab.TypeIndex; VAR lx: MGen.LitStr);
  VAR vD: BOOLEAN;
    vnD: SymTab.Name;
  BEGIN
    Expr(t, lx, vD, vnD);
  END ConstExpr;

PROCEDURE ProcedureDecl;
  VAR n, m: SymTab.Name;
    rt: SymTab.TypeIndex;
    hasR, ok: BOOLEAN;
    endL: INTEGER;
  BEGIN
    Expect(18);
    hasR := FALSE;;
    GetIdent(n);
    IF SymTab.IsForward(n) THEN
      SymTab.ReuseProc(n)
    ELSIF ~SymTab.EnterProc(n) THEN
      SemError(200)
    END;
    SymTab.OpenProcScope;
    endL := MGen.NewLabel();
    MGen.Jmp(endL);;
    IF (sym = 19) THEN
      Get;
      FormalParams;
      Expect(20);
    END;
    IF (sym = 17) THEN
      Get;
      QualIdent(rt);
      hasR := TRUE;;
    END;
    IF hasR THEN
      ok := SymTab.SetProcRet(rt)
    ELSE
      ok := SymTab.SetProcRet(
              SymTab.InvalidType)
    END;
    IF ~ok THEN SemError(231) END;
    IF ~SymTab.VerifyProc() THEN
      SemError(231)
    END;;
    Expect(6);
    IF In(symSet[6], sym) THEN
      Block(TRUE);
      GetIdent(m);
      IF ~SymTab.Equal(n, m) THEN
      SemError(202) END;
      MGen.DefLabel(endL);
      SymTab.CloseProc;;
    ELSIF (sym = 21) THEN
      Get;
      SymTab.SetForward;
        SymTab.CloseProc;
        MGen.DefLabel(endL);;
    ELSE SynError(78);
    END;
  END ProcedureDecl;

PROCEDURE VarDecl;
  VAR t: SymTab.TypeIndex;
    i: CARDINAL;
    nm: SymTab.Name;
    cls: INTEGER;
  BEGIN
    VarIdents;
    Expect(17);
    Type(t);
    cls := SymTab.ClassOf(t);
    IF (cls # SymTab.ClInt)
       & (cls # SymTab.ClReal)
       & (cls # SymTab.ClBool)
       & (cls # SymTab.ClChar)
       & (cls # SymTab.ClEnum)
       & (cls # SymTab.ClSet) THEN
      SemError(230)
    END;
    i := 0;
    WHILE i < SymTab.PendCount() DO
      SymTab.PendName(i, nm);
      IF SymTab.SymDepth(nm) = 0 THEN
        MGen.DeclVar(nm)
      END;
      INC(i)
    END;
    SymTab.FixPending(t);;
  END VarDecl;

PROCEDURE TypeDecl;
  VAR n: SymTab.Name;
    t0, t1: SymTab.TypeIndex;
  BEGIN
    GetIdent(n);
    IF ~SymTab.Enter(n, SymTab.KindType)
    THEN SemError(200) END;
    t0 := SymTab.NewAlias();
    SymTab.SetSymType(n, t0);;
    Expect(16);
    Type(t1);
    IF t1 = t0 THEN SemError(223);
      SymTab.SetTarget(t0,
        SymTab.InvalidType)
    ELSE SymTab.SetTarget(t0, t1) END;;
  END TypeDecl;

PROCEDURE ConstDecl;
  VAR n: SymTab.Name;
    t: SymTab.TypeIndex;
    lx: MGen.LitStr;
    cls: INTEGER;
  BEGIN
    GetIdent(n);
    IF ~SymTab.Enter(n, SymTab.KindConst)
    THEN SemError(200) END;
    Expect(16);
    MGen.NoEmitEnter;;
    ConstExpr(t, lx);
    SymTab.SetSymType(n, t);
    cls := SymTab.ClassOf(t);
    IF cls = SymTab.ClStr THEN
      SemError(230)
    ELSIF ~MGen.IsLit(lx) THEN
      SemError(230)
    END;
    MGen.DeclConst(n, lx, t);
    MGen.NoEmitExit;;
  END ConstDecl;

PROCEDURE StatSeq;
  BEGIN
    Stat;
    WHILE (sym = 6) DO
      Get;
      Stat;
    END;
  END StatSeq;

PROCEDURE Declaration;
  BEGIN
    IF (sym = 13) THEN
      Get;
      WHILE (sym = 1) DO
        ConstDecl;
        Expect(6);
      END;
    ELSIF (sym = 14) THEN
      Get;
      WHILE (sym = 1) DO
        TypeDecl;
        Expect(6);
      END;
    ELSIF (sym = 15) THEN
      Get;
      WHILE (sym = 1) DO
        VarDecl;
        Expect(6);
      END;
    ELSIF (sym = 18) THEN
      ProcedureDecl;
      Expect(6);
    ELSE SynError(79);
    END;
  END Declaration;

PROCEDURE ImportList;
  VAR n: SymTab.Name;
  BEGIN
    GetIdent(n);
    IF ~SymTab.Enter(n, SymTab.KindImport)
    THEN SemError(200) END;
    WHILE (sym = 10) DO
      Get;
      GetIdent(n);
      IF ~SymTab.Enter(n, SymTab.KindImport)
      THEN SemError(200) END;
    END;
  END ImportList;

PROCEDURE Block (isProc: BOOLEAN);
  VAR began: BOOLEAN;
  BEGIN
    began := FALSE;;
    WHILE (sym = 13) OR (sym = 14) OR (sym = 15) OR (sym = 18) DO
      Declaration;
    END;
    IF (sym = 11) THEN
      Get;
      began := TRUE;
      IF isProc THEN
        MGen.ProcEntry(
          SymTab.CurProc(),
          SymTab.ProcNLocals())
      ELSE MGen.BeginBody
      END;;
      StatSeq;
    END;
    Expect(12);
    IF isProc THEN
    IF ~began THEN
      MGen.ProcEntry(
        SymTab.CurProc(),
        SymTab.ProcNLocals())
    END;
    IF SymTab.InFunction() THEN
      MGen.PushInt(0)
    END;
    MGen.Leave(SymTab.CurNPar(),
      SymTab.InFunction())
    END;;
  END Block;

PROCEDURE Import;
  VAR n: SymTab.Name;
  BEGIN
    IF (sym = 8) THEN
      Get;
      GetIdent(n);
      IF ~SymTab.Enter(n, SymTab.KindImport)
      THEN SemError(200) END;
      Expect(9);
      ImportList;
      Expect(6);
    ELSIF (sym = 9) THEN
      Get;
      ImportList;
      Expect(6);
    ELSE SynError(80);
    END;
  END Import;

PROCEDURE GetIdent (VAR n: SymTab.Name);
  BEGIN
    Expect(1);
    LexName(n);;
  END GetIdent;

PROCEDURE M2c;
  VAR m1, m2: SymTab.Name;
  BEGIN
    Expect(5);
    GetIdent(m1);
    SymTab.Init; MGen.OpenModule(m1);
    IF ~SymTab.Enter(m1, SymTab.KindModule)
    THEN SemError(200) END;
    Expect(6);
    WHILE (sym = 8) OR (sym = 9) DO
      Import;
    END;
    Block(FALSE);
    GetIdent(m2);
    IF ~SymTab.Equal(m1, m2)
    THEN SemError(202) END;
    Expect(7);
    IF SymTab.AnyForward() THEN
    SemError(231)
    END;
    MGen.EndModule;
    SymTab.PrintTable;;
  END M2c;



PROCEDURE Parse;
  BEGIN
    M2cS.Reset; Get;
    M2c;

  END Parse;

BEGIN
  errDist := minErrDist;
  symSet[ 0, 0] := BITSET{0};
  symSet[ 0, 1] := BITSET{};
  symSet[ 0, 2] := BITSET{};
  symSet[ 0, 3] := BITSET{};
  symSet[ 0, 4] := BITSET{};
  symSet[ 1, 0] := BITSET{1, 2, 3, 4};
  symSet[ 1, 1] := BITSET{3};
  symSet[ 1, 2] := BITSET{14};
  symSet[ 1, 3] := BITSET{9};
  symSet[ 1, 4] := BITSET{1, 2, 3};
  symSet[ 2, 0] := BITSET{};
  symSet[ 2, 1] := BITSET{};
  symSet[ 2, 2] := BITSET{};
  symSet[ 2, 3] := BITSET{11, 12, 13, 14, 15};
  symSet[ 2, 4] := BITSET{0};
  symSet[ 3, 0] := BITSET{6, 12};
  symSet[ 3, 1] := BITSET{};
  symSet[ 3, 2] := BITSET{3, 4, 6, 10};
  symSet[ 3, 3] := BITSET{};
  symSet[ 3, 4] := BITSET{};
  symSet[ 4, 0] := BITSET{1};
  symSet[ 4, 1] := BITSET{15};
  symSet[ 4, 2] := BITSET{1, 5, 7, 9, 11, 12, 15};
  symSet[ 4, 3] := BITSET{0};
  symSet[ 4, 4] := BITSET{};
  symSet[ 5, 0] := BITSET{};
  symSet[ 5, 1] := BITSET{0};
  symSet[ 5, 2] := BITSET{};
  symSet[ 5, 3] := BITSET{2, 3, 4, 5, 6, 7, 8};
  symSet[ 5, 4] := BITSET{};
  symSet[ 6, 0] := BITSET{11, 12, 13, 14, 15};
  symSet[ 6, 1] := BITSET{2};
  symSet[ 6, 2] := BITSET{};
  symSet[ 6, 3] := BITSET{};
  symSet[ 6, 4] := BITSET{};
END M2cP.