module CAttrs (
AttrC, attrC, getCHeader, enterNewRangeC, enterNewObjRangeC,
leaveRangeC, leaveObjRangeC, addDefObjC, lookupDefObjC,
lookupDefObjCShadow, addDefTagC, lookupDefTagC,
lookupDefTagCShadow, applyPrefix, getDefOfIdentC,
setDefOfIdentC, updDefOfIdentC, freezeDefOfIdentsAttrC,
softenDefOfIdentsAttrC,
CObj(..), CTag(..), CDef(..))
where
import Data.Char (toUpper)
import Data.List (isPrefixOf)
import Data.Maybe (mapMaybe)
import Position (Position, Pos(posOf), nopos, dontCarePos, builtinPos)
import Errors (interr)
import Idents (Ident, getIdentAttrs, identToLexeme, onlyPosIdent)
import Attributes (Attr(..), AttrTable, getAttr, setAttr, updAttr,
newAttrTable, freezeAttrTable, softenAttrTable)
import NameSpaces (NameSpace, nameSpace, enterNewRange, leaveRange, defLocal,
defGlobal, find, nameSpaceToList)
import Binary (Binary(..), putByte, getByte)
import CAST
data AttrC = AttrC {
:: CHeader,
AttrC -> CObjNS
defObjsAC :: CObjNS,
AttrC -> CTagNS
defTagsAC :: CTagNS,
AttrC -> CShadowNS
shadowsAC :: CShadowNS,
AttrC -> CDefTable
defsAC :: CDefTable
}
attrC :: CHeader -> AttrC
attrC :: CHeader -> AttrC
attrC CHeader
header = AttrC {
headerAC :: CHeader
headerAC = CHeader
header,
defObjsAC :: CObjNS
defObjsAC = CObjNS
cObjNS,
defTagsAC :: CTagNS
defTagsAC = CTagNS
cTagNS,
shadowsAC :: CShadowNS
shadowsAC = CShadowNS
cShadowNS,
defsAC :: CDefTable
defsAC = CDefTable
cDefTable
}
getCHeader :: AttrC -> CHeader
= AttrC -> CHeader
headerAC
enterNewRangeC :: AttrC -> AttrC
enterNewRangeC :: AttrC -> AttrC
enterNewRangeC AttrC
ac = AttrC
ac {
defObjsAC :: CObjNS
defObjsAC = forall a. NameSpace a -> NameSpace a
enterNewRange forall b c a. (b -> c) -> (a -> b) -> a -> c
. AttrC -> CObjNS
defObjsAC forall a b. (a -> b) -> a -> b
$ AttrC
ac,
defTagsAC :: CTagNS
defTagsAC = forall a. NameSpace a -> NameSpace a
enterNewRange forall b c a. (b -> c) -> (a -> b) -> a -> c
. AttrC -> CTagNS
defTagsAC forall a b. (a -> b) -> a -> b
$ AttrC
ac
}
enterNewObjRangeC :: AttrC -> AttrC
enterNewObjRangeC :: AttrC -> AttrC
enterNewObjRangeC AttrC
ac = AttrC
ac {
defObjsAC :: CObjNS
defObjsAC = forall a. NameSpace a -> NameSpace a
enterNewRange forall b c a. (b -> c) -> (a -> b) -> a -> c
. AttrC -> CObjNS
defObjsAC forall a b. (a -> b) -> a -> b
$ AttrC
ac
}
leaveRangeC :: AttrC -> AttrC
leaveRangeC :: AttrC -> AttrC
leaveRangeC AttrC
ac = AttrC
ac {
defObjsAC :: CObjNS
defObjsAC = forall a b. (a, b) -> a
fst forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a. NameSpace a -> (NameSpace a, [(Ident, a)])
leaveRange forall b c a. (b -> c) -> (a -> b) -> a -> c
. AttrC -> CObjNS
defObjsAC forall a b. (a -> b) -> a -> b
$ AttrC
ac,
defTagsAC :: CTagNS
defTagsAC = forall a b. (a, b) -> a
fst forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a. NameSpace a -> (NameSpace a, [(Ident, a)])
leaveRange forall b c a. (b -> c) -> (a -> b) -> a -> c
. AttrC -> CTagNS
defTagsAC forall a b. (a -> b) -> a -> b
$ AttrC
ac
}
leaveObjRangeC :: AttrC -> AttrC
leaveObjRangeC :: AttrC -> AttrC
leaveObjRangeC AttrC
ac = AttrC
ac {
defObjsAC :: CObjNS
defObjsAC = forall a b. (a, b) -> a
fst forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a. NameSpace a -> (NameSpace a, [(Ident, a)])
leaveRange forall b c a. (b -> c) -> (a -> b) -> a -> c
. AttrC -> CObjNS
defObjsAC forall a b. (a -> b) -> a -> b
$ AttrC
ac
}
addDefObjC :: AttrC -> Ident -> CObj -> (AttrC, Maybe CObj)
addDefObjC :: AttrC -> Ident -> CObj -> (AttrC, Maybe CObj)
addDefObjC AttrC
ac Ident
ide CObj
obj = let om :: CObjNS
om = AttrC -> CObjNS
defObjsAC AttrC
ac
(CObjNS
ac', Maybe CObj
obj') = forall a. NameSpace a -> Ident -> a -> (NameSpace a, Maybe a)
defLocal CObjNS
om Ident
ide CObj
obj
in
(AttrC
ac {defObjsAC :: CObjNS
defObjsAC = CObjNS
ac'}, Maybe CObj
obj')
lookupDefObjC :: AttrC -> Ident -> Maybe CObj
lookupDefObjC :: AttrC -> Ident -> Maybe CObj
lookupDefObjC AttrC
ac Ident
ide = forall a. NameSpace a -> Ident -> Maybe a
find (AttrC -> CObjNS
defObjsAC AttrC
ac) Ident
ide
lookupDefObjCShadow :: AttrC -> Ident -> Maybe (CObj, Ident)
lookupDefObjCShadow :: AttrC -> Ident -> Maybe (CObj, Ident)
lookupDefObjCShadow AttrC
ac Ident
ide =
case AttrC -> Ident -> Maybe CObj
lookupDefObjC AttrC
ac Ident
ide of
Just CObj
obj -> forall a. a -> Maybe a
Just (CObj
obj, Ident
ide)
Maybe CObj
Nothing -> case forall a. NameSpace a -> Ident -> Maybe a
find (AttrC -> CShadowNS
shadowsAC AttrC
ac) Ident
ide of
Maybe Ident
Nothing -> forall a. Maybe a
Nothing
Just Ident
ide' -> case AttrC -> Ident -> Maybe CObj
lookupDefObjC AttrC
ac Ident
ide' of
Just CObj
obj -> forall a. a -> Maybe a
Just (CObj
obj, Ident
ide')
Maybe CObj
Nothing -> forall a. Maybe a
Nothing
addDefTagC :: AttrC -> Ident -> CTag -> (AttrC, Maybe CTag)
addDefTagC :: AttrC -> Ident -> CTag -> (AttrC, Maybe CTag)
addDefTagC AttrC
ac Ident
ide CTag
obj = let tm :: CTagNS
tm = AttrC -> CTagNS
defTagsAC AttrC
ac
(CTagNS
ac', Maybe CTag
obj') = forall a. NameSpace a -> Ident -> a -> (NameSpace a, Maybe a)
defLocal CTagNS
tm Ident
ide CTag
obj
in
(AttrC
ac {defTagsAC :: CTagNS
defTagsAC = CTagNS
ac'}, Maybe CTag
obj')
lookupDefTagC :: AttrC -> Ident -> Maybe CTag
lookupDefTagC :: AttrC -> Ident -> Maybe CTag
lookupDefTagC AttrC
ac Ident
ide = forall a. NameSpace a -> Ident -> Maybe a
find (AttrC -> CTagNS
defTagsAC AttrC
ac) Ident
ide
lookupDefTagCShadow :: AttrC -> Ident -> Maybe (CTag, Ident)
lookupDefTagCShadow :: AttrC -> Ident -> Maybe (CTag, Ident)
lookupDefTagCShadow AttrC
ac Ident
ide =
case AttrC -> Ident -> Maybe CTag
lookupDefTagC AttrC
ac Ident
ide of
Just CTag
tag -> forall a. a -> Maybe a
Just (CTag
tag, Ident
ide)
Maybe CTag
Nothing -> case forall a. NameSpace a -> Ident -> Maybe a
find (AttrC -> CShadowNS
shadowsAC AttrC
ac) Ident
ide of
Maybe Ident
Nothing -> forall a. Maybe a
Nothing
Just Ident
ide' -> case AttrC -> Ident -> Maybe CTag
lookupDefTagC AttrC
ac Ident
ide' of
Just CTag
tag -> forall a. a -> Maybe a
Just (CTag
tag, Ident
ide')
Maybe CTag
Nothing -> forall a. Maybe a
Nothing
applyPrefix :: AttrC -> String -> AttrC
applyPrefix :: AttrC -> String -> AttrC
applyPrefix AttrC
ac String
prefix =
let
shadows :: CShadowNS
shadows = AttrC -> CShadowNS
shadowsAC AttrC
ac
names :: [Ident]
names = forall a b. (a -> b) -> [a] -> [b]
map forall a b. (a, b) -> a
fst (forall a. NameSpace a -> [(Ident, a)]
nameSpaceToList (AttrC -> CObjNS
defObjsAC AttrC
ac))
forall a. [a] -> [a] -> [a]
++ forall a b. (a -> b) -> [a] -> [b]
map forall a b. (a, b) -> a
fst (forall a. NameSpace a -> [(Ident, a)]
nameSpaceToList (AttrC -> CTagNS
defTagsAC AttrC
ac))
newShadows :: [(Ident, Ident)]
newShadows = forall a b. (a -> Maybe b) -> [a] -> [b]
mapMaybe (String -> Ident -> Maybe (Ident, Ident)
strip String
prefix) [Ident]
names
in
AttrC
ac {shadowsAC :: CShadowNS
shadowsAC = forall (t :: * -> *) b a.
Foldable t =>
(b -> a -> b) -> b -> t a -> b
foldl forall {a}. NameSpace a -> (Ident, a) -> NameSpace a
define CShadowNS
shadows [(Ident, Ident)]
newShadows}
where
strip :: String -> Ident -> Maybe (Ident, Ident)
strip String
prefix Ident
ide = case String -> String -> Maybe String
eat String
prefix (Ident -> String
identToLexeme Ident
ide) of
Maybe String
Nothing -> forall a. Maybe a
Nothing
Just String
"" -> forall a. Maybe a
Nothing
Just String
newName -> forall a. a -> Maybe a
Just
(Position -> String -> Ident
onlyPosIdent (forall a. Pos a => a -> Position
posOf Ident
ide) String
newName,
Ident
ide)
eat :: String -> String -> Maybe String
eat [] (Char
'_':String
cs) = String -> String -> Maybe String
eat [] String
cs
eat [] String
cs = forall a. a -> Maybe a
Just String
cs
eat (Char
p:String
prefix) (Char
c:String
cs) | Char -> Char
toUpper Char
p forall a. Eq a => a -> a -> Bool
== Char -> Char
toUpper Char
c = String -> String -> Maybe String
eat String
prefix String
cs
| Bool
otherwise = forall a. Maybe a
Nothing
eat String
_ String
_ = forall a. Maybe a
Nothing
define :: NameSpace a -> (Ident, a) -> NameSpace a
define NameSpace a
ns (Ident
ide, a
def) = forall a b. (a, b) -> a
fst (forall a. NameSpace a -> Ident -> a -> (NameSpace a, Maybe a)
defGlobal NameSpace a
ns Ident
ide a
def)
getDefOfIdentC :: AttrC -> Ident -> CDef
getDefOfIdentC :: AttrC -> Ident -> CDef
getDefOfIdentC AttrC
ac = forall a. Attr a => AttrTable a -> Attrs -> a
getAttr (AttrC -> CDefTable
defsAC AttrC
ac) forall b c a. (b -> c) -> (a -> b) -> a -> c
. Ident -> Attrs
getIdentAttrs
setDefOfIdentC :: AttrC -> Ident -> CDef -> AttrC
setDefOfIdentC :: AttrC -> Ident -> CDef -> AttrC
setDefOfIdentC AttrC
ac Ident
id CDef
def =
let tot' :: CDefTable
tot' = forall a. Attr a => AttrTable a -> Attrs -> a -> AttrTable a
setAttr (AttrC -> CDefTable
defsAC AttrC
ac) (Ident -> Attrs
getIdentAttrs Ident
id) CDef
def
in
AttrC
ac {defsAC :: CDefTable
defsAC = CDefTable
tot'}
updDefOfIdentC :: AttrC -> Ident -> CDef -> AttrC
updDefOfIdentC :: AttrC -> Ident -> CDef -> AttrC
updDefOfIdentC AttrC
ac Ident
id CDef
def =
let tot' :: CDefTable
tot' = forall a. Attr a => AttrTable a -> Attrs -> a -> AttrTable a
updAttr (AttrC -> CDefTable
defsAC AttrC
ac) (Ident -> Attrs
getIdentAttrs Ident
id) CDef
def
in
AttrC
ac {defsAC :: CDefTable
defsAC = CDefTable
tot'}
freezeDefOfIdentsAttrC :: AttrC -> AttrC
freezeDefOfIdentsAttrC :: AttrC -> AttrC
freezeDefOfIdentsAttrC AttrC
ac = AttrC
ac {defsAC :: CDefTable
defsAC = forall a. Attr a => AttrTable a -> AttrTable a
freezeAttrTable (AttrC -> CDefTable
defsAC AttrC
ac)}
softenDefOfIdentsAttrC :: AttrC -> AttrC
softenDefOfIdentsAttrC :: AttrC -> AttrC
softenDefOfIdentsAttrC AttrC
ac = AttrC
ac {defsAC :: CDefTable
defsAC = forall a. Attr a => AttrTable a -> AttrTable a
softenAttrTable (AttrC -> CDefTable
defsAC AttrC
ac)}
data CObj = TypeCO CDecl
| ObjCO CDecl
| EnumCO Ident CEnum
| BuiltinCO
instance Eq CObj where
(TypeCO CDecl
decl1 ) == :: CObj -> CObj -> Bool
== (TypeCO CDecl
decl2 ) = CDecl
decl1 forall a. Eq a => a -> a -> Bool
== CDecl
decl2
(ObjCO CDecl
decl1 ) == (ObjCO CDecl
decl2 ) = CDecl
decl1 forall a. Eq a => a -> a -> Bool
== CDecl
decl2
(EnumCO Ident
ide1 CEnum
enum1) == (EnumCO Ident
ide2 CEnum
enum2) = Ident
ide1 forall a. Eq a => a -> a -> Bool
== Ident
ide2 Bool -> Bool -> Bool
&& CEnum
enum1 forall a. Eq a => a -> a -> Bool
== CEnum
enum2
CObj
_ == CObj
_ = Bool
False
instance Pos CObj where
posOf :: CObj -> Position
posOf (TypeCO CDecl
def ) = forall a. Pos a => a -> Position
posOf CDecl
def
posOf (ObjCO CDecl
def ) = forall a. Pos a => a -> Position
posOf CDecl
def
posOf (EnumCO Ident
ide CEnum
_) = forall a. Pos a => a -> Position
posOf Ident
ide
posOf (CObj
BuiltinCO ) = Position
builtinPos
data CTag = StructUnionCT CStructUnion
| EnumCT CEnum
instance Eq CTag where
(StructUnionCT CStructUnion
struct1) == :: CTag -> CTag -> Bool
== (StructUnionCT CStructUnion
struct2) = CStructUnion
struct1 forall a. Eq a => a -> a -> Bool
== CStructUnion
struct2
(EnumCT CEnum
enum1 ) == (EnumCT CEnum
enum2 ) = CEnum
enum1 forall a. Eq a => a -> a -> Bool
== CEnum
enum2
CTag
_ == CTag
_ = Bool
False
instance Pos CTag where
posOf :: CTag -> Position
posOf (StructUnionCT CStructUnion
def) = forall a. Pos a => a -> Position
posOf CStructUnion
def
posOf (EnumCT CEnum
def) = forall a. Pos a => a -> Position
posOf CEnum
def
data CDef = UndefCD
| DontCareCD
| ObjCD CObj
| TagCD CTag
instance Eq CDef where
(ObjCD CObj
obj1) == :: CDef -> CDef -> Bool
== (ObjCD CObj
obj2) = CObj
obj1 forall a. Eq a => a -> a -> Bool
== CObj
obj2
(TagCD CTag
tag1) == (TagCD CTag
tag2) = CTag
tag1 forall a. Eq a => a -> a -> Bool
== CTag
tag2
CDef
DontCareCD == CDef
_ = Bool
True
CDef
_ == CDef
DontCareCD = Bool
True
CDef
UndefCD == CDef
_ =
forall a. String -> a
interr String
"CAttrs: Attempt to compare an undefined C definition!"
CDef
_ == CDef
UndefCD =
forall a. String -> a
interr String
"CAttrs: Attempt to compare an undefined C definition!"
CDef
_ == CDef
_ = Bool
False
instance Attr CDef where
undef :: CDef
undef = CDef
UndefCD
dontCare :: CDef
dontCare = CDef
DontCareCD
isUndef :: CDef -> Bool
isUndef CDef
UndefCD = Bool
True
isUndef CDef
_ = Bool
False
isDontCare :: CDef -> Bool
isDontCare CDef
DontCareCD = Bool
True
isDontCare CDef
_ = Bool
False
instance Pos CDef where
posOf :: CDef -> Position
posOf CDef
UndefCD = Position
nopos
posOf CDef
DontCareCD = Position
dontCarePos
posOf (ObjCD CObj
obj) = forall a. Pos a => a -> Position
posOf CObj
obj
posOf (TagCD CTag
tag) = forall a. Pos a => a -> Position
posOf CTag
tag
type CObjNS = NameSpace CObj
cObjNS :: CObjNS
cObjNS :: CObjNS
cObjNS = forall a. NameSpace a
nameSpace
type CTagNS = NameSpace CTag
cTagNS :: CTagNS
cTagNS :: CTagNS
cTagNS = forall a. NameSpace a
nameSpace
type CShadowNS = NameSpace Ident
cShadowNS :: CShadowNS
cShadowNS :: CShadowNS
cShadowNS = forall a. NameSpace a
nameSpace
type CDefTable = AttrTable CDef
cDefTable :: CDefTable
cDefTable :: CDefTable
cDefTable = forall a. Attr a => String -> AttrTable a
newAttrTable String
"C General Definition Table for Idents"
instance Binary AttrC where
put_ :: BinHandle -> AttrC -> IO ()
put_ BinHandle
bh (AttrC CHeader
aa CObjNS
ab CTagNS
ac CShadowNS
ad CDefTable
ae) = do
forall a. Binary a => BinHandle -> a -> IO ()
put_ BinHandle
bh CObjNS
ab
forall a. Binary a => BinHandle -> a -> IO ()
put_ BinHandle
bh CTagNS
ac
forall a. Binary a => BinHandle -> a -> IO ()
put_ BinHandle
bh CShadowNS
ad
forall a. Binary a => BinHandle -> a -> IO ()
put_ BinHandle
bh CDefTable
ae
get :: BinHandle -> IO AttrC
get BinHandle
bh = do
CObjNS
ab <- forall a. Binary a => BinHandle -> IO a
get BinHandle
bh
CTagNS
ac <- forall a. Binary a => BinHandle -> IO a
get BinHandle
bh
CShadowNS
ad <- forall a. Binary a => BinHandle -> IO a
get BinHandle
bh
CDefTable
ae <- forall a. Binary a => BinHandle -> IO a
get BinHandle
bh
forall (m :: * -> *) a. Monad m => a -> m a
return (CHeader -> CObjNS -> CTagNS -> CShadowNS -> CDefTable -> AttrC
AttrC (forall a. HasCallStack => String -> a
error String
"AttrC.headerAC should not be needed") CObjNS
ab CTagNS
ac CShadowNS
ad CDefTable
ae)
instance Binary CObj where
put_ :: BinHandle -> CObj -> IO ()
put_ BinHandle
bh (TypeCO CDecl
aa) = do
BinHandle -> Word8 -> IO ()
putByte BinHandle
bh Word8
0
forall a. Binary a => BinHandle -> a -> IO ()
put_ BinHandle
bh CDecl
aa
put_ BinHandle
bh (ObjCO CDecl
ab) = do
BinHandle -> Word8 -> IO ()
putByte BinHandle
bh Word8
1
forall a. Binary a => BinHandle -> a -> IO ()
put_ BinHandle
bh CDecl
ab
put_ BinHandle
bh (EnumCO Ident
ac CEnum
ad) = do
BinHandle -> Word8 -> IO ()
putByte BinHandle
bh Word8
2
forall a. Binary a => BinHandle -> a -> IO ()
put_ BinHandle
bh Ident
ac
forall a. Binary a => BinHandle -> a -> IO ()
put_ BinHandle
bh CEnum
ad
put_ BinHandle
bh CObj
BuiltinCO = do
BinHandle -> Word8 -> IO ()
putByte BinHandle
bh Word8
3
get :: BinHandle -> IO CObj
get BinHandle
bh = do
Word8
h <- BinHandle -> IO Word8
getByte BinHandle
bh
case Word8
h of
Word8
0 -> do
CDecl
aa <- forall a. Binary a => BinHandle -> IO a
get BinHandle
bh
forall (m :: * -> *) a. Monad m => a -> m a
return (CDecl -> CObj
TypeCO CDecl
aa)
Word8
1 -> do
CDecl
ab <- forall a. Binary a => BinHandle -> IO a
get BinHandle
bh
forall (m :: * -> *) a. Monad m => a -> m a
return (CDecl -> CObj
ObjCO CDecl
ab)
Word8
2 -> do
Ident
ac <- forall a. Binary a => BinHandle -> IO a
get BinHandle
bh
CEnum
ad <- forall a. Binary a => BinHandle -> IO a
get BinHandle
bh
forall (m :: * -> *) a. Monad m => a -> m a
return (Ident -> CEnum -> CObj
EnumCO Ident
ac CEnum
ad)
Word8
3 -> do
forall (m :: * -> *) a. Monad m => a -> m a
return CObj
BuiltinCO
instance Binary CTag where
put_ :: BinHandle -> CTag -> IO ()
put_ BinHandle
bh (StructUnionCT CStructUnion
aa) = do
BinHandle -> Word8 -> IO ()
putByte BinHandle
bh Word8
0
forall a. Binary a => BinHandle -> a -> IO ()
put_ BinHandle
bh CStructUnion
aa
put_ BinHandle
bh (EnumCT CEnum
ab) = do
BinHandle -> Word8 -> IO ()
putByte BinHandle
bh Word8
1
forall a. Binary a => BinHandle -> a -> IO ()
put_ BinHandle
bh CEnum
ab
get :: BinHandle -> IO CTag
get BinHandle
bh = do
Word8
h <- BinHandle -> IO Word8
getByte BinHandle
bh
case Word8
h of
Word8
0 -> do
CStructUnion
aa <- forall a. Binary a => BinHandle -> IO a
get BinHandle
bh
forall (m :: * -> *) a. Monad m => a -> m a
return (CStructUnion -> CTag
StructUnionCT CStructUnion
aa)
Word8
1 -> do
CEnum
ab <- forall a. Binary a => BinHandle -> IO a
get BinHandle
bh
forall (m :: * -> *) a. Monad m => a -> m a
return (CEnum -> CTag
EnumCT CEnum
ab)
instance Binary CDef where
put_ :: BinHandle -> CDef -> IO ()
put_ BinHandle
bh CDef
UndefCD = do
BinHandle -> Word8 -> IO ()
putByte BinHandle
bh Word8
0
put_ BinHandle
bh CDef
DontCareCD = do
BinHandle -> Word8 -> IO ()
putByte BinHandle
bh Word8
1
put_ BinHandle
bh (ObjCD CObj
aa) = do
BinHandle -> Word8 -> IO ()
putByte BinHandle
bh Word8
2
forall a. Binary a => BinHandle -> a -> IO ()
put_ BinHandle
bh CObj
aa
put_ BinHandle
bh (TagCD CTag
ab) = do
BinHandle -> Word8 -> IO ()
putByte BinHandle
bh Word8
3
forall a. Binary a => BinHandle -> a -> IO ()
put_ BinHandle
bh CTag
ab
get :: BinHandle -> IO CDef
get BinHandle
bh = do
Word8
h <- BinHandle -> IO Word8
getByte BinHandle
bh
case Word8
h of
Word8
0 -> do
forall (m :: * -> *) a. Monad m => a -> m a
return CDef
UndefCD
Word8
1 -> do
forall (m :: * -> *) a. Monad m => a -> m a
return CDef
DontCareCD
Word8
2 -> do
CObj
aa <- forall a. Binary a => BinHandle -> IO a
get BinHandle
bh
forall (m :: * -> *) a. Monad m => a -> m a
return (CObj -> CDef
ObjCD CObj
aa)
Word8
3 -> do
CTag
ab <- forall a. Binary a => BinHandle -> IO a
get BinHandle
bh
forall (m :: * -> *) a. Monad m => a -> m a
return (CTag -> CDef
TagCD CTag
ab)