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

(* File: Stmt.m3                                               *)
(* Last modified on Sat Feb 10 20:32:47 1990 by kalsow         *)
(*      modified on Tue Jan 16 06:44:48 1990 by muller         *)


MODULE Stmt EXPORTS Stmt, StmtRep;

IMPORT AssertStmt;
IMPORT AssignStmt, BlockStmt, CallStmt, CaseStmt, ExitStmt, ForStmt;
IMPORT IfStmt, LockStmt, LoopStmt, RepeatStmt, ReturnStmt, EvalStmt;
IMPORT TryFinStmt, TryStmt, TypeCaseStmt, WhileStmt, WithStmt;
IMPORT Scope, Scanner, RaiseStmt, Temp, Token, Coverage;
FROM Scanner IMPORT GetToken, cur;

PROCEDURE Parse (READONLY fail: Token.Set): T =
  TYPE TK = Token.T;
  VAR fail2: Token.Set;  t, first, last: T;
  BEGIN
    fail2 := fail + Token.Set{TK.tSEMI};
    first := NIL;  last := NIL;
    LOOP
      CASE cur.token OF
      | TK.tCONST,
        TK.tTYPE,
        TK.tVAR,
        TK.tEXCEPTION,
        TK.tINLINE,
        TK.tPROCEDURE,
        TK.tBEGIN    => t := BlockStmt.Parse (fail2);
      | TK.tIDENT,
        TK.tLPAREN,
        TK.tARRAY,
        TK.tRECORD   => t := AssignStmt.Parse (fail2);
      | TK.tCASE     => t := CaseStmt.Parse (fail2);
      | TK.tEXIT     => t := ExitStmt.Parse (fail2);
      | TK.tEVAL     => t := EvalStmt.Parse (fail2);
      | TK.tASSERT   => t := AssertStmt.Parse (fail2);
      | TK.tFOR      => t := ForStmt.Parse (fail2);
      | TK.tIF       => t := IfStmt.Parse (fail2);
      | TK.tLOCK     => t := LockStmt.Parse (fail2);
      | TK.tLOOP     => t := LoopStmt.Parse (fail2);
      | TK.tRAISE    => t := RaiseStmt.Parse (fail2);
      | TK.tREPEAT   => t := RepeatStmt.Parse (fail2);
      | TK.tRETURN   => t := ReturnStmt.Parse (fail2);
      | TK.tTRY      => t := TryStmt.Parse (fail2);
      | TK.tTYPECASE => t := TypeCaseStmt.Parse (fail2);
      | TK.tWHILE    => t := WhileStmt.Parse (fail2);
      | TK.tWITH     => t := WithStmt.Parse (fail2);
      ELSE RETURN first;
      END;
      IF (first = NIL) THEN first := t ELSE last.next := t END;
      last := t;
      IF (cur.token # TK.tSEMI) THEN RETURN first END;
      GetToken (); (* ; *)
    END;
    RETURN first;
  END Parse;

PROCEDURE Init (t: T) =
  BEGIN
    t.next   := NIL;
    t.origin := Scanner.offset;
  END Init;

PROCEDURE Bind (t: T) =
  BEGIN
    WHILE (t # NIL) DO
      Scanner.offset := t.origin;
      Coverage.NoteLine ();
      t.bind ();
      t := t.next;
    END;
  END Bind;

PROCEDURE TypeCheck (t: T) =
  BEGIN
    WHILE (t # NIL) DO
      Scanner.offset := t.origin;
      t.check ();
      t := t.next;
    END;
  END TypeCheck;

PROCEDURE Precompile (t: T) =
  BEGIN
    WHILE (t # NIL) DO
      Scanner.offset := t.origin;
      t.precompile ();
      t := t.next;
    END;
  END Precompile;

PROCEDURE Compile (t: T): Outcomes =
  VAR oc, xc: Outcomes;
  BEGIN
    oc := Outcomes {Outcome.FallThrough};
    WHILE (t # NIL) DO
      Scanner.offset := t.origin;
      Coverage.CountLine ();
      Temp.KillValues ();
      xc := t.compile ();
      oc := oc + xc;
      Temp.AssertAllFree ();
      IF (Outcome.FallThrough IN xc)
        THEN t := t.next;
	ELSE t := NIL;  oc := oc - Outcomes {Outcome.FallThrough};
      END;
    END;
    Temp.KillValues ();
    RETURN oc;
  END Compile;

(******************************************************************)

PROCEDURE Initialize () =
  BEGIN
  END Initialize;

BEGIN
END Stmt.