import HsSyn as Hs
( HsExpr(..), HsLit(..), ArithSeqInfo(..),
- HsStmtContext(..),
+ HsStmtContext(..), TyClDecl(..),
Match(..), GRHSs(..), GRHS(..), HsPred(..),
- HsDecl(..), InstDecl(..), ConDecl(..),
+ HsDecl(..), TyClDecl(..), InstDecl(..), ConDecl(..),
Stmt(..), HsBinds(..), MonoBinds(..), Sig(..),
Pat(..), HsConDetails(..), HsOverLit, BangType(..),
placeHolderType, HsType(..), HsTupCon(..),
HsTyVarBndr(..), HsContext,
- mkSimpleMatch
+ mkSimpleMatch, mkHsForAllTy
)
import RdrName ( RdrName, mkRdrUnqual, mkRdrQual, mkOrig )
import Module ( mkModuleName )
-import RdrHsSyn ( mkHsIntegral, mkClassDecl, mkTyData )
+import RdrHsSyn ( mkHsIntegral, mkHsFractional, mkClassDecl, mkTyData )
import OccName
import SrcLoc ( SrcLoc, generatedSrcLoc )
import TyCon ( DataConDetails(..) )
import Type ( Type )
import BasicTypes( Boxity(..), RecFlag(Recursive),
NewOrData(..), StrictnessMark(..) )
-import FastString( mkFastString )
-import Char ( ord, isAlphaNum )
+import ForeignCall ( Safety(..), CCallConv(..), CCallTarget(..) )
+import HsDecls ( CImportSpec(..), ForeignImport(..), ForeignDecl(..) )
+import FastString( FastString, mkFastString, nilFS )
+import Char ( ord, isAscii, isAlphaNum, isAlpha )
import List ( partition )
+import ErrUtils (Message)
import Outputable
-------------------------------------------------------------------
-convertToHsDecls :: [Meta.Dec] -> [HsDecl RdrName]
+convertToHsDecls :: [Meta.Dec] -> [Either (HsDecl RdrName) Message]
convertToHsDecls ds = map cvt_top ds
-cvt_top d@(Val _ _ _) = ValD (cvtd d)
-cvt_top d@(Fun _ _) = ValD (cvtd d)
+cvt_top :: Meta.Dec -> Either (HsDecl RdrName) Message
+cvt_top d@(Val _ _ _) = Left $ ValD (cvtd d)
+cvt_top d@(Fun _ _) = Left $ ValD (cvtd d)
+cvt_top (TySyn tc tvs rhs)
+ = Left $ TyClD (TySynonym (tconName tc) (cvt_tvs tvs) (cvtType rhs) loc0)
+
cvt_top (Data tc tvs constrs derivs)
- = TyClD (mkTyData DataType
- (noContext, tconName tc, cvt_tvs tvs)
- (DataCons (map mk_con constrs))
- (mk_derivs derivs) loc0)
+ = Left $ TyClD (mkTyData DataType
+ (noContext, tconName tc, cvt_tvs tvs)
+ (DataCons (map mk_con constrs))
+ (mk_derivs derivs) loc0)
where
- mk_con (Constr c tys)
+ mk_con (Constr c strtys)
+ = ConDecl (cName c) noExistentials noContext
+ (PrefixCon (map mk_arg strtys)) loc0
+ mk_con (RecConstr c varstrtys)
= ConDecl (cName c) noExistentials noContext
- (PrefixCon (map mk_arg tys)) loc0
+ (RecCon (map mk_id_arg varstrtys)) loc0
+ mk_con (InfixConstr st1 c st2)
+ = ConDecl (cName c) noExistentials noContext
+ (InfixCon (mk_arg st1) (mk_arg st2)) loc0
+
+ mk_arg (Strict, ty) = BangType MarkedUserStrict (cvtType ty)
+ mk_arg (NonStrict, ty) = BangType NotMarkedStrict (cvtType ty)
- mk_arg ty = BangType NotMarkedStrict (cvtType ty)
+ mk_id_arg (i, Strict, ty)
+ = (vName i, BangType MarkedUserStrict (cvtType ty))
+ mk_id_arg (i, NonStrict, ty)
+ = (vName i, BangType NotMarkedStrict (cvtType ty))
mk_derivs [] = Nothing
mk_derivs cs = Just [HsClassP (tconName c) [] | c <- cs]
cvt_top (Class ctxt cl tvs decs)
- = TyClD (mkClassDecl (cvt_context ctxt, tconName cl, cvt_tvs tvs)
- noFunDeps
- sigs (Just binds) loc0)
+ = Left $ TyClD (mkClassDecl (cvt_context ctxt, tconName cl, cvt_tvs tvs)
+ noFunDeps
+ sigs (Just binds) loc0)
where
(binds,sigs) = cvtBindsAndSigs decs
cvt_top (Instance tys ty decs)
- = InstD (InstDecl inst_ty binds sigs Nothing loc0)
+ = Left $ InstD (InstDecl inst_ty binds sigs Nothing loc0)
where
(binds, sigs) = cvtBindsAndSigs decs
inst_ty = HsForAllTy Nothing
(cvt_context tys)
(HsPredTy (cvt_pred ty))
-cvt_top (Proto nm typ) = SigD (Sig (vName nm) (cvtType typ) loc0)
+cvt_top (Proto nm typ) = Left $ SigD (Sig (vName nm) (cvtType typ) loc0)
+
+cvt_top (Foreign (Import callconv safety from nm typ))
+ = case parsed of
+ Just (c_header, cis) ->
+ let i = CImport callconv' safety' c_header nilFS cis
+ in Left $ ForD (ForeignImport (vName nm) (cvtType typ) i False loc0)
+ Nothing -> Right $ text (show from)
+ <+> ptext SLIT("is not a valid ccall impent")
+ where callconv' = case callconv of
+ CCall -> CCallConv
+ StdCall -> StdCallConv
+ safety' = case safety of
+ Unsafe -> PlayRisky
+ Safe -> PlaySafe False
+ Threadsafe -> PlaySafe True
+ parsed = parse_ccall_impent nm from
+
+parse_ccall_impent :: String -> String -> Maybe (FastString, CImportSpec)
+parse_ccall_impent nm s
+ = case lex_ccall_impent s of
+ Just ["dynamic"] -> Just (nilFS, CFunction DynamicTarget)
+ Just ["wrapper"] -> Just (nilFS, CWrapper)
+ Just ("static":ts) -> parse_ccall_impent_static nm ts
+ Just ts -> parse_ccall_impent_static nm ts
+ Nothing -> Nothing
+
+parse_ccall_impent_static :: String
+ -> [String]
+ -> Maybe (FastString, CImportSpec)
+parse_ccall_impent_static nm ts
+ = let ts' = case ts of
+ [ "&", cid] -> [ cid]
+ [fname, "&" ] -> [fname ]
+ [fname, "&", cid] -> [fname, cid]
+ _ -> ts
+ in case ts' of
+ [ cid] | is_cid cid -> Just (nilFS, mk_cid cid)
+ [fname, cid] | is_cid cid -> Just (mkFastString fname, mk_cid cid)
+ [ ] -> Just (nilFS, mk_cid nm)
+ [fname ] -> Just (mkFastString fname, mk_cid nm)
+ _ -> Nothing
+ where is_cid :: String -> Bool
+ is_cid x = all (/= '.') x && (isAlpha (head x) || head x == '_')
+ mk_cid :: String -> CImportSpec
+ mk_cid = CFunction . StaticTarget . mkFastString
+
+lex_ccall_impent :: String -> Maybe [String]
+lex_ccall_impent "" = Just []
+lex_ccall_impent ('&':xs) = fmap ("&":) $ lex_ccall_impent xs
+lex_ccall_impent (' ':xs) = lex_ccall_impent xs
+lex_ccall_impent ('\t':xs) = lex_ccall_impent xs
+lex_ccall_impent xs = case span is_valid xs of
+ ("", _) -> Nothing
+ (t, xs') -> fmap (t:) $ lex_ccall_impent xs'
+ where is_valid :: Char -> Bool
+ is_valid c = isAscii c && (isAlphaNum c || c `elem` "._")
noContext = []
noExistentials = []
convertToHsExpr :: Meta.Exp -> HsExpr RdrName
convertToHsExpr = cvt
-cvt (Var s) = HsVar(vName s)
-cvt (Con s) = HsVar(cName s)
+cvt (Var s) = HsVar (vName s)
+cvt (Con s) = HsVar (cName s)
cvt (Lit l)
| overloadedLit l = HsOverLit (cvtOverLit l)
| otherwise = HsLit (cvtLit l)
cvt (App x y) = HsApp (cvt x) (cvt y)
cvt (Lam ps e) = HsLam (mkSimpleMatch (map cvtp ps) (cvt e) void loc0)
+cvt (Tup [e]) = cvt e
cvt (Tup es) = ExplicitTuple(map cvt es) Boxed
cvt (Cond x y z) = HsIf (cvt x) (cvt y) (cvt z) loc0
cvt (Let ds e) = HsLet (cvtdecs ds) (cvt e)
cvt (Comp ss) = HsDo ListComp (cvtstmts ss) [] void loc0
cvt (ArithSeq dd) = ArithSeqIn (cvtdd dd)
cvt (ListExp xs) = ExplicitList void (map cvt xs)
-cvt (Infix (Just x) s (Just y)) = OpApp (cvt x) (HsVar(vName s)) undefined (cvt y)
-cvt (Infix Nothing s (Just y)) = SectionR (HsVar(vName s)) (cvt y)
-cvt (Infix (Just x) s Nothing ) = SectionL (cvt x) (HsVar(vName s))
-cvt (Infix Nothing s Nothing ) = HsVar(vName s) -- Can I indicate this is an infix thing?
-
+cvt (Infix (Just x) s (Just y))
+ = HsPar (OpApp (cvt x) (cvt s) undefined (cvt y))
+cvt (Infix Nothing s (Just y)) = SectionR (cvt s) (cvt y)
+cvt (Infix (Just x) s Nothing ) = SectionL (cvt x) (cvt s)
+cvt (Infix Nothing s Nothing ) = cvt s -- Can I indicate this is an infix thing?
+cvt (SigExp e t) = ExprWithTySig (cvt e) (cvtType t)
cvtdecs :: [Meta.Dec] -> HsBinds RdrName
cvtdecs [] = EmptyBinds
-- Used only for declarations in a 'let/where' clause,
-- not for top level decls
cvtd (Val (Pvar s) body ds) = FunMonoBind (vName s) False
- (panic "what now?") loc0
+ [cvtclause (Clause [] body ds)] loc0
cvtd (Fun nm cls) = FunMonoBind (vName nm) False (map cvtclause cls) loc0
cvtd (Val p body ds) = PatMonoBind (cvtp p) (GRHSs (cvtguard body)
(cvtdecs ds)
cvtclause :: Meta.Clause (Meta.Pat) (Meta.Exp) (Meta.Dec) -> Hs.Match RdrName
-cvtclause (ps,body,wheres) = Match (map cvtp ps) Nothing
- (GRHSs (cvtguard body) (cvtdecs wheres) void)
+cvtclause (Clause ps body wheres)
+ = Match (map cvtp ps) Nothing (GRHSs (cvtguard body) (cvtdecs wheres) void)
cvtm :: Meta.Mat -> Hs.Match RdrName
-cvtm (p,body,wheres) = Match [cvtp p] Nothing
- (GRHSs (cvtguard body) (cvtdecs wheres) void)
+cvtm (Mat p body wheres)
+ = Match [cvtp p] Nothing (GRHSs (cvtguard body) (cvtdecs wheres) void)
cvtguard :: Meta.Rhs -> [GRHS RdrName]
cvtguard (Guarded pairs) = map cvtpair pairs
ResultStmt (cvt y) loc0] loc0
cvtOverLit :: Lit -> HsOverLit
-cvtOverLit (Int i) = mkHsIntegral (fromInt i)
--- An Int is like an an (overloaded) '3' in a Haskell source program
+cvtOverLit (Integer i) = mkHsIntegral i
+cvtOverLit (Rational r) = mkHsFractional r
+-- An Integer is like an an (overloaded) '3' in a Haskell source program
+-- Similarly 3.5 for fractionals
cvtLit :: Lit -> HsLit
-cvtLit (Char c) = HsChar (ord c)
-cvtLit (CrossStage s) = error "What do we do about crossStage constants?"
+cvtLit (Char c) = HsChar (ord c)
+cvtLit (String s) = HsString (mkFastString s)
cvtp :: Meta.Pat -> Hs.Pat RdrName
cvtp (Plit l)
-- about that!
| otherwise = LitPat (cvtLit l)
cvtp (Pvar s) = VarPat(vName s)
+cvtp (Ptup [p]) = cvtp p
cvtp (Ptup ps) = TuplePat (map cvtp ps) Boxed
cvtp (Pcon s ps) = ConPatIn (cName s) (PrefixCon (map cvtp ps))
cvtp (Ptilde p) = LazyPat (cvtp p)
cvt_pred :: Typ -> HsPred RdrName
cvt_pred ty = case split_ty_app ty of
- (Tvar tc, tys) -> HsClassP (tconName tc) (map cvtType tys)
+ (Tcon (TconName tc), tys) -> HsClassP (tconName tc) (map cvtType tys)
other -> panic "Malformed predicate"
cvtType :: Meta.Typ -> HsType RdrName
trans (Tvar nm, args) = foldl HsAppTy (HsTyVar (tName nm)) args
trans (Tcon tc, args) = foldl HsAppTy (HsTyVar (tc_name tc)) args
+ trans (TForall tvs cxt ty, []) = mkHsForAllTy (Just (cvt_tvs tvs))
+ (cvt_context cxt)
+ (cvtType ty)
+
tc_name (TconName nm) = tconName nm
tc_name Arrow = tconName "->"
tc_name List = tconName "[]"
overloadedLit :: Lit -> Bool
-- True for literals that Haskell treats as overloaded
-overloadedLit (Int l) = True
-overloadedLit l = False
+overloadedLit (Integer l) = True
+overloadedLit (Rational l) = True
+overloadedLit l = False
void :: Type.Type
void = placeHolderType
loc0 :: SrcLoc
loc0 = generatedSrcLoc
-fromInt :: Int -> Integer
-fromInt x = toInteger x
-
-- variable names
vName :: String -> RdrName
vName = mkName varName
--- Constructor function names
+-- Constructor function names; this is Haskell source, hence srcDataName
cName :: String -> RdrName
-cName = mkName dataName
+cName = mkName srcDataName
-- Type variable names
tName :: String -> RdrName
projects / ghc-hetmet.git / blobdiff