CanItFail(..), EquationInfo(..), MatchResult(..),
EqnNo, EqnSet,
+ tidyLitPat, tidyNPat,
+
mkDsLet, mkDsLets,
cantFailMatchResult, extractMatchResult,
mkCoPrimCaseMatchResult, mkCoAlgCaseMatchResult,
mkErrorAppDs, mkNilExpr, mkConsExpr,
+ mkStringLit, mkStringLitFS, mkIntegerLit,
mkSelectorBinds, mkTupleExpr, mkTupleSelector,
import {-# SOURCE #-} Match ( matchSimply )
-import HsSyn ( OutPat(..) )
-import TcHsSyn ( TypecheckedPat )
-import DsHsSyn ( outPatType, collectTypedPatBinders )
+import HsSyn
+import TcHsSyn ( TypecheckedPat, outPatType, collectTypedPatBinders )
import CoreSyn
import DsMonad
-import CoreUtils ( coreExprType )
+import CoreUtils ( exprType, mkIfThenElse )
import PrelInfo ( iRREFUT_PAT_ERROR_ID )
+import MkId ( rebuildConArgs )
import Id ( idType, Id, mkWildId )
-import Const ( Literal(..), Con(..) )
-import TyCon ( isNewTyCon, tyConDataCons )
-import DataCon ( DataCon, StrictnessMark, maybeMarkedUnboxed, dataConStrictMarks,
- dataConArgTys, dataConId
- )
-import Type ( mkFunTy, isUnLiftedType, splitAlgTyConApp, unUsgTy,
- Type
- )
-import TysWiredIn ( unitDataCon, tupleCon, stringTy, unitTy, unitDataCon,
- nilDataCon, consDataCon
- )
+import Literal ( Literal(..), inIntRange, tARGET_MAX_INT )
+import TyCon ( isNewTyCon, tyConDataCons, isRecursiveTyCon )
+import DataCon ( DataCon, dataConStrictMarks, dataConId,
+ dataConSourceArity )
+import Type ( mkFunTy, isUnLiftedType, Type, splitTyConApp )
+import TcType ( tcTyConAppTyCon, isIntTy, isFloatTy, isDoubleTy )
+import TysPrim ( intPrimTy, charPrimTy, floatPrimTy, doublePrimTy )
+import TysWiredIn ( nilDataCon, consDataCon,
+ tupleCon,
+ unitDataConId, unitTy,
+ charTy, charDataCon,
+ intTy, intDataCon, smallIntegerDataCon,
+ floatDataCon,
+ doubleDataCon,
+ stringTy, isPArrFakeCon )
+import BasicTypes ( Boxity(..) )
import UniqSet ( mkUniqSet, minusUniqSet, isEmptyUniqSet, UniqSet )
+import PrelNames ( unpackCStringName, unpackCStringUtf8Name,
+ plusIntegerName, timesIntegerName,
+ lengthPName, indexPName )
import Outputable
+import UnicodeUtil ( stringToUtf8 )
+import Util ( isSingleton )
+\end{code}
+
+
+
+%************************************************************************
+%* *
+\subsection{Tidying lit pats}
+%* *
+%************************************************************************
+
+\begin{code}
+tidyLitPat :: HsLit -> TypecheckedPat -> TypecheckedPat
+tidyLitPat (HsChar c) pat = ConPat charDataCon charTy [] [] [LitPat (HsCharPrim c) charPrimTy]
+tidyLitPat lit pat = pat
+
+tidyNPat :: HsLit -> Type -> TypecheckedPat -> TypecheckedPat
+tidyNPat (HsString s) _ pat
+ | _LENGTH_ s <= 1 -- Short string literals only
+ = foldr (\c pat -> ConPat consDataCon stringTy [] [] [mk_char_lit c,pat])
+ (ConPat nilDataCon stringTy [] [] []) (_UNPK_INT_ s)
+ -- The stringTy is the type of the whole pattern, not
+ -- the type to instantiate (:) or [] with!
+ where
+ mk_char_lit c = ConPat charDataCon charTy [] [] [LitPat (HsCharPrim c) charPrimTy]
+
+tidyNPat lit lit_ty default_pat
+ | isIntTy lit_ty = ConPat intDataCon lit_ty [] [] [LitPat (mk_int lit) intPrimTy]
+ | isFloatTy lit_ty = ConPat floatDataCon lit_ty [] [] [LitPat (mk_float lit) floatPrimTy]
+ | isDoubleTy lit_ty = ConPat doubleDataCon lit_ty [] [] [LitPat (mk_double lit) doublePrimTy]
+ | otherwise = default_pat
+
+ where
+ mk_int (HsInteger i) = HsIntPrim i
+
+ mk_float (HsInteger i) = HsFloatPrim (fromInteger i)
+ mk_float (HsRat f _) = HsFloatPrim f
+
+ mk_double (HsInteger i) = HsDoublePrim (fromInteger i)
+ mk_double (HsRat f _) = HsDoublePrim f
\end{code}
%************************************************************************
%* *
-\subsection{ Building lets}
+\subsection{Building lets}
%* *
%************************************************************************
where
mk_case fail
= mapDs (mk_alt fail) match_alts `thenDs` \ alts ->
- returnDs (Case (Var var) var (alts ++ [(DEFAULT, [], fail)]))
+ returnDs (Case (Var var) var ((DEFAULT, [], fail) : alts))
mk_alt fail (lit, MatchResult _ body_fn) = body_fn fail `thenDs` \ body ->
- returnDs (Literal lit, [], body)
+ returnDs (LitAlt lit, [], body)
mkCoAlgCaseMatchResult :: Id -- Scrutinee
mkCoAlgCaseMatchResult var match_alts
| isNewTyCon tycon -- Newtype case; use a let
- = ASSERT( newtype_sanity )
- mkCoLetsMatchResult [coercion_bind] match_result
+ = ASSERT( null (tail match_alts) && null (tail arg_ids) )
+ mkCoLetsMatchResult [NonRec arg_id newtype_rhs] match_result
+
+ | isPArrFakeAlts match_alts -- Sugared parallel array; use a literal case
+ = MatchResult CanFail mk_parrCase
| otherwise -- Datatype case; use a case
= MatchResult fail_flag mk_case
where
-- Common stuff
scrut_ty = idType var
- (tycon, tycon_arg_tys, _) = splitAlgTyConApp scrut_ty
+ tycon = tcTyConAppTyCon scrut_ty -- Newtypes must be opaque here
-- Stuff for newtype
- (con_id, arg_ids, match_result) = head match_alts
- arg_id = head arg_ids
- coercion_bind = NonRec arg_id
- (Note (Coerce (idType arg_id) scrut_ty) (Var var))
- newtype_sanity = null (tail match_alts) && null (tail arg_ids)
-
+ (_, arg_ids, match_result) = head match_alts
+ arg_id = head arg_ids
+
+ newtype_rhs | isRecursiveTyCon tycon -- Recursive case; need a case
+ = Note (Coerce (idType arg_id) scrut_ty) (Var var)
+ | otherwise -- Normal case (newtype is transparent)
+ = Var var
+
-- Stuff for data types
data_cons = tyConDataCons tycon
wild_var = mkWildId (idType var)
mk_case fail = mapDs (mk_alt fail) match_alts `thenDs` \ alts ->
- returnDs (Case (Var var) wild_var (alts ++ mk_default fail))
+ returnDs (Case (Var var) wild_var (mk_default fail ++ alts))
mk_alt fail (con, args, MatchResult _ body_fn)
- = body_fn fail `thenDs` \ body ->
- rebuildConArgs con args (dataConStrictMarks con) body
- `thenDs` \ (body', real_args) ->
- returnDs (DataCon con, real_args, body')
+ = body_fn fail `thenDs` \ body ->
+ getUniquesDs `thenDs` \ us ->
+ let
+ (binds, real_args) = rebuildConArgs args (dataConStrictMarks con) us
+ in
+ returnDs (DataAlt con, real_args, mkDsLets binds body)
mk_default fail | exhaustive_case = []
| otherwise = [(DEFAULT, [], fail)]
un_mentioned_constructors
= mkUniqSet data_cons `minusUniqSet` mkUniqSet [ con | (con, _, _) <- match_alts]
exhaustive_case = isEmptyUniqSet un_mentioned_constructors
+
+ -- Stuff for parallel arrays
+ --
+ -- * the following is to desugar cases over fake constructors for
+ -- parallel arrays, which are introduced by `tidy1' in the `PArrPat'
+ -- case
+ --
+ -- Concerning `isPArrFakeAlts':
+ --
+ -- * it is *not* sufficient to just check the type of the type
+ -- constructor, as we have to be careful not to confuse the real
+ -- representation of parallel arrays with the fake constructors;
+ -- moreover, a list of alternatives must not mix fake and real
+ -- constructors (this is checked earlier on)
+ --
+ -- FIXME: We actually go through the whole list and make sure that
+ -- either all or none of the constructors are fake parallel
+ -- array constructors. This is to spot equations that mix fake
+ -- constructors with the real representation defined in
+ -- `PrelPArr'. It would be nicer to spot this situation
+ -- earlier and raise a proper error message, but it can really
+ -- only happen in `PrelPArr' anyway.
+ --
+ isPArrFakeAlts [(dcon, _, _)] = isPArrFakeCon dcon
+ isPArrFakeAlts ((dcon, _, _):alts) =
+ case (isPArrFakeCon dcon, isPArrFakeAlts alts) of
+ (True , True ) -> True
+ (False, False) -> False
+ _ ->
+ panic "DsUtils: You may not mix `[:...:]' with `PArr' patterns"
+ --
+ mk_parrCase fail =
+ dsLookupGlobalValue lengthPName `thenDs` \lengthP ->
+ unboxAlt `thenDs` \alt ->
+ returnDs (Case (len lengthP) (mkWildId intTy) [alt])
+ where
+ elemTy = case splitTyConApp (idType var) of
+ (_, [elemTy]) -> elemTy
+ _ -> panic panicMsg
+ panicMsg = "DsUtils.mkCoAlgCaseMatchResult: not a parallel array?"
+ len lengthP = mkApps (Var lengthP) [Type elemTy, Var var]
+ --
+ unboxAlt =
+ newSysLocalDs intPrimTy `thenDs` \l ->
+ dsLookupGlobalValue indexPName `thenDs` \indexP ->
+ mapDs (mkAlt indexP) match_alts `thenDs` \alts ->
+ returnDs (DataAlt intDataCon, [l], (Case (Var l) wild (dft : alts)))
+ where
+ wild = mkWildId intPrimTy
+ dft = (DEFAULT, [], fail)
+ --
+ -- each alternative matches one array length (corresponding to one
+ -- fake array constructor), so the match is on a literal; each
+ -- alternative's body is extended by a local binding for each
+ -- constructor argument, which are bound to array elements starting
+ -- with the first
+ --
+ mkAlt indexP (con, args, MatchResult _ bodyFun) =
+ bodyFun fail `thenDs` \body ->
+ returnDs (LitAlt lit, [], mkDsLets binds body)
+ where
+ lit = MachInt $ toInteger (dataConSourceArity con)
+ binds = [NonRec arg (indexExpr i) | (i, arg) <- zip [1..] args]
+ --
+ indexExpr i = mkApps (Var indexP) [Type elemTy, Var var, toInt i]
+ toInt i = mkConApp intDataCon [Lit $ MachInt i]
\end{code}
-%
-For each constructor we match on, we might need to re-pack some
-of the strict fields if they are unpacked in the constructor.
-%
-\begin{code}
-rebuildConArgs
- :: DataCon -- the con we're matching on
- -> [Id] -- the source-level args
- -> [StrictnessMark] -- the strictness annotations (per-arg)
- -> CoreExpr -- the body
- -> DsM (CoreExpr, [Id])
-
-rebuildConArgs con [] stricts body = returnDs (body, [])
-rebuildConArgs con (arg:args) stricts body | isTyVar arg
- = rebuildConArgs con args stricts body `thenDs` \ (body', args') ->
- returnDs (body',arg:args')
-rebuildConArgs con (arg:args) (str:stricts) body
- = rebuildConArgs con args stricts body `thenDs` \ (body', real_args) ->
- case maybeMarkedUnboxed str of
- Just (pack_con, tys) ->
- let id_tys = dataConArgTys pack_con ty_args in
- newSysLocalsDs id_tys `thenDs` \ unpacked_args ->
- returnDs (
- mkDsLet (NonRec arg (Con (DataCon pack_con)
- (map Type ty_args ++
- map Var unpacked_args))) body',
- unpacked_args ++ real_args
- )
- _ -> returnDs (body', arg:real_args)
-
- where ty_args = case splitAlgTyConApp (idType arg) of { (_,args,_) -> args }
-\end{code}
+
%************************************************************************
%* *
let
full_msg = showSDoc (hcat [ppr src_loc, text "|", text msg])
in
- returnDs (mkApps (Var err_id) [(Type . unUsgTy) ty, mkStringLit full_msg])
- -- unUsgTy *required* -- KSW 1999-04-07
+ mkStringLit full_msg `thenDs` \ core_msg ->
+ returnDs (mkApps (Var err_id) [Type ty, core_msg])
+\end{code}
+
+
+*************************************************************
+%* *
+\subsection{Making literals}
+%* *
+%************************************************************************
+
+\begin{code}
+mkIntegerLit :: Integer -> DsM CoreExpr
+mkIntegerLit i
+ | inIntRange i -- Small enough, so start from an Int
+ = returnDs (mkSmallIntegerLit i)
+
+-- Special case for integral literals with a large magnitude:
+-- They are transformed into an expression involving only smaller
+-- integral literals. This improves constant folding.
+
+ | otherwise -- Big, so start from a string
+ = dsLookupGlobalValue plusIntegerName `thenDs` \ plus_id ->
+ dsLookupGlobalValue timesIntegerName `thenDs` \ times_id ->
+ let
+ plus a b = Var plus_id `App` a `App` b
+ times a b = Var times_id `App` a `App` b
+
+ -- Transform i into (x1 + (x2 + (x3 + (...) * b) * b) * b) with abs xi <= b
+ horner :: Integer -> Integer -> CoreExpr
+ horner b i | abs q <= 1 = if r == 0 || r == i
+ then mkSmallIntegerLit i
+ else mkSmallIntegerLit r `plus` mkSmallIntegerLit (i-r)
+ | r == 0 = horner b q `times` mkSmallIntegerLit b
+ | otherwise = mkSmallIntegerLit r `plus` (horner b q `times` mkSmallIntegerLit b)
+ where
+ (q,r) = i `quotRem` b
+
+ in
+ returnDs (horner tARGET_MAX_INT i)
+
+mkSmallIntegerLit i = mkConApp smallIntegerDataCon [mkIntLit i]
+
+mkStringLit :: String -> DsM CoreExpr
+mkStringLit str = mkStringLitFS (_PK_ str)
+
+mkStringLitFS :: FAST_STRING -> DsM CoreExpr
+mkStringLitFS str
+ | _NULL_ str
+ = returnDs (mkNilExpr charTy)
+
+ | _LENGTH_ str == 1
+ = let
+ the_char = mkConApp charDataCon [mkLit (MachChar (_HEAD_INT_ str))]
+ in
+ returnDs (mkConsExpr charTy the_char (mkNilExpr charTy))
+
+ | all safeChar chars
+ = dsLookupGlobalValue unpackCStringName `thenDs` \ unpack_id ->
+ returnDs (App (Var unpack_id) (Lit (MachStr str)))
+
+ | otherwise
+ = dsLookupGlobalValue unpackCStringUtf8Name `thenDs` \ unpack_id ->
+ returnDs (App (Var unpack_id) (Lit (MachStr (_PK_ (stringToUtf8 chars)))))
+
+ where
+ chars = _UNPK_INT_ str
+ safeChar c = c >= 1 && c <= 0xFF
\end{code}
+
%************************************************************************
%* *
\subsection[mkSelectorBind]{Make a selector bind}
= returnDs [(v, val_expr)]
mkSelectorBinds pat val_expr
- | length binders == 1 || is_simple_pat pat
- = newSysLocalDs (coreExprType val_expr) `thenDs` \ val_var ->
+ | isSingleton binders || is_simple_pat pat
+ = newSysLocalDs (exprType val_expr) `thenDs` \ val_var ->
-- For the error message we don't use mkErrorAppDs to avoid
-- duplicating the string literal each time
let
full_msg = showSDoc (hcat [ppr src_loc, text "|", ppr pat])
in
+ mkStringLit full_msg `thenDs` \ core_msg ->
mapDs (mk_bind val_var msg_var) binders `thenDs` \ binds ->
returnDs ( (val_var, val_expr) :
- (msg_var, mkStringLit full_msg) :
+ (msg_var, core_msg) :
binds )
| otherwise
- = mkErrorAppDs iRREFUT_PAT_ERROR_ID tuple_ty (showSDoc (ppr pat))
- `thenDs` \ error_expr ->
- matchSimply val_expr LetMatch pat local_tuple error_expr
- `thenDs` \ tuple_expr ->
- newSysLocalDs tuple_ty
- `thenDs` \ tuple_var ->
+ = mkErrorAppDs iRREFUT_PAT_ERROR_ID
+ tuple_ty (showSDoc (ppr pat)) `thenDs` \ error_expr ->
+ matchSimply val_expr PatBindRhs pat local_tuple error_expr `thenDs` \ tuple_expr ->
+ newSysLocalDs tuple_ty `thenDs` \ tuple_var ->
let
- mk_tup_bind binder =
- (binder, mkTupleSelector binders binder tuple_var (Var tuple_var))
+ mk_tup_bind binder
+ = (binder, mkTupleSelector binders binder tuple_var (Var tuple_var))
in
returnDs ( (tuple_var, tuple_expr) : map mk_tup_bind binders )
where
binders = collectTypedPatBinders pat
local_tuple = mkTupleExpr binders
- tuple_ty = coreExprType local_tuple
+ tuple_ty = exprType local_tuple
mk_bind scrut_var msg_var bndr_var
-- (mk_bind sv bv) generates
-- bv = case sv of { pat -> bv; other -> error-msg }
-- Remember, pat binds bv
- = matchSimply (Var scrut_var) LetMatch pat
+ = matchSimply (Var scrut_var) PatBindRhs pat
(Var bndr_var) error_expr `thenDs` \ rhs_expr ->
returnDs (bndr_var, rhs_expr)
where
binder_ty = idType bndr_var
error_expr = mkApps (Var iRREFUT_PAT_ERROR_ID) [Type binder_ty, Var msg_var]
- is_simple_pat (TuplePat ps True{-boxed-}) = all is_triv_pat ps
+ is_simple_pat (TuplePat ps Boxed) = all is_triv_pat ps
is_simple_pat (ConPat _ _ _ _ ps) = all is_triv_pat ps
is_simple_pat (VarPat _) = True
is_simple_pat (RecPat _ _ _ _ ps) = and [is_triv_pat p | (_,p,_) <- ps]
@mkTupleExpr@ builds a tuple; the inverse to @mkTupleSelector@. If it
-has only one element, it is the identity function. Notice we must
-throw out any usage annotation on the outside of an Id.
+has only one element, it is the identity function.
\begin{code}
mkTupleExpr :: [Id] -> CoreExpr
-mkTupleExpr [] = mkConApp unitDataCon []
+mkTupleExpr [] = Var unitDataConId
mkTupleExpr [id] = Var id
-mkTupleExpr ids = mkConApp (tupleCon (length ids))
- (map (Type . unUsgTy . idType) ids ++ [ Var i | i <- ids ])
+mkTupleExpr ids = mkConApp (tupleCon Boxed (length ids))
+ (map (Type . idType) ids ++ [ Var i | i <- ids ])
\end{code}
mkTupleSelector vars the_var scrut_var scrut
= ASSERT( not (null vars) )
- Case scrut scrut_var [(DataCon (tupleCon (length vars)), vars, Var the_var)]
+ Case scrut scrut_var [(DataAlt (tupleCon Boxed (length vars)), vars, Var the_var)]
\end{code}
= newFailLocalDs (unitTy `mkFunTy` ty) `thenDs` \ fail_fun_var ->
newSysLocalDs unitTy `thenDs` \ fail_fun_arg ->
returnDs (NonRec fail_fun_var (Lam fail_fun_arg expr),
- App (Var fail_fun_var) (mkConApp unitDataCon []))
+ App (Var fail_fun_var) (Var unitDataConId))
| otherwise
= newFailLocalDs ty `thenDs` \ fail_var ->
returnDs (NonRec fail_var expr, Var fail_var)
where
- ty = coreExprType expr
+ ty = exprType expr
\end{code}
-
projects / ghc-hetmet.git / blobdiff