Allow name hints to be set for a signal.

[matthijs/master-project/cλash.git] / Pretty.hs

diff --git a/Pretty.hs b/Pretty.hs
index 6f5f63dc71b46323fb582674992bd18e7c335d19..433c15a7abdc29914c2a6f84d0cd89a9f2cb2512 100644 (file)
--- a/Pretty.hs
+++ b/Pretty.hs
@@ -1,13 +1,19 @@
 module Pretty (prettyShow) where
 
 import qualified Data.Map as Map
+import qualified Data.Foldable as Foldable
+import qualified List
+
+import qualified Var
 import qualified CoreSyn
+import qualified TypeRep
 import qualified Module
 import qualified HscTypes
 import Text.PrettyPrint.HughesPJClass
 import Outputable ( showSDoc, ppr, Outputable, OutputableBndr)
 
 import qualified ForSyDe.Backend.Ppr
+import qualified ForSyDe.Backend.VHDL.Ppr
 import qualified ForSyDe.Backend.VHDL.AST as AST
 
 import HsValueMap
@@ -15,6 +21,11 @@ import FlattenTypes
 import TranslatorTypes
 import VHDLTypes
 
+-- | A version of the default pPrintList method, which uses a custom function
+--   f instead of pPrint to print elements.
+printList :: (a -> Doc) -> [a] -> Doc
+printList f = brackets . fsep . punctuate comma . map f
+
 instance Pretty HsFunction where
   pPrint (HsFunction name args res) =
     text name <> char ' ' <> parens (hsep $ punctuate comma args') <> text " -> " <> res'
@@ -28,35 +39,58 @@ instance Pretty x => Pretty (HsValueMap x) where
 
 instance Pretty HsValueUse where
   pPrint Port            = char 'P'
-  pPrint (State n)       = char 'C' <> int n
+  pPrint (State n)       = char 'S' <> int n
   pPrint (HighOrder _ _) = text "Higher Order"
 
-instance Pretty id => Pretty (FlatFunction' id) where
-  pPrint (FlatFunction args res apps conds sigs) =
+instance Pretty FlatFunction where
+  pPrint (FlatFunction args res defs sigs) =
     (text "Args: ") $$ nest 10 (pPrint args)
     $+$ (text "Result: ") $$ nest 10 (pPrint res)
-    $+$ (text "Apps: ") $$ nest 10 (vcat (map pPrint apps))
-    $+$ (text "Conds: ") $$ nest 10 (pPrint conds)
-    $+$ text "Signals: " $$ nest 10 (pPrint sigs)
+    $+$ (text "Defs: ") $$ nest 10 (ppdefs defs)
+    $+$ text "Signals: " $$ nest 10 (printList ppsig sigs)
+    where
+      ppsig (id, info) = pPrint id <> pPrint info
+      ppdefs defs = vcat (map pPrint sorted)
+        where 
+          -- Roughly sort the entries (inaccurate for Fapps)
+          sorted = List.sortBy (\a b -> compare (sigDefDst a) (sigDefDst b)) defs
+          sigDefDst (FApp _ _ dst) = head $ Foldable.toList dst
+          sigDefDst (CondDef _ _ _ dst) = dst
+          sigDefDst (UncondDef _ dst) = dst
 
-instance Pretty id => Pretty (FApp id) where
+
+instance Pretty SigDef where
   pPrint (FApp func args res) =
     pPrint func <> text " : " <> pPrint args <> text " -> " <> pPrint res
+  pPrint (CondDef cond true false res) = 
+    pPrint cond <> text " ? " <> pPrint true <> text " : " <> pPrint false <> text " -> " <> pPrint res
+  pPrint (UncondDef src dst) =
+    ppsrc src <> text " -> " <> pPrint dst
+    where
+      ppsrc (Left id) = pPrint id
+      ppsrc (Right expr) = pPrint expr
 
-instance Pretty id => Pretty (CondDef id) where
-  pPrint _ = text "TODO"
+instance Pretty SignalExpr where
+  pPrint (EqLit id lit) =
+    parens $ pPrint id <> text " = " <> text lit
+  pPrint (Literal lit) =
+    text lit
+  pPrint (Eq a b) =
+    parens $ pPrint a <> text " = " <> pPrint b
 
 instance Pretty SignalInfo where
-  pPrint (SignalInfo name use ty) =
+  pPrint (SignalInfo name use ty hints) =
     text ":" <> (pPrint use) <> (ppname name)
     where
       ppname Nothing = empty
       ppname (Just name) = text ":" <> text name
 
 instance Pretty SigUse where
-  pPrint SigPort     = text "P"
+  pPrint SigPortIn   = text "PI"
+  pPrint SigPortOut  = text "PO"
   pPrint SigInternal = text "I"
-  pPrint SigState    = text "S"
+  pPrint (SigStateOld n) = text "SO:" <> int n
+  pPrint (SigStateNew n) = text "SN:" <> int n
   pPrint SigSubState = text "s"
 
 instance Pretty VHDLSession where
@@ -84,7 +118,7 @@ instance Pretty FuncData where
 
 instance Pretty Entity where
   pPrint (Entity id args res decl) =
-    text "Entity id: " $$ nest 10 (pPrint id)
+    text "Entity: " $$ nest 10 (pPrint id)
     $+$ text "Args: " $$ nest 10 (pPrint args)
     $+$ text "Result: " $$ nest 10 (pPrint res)
     $+$ ppdecl decl
@@ -92,7 +126,7 @@ instance Pretty Entity where
       ppdecl Nothing = text "VHDL entity not present"
       ppdecl (Just _) = text "VHDL entity present"
 
-instance (OutputableBndr b) => Pretty (CoreSyn.Bind b) where
+instance (OutputableBndr b, Show b) => Pretty (CoreSyn.Bind b) where
   pPrint (CoreSyn.NonRec b expr) =
     text "NonRec: " $$ nest 10 (prettyBind (b, expr))
   pPrint (CoreSyn.Rec binds) =
@@ -101,9 +135,21 @@ instance (OutputableBndr b) => Pretty (CoreSyn.Bind b) where
 instance Pretty AST.VHDLId where
   pPrint id = ForSyDe.Backend.Ppr.ppr id
 
-prettyBind :: (Outputable b, Outputable e) => (b, e) -> Doc
+prettyBind :: (Show b, Show e) => (b, e) -> Doc
 prettyBind (b, expr) =
   text b' <> text " = " <> text expr'
   where
-    b' = showSDoc $ ppr b
-    expr' = showSDoc $ ppr expr
+    b' = show b
+    expr' = show expr
+
+-- Derive Show for core expressions and binders, so we can see the actual
+-- structure.
+deriving instance (Show b) => Show (CoreSyn.Expr b)
+deriving instance (Show b) => Show (CoreSyn.Bind b)
+
+-- Implement dummy shows for Note and Type, so we can at least use show on
+-- expressions.
+instance Show CoreSyn.Note where
+  show n = "<note>"
+instance Show TypeRep.Type where
+  show t = "_type:(" ++ (showSDoc $ ppr t) ++ ")"