{-# LANGUAGE DeriveDataTypeable #-}
{-# LANGUAGE DeriveGeneric #-}
{-# LANGUAGE DeriveAnyClass #-}
{-# OPTIONS_GHC -fno-warn-orphans #-}

module Language.Fortran.Vars.Types
  ( module Language.Fortran.Vars.Types
  , SemType(..)
  , CharacterLen(..)
  , Kind
  )
where

import           Language.Fortran.Extras.Encoding
import           Language.Fortran.Vars.Orphans
                                                ( )
import           Data.Aeson                     ( FromJSON
                                                , ToJSON
                                                , ToJSONKey
                                                , FromJSONKey
                                                )
import           Data.Data                      ( Data )
import           Data.Map                       ( Map )
import           Data.Typeable                  ( Typeable )
import           GHC.Generics                   ( Generic )
import           Control.DeepSeq                ( NFData )
import           Language.Fortran.AST           ( Name
                                                , ProgramUnitName
                                                , Expression
                                                )
import qualified Language.Fortran.AST.Literal.Boz      as AST
import           Language.Fortran.Util.Position ( SrcSpan(..)
                                                , Position(..)
                                                )
import           Language.Fortran.Analysis.SemanticTypes
                                                ( SemType(..)
                                                , CharacterLen(..)
                                                , Kind
                                                )

type Type = SemType

-- | The evaluated value of a FORTRAN expression
data ExpVal
  = Int     Int
  | Real    Double
  | Str     String
  | Logical Bool
  | Boz     AST.Boz
  deriving (ExpVal -> ExpVal -> Bool
(ExpVal -> ExpVal -> Bool)
-> (ExpVal -> ExpVal -> Bool) -> Eq ExpVal
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: ExpVal -> ExpVal -> Bool
$c/= :: ExpVal -> ExpVal -> Bool
== :: ExpVal -> ExpVal -> Bool
$c== :: ExpVal -> ExpVal -> Bool
Eq, Eq ExpVal
Eq ExpVal
-> (ExpVal -> ExpVal -> Ordering)
-> (ExpVal -> ExpVal -> Bool)
-> (ExpVal -> ExpVal -> Bool)
-> (ExpVal -> ExpVal -> Bool)
-> (ExpVal -> ExpVal -> Bool)
-> (ExpVal -> ExpVal -> ExpVal)
-> (ExpVal -> ExpVal -> ExpVal)
-> Ord ExpVal
ExpVal -> ExpVal -> Bool
ExpVal -> ExpVal -> Ordering
ExpVal -> ExpVal -> ExpVal
forall a.
Eq a
-> (a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
min :: ExpVal -> ExpVal -> ExpVal
$cmin :: ExpVal -> ExpVal -> ExpVal
max :: ExpVal -> ExpVal -> ExpVal
$cmax :: ExpVal -> ExpVal -> ExpVal
>= :: ExpVal -> ExpVal -> Bool
$c>= :: ExpVal -> ExpVal -> Bool
> :: ExpVal -> ExpVal -> Bool
$c> :: ExpVal -> ExpVal -> Bool
<= :: ExpVal -> ExpVal -> Bool
$c<= :: ExpVal -> ExpVal -> Bool
< :: ExpVal -> ExpVal -> Bool
$c< :: ExpVal -> ExpVal -> Bool
compare :: ExpVal -> ExpVal -> Ordering
$ccompare :: ExpVal -> ExpVal -> Ordering
Ord, Int -> ExpVal -> ShowS
[ExpVal] -> ShowS
ExpVal -> String
(Int -> ExpVal -> ShowS)
-> (ExpVal -> String) -> ([ExpVal] -> ShowS) -> Show ExpVal
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [ExpVal] -> ShowS
$cshowList :: [ExpVal] -> ShowS
show :: ExpVal -> String
$cshow :: ExpVal -> String
showsPrec :: Int -> ExpVal -> ShowS
$cshowsPrec :: Int -> ExpVal -> ShowS
Show, Typeable ExpVal
Typeable ExpVal
-> (forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> ExpVal -> c ExpVal)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c ExpVal)
-> (ExpVal -> Constr)
-> (ExpVal -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c ExpVal))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c ExpVal))
-> ((forall b. Data b => b -> b) -> ExpVal -> ExpVal)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> ExpVal -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> ExpVal -> r)
-> (forall u. (forall d. Data d => d -> u) -> ExpVal -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> ExpVal -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> ExpVal -> m ExpVal)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> ExpVal -> m ExpVal)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> ExpVal -> m ExpVal)
-> Data ExpVal
ExpVal -> DataType
ExpVal -> Constr
(forall b. Data b => b -> b) -> ExpVal -> ExpVal
forall a.
Typeable a
-> (forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> a -> c a)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c a)
-> (a -> Constr)
-> (a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c a))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
-> ((forall b. Data b => b -> b) -> a -> a)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall u. (forall d. Data d => d -> u) -> a -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> Data a
forall u. Int -> (forall d. Data d => d -> u) -> ExpVal -> u
forall u. (forall d. Data d => d -> u) -> ExpVal -> [u]
forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> ExpVal -> r
forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> ExpVal -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> ExpVal -> m ExpVal
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> ExpVal -> m ExpVal
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c ExpVal
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> ExpVal -> c ExpVal
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c ExpVal)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c ExpVal)
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> ExpVal -> m ExpVal
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> ExpVal -> m ExpVal
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> ExpVal -> m ExpVal
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> ExpVal -> m ExpVal
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> ExpVal -> m ExpVal
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> ExpVal -> m ExpVal
gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> ExpVal -> u
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> ExpVal -> u
gmapQ :: forall u. (forall d. Data d => d -> u) -> ExpVal -> [u]
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> ExpVal -> [u]
gmapQr :: forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> ExpVal -> r
$cgmapQr :: forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> ExpVal -> r
gmapQl :: forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> ExpVal -> r
$cgmapQl :: forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> ExpVal -> r
gmapT :: (forall b. Data b => b -> b) -> ExpVal -> ExpVal
$cgmapT :: (forall b. Data b => b -> b) -> ExpVal -> ExpVal
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c ExpVal)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c ExpVal)
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c ExpVal)
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c ExpVal)
dataTypeOf :: ExpVal -> DataType
$cdataTypeOf :: ExpVal -> DataType
toConstr :: ExpVal -> Constr
$ctoConstr :: ExpVal -> Constr
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c ExpVal
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c ExpVal
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> ExpVal -> c ExpVal
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> ExpVal -> c ExpVal
Data, Typeable, (forall x. ExpVal -> Rep ExpVal x)
-> (forall x. Rep ExpVal x -> ExpVal) -> Generic ExpVal
forall x. Rep ExpVal x -> ExpVal
forall x. ExpVal -> Rep ExpVal x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep ExpVal x -> ExpVal
$cfrom :: forall x. ExpVal -> Rep ExpVal x
Generic, ExpVal -> ()
(ExpVal -> ()) -> NFData ExpVal
forall a. (a -> ()) -> NFData a
rnf :: ExpVal -> ()
$crnf :: ExpVal -> ()
NFData)

-- instance FromJSON AST.Conforming
-- instance ToJSON AST.Conforming
instance FromJSON ExpVal
instance ToJSON ExpVal

-- | Memory offset given to a variable in memory
type Offset = Int

-- | The name of block of memory
type MemoryBlockName = Name

-- | The location of a variable, i.e. the 'MemoryBlockName' that
-- contains it as well as the 'Offset' to its location in memory
type Location = (MemoryBlockName, Offset)

-- | The declared lifetimes of the variables in memory
data StorageClass
  = Static
  | Automatic
  | Constant
  | Common
  | Unspecified
  deriving (StorageClass -> StorageClass -> Bool
(StorageClass -> StorageClass -> Bool)
-> (StorageClass -> StorageClass -> Bool) -> Eq StorageClass
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: StorageClass -> StorageClass -> Bool
$c/= :: StorageClass -> StorageClass -> Bool
== :: StorageClass -> StorageClass -> Bool
$c== :: StorageClass -> StorageClass -> Bool
Eq, Eq StorageClass
Eq StorageClass
-> (StorageClass -> StorageClass -> Ordering)
-> (StorageClass -> StorageClass -> Bool)
-> (StorageClass -> StorageClass -> Bool)
-> (StorageClass -> StorageClass -> Bool)
-> (StorageClass -> StorageClass -> Bool)
-> (StorageClass -> StorageClass -> StorageClass)
-> (StorageClass -> StorageClass -> StorageClass)
-> Ord StorageClass
StorageClass -> StorageClass -> Bool
StorageClass -> StorageClass -> Ordering
StorageClass -> StorageClass -> StorageClass
forall a.
Eq a
-> (a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
min :: StorageClass -> StorageClass -> StorageClass
$cmin :: StorageClass -> StorageClass -> StorageClass
max :: StorageClass -> StorageClass -> StorageClass
$cmax :: StorageClass -> StorageClass -> StorageClass
>= :: StorageClass -> StorageClass -> Bool
$c>= :: StorageClass -> StorageClass -> Bool
> :: StorageClass -> StorageClass -> Bool
$c> :: StorageClass -> StorageClass -> Bool
<= :: StorageClass -> StorageClass -> Bool
$c<= :: StorageClass -> StorageClass -> Bool
< :: StorageClass -> StorageClass -> Bool
$c< :: StorageClass -> StorageClass -> Bool
compare :: StorageClass -> StorageClass -> Ordering
$ccompare :: StorageClass -> StorageClass -> Ordering
Ord, Int -> StorageClass -> ShowS
[StorageClass] -> ShowS
StorageClass -> String
(Int -> StorageClass -> ShowS)
-> (StorageClass -> String)
-> ([StorageClass] -> ShowS)
-> Show StorageClass
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [StorageClass] -> ShowS
$cshowList :: [StorageClass] -> ShowS
show :: StorageClass -> String
$cshow :: StorageClass -> String
showsPrec :: Int -> StorageClass -> ShowS
$cshowsPrec :: Int -> StorageClass -> ShowS
Show, Typeable StorageClass
Typeable StorageClass
-> (forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> StorageClass -> c StorageClass)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c StorageClass)
-> (StorageClass -> Constr)
-> (StorageClass -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c StorageClass))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c StorageClass))
-> ((forall b. Data b => b -> b) -> StorageClass -> StorageClass)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> StorageClass -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> StorageClass -> r)
-> (forall u. (forall d. Data d => d -> u) -> StorageClass -> [u])
-> (forall u.
    Int -> (forall d. Data d => d -> u) -> StorageClass -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> StorageClass -> m StorageClass)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> StorageClass -> m StorageClass)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> StorageClass -> m StorageClass)
-> Data StorageClass
StorageClass -> DataType
StorageClass -> Constr
(forall b. Data b => b -> b) -> StorageClass -> StorageClass
forall a.
Typeable a
-> (forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> a -> c a)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c a)
-> (a -> Constr)
-> (a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c a))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
-> ((forall b. Data b => b -> b) -> a -> a)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall u. (forall d. Data d => d -> u) -> a -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> Data a
forall u. Int -> (forall d. Data d => d -> u) -> StorageClass -> u
forall u. (forall d. Data d => d -> u) -> StorageClass -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> StorageClass -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> StorageClass -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> StorageClass -> m StorageClass
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> StorageClass -> m StorageClass
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c StorageClass
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> StorageClass -> c StorageClass
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c StorageClass)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c StorageClass)
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> StorageClass -> m StorageClass
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> StorageClass -> m StorageClass
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> StorageClass -> m StorageClass
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> StorageClass -> m StorageClass
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> StorageClass -> m StorageClass
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> StorageClass -> m StorageClass
gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> StorageClass -> u
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> StorageClass -> u
gmapQ :: forall u. (forall d. Data d => d -> u) -> StorageClass -> [u]
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> StorageClass -> [u]
gmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> StorageClass -> r
$cgmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> StorageClass -> r
gmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> StorageClass -> r
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> StorageClass -> r
gmapT :: (forall b. Data b => b -> b) -> StorageClass -> StorageClass
$cgmapT :: (forall b. Data b => b -> b) -> StorageClass -> StorageClass
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c StorageClass)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c StorageClass)
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c StorageClass)
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c StorageClass)
dataTypeOf :: StorageClass -> DataType
$cdataTypeOf :: StorageClass -> DataType
toConstr :: StorageClass -> Constr
$ctoConstr :: StorageClass -> Constr
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c StorageClass
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c StorageClass
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> StorageClass -> c StorageClass
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> StorageClass -> c StorageClass
Data, Typeable, (forall x. StorageClass -> Rep StorageClass x)
-> (forall x. Rep StorageClass x -> StorageClass)
-> Generic StorageClass
forall x. Rep StorageClass x -> StorageClass
forall x. StorageClass -> Rep StorageClass x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep StorageClass x -> StorageClass
$cfrom :: forall x. StorageClass -> Rep StorageClass x
Generic)

instance FromJSON StorageClass
instance ToJSON StorageClass

-- | The declared dimensions of a staticically typed array variable
-- type is of the form [(dim1_lower, dim1_upper), (dim2_lower, dim2_upper)]
type Dimensions = [(Int, Int)]

-- | An entry in the 'SymbolTable' for some variable
data SymbolTableEntry
  = SParameter { SymbolTableEntry -> Type
parType :: Type , SymbolTableEntry -> ExpVal
parVal :: ExpVal }
  | SVariable { SymbolTableEntry -> Type
varType :: Type , SymbolTableEntry -> Location
varLoc :: Location }
  | SDummy { SymbolTableEntry -> Type
dumType :: Type }
  | SExternal {SymbolTableEntry -> Type
extType :: Type }
  deriving (SymbolTableEntry -> SymbolTableEntry -> Bool
(SymbolTableEntry -> SymbolTableEntry -> Bool)
-> (SymbolTableEntry -> SymbolTableEntry -> Bool)
-> Eq SymbolTableEntry
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: SymbolTableEntry -> SymbolTableEntry -> Bool
$c/= :: SymbolTableEntry -> SymbolTableEntry -> Bool
== :: SymbolTableEntry -> SymbolTableEntry -> Bool
$c== :: SymbolTableEntry -> SymbolTableEntry -> Bool
Eq, Eq SymbolTableEntry
Eq SymbolTableEntry
-> (SymbolTableEntry -> SymbolTableEntry -> Ordering)
-> (SymbolTableEntry -> SymbolTableEntry -> Bool)
-> (SymbolTableEntry -> SymbolTableEntry -> Bool)
-> (SymbolTableEntry -> SymbolTableEntry -> Bool)
-> (SymbolTableEntry -> SymbolTableEntry -> Bool)
-> (SymbolTableEntry -> SymbolTableEntry -> SymbolTableEntry)
-> (SymbolTableEntry -> SymbolTableEntry -> SymbolTableEntry)
-> Ord SymbolTableEntry
SymbolTableEntry -> SymbolTableEntry -> Bool
SymbolTableEntry -> SymbolTableEntry -> Ordering
SymbolTableEntry -> SymbolTableEntry -> SymbolTableEntry
forall a.
Eq a
-> (a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
min :: SymbolTableEntry -> SymbolTableEntry -> SymbolTableEntry
$cmin :: SymbolTableEntry -> SymbolTableEntry -> SymbolTableEntry
max :: SymbolTableEntry -> SymbolTableEntry -> SymbolTableEntry
$cmax :: SymbolTableEntry -> SymbolTableEntry -> SymbolTableEntry
>= :: SymbolTableEntry -> SymbolTableEntry -> Bool
$c>= :: SymbolTableEntry -> SymbolTableEntry -> Bool
> :: SymbolTableEntry -> SymbolTableEntry -> Bool
$c> :: SymbolTableEntry -> SymbolTableEntry -> Bool
<= :: SymbolTableEntry -> SymbolTableEntry -> Bool
$c<= :: SymbolTableEntry -> SymbolTableEntry -> Bool
< :: SymbolTableEntry -> SymbolTableEntry -> Bool
$c< :: SymbolTableEntry -> SymbolTableEntry -> Bool
compare :: SymbolTableEntry -> SymbolTableEntry -> Ordering
$ccompare :: SymbolTableEntry -> SymbolTableEntry -> Ordering
Ord, Int -> SymbolTableEntry -> ShowS
[SymbolTableEntry] -> ShowS
SymbolTableEntry -> String
(Int -> SymbolTableEntry -> ShowS)
-> (SymbolTableEntry -> String)
-> ([SymbolTableEntry] -> ShowS)
-> Show SymbolTableEntry
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [SymbolTableEntry] -> ShowS
$cshowList :: [SymbolTableEntry] -> ShowS
show :: SymbolTableEntry -> String
$cshow :: SymbolTableEntry -> String
showsPrec :: Int -> SymbolTableEntry -> ShowS
$cshowsPrec :: Int -> SymbolTableEntry -> ShowS
Show, Typeable SymbolTableEntry
Typeable SymbolTableEntry
-> (forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> SymbolTableEntry -> c SymbolTableEntry)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c SymbolTableEntry)
-> (SymbolTableEntry -> Constr)
-> (SymbolTableEntry -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c SymbolTableEntry))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c SymbolTableEntry))
-> ((forall b. Data b => b -> b)
    -> SymbolTableEntry -> SymbolTableEntry)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> SymbolTableEntry -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> SymbolTableEntry -> r)
-> (forall u.
    (forall d. Data d => d -> u) -> SymbolTableEntry -> [u])
-> (forall u.
    Int -> (forall d. Data d => d -> u) -> SymbolTableEntry -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d)
    -> SymbolTableEntry -> m SymbolTableEntry)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d)
    -> SymbolTableEntry -> m SymbolTableEntry)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d)
    -> SymbolTableEntry -> m SymbolTableEntry)
-> Data SymbolTableEntry
SymbolTableEntry -> DataType
SymbolTableEntry -> Constr
(forall b. Data b => b -> b)
-> SymbolTableEntry -> SymbolTableEntry
forall a.
Typeable a
-> (forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> a -> c a)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c a)
-> (a -> Constr)
-> (a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c a))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
-> ((forall b. Data b => b -> b) -> a -> a)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall u. (forall d. Data d => d -> u) -> a -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> Data a
forall u.
Int -> (forall d. Data d => d -> u) -> SymbolTableEntry -> u
forall u. (forall d. Data d => d -> u) -> SymbolTableEntry -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> SymbolTableEntry -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> SymbolTableEntry -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d)
-> SymbolTableEntry -> m SymbolTableEntry
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> SymbolTableEntry -> m SymbolTableEntry
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c SymbolTableEntry
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> SymbolTableEntry -> c SymbolTableEntry
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c SymbolTableEntry)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c SymbolTableEntry)
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> SymbolTableEntry -> m SymbolTableEntry
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> SymbolTableEntry -> m SymbolTableEntry
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> SymbolTableEntry -> m SymbolTableEntry
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> SymbolTableEntry -> m SymbolTableEntry
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d)
-> SymbolTableEntry -> m SymbolTableEntry
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d)
-> SymbolTableEntry -> m SymbolTableEntry
gmapQi :: forall u.
Int -> (forall d. Data d => d -> u) -> SymbolTableEntry -> u
$cgmapQi :: forall u.
Int -> (forall d. Data d => d -> u) -> SymbolTableEntry -> u
gmapQ :: forall u. (forall d. Data d => d -> u) -> SymbolTableEntry -> [u]
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> SymbolTableEntry -> [u]
gmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> SymbolTableEntry -> r
$cgmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> SymbolTableEntry -> r
gmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> SymbolTableEntry -> r
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> SymbolTableEntry -> r
gmapT :: (forall b. Data b => b -> b)
-> SymbolTableEntry -> SymbolTableEntry
$cgmapT :: (forall b. Data b => b -> b)
-> SymbolTableEntry -> SymbolTableEntry
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c SymbolTableEntry)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c SymbolTableEntry)
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c SymbolTableEntry)
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c SymbolTableEntry)
dataTypeOf :: SymbolTableEntry -> DataType
$cdataTypeOf :: SymbolTableEntry -> DataType
toConstr :: SymbolTableEntry -> Constr
$ctoConstr :: SymbolTableEntry -> Constr
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c SymbolTableEntry
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c SymbolTableEntry
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> SymbolTableEntry -> c SymbolTableEntry
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> SymbolTableEntry -> c SymbolTableEntry
Data, Typeable, (forall x. SymbolTableEntry -> Rep SymbolTableEntry x)
-> (forall x. Rep SymbolTableEntry x -> SymbolTableEntry)
-> Generic SymbolTableEntry
forall x. Rep SymbolTableEntry x -> SymbolTableEntry
forall x. SymbolTableEntry -> Rep SymbolTableEntry x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep SymbolTableEntry x -> SymbolTableEntry
$cfrom :: forall x. SymbolTableEntry -> Rep SymbolTableEntry x
Generic)

instance FromJSON SymbolTableEntry
instance ToJSON SymbolTableEntry

-- | Symbol table containing all non-intrisic symbols declared in a program
type SymbolTable = Map Name SymbolTableEntry

-- | Structure to hold information about the named blocks of memory
-- in the program
data MemoryBlock = MemoryBlock
  { MemoryBlock -> Maybe Int
blockSize    :: Maybe Int -- ^ Nothing for when block is dynamically sized
  , MemoryBlock -> StorageClass
storageClass :: StorageClass
  , MemoryBlock -> [String]
variables    :: [Name]
  } deriving (MemoryBlock -> MemoryBlock -> Bool
(MemoryBlock -> MemoryBlock -> Bool)
-> (MemoryBlock -> MemoryBlock -> Bool) -> Eq MemoryBlock
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: MemoryBlock -> MemoryBlock -> Bool
$c/= :: MemoryBlock -> MemoryBlock -> Bool
== :: MemoryBlock -> MemoryBlock -> Bool
$c== :: MemoryBlock -> MemoryBlock -> Bool
Eq, Eq MemoryBlock
Eq MemoryBlock
-> (MemoryBlock -> MemoryBlock -> Ordering)
-> (MemoryBlock -> MemoryBlock -> Bool)
-> (MemoryBlock -> MemoryBlock -> Bool)
-> (MemoryBlock -> MemoryBlock -> Bool)
-> (MemoryBlock -> MemoryBlock -> Bool)
-> (MemoryBlock -> MemoryBlock -> MemoryBlock)
-> (MemoryBlock -> MemoryBlock -> MemoryBlock)
-> Ord MemoryBlock
MemoryBlock -> MemoryBlock -> Bool
MemoryBlock -> MemoryBlock -> Ordering
MemoryBlock -> MemoryBlock -> MemoryBlock
forall a.
Eq a
-> (a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
min :: MemoryBlock -> MemoryBlock -> MemoryBlock
$cmin :: MemoryBlock -> MemoryBlock -> MemoryBlock
max :: MemoryBlock -> MemoryBlock -> MemoryBlock
$cmax :: MemoryBlock -> MemoryBlock -> MemoryBlock
>= :: MemoryBlock -> MemoryBlock -> Bool
$c>= :: MemoryBlock -> MemoryBlock -> Bool
> :: MemoryBlock -> MemoryBlock -> Bool
$c> :: MemoryBlock -> MemoryBlock -> Bool
<= :: MemoryBlock -> MemoryBlock -> Bool
$c<= :: MemoryBlock -> MemoryBlock -> Bool
< :: MemoryBlock -> MemoryBlock -> Bool
$c< :: MemoryBlock -> MemoryBlock -> Bool
compare :: MemoryBlock -> MemoryBlock -> Ordering
$ccompare :: MemoryBlock -> MemoryBlock -> Ordering
Ord, Int -> MemoryBlock -> ShowS
[MemoryBlock] -> ShowS
MemoryBlock -> String
(Int -> MemoryBlock -> ShowS)
-> (MemoryBlock -> String)
-> ([MemoryBlock] -> ShowS)
-> Show MemoryBlock
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [MemoryBlock] -> ShowS
$cshowList :: [MemoryBlock] -> ShowS
show :: MemoryBlock -> String
$cshow :: MemoryBlock -> String
showsPrec :: Int -> MemoryBlock -> ShowS
$cshowsPrec :: Int -> MemoryBlock -> ShowS
Show, Typeable MemoryBlock
Typeable MemoryBlock
-> (forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> MemoryBlock -> c MemoryBlock)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c MemoryBlock)
-> (MemoryBlock -> Constr)
-> (MemoryBlock -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c MemoryBlock))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c MemoryBlock))
-> ((forall b. Data b => b -> b) -> MemoryBlock -> MemoryBlock)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> MemoryBlock -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> MemoryBlock -> r)
-> (forall u. (forall d. Data d => d -> u) -> MemoryBlock -> [u])
-> (forall u.
    Int -> (forall d. Data d => d -> u) -> MemoryBlock -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> MemoryBlock -> m MemoryBlock)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> MemoryBlock -> m MemoryBlock)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> MemoryBlock -> m MemoryBlock)
-> Data MemoryBlock
MemoryBlock -> DataType
MemoryBlock -> Constr
(forall b. Data b => b -> b) -> MemoryBlock -> MemoryBlock
forall a.
Typeable a
-> (forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> a -> c a)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c a)
-> (a -> Constr)
-> (a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c a))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
-> ((forall b. Data b => b -> b) -> a -> a)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall u. (forall d. Data d => d -> u) -> a -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> Data a
forall u. Int -> (forall d. Data d => d -> u) -> MemoryBlock -> u
forall u. (forall d. Data d => d -> u) -> MemoryBlock -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> MemoryBlock -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> MemoryBlock -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> MemoryBlock -> m MemoryBlock
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> MemoryBlock -> m MemoryBlock
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c MemoryBlock
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> MemoryBlock -> c MemoryBlock
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c MemoryBlock)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c MemoryBlock)
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> MemoryBlock -> m MemoryBlock
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> MemoryBlock -> m MemoryBlock
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> MemoryBlock -> m MemoryBlock
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> MemoryBlock -> m MemoryBlock
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> MemoryBlock -> m MemoryBlock
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> MemoryBlock -> m MemoryBlock
gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> MemoryBlock -> u
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> MemoryBlock -> u
gmapQ :: forall u. (forall d. Data d => d -> u) -> MemoryBlock -> [u]
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> MemoryBlock -> [u]
gmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> MemoryBlock -> r
$cgmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> MemoryBlock -> r
gmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> MemoryBlock -> r
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> MemoryBlock -> r
gmapT :: (forall b. Data b => b -> b) -> MemoryBlock -> MemoryBlock
$cgmapT :: (forall b. Data b => b -> b) -> MemoryBlock -> MemoryBlock
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c MemoryBlock)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c MemoryBlock)
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c MemoryBlock)
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c MemoryBlock)
dataTypeOf :: MemoryBlock -> DataType
$cdataTypeOf :: MemoryBlock -> DataType
toConstr :: MemoryBlock -> Constr
$ctoConstr :: MemoryBlock -> Constr
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c MemoryBlock
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c MemoryBlock
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> MemoryBlock -> c MemoryBlock
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> MemoryBlock -> c MemoryBlock
Data, Typeable, (forall x. MemoryBlock -> Rep MemoryBlock x)
-> (forall x. Rep MemoryBlock x -> MemoryBlock)
-> Generic MemoryBlock
forall x. Rep MemoryBlock x -> MemoryBlock
forall x. MemoryBlock -> Rep MemoryBlock x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep MemoryBlock x -> MemoryBlock
$cfrom :: forall x. MemoryBlock -> Rep MemoryBlock x
Generic)

instance FromJSON MemoryBlock
instance ToJSON MemoryBlock

-- | Map from a structure name to its internal structure, specifying members
-- and their corresponding type. This can then be used to check the type of a
-- data reference expression.
type StructureTable = Map String Structure

-- List of structure fields forming a structure
type Structure = [StructureTableEntry]

-- | Data structurue for a single field of a structure
data StructureTableEntry
  = FieldEntry String Type
  | UnionEntry [Structure]
  deriving (StructureTableEntry -> StructureTableEntry -> Bool
(StructureTableEntry -> StructureTableEntry -> Bool)
-> (StructureTableEntry -> StructureTableEntry -> Bool)
-> Eq StructureTableEntry
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: StructureTableEntry -> StructureTableEntry -> Bool
$c/= :: StructureTableEntry -> StructureTableEntry -> Bool
== :: StructureTableEntry -> StructureTableEntry -> Bool
$c== :: StructureTableEntry -> StructureTableEntry -> Bool
Eq, Int -> StructureTableEntry -> ShowS
Structure -> ShowS
StructureTableEntry -> String
(Int -> StructureTableEntry -> ShowS)
-> (StructureTableEntry -> String)
-> (Structure -> ShowS)
-> Show StructureTableEntry
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: Structure -> ShowS
$cshowList :: Structure -> ShowS
show :: StructureTableEntry -> String
$cshow :: StructureTableEntry -> String
showsPrec :: Int -> StructureTableEntry -> ShowS
$cshowsPrec :: Int -> StructureTableEntry -> ShowS
Show, Typeable StructureTableEntry
Typeable StructureTableEntry
-> (forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g)
    -> StructureTableEntry
    -> c StructureTableEntry)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c StructureTableEntry)
-> (StructureTableEntry -> Constr)
-> (StructureTableEntry -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c StructureTableEntry))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c StructureTableEntry))
-> ((forall b. Data b => b -> b)
    -> StructureTableEntry -> StructureTableEntry)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> StructureTableEntry -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> StructureTableEntry -> r)
-> (forall u.
    (forall d. Data d => d -> u) -> StructureTableEntry -> [u])
-> (forall u.
    Int -> (forall d. Data d => d -> u) -> StructureTableEntry -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d)
    -> StructureTableEntry -> m StructureTableEntry)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d)
    -> StructureTableEntry -> m StructureTableEntry)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d)
    -> StructureTableEntry -> m StructureTableEntry)
-> Data StructureTableEntry
StructureTableEntry -> DataType
StructureTableEntry -> Constr
(forall b. Data b => b -> b)
-> StructureTableEntry -> StructureTableEntry
forall a.
Typeable a
-> (forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> a -> c a)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c a)
-> (a -> Constr)
-> (a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c a))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
-> ((forall b. Data b => b -> b) -> a -> a)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall u. (forall d. Data d => d -> u) -> a -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> Data a
forall u.
Int -> (forall d. Data d => d -> u) -> StructureTableEntry -> u
forall u.
(forall d. Data d => d -> u) -> StructureTableEntry -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> StructureTableEntry -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> StructureTableEntry -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d)
-> StructureTableEntry -> m StructureTableEntry
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> StructureTableEntry -> m StructureTableEntry
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c StructureTableEntry
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g)
-> StructureTableEntry
-> c StructureTableEntry
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c StructureTableEntry)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c StructureTableEntry)
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> StructureTableEntry -> m StructureTableEntry
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> StructureTableEntry -> m StructureTableEntry
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> StructureTableEntry -> m StructureTableEntry
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> StructureTableEntry -> m StructureTableEntry
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d)
-> StructureTableEntry -> m StructureTableEntry
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d)
-> StructureTableEntry -> m StructureTableEntry
gmapQi :: forall u.
Int -> (forall d. Data d => d -> u) -> StructureTableEntry -> u
$cgmapQi :: forall u.
Int -> (forall d. Data d => d -> u) -> StructureTableEntry -> u
gmapQ :: forall u.
(forall d. Data d => d -> u) -> StructureTableEntry -> [u]
$cgmapQ :: forall u.
(forall d. Data d => d -> u) -> StructureTableEntry -> [u]
gmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> StructureTableEntry -> r
$cgmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> StructureTableEntry -> r
gmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> StructureTableEntry -> r
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> StructureTableEntry -> r
gmapT :: (forall b. Data b => b -> b)
-> StructureTableEntry -> StructureTableEntry
$cgmapT :: (forall b. Data b => b -> b)
-> StructureTableEntry -> StructureTableEntry
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c StructureTableEntry)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c StructureTableEntry)
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c StructureTableEntry)
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c StructureTableEntry)
dataTypeOf :: StructureTableEntry -> DataType
$cdataTypeOf :: StructureTableEntry -> DataType
toConstr :: StructureTableEntry -> Constr
$ctoConstr :: StructureTableEntry -> Constr
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c StructureTableEntry
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c StructureTableEntry
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g)
-> StructureTableEntry
-> c StructureTableEntry
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g)
-> StructureTableEntry
-> c StructureTableEntry
Data)

-- | Mapping from the name of a memory block to the information about it
type StorageTable = Map MemoryBlockName MemoryBlock

-- | The model to represent an individual 'Language.Fortran.AST.ProgramUnit'
type ProgramUnitModel = (SymbolTable, StorageTable)

-- | Mapping from the name of a 'Language.Fortran.AST.ProgramUnit' to
-- its 'ProgramUnitModel'
type ProgramFileModel = Map ProgramUnitName ProgramUnitModel

-- | Mapping from name of a program unit to relevant structure table
type ProgramStructureTables = Map ProgramUnitName StructureTable

-- move these to common
instance ToJSON ProgramUnitName
instance ToJSONKey ProgramUnitName
instance FromJSON ProgramUnitName
instance FromJSONKey ProgramUnitName

data TypeError
  = TypeError FilePath SrcSpan String
  | UnknownType SrcSpan
  | UnboundVariable Name
  | UnknownField String
  deriving (TypeError -> TypeError -> Bool
(TypeError -> TypeError -> Bool)
-> (TypeError -> TypeError -> Bool) -> Eq TypeError
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: TypeError -> TypeError -> Bool
$c/= :: TypeError -> TypeError -> Bool
== :: TypeError -> TypeError -> Bool
$c== :: TypeError -> TypeError -> Bool
Eq, Eq TypeError
Eq TypeError
-> (TypeError -> TypeError -> Ordering)
-> (TypeError -> TypeError -> Bool)
-> (TypeError -> TypeError -> Bool)
-> (TypeError -> TypeError -> Bool)
-> (TypeError -> TypeError -> Bool)
-> (TypeError -> TypeError -> TypeError)
-> (TypeError -> TypeError -> TypeError)
-> Ord TypeError
TypeError -> TypeError -> Bool
TypeError -> TypeError -> Ordering
TypeError -> TypeError -> TypeError
forall a.
Eq a
-> (a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
min :: TypeError -> TypeError -> TypeError
$cmin :: TypeError -> TypeError -> TypeError
max :: TypeError -> TypeError -> TypeError
$cmax :: TypeError -> TypeError -> TypeError
>= :: TypeError -> TypeError -> Bool
$c>= :: TypeError -> TypeError -> Bool
> :: TypeError -> TypeError -> Bool
$c> :: TypeError -> TypeError -> Bool
<= :: TypeError -> TypeError -> Bool
$c<= :: TypeError -> TypeError -> Bool
< :: TypeError -> TypeError -> Bool
$c< :: TypeError -> TypeError -> Bool
compare :: TypeError -> TypeError -> Ordering
$ccompare :: TypeError -> TypeError -> Ordering
Ord, Int -> TypeError -> ShowS
[TypeError] -> ShowS
TypeError -> String
(Int -> TypeError -> ShowS)
-> (TypeError -> String)
-> ([TypeError] -> ShowS)
-> Show TypeError
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [TypeError] -> ShowS
$cshowList :: [TypeError] -> ShowS
show :: TypeError -> String
$cshow :: TypeError -> String
showsPrec :: Int -> TypeError -> ShowS
$cshowsPrec :: Int -> TypeError -> ShowS
Show, (forall x. TypeError -> Rep TypeError x)
-> (forall x. Rep TypeError x -> TypeError) -> Generic TypeError
forall x. Rep TypeError x -> TypeError
forall x. TypeError -> Rep TypeError x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep TypeError x -> TypeError
$cfrom :: forall x. TypeError -> Rep TypeError x
Generic)

-- | Helper method for getting the FilePath out of SrcSpan
typeError :: SrcSpan -> String -> TypeError
typeError :: SrcSpan -> String -> TypeError
typeError SrcSpan
sp = let SrcSpan Position
p Position
_ = SrcSpan
sp in String -> SrcSpan -> String -> TypeError
TypeError (Position -> String
posFilePath Position
p) SrcSpan
sp

instance ToJSON TypeError
instance FromJSON TypeError

type TypeOf a = Expression a -> Either TypeError Type