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

(* File: NamedExpr.m3                                          *)
(* Last modified on Fri Apr 27 07:43:09 1990 by muller         *)
(*      modified on Sat Feb 10 17:40:18 1990 by kalsow         *)



MODULE NamedExpr;

IMPORT Expr, ExprRep, Value, ValueRep, String;
IMPORT Type, Variable, VarExpr, ProcExpr;
IMPORT TypeExpr, Temp, Wr, Scope, Int, Error;

TYPE
  P = Expr.T BRANDED "Named Expr" OBJECT
        name  : String.T;
	value : Value.T;
      METHODS
        bind         := Bind;
        check        := Check;
        compile      := Compile;
        evaluate     := Fold;
        fprint       := FPrinter;
        write        := ExprRep.NoWriter;
        isEqual      := EqCheck;
        getBounds    := Bounder;
        isWritable   := IsWritable;
        isDesignator := IsDesignator;
	isZeroes     := IsZeroes;
	genLiteral   := ExprRep.NoLiteral;
      END;

PROCEDURE New (name: String.T): Expr.T =
  VAR p := NEW (P);
  BEGIN
    ExprRep.Init (p);
    p.name  := name;
    p.value := NIL;
    RETURN p;
  END New;

PROCEDURE FromValue (value: Value.T): Expr.T =
  VAR p := NEW (P);
  BEGIN
    ExprRep.Init (p);
    p.name  := value.name;
    p.value := value;
    RETURN p;
  END FromValue;

PROCEDURE Split (e: Expr.T;  VAR name: String.T;  VAR obj: Value.T): BOOLEAN =
  BEGIN
    TYPECASE e OF
    | NULL => RETURN FALSE;
    | P(p) => name := p.name;  obj := p.value;  RETURN TRUE;
    ELSE      RETURN FALSE;
    END;
  END Split;

PROCEDURE Bind (p: P) =
  BEGIN
    IF (p.value = NIL) THEN
      p.value := Scope.LookUp (p.name);
      IF (p.value = NIL) THEN
        Error.Str (p.name, "undefined");
        p.value := VarExpr.Obj (VarExpr.New (Int.T, p.name));
      END;
    END;
    Value.Bind (p.value);
    p.type := Value.TypeOf (p.value);
  END Bind;

PROCEDURE Check (p: P) =
  BEGIN
    Value.TypeCheck (p.value);
  END Check;

PROCEDURE EqCheck (a: P;  e: Expr.T): BOOLEAN =
  BEGIN
    TYPECASE e OF
    | NULL => RETURN FALSE;
    | P(b) => RETURN (a.value = b.value);
    ELSE      RETURN FALSE;
    END;
  END EqCheck;

PROCEDURE Compile (p: P): Temp.T =
  BEGIN
    RETURN Value.Load (p.value);
  END Compile;

PROCEDURE Bounder (p: P;  VAR min, max: INTEGER) =
  BEGIN
    CASE Value.ClassOf (p.value) OF
    | Value.Class.Expr => Expr.GetBounds (Value.ToExpr (p.value), min, max);
    | Value.Class.Var  => Variable.GetBounds (p.value, min, max);
    ELSE                  Type.GetBounds (p.type, min, max);
    END;
  END Bounder;

PROCEDURE Fold (p: P): Expr.T =
  BEGIN
    CASE Value.ClassOf (p.value) OF
    | Value.Class.Expr      => RETURN Expr.ConstValue (Value.ToExpr (p.value));
    | Value.Class.Procedure => RETURN ProcExpr.New (p.value);
    | Value.Class.Type      => RETURN TypeExpr.New (Value.ToType (p.value));
    ELSE                       RETURN NIL;
    END;
  END Fold;

PROCEDURE IsDesignator (p: P): BOOLEAN =
  BEGIN
    RETURN (Value.ClassOf (p.value) = Value.Class.Var);
  END IsDesignator;

PROCEDURE IsWritable (p: P): BOOLEAN =
  BEGIN
    RETURN NOT p.value.readonly;
  END IsWritable;

PROCEDURE IsZeroes (p: P): BOOLEAN =
  BEGIN
    RETURN Expr.IsZeroes (Value.ToExpr (p.value));
  END IsZeroes;

PROCEDURE FPrinter (p: P;  map: Type.Map;  wr: Wr.T) =
  BEGIN
    Value.Fingerprint (p.value, map, wr);
  END FPrinter;

BEGIN
END NamedExpr.