(* Copyright (C) 1989, Digital Equipment Corporation           *)
(* All rights reserved.                                        *)
(* See the file COPYRIGHT for a full description.              *)

(* File: AssertStmt.m3                                         *)
(* Last modified on Fri Apr 20 06:43:01 1990 by muller         *)
(*      modified on Mon Feb 12 09:42:49 1990 by kalsow         *)


MODULE AssertStmt;

IMPORT Expr, Token, Scanner, Stmt, StmtRep, Error, Temp, Void, Type, Bool;
IMPORT Emit, PackedType, Host, EnumExpr;

TYPE
  P = Stmt.T OBJECT
        e          : Expr.T;
      METHODS
	bind       := Bind;
        check      := Check;
	precompile := Precompile;
	compile    := Compile;
      END;

PROCEDURE Parse (READONLY fail: Token.Set): Stmt.T =
  VAR p: P;
  BEGIN
    (** Error.WarnNonStandard ("<*ASSERT*> pragma"); **)
    p := NEW (P);
    StmtRep.Init (p);
    Scanner.Match (Token.T.tASSERT, fail, Token.ExprStart);
    p.e := Expr.Parse (fail);
    IF (Scanner.cur.token # Token.T.tENDPRAGMA) THEN
      Scanner.Fail ("missing \'*>\'", fail + Token.Set {Token.T.tENDPRAGMA});
    END;
    Scanner.cur.token := Token.T.tSEMI;  (* for the statement parser *)
    RETURN p;
  END Parse;

PROCEDURE Bind (p: P) =
  BEGIN
    Expr.Bind (p.e);
  END Bind;

PROCEDURE Check (p: P) =
  BEGIN
    Expr.TypeCheck (p.e);
    IF NOT Type.IsEqual (PackedType.Strip (Expr.TypeOf (p.e)), Bool.T) THEN
      Error.Msg ("you can only ASSERT boolean expressions");
    END;
  END Check;

PROCEDURE Precompile (<*UNUSED*> p: P) =
  BEGIN
  END Precompile;

PROCEDURE Compile (p: P): Stmt.Outcomes =
  VAR t: Temp.T;  v: Expr.T;  i: INTEGER;  u: Type.T;
  BEGIN
    IF Host.asserts THEN
      t := Expr.Compile (p.e);
      Emit.OpT ("if (!@) ASSERTFAULT;\n", t);
      Temp.Free (t); 
      v := Expr.ConstValue (p.e);
      IF v # NIL AND EnumExpr.Split (v, i, u) AND i = 0 THEN
        RETURN Stmt.Outcomes {};
      END;
    END;
    RETURN Stmt.Outcomes {Stmt.Outcome.FallThrough};
  END Compile;

BEGIN
END AssertStmt.