-- Hoogle documentation, generated by Haddock
-- See Hoogle, http://www.haskell.org/hoogle/


-- | Parser and anlyses for Fortran standards 66, 77, 90.
--   
--   Provides lexing, parsing, and basic analyses of Fortran code covering
--   standards: FORTRAN 66, FORTRAN 77, and Fortran 90. Includes data flow
--   and basic block analysis, a renamer, and type analysis. For example
--   usage, see the <a>camfort</a> project, which uses fortran-src as its
--   front end.
@package fortran-src
@version 0.2.0.0


-- | Simple module to provide functions that read Fortran literals
module Language.Fortran.Parser.Utils

-- | Convert a Fortran literal Real into a Haskell Double.
readReal :: String -> Maybe Double

-- | Convert a Fortran literal Integer into a Haskell Integer.
readInteger :: String -> Maybe Integer

module Language.Fortran.Util.FirstParameter
class FirstParameter a e | a -> e
getFirstParameter :: FirstParameter a e => a -> e
setFirstParameter :: FirstParameter a e => e -> a -> a
getFirstParameter :: (FirstParameter a e, Generic a, GFirstParameter (Rep a) e) => a -> e
setFirstParameter :: (FirstParameter a e, Generic a, GFirstParameter (Rep a) e) => e -> a -> a
class GFirstParameter f e
getFirstParameter' :: GFirstParameter f e => f a -> e
setFirstParameter' :: GFirstParameter f e => e -> f a -> f a
instance Language.Fortran.Util.FirstParameter.GFirstParameter (GHC.Generics.K1 i e) e
instance Language.Fortran.Util.FirstParameter.GFirstParameter (GHC.Generics.K1 i a) e
instance Language.Fortran.Util.FirstParameter.GFirstParameter a e => Language.Fortran.Util.FirstParameter.GFirstParameter (GHC.Generics.M1 i c a) e
instance (Language.Fortran.Util.FirstParameter.GFirstParameter a e, Language.Fortran.Util.FirstParameter.GFirstParameter b e) => Language.Fortran.Util.FirstParameter.GFirstParameter (a GHC.Generics.:+: b) e
instance (Language.Fortran.Util.FirstParameter.GFirstParameter a e, Language.Fortran.Util.FirstParameter.GFirstParameter b e) => Language.Fortran.Util.FirstParameter.GFirstParameter (a GHC.Generics.:*: b) e
instance Language.Fortran.Util.FirstParameter.GFirstParameter GHC.Generics.U1 GHC.Base.String

module Language.Fortran.Util.SecondParameter
class SecondParameter a e | a -> e
getSecondParameter :: SecondParameter a e => a -> e
setSecondParameter :: SecondParameter a e => e -> a -> a
getSecondParameter :: (SecondParameter a e, Generic a, GSecondParameter (Rep a) e) => a -> e
setSecondParameter :: (SecondParameter a e, Generic a, GSecondParameter (Rep a) e) => e -> a -> a
instance (Language.Fortran.Util.SecondParameter.ParameterLeaf a, Language.Fortran.Util.SecondParameter.GSecondParameter a e, Language.Fortran.Util.SecondParameter.GSecondParameter' b e) => Language.Fortran.Util.SecondParameter.GSecondParameter (a GHC.Generics.:*: b) e
instance Language.Fortran.Util.SecondParameter.ParameterLeaf (GHC.Generics.M1 i c a)
instance Language.Fortran.Util.SecondParameter.ParameterLeaf (a GHC.Generics.:*: b)
instance Language.Fortran.Util.SecondParameter.GSecondParameter' a e => Language.Fortran.Util.SecondParameter.GSecondParameter' (GHC.Generics.M1 i c a) e
instance Language.Fortran.Util.SecondParameter.GSecondParameter' a e => Language.Fortran.Util.SecondParameter.GSecondParameter' (a GHC.Generics.:*: b) e
instance Language.Fortran.Util.SecondParameter.GSecondParameter' (GHC.Generics.K1 i e) e
instance Language.Fortran.Util.SecondParameter.GSecondParameter' (GHC.Generics.K1 i a) e
instance Language.Fortran.Util.SecondParameter.GSecondParameter (GHC.Generics.K1 i a) e
instance Language.Fortran.Util.SecondParameter.GSecondParameter a e => Language.Fortran.Util.SecondParameter.GSecondParameter (GHC.Generics.M1 i c a) e
instance (Language.Fortran.Util.SecondParameter.GSecondParameter a e, Language.Fortran.Util.SecondParameter.GSecondParameter b e) => Language.Fortran.Util.SecondParameter.GSecondParameter (a GHC.Generics.:+: b) e

module Language.Fortran.Util.Position
class Loc a
getPos :: Loc a => a -> Position
data Position
Position :: {-# UNPACK #-} !Int -> {-# UNPACK #-} !Int -> {-# UNPACK #-} !Int -> Position
[posAbsoluteOffset] :: Position -> {-# UNPACK #-} !Int
[posColumn] :: Position -> {-# UNPACK #-} !Int
[posLine] :: Position -> {-# UNPACK #-} !Int
initPosition :: Position
lineCol :: Position -> (Int, Int)
data SrcSpan
SrcSpan :: Position -> Position -> SrcSpan
columnDistance :: SrcSpan -> Int
lineDistance :: SrcSpan -> Int
initSrcSpan :: SrcSpan
class Spanned a
getSpan :: Spanned a => a -> SrcSpan
setSpan :: Spanned a => SrcSpan -> a -> a
getSpan :: (Spanned a, (SecondParameter a SrcSpan)) => a -> SrcSpan
setSpan :: (Spanned a, (SecondParameter a SrcSpan)) => SrcSpan -> a -> a
instance GHC.Generics.Generic Language.Fortran.Util.Position.SrcSpan
instance Data.Data.Data Language.Fortran.Util.Position.SrcSpan
instance GHC.Classes.Ord Language.Fortran.Util.Position.SrcSpan
instance GHC.Classes.Eq Language.Fortran.Util.Position.SrcSpan
instance GHC.Generics.Generic Language.Fortran.Util.Position.Position
instance Data.Data.Data Language.Fortran.Util.Position.Position
instance GHC.Classes.Ord Language.Fortran.Util.Position.Position
instance GHC.Classes.Eq Language.Fortran.Util.Position.Position
instance Language.Fortran.Util.Position.Spanned Language.Fortran.Util.Position.SrcSpan
instance Data.Binary.Class.Binary Language.Fortran.Util.Position.SrcSpan
instance GHC.Show.Show Language.Fortran.Util.Position.SrcSpan
instance Text.PrettyPrint.GenericPretty.Out Language.Fortran.Util.Position.SrcSpan
instance Data.Binary.Class.Binary Language.Fortran.Util.Position.Position
instance GHC.Show.Show Language.Fortran.Util.Position.Position

module Language.Fortran.ParserMonad
data FortranVersion
Fortran66 :: FortranVersion
Fortran77 :: FortranVersion
Fortran77Extended :: FortranVersion
Fortran90 :: FortranVersion
Fortran2003 :: FortranVersion
Fortran2008 :: FortranVersion
data ParanthesesCount
ParanthesesCount :: Integer -> Bool -> ParanthesesCount
[pcActual] :: ParanthesesCount -> Integer
[pcHasReached0] :: ParanthesesCount -> Bool
data Context
ConStart :: Context
ConData :: Context
ConImplicit :: Context
ConNamelist :: Context
ConCommon :: Context
data ParseState a
ParseState :: a -> ParanthesesCount -> FortranVersion -> String -> [Context] -> ParseState a
[psAlexInput] :: ParseState a -> a
[psParanthesesCount] :: ParseState a -> ParanthesesCount
[psVersion] :: ParseState a -> FortranVersion
[psFilename] :: ParseState a -> String
[psContext] :: ParseState a -> [Context]
data ParseError a b
ParseError :: Position -> Maybe b -> String -> String -> ParseError a b
[errPos] :: ParseError a b -> Position
[errLastToken] :: ParseError a b -> Maybe b
[errFilename] :: ParseError a b -> String
[errMsg] :: ParseError a b -> String
tokenMsg :: Show a => Maybe a -> [Char]
data ParseResult b c a
ParseOk :: a -> (ParseState b) -> ParseResult b c a
ParseFailed :: (ParseError b c) -> ParseResult b c a
data ParseErrorSimple
ParseErrorSimple :: Position -> String -> String -> ParseErrorSimple
[errorPos] :: ParseErrorSimple -> Position
[errorFilename] :: ParseErrorSimple -> String
[errorMsg] :: ParseErrorSimple -> String
fromParseResultUnsafe :: (Show c) => ParseResult b c a -> a
fromRight :: Show a => Either a b -> b
fromParseResult :: (Show c) => ParseResult b c a -> Either ParseErrorSimple a
class LastToken a b | a -> b
getLastToken :: (LastToken a b, (Show b)) => a -> Maybe b
newtype Parse b c a
Parse :: (ParseState b -> ParseResult b c a) -> Parse b c a
[unParse] :: Parse b c a -> ParseState b -> ParseResult b c a
getVersion :: (Loc a, LastToken a b, Show b) => Parse a b FortranVersion
putAlex :: (Loc a, LastToken a b, Show b) => a -> Parse a b ()
getAlex :: (Loc a, LastToken a b, Show b) => Parse a b a
topContext :: (Loc a, LastToken a b, Show b) => Parse a b Context
popContext :: (Loc a, LastToken a b, Show b) => Parse a b ()
pushContext :: (Loc a, LastToken a b, Show b) => Context -> Parse a b ()
getPosition :: (Loc a, LastToken a b, Show b) => Parse a b Position
getSrcSpan :: (Loc a, LastToken a b, Show b) => Position -> Parse a b SrcSpan
getParanthesesCount :: (Loc a, LastToken a b, Show b) => Parse a b ParanthesesCount
resetPar :: (Loc a, LastToken a b, Show b) => Parse a b ()
incPar :: (Loc a, LastToken a b, Show b) => Parse a b ()
decPar :: (Loc a, LastToken a b, Show b) => Parse a b ()
throwIOerror :: () => String -> a
runParse :: (Loc b, LastToken b c, Show c) => Parse b c a -> ParseState b -> ParseResult b c a
runParseUnsafe :: (Loc b, LastToken b c, Show c) => Parse b c a -> ParseState b -> (a, ParseState b)
evalParse :: (Loc b, LastToken b c, Show c) => Parse b c a -> ParseState b -> a
execParse :: (Loc b, LastToken b c, Show c) => Parse b c a -> ParseState b -> ParseState b
class Tok a
eofToken :: Tok a => a -> Bool
collectTokens :: forall a b. (Loc b, Tok a, LastToken b a, Show a) => Parse b a a -> ParseState b -> [a]
collectTokensSafe :: forall a b. (Loc b, Tok a, LastToken b a, Show a) => Parse b a a -> ParseState b -> Maybe [a]
instance GHC.Show.Show a => GHC.Show.Show (Language.Fortran.ParserMonad.ParseState a)
instance GHC.Classes.Eq Language.Fortran.ParserMonad.Context
instance GHC.Show.Show Language.Fortran.ParserMonad.Context
instance GHC.Classes.Eq Language.Fortran.ParserMonad.ParanthesesCount
instance GHC.Show.Show Language.Fortran.ParserMonad.ParanthesesCount
instance GHC.Generics.Generic Language.Fortran.ParserMonad.FortranVersion
instance Data.Data.Data Language.Fortran.ParserMonad.FortranVersion
instance GHC.Classes.Eq Language.Fortran.ParserMonad.FortranVersion
instance GHC.Classes.Ord Language.Fortran.ParserMonad.FortranVersion
instance (Language.Fortran.Util.Position.Loc b, Language.Fortran.ParserMonad.LastToken b c, GHC.Show.Show c) => GHC.Base.Monad (Language.Fortran.ParserMonad.Parse b c)
instance (Language.Fortran.Util.Position.Loc b, Language.Fortran.ParserMonad.LastToken b c, GHC.Show.Show c) => GHC.Base.Functor (Language.Fortran.ParserMonad.Parse b c)
instance (Language.Fortran.Util.Position.Loc b, Language.Fortran.ParserMonad.LastToken b c, GHC.Show.Show c) => GHC.Base.Applicative (Language.Fortran.ParserMonad.Parse b c)
instance (Language.Fortran.Util.Position.Loc b, Language.Fortran.ParserMonad.LastToken b c, GHC.Show.Show c) => Control.Monad.State.Class.MonadState (Language.Fortran.ParserMonad.ParseState b) (Language.Fortran.ParserMonad.Parse b c)
instance (Language.Fortran.Util.Position.Loc b, Language.Fortran.ParserMonad.LastToken b c, GHC.Show.Show c) => Control.Monad.Error.Class.MonadError (Language.Fortran.ParserMonad.ParseError b c) (Language.Fortran.ParserMonad.Parse b c)
instance GHC.Show.Show Language.Fortran.ParserMonad.ParseErrorSimple
instance GHC.Base.Functor (Language.Fortran.ParserMonad.ParseResult b c)
instance GHC.Show.Show b => GHC.Show.Show (Language.Fortran.ParserMonad.ParseError a b)
instance (Data.Typeable.Internal.Typeable a, Data.Typeable.Internal.Typeable b, GHC.Show.Show a, GHC.Show.Show b) => GHC.Exception.Exception (Language.Fortran.ParserMonad.ParseError a b)
instance GHC.Show.Show Language.Fortran.ParserMonad.FortranVersion

module Language.Fortran.Intrinsics

-- | Obtain set of intrinsics that are most closely aligned with given
--   version.
getVersionIntrinsics :: FortranVersion -> IntrinsicsTable
getIntrinsicReturnType :: String -> IntrinsicsTable -> Maybe IntrinsicType
getIntrinsicNames :: IntrinsicsTable -> [String]
getIntrinsicDefsUses :: String -> IntrinsicsTable -> Maybe ([Int], [Int])
isIntrinsic :: String -> IntrinsicsTable -> Bool
data IntrinsicType
ITReal :: IntrinsicType
ITInteger :: IntrinsicType
ITComplex :: IntrinsicType
ITDouble :: IntrinsicType
ITLogical :: IntrinsicType
ITParam :: Int -> IntrinsicType
type IntrinsicsTable = Map String IntrinsicsEntry
allIntrinsics :: IntrinsicsTable
instance GHC.Generics.Generic Language.Fortran.Intrinsics.IntrinsicsEntry
instance GHC.Classes.Ord Language.Fortran.Intrinsics.IntrinsicsEntry
instance GHC.Classes.Eq Language.Fortran.Intrinsics.IntrinsicsEntry
instance GHC.Show.Show Language.Fortran.Intrinsics.IntrinsicsEntry
instance GHC.Generics.Generic Language.Fortran.Intrinsics.IntrinsicType
instance GHC.Classes.Ord Language.Fortran.Intrinsics.IntrinsicType
instance GHC.Classes.Eq Language.Fortran.Intrinsics.IntrinsicType
instance GHC.Show.Show Language.Fortran.Intrinsics.IntrinsicType

module Language.Fortran.Lexer.FreeForm
alex_tab_size :: Int
alex_base :: AlexAddr
alex_table :: AlexAddr
alex_check :: AlexAddr
alex_deflt :: AlexAddr
alex_accept :: Array Int AlexAcc User
alex_actions :: Array Int LexAction Maybe Token
alexIndexInt32OffAddr :: AlexAddr -> Int# -> Int#
quickIndex :: Array Int AlexAcc User -> Int -> AlexAcc User
data AlexReturn a
AlexEOF :: AlexReturn a
AlexError :: !AlexInput -> AlexReturn a
AlexSkip :: !AlexInput -> !Int -> AlexReturn a
AlexToken :: !AlexInput -> !Int -> a -> AlexReturn a
alexScan :: AlexInput -> Int -> AlexReturn LexAction Maybe Token
alex_scan_tkn :: User -> AlexInput -> Int# -> AlexInput -> Int# -> AlexLastAcc -> (AlexLastAcc, AlexInput)
data AlexLastAcc
AlexNone :: AlexLastAcc
AlexLastAcc :: !Int -> !AlexInput -> !Int -> AlexLastAcc
AlexLastSkip :: !AlexInput -> !Int -> AlexLastAcc
data AlexAcc user
AlexAccNone :: AlexAcc user
AlexAcc :: Int -> AlexAcc user
AlexAccSkip :: AlexAcc user
AlexAccPred :: Int -> (AlexAccPred user) -> (AlexAcc user) -> AlexAcc user
AlexAccSkipPred :: (AlexAccPred user) -> (AlexAcc user) -> AlexAcc user
type AlexAccPred user = user -> AlexInput -> Int -> AlexInput -> Bool
alexAndPred :: () => (t1 -> t2 -> t3 -> t4 -> Bool) -> (t1 -> t2 -> t3 -> t4 -> Bool) -> t1 -> t2 -> t3 -> t4 -> Bool
alexPrevCharIs :: () => Char -> p1 -> AlexInput -> p2 -> p3 -> Bool
alexPrevCharMatches :: () => (Char -> t) -> p1 -> AlexInput -> p2 -> p3 -> t
alexPrevCharIsOneOf :: () => Array Char e -> p1 -> AlexInput -> p2 -> p3 -> e
alexRightContext :: Int -> AlexAccPred User
formatP :: User -> AlexInput -> Int -> AlexInput -> Bool
followsDoP :: User -> AlexInput -> Int -> AlexInput -> Bool
followsColonP :: User -> AlexInput -> Int -> AlexInput -> Bool
selectorP :: User -> AlexInput -> Int -> AlexInput -> Bool
ifConditionEndP :: User -> AlexInput -> Int -> AlexInput -> Bool
opP :: User -> AlexInput -> Int -> AlexInput -> Bool
partOfExpOrPointerAssignmentP :: User -> AlexInput -> Int -> AlexInput -> Bool
precedesDoubleColon :: AlexInput -> Bool
attributeP :: User -> AlexInput -> Int -> AlexInput -> Bool
constructNameP :: User -> AlexInput -> Int -> AlexInput -> Bool
genericSpecP :: User -> AlexInput -> Int -> AlexInput -> Bool
notDefinedOperP :: User -> AlexInput -> Int -> AlexInput -> Bool
typeSpecP :: User -> AlexInput -> Int -> AlexInput -> Bool
resultP :: User -> AlexInput -> Int -> AlexInput -> Bool
notPrecedingDotP :: User -> AlexInput -> Int -> AlexInput -> Bool
followsIntentP :: User -> AlexInput -> Int -> AlexInput -> Bool
useStP :: User -> AlexInput -> Int -> AlexInput -> Bool
caseStP :: User -> AlexInput -> Int -> AlexInput -> Bool
assignStP :: User -> AlexInput -> Int -> AlexInput -> Bool
prevTokenConstr :: AlexInput -> Maybe Constr
nextTokenConstr :: User -> AlexInput -> Maybe Constr
seenConstr :: Constr -> AlexInput -> Bool
fillConstr :: () => (a -> Token) -> Constr
adjustComment :: LexAction (Maybe Token) -> LexAction (Maybe Token)
leftPar :: LexAction (Maybe Token)
comma :: LexAction (Maybe Token)
slashOrDivision :: LexAction (Maybe Token)
addSpan :: (SrcSpan -> Token) -> LexAction (Maybe Token)
addSpanAndMatch :: (SrcSpan -> String -> Token) -> LexAction (Maybe Token)
getLexeme :: LexAction Lexeme
putLexeme :: Lexeme -> LexAction ()
resetLexeme :: LexAction ()
getMatch :: LexAction String
putMatch :: String -> LexAction ()
updatePreviousToken :: Maybe Token -> LexAction ()
addToPreviousTokensInLine :: Token -> LexAction ()
checkPreviousTokensInLine :: (Token -> Bool) -> AlexInput -> Bool
getLexemeSpan :: LexAction SrcSpan
lexCharacter :: LexAction (Maybe Token)
toSC :: Int -> LexAction ()
stabiliseStartCode :: LexAction ()
normaliseStartCode :: LexAction ()
invalidPosition :: Position
isValidPosition :: Position -> Bool
data Lexeme
Lexeme :: !String -> {-# UNPACK #-} !Position -> {-# UNPACK #-} !Position -> !Bool -> Lexeme
[lexemeMatch] :: Lexeme -> !String
[lexemeStart] :: Lexeme -> {-# UNPACK #-} !Position
[lexemeEnd] :: Lexeme -> {-# UNPACK #-} !Position
[lexemeIsCmt] :: Lexeme -> !Bool
initLexeme :: Lexeme
data StartCodeStatus
Return :: StartCodeStatus
Stable :: StartCodeStatus
data StartCode
StartCode :: {-# UNPACK #-} !Int -> !StartCodeStatus -> StartCode
[scActual] :: StartCode -> {-# UNPACK #-} !Int
[scStatus] :: StartCode -> !StartCodeStatus
data AlexInput
AlexInput :: !ByteString -> {-# UNPACK #-} !Position -> {-# UNPACK #-} !Int -> {-# UNPACK #-} !Char -> {-# UNPACK #-} !Lexeme -> {-# UNPACK #-} !StartCode -> !(Maybe Token) -> !([Token]) -> AlexInput
[aiSourceBytes] :: AlexInput -> !ByteString
[aiPosition] :: AlexInput -> {-# UNPACK #-} !Position
[aiEndOffset] :: AlexInput -> {-# UNPACK #-} !Int
[aiPreviousChar] :: AlexInput -> {-# UNPACK #-} !Char
[aiLexeme] :: AlexInput -> {-# UNPACK #-} !Lexeme
[aiStartCode] :: AlexInput -> {-# UNPACK #-} !StartCode
[aiPreviousToken] :: AlexInput -> !(Maybe Token)
[aiPreviousTokensInLine] :: AlexInput -> !([Token])
type LexAction a = Parse AlexInput Token a
vanillaAlexInput :: AlexInput
updateLexeme :: Char -> Position -> AlexInput -> AlexInput
data User
User :: FortranVersion -> ParanthesesCount -> User
data Move
Continuation :: Move
Char :: Move
Newline :: Move
alexGetByte :: AlexInput -> Maybe (Word8, AlexInput)
alexInputPrevChar :: AlexInput -> Char
currentChar :: AlexInput -> Char
advanceWithoutContinuation :: AlexInput -> Maybe AlexInput
isContinuation :: AlexInput -> Bool
skipContinuation :: AlexInput -> AlexInput
advance :: Move -> Position -> Position
lexer :: (Token -> LexAction a) -> LexAction a
lexer' :: LexAction Token
alexScanUser :: User -> AlexInput -> Int -> AlexReturn (LexAction (Maybe Token))
data Token
TId :: SrcSpan -> String -> Token
TComment :: SrcSpan -> String -> Token
TString :: SrcSpan -> String -> Token
TIntegerLiteral :: SrcSpan -> String -> Token
TRealLiteral :: SrcSpan -> String -> Token
TBozLiteral :: SrcSpan -> String -> Token
TComma :: SrcSpan -> Token
TComma2 :: SrcSpan -> Token
TSemiColon :: SrcSpan -> Token
TColon :: SrcSpan -> Token
TDoubleColon :: SrcSpan -> Token
TOpAssign :: SrcSpan -> Token
TArrow :: SrcSpan -> Token
TPercent :: SrcSpan -> Token
TLeftPar :: SrcSpan -> Token
TLeftPar2 :: SrcSpan -> Token
TRightPar :: SrcSpan -> Token
TLeftInitPar :: SrcSpan -> Token
TRightInitPar :: SrcSpan -> Token
TOpCustom :: SrcSpan -> String -> Token
TOpExp :: SrcSpan -> Token
TOpPlus :: SrcSpan -> Token
TOpMinus :: SrcSpan -> Token
TStar :: SrcSpan -> Token
TOpDivision :: SrcSpan -> Token
TSlash :: SrcSpan -> Token
TOpOr :: SrcSpan -> Token
TOpAnd :: SrcSpan -> Token
TOpNot :: SrcSpan -> Token
TOpEquivalent :: SrcSpan -> Token
TOpNotEquivalent :: SrcSpan -> Token
TOpLT :: SrcSpan -> Token
TOpLE :: SrcSpan -> Token
TOpEQ :: SrcSpan -> Token
TOpNE :: SrcSpan -> Token
TOpGT :: SrcSpan -> Token
TOpGE :: SrcSpan -> Token
TLogicalLiteral :: SrcSpan -> String -> Token
TProgram :: SrcSpan -> Token
TEndProgram :: SrcSpan -> Token
TFunction :: SrcSpan -> Token
TEndFunction :: SrcSpan -> Token
TResult :: SrcSpan -> Token
TRecursive :: SrcSpan -> Token
TSubroutine :: SrcSpan -> Token
TEndSubroutine :: SrcSpan -> Token
TBlockData :: SrcSpan -> Token
TEndBlockData :: SrcSpan -> Token
TModule :: SrcSpan -> Token
TEndModule :: SrcSpan -> Token
TContains :: SrcSpan -> Token
TUse :: SrcSpan -> Token
TOnly :: SrcSpan -> Token
TInterface :: SrcSpan -> Token
TEndInterface :: SrcSpan -> Token
TModuleProcedure :: SrcSpan -> Token
TAssignment :: SrcSpan -> Token
TOperator :: SrcSpan -> Token
TCall :: SrcSpan -> Token
TReturn :: SrcSpan -> Token
TEntry :: SrcSpan -> Token
TInclude :: SrcSpan -> Token
TPublic :: SrcSpan -> Token
TPrivate :: SrcSpan -> Token
TParameter :: SrcSpan -> Token
TAllocatable :: SrcSpan -> Token
TDimension :: SrcSpan -> Token
TExternal :: SrcSpan -> Token
TIntent :: SrcSpan -> Token
TIntrinsic :: SrcSpan -> Token
TOptional :: SrcSpan -> Token
TPointer :: SrcSpan -> Token
TSave :: SrcSpan -> Token
TTarget :: SrcSpan -> Token
TIn :: SrcSpan -> Token
TOut :: SrcSpan -> Token
TInOut :: SrcSpan -> Token
TData :: SrcSpan -> Token
TNamelist :: SrcSpan -> Token
TImplicit :: SrcSpan -> Token
TEquivalence :: SrcSpan -> Token
TCommon :: SrcSpan -> Token
TFormat :: SrcSpan -> Token
TBlob :: SrcSpan -> String -> Token
TAllocate :: SrcSpan -> Token
TDeallocate :: SrcSpan -> Token
TNullify :: SrcSpan -> Token
TNone :: SrcSpan -> Token
TGoto :: SrcSpan -> Token
TAssign :: SrcSpan -> Token
TTo :: SrcSpan -> Token
TContinue :: SrcSpan -> Token
TStop :: SrcSpan -> Token
TPause :: SrcSpan -> Token
TDo :: SrcSpan -> Token
TEndDo :: SrcSpan -> Token
TWhile :: SrcSpan -> Token
TIf :: SrcSpan -> Token
TThen :: SrcSpan -> Token
TElse :: SrcSpan -> Token
TElsif :: SrcSpan -> Token
TEndIf :: SrcSpan -> Token
TCase :: SrcSpan -> Token
TSelectCase :: SrcSpan -> Token
TEndSelect :: SrcSpan -> Token
TDefault :: SrcSpan -> Token
TCycle :: SrcSpan -> Token
TExit :: SrcSpan -> Token
TForall :: SrcSpan -> Token
TEndForall :: SrcSpan -> Token
TWhere :: SrcSpan -> Token
TElsewhere :: SrcSpan -> Token
TEndWhere :: SrcSpan -> Token
TType :: SrcSpan -> Token
TEndType :: SrcSpan -> Token
TSequence :: SrcSpan -> Token
TKind :: SrcSpan -> Token
TLen :: SrcSpan -> Token
TInteger :: SrcSpan -> Token
TReal :: SrcSpan -> Token
TDoublePrecision :: SrcSpan -> Token
TLogical :: SrcSpan -> Token
TCharacter :: SrcSpan -> Token
TComplex :: SrcSpan -> Token
TOpen :: SrcSpan -> Token
TClose :: SrcSpan -> Token
TRead :: SrcSpan -> Token
TWrite :: SrcSpan -> Token
TPrint :: SrcSpan -> Token
TBackspace :: SrcSpan -> Token
TRewind :: SrcSpan -> Token
TInquire :: SrcSpan -> Token
TEndfile :: SrcSpan -> Token
TEnd :: SrcSpan -> Token
TNewline :: SrcSpan -> Token
TEOF :: SrcSpan -> Token
class SpecifiesType a
isTypeSpec :: SpecifiesType a => a -> Bool
initParseState :: ByteString -> FortranVersion -> String -> ParseState AlexInput
collectFreeTokens :: FortranVersion -> ByteString -> [Token]
scC :: Int
scI :: Int
scN :: Int
scT :: Int
alex_action_0 :: LexAction Maybe Token
alex_action_1 :: Parse AlexInput Token Maybe Token
alex_action_3 :: LexAction Maybe Token
alex_action_4 :: Parse AlexInput Token Maybe Token
alex_action_5 :: Parse AlexInput Token Maybe Token
alex_action_6 :: LexAction Maybe Token
alex_action_7 :: LexAction Maybe Token
alex_action_8 :: LexAction Maybe Token
alex_action_9 :: Parse AlexInput Token Maybe Token
alex_action_10 :: LexAction Maybe Token
alex_action_11 :: LexAction Maybe Token
alex_action_12 :: LexAction Maybe Token
alex_action_13 :: LexAction Maybe Token
alex_action_14 :: LexAction Maybe Token
alex_action_15 :: LexAction Maybe Token
alex_action_16 :: LexAction Maybe Token
alex_action_17 :: LexAction Maybe Token
alex_action_18 :: LexAction Maybe Token
alex_action_19 :: LexAction Maybe Token
alex_action_20 :: LexAction Maybe Token
alex_action_21 :: LexAction Maybe Token
alex_action_22 :: LexAction Maybe Token
alex_action_23 :: Parse AlexInput Token Maybe Token
alex_action_24 :: Parse AlexInput Token Maybe Token
alex_action_25 :: LexAction Maybe Token
alex_action_26 :: LexAction Maybe Token
alex_action_27 :: LexAction Maybe Token
alex_action_28 :: LexAction Maybe Token
alex_action_29 :: LexAction Maybe Token
alex_action_30 :: LexAction Maybe Token
alex_action_31 :: LexAction Maybe Token
alex_action_32 :: LexAction Maybe Token
alex_action_33 :: LexAction Maybe Token
alex_action_34 :: LexAction Maybe Token
alex_action_35 :: LexAction Maybe Token
alex_action_36 :: LexAction Maybe Token
alex_action_37 :: LexAction Maybe Token
alex_action_38 :: LexAction Maybe Token
alex_action_39 :: LexAction Maybe Token
alex_action_40 :: LexAction Maybe Token
alex_action_41 :: LexAction Maybe Token
alex_action_42 :: LexAction Maybe Token
alex_action_43 :: LexAction Maybe Token
alex_action_44 :: LexAction Maybe Token
alex_action_45 :: LexAction Maybe Token
alex_action_46 :: LexAction Maybe Token
alex_action_47 :: LexAction Maybe Token
alex_action_48 :: LexAction Maybe Token
alex_action_49 :: LexAction Maybe Token
alex_action_50 :: LexAction Maybe Token
alex_action_51 :: LexAction Maybe Token
alex_action_52 :: LexAction Maybe Token
alex_action_53 :: LexAction Maybe Token
alex_action_54 :: LexAction Maybe Token
alex_action_55 :: LexAction Maybe Token
alex_action_56 :: LexAction Maybe Token
alex_action_57 :: LexAction Maybe Token
alex_action_58 :: LexAction Maybe Token
alex_action_59 :: LexAction Maybe Token
alex_action_60 :: LexAction Maybe Token
alex_action_61 :: LexAction Maybe Token
alex_action_62 :: LexAction Maybe Token
alex_action_63 :: LexAction Maybe Token
alex_action_64 :: LexAction Maybe Token
alex_action_65 :: LexAction Maybe Token
alex_action_66 :: LexAction Maybe Token
alex_action_67 :: LexAction Maybe Token
alex_action_68 :: LexAction Maybe Token
alex_action_69 :: LexAction Maybe Token
alex_action_70 :: LexAction Maybe Token
alex_action_71 :: LexAction Maybe Token
alex_action_72 :: LexAction Maybe Token
alex_action_73 :: LexAction Maybe Token
alex_action_74 :: LexAction Maybe Token
alex_action_75 :: LexAction Maybe Token
alex_action_76 :: LexAction Maybe Token
alex_action_77 :: LexAction Maybe Token
alex_action_78 :: LexAction Maybe Token
alex_action_79 :: LexAction Maybe Token
alex_action_80 :: LexAction Maybe Token
alex_action_81 :: LexAction Maybe Token
alex_action_82 :: LexAction Maybe Token
alex_action_83 :: LexAction Maybe Token
alex_action_84 :: LexAction Maybe Token
alex_action_85 :: LexAction Maybe Token
alex_action_86 :: LexAction Maybe Token
alex_action_87 :: LexAction Maybe Token
alex_action_88 :: LexAction Maybe Token
alex_action_89 :: LexAction Maybe Token
alex_action_90 :: LexAction Maybe Token
alex_action_91 :: LexAction Maybe Token
alex_action_92 :: LexAction Maybe Token
alex_action_93 :: LexAction Maybe Token
alex_action_94 :: LexAction Maybe Token
alex_action_95 :: LexAction Maybe Token
alex_action_96 :: LexAction Maybe Token
alex_action_97 :: LexAction Maybe Token
alex_action_98 :: LexAction Maybe Token
alex_action_99 :: LexAction Maybe Token
alex_action_100 :: LexAction Maybe Token
alex_action_101 :: LexAction Maybe Token
alex_action_102 :: LexAction Maybe Token
alex_action_103 :: LexAction Maybe Token
alex_action_104 :: LexAction Maybe Token
alex_action_105 :: LexAction Maybe Token
alex_action_106 :: LexAction Maybe Token
alex_action_107 :: LexAction Maybe Token
alex_action_108 :: LexAction Maybe Token
alex_action_109 :: LexAction Maybe Token
alex_action_110 :: LexAction Maybe Token
alex_action_111 :: LexAction Maybe Token
alex_action_112 :: LexAction Maybe Token
alex_action_113 :: LexAction Maybe Token
alex_action_114 :: Parse AlexInput Token Maybe Token
alex_action_115 :: LexAction Maybe Token
alex_action_116 :: LexAction Maybe Token
alex_action_117 :: LexAction Maybe Token
alex_action_118 :: LexAction Maybe Token
alex_action_119 :: LexAction Maybe Token
alex_action_120 :: LexAction Maybe Token
alex_action_121 :: LexAction Maybe Token
alex_action_122 :: LexAction Maybe Token
alex_action_123 :: LexAction Maybe Token
alex_action_124 :: LexAction Maybe Token
alex_action_125 :: LexAction Maybe Token
alex_action_126 :: LexAction Maybe Token
alex_action_127 :: LexAction Maybe Token
alex_action_128 :: LexAction Maybe Token
alex_action_129 :: LexAction Maybe Token
alex_action_130 :: Parse AlexInput Token Maybe Token
alex_action_131 :: LexAction Maybe Token
alex_action_132 :: LexAction Maybe Token
alex_action_133 :: LexAction Maybe Token
alex_action_134 :: LexAction Maybe Token
alex_action_135 :: LexAction Maybe Token
alex_action_136 :: LexAction Maybe Token
alex_action_137 :: LexAction Maybe Token
alex_action_138 :: LexAction Maybe Token
alex_action_139 :: LexAction Maybe Token
alex_action_140 :: LexAction Maybe Token
alex_action_141 :: LexAction Maybe Token
alex_action_142 :: LexAction Maybe Token
alex_action_143 :: LexAction Maybe Token
alex_action_144 :: LexAction Maybe Token
alex_action_145 :: LexAction Maybe Token
alex_action_146 :: LexAction Maybe Token
alex_action_147 :: LexAction Maybe Token
alex_action_148 :: LexAction Maybe Token
alex_action_149 :: LexAction Maybe Token
alex_action_150 :: LexAction Maybe Token
alex_action_151 :: LexAction Maybe Token
alex_action_152 :: LexAction Maybe Token
alex_action_153 :: LexAction Maybe Token
alex_action_154 :: LexAction Maybe Token
alex_action_155 :: LexAction Maybe Token
data AlexAddr
AlexA# :: Addr# -> AlexAddr
alexIndexInt16OffAddr :: AlexAddr -> Int# -> Int#
instance GHC.Show.Show Language.Fortran.Lexer.FreeForm.AlexInput
instance GHC.Generics.Generic Language.Fortran.Lexer.FreeForm.Token
instance Data.Data.Data Language.Fortran.Lexer.FreeForm.Token
instance GHC.Show.Show Language.Fortran.Lexer.FreeForm.Token
instance GHC.Classes.Eq Language.Fortran.Lexer.FreeForm.Token
instance GHC.Show.Show Language.Fortran.Lexer.FreeForm.StartCode
instance GHC.Show.Show Language.Fortran.Lexer.FreeForm.StartCodeStatus
instance GHC.Show.Show Language.Fortran.Lexer.FreeForm.Lexeme
instance Language.Fortran.Lexer.FreeForm.SpecifiesType Language.Fortran.Lexer.FreeForm.Token
instance Language.Fortran.Lexer.FreeForm.SpecifiesType [Language.Fortran.Lexer.FreeForm.Token]
instance Language.Fortran.Util.Position.Loc Language.Fortran.Lexer.FreeForm.AlexInput
instance Language.Fortran.ParserMonad.LastToken Language.Fortran.Lexer.FreeForm.AlexInput Language.Fortran.Lexer.FreeForm.Token
instance Language.Fortran.Util.FirstParameter.FirstParameter Language.Fortran.Lexer.FreeForm.Token Language.Fortran.Util.Position.SrcSpan
instance Language.Fortran.Util.FirstParameter.FirstParameter Language.Fortran.Lexer.FreeForm.Token Language.Fortran.Util.Position.SrcSpan => Language.Fortran.Util.Position.Spanned Language.Fortran.Lexer.FreeForm.Token
instance Language.Fortran.ParserMonad.Tok Language.Fortran.Lexer.FreeForm.Token
instance Language.Fortran.Util.Position.Spanned Language.Fortran.Lexer.FreeForm.Lexeme

module Language.Fortran.Lexer.FixedForm
alex_tab_size :: Int
alex_base :: AlexAddr
alex_table :: AlexAddr
alex_check :: AlexAddr
alex_deflt :: AlexAddr
alex_accept :: Array Int AlexAcc FortranVersion
alex_actions :: Array Int LexAction Maybe Token
alexIndexInt32OffAddr :: AlexAddr -> Int# -> Int#
quickIndex :: Array Int AlexAcc FortranVersion -> Int -> AlexAcc FortranVersion
data AlexReturn a
AlexEOF :: AlexReturn a
AlexError :: !AlexInput -> AlexReturn a
AlexSkip :: !AlexInput -> !Int -> AlexReturn a
AlexToken :: !AlexInput -> !Int -> a -> AlexReturn a
alexScan :: AlexInput -> Int -> AlexReturn LexAction Maybe Token
alex_scan_tkn :: FortranVersion -> AlexInput -> Int# -> AlexInput -> Int# -> AlexLastAcc -> (AlexLastAcc, AlexInput)
data AlexLastAcc
AlexNone :: AlexLastAcc
AlexLastAcc :: !Int -> !AlexInput -> !Int -> AlexLastAcc
AlexLastSkip :: !AlexInput -> !Int -> AlexLastAcc
data AlexAcc user
AlexAccNone :: AlexAcc user
AlexAcc :: Int -> AlexAcc user
AlexAccSkip :: AlexAcc user
AlexAccPred :: Int -> (AlexAccPred user) -> (AlexAcc user) -> AlexAcc user
AlexAccSkipPred :: (AlexAccPred user) -> (AlexAcc user) -> AlexAcc user
type AlexAccPred user = user -> AlexInput -> Int -> AlexInput -> Bool
alexAndPred :: () => (t1 -> t2 -> t3 -> t4 -> Bool) -> (t1 -> t2 -> t3 -> t4 -> Bool) -> t1 -> t2 -> t3 -> t4 -> Bool
alexPrevCharIs :: () => Char -> p1 -> AlexInput -> p2 -> p3 -> Bool
alexPrevCharMatches :: () => (Char -> t) -> p1 -> AlexInput -> p2 -> p3 -> t
alexPrevCharIsOneOf :: () => Array Char e -> p1 -> AlexInput -> p2 -> p3 -> e
alexRightContext :: () => Int -> FortranVersion -> p1 -> p2 -> AlexInput -> Bool
formatP :: FortranVersion -> AlexInput -> Int -> AlexInput -> Bool
formatExtendedP :: FortranVersion -> AlexInput -> Int -> AlexInput -> Bool
implicitType77P :: FortranVersion -> AlexInput -> Int -> AlexInput -> Bool
implicitTypeExtendedP :: FortranVersion -> AlexInput -> Int -> AlexInput -> Bool
implicitStP :: FortranVersion -> AlexInput -> Int -> AlexInput -> Bool
extendedIdP :: FortranVersion -> AlexInput -> Int -> AlexInput -> Bool
idP :: FortranVersion -> AlexInput -> Int -> AlexInput -> Bool
doP :: FortranVersion -> AlexInput -> Bool
equalFollowsP :: FortranVersion -> AlexInput -> Bool
commentP :: FortranVersion -> AlexInput -> Int -> AlexInput -> Bool
withinLabelColsP :: FortranVersion -> AlexInput -> Int -> AlexInput -> Bool
atColP :: Int -> AlexInput -> Bool
exponentP :: FortranVersion -> AlexInput -> Int -> AlexInput -> Bool
fortran66P :: FortranVersion -> AlexInput -> Int -> AlexInput -> Bool
fortran77P :: FortranVersion -> AlexInput -> Int -> AlexInput -> Bool
extended77P :: FortranVersion -> AlexInput -> Int -> AlexInput -> Bool
addSpan :: (SrcSpan -> Token) -> LexAction (Maybe Token)
addSpanAndMatch :: (SrcSpan -> String -> Token) -> LexAction (Maybe Token)
getLexeme :: LexAction Lexeme
putLexeme :: Lexeme -> LexAction ()
resetLexeme :: LexAction ()
getMatch :: LexAction String
putMatch :: String -> LexAction ()
incWhiteSensitiveCharCount :: LexAction ()
resetWhiteSensitiveCharCount :: LexAction ()
updatePreviousToken :: Maybe Token -> LexAction ()
addToPreviousTokensInLine :: Token -> LexAction ()
checkPreviousTokensInLine :: (Token -> Bool) -> AlexInput -> Bool
getLexemeSpan :: LexAction SrcSpan
lexComment :: Maybe Char -> LexAction (Maybe Token)
strAutomaton :: Int -> LexAction (Maybe Token)
lexHollerith :: LexAction (Maybe Token)
lexN :: Int -> LexAction (Maybe String)
maybeToKeyword :: LexAction (Maybe Token)
typeSCChange :: LexAction (Maybe Token)
toSC :: Int -> LexAction (Maybe Token)
data Token
TLeftPar :: SrcSpan -> Token
TRightPar :: SrcSpan -> Token
TLeftArrayPar :: SrcSpan -> Token
TRightArrayPar :: SrcSpan -> Token
TComma :: SrcSpan -> Token
TDot :: SrcSpan -> Token
TColon :: SrcSpan -> Token
TInclude :: SrcSpan -> Token
TProgram :: SrcSpan -> Token
TFunction :: SrcSpan -> Token
TSubroutine :: SrcSpan -> Token
TBlockData :: SrcSpan -> Token
TEnd :: SrcSpan -> Token
TAssign :: SrcSpan -> Token
TOpAssign :: SrcSpan -> Token
TTo :: SrcSpan -> Token
TGoto :: SrcSpan -> Token
TIf :: SrcSpan -> Token
TThen :: SrcSpan -> Token
TElse :: SrcSpan -> Token
TElsif :: SrcSpan -> Token
TEndif :: SrcSpan -> Token
TCall :: SrcSpan -> Token
TReturn :: SrcSpan -> Token
TSave :: SrcSpan -> Token
TContinue :: SrcSpan -> Token
TStop :: SrcSpan -> Token
TExit :: SrcSpan -> Token
TPause :: SrcSpan -> Token
TDo :: SrcSpan -> Token
TDoWhile :: SrcSpan -> Token
TEndDo :: SrcSpan -> Token
TRead :: SrcSpan -> Token
TWrite :: SrcSpan -> Token
TRewind :: SrcSpan -> Token
TBackspace :: SrcSpan -> Token
TEndfile :: SrcSpan -> Token
TInquire :: SrcSpan -> Token
TOpen :: SrcSpan -> Token
TClose :: SrcSpan -> Token
TPrint :: SrcSpan -> Token
TDimension :: SrcSpan -> Token
TCommon :: SrcSpan -> Token
TEquivalence :: SrcSpan -> Token
TExternal :: SrcSpan -> Token
TIntrinsic :: SrcSpan -> Token
TType :: SrcSpan -> String -> Token
TEntry :: SrcSpan -> Token
TImplicit :: SrcSpan -> Token
TNone :: SrcSpan -> Token
TParameter :: SrcSpan -> Token
TData :: SrcSpan -> Token
TFormat :: SrcSpan -> Token
TBlob :: SrcSpan -> String -> Token
TInt :: SrcSpan -> String -> Token
TExponent :: SrcSpan -> String -> Token
TBool :: SrcSpan -> String -> Token
TOpPlus :: SrcSpan -> Token
TOpMinus :: SrcSpan -> Token
TOpExp :: SrcSpan -> Token
TStar :: SrcSpan -> Token
TSlash :: SrcSpan -> Token
TOpOr :: SrcSpan -> Token
TOpAnd :: SrcSpan -> Token
TOpNot :: SrcSpan -> Token
TOpEquivalent :: SrcSpan -> Token
TOpNotEquivalent :: SrcSpan -> Token
TOpLT :: SrcSpan -> Token
TOpLE :: SrcSpan -> Token
TOpEQ :: SrcSpan -> Token
TOpNE :: SrcSpan -> Token
TOpGT :: SrcSpan -> Token
TOpGE :: SrcSpan -> Token
TId :: SrcSpan -> String -> Token
TComment :: SrcSpan -> String -> Token
TString :: SrcSpan -> String -> Token
THollerith :: SrcSpan -> String -> Token
TLabel :: SrcSpan -> String -> Token
TNewline :: SrcSpan -> Token
TEOF :: SrcSpan -> Token
data Lexeme
Lexeme :: String -> Maybe Position -> Maybe Position -> Lexeme
[lexemeMatch] :: Lexeme -> String
[lexemeStart] :: Lexeme -> Maybe Position
[lexemeEnd] :: Lexeme -> Maybe Position
initLexeme :: Lexeme
data AlexInput
AlexInput :: ByteString -> Int -> Position -> [Word8] -> Char -> Lexeme -> Int -> Int -> Maybe Token -> [Token] -> AlexInput
[aiSourceBytes] :: AlexInput -> ByteString
[aiEndOffset] :: AlexInput -> Int
[aiPosition] :: AlexInput -> Position
[aiBytes] :: AlexInput -> [Word8]
[aiPreviousChar] :: AlexInput -> Char
[aiLexeme] :: AlexInput -> Lexeme
[aiWhiteSensitiveCharCount] :: AlexInput -> Int
[aiStartCode] :: AlexInput -> Int
[aiPreviousToken] :: AlexInput -> Maybe Token
[aiPreviousTokensInLine] :: AlexInput -> [Token]
type LexAction a = Parse AlexInput Token a
vanillaAlexInput :: AlexInput
updateLexeme :: Maybe Char -> Position -> AlexInput -> AlexInput
data Move
Continuation :: Move
Char :: Move
Newline :: Move
alexGetByte :: AlexInput -> Maybe (Word8, AlexInput)
alexInputPrevChar :: AlexInput -> Char
takeNChars :: Integer -> AlexInput -> String
currentChar :: AlexInput -> Char
isContinuation :: AlexInput -> Bool
skip :: Move -> AlexInput -> Maybe (Word8, AlexInput)
advance :: Move -> Position -> Position
utf8Encode :: Char -> [Word8]
lexer :: (Token -> LexAction a) -> LexAction a
lexer' :: LexAction Token
alexScanUser :: FortranVersion -> AlexInput -> Int -> AlexReturn (LexAction (Maybe Token))
initParseState :: ByteString -> FortranVersion -> String -> ParseState AlexInput
collectFixedTokens :: FortranVersion -> ByteString -> [Token]
collectFixedTokensSafe :: FortranVersion -> ByteString -> Maybe [Token]
iif :: Int
keyword :: Int
st :: Int
alex_action_0 :: LexAction Maybe Token
alex_action_1 :: LexAction Maybe Token
alex_action_2 :: LexAction Maybe Token
alex_action_4 :: Parse AlexInput Token Maybe Token
alex_action_6 :: LexAction Maybe Token
alex_action_7 :: Parse AlexInput Token Maybe Token
alex_action_8 :: LexAction Maybe Token
alex_action_9 :: Parse AlexInput Token Maybe Token
alex_action_10 :: LexAction Maybe Token
alex_action_11 :: LexAction Maybe Token
alex_action_12 :: LexAction Maybe Token
alex_action_13 :: LexAction Maybe Token
alex_action_14 :: LexAction Maybe Token
alex_action_15 :: Parse AlexInput Token Maybe Token
alex_action_16 :: Parse AlexInput Token Maybe Token
alex_action_17 :: Parse AlexInput Token Maybe Token
alex_action_18 :: Parse AlexInput Token Maybe Token
alex_action_19 :: Parse AlexInput Token Maybe Token
alex_action_20 :: Parse AlexInput Token Maybe Token
alex_action_21 :: Parse AlexInput Token Maybe Token
alex_action_22 :: Parse AlexInput Token Maybe Token
alex_action_23 :: Parse AlexInput Token Maybe Token
alex_action_24 :: LexAction Maybe Token
alex_action_25 :: LexAction Maybe Token
alex_action_26 :: Parse AlexInput Token Maybe Token
alex_action_27 :: Parse AlexInput Token Maybe Token
alex_action_28 :: Parse AlexInput Token Maybe Token
alex_action_29 :: Parse AlexInput Token Maybe Token
alex_action_30 :: LexAction Maybe Token
alex_action_31 :: Parse AlexInput Token Maybe Token
alex_action_32 :: LexAction Maybe Token
alex_action_33 :: Parse AlexInput Token Maybe Token
alex_action_34 :: Parse AlexInput Token Maybe Token
alex_action_35 :: Parse AlexInput Token Maybe Token
alex_action_36 :: Parse AlexInput Token Maybe Token
alex_action_37 :: Parse AlexInput Token Maybe Token
alex_action_38 :: Parse AlexInput Token Maybe Token
alex_action_39 :: Parse AlexInput Token Maybe Token
alex_action_40 :: Parse AlexInput Token Maybe Token
alex_action_41 :: Parse AlexInput Token Maybe Token
alex_action_42 :: Parse AlexInput Token Maybe Token
alex_action_43 :: Parse AlexInput Token Maybe Token
alex_action_44 :: Parse AlexInput Token Maybe Token
alex_action_45 :: Parse AlexInput Token Maybe Token
alex_action_46 :: Parse AlexInput Token Maybe Token
alex_action_47 :: Parse AlexInput Token Maybe Token
alex_action_48 :: Parse AlexInput Token Maybe Token
alex_action_49 :: Parse AlexInput Token Maybe Token
alex_action_50 :: Parse AlexInput Token Maybe Token
alex_action_51 :: Parse AlexInput Token Maybe Token
alex_action_52 :: Parse AlexInput Token Maybe Token
alex_action_53 :: Parse AlexInput Token Maybe Token
alex_action_54 :: Parse AlexInput Token Maybe Token
alex_action_55 :: Parse AlexInput Token Maybe Token
alex_action_56 :: Parse AlexInput Token Maybe Token
alex_action_57 :: Parse AlexInput Token Maybe Token
alex_action_58 :: LexAction Maybe Token
alex_action_59 :: Parse AlexInput Token Maybe Token
alex_action_60 :: LexAction Maybe Token
alex_action_61 :: Parse AlexInput Token Maybe Token
alex_action_62 :: LexAction Maybe Token
alex_action_63 :: Parse AlexInput Token Maybe Token
alex_action_64 :: LexAction Maybe Token
alex_action_65 :: Parse AlexInput Token Maybe Token
alex_action_66 :: Parse AlexInput Token Maybe Token
alex_action_67 :: Parse AlexInput Token Maybe Token
alex_action_68 :: Parse AlexInput Token Maybe Token
alex_action_69 :: LexAction Maybe Token
alex_action_70 :: LexAction Maybe Token
alex_action_71 :: LexAction Maybe Token
alex_action_72 :: LexAction Maybe Token
alex_action_73 :: LexAction Maybe Token
alex_action_74 :: LexAction Maybe Token
alex_action_75 :: LexAction Maybe Token
alex_action_76 :: LexAction Maybe Token
alex_action_77 :: LexAction Maybe Token
alex_action_78 :: LexAction Maybe Token
alex_action_79 :: LexAction Maybe Token
alex_action_80 :: LexAction Maybe Token
alex_action_81 :: LexAction Maybe Token
alex_action_82 :: LexAction Maybe Token
alex_action_83 :: LexAction Maybe Token
alex_action_84 :: LexAction Maybe Token
alex_action_85 :: LexAction Maybe Token
alex_action_86 :: LexAction Maybe Token
alex_action_87 :: LexAction Maybe Token
alex_action_88 :: LexAction Maybe Token
alex_action_89 :: LexAction Maybe Token
alex_action_90 :: LexAction Maybe Token
alex_action_91 :: LexAction Maybe Token
alex_action_92 :: LexAction Maybe Token
alex_action_93 :: LexAction Maybe Token
alex_action_94 :: LexAction Maybe Token
alex_action_95 :: LexAction Maybe Token
alex_action_96 :: LexAction Maybe Token
alex_action_97 :: LexAction Maybe Token
alex_action_98 :: LexAction Maybe Token
data AlexAddr
AlexA# :: Addr# -> AlexAddr
alexIndexInt16OffAddr :: AlexAddr -> Int# -> Int#
instance GHC.Show.Show Language.Fortran.Lexer.FixedForm.AlexInput
instance GHC.Show.Show Language.Fortran.Lexer.FixedForm.Lexeme
instance GHC.Generics.Generic Language.Fortran.Lexer.FixedForm.Token
instance Data.Data.Data Language.Fortran.Lexer.FixedForm.Token
instance GHC.Classes.Ord Language.Fortran.Lexer.FixedForm.Token
instance GHC.Classes.Eq Language.Fortran.Lexer.FixedForm.Token
instance GHC.Show.Show Language.Fortran.Lexer.FixedForm.Token
instance Language.Fortran.Util.Position.Loc Language.Fortran.Lexer.FixedForm.AlexInput
instance Language.Fortran.ParserMonad.LastToken Language.Fortran.Lexer.FixedForm.AlexInput Language.Fortran.Lexer.FixedForm.Token
instance Language.Fortran.Util.Position.Spanned Language.Fortran.Lexer.FixedForm.Lexeme
instance Language.Fortran.Util.FirstParameter.FirstParameter Language.Fortran.Lexer.FixedForm.Token Language.Fortran.Util.Position.SrcSpan
instance Language.Fortran.Util.FirstParameter.FirstParameter Language.Fortran.Lexer.FixedForm.Token Language.Fortran.Util.Position.SrcSpan => Language.Fortran.Util.Position.Spanned Language.Fortran.Lexer.FixedForm.Token
instance Language.Fortran.ParserMonad.Tok Language.Fortran.Lexer.FixedForm.Token

module Language.Fortran.AST
type A0 = ()
type Name = String
data AList t a
AList :: a -> SrcSpan -> [t a] -> AList t a
fromList :: Spanned (t a) => a -> [t a] -> AList t a
fromReverseList :: Spanned (t ()) => [t ()] -> AList t ()
aCons :: t a -> AList t a -> AList t a
infixr 5 `aCons`
aReverse :: AList t a -> AList t a
aStrip :: AList t a -> [t a]
aMap :: (t a -> r a) -> AList t a -> AList r a
data BaseType
TypeInteger :: BaseType
TypeReal :: BaseType
TypeDoublePrecision :: BaseType
TypeComplex :: BaseType
TypeDoubleComplex :: BaseType
TypeLogical :: BaseType
TypeCharacter :: BaseType
TypeCustom :: String -> BaseType
data TypeSpec a
TypeSpec :: a -> SrcSpan -> BaseType -> (Maybe (Selector a)) -> TypeSpec a
data Selector a
Selector :: a -> SrcSpan -> (Maybe (Expression a)) -> (Maybe (Expression a)) -> Selector a
data MetaInfo
MetaInfo :: FortranVersion -> String -> MetaInfo
[miVersion] :: MetaInfo -> FortranVersion
[miFilename] :: MetaInfo -> String
data ProgramFile a
ProgramFile :: MetaInfo -> [ProgramUnit a] -> ProgramFile a
pfSetFilename :: () => String -> ProgramFile a -> ProgramFile a
pfGetFilename :: () => ProgramFile a -> String
data ProgramUnit a
PUMain :: a -> SrcSpan -> (Maybe Name) -> [Block a] -> (Maybe [ProgramUnit a]) -> ProgramUnit a
PUModule :: a -> SrcSpan -> Name -> [Block a] -> (Maybe [ProgramUnit a]) -> ProgramUnit a
PUSubroutine :: a -> SrcSpan -> Bool -> Name -> (Maybe (AList Expression a)) -> [Block a] -> (Maybe [ProgramUnit a]) -> ProgramUnit a
PUFunction :: a -> SrcSpan -> (Maybe (TypeSpec a)) -> Bool -> Name -> (Maybe (AList Expression a)) -> (Maybe (Expression a)) -> [Block a] -> (Maybe [ProgramUnit a]) -> ProgramUnit a
PUBlockData :: a -> SrcSpan -> (Maybe Name) -> [Block a] -> ProgramUnit a
PUComment :: a -> SrcSpan -> (Comment a) -> ProgramUnit a
programUnitBody :: ProgramUnit a -> [Block a]
updateProgramUnitBody :: ProgramUnit a -> [Block a] -> ProgramUnit a
programUnitSubprograms :: ProgramUnit a -> Maybe [ProgramUnit a]
newtype Comment a
Comment :: String -> Comment a
data Block a
BlStatement :: a -> SrcSpan -> (Maybe (Expression a)) -> (Statement a) -> Block a
BlIf :: a -> SrcSpan -> (Maybe (Expression a)) -> (Maybe String) -> [Maybe (Expression a)] -> [[Block a]] -> (Maybe (Expression a)) -> Block a
BlCase :: a -> SrcSpan -> (Maybe (Expression a)) -> (Maybe String) -> (Expression a) -> [Maybe (AList Index a)] -> [[Block a]] -> (Maybe (Expression a)) -> Block a
BlDo :: a -> SrcSpan -> (Maybe (Expression a)) -> (Maybe String) -> (Maybe (Expression a)) -> (Maybe (DoSpecification a)) -> [Block a] -> (Maybe (Expression a)) -> Block a
BlDoWhile :: a -> SrcSpan -> (Maybe (Expression a)) -> (Maybe String) -> (Expression a) -> [Block a] -> (Maybe (Expression a)) -> Block a
BlInterface :: a -> SrcSpan -> (Maybe (Expression a)) -> [ProgramUnit a] -> [Block a] -> Block a
BlComment :: a -> SrcSpan -> (Comment a) -> Block a
data Statement a
StDeclaration :: a -> SrcSpan -> (TypeSpec a) -> (Maybe (AList Attribute a)) -> (AList Declarator a) -> Statement a
StIntent :: a -> SrcSpan -> Intent -> (AList Expression a) -> Statement a
StOptional :: a -> SrcSpan -> (AList Expression a) -> Statement a
StPublic :: a -> SrcSpan -> (Maybe (AList Expression a)) -> Statement a
StPrivate :: a -> SrcSpan -> (Maybe (AList Expression a)) -> Statement a
StSave :: a -> SrcSpan -> (Maybe (AList Expression a)) -> Statement a
StDimension :: a -> SrcSpan -> (AList Declarator a) -> Statement a
StAllocatable :: a -> SrcSpan -> (AList Declarator a) -> Statement a
StPointer :: a -> SrcSpan -> (AList Declarator a) -> Statement a
StTarget :: a -> SrcSpan -> (AList Declarator a) -> Statement a
StData :: a -> SrcSpan -> (AList DataGroup a) -> Statement a
StNamelist :: a -> SrcSpan -> (AList Namelist a) -> Statement a
StParameter :: a -> SrcSpan -> (AList Declarator a) -> Statement a
StExternal :: a -> SrcSpan -> (AList Expression a) -> Statement a
StIntrinsic :: a -> SrcSpan -> (AList Expression a) -> Statement a
StCommon :: a -> SrcSpan -> (AList CommonGroup a) -> Statement a
StEquivalence :: a -> SrcSpan -> (AList (AList Expression) a) -> Statement a
StFormat :: a -> SrcSpan -> (AList FormatItem a) -> Statement a
StImplicit :: a -> SrcSpan -> (Maybe (AList ImpList a)) -> Statement a
StEntry :: a -> SrcSpan -> (Expression a) -> (Maybe (AList Expression a)) -> (Maybe (Expression a)) -> Statement a
StInclude :: a -> SrcSpan -> (Expression a) -> Statement a
StDo :: a -> SrcSpan -> (Maybe String) -> (Maybe (Expression a)) -> (Maybe (DoSpecification a)) -> Statement a
StDoWhile :: a -> SrcSpan -> (Maybe String) -> (Maybe (Expression a)) -> (Expression a) -> Statement a
StEnddo :: a -> SrcSpan -> (Maybe String) -> Statement a
StCycle :: a -> SrcSpan -> (Maybe (Expression a)) -> Statement a
StExit :: a -> SrcSpan -> (Maybe (Expression a)) -> Statement a
StIfLogical :: a -> SrcSpan -> (Expression a) -> (Statement a) -> Statement a
StIfArithmetic :: a -> SrcSpan -> (Expression a) -> (Expression a) -> (Expression a) -> (Expression a) -> Statement a
StIfThen :: a -> SrcSpan -> (Maybe String) -> (Expression a) -> Statement a
StElse :: a -> SrcSpan -> (Maybe String) -> Statement a
StElsif :: a -> SrcSpan -> (Maybe String) -> (Expression a) -> Statement a
StEndif :: a -> SrcSpan -> (Maybe String) -> Statement a
StSelectCase :: a -> SrcSpan -> (Maybe String) -> (Expression a) -> Statement a
StCase :: a -> SrcSpan -> (Maybe String) -> (Maybe (AList Index a)) -> Statement a
StEndcase :: a -> SrcSpan -> (Maybe String) -> Statement a
StFunction :: a -> SrcSpan -> (Expression a) -> (AList Expression a) -> (Expression a) -> Statement a
StExpressionAssign :: a -> SrcSpan -> (Expression a) -> (Expression a) -> Statement a
StPointerAssign :: a -> SrcSpan -> (Expression a) -> (Expression a) -> Statement a
StLabelAssign :: a -> SrcSpan -> (Expression a) -> (Expression a) -> Statement a
StGotoUnconditional :: a -> SrcSpan -> (Expression a) -> Statement a
StGotoAssigned :: a -> SrcSpan -> (Expression a) -> (AList Expression a) -> Statement a
StGotoComputed :: a -> SrcSpan -> (AList Expression a) -> (Expression a) -> Statement a
StCall :: a -> SrcSpan -> (Expression a) -> (Maybe (AList Argument a)) -> Statement a
StReturn :: a -> SrcSpan -> (Maybe (Expression a)) -> Statement a
StContinue :: a -> SrcSpan -> Statement a
StStop :: a -> SrcSpan -> (Maybe (Expression a)) -> Statement a
StPause :: a -> SrcSpan -> (Maybe (Expression a)) -> Statement a
StRead :: a -> SrcSpan -> (AList ControlPair a) -> (Maybe (AList Expression a)) -> Statement a
StRead2 :: a -> SrcSpan -> (Expression a) -> (Maybe (AList Expression a)) -> Statement a
StWrite :: a -> SrcSpan -> (AList ControlPair a) -> (Maybe (AList Expression a)) -> Statement a
StPrint :: a -> SrcSpan -> (Expression a) -> (Maybe (AList Expression a)) -> Statement a
StOpen :: a -> SrcSpan -> (AList ControlPair a) -> Statement a
StClose :: a -> SrcSpan -> (AList ControlPair a) -> Statement a
StInquire :: a -> SrcSpan -> (AList ControlPair a) -> Statement a
StRewind :: a -> SrcSpan -> (AList ControlPair a) -> Statement a
StRewind2 :: a -> SrcSpan -> (Expression a) -> Statement a
StBackspace :: a -> SrcSpan -> (AList ControlPair a) -> Statement a
StBackspace2 :: a -> SrcSpan -> (Expression a) -> Statement a
StEndfile :: a -> SrcSpan -> (AList ControlPair a) -> Statement a
StEndfile2 :: a -> SrcSpan -> (Expression a) -> Statement a
StAllocate :: a -> SrcSpan -> (AList Expression a) -> (Maybe (ControlPair a)) -> Statement a
StNullify :: a -> SrcSpan -> (AList Expression a) -> Statement a
StDeallocate :: a -> SrcSpan -> (AList Expression a) -> (Maybe (ControlPair a)) -> Statement a
StWhere :: a -> SrcSpan -> (Expression a) -> (Statement a) -> Statement a
StWhereConstruct :: a -> SrcSpan -> (Expression a) -> Statement a
StElsewhere :: a -> SrcSpan -> Statement a
StEndWhere :: a -> SrcSpan -> Statement a
StUse :: a -> SrcSpan -> (Expression a) -> Only -> (Maybe (AList Use a)) -> Statement a
StModuleProcedure :: a -> SrcSpan -> (AList Expression a) -> Statement a
StType :: a -> SrcSpan -> (Maybe (AList Attribute a)) -> String -> Statement a
StEndType :: a -> SrcSpan -> (Maybe String) -> Statement a
StSequence :: a -> SrcSpan -> Statement a
StForall :: a -> SrcSpan -> (ForallHeader a) -> (Statement a) -> Statement a
StFormatBogus :: a -> SrcSpan -> String -> Statement a
data ForallHeader a
ForallHeader :: [(Name, Expression a, Expression a, Maybe (Expression a))] -> (Maybe (Expression a)) -> ForallHeader a
data Only
Exclusive :: Only
Permissive :: Only
data Use a
UseRename :: a -> SrcSpan -> (Expression a) -> (Expression a) -> Use a
UseID :: a -> SrcSpan -> (Expression a) -> Use a
data Argument a
Argument :: a -> SrcSpan -> (Maybe String) -> (Expression a) -> Argument a
data Attribute a
AttrParameter :: a -> SrcSpan -> Attribute a
AttrPublic :: a -> SrcSpan -> Attribute a
AttrPrivate :: a -> SrcSpan -> Attribute a
AttrAllocatable :: a -> SrcSpan -> Attribute a
AttrDimension :: a -> SrcSpan -> (AList DimensionDeclarator a) -> Attribute a
AttrExternal :: a -> SrcSpan -> Attribute a
AttrIntent :: a -> SrcSpan -> Intent -> Attribute a
AttrIntrinsic :: a -> SrcSpan -> Attribute a
AttrOptional :: a -> SrcSpan -> Attribute a
AttrPointer :: a -> SrcSpan -> Attribute a
AttrSave :: a -> SrcSpan -> Attribute a
AttrTarget :: a -> SrcSpan -> Attribute a
data Intent
In :: Intent
Out :: Intent
InOut :: Intent
data ControlPair a
ControlPair :: a -> SrcSpan -> (Maybe String) -> (Expression a) -> ControlPair a
data ImpList a
ImpList :: a -> SrcSpan -> (TypeSpec a) -> (AList ImpElement a) -> ImpList a
data ImpElement a
ImpCharacter :: a -> SrcSpan -> String -> ImpElement a
ImpRange :: a -> SrcSpan -> String -> String -> ImpElement a
data CommonGroup a
CommonGroup :: a -> SrcSpan -> (Maybe (Expression a)) -> (AList Expression a) -> CommonGroup a
data Namelist a
Namelist :: a -> SrcSpan -> (Expression a) -> (AList Expression a) -> Namelist a
data DataGroup a
DataGroup :: a -> SrcSpan -> (AList Expression a) -> (AList Expression a) -> DataGroup a
data FormatItem a
FIFormatList :: a -> SrcSpan -> (Maybe String) -> (AList FormatItem a) -> FormatItem a
FIHollerith :: a -> SrcSpan -> (Value a) -> FormatItem a
FIDelimiter :: a -> SrcSpan -> FormatItem a
FIFieldDescriptorDEFG :: a -> SrcSpan -> (Maybe Integer) -> Char -> Integer -> Integer -> FormatItem a
FIFieldDescriptorAIL :: a -> SrcSpan -> (Maybe Integer) -> Char -> Integer -> FormatItem a
FIBlankDescriptor :: a -> SrcSpan -> Integer -> FormatItem a
FIScaleFactor :: a -> SrcSpan -> Integer -> FormatItem a
data DoSpecification a
DoSpecification :: a -> SrcSpan -> (Statement a) -> (Expression a) -> (Maybe (Expression a)) -> DoSpecification a
data Expression a
ExpValue :: a -> SrcSpan -> (Value a) -> Expression a
ExpBinary :: a -> SrcSpan -> BinaryOp -> (Expression a) -> (Expression a) -> Expression a
ExpUnary :: a -> SrcSpan -> UnaryOp -> (Expression a) -> Expression a
ExpSubscript :: a -> SrcSpan -> (Expression a) -> (AList Index a) -> Expression a
ExpDataRef :: a -> SrcSpan -> (Expression a) -> (Expression a) -> Expression a
ExpFunctionCall :: a -> SrcSpan -> (Expression a) -> (Maybe (AList Argument a)) -> Expression a
ExpImpliedDo :: a -> SrcSpan -> (AList Expression a) -> (DoSpecification a) -> Expression a
ExpInitialisation :: a -> SrcSpan -> (AList Expression a) -> Expression a
ExpReturnSpec :: a -> SrcSpan -> (Expression a) -> Expression a
data Index a
IxSingle :: a -> SrcSpan -> (Maybe String) -> (Expression a) -> Index a
IxRange :: a -> SrcSpan -> (Maybe (Expression a)) -> (Maybe (Expression a)) -> (Maybe (Expression a)) -> Index a
data Value a
ValInteger :: String -> Value a
ValReal :: String -> Value a
ValComplex :: (Expression a) -> (Expression a) -> Value a
ValString :: String -> Value a
ValHollerith :: String -> Value a
ValVariable :: Name -> Value a
ValIntrinsic :: Name -> Value a
ValLogical :: String -> Value a
ValOperator :: String -> Value a
ValAssignment :: Value a
ValType :: String -> Value a
ValStar :: Value a
data Declarator a
DeclVariable :: a -> SrcSpan -> (Expression a) -> (Maybe (Expression a)) -> (Maybe (Expression a)) -> Declarator a
DeclArray :: a -> SrcSpan -> (Expression a) -> (AList DimensionDeclarator a) -> (Maybe (Expression a)) -> (Maybe (Expression a)) -> Declarator a
setInitialisation :: Declarator a -> Expression a -> Declarator a
data DimensionDeclarator a
DimensionDeclarator :: a -> SrcSpan -> (Maybe (Expression a)) -> (Maybe (Expression a)) -> DimensionDeclarator a
data UnaryOp
Plus :: UnaryOp
Minus :: UnaryOp
Not :: UnaryOp
UnCustom :: String -> UnaryOp
data BinaryOp
Addition :: BinaryOp
Subtraction :: BinaryOp
Multiplication :: BinaryOp
Division :: BinaryOp
Exponentiation :: BinaryOp
Concatenation :: BinaryOp
GT :: BinaryOp
GTE :: BinaryOp
LT :: BinaryOp
LTE :: BinaryOp
EQ :: BinaryOp
NE :: BinaryOp
Or :: BinaryOp
And :: BinaryOp
Equivalent :: BinaryOp
NotEquivalent :: BinaryOp
BinCustom :: String -> BinaryOp
class Annotated f
getAnnotation :: Annotated f => f a -> a
setAnnotation :: Annotated f => a -> f a -> f a
modifyAnnotation :: Annotated f => (a -> a) -> f a -> f a
getAnnotation :: (Annotated f, (FirstParameter (f a) a)) => f a -> a
setAnnotation :: (Annotated f, (FirstParameter (f a) a)) => a -> f a -> f a
class (Spanned a, Spanned b) => SpannedPair a b
getTransSpan :: SpannedPair a b => a -> b -> SrcSpan
class Labeled f
getLabel :: Labeled f => f a -> Maybe (Expression a)
getLastLabel :: Labeled f => f a -> Maybe (Expression a)
setLabel :: Labeled f => f a -> Expression a -> f a
class Conditioned f
getCondition :: Conditioned f => f a -> Maybe (Expression a)
data ProgramUnitName
Named :: String -> ProgramUnitName
NamelessBlockData :: ProgramUnitName
NamelessComment :: ProgramUnitName
NamelessMain :: ProgramUnitName
class Named a
getName :: Named a => a -> ProgramUnitName
setName :: Named a => ProgramUnitName -> a -> a
nonExecutableStatement :: FortranVersion -> Statement a -> Bool
executableStatement :: FortranVersion -> Statement a -> Bool
executableStatementBlock :: FortranVersion -> Block a -> Bool
nonExecutableStatementBlock :: FortranVersion -> Block a -> Bool
instance GHC.Generics.Generic Language.Fortran.AST.ProgramUnitName
instance Data.Data.Data Language.Fortran.AST.ProgramUnitName
instance GHC.Show.Show Language.Fortran.AST.ProgramUnitName
instance GHC.Classes.Eq Language.Fortran.AST.ProgramUnitName
instance GHC.Classes.Ord Language.Fortran.AST.ProgramUnitName
instance GHC.Base.Functor Language.Fortran.AST.ProgramFile
instance GHC.Generics.Generic (Language.Fortran.AST.ProgramFile a)
instance Data.Data.Data a => Data.Data.Data (Language.Fortran.AST.ProgramFile a)
instance GHC.Show.Show a => GHC.Show.Show (Language.Fortran.AST.ProgramFile a)
instance GHC.Classes.Eq a => GHC.Classes.Eq (Language.Fortran.AST.ProgramFile a)
instance GHC.Base.Functor Language.Fortran.AST.Block
instance GHC.Generics.Generic (Language.Fortran.AST.Block a)
instance Data.Data.Data a => Data.Data.Data (Language.Fortran.AST.Block a)
instance GHC.Show.Show a => GHC.Show.Show (Language.Fortran.AST.Block a)
instance GHC.Classes.Eq a => GHC.Classes.Eq (Language.Fortran.AST.Block a)
instance GHC.Base.Functor Language.Fortran.AST.ProgramUnit
instance GHC.Generics.Generic (Language.Fortran.AST.ProgramUnit a)
instance Data.Data.Data a => Data.Data.Data (Language.Fortran.AST.ProgramUnit a)
instance GHC.Show.Show a => GHC.Show.Show (Language.Fortran.AST.ProgramUnit a)
instance GHC.Classes.Eq a => GHC.Classes.Eq (Language.Fortran.AST.ProgramUnit a)
instance GHC.Base.Functor Language.Fortran.AST.ForallHeader
instance GHC.Generics.Generic (Language.Fortran.AST.ForallHeader a)
instance Data.Data.Data a => Data.Data.Data (Language.Fortran.AST.ForallHeader a)
instance GHC.Show.Show a => GHC.Show.Show (Language.Fortran.AST.ForallHeader a)
instance GHC.Classes.Eq a => GHC.Classes.Eq (Language.Fortran.AST.ForallHeader a)
instance GHC.Base.Functor Language.Fortran.AST.Use
instance GHC.Generics.Generic (Language.Fortran.AST.Use a)
instance Data.Data.Data a => Data.Data.Data (Language.Fortran.AST.Use a)
instance GHC.Show.Show a => GHC.Show.Show (Language.Fortran.AST.Use a)
instance GHC.Classes.Eq a => GHC.Classes.Eq (Language.Fortran.AST.Use a)
instance GHC.Base.Functor Language.Fortran.AST.Argument
instance GHC.Generics.Generic (Language.Fortran.AST.Argument a)
instance Data.Data.Data a => Data.Data.Data (Language.Fortran.AST.Argument a)
instance GHC.Show.Show a => GHC.Show.Show (Language.Fortran.AST.Argument a)
instance GHC.Classes.Eq a => GHC.Classes.Eq (Language.Fortran.AST.Argument a)
instance GHC.Base.Functor Language.Fortran.AST.Attribute
instance GHC.Generics.Generic (Language.Fortran.AST.Attribute a)
instance Data.Data.Data a => Data.Data.Data (Language.Fortran.AST.Attribute a)
instance GHC.Show.Show a => GHC.Show.Show (Language.Fortran.AST.Attribute a)
instance GHC.Classes.Eq a => GHC.Classes.Eq (Language.Fortran.AST.Attribute a)
instance GHC.Base.Functor Language.Fortran.AST.ControlPair
instance GHC.Generics.Generic (Language.Fortran.AST.ControlPair a)
instance Data.Data.Data a => Data.Data.Data (Language.Fortran.AST.ControlPair a)
instance GHC.Show.Show a => GHC.Show.Show (Language.Fortran.AST.ControlPair a)
instance GHC.Classes.Eq a => GHC.Classes.Eq (Language.Fortran.AST.ControlPair a)
instance GHC.Base.Functor Language.Fortran.AST.Selector
instance GHC.Generics.Generic (Language.Fortran.AST.Selector a)
instance Data.Data.Data a => Data.Data.Data (Language.Fortran.AST.Selector a)
instance GHC.Show.Show a => GHC.Show.Show (Language.Fortran.AST.Selector a)
instance GHC.Classes.Eq a => GHC.Classes.Eq (Language.Fortran.AST.Selector a)
instance GHC.Base.Functor Language.Fortran.AST.TypeSpec
instance GHC.Generics.Generic (Language.Fortran.AST.TypeSpec a)
instance Data.Data.Data a => Data.Data.Data (Language.Fortran.AST.TypeSpec a)
instance GHC.Show.Show a => GHC.Show.Show (Language.Fortran.AST.TypeSpec a)
instance GHC.Classes.Eq a => GHC.Classes.Eq (Language.Fortran.AST.TypeSpec a)
instance GHC.Base.Functor Language.Fortran.AST.ImpList
instance GHC.Generics.Generic (Language.Fortran.AST.ImpList a)
instance Data.Data.Data a => Data.Data.Data (Language.Fortran.AST.ImpList a)
instance GHC.Show.Show a => GHC.Show.Show (Language.Fortran.AST.ImpList a)
instance GHC.Classes.Eq a => GHC.Classes.Eq (Language.Fortran.AST.ImpList a)
instance GHC.Base.Functor Language.Fortran.AST.CommonGroup
instance GHC.Generics.Generic (Language.Fortran.AST.CommonGroup a)
instance Data.Data.Data a => Data.Data.Data (Language.Fortran.AST.CommonGroup a)
instance GHC.Show.Show a => GHC.Show.Show (Language.Fortran.AST.CommonGroup a)
instance GHC.Classes.Eq a => GHC.Classes.Eq (Language.Fortran.AST.CommonGroup a)
instance GHC.Base.Functor Language.Fortran.AST.Namelist
instance GHC.Generics.Generic (Language.Fortran.AST.Namelist a)
instance Data.Data.Data a => Data.Data.Data (Language.Fortran.AST.Namelist a)
instance GHC.Show.Show a => GHC.Show.Show (Language.Fortran.AST.Namelist a)
instance GHC.Classes.Eq a => GHC.Classes.Eq (Language.Fortran.AST.Namelist a)
instance GHC.Base.Functor Language.Fortran.AST.DataGroup
instance GHC.Generics.Generic (Language.Fortran.AST.DataGroup a)
instance Data.Data.Data a => Data.Data.Data (Language.Fortran.AST.DataGroup a)
instance GHC.Show.Show a => GHC.Show.Show (Language.Fortran.AST.DataGroup a)
instance GHC.Classes.Eq a => GHC.Classes.Eq (Language.Fortran.AST.DataGroup a)
instance GHC.Base.Functor Language.Fortran.AST.FormatItem
instance GHC.Generics.Generic (Language.Fortran.AST.FormatItem a)
instance Data.Data.Data a => Data.Data.Data (Language.Fortran.AST.FormatItem a)
instance GHC.Show.Show a => GHC.Show.Show (Language.Fortran.AST.FormatItem a)
instance GHC.Classes.Eq a => GHC.Classes.Eq (Language.Fortran.AST.FormatItem a)
instance GHC.Base.Functor Language.Fortran.AST.DimensionDeclarator
instance GHC.Generics.Generic (Language.Fortran.AST.DimensionDeclarator a)
instance Data.Data.Data a => Data.Data.Data (Language.Fortran.AST.DimensionDeclarator a)
instance GHC.Show.Show a => GHC.Show.Show (Language.Fortran.AST.DimensionDeclarator a)
instance GHC.Classes.Eq a => GHC.Classes.Eq (Language.Fortran.AST.DimensionDeclarator a)
instance GHC.Base.Functor Language.Fortran.AST.Declarator
instance GHC.Generics.Generic (Language.Fortran.AST.Declarator a)
instance Data.Data.Data a => Data.Data.Data (Language.Fortran.AST.Declarator a)
instance GHC.Show.Show a => GHC.Show.Show (Language.Fortran.AST.Declarator a)
instance GHC.Classes.Eq a => GHC.Classes.Eq (Language.Fortran.AST.Declarator a)
instance GHC.Base.Functor Language.Fortran.AST.Statement
instance GHC.Generics.Generic (Language.Fortran.AST.Statement a)
instance Data.Data.Data a => Data.Data.Data (Language.Fortran.AST.Statement a)
instance GHC.Show.Show a => GHC.Show.Show (Language.Fortran.AST.Statement a)
instance GHC.Classes.Eq a => GHC.Classes.Eq (Language.Fortran.AST.Statement a)
instance GHC.Base.Functor Language.Fortran.AST.DoSpecification
instance GHC.Generics.Generic (Language.Fortran.AST.DoSpecification a)
instance Data.Data.Data a => Data.Data.Data (Language.Fortran.AST.DoSpecification a)
instance GHC.Show.Show a => GHC.Show.Show (Language.Fortran.AST.DoSpecification a)
instance GHC.Classes.Eq a => GHC.Classes.Eq (Language.Fortran.AST.DoSpecification a)
instance GHC.Base.Functor Language.Fortran.AST.Index
instance GHC.Generics.Generic (Language.Fortran.AST.Index a)
instance Data.Data.Data a => Data.Data.Data (Language.Fortran.AST.Index a)
instance GHC.Show.Show a => GHC.Show.Show (Language.Fortran.AST.Index a)
instance GHC.Classes.Eq a => GHC.Classes.Eq (Language.Fortran.AST.Index a)
instance GHC.Base.Functor Language.Fortran.AST.Value
instance GHC.Generics.Generic (Language.Fortran.AST.Value a)
instance Data.Data.Data a => Data.Data.Data (Language.Fortran.AST.Value a)
instance GHC.Show.Show a => GHC.Show.Show (Language.Fortran.AST.Value a)
instance GHC.Classes.Eq a => GHC.Classes.Eq (Language.Fortran.AST.Value a)
instance GHC.Base.Functor Language.Fortran.AST.Expression
instance GHC.Generics.Generic (Language.Fortran.AST.Expression a)
instance Data.Data.Data a => Data.Data.Data (Language.Fortran.AST.Expression a)
instance GHC.Show.Show a => GHC.Show.Show (Language.Fortran.AST.Expression a)
instance GHC.Classes.Eq a => GHC.Classes.Eq (Language.Fortran.AST.Expression a)
instance GHC.Generics.Generic Language.Fortran.AST.BinaryOp
instance Data.Data.Data Language.Fortran.AST.BinaryOp
instance GHC.Show.Show Language.Fortran.AST.BinaryOp
instance GHC.Classes.Eq Language.Fortran.AST.BinaryOp
instance GHC.Generics.Generic Language.Fortran.AST.UnaryOp
instance Data.Data.Data Language.Fortran.AST.UnaryOp
instance GHC.Show.Show Language.Fortran.AST.UnaryOp
instance GHC.Classes.Eq Language.Fortran.AST.UnaryOp
instance GHC.Base.Functor Language.Fortran.AST.ImpElement
instance GHC.Generics.Generic (Language.Fortran.AST.ImpElement a)
instance Data.Data.Data a => Data.Data.Data (Language.Fortran.AST.ImpElement a)
instance GHC.Show.Show a => GHC.Show.Show (Language.Fortran.AST.ImpElement a)
instance GHC.Classes.Eq a => GHC.Classes.Eq (Language.Fortran.AST.ImpElement a)
instance GHC.Generics.Generic Language.Fortran.AST.Intent
instance Data.Data.Data Language.Fortran.AST.Intent
instance GHC.Show.Show Language.Fortran.AST.Intent
instance GHC.Classes.Eq Language.Fortran.AST.Intent
instance GHC.Generics.Generic Language.Fortran.AST.Only
instance Data.Data.Data Language.Fortran.AST.Only
instance GHC.Show.Show Language.Fortran.AST.Only
instance GHC.Classes.Eq Language.Fortran.AST.Only
instance GHC.Base.Functor Language.Fortran.AST.Comment
instance GHC.Generics.Generic (Language.Fortran.AST.Comment a)
instance Data.Data.Data a => Data.Data.Data (Language.Fortran.AST.Comment a)
instance GHC.Show.Show (Language.Fortran.AST.Comment a)
instance GHC.Classes.Eq (Language.Fortran.AST.Comment a)
instance GHC.Generics.Generic Language.Fortran.AST.MetaInfo
instance Data.Data.Data Language.Fortran.AST.MetaInfo
instance GHC.Show.Show Language.Fortran.AST.MetaInfo
instance GHC.Classes.Eq Language.Fortran.AST.MetaInfo
instance GHC.Generics.Generic Language.Fortran.AST.BaseType
instance Data.Data.Data Language.Fortran.AST.BaseType
instance GHC.Show.Show Language.Fortran.AST.BaseType
instance GHC.Classes.Eq Language.Fortran.AST.BaseType
instance GHC.Classes.Ord Language.Fortran.AST.BaseType
instance GHC.Generics.Generic (Language.Fortran.AST.AList t a)
instance (Data.Data.Data (t a), Data.Data.Data a, Data.Typeable.Internal.Typeable t) => Data.Data.Data (Language.Fortran.AST.AList t a)
instance (GHC.Show.Show (t a), GHC.Show.Show a) => GHC.Show.Show (Language.Fortran.AST.AList t a)
instance (GHC.Classes.Eq (t a), GHC.Classes.Eq a) => GHC.Classes.Eq (Language.Fortran.AST.AList t a)
instance Language.Fortran.AST.Named (Language.Fortran.AST.ProgramUnit a)
instance Data.Binary.Class.Binary Language.Fortran.AST.ProgramUnitName
instance Language.Fortran.AST.Conditioned Language.Fortran.AST.Block
instance Language.Fortran.AST.Conditioned Language.Fortran.AST.Statement
instance Language.Fortran.AST.Labeled Language.Fortran.AST.Block
instance Language.Fortran.Util.Position.Spanned a => Language.Fortran.Util.Position.Spanned [a]
instance (Language.Fortran.Util.Position.Spanned a, Language.Fortran.Util.Position.Spanned b) => Language.Fortran.Util.Position.Spanned (a, GHC.Base.Maybe b)
instance (Language.Fortran.Util.Position.Spanned a, Language.Fortran.Util.Position.Spanned b) => Language.Fortran.Util.Position.Spanned (GHC.Base.Maybe a, b)
instance (Language.Fortran.Util.Position.Spanned a, Language.Fortran.Util.Position.Spanned b) => Language.Fortran.Util.Position.Spanned (a, b)
instance (Language.Fortran.Util.Position.Spanned a, Language.Fortran.Util.Position.Spanned b, Language.Fortran.Util.Position.Spanned c) => Language.Fortran.Util.Position.Spanned (GHC.Base.Maybe a, GHC.Base.Maybe b, GHC.Base.Maybe c)
instance (Language.Fortran.Util.Position.Spanned a, Language.Fortran.Util.Position.Spanned b, Language.Fortran.Util.Position.Spanned c) => Language.Fortran.Util.Position.Spanned (a, GHC.Base.Maybe b, GHC.Base.Maybe c)
instance (Language.Fortran.Util.Position.Spanned a, Language.Fortran.Util.Position.Spanned b, Language.Fortran.Util.Position.Spanned c) => Language.Fortran.Util.Position.Spanned (GHC.Base.Maybe a, b, c)
instance (Language.Fortran.Util.Position.Spanned a, Language.Fortran.Util.Position.Spanned b, Language.Fortran.Util.Position.Spanned c) => Language.Fortran.Util.Position.Spanned (a, b, c)
instance (Language.Fortran.Util.Position.Spanned a, Language.Fortran.Util.Position.Spanned b) => Language.Fortran.AST.SpannedPair a b
instance (Language.Fortran.Util.Position.Spanned a, Language.Fortran.Util.Position.Spanned b) => Language.Fortran.AST.SpannedPair a [b]
instance (Language.Fortran.Util.Position.Spanned a, Language.Fortran.Util.Position.Spanned b) => Language.Fortran.AST.SpannedPair a [[b]]
instance Language.Fortran.AST.Annotated (Language.Fortran.AST.AList t)
instance Language.Fortran.AST.Annotated Language.Fortran.AST.ProgramUnit
instance Language.Fortran.AST.Annotated Language.Fortran.AST.Block
instance Language.Fortran.AST.Annotated Language.Fortran.AST.Statement
instance Language.Fortran.AST.Annotated Language.Fortran.AST.Argument
instance Language.Fortran.AST.Annotated Language.Fortran.AST.Use
instance Language.Fortran.AST.Annotated Language.Fortran.AST.TypeSpec
instance Language.Fortran.AST.Annotated Language.Fortran.AST.Selector
instance Language.Fortran.AST.Annotated Language.Fortran.AST.Attribute
instance Language.Fortran.AST.Annotated Language.Fortran.AST.ImpList
instance Language.Fortran.AST.Annotated Language.Fortran.AST.ImpElement
instance Language.Fortran.AST.Annotated Language.Fortran.AST.CommonGroup
instance Language.Fortran.AST.Annotated Language.Fortran.AST.DataGroup
instance Language.Fortran.AST.Annotated Language.Fortran.AST.Namelist
instance Language.Fortran.AST.Annotated Language.Fortran.AST.FormatItem
instance Language.Fortran.AST.Annotated Language.Fortran.AST.Expression
instance Language.Fortran.AST.Annotated Language.Fortran.AST.Index
instance Language.Fortran.AST.Annotated Language.Fortran.AST.DoSpecification
instance Language.Fortran.AST.Annotated Language.Fortran.AST.Declarator
instance Language.Fortran.AST.Annotated Language.Fortran.AST.DimensionDeclarator
instance Language.Fortran.AST.Annotated Language.Fortran.AST.ControlPair
instance Text.PrettyPrint.GenericPretty.Out a => Text.PrettyPrint.GenericPretty.Out (Language.Fortran.AST.ProgramFile a)
instance Language.Fortran.Util.FirstParameter.FirstParameter (Language.Fortran.AST.ProgramUnit a) a
instance Language.Fortran.Util.FirstParameter.FirstParameter (Language.Fortran.AST.Block a) a
instance Language.Fortran.Util.SecondParameter.SecondParameter (Language.Fortran.AST.ProgramUnit a) Language.Fortran.Util.Position.SrcSpan
instance Language.Fortran.Util.SecondParameter.SecondParameter (Language.Fortran.AST.Block a) Language.Fortran.Util.Position.SrcSpan
instance Language.Fortran.Util.Position.Spanned (Language.Fortran.AST.ProgramUnit a)
instance Language.Fortran.Util.Position.Spanned (Language.Fortran.AST.Block a)
instance Text.PrettyPrint.GenericPretty.Out a => Text.PrettyPrint.GenericPretty.Out (Language.Fortran.AST.ProgramUnit a)
instance Text.PrettyPrint.GenericPretty.Out a => Text.PrettyPrint.GenericPretty.Out (Language.Fortran.AST.Block a)
instance Language.Fortran.Util.FirstParameter.FirstParameter (Language.Fortran.AST.Statement a) a
instance Language.Fortran.Util.FirstParameter.FirstParameter (Language.Fortran.AST.Argument a) a
instance Language.Fortran.Util.FirstParameter.FirstParameter (Language.Fortran.AST.Use a) a
instance Language.Fortran.Util.FirstParameter.FirstParameter (Language.Fortran.AST.TypeSpec a) a
instance Language.Fortran.Util.FirstParameter.FirstParameter (Language.Fortran.AST.Selector a) a
instance Language.Fortran.Util.FirstParameter.FirstParameter (Language.Fortran.AST.Attribute a) a
instance Language.Fortran.Util.FirstParameter.FirstParameter (Language.Fortran.AST.ImpList a) a
instance Language.Fortran.Util.FirstParameter.FirstParameter (Language.Fortran.AST.CommonGroup a) a
instance Language.Fortran.Util.FirstParameter.FirstParameter (Language.Fortran.AST.DataGroup a) a
instance Language.Fortran.Util.FirstParameter.FirstParameter (Language.Fortran.AST.Namelist a) a
instance Language.Fortran.Util.FirstParameter.FirstParameter (Language.Fortran.AST.FormatItem a) a
instance Language.Fortran.Util.FirstParameter.FirstParameter (Language.Fortran.AST.Expression a) a
instance Language.Fortran.Util.FirstParameter.FirstParameter (Language.Fortran.AST.Index a) a
instance Language.Fortran.Util.FirstParameter.FirstParameter (Language.Fortran.AST.DoSpecification a) a
instance Language.Fortran.Util.FirstParameter.FirstParameter (Language.Fortran.AST.Declarator a) a
instance Language.Fortran.Util.FirstParameter.FirstParameter (Language.Fortran.AST.DimensionDeclarator a) a
instance Language.Fortran.Util.FirstParameter.FirstParameter (Language.Fortran.AST.ControlPair a) a
instance Language.Fortran.Util.SecondParameter.SecondParameter (Language.Fortran.AST.Statement a) Language.Fortran.Util.Position.SrcSpan
instance Language.Fortran.Util.SecondParameter.SecondParameter (Language.Fortran.AST.Argument a) Language.Fortran.Util.Position.SrcSpan
instance Language.Fortran.Util.SecondParameter.SecondParameter (Language.Fortran.AST.Use a) Language.Fortran.Util.Position.SrcSpan
instance Language.Fortran.Util.SecondParameter.SecondParameter (Language.Fortran.AST.TypeSpec a) Language.Fortran.Util.Position.SrcSpan
instance Language.Fortran.Util.SecondParameter.SecondParameter (Language.Fortran.AST.Selector a) Language.Fortran.Util.Position.SrcSpan
instance Language.Fortran.Util.SecondParameter.SecondParameter (Language.Fortran.AST.Attribute a) Language.Fortran.Util.Position.SrcSpan
instance Language.Fortran.Util.SecondParameter.SecondParameter (Language.Fortran.AST.ImpList a) Language.Fortran.Util.Position.SrcSpan
instance Language.Fortran.Util.SecondParameter.SecondParameter (Language.Fortran.AST.CommonGroup a) Language.Fortran.Util.Position.SrcSpan
instance Language.Fortran.Util.SecondParameter.SecondParameter (Language.Fortran.AST.DataGroup a) Language.Fortran.Util.Position.SrcSpan
instance Language.Fortran.Util.SecondParameter.SecondParameter (Language.Fortran.AST.Namelist a) Language.Fortran.Util.Position.SrcSpan
instance Language.Fortran.Util.SecondParameter.SecondParameter (Language.Fortran.AST.FormatItem a) Language.Fortran.Util.Position.SrcSpan
instance Language.Fortran.Util.SecondParameter.SecondParameter (Language.Fortran.AST.Expression a) Language.Fortran.Util.Position.SrcSpan
instance Language.Fortran.Util.SecondParameter.SecondParameter (Language.Fortran.AST.Index a) Language.Fortran.Util.Position.SrcSpan
instance Language.Fortran.Util.SecondParameter.SecondParameter (Language.Fortran.AST.DoSpecification a) Language.Fortran.Util.Position.SrcSpan
instance Language.Fortran.Util.SecondParameter.SecondParameter (Language.Fortran.AST.Declarator a) Language.Fortran.Util.Position.SrcSpan
instance Language.Fortran.Util.SecondParameter.SecondParameter (Language.Fortran.AST.DimensionDeclarator a) Language.Fortran.Util.Position.SrcSpan
instance Language.Fortran.Util.SecondParameter.SecondParameter (Language.Fortran.AST.ControlPair a) Language.Fortran.Util.Position.SrcSpan
instance Language.Fortran.Util.Position.Spanned (Language.Fortran.AST.Statement a)
instance Language.Fortran.Util.Position.Spanned (Language.Fortran.AST.Argument a)
instance Language.Fortran.Util.Position.Spanned (Language.Fortran.AST.Use a)
instance Language.Fortran.Util.Position.Spanned (Language.Fortran.AST.Attribute a)
instance Language.Fortran.Util.Position.Spanned (Language.Fortran.AST.TypeSpec a)
instance Language.Fortran.Util.Position.Spanned (Language.Fortran.AST.Selector a)
instance Language.Fortran.Util.Position.Spanned (Language.Fortran.AST.ImpList a)
instance Language.Fortran.Util.Position.Spanned (Language.Fortran.AST.CommonGroup a)
instance Language.Fortran.Util.Position.Spanned (Language.Fortran.AST.DataGroup a)
instance Language.Fortran.Util.Position.Spanned (Language.Fortran.AST.Namelist a)
instance Language.Fortran.Util.Position.Spanned (Language.Fortran.AST.FormatItem a)
instance Language.Fortran.Util.Position.Spanned (Language.Fortran.AST.Expression a)
instance Language.Fortran.Util.Position.Spanned (Language.Fortran.AST.Index a)
instance Language.Fortran.Util.Position.Spanned (Language.Fortran.AST.DoSpecification a)
instance Language.Fortran.Util.Position.Spanned (Language.Fortran.AST.Declarator a)
instance Language.Fortran.Util.Position.Spanned (Language.Fortran.AST.DimensionDeclarator a)
instance Language.Fortran.Util.Position.Spanned (Language.Fortran.AST.ControlPair a)
instance Text.PrettyPrint.GenericPretty.Out a => Text.PrettyPrint.GenericPretty.Out (Language.Fortran.AST.Statement a)
instance Text.PrettyPrint.GenericPretty.Out a => Text.PrettyPrint.GenericPretty.Out (Language.Fortran.AST.Argument a)
instance Text.PrettyPrint.GenericPretty.Out a => Text.PrettyPrint.GenericPretty.Out (Language.Fortran.AST.Use a)
instance Text.PrettyPrint.GenericPretty.Out a => Text.PrettyPrint.GenericPretty.Out (Language.Fortran.AST.Attribute a)
instance Text.PrettyPrint.GenericPretty.Out a => Text.PrettyPrint.GenericPretty.Out (Language.Fortran.AST.ImpList a)
instance Text.PrettyPrint.GenericPretty.Out a => Text.PrettyPrint.GenericPretty.Out (Language.Fortran.AST.CommonGroup a)
instance Text.PrettyPrint.GenericPretty.Out a => Text.PrettyPrint.GenericPretty.Out (Language.Fortran.AST.DataGroup a)
instance Text.PrettyPrint.GenericPretty.Out a => Text.PrettyPrint.GenericPretty.Out (Language.Fortran.AST.Namelist a)
instance Text.PrettyPrint.GenericPretty.Out a => Text.PrettyPrint.GenericPretty.Out (Language.Fortran.AST.FormatItem a)
instance Text.PrettyPrint.GenericPretty.Out a => Text.PrettyPrint.GenericPretty.Out (Language.Fortran.AST.Expression a)
instance Text.PrettyPrint.GenericPretty.Out a => Text.PrettyPrint.GenericPretty.Out (Language.Fortran.AST.Index a)
instance Text.PrettyPrint.GenericPretty.Out a => Text.PrettyPrint.GenericPretty.Out (Language.Fortran.AST.DoSpecification a)
instance Text.PrettyPrint.GenericPretty.Out a => Text.PrettyPrint.GenericPretty.Out (Language.Fortran.AST.Value a)
instance Text.PrettyPrint.GenericPretty.Out a => Text.PrettyPrint.GenericPretty.Out (Language.Fortran.AST.TypeSpec a)
instance Text.PrettyPrint.GenericPretty.Out a => Text.PrettyPrint.GenericPretty.Out (Language.Fortran.AST.Selector a)
instance Text.PrettyPrint.GenericPretty.Out a => Text.PrettyPrint.GenericPretty.Out (Language.Fortran.AST.Declarator a)
instance Text.PrettyPrint.GenericPretty.Out a => Text.PrettyPrint.GenericPretty.Out (Language.Fortran.AST.DimensionDeclarator a)
instance Text.PrettyPrint.GenericPretty.Out a => Text.PrettyPrint.GenericPretty.Out (Language.Fortran.AST.ControlPair a)
instance Text.PrettyPrint.GenericPretty.Out a => Text.PrettyPrint.GenericPretty.Out (Language.Fortran.AST.ForallHeader a)
instance Text.PrettyPrint.GenericPretty.Out Language.Fortran.AST.BinaryOp
instance Text.PrettyPrint.GenericPretty.Out Language.Fortran.AST.UnaryOp
instance Language.Fortran.Util.FirstParameter.FirstParameter (Language.Fortran.AST.ImpElement a) a
instance Language.Fortran.Util.SecondParameter.SecondParameter (Language.Fortran.AST.ImpElement a) Language.Fortran.Util.Position.SrcSpan
instance Language.Fortran.Util.Position.Spanned (Language.Fortran.AST.ImpElement a)
instance Text.PrettyPrint.GenericPretty.Out a => Text.PrettyPrint.GenericPretty.Out (Language.Fortran.AST.ImpElement a)
instance Text.PrettyPrint.GenericPretty.Out Language.Fortran.AST.Intent
instance Text.PrettyPrint.GenericPretty.Out Language.Fortran.AST.Only
instance Text.PrettyPrint.GenericPretty.Out a => Text.PrettyPrint.GenericPretty.Out (Language.Fortran.AST.Comment a)
instance Text.PrettyPrint.GenericPretty.Out Language.Fortran.AST.MetaInfo
instance Data.Binary.Class.Binary Language.Fortran.AST.BaseType
instance Text.PrettyPrint.GenericPretty.Out Language.Fortran.AST.BaseType
instance GHC.Base.Functor t => GHC.Base.Functor (Language.Fortran.AST.AList t)
instance Language.Fortran.Util.FirstParameter.FirstParameter (Language.Fortran.AST.AList t a) a
instance Language.Fortran.Util.SecondParameter.SecondParameter (Language.Fortran.AST.AList t a) Language.Fortran.Util.Position.SrcSpan
instance Language.Fortran.Util.Position.Spanned (Language.Fortran.AST.AList t a)
instance (Text.PrettyPrint.GenericPretty.Out a, Text.PrettyPrint.GenericPretty.Out (t a)) => Text.PrettyPrint.GenericPretty.Out (Language.Fortran.AST.AList t a)
instance Text.PrettyPrint.GenericPretty.Out Language.Fortran.ParserMonad.FortranVersion

module Language.Fortran.PrettyPrint
tooOld :: FortranVersion -> String -> FortranVersion -> a
(<?>) :: Doc -> Doc -> Doc
infixl 7 <?>
(<?+>) :: Doc -> Doc -> Doc
infixl 7 <?+>
newline :: Doc
type Indentation = Maybe Int
incIndentation :: Indentation -> Indentation
indent :: Indentation -> Doc -> Doc
overlay :: Doc -> Doc -> Doc
fixedForm :: Maybe Int
pprintAndRender :: IndentablePretty t => FortranVersion -> t -> Indentation -> String
class IndentablePretty t
pprint :: IndentablePretty t => FortranVersion -> t -> Indentation -> Doc
endGen :: Pretty a => FortranVersion -> Doc -> a -> Indentation -> Doc
class Pretty t
pprint' :: Pretty t => FortranVersion -> t -> Doc
commaSep :: [Doc] -> Doc
instance Language.Fortran.PrettyPrint.Pretty a => Language.Fortran.PrettyPrint.IndentablePretty a
instance Language.Fortran.PrettyPrint.IndentablePretty (Language.Fortran.AST.ProgramUnit a)
instance Language.Fortran.PrettyPrint.IndentablePretty (Language.Fortran.AST.Block a)
instance Language.Fortran.PrettyPrint.Pretty a => Language.Fortran.PrettyPrint.Pretty (GHC.Base.Maybe a)
instance Language.Fortran.PrettyPrint.Pretty GHC.Base.String
instance Language.Fortran.PrettyPrint.Pretty (e a) => Language.Fortran.PrettyPrint.Pretty (Language.Fortran.AST.AList e a)
instance Language.Fortran.PrettyPrint.Pretty Language.Fortran.AST.BaseType
instance Language.Fortran.PrettyPrint.Pretty (Language.Fortran.AST.TypeSpec a)
instance Language.Fortran.PrettyPrint.Pretty (Language.Fortran.AST.Selector a)
instance Language.Fortran.PrettyPrint.Pretty (Language.Fortran.AST.Statement a)
instance Language.Fortran.PrettyPrint.Pretty Language.Fortran.AST.Only
instance Language.Fortran.PrettyPrint.Pretty (Language.Fortran.AST.Use a)
instance Language.Fortran.PrettyPrint.Pretty (Language.Fortran.AST.Argument a)
instance Language.Fortran.PrettyPrint.Pretty (Language.Fortran.AST.Attribute a)
instance Language.Fortran.PrettyPrint.Pretty Language.Fortran.AST.Intent
instance Language.Fortran.PrettyPrint.Pretty (Language.Fortran.AST.FormatItem a)
instance Language.Fortran.PrettyPrint.Pretty (Language.Fortran.AST.DoSpecification a)
instance Language.Fortran.PrettyPrint.Pretty (Language.Fortran.AST.ControlPair a)
instance Language.Fortran.PrettyPrint.Pretty (Language.Fortran.AST.ImpList a)
instance Language.Fortran.PrettyPrint.Pretty (Language.Fortran.AST.CommonGroup a)
instance Language.Fortran.PrettyPrint.Pretty (Language.Fortran.AST.Namelist a)
instance Language.Fortran.PrettyPrint.Pretty (Language.Fortran.AST.DataGroup a)
instance Language.Fortran.PrettyPrint.Pretty (Language.Fortran.AST.ImpElement a)
instance Language.Fortran.PrettyPrint.Pretty (Language.Fortran.AST.Expression a)
instance Language.Fortran.PrettyPrint.Pretty (Language.Fortran.AST.Index a)
instance Language.Fortran.PrettyPrint.Pretty (Language.Fortran.AST.Value a)
instance Language.Fortran.PrettyPrint.Pretty (Language.Fortran.AST.Declarator a)
instance Language.Fortran.PrettyPrint.Pretty (Language.Fortran.AST.DimensionDeclarator a)
instance Language.Fortran.PrettyPrint.Pretty Language.Fortran.AST.UnaryOp
instance Language.Fortran.PrettyPrint.Pretty Language.Fortran.AST.BinaryOp
instance Language.Fortran.PrettyPrint.IndentablePretty a => Language.Fortran.PrettyPrint.IndentablePretty (GHC.Base.Maybe a)
instance Language.Fortran.PrettyPrint.IndentablePretty (Language.Fortran.AST.ProgramFile a)
instance Language.Fortran.PrettyPrint.IndentablePretty [Language.Fortran.AST.ProgramUnit a]
instance Language.Fortran.PrettyPrint.IndentablePretty [Language.Fortran.AST.Block a]
instance Language.Fortran.Util.FirstParameter.FirstParameter (Language.Fortran.AST.Value a) GHC.Base.String


-- | Common data structures and functions supporting analysis of the AST.
module Language.Fortran.Analysis

-- | Create analysis annotations for the program, saving the original
--   annotations.
initAnalysis :: Functor b => b a -> b (Analysis a)

-- | Remove analysis annotations from the program, restoring the original
--   annotations.
stripAnalysis :: Functor b => b (Analysis a) -> b a
data Analysis a
Analysis :: a -> Maybe String -> Maybe String -> Maybe (BBGr (Analysis a)) -> Maybe Int -> Maybe ModEnv -> Maybe IDType -> [Name] -> Analysis a

-- | original annotation
[prevAnnotation] :: Analysis a -> a

-- | unique name for function/variable, after variable renaming phase
[uniqueName] :: Analysis a -> Maybe String

-- | original name for function/variable found in source text
[sourceName] :: Analysis a -> Maybe String

-- | basic block graph
[bBlocks] :: Analysis a -> Maybe (BBGr (Analysis a))

-- | unique number for each block during dataflow analysis
[insLabel] :: Analysis a -> Maybe Int
[moduleEnv] :: Analysis a -> Maybe ModEnv
[idType] :: Analysis a -> Maybe IDType
[allLhsVarsAnn] :: Analysis a -> [Name]

-- | Obtain either uniqueName or source name from an ExpValue variable.
varName :: Expression (Analysis a) -> String

-- | Obtain the source name from an ExpValue variable.
srcName :: Expression (Analysis a) -> String

-- | True iff the expression can be used with varName or srcName
isNamedExpression :: Expression a -> Bool

-- | Generate an ExpValue variable with its source name == to its
--   uniqueName.
genVar :: Analysis a -> SrcSpan -> String -> Expression (Analysis a)

-- | Obtain either ProgramUnit uniqueName or whatever is in the AST.
puName :: ProgramUnit (Analysis a) -> ProgramUnitName

-- | Obtain either ProgramUnit sourceName or whatever is in the AST.
puSrcName :: ProgramUnit (Analysis a) -> ProgramUnitName

-- | Set of expressions used -- not defined -- by an AST-block.
blockRhsExprs :: Data a => Block a -> [Expression a]

-- | Return list of expressions that are not "left-hand-side" of assignment
--   statements.
rhsExprs :: (Data a, Data (b a)) => b a -> [Expression a]
type ModEnv = Map String (String, NameType)
data NameType
NTSubprogram :: NameType
NTVariable :: NameType
NTIntrinsic :: NameType
data IDType
IDType :: Maybe BaseType -> Maybe ConstructType -> IDType
[idVType] :: IDType -> Maybe BaseType
[idCType] :: IDType -> Maybe ConstructType
data ConstructType
CTFunction :: ConstructType
CTSubroutine :: ConstructType
CTVariable :: ConstructType
CTArray :: ConstructType
CTParameter :: ConstructType
CTIntrinsic :: ConstructType
data BaseType
TypeInteger :: BaseType
TypeReal :: BaseType
TypeDoublePrecision :: BaseType
TypeComplex :: BaseType
TypeDoubleComplex :: BaseType
TypeLogical :: BaseType
TypeCharacter :: BaseType
TypeCustom :: String -> BaseType

-- | Return list of expressions used as the left-hand-side of assignment
--   statements (including for-loops and function-calls by reference).
lhsExprs :: forall a b. (Data a, Data (b a)) => b a -> [Expression a]

-- | Is this an expression capable of assignment?
isLExpr :: Expression a -> Bool

-- | Set of names found in an AST node.
allVars :: forall a b. (Data a, Data (b (Analysis a))) => b (Analysis a) -> [Name]

-- | Initiate (lazy) computation of all LHS variables for each node of the
--   AST so that it may be accessed later.
analyseAllLhsVars :: forall a. Data a => ProgramFile (Analysis a) -> ProgramFile (Analysis a)
analyseAllLhsVars1 :: (Annotated f, Data (f (Analysis a)), Data a) => f (Analysis a) -> f (Analysis a)

-- | Set of names found in the parts of an AST that are the target of an
--   assignment statement. allLhsVars :: (Annotated b, Data a, Data (b
--   (Analysis a))) =&gt; b (Analysis a) -&gt; [Name]
allLhsVars :: Data a => Block (Analysis a) -> [Name]

-- | Set of names used -- not defined -- by an AST-block.
blockVarUses :: Data a => Block (Analysis a) -> [Name]

-- | Set of names defined by an AST-block.
blockVarDefs :: Data a => Block (Analysis a) -> [Name]

-- | Basic block
type BB a = [Block a]

-- | Basic block graph.
type BBGr a = Gr (BB a) ()

-- | The type of "transformBi"-family functions
type TransFunc f g a = (f (Analysis a) -> f (Analysis a)) -> g (Analysis a) -> g (Analysis a)

-- | The type of "transformBiM"-family functions
type TransFuncM m f g a = (f (Analysis a) -> m (f (Analysis a))) -> g (Analysis a) -> m (g (Analysis a))
instance GHC.Generics.Generic (Language.Fortran.Analysis.Analysis a)
instance GHC.Classes.Eq a => GHC.Classes.Eq (Language.Fortran.Analysis.Analysis a)
instance GHC.Show.Show a => GHC.Show.Show (Language.Fortran.Analysis.Analysis a)
instance Data.Data.Data a => Data.Data.Data (Language.Fortran.Analysis.Analysis a)
instance GHC.Generics.Generic Language.Fortran.Analysis.IDType
instance Data.Data.Data Language.Fortran.Analysis.IDType
instance GHC.Show.Show Language.Fortran.Analysis.IDType
instance GHC.Classes.Eq Language.Fortran.Analysis.IDType
instance GHC.Classes.Ord Language.Fortran.Analysis.IDType
instance GHC.Generics.Generic Language.Fortran.Analysis.ConstructType
instance Data.Data.Data Language.Fortran.Analysis.ConstructType
instance GHC.Show.Show Language.Fortran.Analysis.ConstructType
instance GHC.Classes.Eq Language.Fortran.Analysis.ConstructType
instance GHC.Classes.Ord Language.Fortran.Analysis.ConstructType
instance GHC.Generics.Generic Language.Fortran.Analysis.NameType
instance Data.Data.Data Language.Fortran.Analysis.NameType
instance GHC.Classes.Ord Language.Fortran.Analysis.NameType
instance GHC.Classes.Eq Language.Fortran.Analysis.NameType
instance GHC.Show.Show Language.Fortran.Analysis.NameType
instance Text.PrettyPrint.GenericPretty.Out (Language.Fortran.Analysis.Analysis a)
instance Text.PrettyPrint.GenericPretty.Out Language.Fortran.Analysis.IDType
instance Data.Binary.Class.Binary Language.Fortran.Analysis.IDType
instance Text.PrettyPrint.GenericPretty.Out Language.Fortran.Analysis.ConstructType
instance Data.Binary.Class.Binary Language.Fortran.Analysis.ConstructType
instance Data.Binary.Class.Binary Language.Fortran.Analysis.NameType
instance Text.PrettyPrint.GenericPretty.Out Language.Fortran.Analysis.NameType
instance (Data.Typeable.Internal.Typeable a, Data.Typeable.Internal.Typeable b) => Data.Data.Data (Data.Graph.Inductive.PatriciaTree.Gr a b)

module Language.Fortran.Analysis.Types

-- | Annotate AST nodes with type information and also return a type
--   environment mapping names to type information.
analyseTypes :: Data a => ProgramFile (Analysis a) -> (ProgramFile (Analysis a), TypeEnv)

-- | Annotate AST nodes with type information and also return a type
--   environment mapping names to type information; provided with a
--   starting type environment.
analyseTypesWithEnv :: Data a => TypeEnv -> ProgramFile (Analysis a) -> (ProgramFile (Analysis a), TypeEnv)
extractTypeEnv :: forall a. Data a => ProgramFile (Analysis a) -> TypeEnv

-- | Mapping of names to type information.
type TypeEnv = Map Name IDType
instance GHC.Show.Show Language.Fortran.Analysis.Types.InferState


-- | Analyse variables/function names and produce unique names that can be
--   used to replace the original names while maintaining program
--   equivalence (a.k.a. alpha-conversion). The advantage of the unique
--   names is that scoping issues can be ignored when doing further
--   analysis.
module Language.Fortran.Analysis.Renaming

-- | Annotate unique names for variable and function declarations and uses.
analyseRenames :: Data a => ProgramFile (Analysis a) -> ProgramFile (Analysis a)

-- | Annotate unique names for variable and function declarations and uses.
--   With external module map.
analyseRenamesWithModuleMap :: Data a => ModuleMap -> ProgramFile (Analysis a) -> ProgramFile (Analysis a)

-- | Take the unique name annotations and substitute them into the actual
--   AST.
rename :: Data a => ProgramFile (Analysis a) -> ProgramFile (Analysis a)

-- | Take a renamed program and undo the renames.
unrename :: Data a => ProgramFile (Analysis a) -> ProgramFile (Analysis a)
type ModuleMap = Map ProgramUnitName ModEnv
instance GHC.Classes.Eq Language.Fortran.Analysis.Renaming.RenameState
instance GHC.Show.Show Language.Fortran.Analysis.Renaming.RenameState


-- | Format of Camfort precompiled files with information about Fortran
--   modules. The <tt>ModuleMap</tt> stores information important to the
--   renamer. The other data is up to you.
--   
--   One typical usage might look like:
--   
--   <pre>
--   let modFile1 = genModFile programFile
--   let modFile2 = alterModFileData (const (Just ...)) "mydata" modFile1
--   let bytes    = encodeModFile modFile1
--   ...
--   case decodeModFile bytes of
--     Left error -&gt; print error
--     Right modFile3 -&gt; ...
--       where
--         moduleMap = combinedModuleMap (modFile3:otherModuleFiles)
--         myData    = lookupModFileData "mydata" modFile3
--         renamedPF = analyseRenamesWithModuleMap moduleMap programFile
--   </pre>
module Language.Fortran.Util.ModFile

-- | Standard ending of fortran-src-format "mod files"
modFileSuffix :: String

-- | The data stored in the "mod files"
data ModFile

-- | A set of decoded mod files.
type ModFiles = [ModFile]

-- | Starting point.
emptyModFile :: ModFile

-- | Empty set of mod files. (future proof: may not always be a list)
emptyModFiles :: ModFiles

-- | Looks up the raw "other data" that may be stored in a ModFile by
--   applications that make use of fortran-src.
lookupModFileData :: String -> ModFile -> Maybe ByteString

-- | Get a list of the labels present in the "other data" of a ModFile.
--   More of a meta-programming / debugging feature.
getLabelsModFileData :: ModFile -> [String]

-- | Allows modification<i>insertion</i>deletion of "other data" that may
--   be stored in a ModFile by applications that make use of fortran-src.
--   See <a>alter</a> for more information about the interface of this
--   function.
alterModFileData :: (Maybe ByteString -> Maybe ByteString) -> String -> ModFile -> ModFile

-- | Generate a fresh ModFile from the module map, declaration map and type
--   analysis of a given analysed and renamed ProgramFile.
genModFile :: forall a. Data a => ProgramFile (Analysis a) -> ModFile

-- | Extracts the module map, declaration map and type analysis from an
--   analysed and renamed ProgramFile, then inserts it into the ModFile.
regenModFile :: forall a. Data a => ProgramFile (Analysis a) -> ModFile -> ModFile

-- | Convert ModFile to a strict ByteString for writing to file.
encodeModFile :: ModFile -> ByteString

-- | Convert a strict ByteString to a ModFile, if possible
decodeModFile :: Binary a => ByteString -> Either String a

-- | Map of unique variable name to the unique name of the program unit
--   where it was defined, and the corresponding SrcSpan.
type DeclMap = Map Name (DeclContext, SrcSpan)

-- | Context of a declaration: the ProgramUnit where it was declared.
data DeclContext
DCMain :: DeclContext
DCBlockData :: DeclContext
DCModule :: ProgramUnitName -> DeclContext

-- | (uniqName, srcName)
DCFunction :: (ProgramUnitName, ProgramUnitName) -> DeclContext

-- | (uniqName, srcName)
DCSubroutine :: (ProgramUnitName, ProgramUnitName) -> DeclContext

-- | Extract all module maps (name -&gt; environment) by collecting all of
--   the stored module maps within the PUModule annotation.
extractModuleMap :: forall a. Data a => ProgramFile (Analysis a) -> ModuleMap

-- | Extract map of declared variables with their associated program unit
--   and source span.
extractDeclMap :: forall a. Data a => ProgramFile (Analysis a) -> DeclMap

-- | Get the associated Fortran filename that was used to compile the
--   ModFile.
moduleFilename :: ModFile -> String

-- | Extract the combined declaration map from a set of ModFiles. Useful
--   for parsing a Fortran file in a large context of other modules.
combinedDeclMap :: ModFiles -> DeclMap

-- | Extract the combined module map from a set of ModFiles. Useful for
--   parsing a Fortran file in a large context of other modules.
combinedModuleMap :: ModFiles -> ModuleMap

-- | Extract the combined module map from a set of ModFiles. Useful for
--   parsing a Fortran file in a large context of other modules.
combinedTypeEnv :: ModFiles -> TypeEnv

-- | Create a map that links all unique variable/function names in the
--   ModFiles to their corresponding filename.
genUniqNameToFilenameMap :: ModFiles -> Map Name String
instance GHC.Generics.Generic Language.Fortran.Util.ModFile.ModFile
instance Data.Data.Data Language.Fortran.Util.ModFile.ModFile
instance GHC.Show.Show Language.Fortran.Util.ModFile.ModFile
instance GHC.Classes.Eq Language.Fortran.Util.ModFile.ModFile
instance GHC.Classes.Ord Language.Fortran.Util.ModFile.ModFile
instance GHC.Generics.Generic Language.Fortran.Util.ModFile.DeclContext
instance Data.Data.Data Language.Fortran.Util.ModFile.DeclContext
instance GHC.Show.Show Language.Fortran.Util.ModFile.DeclContext
instance GHC.Classes.Eq Language.Fortran.Util.ModFile.DeclContext
instance GHC.Classes.Ord Language.Fortran.Util.ModFile.DeclContext
instance Data.Binary.Class.Binary Language.Fortran.Util.ModFile.ModFile
instance Data.Binary.Class.Binary Language.Fortran.Util.ModFile.DeclContext

module Language.Fortran.Transformation.TransformMonad
getProgramFile :: Transform a (ProgramFile (Analysis a))
putProgramFile :: ProgramFile (Analysis a) -> Transform a ()
modifyProgramFile :: (ProgramFile (Analysis a) -> ProgramFile (Analysis a)) -> Transform a ()
runTransform :: Data a => TypeEnv -> ModuleMap -> Transform a () -> ProgramFile a -> ProgramFile a
type Transform a = State (TransformationState a)

module Language.Fortran.Transformation.Grouping
groupIf :: Transform a ()
groupDo :: Transform a ()
groupLabeledDo :: Transform a ()
groupCase :: Transform a ()

module Language.Fortran.Transformation.Disambiguation.Intrinsic
disambiguateIntrinsic :: Data a => Transform a ()

module Language.Fortran.Transformation.Disambiguation.Function
disambiguateFunction :: Data a => Transform a ()
instance Language.Fortran.Transformation.Disambiguation.Function.Indexed Language.Fortran.AST.Argument
instance Language.Fortran.Transformation.Disambiguation.Function.Indexed Language.Fortran.AST.Expression

module Language.Fortran.Transformer
transform :: Data a => [Transformation] -> ProgramFile a -> ProgramFile a
transformWithModFiles :: Data a => ModFiles -> [Transformation] -> ProgramFile a -> ProgramFile a
data Transformation
GroupIf :: Transformation
GroupCase :: Transformation
GroupDo :: Transformation
GroupLabeledDo :: Transformation
DisambiguateFunction :: Transformation
DisambiguateIntrinsic :: Transformation
instance GHC.Classes.Eq Language.Fortran.Transformer.Transformation

module Language.Fortran.Parser.Fortran90
statementParser :: LexAction Statement A0
fortran90Parser :: ByteString -> String -> ParseResult AlexInput Token (ProgramFile A0)
fortran90ParserWithModFiles :: ModFiles -> ByteString -> String -> ParseResult AlexInput Token (ProgramFile A0)

module Language.Fortran.Parser.Fortran77
expressionParser :: LexAction Expression A0
statementParser :: LexAction Statement A0
fortran77Parser :: ByteString -> String -> ParseResult AlexInput Token (ProgramFile A0)
extended77Parser :: ByteString -> String -> ParseResult AlexInput Token (ProgramFile A0)
fortran77ParserWithModFiles :: ModFiles -> ByteString -> String -> ParseResult AlexInput Token (ProgramFile A0)
extended77ParserWithModFiles :: ModFiles -> ByteString -> String -> ParseResult AlexInput Token (ProgramFile A0)

module Language.Fortran.Parser.Fortran66
expressionParser :: LexAction Expression A0
statementParser :: LexAction Statement A0
fortran66Parser :: ByteString -> String -> ParseResult AlexInput Token (ProgramFile A0)
fortran66ParserWithModFiles :: ModFiles -> ByteString -> String -> ParseResult AlexInput Token (ProgramFile A0)

module Language.Fortran.Parser.Any
deduceVersion :: String -> FortranVersion
type Parser = ByteString -> String -> Either ParseErrorSimple (ProgramFile A0)
parserVersions :: [(FortranVersion, Parser)]
type ParserWithModFiles = ModFiles -> ByteString -> String -> Either ParseErrorSimple (ProgramFile A0)
parserWithModFilesVersions :: [(FortranVersion, ParserWithModFiles)]
after :: () => (b -> c) -> (t -> a -> b) -> t -> a -> c

-- | Deduce the type of parser from the filename and parse the contents of
--   the file.
fortranParser :: Parser

-- | Deduce the type of parser from the filename and parse the contents of
--   the file, within the context of given "mod files".
fortranParserWithModFiles :: ParserWithModFiles


-- | Dataflow analysis to be applied once basic block analysis is complete.
module Language.Fortran.Analysis.DataFlow

-- | Compute dominators of each bblock in the graph. Node A dominates node
--   B when all paths from the start node of that program unit must pass
--   through node A in order to reach node B. That will be represented as
--   the relation (B, [A, ...]) in the DomMap.
dominators :: BBGr a -> DomMap

-- | Compute the immediate dominator of each bblock in the graph. The
--   immediate dominator is, in a sense, the <tt>closest</tt> dominator of
--   a node. Given nodes A and B, you can say that node A is immediately
--   dominated by node B if there does not exist any node C such that: node
--   A dominates node C and node C dominates node B.
iDominators :: BBGr a -> IDomMap

-- | DomMap : node -&gt; dominators of node
type DomMap = IntMap IntSet

-- | IDomMap : node -&gt; immediate dominator of node
type IDomMap = IntMap Int

-- | The postordering of a graph outputs the label after traversal of
--   children.
postOrder :: OrderF a

-- | Reversed postordering.
revPostOrder :: OrderF a

-- | The preordering of a graph outputs the label before traversal of
--   children.
preOrder :: OrderF a

-- | Reversed preordering.
revPreOrder :: OrderF a

-- | An OrderF is a function from graph to a specific ordering of nodes.
type OrderF a = BBGr a -> [Node]

-- | Apply the iterative dataflow analysis method.
dataFlowSolver :: Ord t => BBGr a -> (Node -> InOut t) -> OrderF a -> (OutF t -> InF t) -> (InF t -> OutF t) -> InOutMap t

-- | Show some information about dataflow analyses.
showDataFlow :: (Data a, Out a, Show a) => ProgramFile (Analysis a) -> String

-- | InOut : (dataflow into the bblock, dataflow out of the bblock)
type InOut t = (t, t)

-- | InOutMap : node -&gt; (dataflow into node, dataflow out of node)
type InOutMap t = IntMap (InOut t)

-- | InF, a function that returns the in-dataflow for a given node
type InF t = Node -> t

-- | OutF, a function that returns the out-dataflow for a given node
type OutF t = Node -> t

-- | Dataflow analysis for live variables given basic block graph.
--   Muchnick, p. 445: A variable is "live" at a particular program point
--   if there is a path to the exit along which its value may be used
--   before it is redefined. It is "dead" if there is no such path.
liveVariableAnalysis :: Data a => BBGr (Analysis a) -> InOutMap (Set Name)

-- | Reaching definitions dataflow analysis. Reaching definitions are the
--   set of variable-defining AST-block labels that may reach a program
--   point. Suppose AST-block with label A defines a variable named v.
--   Label A may reach another program point labeled P if there is at least
--   one program path from label A to label P that does not redefine
--   variable v.
reachingDefinitions :: Data a => DefMap -> BBGr (Analysis a) -> InOutMap IntSet

-- | use-def map: map AST-block labels of variable-using AST-blocks to the
--   AST-blocks that define those variables.
genUDMap :: Data a => BlockMap a -> DefMap -> BBGr (Analysis a) -> InOutMap IntSet -> UDMap

-- | def-use map: map AST-block labels of defining AST-blocks to the
--   AST-blocks that may use the definition.
genDUMap :: Data a => BlockMap a -> DefMap -> BBGr (Analysis a) -> InOutMap IntSet -> DUMap

-- | Invert the DUMap into a UDMap
duMapToUdMap :: DUMap -> UDMap

-- | UDMap : use -&gt; { definition }
type UDMap = IntMap IntSet

-- | DUMap : definition -&gt; { use }
type DUMap = IntMap IntSet

-- | <a>Flows-To</a> analysis. Represent def-use map as a graph.
genFlowsToGraph :: Data a => BlockMap a -> DefMap -> BBGr (Analysis a) -> InOutMap IntSet -> FlowsGraph a

-- | FlowsGraph : nodes as AST-block (numbered by label), edges showing
--   which definitions contribute to which uses.
type FlowsGraph a = Gr (Block (Analysis a)) ()

-- | Create a map (A -&gt; Bs) where A "flows" or contributes towards the
--   variables Bs.
genVarFlowsToMap :: Data a => DefMap -> FlowsGraph a -> VarFlowsMap

-- | Represent "flows" between variables
type VarFlowsMap = Map Name (Set Name)

-- | Build a BlockMap from the AST. This can only be performed after
--   analyseBasicBlocks has operated, created basic blocks, and labeled all
--   of the AST-blocks with unique numbers.
genBlockMap :: Data a => ProgramFile (Analysis a) -> BlockMap a

-- | Build a DefMap from the BlockMap. This allows us to quickly look up
--   the AST-block labels that wrote into the given variable.
genDefMap :: Data a => BlockMap a -> DefMap

-- | BlockMap : AST-block label -&gt; AST-block Each AST-block has been
--   given a unique number label during analysis of basic blocks. The
--   purpose of this map is to provide the ability to lookup AST-blocks by
--   label.
type BlockMap a = IntMap (Block (Analysis a))

-- | DefMap : variable name -&gt; { AST-block label }
type DefMap = Map Name IntSet

-- | Create a call map showing the structure of the program.
genCallMap :: Data a => ProgramFile (Analysis a) -> CallMap

-- | CallMap : program unit name -&gt; { name of function or subroutine }
type CallMap = Map ProgramUnitName (Set Name)

-- | For each loop in the program, find out which bblock nodes are part of
--   the loop by looking through the backedges (m, n) where n is considered
--   the 'loop-header', delete n from the map, and then do a
--   reverse-depth-first traversal starting from m to find all the nodes of
--   interest. Intersect this with the strongly-connected component
--   containing m, in case of <tt>improper</tt> graphs with weird control
--   transfers.
loopNodes :: Graph gr => BackEdgeMap -> gr a b -> [IntSet]

-- | Find the edges that 'loop back' in the graph; ones where the target
--   node dominates the source node. If the backedges are viewed as (m
--   -&gt; n) then n is considered the 'loop-header'
genBackEdgeMap :: Graph gr => DomMap -> gr a b -> BackEdgeMap

-- | The strongly connected component containing a given node.
sccWith :: (Graph gr) => Node -> gr a b -> [Node]

-- | BackEdgeMap : node -&gt; node
type BackEdgeMap = IntMap Node

-- | Similar to loopNodes except it creates a map from loop-header to the
--   set of loop nodes, for each loop-header.
genLoopNodeMap :: Graph gr => BackEdgeMap -> gr a b -> LoopNodeMap

-- | LoopNodeMap : node -&gt; { node }
type LoopNodeMap = IntMap IntSet

-- | For each loop in the program, figure out the names of the induction
--   variables: the variables that are used to represent the current
--   iteration of the loop.
genInductionVarMap :: Data a => BackEdgeMap -> BBGr (Analysis a) -> InductionVarMap

-- | Map of loop header nodes to the induction variables within that loop.
type InductionVarMap = IntMap (Set Name)

-- | Generate an induction variable map that is indexed by the labels on
--   AST-blocks within those loops.
genInductionVarMapByASTBlock :: forall a. Data a => BackEdgeMap -> BBGr (Analysis a) -> InductionVarMapByASTBlock

-- | InductionVarMapByASTBlock : AST-block label -&gt; { name }
type InductionVarMapByASTBlock = IntMap (Set Name)

-- | Compute the set of nodes with no predecessors.
noPredNodes :: Graph g => g a b -> [Node]

-- | For every expression in a loop, try to derive its relationship to a
--   basic induction variable.
genDerivedInductionMap :: forall a. Data a => BackEdgeMap -> BBGr (Analysis a) -> DerivedInductionMap
type DerivedInductionMap = IntMap InductionExpr
data InductionExpr
IETop :: InductionExpr
IELinear :: Name -> Int -> Int -> InductionExpr
IEBottom :: InductionExpr
instance Data.Data.Data Language.Fortran.Analysis.DataFlow.IEFlow
instance GHC.Generics.Generic Language.Fortran.Analysis.DataFlow.IEFlow
instance GHC.Classes.Ord Language.Fortran.Analysis.DataFlow.IEFlow
instance GHC.Classes.Eq Language.Fortran.Analysis.DataFlow.IEFlow
instance GHC.Show.Show Language.Fortran.Analysis.DataFlow.IEFlow
instance Data.Data.Data Language.Fortran.Analysis.DataFlow.InductionExpr
instance GHC.Generics.Generic Language.Fortran.Analysis.DataFlow.InductionExpr
instance GHC.Classes.Ord Language.Fortran.Analysis.DataFlow.InductionExpr
instance GHC.Classes.Eq Language.Fortran.Analysis.DataFlow.InductionExpr
instance GHC.Show.Show Language.Fortran.Analysis.DataFlow.InductionExpr


-- | Analyse a program file and create basic blocks.
module Language.Fortran.Analysis.BBlocks

-- | Insert basic block graphs into each program unit's analysis
analyseBBlocks :: Data a => ProgramFile (Analysis a) -> ProgramFile (Analysis a)

-- | Create a mapping of (non-module) program unit names to their
--   associated bblock graph.
genBBlockMap :: Data a => ProgramFile (Analysis a) -> BBlockMap (Analysis a)

-- | Show a basic block graph in a somewhat decent way.
showBBGr :: (Out a, Show a) => BBGr a -> String

-- | Show a basic block graph without the clutter
showAnalysedBBGr :: (Out a, Show a) => BBGr (Analysis a) -> String

-- | Pick out and show the basic block graphs in the program file analysis.
showBBlocks :: (Data a, Out a, Show a) => ProgramFile (Analysis a) -> String

-- | Output a graph in the GraphViz DOT format
bbgrToDOT :: BBGr a -> String

-- | A mapping of program unit names to bblock graphs.
type BBlockMap a = Map ProgramUnitName (BBGr a)
genSuperBBGr :: forall a. Data a => BBlockMap (Analysis a) -> SuperBBGr (Analysis a)
data SuperBBGr a

-- | Show a basic block supergraph
showSuperBBGr :: (Out a, Show a) => SuperBBGr (Analysis a) -> String

-- | Output a supergraph in the GraphViz DOT format
superBBGrToDOT :: SuperBBGr a -> String

-- | Extract graph from SuperBBGr
superBBGrGraph :: SuperBBGr a -> BBGr a

-- | Extract cluster map from SuperBBGr
superBBGrClusters :: SuperBBGr a -> IntMap ProgramUnitName

-- | Extract entry map from SuperBBGr
superBBGrEntries :: SuperBBGr a -> Map ProgramUnitName SuperNode
findLabeledBBlock :: String -> BBGr a -> Maybe Node
