module GBMonad (
TransFun, transTabToTransFun,
HsObject(..), GB, HsPtrRep, initialGBState, setContext, getLibrary,
getPrefix, getLock, delayCode, getDelayedCode, ptrMapsTo, queryPtr, objIs,
queryObj, queryClass, queryPointer, mergeMaps, dumpMaps
) where
import Data.Char (toUpper, toLower, isSpace)
import Data.List (find)
import Data.Maybe (fromMaybe)
import Position (Position, Pos(posOf), nopos, builtinPos)
import Errors (interr)
import Idents (Ident, identToLexeme, onlyPosIdent)
import Map (Map)
import qualified Map as Map (empty, insert, lookup, fromList, toList, union)
import C (CT, readCT, transCT, raiseErrorCTExc)
import CHS (CHSModule(..), CHSFrag(..), CHSHook(..), CHSTrans(..),
CHSAccess(..), CHSAPath(..), CHSPtrType(..))
type TransFun = Ident -> String
underscoreToCase :: TransFun
underscoreToCase :: TransFun
underscoreToCase Ident
ide = let lexeme :: [Char]
lexeme = TransFun
identToLexeme Ident
ide
ps :: [[Char]]
ps = ([Char] -> Bool) -> [[Char]] -> [[Char]]
forall a. (a -> Bool) -> [a] -> [a]
filter (Bool -> Bool
not (Bool -> Bool) -> ([Char] -> Bool) -> [Char] -> Bool
forall b c a. (b -> c) -> (a -> b) -> a -> c
. [Char] -> Bool
forall a. [a] -> Bool
forall (t :: * -> *) a. Foldable t => t a -> Bool
null) ([[Char]] -> [[Char]])
-> ([Char] -> [[Char]]) -> [Char] -> [[Char]]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. [Char] -> [[Char]]
parts ([Char] -> [[Char]]) -> [Char] -> [[Char]]
forall a b. (a -> b) -> a -> b
$ [Char]
lexeme
in
[[Char]] -> [Char]
forall (t :: * -> *) a. Foldable t => t [a] -> [a]
concat ([[Char]] -> [Char])
-> ([[Char]] -> [[Char]]) -> [[Char]] -> [Char]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. ([Char] -> [Char]) -> [[Char]] -> [[Char]]
forall a b. (a -> b) -> [a] -> [b]
map [Char] -> [Char]
adjustCase ([[Char]] -> [Char]) -> [[Char]] -> [Char]
forall a b. (a -> b) -> a -> b
$ [[Char]]
ps
where
parts :: [Char] -> [[Char]]
parts [Char]
s = let ([Char]
l, [Char]
s') = (Char -> Bool) -> [Char] -> ([Char], [Char])
forall a. (a -> Bool) -> [a] -> ([a], [a])
break (Char -> Char -> Bool
forall a. Eq a => a -> a -> Bool
== Char
'_') [Char]
s
in
[Char]
l [Char] -> [[Char]] -> [[Char]]
forall a. a -> [a] -> [a]
: case [Char]
s' of
[] -> []
(Char
_:[Char]
s'') -> [Char] -> [[Char]]
parts [Char]
s''
adjustCase :: [Char] -> [Char]
adjustCase (Char
c:[Char]
cs) = Char -> Char
toUpper Char
c Char -> [Char] -> [Char]
forall a. a -> [a] -> [a]
: (Char -> Char) -> [Char] -> [Char]
forall a b. (a -> b) -> [a] -> [b]
map Char -> Char
toLower [Char]
cs
transTabToTransFun :: String -> CHSTrans -> TransFun
transTabToTransFun :: [Char] -> CHSTrans -> TransFun
transTabToTransFun [Char]
prefix (CHSTrans Bool
_2Case [(Ident, Ident)]
table) =
\Ident
ide -> let
lexeme :: [Char]
lexeme = TransFun
identToLexeme Ident
ide
dft :: [Char]
dft = if Bool
_2Case
then TransFun
underscoreToCase Ident
ide
else [Char]
lexeme
in
case Ident -> [(Ident, Ident)] -> Maybe Ident
forall a b. Eq a => a -> [(a, b)] -> Maybe b
lookup Ident
ide [(Ident, Ident)]
table of
Just Ident
ide' -> TransFun
identToLexeme Ident
ide'
Maybe Ident
Nothing ->
case [Char] -> [Char] -> Maybe [Char]
eat [Char]
prefix [Char]
lexeme of
Maybe [Char]
Nothing -> [Char]
dft
Just [Char]
eatenLexeme ->
let
eatenIde :: Ident
eatenIde = Position -> [Char] -> Ident
onlyPosIdent (Ident -> Position
forall a. Pos a => a -> Position
posOf Ident
ide) [Char]
eatenLexeme
eatenDft :: [Char]
eatenDft = if Bool
_2Case
then TransFun
underscoreToCase Ident
eatenIde
else [Char]
eatenLexeme
in
case Ident -> [(Ident, Ident)] -> Maybe Ident
forall a b. Eq a => a -> [(a, b)] -> Maybe b
lookup Ident
eatenIde [(Ident, Ident)]
table of
Maybe Ident
Nothing -> [Char]
eatenDft
Just Ident
ide' -> TransFun
identToLexeme Ident
ide'
where
eat :: [Char] -> [Char] -> Maybe [Char]
eat [] (Char
'_':[Char]
cs) = [Char] -> [Char] -> Maybe [Char]
eat [] [Char]
cs
eat [] [Char]
cs = [Char] -> Maybe [Char]
forall a. a -> Maybe a
Just [Char]
cs
eat (Char
p:[Char]
prefix) (Char
c:[Char]
cs) | Char -> Char
toUpper Char
p Char -> Char -> Bool
forall a. Eq a => a -> a -> Bool
== Char -> Char
toUpper Char
c = [Char] -> [Char] -> Maybe [Char]
eat [Char]
prefix [Char]
cs
| Bool
otherwise = Maybe [Char]
forall a. Maybe a
Nothing
eat [Char]
_ [Char]
_ = Maybe [Char]
forall a. Maybe a
Nothing
type PointerMap = Map (Bool, Ident) HsPtrRep
type HsPtrRep = (Bool, CHSPtrType, Maybe String, String)
data HsObject = Pointer {
HsObject -> CHSPtrType
ptrTypeHO :: CHSPtrType,
HsObject -> Bool
isNewtypeHO :: Bool
}
| Class {
HsObject -> Maybe Ident
superclassHO :: (Maybe Ident),
HsObject -> Ident
ptrHO :: Ident
}
deriving (Int -> HsObject -> [Char] -> [Char]
[HsObject] -> [Char] -> [Char]
HsObject -> [Char]
(Int -> HsObject -> [Char] -> [Char])
-> (HsObject -> [Char])
-> ([HsObject] -> [Char] -> [Char])
-> Show HsObject
forall a.
(Int -> a -> [Char] -> [Char])
-> (a -> [Char]) -> ([a] -> [Char] -> [Char]) -> Show a
$cshowsPrec :: Int -> HsObject -> [Char] -> [Char]
showsPrec :: Int -> HsObject -> [Char] -> [Char]
$cshow :: HsObject -> [Char]
show :: HsObject -> [Char]
$cshowList :: [HsObject] -> [Char] -> [Char]
showList :: [HsObject] -> [Char] -> [Char]
Show, ReadPrec [HsObject]
ReadPrec HsObject
Int -> ReadS HsObject
ReadS [HsObject]
(Int -> ReadS HsObject)
-> ReadS [HsObject]
-> ReadPrec HsObject
-> ReadPrec [HsObject]
-> Read HsObject
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS HsObject
readsPrec :: Int -> ReadS HsObject
$creadList :: ReadS [HsObject]
readList :: ReadS [HsObject]
$creadPrec :: ReadPrec HsObject
readPrec :: ReadPrec HsObject
$creadListPrec :: ReadPrec [HsObject]
readListPrec :: ReadPrec [HsObject]
Read)
type HsObjectMap = Map Ident HsObject
instance Read Ident where
readsPrec :: Int -> ReadS Ident
readsPrec Int
_ (Char
'`':[Char]
lexeme) = let ([Char]
ideChars, [Char]
rest) = (Char -> Bool) -> [Char] -> ([Char], [Char])
forall a. (a -> Bool) -> [a] -> ([a], [a])
span (Char -> Char -> Bool
forall a. Eq a => a -> a -> Bool
/= Char
'\'') [Char]
lexeme
in
if [Char] -> Bool
forall a. [a] -> Bool
forall (t :: * -> *) a. Foldable t => t a -> Bool
null [Char]
ideChars
then []
else [(Position -> [Char] -> Ident
onlyPosIdent Position
nopos [Char]
ideChars, [Char] -> [Char]
forall a. HasCallStack => [a] -> [a]
tail [Char]
rest)]
readsPrec Int
p (Char
c:[Char]
cs)
| Char -> Bool
isSpace Char
c = Int -> ReadS Ident
forall a. Read a => Int -> ReadS a
readsPrec Int
p [Char]
cs
readsPrec Int
_ [Char]
_ = []
data GBState = GBState {
GBState -> [Char]
lib :: String,
GBState -> [Char]
prefix :: String,
GBState -> Maybe [Char]
mLock :: Maybe String,
GBState -> [(CHSHook, CHSFrag)]
frags :: [(CHSHook, CHSFrag)],
GBState -> PointerMap
ptrmap :: PointerMap,
GBState -> HsObjectMap
objmap :: HsObjectMap
}
type GB a = CT GBState a
initialGBState :: Maybe String -> GBState
initialGBState :: Maybe [Char] -> GBState
initialGBState Maybe [Char]
mLock = GBState {
lib :: [Char]
lib = [Char]
"",
prefix :: [Char]
prefix = [Char]
"",
mLock :: Maybe [Char]
mLock = Maybe [Char]
mLock,
frags :: [(CHSHook, CHSFrag)]
frags = [],
ptrmap :: PointerMap
ptrmap = PointerMap
forall k a. Map k a
Map.empty,
objmap :: HsObjectMap
objmap = HsObjectMap
forall k a. Map k a
Map.empty
}
setContext :: (Maybe String) -> (Maybe String) -> (Maybe String) ->
GB ()
setContext :: Maybe [Char] -> Maybe [Char] -> Maybe [Char] -> GB ()
setContext Maybe [Char]
lib Maybe [Char]
prefix Maybe [Char]
newMLock =
(GBState -> (GBState, ())) -> GB ()
forall s a. (s -> (s, a)) -> CT s a
transCT ((GBState -> (GBState, ())) -> GB ())
-> (GBState -> (GBState, ())) -> GB ()
forall a b. (a -> b) -> a -> b
$ \GBState
state -> (GBState
state {lib = fromMaybe "" lib,
prefix = fromMaybe "" prefix,
mLock = case newMLock of
Maybe [Char]
Nothing -> GBState -> Maybe [Char]
mLock GBState
state
Just [Char]
_ -> Maybe [Char]
newMLock },
())
getLibrary :: GB String
getLibrary :: GB [Char]
getLibrary = (GBState -> [Char]) -> GB [Char]
forall s a. (s -> a) -> CT s a
readCT GBState -> [Char]
lib
getPrefix :: GB String
getPrefix :: GB [Char]
getPrefix = (GBState -> [Char]) -> GB [Char]
forall s a. (s -> a) -> CT s a
readCT GBState -> [Char]
prefix
getLock :: GB (Maybe String)
getLock :: GB (Maybe [Char])
getLock = (GBState -> Maybe [Char]) -> GB (Maybe [Char])
forall s a. (s -> a) -> CT s a
readCT GBState -> Maybe [Char]
mLock
delayCode :: CHSHook -> String -> GB ()
delayCode :: CHSHook -> [Char] -> GB ()
delayCode CHSHook
hook [Char]
str =
do
frags <- (GBState -> [(CHSHook, CHSFrag)])
-> CT GBState [(CHSHook, CHSFrag)]
forall s a. (s -> a) -> CT s a
readCT GBState -> [(CHSHook, CHSFrag)]
frags
frags' <- delay hook frags
transCT (\GBState
state -> (GBState
state {frags = frags'}, ()))
where
newEntry :: (CHSHook, CHSFrag)
newEntry = (CHSHook
hook, ([Char] -> Position -> CHSFrag
CHSVerb ([Char]
"\n" [Char] -> [Char] -> [Char]
forall a. [a] -> [a] -> [a]
++ [Char]
str) (CHSHook -> Position
forall a. Pos a => a -> Position
posOf CHSHook
hook)))
delay :: CHSHook -> [(CHSHook, CHSFrag)] -> CT GBState [(CHSHook, CHSFrag)]
delay hook :: CHSHook
hook@(CHSCall Bool
isFun Bool
isUns Bool
_ Ident
ide Maybe Ident
oalias Position
_) [(CHSHook, CHSFrag)]
frags =
case ((CHSHook, CHSFrag) -> Bool)
-> [(CHSHook, CHSFrag)] -> Maybe (CHSHook, CHSFrag)
forall (t :: * -> *) a. Foldable t => (a -> Bool) -> t a -> Maybe a
find (\(CHSHook
hook', CHSFrag
_) -> CHSHook
hook' CHSHook -> CHSHook -> Bool
forall a. Eq a => a -> a -> Bool
== CHSHook
hook) [(CHSHook, CHSFrag)]
frags of
Just (CHSCall Bool
isFun' Bool
isUns' Bool
_ Ident
ide' Maybe Ident
_ Position
_, CHSFrag
_)
| Bool
isFun Bool -> Bool -> Bool
forall a. Eq a => a -> a -> Bool
== Bool
isFun'
Bool -> Bool -> Bool
&& Bool
isUns Bool -> Bool -> Bool
forall a. Eq a => a -> a -> Bool
== Bool
isUns'
Bool -> Bool -> Bool
&& Ident
ide Ident -> Ident -> Bool
forall a. Eq a => a -> a -> Bool
== Ident
ide' -> [(CHSHook, CHSFrag)] -> CT GBState [(CHSHook, CHSFrag)]
forall a. a -> PreCST SwitchBoard (CState GBState) a
forall (m :: * -> *) a. Monad m => a -> m a
return [(CHSHook, CHSFrag)]
frags
| Bool
otherwise -> Position -> Position -> CT GBState [(CHSHook, CHSFrag)]
forall {a}. Position -> Position -> GB a
err (Ident -> Position
forall a. Pos a => a -> Position
posOf Ident
ide) (Ident -> Position
forall a. Pos a => a -> Position
posOf Ident
ide')
Maybe (CHSHook, CHSFrag)
Nothing -> [(CHSHook, CHSFrag)] -> CT GBState [(CHSHook, CHSFrag)]
forall a. a -> PreCST SwitchBoard (CState GBState) a
forall (m :: * -> *) a. Monad m => a -> m a
return ([(CHSHook, CHSFrag)] -> CT GBState [(CHSHook, CHSFrag)])
-> [(CHSHook, CHSFrag)] -> CT GBState [(CHSHook, CHSFrag)]
forall a b. (a -> b) -> a -> b
$ [(CHSHook, CHSFrag)]
frags [(CHSHook, CHSFrag)]
-> [(CHSHook, CHSFrag)] -> [(CHSHook, CHSFrag)]
forall a. [a] -> [a] -> [a]
++ [(CHSHook, CHSFrag)
newEntry]
delay CHSHook
_ [(CHSHook, CHSFrag)]
_ =
[Char] -> CT GBState [(CHSHook, CHSFrag)]
forall a. [Char] -> a
interr [Char]
"GBMonad.delayCode: Illegal delay!"
err :: Position -> Position -> GB a
err = Position -> Position -> GB a
forall {a}. Position -> Position -> GB a
incompatibleCallHooksErr
getDelayedCode :: GB [CHSFrag]
getDelayedCode :: GB [CHSFrag]
getDelayedCode = (GBState -> [CHSFrag]) -> GB [CHSFrag]
forall s a. (s -> a) -> CT s a
readCT (((CHSHook, CHSFrag) -> CHSFrag)
-> [(CHSHook, CHSFrag)] -> [CHSFrag]
forall a b. (a -> b) -> [a] -> [b]
map (CHSHook, CHSFrag) -> CHSFrag
forall a b. (a, b) -> b
snd ([(CHSHook, CHSFrag)] -> [CHSFrag])
-> (GBState -> [(CHSHook, CHSFrag)]) -> GBState -> [CHSFrag]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. GBState -> [(CHSHook, CHSFrag)]
frags)
ptrMapsTo :: (Bool, Ident) -> HsPtrRep -> GB ()
(Bool
isStar, Ident
cName) ptrMapsTo :: (Bool, Ident) -> (Bool, CHSPtrType, Maybe [Char], [Char]) -> GB ()
`ptrMapsTo` (Bool, CHSPtrType, Maybe [Char], [Char])
hsRepr =
(GBState -> (GBState, ())) -> GB ()
forall s a. (s -> (s, a)) -> CT s a
transCT (\GBState
state -> (GBState
state {
ptrmap = Map.insert (isStar, cName) hsRepr (ptrmap state)
}, ()))
queryPtr :: (Bool, Ident) -> GB (Maybe HsPtrRep)
queryPtr :: (Bool, Ident)
-> GB (Maybe (Bool, CHSPtrType, Maybe [Char], [Char]))
queryPtr (Bool, Ident)
pcName = do
fm <- (GBState -> PointerMap) -> CT GBState PointerMap
forall s a. (s -> a) -> CT s a
readCT GBState -> PointerMap
ptrmap
return $ Map.lookup pcName fm
objIs :: Ident -> HsObject -> GB ()
Ident
hsName objIs :: Ident -> HsObject -> GB ()
`objIs` HsObject
obj =
(GBState -> (GBState, ())) -> GB ()
forall s a. (s -> (s, a)) -> CT s a
transCT (\GBState
state -> (GBState
state {
objmap = Map.insert hsName obj (objmap state)
}, ()))
queryObj :: Ident -> GB (Maybe HsObject)
queryObj :: Ident -> GB (Maybe HsObject)
queryObj Ident
hsName = do
fm <- (GBState -> HsObjectMap) -> CT GBState HsObjectMap
forall s a. (s -> a) -> CT s a
readCT GBState -> HsObjectMap
objmap
return $ Map.lookup hsName fm
queryClass :: Ident -> GB HsObject
queryClass :: Ident -> GB HsObject
queryClass Ident
hsName = do
let pos :: Position
pos = Ident -> Position
forall a. Pos a => a -> Position
posOf Ident
hsName
oobj <- Ident -> GB (Maybe HsObject)
queryObj Ident
hsName
case oobj of
Just obj :: HsObject
obj@(Class Maybe Ident
_ Ident
_) -> HsObject -> GB HsObject
forall a. a -> PreCST SwitchBoard (CState GBState) a
forall (m :: * -> *) a. Monad m => a -> m a
return HsObject
obj
Just HsObject
_ -> Ident -> GB HsObject
forall a. Ident -> GB a
classExpectedErr Ident
hsName
Maybe HsObject
Nothing -> Ident -> GB HsObject
forall a. Ident -> GB a
hsObjExpectedErr Ident
hsName
queryPointer :: Ident -> GB HsObject
queryPointer :: Ident -> GB HsObject
queryPointer Ident
hsName = do
let pos :: Position
pos = Ident -> Position
forall a. Pos a => a -> Position
posOf Ident
hsName
oobj <- Ident -> GB (Maybe HsObject)
queryObj Ident
hsName
case oobj of
Just obj :: HsObject
obj@(Pointer CHSPtrType
_ Bool
_) -> HsObject -> GB HsObject
forall a. a -> PreCST SwitchBoard (CState GBState) a
forall (m :: * -> *) a. Monad m => a -> m a
return HsObject
obj
Just HsObject
_ -> Ident -> GB HsObject
forall a. Ident -> GB a
pointerExpectedErr Ident
hsName
Maybe HsObject
Nothing -> Ident -> GB HsObject
forall a. Ident -> GB a
hsObjExpectedErr Ident
hsName
mergeMaps :: String -> GB ()
mergeMaps :: [Char] -> GB ()
mergeMaps [Char]
str =
(GBState -> (GBState, ())) -> GB ()
forall s a. (s -> (s, a)) -> CT s a
transCT (\GBState
state -> (GBState
state {
ptrmap = Map.union (ptrmap state) readPtrMap,
objmap = Map.union (objmap state) readObjMap
}, ()))
where
([((Bool, [Char]), (Bool, CHSPtrType, Maybe [Char], [Char]))]
ptrAssoc, [([Char], HsObject)]
objAssoc) = [Char]
-> ([((Bool, [Char]), (Bool, CHSPtrType, Maybe [Char], [Char]))],
[([Char], HsObject)])
forall a. Read a => [Char] -> a
read [Char]
str
readPtrMap :: PointerMap
readPtrMap = [((Bool, Ident), (Bool, CHSPtrType, Maybe [Char], [Char]))]
-> PointerMap
forall k a. Ord k => [(k, a)] -> Map k a
Map.fromList [((Bool
isStar, Position -> [Char] -> Ident
onlyPosIdent Position
nopos [Char]
ide), (Bool, CHSPtrType, Maybe [Char], [Char])
repr)
| ((Bool
isStar, [Char]
ide), (Bool, CHSPtrType, Maybe [Char], [Char])
repr) <- [((Bool, [Char]), (Bool, CHSPtrType, Maybe [Char], [Char]))]
ptrAssoc]
readObjMap :: HsObjectMap
readObjMap = [(Ident, HsObject)] -> HsObjectMap
forall k a. Ord k => [(k, a)] -> Map k a
Map.fromList [(Position -> [Char] -> Ident
onlyPosIdent Position
nopos [Char]
ide, HsObject
obj)
| ([Char]
ide, HsObject
obj) <- [([Char], HsObject)]
objAssoc]
dumpMaps :: GB String
dumpMaps :: GB [Char]
dumpMaps = do
ptrFM <- (GBState -> PointerMap) -> CT GBState PointerMap
forall s a. (s -> a) -> CT s a
readCT GBState -> PointerMap
ptrmap
objFM <- readCT objmap
let dumpable = ([((Bool
isStar, TransFun
identToLexeme Ident
ide), (Bool, CHSPtrType, Maybe [Char], [Char])
repr)
| ((Bool
isStar, Ident
ide), (Bool, CHSPtrType, Maybe [Char], [Char])
repr) <- PointerMap
-> [((Bool, Ident), (Bool, CHSPtrType, Maybe [Char], [Char]))]
forall k a. Map k a -> [(k, a)]
Map.toList PointerMap
ptrFM],
[(TransFun
identToLexeme Ident
ide, HsObject
obj)
| (Ident
ide, HsObject
obj) <- HsObjectMap -> [(Ident, HsObject)]
forall k a. Map k a -> [(k, a)]
Map.toList HsObjectMap
objFM])
return $ show dumpable
incompatibleCallHooksErr :: Position -> Position -> GB a
incompatibleCallHooksErr :: forall {a}. Position -> Position -> GB a
incompatibleCallHooksErr Position
here Position
there =
Position -> [[Char]] -> CT GBState a
forall s a. Position -> [[Char]] -> CT s a
raiseErrorCTExc Position
here
[[Char]
"Incompatible call hooks!",
[Char]
"There is a another call hook for the same C function at " [Char] -> [Char] -> [Char]
forall a. [a] -> [a] -> [a]
++ Position -> [Char]
forall a. Show a => a -> [Char]
show Position
there,
[Char]
"The flags and C function name of the two hooks should be identical,",
[Char]
"but they are not."]
classExpectedErr :: Ident -> GB a
classExpectedErr :: forall a. Ident -> GB a
classExpectedErr Ident
ide =
Position -> [[Char]] -> CT GBState a
forall s a. Position -> [[Char]] -> CT s a
raiseErrorCTExc (Ident -> Position
forall a. Pos a => a -> Position
posOf Ident
ide)
[[Char]
"Expected a class name!",
[Char]
"Expected `" [Char] -> [Char] -> [Char]
forall a. [a] -> [a] -> [a]
++ TransFun
identToLexeme Ident
ide [Char] -> [Char] -> [Char]
forall a. [a] -> [a] -> [a]
++ [Char]
"' to refer to a class introduced",
[Char]
"by a class hook."]
pointerExpectedErr :: Ident -> GB a
pointerExpectedErr :: forall a. Ident -> GB a
pointerExpectedErr Ident
ide =
Position -> [[Char]] -> CT GBState a
forall s a. Position -> [[Char]] -> CT s a
raiseErrorCTExc (Ident -> Position
forall a. Pos a => a -> Position
posOf Ident
ide)
[[Char]
"Expected a pointer name!",
[Char]
"Expected `" [Char] -> [Char] -> [Char]
forall a. [a] -> [a] -> [a]
++ TransFun
identToLexeme Ident
ide [Char] -> [Char] -> [Char]
forall a. [a] -> [a] -> [a]
++ [Char]
"' to be a type name introduced by",
[Char]
"a pointer hook."]
hsObjExpectedErr :: Ident -> GB a
hsObjExpectedErr :: forall a. Ident -> GB a
hsObjExpectedErr Ident
ide =
Position -> [[Char]] -> CT GBState a
forall s a. Position -> [[Char]] -> CT s a
raiseErrorCTExc (Ident -> Position
forall a. Pos a => a -> Position
posOf Ident
ide)
[[Char]
"Unknown name!",
[Char]
"`" [Char] -> [Char] -> [Char]
forall a. [a] -> [a] -> [a]
++ TransFun
identToLexeme Ident
ide [Char] -> [Char] -> [Char]
forall a. [a] -> [a] -> [a]
++ [Char]
"' is unknown; it has *not* been defined by",
[Char]
"a previous hook."]