%
% (c) The GRASP/AQUA Project, Glasgow University, 1993-2000
%
+
\section[GHC_Main]{Main driver for Glasgow Haskell compiler}
\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(..), TyThing(..) )
+import HscTypes ( InteractiveContext(..) )
import PrelNames ( iNTERACTIVE )
import StringBuffer ( stringToStringBuffer )
+import FastString ( mkFastString )
+import Char ( isUpper )
+import DriverUtil ( split_longest_prefix )
#endif
import HsSyn
import Parser
import Lex ( PState(..), ParseResult(..) )
import SrcLoc ( mkSrcLoc )
+import Finder ( findModule )
import Rename ( checkOldIface, renameModule, closeIfaceDecls )
import Rules ( emptyRuleBase )
import PrelInfo ( wiredInThingEnv, wiredInThings )
-import PrelNames ( vanillaSyntaxMap, knownKeyNames )
-import MkIface ( completeIface, writeIface, pprIface )
+import PrelNames ( knownKeyNames )
+import MkIface ( mkFinalIface )
import TcModule
import InstEnv ( emptyInstEnv )
import Desugar
import Bag ( emptyBag )
import Outputable
import Interpreter
-import CmStaticInfo ( GhciMode(..) )
import HscStats ( ppSourceStats )
import HscTypes
import FiniteMap ( FiniteMap, plusFM, emptyFM, addToFM )
import OccName ( OccName )
import Name ( Name, nameModule, nameOccName, getName, isGlobalName )
import NameEnv ( emptyNameEnv, mkNameEnv )
-import Module ( Module, lookupModuleEnvByName )
-import Maybes ( orElse )
+import Module ( Module )
import IOExts ( newIORef, readIORef, writeIORef, unsafePerformIO )
import Monad ( when )
-import Maybe ( isJust )
+import Maybe ( isJust, fromJust, catMaybes )
import IO
+
+import MkExternalCore ( emitExternalCore )
\end{code}
| HscRecomp PersistentCompilerState -- updated PCS
ModDetails -- new details (HomeSymbolTable additions)
ModIface -- new iface (if any compilation was done)
- (Maybe String) -- generated stub_h filename (in TMPDIR)
- (Maybe String) -- generated stub_c filename (in TMPDIR)
+ 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
-> DynFlags
-> Module
-> ModuleLocation -- location info
- -> Bool -- source unchanged?
+ -> Bool -- True <=> source unchanged
+ -> Bool -- True <=> have an object file (for msgs only)
-> Maybe ModIface -- old interface, if available
-> HomeSymbolTable -- for home module ModDetails
-> HomeIfaceTable
-> PersistentCompilerState -- IN: persistent compiler state
-> IO HscResult
-hscMain ghci_mode dflags mod location source_unchanged maybe_old_iface hst hit pcs
+hscMain ghci_mode dflags mod location source_unchanged have_object
+ maybe_old_iface hst hit pcs
= do {
showPass dflags ("Checking old interface for hs = "
++ show (ml_hs_file location)
++ ", hspp = " ++ show (ml_hspp_file location));
(pcs_ch, errs_found, (recomp_reqd, maybe_checked_iface))
- <- checkOldIface ghci_mode dflags hit hst pcs
- (unJust "hscMain" (ml_hi_file location))
+ <- _scc_ "checkOldIface"
+ checkOldIface ghci_mode dflags hit hst pcs (ml_hi_file location)
source_unchanged maybe_old_iface;
if errs_found then
what_next | recomp_reqd || no_old_iface = hscRecomp
| otherwise = hscNoRecomp
;
- what_next ghci_mode dflags mod location maybe_checked_iface
- hst hit pcs_ch
+ what_next ghci_mode dflags have_object mod location
+ maybe_checked_iface hst hit pcs_ch
}}
-- we definitely expect to have the old interface available
-hscNoRecomp ghci_mode dflags mod location (Just old_iface) hst hit pcs_ch
+hscNoRecomp ghci_mode dflags have_object
+ mod location (Just old_iface) hst hit pcs_ch
| ghci_mode == OneShot
= do {
hPutStrLn stderr "compilation IS NOT required";
| otherwise
= do {
when (verbosity dflags >= 1) $
- hPutStrLn stderr ("Skipping " ++ compMsg mod location);
+ hPutStrLn stderr ("Skipping " ++
+ compMsg have_object mod location);
-- CLOSURE
(pcs_cl, closure_errs, cl_hs_decls)
-- 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);
return (HscNoRecomp pcs_tc new_details old_iface)
}}}
-compMsg mod location =
+compMsg use_object mod location =
mod_str ++ take (max 0 (16 - length mod_str)) (repeat ' ')
- ++ " (" ++ unJust "hscRecomp" (ml_hs_file location) ++ ")"
+ ++" ( " ++ unJust "hscRecomp" (ml_hs_file location) ++ ", "
+ ++ (if use_object
+ then unJust "hscRecomp" (ml_obj_file location)
+ else "interpreted")
+ ++ " )"
where mod_str = moduleUserString mod
-hscRecomp ghci_mode dflags mod location maybe_checked_iface hst hit pcs_ch
+hscRecomp ghci_mode dflags have_object
+ mod location maybe_checked_iface hst hit pcs_ch
= do {
- ; when (verbosity dflags >= 1) $
- hPutStrLn stderr ("Compiling " ++ compMsg mod location);
-
-- 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 " ++
+ compMsg (not toInterp) mod location);
-------------------
-- PARSE
<- _scc_ "DeSugar"
deSugar dflags pcs_tc hst this_mod print_unqualified tc_result
+ ; pcs_middle
+ <- if ghci_mode == OneShot
+ then do init_pcs <- initPersistentCompilerState
+ init_prs <- initPersistentRenamerState
+ let
+ rules = pcs_rules pcs_tc
+ orig_tc = prsOrig (pcs_PRS pcs_tc)
+ new_prs = init_prs{ prsOrig=orig_tc }
+
+ orig_tc `seq` rules `seq` new_prs `seq`
+ return init_pcs{ pcs_PRS = new_prs,
+ pcs_rules = rules }
+ else return pcs_tc
+
-------------------
-- SIMPLIFY
-------------------
; simpl_details
<- _scc_ "Core2Core"
- core2core dflags pcs_tc hst dont_discard ds_details
+ core2core dflags pcs_middle hst dont_discard ds_details
-------------------
-- TIDY
-- Meanwhile, tidyCorePgm is careful not to look at cg_info!
; (pcs_simpl, tidy_details)
- <- tidyCorePgm dflags this_mod pcs_tc cg_info simpl_details
+ <- _scc_ "CoreTidy"
+ tidyCorePgm dflags this_mod pcs_middle cg_info simpl_details
+ ; pcs_final <- if ghci_mode == OneShot then initPersistentCompilerState
+ else return pcs_simpl
+
+ -- alive at this point:
+ -- tidy_details
+ -- new_iface
+
+ ; emitExternalCore dflags new_iface tidy_details
-------------------
-- PREPARE FOR CODE GENERATION
-------------------
-- Do saturation and convert to A-normal form
- ; prepd_details <- corePrepPgm dflags tidy_details
+ ; prepd_details <- _scc_ "CorePrep" corePrepPgm dflags tidy_details
-------------------
-- CONVERT TO STG and COMPLETE CODE GENERATION
local_classes = typeEnvClasses env_tc
imported_module_names = map ideclName (hsModuleImports rdr_module)
- imported_modules = map mod_name_to_Module imported_module_names
+
+ mod_name_to_Module nm
+ = do m <- findModule nm ; return (fst (fromJust m))
(h_code,c_code,fe_binders) = foreign_stuff
-
- pit = pcs_PIT pcs_simpl
- mod_name_to_Module :: ModuleName -> Module
- mod_name_to_Module nm
- = let str_mi = lookupModuleEnvByName hit nm `orElse`
- lookupModuleEnvByName pit nm `orElse`
- pprPanic "mod_name_to_Module: no hst or pst mapping for"
- (ppr nm)
- in mi_module str_mi
-
- ; (maybe_stub_h_filename, maybe_stub_c_filename,
- maybe_bcos, final_iface )
+ ; imported_modules <- mapM mod_name_to_Module imported_module_names
+
+ ; (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
mkFinalIface ghci_mode dflags location
maybe_checked_iface new_iface tidy_details
- return ( Nothing, Nothing,
- Just (bcos,itbl_env), final_iface )
+ 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 -----------------------
- (maybe_stub_h_name, maybe_stub_c_name)
- <- codeOutput dflags this_mod local_tycons
- binds stg_binds
- c_code h_code abstractC
-
- return ( maybe_stub_h_name, maybe_stub_c_name,
- 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 = []}
-- and the answer is ...
- ; return (HscRecomp pcs_simpl
+ ; return (HscRecomp pcs_final
final_details
final_iface
- maybe_stub_h_filename maybe_stub_c_filename
+ stub_h_exists stub_c_exists
maybe_bcos)
}}}}}}}
-
-
-mkFinalIface ghci_mode dflags location
- maybe_old_iface new_iface new_details
- = case completeIface maybe_old_iface new_iface new_details of
-
- (new_iface, Nothing) -- no change in the interfacfe
- -> do when (dopt Opt_D_dump_hi_diffs dflags)
- (printDump (text "INTERFACE UNCHANGED"))
- dumpIfSet_dyn dflags Opt_D_dump_hi
- "UNCHANGED FINAL INTERFACE" (pprIface new_iface)
- return new_iface
-
- (new_iface, Just sdoc_diffs)
- -> do dumpIfSet_dyn dflags Opt_D_dump_hi_diffs "INTERFACE HAS CHANGED"
- sdoc_diffs
- dumpIfSet_dyn dflags Opt_D_dump_hi "NEW FINAL INTERFACE"
- (pprIface new_iface)
-
- -- Write the interface file, if not in interactive mode
- when (ghci_mode /= Interactive)
- (writeIface (unJust "hscRecomp:hi" (ml_hi_file location))
- new_iface)
- return new_iface
-
-
myParseModule dflags src_filename
= do -------------------------- Parser ----------------
showPass dflags "Parser"
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}
%* *
%************************************************************************
grab names = foldl add emptyFM names
add env name
= addToFM env (moduleName (nameModule name), nameOccName name) name
-
-
-initRules :: PackageRuleBase
-initRules = emptyRuleBase
-{- SHOULD BE (ish)
- foldl add emptyVarEnv builtinRules
- where
- add env (name,rule)
- = extendRuleBase env name rule
--}
\end{code}
projects / ghc-hetmet.git / blobdiff