\begin{code}
module HscMain ( HscResult(..), hscMain,
#ifdef GHCI
- hscStmt,
+ hscStmt, hscThing,
#endif
initPersistentCompilerState ) where
import ByteCodeGen ( byteCodeGen )
import CoreTidy ( tidyCoreExpr )
import CorePrep ( corePrepExpr )
-import Rename ( renameStmt )
+import Rename ( renameStmt, renameRdrName )
+import RdrName ( rdrNameOcc, setRdrNameOcc )
import RdrHsSyn ( RdrNameStmt )
+import OccName ( dataName, tcClsName,
+ occNameSpace, setOccNameSpace )
import Type ( Type )
import Id ( Id, idName, setGlobalIdDetails )
import IdInfo ( GlobalIdDetails(VanillaGlobal) )
import HscTypes ( InteractiveContext(..) )
import PrelNames ( iNTERACTIVE )
import StringBuffer ( stringToStringBuffer )
+import FastString ( mkFastString )
+import Char ( isUpper )
+import DriverUtil ( split_longest_prefix )
#endif
import HsSyn
import Rename ( checkOldIface, renameModule, closeIfaceDecls )
import Rules ( emptyRuleBase )
import PrelInfo ( wiredInThingEnv, wiredInThings )
-import PrelNames ( vanillaSyntaxMap, knownKeyNames )
+import PrelNames ( knownKeyNames )
import MkIface ( mkFinalIface )
import TcModule
import InstEnv ( emptyInstEnv )
import Bag ( emptyBag )
import Outputable
import Interpreter
-import CmStaticInfo ( GhciMode(..) )
import HscStats ( ppSourceStats )
import HscTypes
import FiniteMap ( FiniteMap, plusFM, emptyFM, addToFM )
import IOExts ( newIORef, readIORef, writeIORef, unsafePerformIO )
import Monad ( when )
-import Maybe ( isJust, fromJust )
+import Maybe ( isJust, fromJust, catMaybes )
import IO
+
+import MkExternalCore ( emitExternalCore )
\end{code}
ModIface -- new iface (if any compilation was done)
Bool -- stub_h exists
Bool -- stub_c exists
+#ifdef GHCI
(Maybe ([UnlinkedBCO],ItblEnv)) -- interpreted code, if any
-
+#else
+ (Maybe ()) -- no interpreted code whatsoever
+#endif
-- no errors or warnings; the individual passes
-- (parse/rename/typecheck) print messages themselves
(pcs_ch, errs_found, (recomp_reqd, maybe_checked_iface))
<- _scc_ "checkOldIface"
- checkOldIface ghci_mode dflags hit hst pcs
- (unJust "hscMain" (ml_hi_file location))
+ checkOldIface ghci_mode dflags hit hst pcs (ml_hi_file location)
source_unchanged maybe_old_iface;
if errs_found then
-- TYPECHECK
maybe_tc_result
- <- typecheckIface dflags pcs_cl hst old_iface (vanillaSyntaxMap, cl_hs_decls);
+ <- typecheckIface dflags pcs_cl hst old_iface cl_hs_decls;
case maybe_tc_result of {
Nothing -> return (HscFail pcs_cl);
= do {
-- what target are we shooting for?
; let toInterp = dopt_HscLang dflags == HscInterpreted
+ ; let toNothing = dopt_HscLang dflags == HscNothing
; when (verbosity dflags >= 1) $
hPutStrLn stderr ("Compiling " ++
-- tidy_details
-- new_iface
+ ; emitExternalCore dflags new_iface tidy_details
-------------------
-- PREPARE FOR CODE GENERATION
-------------------
; (stub_h_exists, stub_c_exists, maybe_bcos, final_iface )
<- if toInterp
+#ifdef GHCI
then do
----------------- Generate byte code ------------------
(bcos,itbl_env) <- byteCodeGen dflags binds
maybe_checked_iface new_iface tidy_details
return ( False, False, Just (bcos,itbl_env), final_iface )
+#else
+ then error "GHC not compiled with interpreter"
+#endif
else do
----------------- Convert to STG ------------------
mkFinalIface ghci_mode dflags location
maybe_checked_iface new_iface tidy_details
- ------------------ Code generation ------------------
- abstractC <- _scc_ "CodeGen"
- codeGen dflags this_mod imported_modules
- cost_centre_info fe_binders
- local_tycons stg_binds
-
- ------------------ Code output -----------------------
- (stub_h_exists, stub_c_exists)
- <- codeOutput dflags this_mod local_tycons
- binds stg_binds
- c_code h_code abstractC
-
- return (stub_h_exists, stub_c_exists, Nothing, final_iface)
+ if toNothing
+ then do
+ return (False, False, Nothing, final_iface)
+ else do
+ ------------------ Code generation ------------------
+ abstractC <- _scc_ "CodeGen"
+ codeGen dflags this_mod imported_modules
+ cost_centre_info fe_binders
+ local_tycons stg_binds
+
+ ------------------ Code output -----------------------
+ (stub_h_exists, stub_c_exists)
+ <- codeOutput dflags this_mod local_tycons
+ binds stg_binds
+ c_code h_code abstractC
+
+ return (stub_h_exists, stub_c_exists, Nothing, final_iface)
; let final_details = tidy_details {md_binds = []}
where
stgBindPairs (StgNonRec _ b r) = [(b,r)]
stgBindPairs (StgRec _ prs) = prs
+
+
\end{code}
Nothing -> return (pcs0, Nothing)
Just parsed_stmt -> do {
- let { notExprStmt (ExprStmt _ _) = False;
- notExprStmt _ = True
+ let { notExprStmt (ExprStmt _ _ _) = False;
+ notExprStmt _ = True
};
if (just_expr && notExprStmt parsed_stmt)
-- Typecheck it
maybe_tc_return <-
if just_expr
- then case rn_stmt of { (syn, ExprStmt e _, decls) ->
+ then case rn_stmt of { (ExprStmt e _ _, decls) ->
typecheckExpr dflags pcs1 hst type_env
- print_unqual iNTERACTIVE (syn,e,decls) }
+ print_unqual iNTERACTIVE (e,decls) }
else typecheckStmt dflags pcs1 hst type_env
print_unqual iNTERACTIVE bound_names rn_stmt
case parseStmt buf PState{ bol = 0#, atbol = 1#,
context = [], glasgow_exts = glaexts,
- loc = mkSrcLoc SLIT("<no file>") 0 } of {
+ loc = mkSrcLoc SLIT("<interactive>") 1 } of {
PFailed err -> do { hPutStrLn stderr (showSDoc err);
-- Not yet implemented in <4.11 freeStringBuffer buf;
%************************************************************************
%* *
+\subsection{Getting information about an identifer}
+%* *
+%************************************************************************
+
+\begin{code}
+#ifdef GHCI
+hscThing -- like hscStmt, but deals with a single identifier
+ :: DynFlags
+ -> HomeSymbolTable
+ -> HomeIfaceTable
+ -> PersistentCompilerState -- IN: persistent compiler state
+ -> InteractiveContext -- Context for compiling
+ -> String -- The identifier
+ -> IO ( PersistentCompilerState,
+ [TyThing] )
+
+hscThing dflags hst hit pcs0 icontext str
+ = do let
+ InteractiveContext {
+ ic_rn_env = rn_env,
+ ic_module = scope_mod } = icontext
+
+ maybe_rdr_name <- myParseIdentifier dflags str
+ case maybe_rdr_name of {
+ Nothing -> return (pcs0, []);
+ Just rdr_name -> do
+
+ -- if the identifier is a constructor (begins with an
+ -- upper-case letter), then we need to consider both
+ -- constructor and type class identifiers.
+ let rdr_names
+ | occNameSpace occ == dataName = [ rdr_name, tccls_name ]
+ | otherwise = [ rdr_name ]
+ where
+ occ = rdrNameOcc rdr_name
+ tccls_occ = setOccNameSpace occ tcClsName
+ tccls_name = setRdrNameOcc rdr_name tccls_occ
+
+ (pcs, unqual, maybe_rn_result) <-
+ renameRdrName dflags hit hst pcs0 scope_mod scope_mod
+ rn_env rdr_names
+
+ case maybe_rn_result of {
+ Nothing -> return (pcs, []);
+ Just (names, decls) -> do {
+
+ maybe_pcs <- typecheckExtraDecls dflags pcs hst unqual
+ iNTERACTIVE decls;
+
+ case maybe_pcs of {
+ Nothing -> return (pcs, []);
+ Just pcs ->
+ let maybe_ty_things = map (lookupType hst (pcs_PTE pcs)) names
+ in
+ return (pcs, catMaybes maybe_ty_things) }
+ }}}
+
+myParseIdentifier dflags str
+ = do buf <- stringToStringBuffer str
+
+ let glaexts | dopt Opt_GlasgowExts dflags = 1#
+ | otherwise = 0#
+
+ case parseIdentifier buf
+ PState{ bol = 0#, atbol = 1#,
+ context = [], glasgow_exts = glaexts,
+ loc = mkSrcLoc SLIT("<interactive>") 1 } of
+
+ PFailed err -> do { hPutStrLn stderr (showSDoc err);
+ freeStringBuffer buf;
+ return Nothing }
+
+ POk _ rdr_name -> do { --should, but can't: freeStringBuffer buf;
+ return (Just rdr_name) }
+#endif
+\end{code}
+
+%************************************************************************
+%* *
\subsection{Initial persistent state}
%* *
%************************************************************************