Made functions reference the same label

vasilescur · Apr 10, 2020 · f6e18da · f6e18da
1 parent d882ef7
commit f6e18da
Show file tree

Hide file tree

Showing 12 changed files with 19 additions and 15 deletions.
diff --git a/.cm/amd64-unix/main.sml b/.cm/amd64-unix/main.sml
diff --git a/IR/.cm/amd64-unix/translate.sig b/IR/.cm/amd64-unix/translate.sig
diff --git a/IR/.cm/amd64-unix/translate.sml b/IR/.cm/amd64-unix/translate.sml
diff --git a/IR/translate.sig b/IR/translate.sig
@@ -34,7 +34,7 @@ sig
   val letIR : exp list * exp -> exp
 
 
-  val procedureEntryExit : level * exp -> unit
+  val procedureEntryExit : level * exp * Temp.label -> unit
 
   val result : unit -> frag list
 

diff --git a/IR/translate.sml b/IR/translate.sml
@@ -218,11 +218,11 @@ struct
 
   fun newVar () = Ex (T.TEMP (Temp.newtemp ()))
 
-  fun procedureEntryExit (level', body') =
+  fun procedureEntryExit (level', body', label) =
     let val levelFrame =  (* Determine the level *)
           case level' of 
               TOPLEVEL => (Err.error 0 "Illegal function declaration in outermost level";
-                           F.nextFrame ({name = Temp.newlabel(), formals = []}))
+                           F.nextFrame ({name = label, formals = []}))
             | NONTOP ({unique = _, parent = _, frame = frame'}) => frame'
         val trBody = unNx body'
     in  (* Append to frag list *)

diff --git a/semant/.cm/amd64-unix/env.sig b/semant/.cm/amd64-unix/env.sig
diff --git a/semant/.cm/amd64-unix/env.sml b/semant/.cm/amd64-unix/env.sml
diff --git a/semant/.cm/amd64-unix/semant.sml b/semant/.cm/amd64-unix/semant.sml
diff --git a/semant/env.sig b/semant/env.sig
@@ -10,7 +10,7 @@ sig
     | FunEntry of {level: level,
                     label: Temp.label,
                     formals: ty list, 
-                    result : ty}
+                    result : ty ref}
 
   val base_tenv : ty Symbol.table (* predefined types*)
   val base_venv : enventry Symbol.table (* predefined functions*)

diff --git a/semant/env.sml b/semant/env.sml
@@ -9,7 +9,7 @@ struct
                     | FunEntry of {level: level,
                                    label: Temp.label,
                                    formals: ty list, 
-                                   result: ty}
+                                   result: ty ref}
 
   (* Base type environment -- built in types "int" and "string" *)
   val base_tenv = Symbol.enter (

diff --git a/semant/semant.sml b/semant/semant.sml
@@ -136,18 +136,19 @@ struct
                             end
                       val formals = List.foldl paramToFormal [] params
                       val newLabel = Temp.newlabel ()
+                      val _ = err pos ("Added function signature with label " ^ S.name (newLabel))
                   in case result of 
-                      NONE => S.enter(venv, name, E.FunEntry {level=R.nextLevel (level, newLabel, paramsToEscapes (params, [])), label=newLabel, formals=formals, result=T.BOTTOM})
+                      NONE => S.enter(venv, name, E.FunEntry {level=R.nextLevel (level, newLabel, paramsToEscapes (params, [])), label=newLabel, formals=formals, result=ref T.BOTTOM})
                     | SOME (resultVal, resultPos) => 
                               let val resultTy = S.look (tenv, resultVal)
                               in case resultTy of
                                   NONE => 
                                         (err resultPos "Unrecognized type"; 
                                          S.enter (venv, name,
-                                                  E.FunEntry {level=R.nextLevel (level, newLabel, paramsToEscapes (params, [])), label=newLabel, formals=formals, result=T.BOTTOM}))
+                                                  E.FunEntry {level=R.nextLevel (level, newLabel, paramsToEscapes (params, [])), label=newLabel, formals=formals, result=ref T.BOTTOM}))
                                 | SOME(resultTyVal) => 
                                         S.enter(venv, name, 
-                                                E.FunEntry {level=R.nextLevel (level, newLabel, paramsToEscapes (params, [])), label=newLabel, formals=formals, result=resultTyVal})
+                                                E.FunEntry {level=R.nextLevel (level, newLabel, paramsToEscapes (params, [])), label=newLabel, formals=formals, result=ref resultTyVal})
 
                               end
                   end
@@ -167,11 +168,13 @@ struct
                       val formals = List.foldl paramToFormal [] params
                       val newVenv = #venv (List.foldl addParam {tenv=tenv, venv=venv} params)
                       val bodyExpty = transExp (level, breakLabel, newVenv, tenv) body
-                      val newLabel = Temp.newlabel ()
-                      val nextLevel = R.nextLevel (level, newLabel, paramsToEscapes (params, []))
-                      val _ = R.procedureEntryExit (nextLevel, #exp bodyExpty)
+                      val newVenv = case S.look (venv, name) of 
+                                NONE => venv
+                              | SOME(E.FunEntry {level, label, formals, result}) => (R.procedureEntryExit (level, #exp bodyExpty, label); 
+                                                                                     result := (#ty bodyExpty); 
+                                                                                     venv)
                   in case result of 
-                      NONE => {tenv=tenv, venv= S.enter (venv, name, E.FunEntry {level=nextLevel, label=newLabel, formals=formals, result= #ty bodyExpty})}
+                      NONE => {tenv=tenv, venv=newVenv}
                     | SOME (resultSym, resultPos) => (checkTypesEq (#ty bodyExpty, findType (resultSym, tenv), resultPos, "Function return type does not match body type check"); {tenv=tenv, venv=venv})
                     (* Need procedureEntryExit call? *)
                   end
@@ -194,7 +197,7 @@ struct
                                 NONE => (err pos "Function undefined"; {exp=R.nilIR (), ty=T.BOTTOM})
                               | SOME (entry) => case entry of 
                                               E.FunEntry ({formals, result, level=funlevel, label}) => (checkArgs (formals, args); 
-                                                                                               {exp=R.callIR (funlevel, level, label, map translateArg args), ty=result})
+                                                                                               {exp=R.callIR (funlevel, level, label, map translateArg args), ty= (!result)})
                                             | E.VarEntry ({ty, access}) => (err pos "Function undefined"; {exp=R.nilIR (), ty=T.BOTTOM})
               end
           | trexp (A.RecordExp ({fields, typ, pos})) = 
@@ -340,7 +343,7 @@ struct
       val ir = #exp ((transExp (mainLevel, mainLabel, venv, tenv)) absyn)
 
     in
-      R.procedureEntryExit (mainLevel, ir);
+      R.procedureEntryExit (mainLevel, ir, mainLabel);
       R.result ()
     end
 end
diff --git a/testcases/test7.tig b/testcases/test7.tig
@@ -7,6 +7,7 @@ let
 	var one : int := 1
 	var four : int := 4
 in
-	add (one, four)
+	add (one, four);
+  add (one, four)
 end