skate: adding generation of fact format string
authorReto Achermann <reto.achermann@inf.ethz.ch>
Sun, 14 May 2017 19:09:34 +0000 (21:09 +0200)
committerReto Achermann <reto.achermann@inf.ethz.ch>
Sun, 14 May 2017 19:09:34 +0000 (21:09 +0200)
Signed-off-by: Reto Achermann <reto.achermann@inf.ethz.ch>

tools/skate/CAbsSyntax.hs
tools/skate/SkateBackendCommon.hs
tools/skate/SkateBackendHeader.hs
tools/skate/SkateDeclarationTable.hs
tools/skate/SkateTypeTable.hs
tools/skate/SkateTypes.hs

index 928466e..665cbd8 100644 (file)
@@ -340,6 +340,8 @@ pp_fnbody :: [ Stmt ] -> [ String ]
 pp_fnbody body = [ "{" ] ++ (indent_stmts body) ++ [ "}", ""]
 
 pp_fnhead :: TypeSpec -> String -> [ Param ] -> String
+pp_fnhead ts n [] =
+    (pp_typespec ts n) ++ "(void)"
 pp_fnhead ts n pl =
     (pp_typespec ts n) ++ "(" ++ parlist ++ ")"
     where
index 7690cf2..35d472d 100644 (file)
@@ -59,18 +59,177 @@ identifier_to_cname (xs:x) =
     if xs == '.' then '_' : identifier_to_cname x
     else xs : identifier_to_cname x
 
+{- makes a type out of a cname -}
 make_type_name :: String -> String
 make_type_name s = s ++ "_t"
 
+make_format_name_pr :: String -> String
+make_format_name_pr s =  map toUpper (s ++ "_pri")
+
+make_format_name_rd :: String -> String
+make_format_name_rd s =  map toUpper (s ++ "_scn")
+
+{--}
+identifier_to_prolog :: [Char] -> [Char]
+identifier_to_prolog [] = []
+identifier_to_prolog (xs:x) =
+    if xs == '.' then '_' : identifier_to_cname x
+    else xs : identifier_to_cname x
+
+
+typeref_to_ctype :: TypeRef -> C.TypeSpec
+typeref_to_ctype (TBuiltIn UInt8)   = C.TypeName "uint8_t"
+typeref_to_ctype (TBuiltIn UInt16)  = C.TypeName "uint16_t"
+typeref_to_ctype (TBuiltIn UInt32)  = C.TypeName "uint32_t"
+typeref_to_ctype (TBuiltIn UInt64)  = C.TypeName "uint64_t"
+typeref_to_ctype (TBuiltIn UIntPtr) = C.TypeName "uintptr_t"
+typeref_to_ctype (TBuiltIn Int8)    = C.TypeName "int8_t"
+typeref_to_ctype (TBuiltIn Int16)   = C.TypeName "int16_t"
+typeref_to_ctype (TBuiltIn Int32)   = C.TypeName "int32_t"
+typeref_to_ctype (TBuiltIn Int64)   = C.TypeName "int64_t"
+typeref_to_ctype (TBuiltIn IntPtr)  = C.TypeName "intptr_t"
+typeref_to_ctype (TBuiltIn Size)    = C.TypeName "size_t"
+typeref_to_ctype (TBuiltIn Bool)    = C.TypeName "bool"
+typeref_to_ctype (TBuiltIn String)  = C.Ptr (C.TypeName "char")
+typeref_to_ctype (TBuiltIn Char)    = C.TypeName "char"
+typeref_to_ctype (TBuiltIn Capref)  = C.Struct "capref"
+typeref_to_ctype (TEnum i _ )        = C.TypeName (make_type_name (identifier_to_cname i))
+typeref_to_ctype (TConstant i _ )    = C.TypeName (make_type_name (identifier_to_cname i))
+typeref_to_ctype (TFact i _)        = C.TypeName (make_type_name (identifier_to_cname i))
+typeref_to_ctype (TFlags i _ )       = C.TypeName (make_type_name (identifier_to_cname i))
+
+
+{-
+==============================================================================
+= Function Signatures
+==============================================================================
+-}
+
+
+skate_c_errval_t :: C.TypeSpec
+skate_c_errval_t = C.TypeName "errval_t"
+
+skate_c_void_t :: C.TypeSpec
+skate_c_void_t = C.TypeName "void"
+
+skate_c_fn_decl :: C.TypeSpec -> String -> [String] -> [C.Param] -> C.Unit
+skate_c_fn_decl rt n c p = C.UnitList [
+    C.Blank, C.Blank,
+    C.MultiDoxy c,
+    C.FunctionDecl C.NoScope rt fn p]
+    where
+        fn = (identifier_to_cname n)
+
+
+skate_c_fn_def :: C.TypeSpec -> String -> [String] -> [C.Param] -> [C.Stmt] -> C.Unit
+skate_c_fn_def rt n c p st = C.UnitList [
+    C.Blank, C.Blank,
+    C.MultiDoxy c,
+    C.FunctionDef C.NoScope rt fn p st]
+    where
+        fn = (identifier_to_cname n)
+
+
+
 {-----------------------------------------------------------------------------
-- Function signatures
+- schema.namespace.decl.describe()
 ------------------------------------------------------------------------------}
 
 skate_c_fn_name_describe :: String -> String
-skate_c_fn_name_describe fn = fn ++ ".describe"
+skate_c_fn_name_describe fn = (make_qualified_identifer fn "describe")
+
+skate_c_fn_decl_describe :: String -> C.Unit
+skate_c_fn_decl_describe fn = skate_c_fn_decl skate_c_void_t fn_name doxy []
+    where
+        fn_name = (skate_c_fn_name_describe fn)
+        doxy = ["@brief Describes the " ++ fn]
+
+
+skate_c_fn_def_describe :: String -> [ C.Stmt ] -> C.Unit
+skate_c_fn_def_describe fn = C.FunctionDef C.NoScope skate_c_errval_t fn_name params
+    where
+        fn_name = (skate_c_fn_name_describe fn)
+        params = []
+
+
+{-----------------------------------------------------------------------------
+- schema.namespace.decl.describe()
+------------------------------------------------------------------------------}
+
+skate_c_fn_name_explain :: String -> String
+skate_c_fn_name_explain fn = (make_qualified_identifer fn "explain")
+
+
+{-----------------------------------------------------------------------------
+- schema.namespace.decl.print()
+------------------------------------------------------------------------------}
+
+skate_c_fn_name_print :: String -> String
+skate_c_fn_name_print fn = (make_qualified_identifer fn "print")
+
+{-----------------------------------------------------------------------------
+- schema.namespace.decl.add()
+------------------------------------------------------------------------------}
 
 skate_c_fn_name_add :: String -> String
-skate_c_fn_name_add fn = fn ++ ".add"
+skate_c_fn_name_add fn = (make_qualified_identifer fn "add")
+
+skate_c_fn_decl_add :: String -> ([String], [C.Param])-> C.Unit
+skate_c_fn_decl_add fn (d, p) = skate_c_fn_decl skate_c_void_t fn_name doxy p
+    where
+        fn_name = (skate_c_fn_name_add fn)
+        doxy = ["@brief Adds the " ++ fn, ""] ++ d
+
+
+
+skate_c_fn_def_add :: String -> [C.Param] -> [ C.Stmt ] -> C.Unit
+skate_c_fn_def_add fn p s = C.FunctionDef C.NoScope skate_c_errval_t fn_name p s
+    where
+        fn_name = (skate_c_fn_name_add fn)
+
+{-----------------------------------------------------------------------------
+- schema.namespace.decl.delete()
+------------------------------------------------------------------------------}
+
+skate_c_fn_name_delete :: String -> String
+skate_c_fn_name_delete fn = (make_qualified_identifer fn "delete")
+
+{-----------------------------------------------------------------------------
+- schema.namespace.decl.list()
+------------------------------------------------------------------------------}
 
 skate_c_fn_name_list :: String -> String
-skate_c_fn_name_list fn = fn ++ ".list"
+skate_c_fn_name_list fn = (make_qualified_identifer fn "list")
+
+
+{-----------------------------------------------------------------------------
+- Function signatures
+------------------------------------------------------------------------------}
+
+skate_c_fn_one_param :: FactAttrib -> C.Param
+skate_c_fn_one_param a@(FactAttrib i d t _) = C.Param (typeref_to_ctype t) i
+
+
+skate_c_fn_params_fact :: [FactAttrib] -> ([String], [C.Param])
+skate_c_fn_params_fact attribs = (
+    ["@param " ++ i ++ " " ++ d | FactAttrib i d _ _ <- attribs],
+    [skate_c_fn_one_param a | a <- attribs])
+
+skate_c_fn_params :: C.TypeSpec -> String -> [C.Param]
+skate_c_fn_params t var = [C.Param t var]
+
+
+
+skate_c_fn_decls_facts :: String -> [FactAttrib] -> [C.Unit]
+skate_c_fn_decls_facts fn attribs = [
+    skate_c_fn_decl_describe fn,
+    skate_c_fn_decl_add fn p]
+        where
+            p = skate_c_fn_params_fact attribs
+
+
+
+
+-- | FunctionDef ScopeSpec TypeSpec String  [ Param ] [ Stmt ]
+-- | StaticInline TypeSpec String           [ Param ] [ Stmt ]
+-- | FunctionDecl ScopeSpec TypeSpec String [ Param ]
index 1fbc158..400e388 100644 (file)
@@ -23,6 +23,7 @@ import SkateParser
 import SkateSchema
 import SkateTypes
 import SkateBackendCommon
+import qualified SkateTypeTable as TT
 
 
 
@@ -58,28 +59,28 @@ skate_header_body sr infile =
         "Flags",
         "===================================================================="
     ], C.Blank] ++
-    (skate_c_header_decls (flags sr)) ++
+    (skate_c_header_decls (flags sr) (types sr)) ++
     [C.Blank, C.Blank] ++
     [C.MultiComment [
         "====================================================================",
         "Constants",
         "===================================================================="
     ], C.Blank] ++
-    (skate_c_header_decls (constants sr)) ++
+    (skate_c_header_decls (constants sr) (types sr)) ++
     [C.Blank, C.Blank] ++
     [C.MultiComment [
         "====================================================================",
         "Enumerations",
         "===================================================================="
     ], C.Blank] ++
-    (skate_c_header_decls (enumerations sr)) ++
+    (skate_c_header_decls (enumerations sr) (types sr)) ++
     [C.Blank, C.Blank] ++
     [C.MultiComment [
         "====================================================================",
         "Facts",
         "===================================================================="
     ], C.Blank] ++
-    (skate_c_header_decls (facts sr)) ++
+    (skate_c_header_decls (facts sr) (types sr)) ++
     [C.Blank, C.Blank]
 
 
@@ -96,7 +97,6 @@ skate_c_headerfiles [] = [C.MultiComment ["No Imports"]]
 skate_c_headerfiles imps = [C.MultiComment ["Imports"]] ++
     map (C.Include C.Standard) [ skate_c_includepath i | i <- imps ]
 
-
 {-----------------------------------------------------------------------------
 - Facts
 ------------------------------------------------------------------------------}
@@ -106,15 +106,26 @@ skate_c_header_one_attrib p e@(FactAttrib i d t sp) = [
   C.ParamDoxyComment d,
   C.Param (typeref_to_ctype t) i]
 
-skate_c_header_fact :: String -> String -> [ FactAttrib ] -> SourcePos -> [C.Unit]
-skate_c_header_fact i d attrib sp = [
-    (skate_c_type_comment "Fact" d i sp),
+
+skate_c_header_resolve_types :: TypeRef -> [TT.TTEntry] -> TypeRef
+skate_c_header_resolve_types tr@(TEnum i _) ttbl = TBuiltIn (TT.get_builtin_type i ttbl)
+skate_c_header_resolve_types tr@(TConstant i _) ttbl = TBuiltIn (TT.get_builtin_type i ttbl)
+skate_c_header_resolve_types tr@(TFlags i _) ttbl = TBuiltIn (TT.get_builtin_type i ttbl)
+skate_c_header_resolve_types tr _ = tr
+
+
+skate_c_header_fact :: String -> String -> [ FactAttrib ] -> SourcePos -> [TT.TTEntry] -> [C.Unit]
+skate_c_header_fact i d attrib sp ttbl = [
+    (skate_c_type_comment "fact" d i sp),
     C.StructDecl ttype $ concat (intersperse [C.ParamBlank] [skate_c_header_one_attrib i a | a <- attrib]),
     C.TypeDef (C.Struct ttype) ttype,
-    C.Blank]
+    C.Blank] ++ skate_c_fn_decls_facts i attrib
+    ++ [C.Blank, C.Blank, (skate_c_prolog_strings i types), C.Blank, C.Blank]
     where
         tname = (identifier_to_cname i)
         ttype = (make_type_name tname)
+        types = [skate_c_header_resolve_types t ttbl | e@(FactAttrib i d t sp) <- attrib ]
+
 
 
 {-----------------------------------------------------------------------------
@@ -134,7 +145,7 @@ skate_c_header_one_flag p f@(FlagDef i d v _) t = C.UnitList [
 
 skate_c_header_flags :: String -> String -> Integer ->[ FlagDef ] -> SourcePos -> [C.Unit]
 skate_c_header_flags i d w defs sp = [
-    (skate_c_type_comment "Flags" d i sp),
+    (skate_c_type_comment "flags" d i sp),
     C.TypeDef (C.TypeName ttype) tname,
     C.Blank]
     ++ [skate_c_header_one_flag i def (C.TypeName tname) | def <- defs]
@@ -165,7 +176,7 @@ skate_c_header_one_const p f@(ConstantDefStr i d v _) t = C.UnitList [
 
 skate_c_header_const :: String -> String -> TypeRef ->[ ConstantDef ] -> SourcePos -> [C.Unit]
 skate_c_header_const i d t@(TBuiltIn tref) defs sp = [
-    (skate_c_type_comment "Constants" d i sp),
+    (skate_c_type_comment "constants" d i sp),
     C.TypeDef (typeref_to_ctype t) tname,
     C.Blank]
     ++ [skate_c_header_one_const i def (C.TypeName tname) | def <- defs]
@@ -188,7 +199,7 @@ skate_c_header_one_enum p e@(EnumDef i d _) = C.EnumItem name d Nothing
 
 skate_c_header_enum :: String -> String -> [ EnumDef ] -> SourcePos -> [C.Unit]
 skate_c_header_enum i d defs sp = [
-    (skate_c_type_comment "Enumeration" d i sp),
+    (skate_c_type_comment "enumeration" d i sp),
     C.EnumDecl ttype [skate_c_header_one_enum i def | def <- defs],
     C.Blank]
     where
@@ -197,26 +208,46 @@ skate_c_header_enum i d defs sp = [
 
 
 
-
 {-----------------------------------------------------------------------------
 - Generic Declarations
 ------------------------------------------------------------------------------}
 
-skate_c_header_one_decl :: Declaration -> [ C.Unit ]
-skate_c_header_one_decl de@(Fact i d a sp) = skate_c_header_fact i d a sp
-skate_c_header_one_decl de@(Flags i d w f sp) = skate_c_header_flags i d w f sp
-skate_c_header_one_decl de@(Constants i d t f sp) = skate_c_header_const i d t f sp
-skate_c_header_one_decl de@(Enumeration i d f sp) = skate_c_header_enum i d f sp
-skate_c_header_one_decl _  = []
+skate_c_header_one_decl :: Declaration -> [TT.TTEntry] -> [ C.Unit ]
+skate_c_header_one_decl de@(Fact i d a sp) tt = skate_c_header_fact i d a sp tt
+skate_c_header_one_decl de@(Flags i d w f sp) _ = skate_c_header_flags i d w f sp
+skate_c_header_one_decl de@(Constants i d t f sp) _ = skate_c_header_const i d t f sp
+skate_c_header_one_decl de@(Enumeration i d f sp) _ = skate_c_header_enum i d f sp
+skate_c_header_one_decl _  _ = []
 
 
-skate_c_header_decls :: [Declaration] -> [ C.Unit ]
-skate_c_header_decls decls = [C.UnitList $ skate_c_header_one_decl d | d <- decls]
+skate_c_header_decls :: [Declaration] -> [TT.TTEntry] -> [ C.Unit ]
+skate_c_header_decls decls ttbl = [C.UnitList $ skate_c_header_one_decl d ttbl | d <- decls]
 
 skate_c_type_comment :: String -> String -> String -> SourcePos -> C.Unit
 skate_c_type_comment t desc defined sp = C.MultiDoxy [
     "@brief " ++ desc,
     "",
-    "Type: " ++ t,
-    "Defined in " ++ defined,
-    "Defined in " ++ (show sp)]
+    "Type: " ++ t ++ " " ++ defined,
+    "Defined: " ++ (show sp)]
+
+skate_c_prolog_strings :: String -> [TypeRef] -> C.Unit
+skate_c_prolog_strings i t = C.UnitList [
+    C.DoxyComment ("Prolog format string for " ++ i),
+    C.Define (make_format_name_pr cname) []  (prolog ++  wr_fmt ++ "\").\""),
+    C.Blank,
+    C.DoxyComment ("Prolog format string for " ++ i),
+    C.Define (make_format_name_rd cname) [] (prolog ++  rd_fmt ++ "\").\""),
+    C.Blank]
+    where
+        cname = (identifier_to_cname i)
+        wr_fmt = concat (intersperse " \", \" " [fmt_wr a | a <- t])
+        rd_fmt = concat (intersperse " \", \" " [fmt_rd a | a <- t])
+        prolog = "\"" ++ (identifier_to_prolog i) ++ "(\" "
+
+fmt_wr :: TypeRef -> String
+fmt_wr (TFact t _ ) = (make_format_name_pr (identifier_to_cname t))
+fmt_wr (TBuiltIn t) = builtin_fmt_wr t
+
+fmt_rd :: TypeRef -> String
+fmt_rd (TFact t _ ) = (make_format_name_rd (identifier_to_cname t))
+fmt_rd (TBuiltIn t) = builtin_fmt_rd t
index 1a6b169..6bcb32d 100644 (file)
@@ -54,6 +54,9 @@ make_table s@(Schema n d decls imps _) ttbl = do {
         flags = filter flags_filter fdecls;
         constants = filter constants_filter fdecls;
         enumerations = filter enumeration_filter fdecls;
+        -- fact_flattened = [flatten_fact_type de facts ttbl | de <- facts]
+
+
 
 
 {-
@@ -63,6 +66,7 @@ make_table s@(Schema n d decls imps _) ttbl = do {
 -}
 
 
+
 {- filter functions -}
 fact_filter :: Declaration -> Bool
 fact_filter d@(Fact _ _ _ _) = True
@@ -100,3 +104,25 @@ parseType p t x@(Enumeration i d e _) = t ++ [x]
 parseType p t x@(Namespace i d decls _) = flatten_decl_tree i (t ++ [x]) decls
 parseType p t x@(Section _ decls _) = flatten_decl_tree p t decls
 parseType p t x@(Text _ _) = t
+
+
+{- -}
+
+find_fact_filter:: String -> Declaration -> Bool
+find_fact_filter i d@(Fact id _ _ _) = (i == id)
+find_fact_filter _ _ = False
+
+flatten_one_attribute :: FactAttrib -> [Declaration] -> [TT.TTEntry]-> [FactAttrib]
+flatten_one_attribute a@(FactAttrib i d tr@(TEnum ti _) p) facts ttbl = [a]
+flatten_one_attribute a@(FactAttrib i d tr@(TConstant ti _) p) facts ttbl = [a]
+flatten_one_attribute a@(FactAttrib i d tr@(TBuiltIn ti) p) facts ttbl = [a]
+flatten_one_attribute a@(FactAttrib i d tr@(TFlags ti _) p) facts ttbl = [a]
+flatten_one_attribute a@(FactAttrib i d tr@(TFact ti _ ) p) facts ttbl = flat
+    where
+        f@(Fact fi fd fa fp) = head $ filter (find_fact_filter ti) facts;
+        flat = concat $ [flatten_one_attribute at facts ttbl | at <- fa]
+
+flatten_fact_type :: Declaration -> [Declaration] -> [TT.TTEntry] -> Declaration
+flatten_fact_type de@(Fact i d a p) facts ttbl = Fact i d a2 p
+    where
+        a2 = concat $ [flatten_one_attribute attr facts ttbl | attr <- a]
index dd22a10..1611630 100644 (file)
@@ -33,10 +33,10 @@ instance Show RecType where
     show TTEnum = "enum"
     show TTFact = "fact"
 
-data TTEntry = Rec RecType String SourcePos
+data TTEntry = Rec RecType String TypeBuiltIn SourcePos
 
 instance Show TTEntry where
-    show (Rec _ s _) = "TT.Rec: " ++ s
+    show (Rec _ s _ _) = "TT.Rec: " ++ s
 
 
 {-
@@ -66,7 +66,13 @@ exist ttbl t a = not (null (filter (type_ref_exists a t) ttbl))
 lookup ::  [TTEntry] -> String -> RecType
 lookup t a = tt
     where
-        Rec tt _  _= head (filter (typeExists a) t)
+        Rec tt _ _ _= head (filter (typeExists a) t)
+
+
+get_builtin_type :: String -> [TTEntry] -> TypeBuiltIn
+get_builtin_type a t = tt
+    where
+        Rec rt _ tt _ = head (filter (typeExists a) t)
 
 {-
 ==============================================================================
@@ -83,28 +89,28 @@ addOneTypeToTable p t [] = t
 
 {- handles each declaration and adds a type  -}
 parseType :: String -> [TTEntry] -> Declaration -> [TTEntry]
-parseType p t d@(Fact i _ _ sp) = addOneType i t TTFact sp
-parseType p t d@(Flags i _ w _ sp) = addOneType i t TTFlags sp
-parseType p t d@(Constants i _ _ _ sp) = addOneType i t TTConstant sp
-parseType p t d@(Enumeration i _ _ sp) = addOneType i t TTEnum sp
+parseType p t d@(Fact i _ _ sp) = addOneType i t TTFact UInt8 sp
+parseType p t d@(Flags i _ w _ sp) = addOneType i t TTFlags (builtin_flag_type w) sp
+parseType p t d@(Constants i _ a@(TBuiltIn tr) _ sp) = addOneType i t TTConstant tr sp
+parseType p t d@(Enumeration i _ _ sp) = addOneType i t TTEnum UInt32 sp
 parseType p t d@(Namespace i _ decls sp) = addOneTypeToTable i t decls
 parseType p t d@(Section _ decls sp) = addOneTypeToTable p t decls
 parseType p t d@(Text _ sp) = t
 
 {- boolean function that returns True iff the type record matches -}
 typeExists :: String -> TTEntry -> Bool
-typeExists a d@(Rec _ e _) = (a == e)
+typeExists a d@(Rec _ e _ _) = (a == e)
 
 {- boolean function that returns True iff the type record matches -}
 type_ref_exists :: String -> RecType -> TTEntry -> Bool
-type_ref_exists a t d@(Rec tt e _) = ((a == e) &&  (t == tt))
+type_ref_exists a t d@(Rec tt e _ _) = ((a == e) &&  (t == tt))
 
 {- adds one type to the type table -}
-addOneType :: String -> [TTEntry] -> RecType -> SourcePos -> [TTEntry]
-addOneType n recs t sp =
+addOneType :: String -> [TTEntry] -> RecType -> TypeBuiltIn -> SourcePos -> [TTEntry]
+addOneType n recs t tr sp =
     let
         existingTypes = (filter (typeExists n) recs)
     in
-    if null existingTypes then recs ++ [Rec t n sp]
+    if null existingTypes then recs ++ [Rec t n tr sp]
     else error $ "error in " ++ (show sp) ++ ": re-definition of type '" ++ n ++ "'."
                  ++ " previously defined " ++ (show (head existingTypes));
index 0a6b0c7..2ca778b 100644 (file)
@@ -16,6 +16,7 @@ module SkateTypes where
 
 import qualified CAbsSyntax as C
 
+
 data TypeBuiltIn = UInt8 | UInt16 | UInt32 | UInt64 | UIntPtr
                   | Int8 | Int16  | Int32  | Int64  | IntPtr
                   | Size | Char   | Bool   | String | Capref
@@ -31,11 +32,11 @@ data TypeRef = TEnum String String
              deriving(Eq)
 
 instance Show TypeRef where
-    show (TEnum t _) = "TEnum(" ++ t ++ ")"
-    show (TConstant t _) = "TConstant(" ++ t ++ ")"
-    show (TFact t _) = "TFact(" ++ t ++ ")"
+    show (TEnum t _ ) = "TEnum(" ++ t ++ ")"
+    show (TConstant t _ ) = "TConstant(" ++ t ++ ")"
+    show (TFact t _ ) = "TFact(" ++ t ++ ")"
     show (TBuiltIn t) = "TBuiltIn(" ++ (show t) ++ ")"
-    show (TFlags t _)  = "TFlags(" ++ t ++ ")"
+    show (TFlags t _ )  = "TFlags(" ++ t ++ ")"
 
 
 {- -}
@@ -56,27 +57,6 @@ instance Show TypeBuiltIn where
     show Char    = "char"
     show Capref  = "capref"
 
-typeref_to_ctype :: TypeRef -> C.TypeSpec
-typeref_to_ctype (TBuiltIn UInt8)   = C.TypeName "uint8_t"
-typeref_to_ctype (TBuiltIn UInt16)  = C.TypeName "uint16_t"
-typeref_to_ctype (TBuiltIn UInt32)  = C.TypeName "uint32_t"
-typeref_to_ctype (TBuiltIn UInt64)  = C.TypeName "uint64_t"
-typeref_to_ctype (TBuiltIn UIntPtr) = C.TypeName "uintptr_t"
-typeref_to_ctype (TBuiltIn Int8)    = C.TypeName "int8_t"
-typeref_to_ctype (TBuiltIn Int16)   = C.TypeName "int16_t"
-typeref_to_ctype (TBuiltIn Int32)   = C.TypeName "int32_t"
-typeref_to_ctype (TBuiltIn Int64)   = C.TypeName "int64_t"
-typeref_to_ctype (TBuiltIn IntPtr)  = C.TypeName "intptr_t"
-typeref_to_ctype (TBuiltIn Size)    = C.TypeName "size_t"
-typeref_to_ctype (TBuiltIn Bool)    = C.TypeName "bool"
-typeref_to_ctype (TBuiltIn String)  = C.Ptr (C.TypeName "char")
-typeref_to_ctype (TBuiltIn Char)    = C.TypeName "char"
-typeref_to_ctype (TBuiltIn Capref)  = C.Struct "capref"
-typeref_to_ctype (TEnum i _)        = C.TypeName "TODO: SkateTypes.hs" -- (make_type_name (identifier_to_cname i))
-typeref_to_ctype (TConstant i _)    = C.TypeName "TODO: SkateTypes.hs" -- (make_type_name (identifier_to_cname i))typeref_to_ctype (TFact i _)        = C.TypeName "TODO: SkateTypes.hs" -- (make_type_name (identifier_to_cname i))
-typeref_to_ctype (TFlags i _)       = C.TypeName "TODO: SkateTypes.hs" -- (make_type_name (identifier_to_cname i))
-
-
 
 instance Read TypeBuiltIn where
     readsPrec _ = \s -> case s of
@@ -116,8 +96,6 @@ findBuiltIntType "capref" = Capref
 findBuiltIntType s = error  $ "Undefined builtin type " ++ s
 
 
-
-
 builtin_fmt_wr :: TypeBuiltIn -> String
 builtin_fmt_wr (UInt8)   = "PRIu8"
 builtin_fmt_wr (UInt16)  = "PRIu16"
@@ -130,9 +108,9 @@ builtin_fmt_wr (Int32)   = "PRIi32"
 builtin_fmt_wr (Int64)   = "PRIi64"
 builtin_fmt_wr (IntPtr)  = "PRIuPTR"
 builtin_fmt_wr (Size)    = "PRIuSIZE"
-builtin_fmt_wr (Bool)    = "\"i\""
-builtin_fmt_wr (String)  = "\"s\""
-builtin_fmt_wr (Char)    = "\"c\""
+builtin_fmt_wr (Bool)    = "\"%i\""
+builtin_fmt_wr (String)  = "\"%s\""
+builtin_fmt_wr (Char)    = "\"%c\""
 
 
 builtin_fmt_rd :: TypeBuiltIn -> String
@@ -147,9 +125,9 @@ builtin_fmt_rd (Int32)   = "SCNi32"
 builtin_fmt_rd (Int64)   = "SCNi64"
 builtin_fmt_rd (IntPtr)  = "SCNuPTR"
 builtin_fmt_rd (Size)    = "SCNuSIZE"
-builtin_fmt_rd (Bool)    = "\"i\""
-builtin_fmt_rd (String)  = "\"s\""
-builtin_fmt_rd (Char)    = "\"c\""
+builtin_fmt_rd (Bool)    = "\"%i\""
+builtin_fmt_rd (String)  = "\"%s\""
+builtin_fmt_rd (Char)    = "\"%c\""
 
 builtin_get_bits:: TypeBuiltIn -> Integer
 builtin_get_bits (UInt8)   = 8
@@ -165,3 +143,9 @@ builtin_get_bits (IntPtr)  = 64 -- xxx: make this arch specific!
 builtin_get_bits (Size)    = 64 -- xxx: make this arch specific!
 builtin_get_bits (Bool)    = 8
 builtin_get_bits (Char)    = 8
+
+builtin_flag_type :: Integer -> TypeBuiltIn
+builtin_flag_type 64 = UInt64
+builtin_flag_type 32 = UInt32
+builtin_flag_type 16 = UInt16
+builtin_flag_type  8 = UInt8