-----------------------------------------------------------------------------
--
--- 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 ( getImportsFromFile, getImports
+module HeaderInfo ( getImports
, getOptionsFromFile, getOptions
- , optionsErrorMsgs ) where
+ , optionsErrorMsgs,
+ checkProcessArgsResult ) where
#include "HsVersions.h"
+import RdrName
+import HscTypes
import Parser ( parseHeader )
-import Lexer ( P(..), ParseResult(..), mkPState, pragState
- , lexer, Token(..), PState(..) )
+import Lexer
import FastString
import HsSyn ( ImportDecl(..), HsModule(..) )
import Module ( ModuleName, moduleName )
import PrelNames ( gHC_PRIM, mAIN_NAME )
-import StringBuffer ( StringBuffer(..), hGetStringBuffer, hGetStringBufferBlock
- , appendStringBuffers )
+import StringBuffer
import SrcLoc
-import FastString ( mkFastString )
-import DynFlags ( DynFlags )
+import DynFlags
import ErrUtils
import Util
import Outputable
import Pretty ()
-import Panic
import Maybes
-import Bag ( emptyBag, listToBag )
+import Bag ( emptyBag, listToBag, unitBag )
-import Distribution.Compiler
-
-import Control.Exception
+import MonadUtils ( MonadIO )
+import Exception
+import Control.Monad
import System.IO
+import System.IO.Unsafe
import Data.List
-#if __GLASGOW_HASKELL__ >= 601
-import System.IO ( openBinaryFile )
-#else
-import IOExts ( openFileEx, IOModeEx(..) )
-#endif
-
-#if __GLASGOW_HASKELL__ < 601
-openBinaryFile fp mode = openFileEx fp (BinaryMode mode)
-#endif
-
--- getImportsFromFile is careful to close the file afterwards, otherwise
--- we can end up with a large number of open handles before the garbage
--- collector gets around to closing them.
-getImportsFromFile :: DynFlags -> FilePath
- -> IO ([Located ModuleName], [Located ModuleName], Located ModuleName)
-getImportsFromFile dflags filename = do
- buf <- hGetStringBuffer filename
- getImports dflags buf filename
-
-getImports :: DynFlags -> StringBuffer -> FilePath
- -> IO ([Located ModuleName], [Located ModuleName], Located ModuleName)
-getImports dflags buf filename = do
- let loc = mkSrcLoc (mkFastString filename) 1 0
+------------------------------------------------------------------------------
+
+-- | 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 1
case unP parseHeader (mkPState buf loc dflags) of
- PFailed span err -> parseError span err
- POk _ rdr_module ->
+ PFailed span err -> parseError span err
+ POk pst rdr_module -> do
+ let _ms@(_warns, errs) = getMessages pst
+ -- don't log warnings: they'll be reported when we parse the file
+ -- for real. See #2500.
+ ms = (emptyBag, errs)
+ -- logWarnings warns
+ if errorsFound dflags ms
+ then liftIO $ throwIO $ mkSrcErr errs
+ else
case rdr_module of
- L _ (HsModule mb_mod _ imps _ _ _ _ _) ->
+ L _ (HsModule mb_mod _ imps _ _ _) ->
let
- mod = mb_mod `orElse` L (srcLocSpan 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)
+ main_loc = mkSrcLoc (mkFastString source_filename) 1 1
+ mod = mb_mod `orElse` L (srcLocSpan main_loc) mAIN_NAME
+ (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 span err = throwDyn $ mkPlainErrMsg span err
-
-isSourceIdecl (ImportDecl _ s _ _ _) = s
-
-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 ->
- do buf <- hGetStringBufferBlock handle blockSize
- loop handle buf)
- where blockSize = 1024
- loop handle buf
- | len buf == 0 = return []
- | otherwise
- = case getOptions' buf filename of
- (Nothing, opts) -> return opts
- (Just buf', opts) -> do nextBlock <- hGetStringBufferBlock handle blockSize
- newBuf <- appendStringBuffers buf' nextBlock
- if len newBuf == len buf
- then return opts
- else do opts' <- loop handle newBuf
- return (opts++opts')
-
-getOptions :: StringBuffer -> FilePath -> [Located String]
-getOptions buf filename
- = case getOptions' buf filename of
- (_,opts) -> opts
+ (\handle -> do
+ opts <- fmap getOptions' $ lazyGetToks dflags filename handle
+ seqList opts $ return opts)
+
+blockSize :: Int
+-- blockSize = 17 -- for testing :-)
+blockSize = 1024
+
+lazyGetToks :: DynFlags -> FilePath -> Handle -> IO [Located Token]
+lazyGetToks dflags filename handle = do
+ buf <- hGetStringBufferBlock handle blockSize
+ unsafeInterleaveIO $ lazyLexBuf handle (pragState dflags buf loc) False
+ where
+ loc = mkSrcLoc (mkFastString filename) 1 1
+
+ lazyLexBuf :: Handle -> PState -> Bool -> IO [Located Token]
+ lazyLexBuf handle state eof = do
+ case unP (lexer return) state of
+ POk state' t -> do
+ -- pprTrace "lazyLexBuf" (text (show (buffer state'))) (return ())
+ if atEnd (buffer state') && not eof
+ -- if this token reached the end of the buffer, and we haven't
+ -- necessarily read up to the end of the file, then the token might
+ -- be truncated, so read some more of the file and lex it again.
+ then getMore handle state
+ else case t of
+ L _ ITeof -> return [t]
+ _other -> do rest <- lazyLexBuf handle state' eof
+ return (t : rest)
+ _ | not eof -> getMore handle state
+ | otherwise -> return [L (last_loc state) ITeof]
+ -- parser assumes an ITeof sentinel at the end
+
+ getMore :: Handle -> PState -> IO [Located Token]
+ getMore handle state = do
+ -- pprTrace "getMore" (text (show (buffer state))) (return ())
+ nextbuf <- hGetStringBufferBlock handle blockSize
+ if (len nextbuf == 0) then lazyLexBuf handle state True else do
+ newbuf <- appendStringBuffers (buffer state) nextbuf
+ unsafeInterleaveIO $ lazyLexBuf handle state{buffer=newbuf} False
+
+
+getToks :: DynFlags -> FilePath -> StringBuffer -> [Located Token]
+getToks dflags filename buf = lexAll (pragState dflags buf loc)
+ where
+ loc = mkSrcLoc (mkFastString filename) 1 1
+
+ lexAll state = case unP (lexer return) state of
+ POk _ t@(L _ ITeof) -> [t]
+ POk state' t -> t : lexAll state'
+ _ -> [L (last_loc state) ITeof]
+
+
+-- | 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
+ = getOptions' (getToks dflags filename buf)
-- 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
- -> 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))
- where loc = mkSrcLoc (mkFastString filename) 1 0
-
- getToken (buf,L _loc tok) = tok
- getLoc (buf,L loc _tok) = loc
- getBuf (buf,_tok) = buf
- combine opts (flag, opts') = (flag, opts++opts')
- add opt (flag, opts) = (flag, opt:opts)
+getOptions' :: [Located Token] -- Input buffer
+ -> [Located String] -- Options.
+getOptions' toks
+ = parseToks toks
+ where
+ getToken (L _loc tok) = tok
+ getLoc (L loc _tok) = loc
parseToks (open:close:xs)
| IToptions_prag str <- getToken open
, ITclose_prag <- getToken close
- = map (L (getLoc open)) (words str) `combine`
+ = map (L (getLoc open)) (words str) ++
parseToks xs
parseToks (open:close:xs)
| ITinclude_prag str <- getToken open
, ITclose_prag <- getToken close
- = map (L (getLoc open)) ["-#include",removeSpaces str] `combine`
+ = map (L (getLoc open)) ["-#include",removeSpaces str] ++
parseToks xs
+ parseToks (open:close:xs)
+ | ITdocOptions str <- getToken open
+ , ITclose_prag <- getToken close
+ = map (L (getLoc open)) ["-haddock-opts", removeSpaces str]
+ ++ parseToks xs
+ parseToks (open:xs)
+ | ITdocOptionsOld str <- getToken open
+ = map (L (getLoc open)) ["-haddock-opts", removeSpaces str]
+ ++ parseToks xs
parseToks (open:xs)
| ITlanguage_prag <- getToken open
= parseLanguage xs
- -- The last token before EOF could have been truncated.
- -- We ignore it to be on the safe side.
- parseToks [tok,eof]
- | ITeof <- getToken eof
- = (Just (getBuf tok),[])
- parseToks (eof:_)
- | ITeof <- getToken eof
- = (Just (getBuf eof),[])
- parseToks _ = (Nothing,[])
- parseLanguage ((_buf,L loc (ITconid fs)):rest)
- = checkExtension (L loc fs) `add`
+ parseToks _ = []
+ parseLanguage (L loc (ITconid fs):rest)
+ = checkExtension (L loc fs) :
case rest of
- (_,L loc ITcomma):more -> parseLanguage more
- (_,L loc ITclose_prag):more -> parseToks more
- (_,L loc _):_ -> languagePragParseError loc
+ (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)
- lexToken t = return t
- lexAll state = case unP (lexer lexToken) state of
- POk state' t@(L _ ITeof) -> [(buffer state,t)]
- POk state' t -> (buffer state,t):lexAll state'
- _ -> [(buffer state,L (last_loc state) ITeof)]
+ parseLanguage []
+ = panic "getOptions'.parseLanguage(2) went past eof token"
+
+-----------------------------------------------------------------------------
+
+-- | 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)
- = case reads (unpackFS ext) of
- [] -> languagePragParseError l
- (okExt,""):_ -> case extensionsToGHCFlag [okExt] of
- ([],[opt]) -> L l opt
- _ -> unsupportedExtnError l okExt
+-- Checks if a given extension is valid, and if so returns
+-- its corresponding flag. Otherwise it throws an exception.
+ = let ext' = unpackFS ext in
+ if ext' `elem` supportedLanguages
+ || ext' `elem` (map ("No"++) supportedLanguages)
+ then L l ("-X"++ext')
+ else unsupportedExtnError l ext'
+languagePragParseError :: SrcSpan -> a
languagePragParseError loc =
- pgmError (showSDoc (mkLocMessage loc (
- text "cannot parse LANGUAGE pragma")))
+ throw $ mkSrcErr $ unitBag $
+ (mkPlainErrMsg loc $
+ vcat [ text "Cannot parse LANGUAGE pragma"
+ , text "Expecting comma-separated list of language options,"
+ , text "each starting with a capital letter"
+ , nest 2 (text "E.g. {-# LANGUAGE RecordPuns, Generics #-}") ])
+unsupportedExtnError :: SrcSpan -> String -> a
unsupportedExtnError loc unsup =
- pgmError (showSDoc (mkLocMessage loc (
- text "unsupported extension: " <>
- (text.show) unsup)))
+ throw $ mkSrcErr $ unitBag $
+ mkPlainErrMsg loc $
+ text "Unsupported extension: " <> text unsup
optionsErrorMsgs :: [String] -> [Located String] -> FilePath -> Messages
-optionsErrorMsgs unhandled_flags flags_lines filename
+optionsErrorMsgs unhandled_flags flags_lines _filename
= (emptyBag, listToBag (map mkMsg unhandled_flags_lines))
where unhandled_flags_lines = [ L l f | f <- unhandled_flags,
L l f' <- flags_lines, f == f' ]
projects / ghc-hetmet.git / blobdiff