#include "HsVersions.h"
import Maybe ( isJust )
-import Monad ( when )
-import IO ( hPutStr, hPutStrLn, hClose, stderr,
- openFile, IOMode(..) )
+import IO ( hPutStrLn, stderr )
import HsSyn
-import RdrHsSyn ( RdrNameHsModule )
-import FastString ( unpackFS )
import StringBuffer ( hGetStringBuffer )
-import Parser ( parse )
+import Parser
import Lex ( PState(..), ParseResult(..) )
import SrcLoc ( mkSrcLoc )
import Rename ( renameModule, checkOldIface, closeIfaceDecls )
-
import Rules ( emptyRuleBase )
-import PrelInfo ( wiredInThings )
+import PrelInfo ( wiredInThingEnv, wiredInThings )
import PrelNames ( knownKeyNames )
-import PrelRules ( builtinRules )
import MkIface ( completeIface, mkModDetailsFromIface, mkModDetails,
- writeIface )
+ writeIface, pprIface )
import TcModule ( TcResults(..), typecheckModule )
-import TcEnv ( tcEnvTyCons, tcEnvClasses )
import InstEnv ( emptyInstEnv )
import Desugar ( deSugar )
import SimplCore ( core2core )
import CodeGen ( codeGen )
import CodeOutput ( codeOutput )
-import Module ( ModuleName, moduleNameUserString,
- moduleUserString, moduleName, emptyModuleEnv,
- extendModuleEnv )
+import Module ( ModuleName, moduleName, mkModuleInThisPackage )
import CmdLineOpts
-import ErrUtils ( ghcExit, doIfSet, dumpIfSet_dyn )
+import ErrUtils ( dumpIfSet_dyn, showPass )
+import Util ( unJust )
import UniqSupply ( mkSplitUniqSupply )
import Bag ( emptyBag )
import Outputable
-import Char ( isSpace )
-import StgInterp ( stgToInterpSyn )
+import Interpreter ( UnlinkedIBind, ItblEnv, stgToInterpSyn )
import HscStats ( ppSourceStats )
import HscTypes ( ModDetails, ModIface(..), PersistentCompilerState(..),
- PersistentRenamerState(..), WhatsImported(..),
- HomeSymbolTable, PackageSymbolTable, ImportVersion,
- GenAvailInfo(..), RdrAvailInfo, OrigNameEnv(..),
- PackageRuleBase, HomeIfaceTable, PackageIfaceTable,
- extendTypeEnv, groupTyThings, TypeEnv, TyThing,
+ PersistentRenamerState(..), ModuleLocation(..),
+ HomeSymbolTable,
+ OrigNameEnv(..), PackageRuleBase, HomeIfaceTable,
typeEnvClasses, typeEnvTyCons, emptyIfaceTable )
-import RnMonad ( ExportItem, ParsedIface(..) )
-import CmSummarise ( ModSummary(..), name_of_summary, ms_get_imports,
- mimp_name )
-import InterpSyn ( UnlinkedIBind )
-import StgInterp ( ItblEnv )
import FiniteMap ( FiniteMap, plusFM, emptyFM, addToFM )
-import OccName ( OccName, pprOccName )
-import Name ( Name, nameModule, emptyNameEnv, nameOccName,
- getName, extendNameEnv_C, nameEnvElts )
-import VarEnv ( emptyVarEnv )
-import Module ( Module, mkModuleName, lookupModuleEnvByName )
+import OccName ( OccName )
+import Name ( Name, nameModule, nameOccName, getName )
+import Name ( emptyNameEnv )
+import Module ( Module, lookupModuleEnvByName )
+import Monad ( when )
\end{code}
hscMain
:: DynFlags
- -> ModSummary -- summary, including source filename
- -> Maybe ModIface -- old interface, if available
+ -> Bool -- source unchanged?
+ -> ModuleLocation -- location info
+ -> Maybe ModIface -- old interface, if available
-> HomeSymbolTable -- for home module ModDetails
-> HomeIfaceTable
-> PersistentCompilerState -- IN: persistent compiler state
-> IO HscResult
-hscMain dflags summary maybe_old_iface hst hit pcs
+hscMain dflags source_unchanged location maybe_old_iface hst hit pcs
= do {
- -- ????? source_unchanged :: Bool -- extracted from summary?
- let source_unchanged = trace "WARNING: source_unchanged?!" False
- ;
- putStrLn "checking old iface ...";
- (pcs_ch, check_errs, (recomp_reqd, maybe_checked_iface))
- <- checkOldIface dflags hit hst pcs (ms_mod summary)
+ putStrLn ("CHECKING OLD IFACE for hs = " ++ show (ml_hs_file location)
+ ++ ", hspp = " ++ show (ml_hspp_file location));
+
+ (pcs_ch, errs_found, (recomp_reqd, maybe_checked_iface))
+ <- checkOldIface dflags hit hst pcs (unJust (ml_hi_file location) "hscMain")
source_unchanged maybe_old_iface;
- if check_errs then
+
+ if errs_found then
return (HscFail pcs_ch)
else do {
what_next | recomp_reqd || no_old_iface = hscRecomp
| otherwise = hscNoRecomp
;
- putStrLn "doing what_next ...";
- what_next dflags summary maybe_checked_iface
+ what_next dflags location maybe_checked_iface
hst hit pcs_ch
}}
-hscNoRecomp dflags summary maybe_checked_iface hst hit pcs_ch
+hscNoRecomp dflags location maybe_checked_iface hst hit pcs_ch
= do {
+ hPutStrLn stderr "COMPILATION NOT REQUIRED";
-- we definitely expect to have the old interface available
let old_iface = case maybe_checked_iface of
Just old_if -> old_if
else do {
-- TYPECHECK
- maybe_tc_result
- <- typecheckModule dflags (ms_mod summary) pcs_cl hst hit cl_hs_decls;
+ maybe_tc_result <- typecheckModule dflags pcs_cl hst
+ old_iface alwaysQualify cl_hs_decls;
case maybe_tc_result of {
Nothing -> return (HscFail pcs_cl);
- Just tc_result -> do {
+ Just (pcs_tc, tc_result) -> do {
- let pcs_tc = tc_pcs tc_result
- env_tc = tc_env tc_result
- binds_tc = tc_binds tc_result
- local_insts = tc_insts tc_result
- local_rules = tc_rules tc_result
+ let env_tc = tc_env tc_result
+ local_insts = tc_insts tc_result
+ local_rules = tc_rules tc_result
;
-- create a new details from the closed, typechecked, old iface
let new_details = mkModDetailsFromIface env_tc local_insts local_rules
}}}}
-hscRecomp dflags summary maybe_checked_iface hst hit pcs_ch
- = do {
- -- what target are we shooting for?
- let toInterp = dopt_HscLang dflags == HscInterpreted
- this_mod = ms_mod summary
- ;
- -- PARSE
- maybe_parsed <- myParseModule dflags summary;
- case maybe_parsed of {
- Nothing -> return (HscFail pcs_ch);
- Just rdr_module -> do {
-
- -- RENAME
- show_pass dflags "Renamer";
- (pcs_rn, maybe_rn_result)
- <- renameModule dflags hit hst pcs_ch this_mod rdr_module;
- case maybe_rn_result of {
- Nothing -> return (HscFail pcs_rn);
- Just (new_iface, rn_hs_decls) -> do {
-
- -- TYPECHECK
- show_pass dflags "Typechecker";
- maybe_tc_result
- <- typecheckModule dflags this_mod pcs_rn hst hit rn_hs_decls;
- case maybe_tc_result of {
- Nothing -> return (HscFail pcs_rn);
- Just tc_result -> do {
-
- let pcs_tc = tc_pcs tc_result
- env_tc = tc_env tc_result
- binds_tc = tc_binds tc_result
- local_insts = tc_insts tc_result
- ;
- -- DESUGAR, SIMPLIFY, TIDY-CORE
- -- We grab the the unfoldings at this point.
- (tidy_binds, orphan_rules, foreign_stuff)
- <- dsThenSimplThenTidy dflags (pcs_rules pcs_tc) this_mod tc_result hst
- ;
- -- CONVERT TO STG
- (stg_binds, oa_tidy_binds, cost_centre_info, top_level_ids)
- <- myCoreToStg dflags this_mod tidy_binds
- ;
- -- cook up a new ModDetails now we (finally) have all the bits
- let new_details = mkModDetails env_tc local_insts tidy_binds
- top_level_ids orphan_rules
- ;
- -- and possibly create a new ModIface
- let maybe_final_iface_and_sdoc
- = completeIface maybe_checked_iface new_iface new_details
- maybe_final_iface
- = case maybe_final_iface_and_sdoc of
- Just (fif, sdoc) -> Just fif; Nothing -> Nothing
- ;
- -- Write the interface file
- writeIface maybe_final_iface
- ;
- -- do the rest of code generation/emission
- (maybe_stub_h_filename, maybe_stub_c_filename, maybe_ibinds)
- <- restOfCodeGeneration dflags toInterp summary
- cost_centre_info foreign_stuff env_tc stg_binds oa_tidy_binds
- hit (pcs_PIT pcs_tc)
- ;
- -- and the answer is ...
- return (HscOK new_details maybe_final_iface
- maybe_stub_h_filename maybe_stub_c_filename
- maybe_ibinds pcs_tc)
- }}}}}}}
-
-
-myParseModule dflags summary
+hscRecomp dflags location maybe_checked_iface hst hit pcs_ch
+ = do {
+ ; hPutStrLn stderr "COMPILATION IS REQUIRED";
+
+ -- what target are we shooting for?
+ ; let toInterp = dopt_HscLang dflags == HscInterpreted
+
+ -------------------
+ -- PARSE
+ -------------------
+ ; maybe_parsed <- myParseModule dflags (unJust (ml_hspp_file location) "hscRecomp:hspp")
+ ; case maybe_parsed of {
+ Nothing -> return (HscFail pcs_ch);
+ Just rdr_module -> do {
+ ; let this_mod = mkModuleInThisPackage (hsModuleName rdr_module)
+
+ -------------------
+ -- RENAME
+ -------------------
+ ; (pcs_rn, maybe_rn_result)
+ <- renameModule dflags hit hst pcs_ch this_mod rdr_module
+ ; case maybe_rn_result of {
+ Nothing -> return (HscFail pcs_rn);
+ Just (print_unqualified, (is_exported, new_iface, rn_hs_decls)) -> do {
+
+ -------------------
+ -- TYPECHECK
+ -------------------
+ ; maybe_tc_result <- typecheckModule dflags pcs_rn hst new_iface
+ print_unqualified rn_hs_decls
+ ; case maybe_tc_result of {
+ Nothing -> do { hPutStrLn stderr "Typecheck failed"
+ ; return (HscFail pcs_rn) } ;
+ Just (pcs_tc, tc_result) -> do {
+
+ ; let env_tc = tc_env tc_result
+ local_insts = tc_insts tc_result
+
+ -------------------
+ -- DESUGAR, SIMPLIFY, TIDY-CORE
+ -------------------
+ -- We grab the the unfoldings at this point.
+ ; simpl_result <- dsThenSimplThenTidy dflags pcs_tc hst this_mod
+ print_unqualified is_exported tc_result
+ ; let (tidy_binds, orphan_rules, foreign_stuff) = simpl_result
+
+ -------------------
+ -- CONVERT TO STG
+ -------------------
+ ; (stg_binds, oa_tidy_binds, cost_centre_info, top_level_ids)
+ <- myCoreToStg dflags this_mod tidy_binds
+
+
+ -------------------
+ -- BUILD THE NEW ModDetails AND ModIface
+ -------------------
+ ; let new_details = mkModDetails env_tc local_insts tidy_binds
+ top_level_ids orphan_rules
+ ; final_iface <- mkFinalIface dflags location maybe_checked_iface
+ new_iface new_details
+
+ -------------------
+ -- COMPLETE CODE GENERATION
+ -------------------
+ ; (maybe_stub_h_filename, maybe_stub_c_filename, maybe_ibinds)
+ <- restOfCodeGeneration dflags toInterp this_mod
+ (map ideclName (hsModuleImports rdr_module))
+ cost_centre_info foreign_stuff env_tc stg_binds oa_tidy_binds
+ hit (pcs_PIT pcs_tc)
+
+ -- and the answer is ...
+ ; return (HscOK new_details (Just final_iface)
+ maybe_stub_h_filename maybe_stub_c_filename
+ maybe_ibinds pcs_tc)
+ }}}}}}}
+
+
+
+mkFinalIface 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
+ writeIface (unJust (ml_hi_file location) "hscRecomp:hi") new_iface
+ return new_iface
+
+
+myParseModule dflags src_filename
= do -------------------------- Parser ----------------
- show_pass dflags "Parser"
+ showPass dflags "Parser"
-- _scc_ "Parser"
- let src_filename -- name of the preprocessed source file
- = case ms_ppsource summary of
- Just (filename, fingerprint) -> filename
- Nothing -> pprPanic
- "myParseModule:summary is not of a source module"
- (ppr summary)
-
buf <- hGetStringBuffer True{-expand tabs-} src_filename
let glaexts | dopt Opt_GlasgowExts dflags = 1#
PFailed err -> do { hPutStrLn stderr (showSDoc err);
return Nothing };
- POk _ rdr_module@(HsModule mod_name _ _ _ _ _ _) -> do {
+
+ POk _ (PModule rdr_module@(HsModule mod_name _ _ _ _ _ _)) -> do {
dumpIfSet_dyn dflags Opt_D_dump_parsed "Parser" (ppr rdr_module) ;
}}
-restOfCodeGeneration dflags toInterp summary cost_centre_info
+restOfCodeGeneration dflags toInterp this_mod imported_module_names cost_centre_info
foreign_stuff env_tc stg_binds oa_tidy_binds
hit pit -- these last two for mapping ModNames to Modules
| toInterp
= do (ibinds,itbl_env)
<- stgToInterpSyn (map fst stg_binds) local_tycons local_classes
return (Nothing, Nothing, Just (ibinds,itbl_env))
+
| otherwise
= do -------------------------- Code generation -------------------------------
- show_pass dflags "CodeGen"
-- _scc_ "CodeGen"
abstractC <- codeGen dflags this_mod imported_modules
cost_centre_info fe_binders
- local_tycons local_classes stg_binds
+ local_tycons stg_binds
-------------------------- Code output -------------------------------
- show_pass dflags "CodeOutput"
-- _scc_ "CodeOutput"
- ncg_uniqs <- mkSplitUniqSupply 'n'
(maybe_stub_h_name, maybe_stub_c_name)
- <- codeOutput dflags this_mod local_tycons local_classes
+ <- codeOutput dflags this_mod local_tycons
oa_tidy_binds stg_binds
- c_code h_code abstractC ncg_uniqs
+ c_code h_code abstractC
return (maybe_stub_h_name, maybe_stub_c_name, Nothing)
where
local_tycons = typeEnvTyCons env_tc
local_classes = typeEnvClasses env_tc
- this_mod = ms_mod summary
- imported_modules = map (mod_name_to_Module.mimp_name)
- (ms_get_imports summary)
+ imported_modules = map mod_name_to_Module imported_module_names
(fe_binders,h_code,c_code) = foreign_stuff
mod_name_to_Module :: ModuleName -> Module
(ppr nm)
-dsThenSimplThenTidy dflags rule_base this_mod tc_result hst
+dsThenSimplThenTidy dflags pcs hst this_mod print_unqual is_exported tc_result
= do -------------------------- Desugaring ----------------
-- _scc_ "DeSugar"
- show_pass dflags "DeSugar"
- ds_uniqs <- mkSplitUniqSupply 'd'
(desugared, rules, h_code, c_code, fe_binders)
- <- deSugar dflags this_mod ds_uniqs hst tc_result
+ <- deSugar dflags pcs hst this_mod print_unqual tc_result
-------------------------- Main Core-language transformations ----------------
-- _scc_ "Core2Core"
- show_pass dflags "Core2Core"
(simplified, orphan_rules)
- <- core2core dflags rule_base hst desugared rules
+ <- core2core dflags pcs hst is_exported desugared rules
-- Do the final tidy-up
- show_pass dflags "CoreTidy"
(tidy_binds, tidy_orphan_rules)
<- tidyCorePgm dflags this_mod simplified orphan_rules
-- simplifier, which for reasons I don't understand, persists
-- thoroughout code generation
- show_pass dflags "Core2Stg"
+ showPass dflags "Core2Stg"
-- _scc_ "Core2Stg"
let stg_binds = topCoreBindsToStg c2s_uniqs occ_anal_tidy_binds
- show_pass dflags "Stg2Stg"
+ showPass dflags "Stg2Stg"
-- _scc_ "Stg2Stg"
(stg_binds2, cost_centre_info) <- stg2stg dflags this_mod st_uniqs stg_binds
let final_ids = collectFinalStgBinders (map fst stg_binds2)
return (stg_binds2, occ_anal_tidy_binds, cost_centre_info, final_ids)
+\end{code}
-show_pass dflags what
- = if dopt Opt_D_show_passes dflags
- then hPutStr stderr ("*** "++what++":\n")
- else return ()
-\end{code}
+%************************************************************************
+%* *
+\subsection{Compiling an expression}
+%* *
+%************************************************************************
+
+hscExpr
+ :: DynFlags
+ -> HomeSymbolTable
+ -> HomeIfaceTable
+ -> PersistentCompilerState -- IN: persistent compiler state
+ -> Module -- Context for compiling
+ -> String -- The expression
+ -> IO HscResult
+
+hscExpr dflags hst hit pcs this_module expr
+ = do { -- Parse it
+ let unqual = unQualInScope
+ ; maybe_parsed <- myParseExpr dflags expr
+ ; case maybe_parsed of {
+ Nothing -> return (HscFail pcs_ch);
+ Just parsed_expr -> do {
+
+ -- Rename it
+ (new_pcs, maybe_renamed_expr) <- renameExpr dflags hit hst pcs this_module parsed_expr ;
+ ; case maybe_renamed_expr of {
+ Nothing -> FAIL
+ Just (print_unqual, rn_expr) ->
+
+ -- Typecheck it
+ maybe_tc_expr <- typecheckExpr dflags pcs hst print_unqual rn_expr
+ ; case maybe_tc_expr of
+ Nothing -> FAIL
+ Just tc_expr ->
+
+ -- Desugar it
+ ; ds_expr <- deSugarExpr dflags pcs hst this_module print_unqual tc_expr
+
+ -- Simplify it
+ ; simpl_expr <- simplifyExpr dflags pcs hst ds_expr
+
+ ; return I'M NOT SURE
+ }
+
+
%************************************************************************
= do prs <- initPersistentRenamerState
return (
PCS { pcs_PIT = emptyIfaceTable,
- pcs_PST = initPackageDetails,
+ pcs_PTE = wiredInThingEnv,
pcs_insts = emptyInstEnv,
pcs_rules = emptyRuleBase,
pcs_PRS = prs
}
)
-initPackageDetails :: PackageSymbolTable
-initPackageDetails = extendTypeEnv emptyModuleEnv (groupTyThings wiredInThings)
-
---initPackageDetails = panic "initPackageDetails"
-
initPersistentRenamerState :: IO PersistentRenamerState
= do ns <- mkSplitUniqSupply 'r'
return (
PRS { prsOrig = Orig { origNames = initOrigNames,
origIParam = emptyFM },
- prsDecls = emptyNameEnv,
- prsInsts = emptyBag,
- prsRules = emptyBag,
+ prsDecls = (emptyNameEnv, 0),
+ prsInsts = (emptyBag, 0),
+ prsRules = (emptyBag, 0),
prsNS = ns
}
)
projects / ghc-hetmet.git / blobdiff