-{-# OPTIONS -fno-warn-incomplete-patterns #-}
--- The above warning supression flag is a temporary kludge.
--- While working on this module you are encouraged to remove it and fix
--- any warnings in the module. See
--- http://hackage.haskell.org/trac/ghc/wiki/Commentary/CodingStyle#Warnings
--- for details
-
-----------------------------------------------------------------------------
--
--- Parsing the top of a Haskell source file to get its module name,
+-- | Parsing the top of a Haskell source file to get its module name,
-- imports and options.
--
-- (c) Simon Marlow 2005
module HeaderInfo ( getImports
, getOptionsFromFile, getOptions
- , optionsErrorMsgs ) where
+ , optionsErrorMsgs,
+ checkProcessArgsResult ) where
#include "HsVersions.h"
+import RdrName
+import HscTypes
import Parser ( parseHeader )
import Lexer
import FastString
import Util
import Outputable
import Pretty ()
-import Panic
import Maybes
-import Bag ( emptyBag, listToBag )
+import Bag ( emptyBag, listToBag, unitBag )
-import Control.Exception
+import MonadUtils ( MonadIO )
+import Exception
import Control.Monad
-import System.Exit
import System.IO
import Data.List
-#if !defined(__GLASGOW_HASKELL__) || __GLASGOW_HASKELL__ >= 601
- -- already imported above
---import System.IO ( openBinaryFile )
-#else
-import IOExts ( openFileEx, IOModeEx(..) )
-#endif
-
-#if defined(__GLASGOW_HASKELL__) && __GLASGOW_HASKELL__ < 601
-openBinaryFile fp mode = openFileEx fp (BinaryMode mode)
-#endif
+------------------------------------------------------------------------------
-getImports :: DynFlags -> StringBuffer -> FilePath -> FilePath
- -> IO ([Located ModuleName], [Located ModuleName], Located ModuleName)
+-- | Parse the imports of a source file.
+--
+-- Throws a 'SourceError' if parsing fails.
+getImports :: GhcMonad m =>
+ DynFlags
+ -> StringBuffer -- ^ Parse this.
+ -> FilePath -- ^ Filename the buffer came from. Used for
+ -- reporting parse error locations.
+ -> FilePath -- ^ The original source filename (used for locations
+ -- in the function result)
+ -> m ([Located (ImportDecl RdrName)], [Located (ImportDecl RdrName)], Located ModuleName)
+ -- ^ The source imports, normal imports, and the module name.
getImports dflags buf filename source_filename = do
let loc = mkSrcLoc (mkFastString filename) 1 0
case unP parseHeader (mkPState buf loc dflags) of
- PFailed span err -> parseError span err
- POk pst rdr_module -> do
- let ms = getMessages pst
- printErrorsAndWarnings dflags ms
- when (errorsFound dflags ms) $ exitWith (ExitFailure 1)
+ PFailed span err -> parseError span err
+ POk pst rdr_module -> do
+ let ms@(warns, errs) = getMessages pst
+ logWarnings warns
+ if errorsFound dflags ms
+ then liftIO $ throwIO $ mkSrcErr errs
+ else
case rdr_module of
L _ (HsModule mb_mod _ imps _ _ _ _) ->
let
main_loc = mkSrcLoc (mkFastString source_filename) 1 0
mod = mb_mod `orElse` L (srcLocSpan main_loc) mAIN_NAME
- (src_idecls, ord_idecls) = partition isSourceIdecl (map unLoc imps)
- source_imps = map getImpMod src_idecls
- ordinary_imps = filter ((/= moduleName gHC_PRIM) . unLoc)
- (map getImpMod ord_idecls)
+ (src_idecls, ord_idecls) = partition (ideclSource.unLoc) imps
+ ordinary_imps = filter ((/= moduleName gHC_PRIM) . unLoc . ideclName . unLoc)
+ ord_idecls
-- GHC.Prim doesn't exist physically, so don't go looking for it.
in
- return (source_imps, ordinary_imps, mod)
+ return (src_idecls, ordinary_imps, mod)
-parseError :: SrcSpan -> Message -> a
-parseError span err = throwDyn $ mkPlainErrMsg span err
-
-isSourceIdecl :: ImportDecl name -> Bool
-isSourceIdecl (ImportDecl _ s _ _ _) = s
-
-getImpMod :: ImportDecl name -> Located ModuleName
-getImpMod (ImportDecl located_mod _ _ _ _) = located_mod
+parseError :: GhcMonad m => SrcSpan -> Message -> m a
+parseError span err = throwOneError $ mkPlainErrMsg span err
--------------------------------------------------------------
-- Get options
--------------------------------------------------------------
-
-getOptionsFromFile :: FilePath -- input file
- -> IO [Located String] -- options, if any
-getOptionsFromFile filename
- = Control.Exception.bracket
+-- | Parse OPTIONS and LANGUAGE pragmas of the source file.
+--
+-- Throws a 'SourceError' if flag parsing fails (including unsupported flags.)
+getOptionsFromFile :: DynFlags
+ -> FilePath -- ^ Input file
+ -> IO [Located String] -- ^ Parsed options, if any.
+getOptionsFromFile dflags filename
+ = Exception.bracket
(openBinaryFile filename ReadMode)
(hClose)
(\handle ->
loop handle buf
| len buf == 0 = return []
| otherwise
- = case getOptions' buf filename of
+ = case getOptions' dflags buf filename of
(Nothing, opts) -> return opts
(Just buf', opts) -> do nextBlock <- hGetStringBufferBlock handle blockSize
newBuf <- appendStringBuffers buf' nextBlock
else do opts' <- loop handle newBuf
return (opts++opts')
-getOptions :: StringBuffer -> FilePath -> [Located String]
-getOptions buf filename
- = case getOptions' buf filename of
+-- | Parse OPTIONS and LANGUAGE pragmas of the source file.
+--
+-- Throws a 'SourceError' if flag parsing fails (including unsupported flags.)
+getOptions :: DynFlags
+ -> StringBuffer -- ^ Input Buffer
+ -> FilePath -- ^ Source filename. Used for location info.
+ -> [Located String] -- ^ Parsed options.
+getOptions dflags buf filename
+ = case getOptions' dflags buf filename of
(_,opts) -> opts
-- The token parser is written manually because Happy can't
-- return a partial result when it encounters a lexer error.
-- We want to extract options before the buffer is passed through
-- CPP, so we can't use the same trick as 'getImports'.
-getOptions' :: StringBuffer -- Input buffer
+getOptions' :: DynFlags
+ -> StringBuffer -- Input buffer
-> FilePath -- Source file. Used for msgs only.
-> ( Maybe StringBuffer -- Just => we can use more input
, [Located String] -- Options.
)
-getOptions' buf filename
- = parseToks (lexAll (pragState buf loc))
+getOptions' dflags buf filename
+ = parseToks (lexAll (pragState dflags buf loc))
where loc = mkSrcLoc (mkFastString filename) 1 0
getToken (_buf,L _loc tok) = tok
(_,L _loc ITcomma):more -> parseLanguage more
(_,L _loc ITclose_prag):more -> parseToks more
(_,L loc _):_ -> languagePragParseError loc
+ [] -> panic "getOptions'.parseLanguage(1) went past eof token"
parseLanguage (tok:_)
= languagePragParseError (getLoc tok)
+ parseLanguage []
+ = panic "getOptions'.parseLanguage(2) went past eof token"
lexToken t = return t
lexAll state = case unP (lexer lexToken) state of
POk _ t@(L _ ITeof) -> [(buffer state,t)]
POk state' t -> (buffer state,t):lexAll state'
_ -> [(buffer state,L (last_loc state) ITeof)]
+-----------------------------------------------------------------------------
+
+-- | Complain about non-dynamic flags in OPTIONS pragmas.
+--
+-- Throws a 'SourceError' if the input list is non-empty claiming that the
+-- input flags are unknown.
+checkProcessArgsResult :: MonadIO m => [Located String] -> m ()
+checkProcessArgsResult flags
+ = when (notNull flags) $
+ liftIO $ throwIO $ mkSrcErr $ listToBag $ map mkMsg flags
+ where mkMsg (L loc flag)
+ = mkPlainErrMsg loc $
+ (text "unknown flag in {-# OPTIONS #-} pragma:" <+>
+ text flag)
+
+-----------------------------------------------------------------------------
+
checkExtension :: Located FastString -> Located String
checkExtension (L l ext)
-- Checks if a given extension is valid, and if so returns
languagePragParseError :: SrcSpan -> a
languagePragParseError loc =
- pgmError (showSDoc (mkLocMessage loc (
- text "cannot parse LANGUAGE pragma")))
+ throw $ mkSrcErr $ unitBag $
+ (mkPlainErrMsg loc $
+ text "cannot parse LANGUAGE pragma: comma-separated list expected")
unsupportedExtnError :: SrcSpan -> String -> a
unsupportedExtnError loc unsup =
- pgmError (showSDoc (mkLocMessage loc (
- text "unsupported extension: " <>
- text unsup)))
+ throw $ mkSrcErr $ unitBag $
+ mkPlainErrMsg loc $
+ text "unsupported extension: " <> text unsup
optionsErrorMsgs :: [String] -> [Located String] -> FilePath -> Messages