-- @@ Autogenerated from WinDll. Do NOT modify unless you know what you're doing.
{-# LANGUAGE ForeignFunctionInterface #-}
{-# LANGUAGE UndecidableInstances #-}

module HsParser where

import WinDll.Lib.NativeMapping
import WinDll.Lib.Tuples
import WinDll.Lib.InstancesTypes
import Foreign
import Foreign.C
import Foreign.Ptr
import Foreign.Marshal.Alloc
import Foreign.Marshal.Utils
import Foreign.ForeignPtr
import Control.Monad
import Control.Monad.Instances
import VsxParser
import GhcSession
import Lexer
import SrcLoc
import FastString
import GHC hiding (ModuleInfo, Type, Instance, Warning, ClassDecl, DataType)
import OccName
import Name
import Var
import DataCon
import Type hiding (Type)
import TyCon
import Class
import Foreign.StablePtr
import HscTypes
import Data.IORef

#let alignment t = "%lu", (unsigned long)offsetof(struct {char x__; t (y__); }, y__)

#include "HsParser.h"

#enum Int,,cApiResultsApiOk = cApiResultsApiOk,cApiResultsApiFail = cApiResultsApiFail
#enum Int,,cMaybeNothing = cMaybeNothing,cMaybeJust = cMaybeJust

type ErrorMessagePtr = (Ptr ErrorMessage)
type ModuleInfoPtr = (Ptr ModuleInfo)
type InformationPtr = (Ptr Information)
type ClassDeclPtr = (Ptr ClassDecl)
type DataTypePtr = (Ptr DataType)
type FunTypePtr = (Ptr FunType)
type ImportPtr = (Ptr Import)
type ConstructorPtr = (Ptr Constructor)
type InstancePtr = (Ptr Instance)
type TypePtr = (Ptr Type)
type ForeignDclPtr = (Ptr ForeignDcl)
type WarningPtr = (Ptr Warning)
type ApiResultsPtr a= (Ptr ((ApiResults a)))
type SrcSpanPtr = (Ptr (SrcSpan))
type FastStringPtr = (Ptr (FastString))
type IORefPtr a1= (Ptr ((IORef a1)))
type HscEnvPtr = (Ptr (HscEnv))

foreign export stdcall "getModuleInfoByPath" getModInfoA :: StablePtr (IORef HscEnv) -> CInt -> CInt -> CWString -> CWString -> CWString -> IO ((ApiResultsPtr ModuleInfo))
foreign export stdcall "createContext" createContextA :: IO (StablePtr (IORef HscEnv))
foreign export stdcall "freeContext" freeContextA :: StablePtr (IORef HscEnv) -> IO (())

getModInfoA :: StablePtr (IORef HscEnv) -> CInt -> CInt -> CWString -> CWString -> CWString -> IO ((ApiResultsPtr ModuleInfo))
getModInfoA a1 a2 a3 a4 a5 a6 = toFFI $ getModInfo (fromFFI a1) (fromFFI a2) (fromFFI a3) (fromFFI a4) (fromFFI a5) (fromFFI a6)

createContextA :: IO (StablePtr (IORef HscEnv))
createContextA  = toFFI $ createContext

freeContextA :: StablePtr (IORef HscEnv) -> IO (())
freeContextA a1 = toFFI $ freeContext (fromFFI a1)

instance Storable ErrorMessage where
    sizeOf    _ = 12
    alignment _ = #alignment ErrorMessage_t
    
    poke ptr (ErrorMessage a1 a2 a3) = do
        (#poke ErrorMessage_t, msg_span) ptr (toFFI a1 :: SrcSpanPtr)
        (#poke ErrorMessage_t, short_msg) ptr (toFFI a2 :: CWString)
        (#poke ErrorMessage_t, long_msg) ptr (toFFI a3 :: CWString)

    peek ptr = do 
        a1' <- (#peek ErrorMessage_t, msg_span) ptr :: IO SrcSpanPtr
        a2' <- (#peek ErrorMessage_t, short_msg) ptr :: IO CWString
        a3' <- (#peek ErrorMessage_t, long_msg) ptr :: IO CWString
        return $ ErrorMessage (fromFFI a1' :: SrcSpan) (fromFFI a2' :: String) (fromFFI a3' :: String)

instance Storable ModuleInfo where
    sizeOf    _ = 44
    alignment _ = #alignment ModuleInfo_t
    
    poke ptr (ModuleInfo a1 a2 a3 a4 a5 a6 a7 a8 a9 a10 a11) = do
        (#poke ModuleInfo_t, generalInfo) ptr (toFFI a1 :: ((MaybePtr Information)))
        (#poke ModuleInfo_t, functions) ptr (toFFI a2 :: ((Tuple2Ptr CInt ((Ptr (FunTypePtr))))))
        (#poke ModuleInfo_t, imports) ptr (toFFI a3 :: ((Tuple2Ptr CInt ((Ptr (ImportPtr))))))
        (#poke ModuleInfo_t, constructors) ptr (toFFI a4 :: ((Tuple2Ptr CInt ((Ptr (ConstructorPtr))))))
        (#poke ModuleInfo_t, instances) ptr (toFFI a5 :: ((Tuple2Ptr CInt ((Ptr (InstancePtr))))))
        (#poke ModuleInfo_t, types) ptr (toFFI a6 :: ((Tuple2Ptr CInt ((Ptr (TypePtr))))))
        (#poke ModuleInfo_t, classes) ptr (toFFI a7 :: ((Tuple2Ptr CInt ((Ptr (ClassDeclPtr))))))
        (#poke ModuleInfo_t, datatypes) ptr (toFFI a8 :: ((Tuple2Ptr CInt ((Ptr (DataTypePtr))))))
        (#poke ModuleInfo_t, foreigns) ptr (toFFI a9 :: ((Tuple2Ptr CInt ((Ptr (ForeignDclPtr))))))
        (#poke ModuleInfo_t, warnings) ptr (toFFI a10 :: ((Tuple2Ptr CInt ((Ptr (WarningPtr))))))
        (#poke ModuleInfo_t, srcWarnings) ptr (toFFI a11 :: ((Tuple2Ptr CInt ((Ptr (ErrorMessagePtr))))))

    peek ptr = do 
        a1' <- (#peek ModuleInfo_t, generalInfo) ptr :: IO ((MaybePtr Information))
        a2' <- (#peek ModuleInfo_t, functions) ptr :: IO ((Tuple2Ptr CInt ((Ptr (FunTypePtr)))))
        a3' <- (#peek ModuleInfo_t, imports) ptr :: IO ((Tuple2Ptr CInt ((Ptr (ImportPtr)))))
        a4' <- (#peek ModuleInfo_t, constructors) ptr :: IO ((Tuple2Ptr CInt ((Ptr (ConstructorPtr)))))
        a5' <- (#peek ModuleInfo_t, instances) ptr :: IO ((Tuple2Ptr CInt ((Ptr (InstancePtr)))))
        a6' <- (#peek ModuleInfo_t, types) ptr :: IO ((Tuple2Ptr CInt ((Ptr (TypePtr)))))
        a7' <- (#peek ModuleInfo_t, classes) ptr :: IO ((Tuple2Ptr CInt ((Ptr (ClassDeclPtr)))))
        a8' <- (#peek ModuleInfo_t, datatypes) ptr :: IO ((Tuple2Ptr CInt ((Ptr (DataTypePtr)))))
        a9' <- (#peek ModuleInfo_t, foreigns) ptr :: IO ((Tuple2Ptr CInt ((Ptr (ForeignDclPtr)))))
        a10' <- (#peek ModuleInfo_t, warnings) ptr :: IO ((Tuple2Ptr CInt ((Ptr (WarningPtr)))))
        a11' <- (#peek ModuleInfo_t, srcWarnings) ptr :: IO ((Tuple2Ptr CInt ((Ptr (ErrorMessagePtr)))))
        return $ ModuleInfo (fromFFI a1' :: (Maybe Information)) (fromFFI a2' :: ((Int, [FunType]))) (fromFFI a3' :: ((Int, [Import]))) (fromFFI a4' :: ((Int, [Constructor]))) (fromFFI a5' :: ((Int, [Instance]))) (fromFFI a6' :: ((Int, [Type]))) (fromFFI a7' :: ((Int, [ClassDecl]))) (fromFFI a8' :: ((Int, [DataType]))) (fromFFI a9' :: ((Int, [ForeignDcl]))) (fromFFI a10' :: ((Int, [Warning]))) (fromFFI a11' :: ((Int, [ErrorMessage])))

instance Storable Information where
    sizeOf    _ = 4
    alignment _ = #alignment Information_t
    
    poke ptr (Information a1) = do
        (#poke Information_t, _importSpan) ptr (toFFI a1 :: SrcSpanPtr)

    peek ptr = do 
        a1' <- (#peek Information_t, _importSpan) ptr :: IO SrcSpanPtr
        return $ Information (fromFFI a1' :: SrcSpan)

instance Storable ClassDecl where
    sizeOf    _ = 16
    alignment _ = #alignment ClassDecl_t
    
    poke ptr (ClassDecl a1 a2 a3 a4) = do
        (#poke ClassDecl_t, _CDSpan) ptr (toFFI a1 :: SrcSpanPtr)
        (#poke ClassDecl_t, _CDname) ptr (toFFI a2 :: CWString)
        (#poke ClassDecl_t, _context) ptr (toFFI a3 :: ((Tuple2Ptr CInt ((Ptr (CWString))))))
        (#poke ClassDecl_t, _head) ptr (toFFI a4 :: ((Tuple2Ptr CInt ((Ptr (CWString))))))

    peek ptr = do 
        a1' <- (#peek ClassDecl_t, _CDSpan) ptr :: IO SrcSpanPtr
        a2' <- (#peek ClassDecl_t, _CDname) ptr :: IO CWString
        a3' <- (#peek ClassDecl_t, _context) ptr :: IO ((Tuple2Ptr CInt ((Ptr (CWString)))))
        a4' <- (#peek ClassDecl_t, _head) ptr :: IO ((Tuple2Ptr CInt ((Ptr (CWString)))))
        return $ ClassDecl (fromFFI a1' :: SrcSpan) (fromFFI a2' :: String) (fromFFI a3' :: ((Int, [String]))) (fromFFI a4' :: ((Int, [String])))

instance Storable DataType where
    sizeOf    _ = 12
    alignment _ = #alignment DataType_t
    
    poke ptr (DataType a1 a2 a3) = do
        (#poke DataType_t, _Dspan) ptr (toFFI a1 :: SrcSpanPtr)
        (#poke DataType_t, _Dname) ptr (toFFI a2 :: CWString)
        (#poke DataType_t, _isNewtype) ptr (toFFI a3 :: CInt)

    peek ptr = do 
        a1' <- (#peek DataType_t, _Dspan) ptr :: IO SrcSpanPtr
        a2' <- (#peek DataType_t, _Dname) ptr :: IO CWString
        a3' <- (#peek DataType_t, _isNewtype) ptr :: IO CInt
        return $ DataType (fromFFI a1' :: SrcSpan) (fromFFI a2' :: String) (fromFFI a3' :: Bool)

instance Storable FunType where
    sizeOf    _ = 28
    alignment _ = #alignment FunType_t
    
    poke ptr (FunType a1 a2 a3 a4 a5 a6 a7) = do
        (#poke FunType_t, _Tspan) ptr (toFFI a1 :: SrcSpanPtr)
        (#poke FunType_t, _Tname) ptr (toFFI a2 :: CWString)
        (#poke FunType_t, _type) ptr (toFFI a3 :: ((MaybePtr String)))
        (#poke FunType_t, _body) ptr (toFFI a4 :: ((MaybePtr SrcSpan)))
        (#poke FunType_t, _isMethod) ptr (toFFI a5 :: CInt)
        (#poke FunType_t, _isExplicit) ptr (toFFI a6 :: CInt)
        (#poke FunType_t, _inline) ptr (toFFI a7 :: (Tuple2Ptr CInt ((Ptr (FunTypePtr)))))

    peek ptr = do 
        a1' <- (#peek FunType_t, _Tspan) ptr :: IO SrcSpanPtr
        a2' <- (#peek FunType_t, _Tname) ptr :: IO CWString
        a3' <- (#peek FunType_t, _type) ptr :: IO ((MaybePtr String))
        a4' <- (#peek FunType_t, _body) ptr :: IO ((MaybePtr SrcSpan))
        a5' <- (#peek FunType_t, _isMethod) ptr :: IO CInt
        a6' <- (#peek FunType_t, _isExplicit) ptr :: IO CInt
        a7' <- (#peek FunType_t, _inline) ptr :: IO (Tuple2Ptr CInt ((Ptr (FunTypePtr))))
        return $ FunType (fromFFI a1' :: SrcSpan) (fromFFI a2' :: String) (fromFFI a3' :: (Maybe String)) (fromFFI a4' :: (Maybe SrcSpan)) (fromFFI a5' :: Bool) (fromFFI a6' :: Bool) (fromFFI a7' :: (Int, [FunType]))

instance Storable Import where
    sizeOf    _ = 28
    alignment _ = #alignment Import_t
    
    poke ptr (Import a1 a2 a3 a4 a5 a6 a7) = do
        (#poke Import_t, _Ispan) ptr (toFFI a1 :: SrcSpanPtr)
        (#poke Import_t, _Iname) ptr (toFFI a2 :: CWString)
        (#poke Import_t, _pkg) ptr (toFFI a3 :: ((MaybePtr String)))
        (#poke Import_t, _source) ptr (toFFI a4 :: CInt)
        (#poke Import_t, _qual) ptr (toFFI a5 :: CInt)
        (#poke Import_t, _as) ptr (toFFI a6 :: ((MaybePtr String)))
        (#poke Import_t, _hiding) ptr (toFFI a7 :: ((MaybePtr ((Int, [String])))))

    peek ptr = do 
        a1' <- (#peek Import_t, _Ispan) ptr :: IO SrcSpanPtr
        a2' <- (#peek Import_t, _Iname) ptr :: IO CWString
        a3' <- (#peek Import_t, _pkg) ptr :: IO ((MaybePtr String))
        a4' <- (#peek Import_t, _source) ptr :: IO CInt
        a5' <- (#peek Import_t, _qual) ptr :: IO CInt
        a6' <- (#peek Import_t, _as) ptr :: IO ((MaybePtr String))
        a7' <- (#peek Import_t, _hiding) ptr :: IO ((MaybePtr ((Int, [String]))))
        return $ Import (fromFFI a1' :: SrcSpan) (fromFFI a2' :: String) (fromFFI a3' :: (Maybe String)) (fromFFI a4' :: Bool) (fromFFI a5' :: Bool) (fromFFI a6' :: (Maybe String)) (fromFFI a7' :: (Maybe ((Int, [String]))))

instance Storable Constructor where
    sizeOf    _ = 12
    alignment _ = #alignment Constructor_t
    
    poke ptr (Constructor a1 a2 a3) = do
        (#poke Constructor_t, _Cspan) ptr (toFFI a1 :: SrcSpanPtr)
        (#poke Constructor_t, _Cname) ptr (toFFI a2 :: CWString)
        (#poke Constructor_t, _Ctype) ptr (toFFI a3 :: CWString)

    peek ptr = do 
        a1' <- (#peek Constructor_t, _Cspan) ptr :: IO SrcSpanPtr
        a2' <- (#peek Constructor_t, _Cname) ptr :: IO CWString
        a3' <- (#peek Constructor_t, _Ctype) ptr :: IO CWString
        return $ Constructor (fromFFI a1' :: SrcSpan) (fromFFI a2' :: String) (fromFFI a3' :: String)

instance Storable Instance where
    sizeOf    _ = 8
    alignment _ = #alignment Instance_t
    
    poke ptr (Instance a1 a2) = do
        (#poke Instance_t, _Ixspan) ptr (toFFI a1 :: SrcSpanPtr)
        (#poke Instance_t, _Ixname) ptr (toFFI a2 :: CWString)

    peek ptr = do 
        a1' <- (#peek Instance_t, _Ixspan) ptr :: IO SrcSpanPtr
        a2' <- (#peek Instance_t, _Ixname) ptr :: IO CWString
        return $ Instance (fromFFI a1' :: SrcSpan) (fromFFI a2' :: String)

instance Storable Type where
    sizeOf    _ = 8
    alignment _ = #alignment Type_t
    
    poke ptr (Type a1 a2) = do
        (#poke Type_t, _Txspan) ptr (toFFI a1 :: SrcSpanPtr)
        (#poke Type_t, _Txname) ptr (toFFI a2 :: CWString)

    peek ptr = do 
        a1' <- (#peek Type_t, _Txspan) ptr :: IO SrcSpanPtr
        a2' <- (#peek Type_t, _Txname) ptr :: IO CWString
        return $ Type (fromFFI a1' :: SrcSpan) (fromFFI a2' :: String)

instance Storable ForeignDcl where
    sizeOf    _ = 16
    alignment _ = #alignment ForeignDcl_t
    
    poke ptr (ForeignDcl a1 a2 a3 a4) = do
        (#poke ForeignDcl_t, _Fspan) ptr (toFFI a1 :: SrcSpanPtr)
        (#poke ForeignDcl_t, _import) ptr (toFFI a2 :: CInt)
        (#poke ForeignDcl_t, _Fname) ptr (toFFI a3 :: CWString)
        (#poke ForeignDcl_t, _Ftype) ptr (toFFI a4 :: CWString)

    peek ptr = do 
        a1' <- (#peek ForeignDcl_t, _Fspan) ptr :: IO SrcSpanPtr
        a2' <- (#peek ForeignDcl_t, _import) ptr :: IO CInt
        a3' <- (#peek ForeignDcl_t, _Fname) ptr :: IO CWString
        a4' <- (#peek ForeignDcl_t, _Ftype) ptr :: IO CWString
        return $ ForeignDcl (fromFFI a1' :: SrcSpan) (fromFFI a2' :: Bool) (fromFFI a3' :: String) (fromFFI a4' :: String)

instance Storable Warning where
    sizeOf    _ = 12
    alignment _ = #alignment Warning_t
    
    poke ptr (Warning a1 a2 a3) = do
        (#poke Warning_t, _Wspan) ptr (toFFI a1 :: SrcSpanPtr)
        (#poke Warning_t, _Wname) ptr (toFFI a2 :: CWString)
        (#poke Warning_t, _msg) ptr (toFFI a3 :: ((Tuple2Ptr CInt ((Ptr (CWString))))))

    peek ptr = do 
        a1' <- (#peek Warning_t, _Wspan) ptr :: IO SrcSpanPtr
        a2' <- (#peek Warning_t, _Wname) ptr :: IO CWString
        a3' <- (#peek Warning_t, _msg) ptr :: IO ((Tuple2Ptr CInt ((Ptr (CWString)))))
        return $ Warning (fromFFI a1' :: SrcSpan) (fromFFI a2' :: String) (fromFFI a3' :: ((Int, [FastString])))

instance Storable ModuleInfo => Storable (ApiResults ModuleInfo) where
    sizeOf    _ = 20
    alignment _ = #alignment ApiResults_t
    
    poke ptr (ApiOk a1) = do
        (#poke ApiResults_t, tag) ptr cApiResultsApiOk
        newptr659112 <- malloc :: IO (Ptr (ApiResults ModuleInfo))
        (#poke ApiOk_t, apiresults_apiok_var1) newptr659112 (toFFI a1 :: ModuleInfoPtr)
        (#poke ApiResults_t, elt) ptr newptr659112

    poke ptr (ApiFail a1 a2 a3) = do
        (#poke ApiResults_t, tag) ptr cApiResultsApiFail
        newptr659112 <- malloc :: IO (Ptr (ApiResults ModuleInfo))
        (#poke ApiFail_t, apiresults_apifail_var1) newptr659112 (toFFI a1 :: CInt)
        (#poke ApiFail_t, apiresults_apifail_var2) newptr659112 (toFFI a2 :: (Ptr (ErrorMessagePtr)))
        (#poke ApiFail_t, apiresults_apifail_var3) newptr659112 (toFFI a3 :: ((MaybePtr ModuleInfo)))
        (#poke ApiResults_t, elt) ptr newptr659112

    peek ptr = do 
        tag' <- (#peek ApiResults_t, tag) ptr :: IO CInt
        case tag' of
          0 -> do
            a1' <- (#peek ApiOk_t, apiresults_apiok_var1) ptr :: IO ModuleInfoPtr
            return $ ApiOk (fromFFI a1' :: ModuleInfo)
          1 -> do
            a1' <- (#peek ApiFail_t, apiresults_apifail_var1) ptr :: IO CInt
            a2' <- (#peek ApiFail_t, apiresults_apifail_var2) ptr :: IO (Ptr (ErrorMessagePtr))
            a3' <- (#peek ApiFail_t, apiresults_apifail_var3) ptr :: IO ((MaybePtr ModuleInfo))
            return $ ApiFail (fromFFI a1' :: Int) (fromFFI a2' :: [ErrorMessage]) (fromFFI a3' :: (Maybe ModuleInfo))

instance Storable ModuleInfo => Storable (Maybe ModuleInfo) where
    sizeOf    _ = 12
    alignment _ = #alignment Maybe_t
    
    poke ptr Nothing = do
        (#poke Maybe_t, tag) ptr cMaybeNothing
        newptr659112 <- malloc :: IO (Ptr (Maybe ModuleInfo))
        (#poke Maybe_t, elt) ptr newptr659112

    poke ptr (Just a1) = do
        (#poke Maybe_t, tag) ptr cMaybeJust
        newptr659112 <- malloc :: IO (Ptr (Maybe ModuleInfo))
        (#poke Just_t, maybe_just_var1) newptr659112 (toFFI a1 :: ModuleInfoPtr)
        (#poke Maybe_t, elt) ptr newptr659112

    peek ptr = do 
        tag' <- (#peek Maybe_t, tag) ptr :: IO CInt
        case tag' of
          0 -> do
            return $ Nothing 
          1 -> do
            a1' <- (#peek Just_t, maybe_just_var1) ptr :: IO ModuleInfoPtr
            return $ Just (fromFFI a1' :: ModuleInfo)

instance Storable Information => Storable (Maybe Information) where
    sizeOf    _ = 12
    alignment _ = #alignment Maybe_t
    
    poke ptr Nothing = do
        (#poke Maybe_t, tag) ptr cMaybeNothing
        newptr659112 <- malloc :: IO (Ptr (Maybe Information))
        (#poke Maybe_t, elt) ptr newptr659112

    poke ptr (Just a1) = do
        (#poke Maybe_t, tag) ptr cMaybeJust
        newptr659112 <- malloc :: IO (Ptr (Maybe Information))
        (#poke Just_t, maybe_just_var1) newptr659112 (toFFI a1 :: InformationPtr)
        (#poke Maybe_t, elt) ptr newptr659112

    peek ptr = do 
        tag' <- (#peek Maybe_t, tag) ptr :: IO CInt
        case tag' of
          0 -> do
            return $ Nothing 
          1 -> do
            a1' <- (#peek Just_t, maybe_just_var1) ptr :: IO InformationPtr
            return $ Just (fromFFI a1' :: Information)

instance Storable CWString => Storable (Maybe String) where
    sizeOf    _ = 12
    alignment _ = #alignment Maybe_t
    
    poke ptr Nothing = do
        (#poke Maybe_t, tag) ptr cMaybeNothing
        newptr659112 <- malloc :: IO (Ptr (Maybe String))
        (#poke Maybe_t, elt) ptr newptr659112

    poke ptr (Just a1) = do
        (#poke Maybe_t, tag) ptr cMaybeJust
        newptr659112 <- malloc :: IO (Ptr (Maybe String))
        (#poke Just_t, maybe_just_var1) newptr659112 (toFFI a1 :: CWString)
        (#poke Maybe_t, elt) ptr newptr659112

    peek ptr = do 
        tag' <- (#peek Maybe_t, tag) ptr :: IO CInt
        case tag' of
          0 -> do
            return $ Nothing 
          1 -> do
            a1' <- (#peek Just_t, maybe_just_var1) ptr :: IO CWString
            return $ Just (fromFFI a1' :: String)

instance Storable SrcSpan => Storable (Maybe SrcSpan) where
    sizeOf    _ = 12
    alignment _ = #alignment Maybe_t
    
    poke ptr Nothing = do
        (#poke Maybe_t, tag) ptr cMaybeNothing
        newptr659112 <- malloc :: IO (Ptr (Maybe SrcSpan))
        (#poke Maybe_t, elt) ptr newptr659112

    poke ptr (Just a1) = do
        (#poke Maybe_t, tag) ptr cMaybeJust
        newptr659112 <- malloc :: IO (Ptr (Maybe SrcSpan))
        (#poke Just_t, maybe_just_var1) newptr659112 (toFFI a1 :: SrcSpanPtr)
        (#poke Maybe_t, elt) ptr newptr659112

    peek ptr = do 
        tag' <- (#peek Maybe_t, tag) ptr :: IO CInt
        case tag' of
          0 -> do
            return $ Nothing 
          1 -> do
            a1' <- (#peek Just_t, maybe_just_var1) ptr :: IO SrcSpanPtr
            return $ Just (fromFFI a1' :: SrcSpan)

instance Storable ((CInt, [CWString])) => Storable (Maybe ((Int, [String]))) where
    sizeOf    _ = 12
    alignment _ = #alignment Maybe_t
    
    poke ptr Nothing = do
        (#poke Maybe_t, tag) ptr cMaybeNothing
        newptr659112 <- malloc :: IO (Ptr (Maybe ((Int, [String]))))
        (#poke Maybe_t, elt) ptr newptr659112

    poke ptr (Just a1) = do
        (#poke Maybe_t, tag) ptr cMaybeJust
        newptr659112 <- malloc :: IO (Ptr (Maybe ((Int, [String]))))
        (#poke Just_t, maybe_just_var1) newptr659112 (toFFI a1 :: ((Tuple2Ptr CInt ((Ptr (CWString))))))
        (#poke Maybe_t, elt) ptr newptr659112

    peek ptr = do 
        tag' <- (#peek Maybe_t, tag) ptr :: IO CInt
        case tag' of
          0 -> do
            return $ Nothing 
          1 -> do
            a1' <- (#peek Just_t, maybe_just_var1) ptr :: IO ((Tuple2Ptr CInt ((Ptr (CWString)))))
            return $ Just (fromFFI a1' :: ((Int, [String])))