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

SCM Repository

[diderot] Diff of /trunk/src/compiler/IL/check-il-fn.sml
ViewVC logotype

Diff of /trunk/src/compiler/IL/check-il-fn.sml

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

revision 511, Tue Feb 8 17:01:43 2011 UTC revision 1116, Thu May 5 04:49:02 2011 UTC
# Line 17  Line 17 
17    (* returns the signature of an operator as (rng, dom). *)    (* returns the signature of an operator as (rng, dom). *)
18      val sigOf : rator -> ty * ty list      val sigOf : rator -> ty * ty list
19    
20    (* return the type of a CONS, where the argument types    (* return the type of a CONS, where the first argument is the annotated type
21     * are given.  Returns NONE if the argument types are     * and the second argument is the list of argument types.  Returns false if
22     * invalid for the IL.     * there is a type error.
23     *)     *)
24      val typeOfCons : ty list -> ty option      val typeOfCons : ty * ty list -> bool
25    
26    end    end
27    
# Line 58  Line 58 
58    
59          fun join inputs = List.foldl VSet.union bottom inputs          fun join inputs = List.foldl VSet.union bottom inputs
60    
61          fun transfer (input, IL.ND{kind, ...}) = (case kind          fun transfer (input, nd as IL.ND{kind, ...}) = (case kind
62                 of IL.NULL => raise Fail "unexpected NULL"                 of IL.NULL => raise Fail("unexpected " ^ IL.Node.toString nd)
63                  | IL.JOIN{phis, ...} => let                  | IL.JOIN{phis, ...} => let
64                    (* add the lhs of the phi node, while removing the rhs variables *)                    (* add the lhs of the phi node, while removing the rhs variables *)
65                      fun doPhi ((y, xs), vs) =                      fun doPhi ((y, xs), vs) =
# Line 69  Line 69 
69                      in                      in
70                        List.foldl doPhi input (!phis)                        List.foldl doPhi input (!phis)
71                      end                      end
72                  | IL.BLOCK{body, ...} => let                  | IL.ASSIGN{stm=(y, _), ...} => VSet.add(input, y)
                     fun doAssign ((y, _), vs) = VSet.add(vs, y)  
                     in  
                       List.foldl doAssign input (!body)  
                     end  
73                  | _ => input                  | _ => input
74                 (* end case *))                 (* end case *))
75    
# Line 161  Line 157 
157                              NL, S "found:    ", VTYS xs                              NL, S "found:    ", VTYS xs
158                            ]                            ]
159                      end                      end
160                  | IL.CONS xs => (                  | IL.APPLY(name, xs) => () (* FIXME: need functor parameter for typing name *)
161                    | IL.CONS(ty, xs) => (
162                      List.app checkVar xs;                      List.app checkVar xs;
163                      case OpTy.typeOfCons (List.map V.ty xs)                      if OpTy.typeOfCons (ty, List.map V.ty xs)
164                       of NONE => errFn [S "invalid ", S(IL.assignToString(y, rhs))]                        then if Ty.same(V.ty y, ty)
                       | SOME ty => if Ty.same(V.ty y, ty)  
165                            then ()                            then ()
166                            else tyError (V.ty y, ty)                            else tyError (V.ty y, ty)
167                          else errFn [S "invalid ", S(IL.assignToString(y, rhs))]
168                      (* end case *))                      (* end case *))
169                (* end case *);                (* end case *);
170                VSet.add(bvs, y)                VSet.add(bvs, y)
# Line 192  Line 189 
189                  ]                  ]
190            end            end
191    
192      fun check (phase, IL.Program{globals, globalInit, strands}) = let      fun check (phase, IL.Program{globalInit, initially, strands}) = let
193            val errBuf = ref []            val errBuf = ref []
194            val errFn = error errBuf            val errFn = error errBuf
195            fun final () = (case !errBuf            fun final () = (case !errBuf
# Line 204  Line 201 
201                  (* end case *))                  (* end case *))
202            val checkPhi = checkPhi errFn            val checkPhi = checkPhi errFn
203            val checkAssign = checkAssign errFn            val checkAssign = checkAssign errFn
204            fun checkStmt (vs, stm) = let            fun checkCFG (vs, cfg) = let
205                  val bvs = VSet.fromList vs                  val bvs = VSet.fromList vs
206                (* compute the variables available on entry to each block *)                (* compute the variables available on entry to each block *)
207                  val nodes = Avail.analyse (bvs, stm)                  val nodes = Avail.analyse (bvs, cfg)
208                  fun checkNd (nd as IL.ND{kind, ...}) = (case kind                  fun checkNd (nd as IL.ND{kind, ...}) = (case kind
209                         of IL.NULL => raise Fail "unexpected NULL"                         of IL.NULL => raise Fail "unexpected NULL"
210                          | IL.JOIN{phis, ...} =>                          | IL.JOIN{phis, ...} =>
# Line 217  Line 214 
214                              orelse VSet.member(bvs, cond)                              orelse VSet.member(bvs, cond)
215                                then ()                                then ()
216                                else errFn [S "unbound variable ", V cond, S " in conditional"]                                else errFn [S "unbound variable ", V cond, S " in conditional"]
217                          | IL.BLOCK{body, ...} =>                          | IL.ASSIGN{stm, ...} =>
218                              ignore (List.foldl checkAssign (VSet.union(Avail.inValue nd, bvs)) (!body))                              ignore (checkAssign (stm, VSet.union(Avail.inValue nd, bvs)))
219                          | IL.NEW{strand, args, ...} => let                          | IL.NEW{strand, args, ...} => let
220                              val bvs = VSet.union(Avail.inValue nd, bvs)                              val bvs = VSet.union(Avail.inValue nd, bvs)
221                            (* check a variable use *)                            (* check a variable use *)
# Line 238  Line 235 
235                  (* cleanup *)                  (* cleanup *)
236                    Avail.scrub nodes                    Avail.scrub nodes
237                  end                  end
238          (* check an strand definition *)          (* the globals are those variables that are live at the exit of the global initialization *)
239              val globals = IL.CFG.liveAtExit globalInit
240            (* check a strand definition *)
241            fun checkStrand (IL.Strand{params, state, stateInit, methods, ...}) = let            fun checkStrand (IL.Strand{params, state, stateInit, methods, ...}) = let
242                    val extraVars = params @ globals
243                  fun checkMethod (IL.Method{stateIn, body, ...}) =                  fun checkMethod (IL.Method{stateIn, body, ...}) =
244                        checkStmt (globals@stateIn, body)                        checkCFG (extraVars@stateIn, body)
245                  in                  in
246                    checkStmt (globals@params, stateInit);                    checkCFG (extraVars, stateInit);
247                    List.app checkMethod methods                    List.app checkMethod methods
248                  end                  end
249            in            in
250            (* check the global part *)            (* check the global part *)
251              checkStmt ([], globalInit);              checkCFG ([], globalInit);
252    (* FIXME: need to check initially *)
253            (* check the strands *)            (* check the strands *)
254              List.app checkStrand strands;              List.app checkStrand strands;
255            (* check for errors *)            (* check for errors *)

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

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