(* tree-il.sml
 *
 * COPYRIGHT (c) 2011 The Diderot Project (http://diderot-language.cs.uchicago.edu)
 * All rights reserved.
 *
 * This representation restores the block structure and nested expression syntax
 * of the source language.
 *)

structure TreeIL =
  struct

    structure Op = LowOps
    structure Ty = LowILTypes

    datatype program = Program of {
	props : StrandUtil.program_prop list,
	globals : var list,
	inputInit : block,
	globalInit : block,
	strands : strand list,
	initially : {
	    isArray : bool,
	    iterPrefix : block,
	    iters : (var * exp * exp) list,
	    createPrefix : block,
	    strand : Atom.atom,
	    args : exp list
	  }
      }

    and strand = Strand of {
	name : Atom.atom,
	params : var list,
	state : state_var list,
	stateInit : block,
	methods : method list
      }

    and state_var = SV of {
	name : string,          (* name (should be unique) *)
	id : Stamp.stamp,       (* unique ID *)
	ty : Ty.ty,             (* type *)
	varying : bool,		(* varies over the lifetime of the strand *)
	output : bool		(* is the output value of the strand *)
      }

    and method = Method of {
	name : StrandUtil.method_name,
	body : block		(* method body *)
      }

    and block = Block of {
	locals : var list,
	body : stm list
      }

    and stm
      = S_Comment of string list
      | S_Assign of var list * exp
      | S_IfThen of exp * block
      | S_IfThenElse of exp * block * block
    (* special Diderot forms *)
(* DEPRECATED
      | S_LoadImage of var * int * exp	(* load image data *)
*)
      | S_Input of var * string * string option * exp option (* get input *)
      | S_InputNrrd of var * string * string option * string option (* get image/seq input *)
      | S_New of Atom.atom * exp list	(* new strand creation *)
      | S_Save of state_var list * exp  (* save strand state *)
      | S_Exit of exp list
    (* return functions for methods *)
      | S_Active
      | S_Stabilize
      | S_Die

    and exp
      = E_State of state_var
      | E_Var of var
      | E_Lit of Literal.literal
      | E_Op of Op.rator * exp list
      | E_Apply of MathFuns.name * exp list
      | E_Cons of Ty.ty * exp list

    and var = V of {
	name : string,			(* name (should be unique) *)
	id : Stamp.stamp,		(* unique ID *)
	kind : var_kind,
	ty : Ty.ty			(* type *)
      }

    and var_kind
      = VK_Input			(* global input variable *)
      | VK_Global			(* global variable *)
      | VK_Local			(* includes strand parameters *)

    structure Var : sig

	val kind : var -> var_kind
	val name : var -> string
	val toString : var -> string
	val ty : var -> Ty.ty

	structure Map : ORD_MAP where type Key.ord_key = var

      end = struct
	fun kind (V{kind, ...}) = kind
	fun name (V{name, ...}) = name
	fun toString (V{name, id, ...}) = concat[name, "$", Stamp.toString id]
	fun ty (V{ty, ...}) = ty
	local
	  structure VarOrd =
	    struct
	      type ord_key = var
	      fun compare (V{id=a, ...}, V{id=b, ...}) = Stamp.compare(a, b)
	    end
	in
	structure Map = RedBlackMapFn (VarOrd)
	end (* local *)
      end

    structure StateVar : sig
        val name : state_var -> string
        val ty : state_var -> Ty.ty
        val isOutput : state_var -> bool
        val isVarying : state_var -> bool
        val toString : state_var -> string
      end = struct
	fun name (SV{name, ...}) = name
	fun ty (SV{ty, ...}) = ty
	fun isOutput (SV{output, ...}) = output
	fun isVarying (SV{varying, ...}) = varying
	fun toString (SV{name, ...}) = "self." ^ name
      end

    fun kindToString k = (case k
	   of VK_Input => "Input"
	    | VK_Global => "Global"
	    | VK_Local => "Local"
	  (* end case *))

    fun stateVarToString (SV{name, ...}) = "self." ^ name

  end