X-Git-Url: https://git.stderr.nl/gitweb?a=blobdiff_plain;f=clash%2FCLasH%2FVHDL%2FVHDLTools.hs;h=521aa0850b0243d08c3623581a696e351b02f2fc;hb=3a92b8b28270471c7a2c8928cfc63a4c00e80c96;hp=165b1ef655710195d244dd13ade22cd243be218d;hpb=04f836932ad17dd557af0ba388a12d2b74c1e7d7;p=matthijs%2Fmaster-project%2Fc%CE%BBash.git diff --git a/clash/CLasH/VHDL/VHDLTools.hs b/clash/CLasH/VHDL/VHDLTools.hs index 165b1ef..521aa08 100644 --- a/clash/CLasH/VHDL/VHDLTools.hs +++ b/clash/CLasH/VHDL/VHDLTools.hs @@ -162,6 +162,11 @@ idToVHDLExpr = vhdlNameToVHDLExpr . AST.NSimple -- Turn a Core expression into an AST expression exprToVHDLExpr core = varToVHDLExpr (exprToVar core) +-- Turn a String into a VHDL expr containing an id +stringToVHDLExpr :: String -> AST.Expr +stringToVHDLExpr = idToVHDLExpr . mkVHDLExtId + + -- Turn a alternative constructor into an AST expression. For -- dataconstructors, this is only the constructor itself, not any arguments it -- has. Should not be called with a DEFAULT constructor. @@ -341,7 +346,8 @@ mkHTypeEither' ty | ty_has_free_tyvars ty = return $ Left $ "\nVHDLTools.mkHType return $ Right $ SizedIType len "Index" -> do bound <- tfp_to_int (ranged_word_bound_ty ty) - return $ Right $ RangedWType bound + -- Upperbound is exclusive, hence the -1 + return $ Right $ RangedWType (bound - 1) otherwise -> mkTyConHType tycon args Nothing -> return $ Left $ "\nVHDLTools.mkHTypeEither': Do not know what to do with type: " ++ pprString ty @@ -351,42 +357,62 @@ mkTyConHType tycon args = case TyCon.tyConDataCons tycon of -- Not an algebraic type [] -> return $ Left $ "VHDLTools.mkTyConHType: Only custom algebraic types are supported: " ++ pprString tycon - [dc] -> do - let arg_tys = DataCon.dataConRepArgTys dc - let real_arg_tys = map (CoreSubst.substTy subst) arg_tys - let real_arg_tys_nostate = filter (\x -> not (isStateType x)) real_arg_tys - elem_htys_either <- mapM mkHTypeEither real_arg_tys_nostate - case Either.partitionEithers elem_htys_either of - ([], [elem_hty]) -> - return $ Right elem_hty - -- No errors in element types - ([], elem_htys) -> - return $ Right $ AggrType (nameToString (TyCon.tyConName tycon)) elem_htys - -- There were errors in element types - (errors, _) -> return $ Left $ - "\nVHDLTools.mkTyConHType: Can not construct type for: " ++ pprString tycon ++ "\n because no type can be construced for some of the arguments.\n" - ++ (concat errors) dcs -> do - let arg_tys = concatMap DataCon.dataConRepArgTys dcs - let real_arg_tys = map (CoreSubst.substTy subst) arg_tys - case real_arg_tys of - [] -> - return $ Right $ EnumType (nameToString (TyCon.tyConName tycon)) (map (nameToString . DataCon.dataConName) dcs) - xs -> return $ Left $ - "VHDLTools.mkTyConHType: Only enum-like constructor datatypes supported: " ++ pprString dcs ++ "\n" + let arg_tyss = map DataCon.dataConRepArgTys dcs + let enum_ty = EnumType name (map (nameToString . DataCon.dataConName) dcs) + case (concat arg_tyss) of + -- No arguments, this is just an enumeration type + [] -> return (Right enum_ty) + -- At least one argument, this becomes an aggregate type + _ -> do + -- Resolve any type arguments to this type + let real_arg_tyss = map (map (CoreSubst.substTy subst)) arg_tyss + -- Remove any state type fields + let real_arg_tyss_nostate = map (filter (\x -> not (isStateType x))) real_arg_tyss + elem_htyss_either <- mapM (mapM mkHTypeEither) real_arg_tyss_nostate + let (errors, elem_htyss) = unzip (map Either.partitionEithers elem_htyss_either) + case (all null errors) of + True -> case (dcs, concat elem_htyss) of + -- A single constructor with a single (non-state) field? + ([dc], [elem_hty]) -> return $ Right elem_hty + -- If we get here, then all of the argument types were state + -- types (we check for enumeration types at the top). Not + -- sure how to handle this, so error out for now. + (_, []) -> error $ "ADT with only State elements (or something like that?) Dunno how to handle this yet. Tycon: " ++ pprString tycon ++ " Arguments: " ++ pprString args + -- A full ADT (with multiple fields and one or multiple + -- constructors). + (_, elem_htys) -> do + let (_, fieldss) = List.mapAccumL (List.mapAccumL label_field) labels elem_htyss + -- Only put in an enumeration as part of the aggregation + -- when there are multiple datacons + let enum_ty_part = case dcs of + [dc] -> Nothing + _ -> Just ("constructor", enum_ty) + -- Create the AggrType HType + return $ Right $ AggrType name enum_ty_part fieldss + -- There were errors in element types + False -> return $ Left $ + "\nVHDLTools.mkTyConHType: Can not construct type for: " ++ pprString tycon ++ "\n because no type can be construced for some of the arguments.\n" + ++ (concat $ concat errors) where + name = (nameToString (TyCon.tyConName tycon)) tyvars = TyCon.tyConTyVars tycon subst = CoreSubst.extendTvSubstList CoreSubst.emptySubst (zip tyvars args) + -- Label a field by taking the first available label and returning + -- the rest. + label_field :: [String] -> HType -> ([String], (String, HType)) + label_field (l:ls) htype = (ls, (l, htype)) + labels = map (:[]) ['A'..'Z'] --- Translate a Haskell type to a VHDL type, generating a new type if needed. --- Returns an error value, using the given message, when no type could be --- created. Returns Nothing when the type is valid, but empty. vhdlTy :: (TypedThing t, Outputable.Outputable t) => String -> t -> TypeSession (Maybe AST.TypeMark) vhdlTy msg ty = do htype <- mkHType msg ty vhdlTyMaybe htype +-- | Translate a Haskell type to a VHDL type, generating a new type if needed. +-- Returns an error value, using the given message, when no type could be +-- created. Returns Nothing when the type is valid, but empty. vhdlTyMaybe :: HType -> TypeSession (Maybe AST.TypeMark) vhdlTyMaybe htype = do typemap <- MonadState.get tsTypes @@ -424,30 +450,59 @@ construct_vhdl_ty htype = mkTyconTy :: HType -> TypeSession TypeMapRec mkTyconTy htype = case htype of - (AggrType tycon args) -> do - elemTysMaybe <- mapM vhdlTyMaybe args - case Maybe.catMaybes elemTysMaybe of - [] -> -- No non-empty members + (AggrType name enum_field_maybe fieldss) -> do + let (labelss, elem_htypess) = unzip (map unzip fieldss) + elemTyMaybess <- mapM (mapM vhdlTyMaybe) elem_htypess + let elem_tyss = map Maybe.catMaybes elemTyMaybess + case concat elem_tyss of + [] -> -- No non-empty fields return Nothing - elem_tys -> do - let elems = zipWith AST.ElementDec recordlabels elem_tys - let elem_names = concatMap prettyShow elem_tys - let ty_id = mkVHDLExtId $ tycon ++ elem_names - let ty_def = AST.TDR $ AST.RecordTypeDef elems - let tupshow = mkTupleShow elem_tys ty_id - MonadState.modify tsTypeFuns $ Map.insert (htype, showIdString) (showId, tupshow) + _ -> do + let reclabelss = map (map mkVHDLBasicId) labelss + let elemss = zipWith (zipWith AST.ElementDec) reclabelss elem_tyss + let elem_names = concatMap (concatMap prettyShow) elem_tyss + let ty_id = mkVHDLExtId $ name ++ elem_names + -- Find out if we need to add an extra field at the start of + -- the record type containing the constructor (only needed + -- when there's more than one constructor). + enum_ty_maybe <- case enum_field_maybe of + Nothing -> return Nothing + Just (_, enum_htype) -> do + enum_ty_maybe' <- vhdlTyMaybe enum_htype + case enum_ty_maybe' of + Nothing -> error $ "Couldn't translate enumeration type part of AggrType: " ++ show htype + -- Note that the first Just means the type is + -- translateable, while the second Just means that there + -- is a enum_ty at all (e.g., there's multiple + -- constructors). + Just enum_ty -> return $ Just enum_ty + -- Create an record field declaration for the first + -- constructor field, if needed. + enum_dec_maybe <- case enum_field_maybe of + Nothing -> return $ Nothing + Just (enum_name, enum_htype) -> do + enum_vhdl_ty_maybe <- vhdlTyMaybe enum_htype + let enum_vhdl_ty = Maybe.fromMaybe (error $ "\nVHDLTools.mkTyconTy: Enumeration field should not have empty type: " ++ show enum_htype) enum_vhdl_ty_maybe + return $ Just $ AST.ElementDec (mkVHDLBasicId enum_name) enum_vhdl_ty + -- Turn the maybe into a list, so we can prepend it. + let enum_decs = Maybe.maybeToList enum_dec_maybe + let enum_tys = Maybe.maybeToList enum_ty_maybe + let ty_def = AST.TDR $ AST.RecordTypeDef (enum_decs ++ concat elemss) + let aggrshow = case enum_field_maybe of + Nothing -> mkTupleShow (enum_tys ++ concat elem_tyss) ty_id + Just (conLbl, EnumType tycon dcs) -> mkAdtShow conLbl dcs (map (map fst) fieldss) ty_id + MonadState.modify tsTypeFuns $ Map.insert (htype, showIdString) (showId, aggrshow) return $ Just (ty_id, Just $ Left ty_def) (EnumType tycon dcs) -> do - let elems = map mkVHDLExtId dcs let ty_id = mkVHDLExtId tycon - let ty_def = AST.TDE $ AST.EnumTypeDef elems - let enumShow = mkEnumShow elems ty_id + let possibilaties = case (length dcs) of 1 -> 1; x -> (x-1) + let bitsize = floor (logBase 2 (fromInteger (toInteger possibilaties))) + let range = AST.ConstraintIndex $ AST.IndexConstraint [AST.DownRange (AST.PrimLit $ show bitsize) (AST.PrimLit "0")] + let ty_def = AST.SubtypeIn unsignedTM (Just range) + let enumShow = mkEnumShow dcs ty_id MonadState.modify tsTypeFuns $ Map.insert (htype, showIdString) (showId, enumShow) - return $ Just (ty_id, Just $ Left ty_def) + return $ Just (ty_id, Just $ Right ty_def) otherwise -> error $ "\nVHDLTools.mkTyconTy: Called for HType that is neiter a AggrType or EnumType: " ++ show htype - where - -- Generate a bunch of labels for fields of a record - recordlabels = map (\c -> mkVHDLBasicId [c]) ['A'..'Z'] -- | Create a VHDL vector type mkVectorTy :: @@ -488,7 +543,7 @@ mkNaturalTy :: mkNaturalTy min_bound max_bound = do let bitsize = floor (logBase 2 (fromInteger (toInteger max_bound))) let ty_id = mkVHDLExtId $ "natural_" ++ (show min_bound) ++ "_to_" ++ (show max_bound) - let range = AST.ConstraintIndex $ AST.IndexConstraint [AST.ToRange (AST.PrimLit $ show min_bound) (AST.PrimLit $ show bitsize)] + let range = AST.ConstraintIndex $ AST.IndexConstraint [AST.DownRange (AST.PrimLit $ show bitsize) (AST.PrimLit $ show min_bound)] let ty_def = AST.SubtypeIn unsignedTM (Just range) return (Just (ty_id, Just $ Right ty_def)) @@ -496,8 +551,8 @@ mkUnsignedTy :: Int -- ^ Haskell type of the unsigned integer -> TypeSession TypeMapRec mkUnsignedTy size = do - let ty_id = mkVHDLExtId $ "unsigned_" ++ show (size - 1) - let range = AST.ConstraintIndex $ AST.IndexConstraint [AST.ToRange (AST.PrimLit "0") (AST.PrimLit $ show (size - 1))] + let ty_id = mkVHDLExtId $ "unsigned_" ++ show size + let range = AST.ConstraintIndex $ AST.IndexConstraint [AST.DownRange (AST.PrimLit $ show (size - 1)) (AST.PrimLit "0")] let ty_def = AST.SubtypeIn unsignedTM (Just range) return (Just (ty_id, Just $ Right ty_def)) @@ -505,28 +560,54 @@ mkSignedTy :: Int -- ^ Haskell type of the signed integer -> TypeSession TypeMapRec mkSignedTy size = do - let ty_id = mkVHDLExtId $ "signed_" ++ show (size - 1) - let range = AST.ConstraintIndex $ AST.IndexConstraint [AST.ToRange (AST.PrimLit "0") (AST.PrimLit $ show (size - 1))] + let ty_id = mkVHDLExtId $ "signed_" ++ show size + let range = AST.ConstraintIndex $ AST.IndexConstraint [AST.DownRange (AST.PrimLit $ show (size - 1)) (AST.PrimLit "0")] let ty_def = AST.SubtypeIn signedTM (Just range) return (Just (ty_id, Just $ Right ty_def)) --- Finds the field labels for VHDL type generated for the given Core type, --- which must result in a record type. -getFieldLabels :: Type.Type -> TypeSession [AST.VHDLId] -getFieldLabels ty = do - -- Ensure that the type is generated (but throw away it's VHDLId) - let error_msg = "\nVHDLTools.getFieldLabels: Can not get field labels, because: " ++ pprString ty ++ "can not be generated." - vhdlTy error_msg ty - -- Get the types map, lookup and unpack the VHDL TypeDef - types <- MonadState.get tsTypes - -- Assume the type for which we want labels is really translatable - htype <- mkHType error_msg ty - case Map.lookup htype types of - Nothing -> error $ "\nVHDLTools.getFieldLabels: Type not found? This should not happen!\nLooking for type: " ++ (pprString ty) ++ "\nhtype: " ++ (show htype) - Just Nothing -> return [] -- The type is empty - Just (Just (_, Just (Left (AST.TDR (AST.RecordTypeDef elems))))) -> return $ map (\(AST.ElementDec id _) -> id) elems - Just (Just (_, Just vty)) -> error $ "\nVHDLTools.getFieldLabels: Type not a record type? This should not happen!\nLooking for type: " ++ pprString (ty) ++ "\nhtype: " ++ (show htype) ++ "\nFound type: " ++ (show vty) - +-- Finds the field labels and types for aggregation HType. Returns an +-- error on other types. +getFields :: + HType -- ^ The HType to get fields for + -> Int -- ^ The constructor to get fields for (e.g., 0 + -- for the first constructor, etc.) + -> [(String, HType)] -- ^ A list of fields, with their name and type +getFields htype dc_i = case htype of + (AggrType name _ fieldss) + | dc_i >= 0 && dc_i < length fieldss -> fieldss!!dc_i + | otherwise -> error $ "VHDLTool.getFields: Invalid constructor index: " ++ (show dc_i) ++ ". No such constructor in HType: " ++ (show htype) + _ -> error $ "VHDLTool.getFields: Can't get fields from non-aggregate HType: " ++ show htype + +-- Finds the field labels for an aggregation type, as VHDLIds. +getFieldLabels :: + HType -- ^ The HType to get field labels for + -> Int -- ^ The constructor to get fields for (e.g., 0 + -- for the first constructor, etc.) + -> [AST.VHDLId] -- ^ The labels +getFieldLabels htype dc_i = ((map mkVHDLBasicId) . (map fst)) (getFields htype dc_i) + +-- Finds the field label for the constructor field, if any. +getConstructorFieldLabel :: + HType + -> Maybe AST.VHDLId +getConstructorFieldLabel (AggrType _ (Just con) _) = + Just $ mkVHDLBasicId (fst con) +getConstructorFieldLabel (AggrType _ Nothing _) = + Nothing +getConstructorFieldLabel htype = + error $ "Can't get constructor field label from non-aggregate HType: " ++ show htype + + +getConstructorIndex :: + HType -> + String -> + Int +getConstructorIndex (EnumType etype cons) dc = case List.elemIndex dc cons of + Just (index) -> index + Nothing -> error $ "VHDLTools.getConstructor: constructor: " ++ show dc ++ " is not part of type: " ++ show etype ++ ", which only has constructors: " ++ show cons +getConstructorIndex htype _ = error $ "Can't get constructor index for non-Enum type: " ++ show htype + + mktydecl :: (AST.VHDLId, Maybe (Either AST.TypeDef AST.SubtypeIn)) -> Maybe AST.PackageDecItem mytydecl (_, Nothing) = Nothing mktydecl (ty_id, Just (Left ty_def)) = Just $ AST.PDITD $ AST.TypeDec ty_id ty_def @@ -556,16 +637,40 @@ mkTupleShow elemTMs tupleTM = AST.SubProgBody showSpec [] [showExpr] recordlabels = map (\c -> mkVHDLBasicId [c]) ['A'..'Z'] tupSize = length elemTMs +mkAdtShow :: + String + -> [String] -- Constructors + -> [[String]] -- Fields for every constructor + -> AST.TypeMark + -> AST.SubProgBody +mkAdtShow conLbl conIds elemIdss adtTM = AST.SubProgBody showSpec [] [showExpr] + where + adtPar = AST.unsafeVHDLBasicId "adt" + showSpec = AST.Function showId [AST.IfaceVarDec adtPar adtTM] stringTM + showExpr = AST.CaseSm (AST.PrimName $ AST.NSelected $ (AST.NSimple adtPar) AST.:.: (AST.SSimple $ (mkVHDLBasicId conLbl))) + [AST.CaseSmAlt [AST.ChoiceE $ AST.PrimLit $ show x] [AST.ReturnSm (Just $ ((AST.PrimLit $ '"':(conIds!!x)++[' ','"'])) AST.:&: showFields x)] | x <- [0..(length conIds) -1]] + showFields i = if (null (elemIdss!!i)) then + AST.PrimLit "''" + else + foldr1 (\e1 e2 -> e1 AST.:&: AST.PrimLit "' '" AST.:&: e2) $ + map ((genExprFCall showId). + AST.PrimName . + AST.NSelected . + (AST.NSimple adtPar AST.:.:). + tupVHDLSuffix) + (map mkVHDLBasicId (elemIdss!!i)) + mkEnumShow :: - [AST.VHDLId] + [String] -> AST.TypeMark -> AST.SubProgBody mkEnumShow elemIds enumTM = AST.SubProgBody showSpec [] [showExpr] - where - enumPar = AST.unsafeVHDLBasicId "enum" + where + enumPar = AST.unsafeVHDLBasicId "enum" showSpec = AST.Function showId [AST.IfaceVarDec enumPar enumTM] stringTM - showExpr = AST.ReturnSm (Just $ - AST.PrimLit (show $ tail $ init $ AST.fromVHDLId enumTM)) + showExpr = AST.CaseSm (AST.PrimName $ AST.NSimple enumPar) + [AST.CaseSmAlt [AST.ChoiceE $ AST.PrimLit $ show x] [AST.ReturnSm (Just $ AST.PrimLit $ '"':(elemIds!!x)++['"'])] | x <- [0..(length elemIds) -1]] + mkVectorShow :: AST.TypeMark -- ^ elemtype