Home My Page Projects Code Snippets Project Openings diderot
Summary Activity Tracker Tasks SCM

SCM Repository

[diderot] Diff of /trunk/src/compiler/codegen/target-sig.sml
ViewVC logotype

Diff of /trunk/src/compiler/codegen/target-sig.sml

Parent Directory Parent Directory | Revision Log Revision Log | View Patch Patch

revision 1115, Thu May 5 04:42:18 2011 UTC revision 1116, Thu May 5 04:49:02 2011 UTC
# Line 11  Line 11 
11    
12      type program      type program
13      type strand      type strand
14        type var
15      type exp      type exp
     type cond  
16      type stm      type stm
     type method  
17    
18      val defineStrand : program * ?? -> strand    (* environment for mapping from TreeIL variables to target variables.  It is also used to
19      val globalVar : program * ?? -> global_var     * track the translation context (e.g., global initialization vs. strand initialization, etc.
20      val stateVar : strand * ?? -> state_var     *)
21        type env
22    (* expression construction *)  
23      structure Expr : sig    (* the supprted widths of vectors of reals on the target.  This value takes into
24        (* variable references *)     * account the actual size of reals (i.e., 32 or 64 bits).
25          val global : global_var -> exp     *)
26          val getState : state_var -> exp      val vectorWidths : unit -> int list
27          val param : param_var -> exp  
28          val var : local_var -> exp    (* tests for whether various expression forms can appear inline *)
29        (* literals *)      val inlineCons : int -> bool        (* can n'th-order tensor construction appear inline *)
30          val intLit : IntegerLit.integer -> exp      val inlineMatrixExp : bool          (* can matrix-valued expressions appear inline? *)
31          val floatLit : FloatLit.float -> exp  
32          val stringLit : string -> exp    (* TreeIL to target translations *)
33          val boolLit : bool -> exp      structure Tr : sig
34        (* vector construction *)          val block : env * TreeIL.block -> stm
35          val vector : exp list -> exp          val exp : env * TreeIL.exp -> exp
36        (* select from a vector *)        end
37          val select : int * vector -> exp  
38        (* vector (and scalar) arithmetic *)    (* variables *)
39          val add : exp * exp -> exp      structure Var : sig
40          val mul : exp * exp -> exp          val name : var -> string
41          val sub : exp * exp -> exp          val global : program * string * TreeIL.Ty.ty -> var (* global variables *)
42          val divide : exp * exp -> exp          val param : TreeIL.var -> var                   (* strand parameters *)
43          val neg : exp -> exp          val state : strand * TreeIL.var -> var          (* strand state variables *)
44          val abs : exp -> exp        end
45          val dot : exp * exprr -> exp            (* dot product *)  
46          val cross : exp * exp -> exp            (* cross product *)    (* environments *)
47          val length : exp -> exp                 (* vector length *)      structure Env : sig
48          val normalize : exp -> exp              (* normalize vector *)        (* create a new environment *)
49        (* comparisons *)          val new : program -> env
50          val min : exp * exp -> exp        (* define the current translation context *)
51          val max : exp * exp -> exp          val scopeGlobal : env -> env                    (* global initialization *)
52        (* math functions *)          val scopeInitially : env -> env                 (* initial strand creation *)
53          val pow : exp * exp -> exp          val scopeStrand : env * TreeIL.var list -> env  (* strand initialization *)
54          val sin : exp -> exp          val scopeMethod : env * TreeIL.var list -> env  (* method body *)
55          val cos : exp -> exp        (* bind a TreeIL variable to a target variable *)
56          val sqrt : exp -> exp          val bind : env * TreeIL.var * var -> env
57        (* conversions *)        end
58          val toReal : exp -> exp                 (* integer to real *)  
59          val roundToInt : exp -> exp             (* round real to int *)    (* programs *)
60          val truncToInt : exp -> exp             (* truncate real to inte *)      structure Program : sig
61          val ceilToInt : exp -> exp              (* ceiling of real to int *)          val new : unit -> program
62          val floorToInt : exp -> exp             (* floor of real to int *)          val init : program * stm -> unit        (* global initialization *)
63        end        (* register the initially code for a program *)
64            val initially : {
65    (* conditionals *)                  prog : program,
66      structure Cond : sig                  isArray : bool,
67        (* comparisons *)                  iterPrefix : stm,
68          val lt : exp * exp -> cond                  iters : (var * exp * exp) list,
69          val lte : exp * exp -> cond                  createPrefix : stm,
70          val equ : exp * exp -> cond                  strand : Atom.atom,
71          val neq : exp * exp -> cond                  args : exp list
72          val gte : exp * exp -> cond                } -> unit
73          val gt : exp * exp -> cond        (* output the code to a file.  The string is the basename of the file, the extension
74        (* logical connectives *)         * is provided by the target.
75          val not : cond -> cond         *)
76          val && : cond * cond -> cond          val generate : string * program -> unit
77          val || : cond * cond -> cond        end
78        end  
79      (* strands *)
80    (* statement construction *)      structure Strand : sig
81      structure Stmt : sig        (* define a strand with the given name *)
82          val assignState : state_var * exp -> stm          val define : program * Atom.atom -> strand
83          val assign : local_var * exp -> stm        (* return the strand with the given name *)
84          val block : stm list -> stm          val lookup : program * Atom.atom -> strand
85          val ifthen : cond * stm -> stm        (* register the strand-state initialization code.  The variables are the strand
86          val ifthenelse : cond * stm * stm -> stm         * parameters.
87           *)
88            val init : strand * var list * stm -> unit
89          (* register a strand method *)
90            val method : strand * string * stm -> unit
91          (* register the strand's output *)
92            val output : strand * TreeIL.Ty.ty * var -> unit
93        end        end
94    
95    end    end

Legend:
Removed from v.1115  
changed lines
  Added in v.1116

root@smlnj-gforge.cs.uchicago.edu
ViewVC Help
Powered by ViewVC 1.0.0