X-Git-Url: https://git.stderr.nl/gitweb?a=blobdiff_plain;f=Flatten.hs;h=ba49d0b8a22a5f7440d1b371a397007ad77e9786;hb=0082f01a853476cdcec0e73bacf8c0d4508dbec0;hp=115460c19e975da9311f600dad3d0283fa2a57a8;hpb=e2a1b9504807512be2e613c9e8822658be6fa626;p=matthijs%2Fmaster-project%2Fc%CE%BBash.git

diff --git a/Flatten.hs b/Flatten.hs
index 115460c..ba49d0b 100644
--- a/Flatten.hs
+++ b/Flatten.hs
@@ -28,7 +28,7 @@ dataConAppArgs dc args =
 
 genSignals ::
   Type.Type
-  -> FlattenState (SignalMap UnnamedSignal)
+  -> FlattenState SignalMap
 
 genSignals ty =
   -- First generate a map with the right structure containing the types, and
@@ -37,13 +37,13 @@ genSignals ty =
 
 -- | Marks a signal as the given SigUse, if its id is in the list of id's
 --   given.
-markSignals :: SigUse -> [UnnamedSignal] -> (UnnamedSignal, SignalInfo) -> (UnnamedSignal, SignalInfo)
+markSignals :: SigUse -> [SignalId] -> (SignalId, SignalInfo) -> (SignalId, SignalInfo)
 markSignals use ids (id, info) =
   (id, info')
   where
     info' = if id `elem` ids then info { sigUse = use} else info
 
-markSignal :: SigUse -> UnnamedSignal -> (UnnamedSignal, SignalInfo) -> (UnnamedSignal, SignalInfo)
+markSignal :: SigUse -> SignalId -> (SignalId, SignalInfo) -> (SignalId, SignalInfo)
 markSignal use id = markSignals use [id]
 
 -- | Flatten a haskell function
@@ -54,27 +54,75 @@ flattenFunction ::
 
 flattenFunction _ (Rec _) = error "Recursive binders not supported"
 flattenFunction hsfunc bind@(NonRec var expr) =
-  FlatFunction args res apps conds sigs''''
+  FlatFunction args res defs sigs
   where
-    init_state        = ([], [], [], 0)
-    (fres, end_state) = State.runState (flattenExpr [] expr) init_state
-    (apps, conds, sigs, _)  = end_state
+    init_state        = ([], [], 0)
+    (fres, end_state) = State.runState (flattenTopExpr hsfunc expr) init_state
+    (defs, sigs, _)   = end_state
     (args, res)       = fres
-    arg_ports         = concat (map Foldable.toList args)
-    res_ports         = Foldable.toList res
-    -- Mark args and result signals as input and output ports resp.
-    sigs'             = fmap (markSignals SigPortIn arg_ports) sigs
-    sigs''            = fmap (markSignals SigPortOut res_ports) sigs'
-    -- Mark args and result states as old and new state resp.
-    args_states       = concat $ zipWith stateList (hsFuncArgs hsfunc) args
-    sigs'''           = foldl (\s (num, id) -> map (markSignal (SigStateOld num) id) s) sigs'' args_states
-    res_states        = stateList (hsFuncRes hsfunc) res
-    sigs''''          = foldl (\s (num, id) -> map (markSignal (SigStateNew num) id) s) sigs''' res_states
 
+flattenTopExpr ::
+  HsFunction
+  -> CoreExpr
+  -> FlattenState ([SignalMap], SignalMap)
+
+flattenTopExpr hsfunc expr = do
+  -- Flatten the expression
+  (args, res) <- flattenExpr [] expr
+  
+  -- Join the signal ids and uses together
+  let zipped_args = zipWith zipValueMaps args (hsFuncArgs hsfunc)
+  let zipped_res = zipValueMaps res (hsFuncRes hsfunc)
+  -- Set the signal uses for each argument / result, possibly updating
+  -- argument or result signals.
+  args' <- mapM (Traversable.mapM $ hsUseToSigUse args_use) zipped_args
+  res' <- Traversable.mapM (hsUseToSigUse res_use) zipped_res
+  return (args', res')
+  where
+    args_use Port = SigPortIn
+    args_use (State n) = SigStateOld n
+    res_use Port = SigPortOut
+    res_use (State n) = SigStateNew n
+
+
+hsUseToSigUse :: 
+  (HsValueUse -> SigUse)      -- ^ A function to actually map the use value
+  -> (SignalId, HsValueUse)   -- ^ The signal to look at and its use
+  -> FlattenState SignalId    -- ^ The resulting signal. This is probably the
+                              --   same as the input, but it could be different.
+hsUseToSigUse f (id, use) = do
+  info <- getSignalInfo id
+  id' <- case sigUse info of 
+    -- Internal signals can be marked as different uses freely.
+    SigInternal -> do
+      return id
+    -- Signals that already have another use, must be duplicated before
+    -- marking. This prevents signals mapping to the same input or output
+    -- port or state variables and ports overlapping, etc.
+    otherwise -> do
+      duplicateSignal id
+  setSignalInfo id' (info { sigUse = f use})
+  return id'
+
+-- | Duplicate the given signal, assigning its value to the new signal.
+--   Returns the new signal id.
+duplicateSignal :: SignalId -> FlattenState SignalId
+duplicateSignal id = do
+  -- Find the type of the original signal
+  info <- getSignalInfo id
+  let ty = sigTy info
+  -- Generate a new signal (which is SigInternal for now, that will be
+  -- sorted out later on).
+  id' <- genSignalId SigInternal ty
+  -- Assign the old signal to the new signal
+  addDef $ UncondDef id id'
+  -- Replace the signal with the new signal
+  return id'
+        
 flattenExpr ::
   BindMap
   -> CoreExpr
-  -> FlattenState ([SignalMap UnnamedSignal], (SignalMap UnnamedSignal))
+  -> FlattenState ([SignalMap], SignalMap)
 
 flattenExpr binds lam@(Lam b expr) = do
   -- Find the type of the binder
@@ -132,7 +180,7 @@ flattenExpr binds app@(App _ _) = do
         appArgs = arg_ress,
         appRes  = res
       }
-      addApp app
+      addDef app
       return ([], res)
     -- | Check a flattened expression to see if it is valid to use as a
     --   function argument. The first argument is the original expression for
@@ -165,7 +213,7 @@ flattenExpr binds expr@(Case (Var v) b _ alts) =
       -> Var.Var                -- The scrutinee
       -> CoreBndr               -- The binder to bind the scrutinee to
       -> CoreAlt                -- The single alternative
-      -> FlattenState ( [SignalMap UnnamedSignal], SignalMap UnnamedSignal)
+      -> FlattenState ( [SignalMap], SignalMap)
                                            -- See expandExpr
     flattenSingleAltCaseExpr binds v b alt@(DataAlt datacon, bind_vars, expr) =
       if not (DataCon.isTupleCon datacon) 
@@ -208,9 +256,9 @@ appToHsFunction ty f args =
 -- | Filters non-state signals and returns the state number and signal id for
 --   state values.
 filterState ::
-  UnnamedSignal                  -- | The signal id to look at
+  SignalId                       -- | The signal id to look at
   -> HsValueUse                  -- | How is this signal used?
-  -> Maybe (Int, UnnamedSignal ) -- | The state num and signal id, if this
+  -> Maybe (StateId, SignalId )  -- | The state num and signal id, if this
                                  --   signal was used as state
 
 filterState id (State num) = 
@@ -221,8 +269,8 @@ filterState _ _ = Nothing
 --   signals in the given maps.
 stateList ::
   HsUseMap
-  -> (SignalMap UnnamedSignal)
-  -> [(Int, UnnamedSignal)]
+  -> (SignalMap)
+  -> [(StateId, SignalId)]
 
 stateList uses signals =
     Maybe.catMaybes $ Foldable.toList $ zipValueMapsWith filterState signals uses
@@ -231,7 +279,7 @@ stateList uses signals =
 getOwnStates ::
   HsFunction                      -- | The function to look at
   -> FlatFunction                 -- | The function to look at
-  -> [(Int, SignalInfo, SignalInfo)]   
+  -> [(StateId, SignalInfo, SignalInfo)]   
         -- | The state signals. The first is the state number, the second the
         --   signal to assign the current state to, the last is the signal
         --   that holds the new state.