\begin{code}
module HscMain ( HscResult(..), hscMain,
#ifdef GHCI
- hscExpr, hscTypeExpr,
+ hscExpr,
#endif
initPersistentCompilerState ) where
#ifdef GHCI
import RdrHsSyn ( RdrNameHsExpr )
-import CoreToStg ( coreToStgExpr )
import StringBuffer ( stringToStringBuffer, freeStringBuffer )
import Unique ( Uniquable(..) )
import Type ( splitTyConApp_maybe )
import PrelNames ( ioTyConKey )
+import ByteCodeGen ( byteCodeGen )
#endif
import HsSyn
import Parser
import Lex ( PState(..), ParseResult(..) )
import SrcLoc ( mkSrcLoc )
-import Rename
+import Rename ( checkOldIface, renameModule, renameExpr, closeIfaceDecls )
import Rules ( emptyRuleBase )
import PrelInfo ( wiredInThingEnv, wiredInThings )
import PrelNames ( knownKeyNames )
import SimplCore
import CoreUtils ( coreBindsSize )
import CoreTidy ( tidyCorePgm )
-import CoreToStg ( topCoreBindsToStg )
+import CoreSat
+import CoreToStg ( coreToStg, coreExprToStg )
import StgSyn ( collectFinalStgBinders )
import SimplStg ( stg2stg )
import CodeGen ( codeGen )
import Monad ( when )
import Maybe ( isJust )
-import IO ( hPutStrLn, stderr )
+import IO
\end{code}
++ ", hspp = " ++ show (ml_hspp_file location));
(pcs_ch, errs_found, (recomp_reqd, maybe_checked_iface))
- <- checkOldIface dflags hit hst pcs
+ <- checkOldIface ghci_mode dflags hit hst pcs
(unJust "hscMain" (ml_hi_file location))
source_unchanged maybe_old_iface;
-- we definitely expect to have the old interface available
hscNoRecomp ghci_mode dflags location (Just old_iface) hst hit pcs_ch
| ghci_mode == OneShot
- = let bomb = panic "hscNoRecomp:OneShot"
- in return (HscNoRecomp pcs_ch bomb bomb)
- | otherwise
= do {
hPutStrLn stderr "compilation IS NOT required";
+ let { bomb = panic "hscNoRecomp:OneShot" };
+ return (HscNoRecomp pcs_ch bomb bomb)
+ }
+ | otherwise
+ = do {
+ hPutStr stderr "compilation IS NOT required";
+ when (verbosity dflags /= 1) $ hPutStrLn stderr "";
-- CLOSURE
(pcs_cl, closure_errs, cl_hs_decls)
hscRecomp ghci_mode dflags location maybe_checked_iface hst hit pcs_ch
= do {
; when (verbosity dflags >= 1) $
- hPutStrLn stderr "compilation IS required";
+ hPutStr stderr "compilation IS required";
+ -- mode -v1 tries to keep everything on one line
+ when (verbosity dflags > 1) $
+ hPutStrLn stderr "";
-- what target are we shooting for?
; let toInterp = dopt_HscLang dflags == HscInterpreted
buf <- hGetStringBuffer True{-expand tabs-} src_filename
let glaexts | dopt Opt_GlasgowExts dflags = 1#
- | otherwise = 0#
+ | otherwise = 0#
case parse buf PState{ bol = 0#, atbol = 1#,
context = [], glasgow_exts = glaexts,
dsThenSimplThenTidy dflags pcs hst this_mod print_unqual is_exported tc_result
- = do -------------------------- Desugaring ----------------
+ = do ------------------ Desugaring ---------------------------------
-- _scc_ "DeSugar"
(desugared, rules, h_code, c_code, fe_binders)
<- deSugar dflags pcs hst this_mod print_unqual tc_result
- -------------------------- Main Core-language transformations ----------------
+ ------------------ Main Core-language transformations ---------
-- _scc_ "Core2Core"
(simplified, orphan_rules)
<- core2core dflags pcs hst is_exported desugared rules
+ -- Do saturation and convert to A-normal form
+ -- NOTE: future passes cannot transform the syntax, only annotate it
+ saturated <- coreSatPgm dflags simplified
+
-- Do the final tidy-up
(pcs', tidy_binds, tidy_orphan_rules)
- <- tidyCorePgm dflags this_mod pcs simplified orphan_rules
+ <- tidyCorePgm dflags this_mod pcs saturated orphan_rules
return (pcs', tidy_binds, tidy_orphan_rules, (fe_binders,h_code,c_code))
-- simplifier, which for reasons I don't understand, persists
-- thoroughout code generation
+ --let bcos = byteCodeGen tidy_binds
+ --putStrLn (showSDoc (vcat (map ppr bcos)))
+
-- _scc_ "Core2Stg"
- stg_binds <- topCoreBindsToStg dflags this_mod tidy_binds
+ stg_binds <- coreToStg dflags this_mod tidy_binds
-- _scc_ "Stg2Stg"
(stg_binds2, cost_centre_info) <- stg2stg dflags this_mod stg_binds
-> PersistentCompilerState -- IN: persistent compiler state
-> Module -- Context for compiling
-> String -- The expression
- -> IO ( PersistentCompilerState, Maybe UnlinkedIExpr )
+ -> IO ( PersistentCompilerState,
+ Maybe (UnlinkedIExpr, PrintUnqualified, Type) )
hscExpr dflags hst hit pcs0 this_module expr
= do {
- -- parse, rename & typecheck the expression
- (pcs1, maybe_tc_result)
- <- hscExprFrontEnd dflags hst hit pcs0 this_module expr;
+ maybe_parsed <- hscParseExpr dflags expr;
+ case maybe_parsed of
+ Nothing -> return (pcs0, Nothing)
+ Just parsed_expr -> do {
- case maybe_tc_result of {
- Nothing -> return (pcs1, Nothing);
- Just (print_unqual, tc_expr, ty) -> do {
+ -- Rename it
+ (pcs1, maybe_renamed_expr) <-
+ renameExpr dflags hit hst pcs0 this_module parsed_expr;
+ case maybe_renamed_expr of
+ Nothing -> return (pcs1, Nothing)
+ Just (print_unqual, rn_expr) -> do {
+
+ -- Typecheck it
+ maybe_tc_return
+ <- typecheckExpr dflags pcs1 hst print_unqual this_module rn_expr;
+ case maybe_tc_return of {
+ Nothing -> return (pcs1, Nothing);
+ Just (pcs2, tc_expr, ty) -> do
-- if it isn't an IO-typed expression,
-- wrap "print" around it & recompile...
};
if (not is_IO_type)
- then hscExpr dflags hst hit pcs1 this_module
- ("print (" ++ expr ++ ")")
+ then do (new_pcs, maybe_stuff)
+ <- hscExpr dflags hst hit pcs2 this_module
+ ("print (" ++ expr ++ ")")
+ case maybe_stuff of
+ Nothing -> return (new_pcs, maybe_stuff)
+ Just (expr, _, _) ->
+ return (new_pcs, Just (expr, print_unqual, ty))
else do
-- Desugar it
- ds_expr <- deSugarExpr dflags pcs1 hst this_module
+ ds_expr <- deSugarExpr dflags pcs2 hst this_module
print_unqual tc_expr;
-- Simplify it
- simpl_expr <- simplifyExpr dflags pcs1 hst ds_expr;
+ simpl_expr <- simplifyExpr dflags pcs2 hst ds_expr;
+
+ -- Saturate it
+ sat_expr <- coreSatExpr dflags simpl_expr;
-- Convert to STG
- stg_expr <- coreToStgExpr dflags simpl_expr;
+ let stg_expr = coreExprToStg sat_expr;
- -- ToDo: need to do StgVarInfo? or SRTs?
+ -- ToDo: need to do SRTs?
-- Convert to InterpSyn
unlinked_iexpr <- stgExprToInterpSyn dflags stg_expr;
- return (pcs1, Just unlinked_iexpr);
- }}}
-
-hscExprFrontEnd
- :: DynFlags
- -> HomeSymbolTable
- -> HomeIfaceTable
- -> PersistentCompilerState -- IN: persistent compiler state
- -> Module -- Context for compiling
- -> String -- The expression
- -> IO ( PersistentCompilerState,
- Maybe (PrintUnqualified,TypecheckedHsExpr,Type)
- )
-hscExprFrontEnd dflags hst hit pcs0 this_module expr
- = do { -- Parse it
- maybe_parsed <- hscParseExpr dflags expr;
- case maybe_parsed of
- Nothing -> return (pcs0, Nothing)
- Just parsed_expr -> do {
-
- -- Rename it
- (pcs1, maybe_renamed_expr) <-
- renameExpr dflags hit hst pcs0 this_module parsed_expr;
- case maybe_renamed_expr of
- Nothing -> return (pcs1, Nothing)
- Just (print_unqual, rn_expr) -> do {
-
- -- Typecheck it
- maybe_tc_return
- <- typecheckExpr dflags pcs1 hst print_unqual this_module rn_expr;
- case maybe_tc_return of
- Nothing -> return (pcs1, Nothing)
- Just (pcs2, tc_expr, ty) ->
- return (pcs2, Just (print_unqual, tc_expr, ty))
- }}}
-
-hscTypeExpr
- :: DynFlags
- -> HomeSymbolTable
- -> HomeIfaceTable
- -> PersistentCompilerState -- IN: persistent compiler state
- -> Module -- Context for compiling
- -> String -- The expression
- -> IO (PersistentCompilerState, Maybe (PrintUnqualified, Type))
-hscTypeExpr dflags hst hit pcs0 this_module expr
- = do (pcs1, maybe_tc_result)
- <- hscExprFrontEnd dflags hst hit pcs0 this_module expr
- case maybe_tc_result of
- Nothing -> return (pcs1, Nothing)
- Just (print_unqual,_,ty) -> return (pcs1, Just (print_unqual,ty))
+ return (pcs2, Just (unlinked_iexpr, print_unqual, ty));
+ }}}}
hscParseExpr :: DynFlags -> String -> IO (Maybe RdrNameHsExpr)
hscParseExpr dflags str
initPersistentRenamerState :: IO PersistentRenamerState
= do ns <- mkSplitUniqSupply 'r'
return (
- PRS { prsOrig = Orig { origNames = initOrigNames,
+ PRS { prsOrig = Orig { origNS = ns,
+ origNames = initOrigNames,
origIParam = emptyFM },
prsDecls = (emptyNameEnv, 0),
prsInsts = (emptyBag, 0),
- prsRules = (emptyBag, 0),
- prsNS = ns
+ prsRules = (emptyBag, 0)
}
)