So      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghi j k l m n o p q r s t u v w x y z { | } ~   Safe-Inferred   portable  experimental tamar@zhox.com  Safe-Inferred A simple stack implementation *Pretty print a stack back out to a string Creating an empty stack #Create a new stack from a template *Adding an element to the top of the stack ,Remove an element from the top of the stack ALook at the item at the top of the stack, but does not remove it ;The size of the stack e.g the amount of elements inside it GShrinks and Compress the stack, reducing the stack to the bare minimum  of steps/)calls needed to represent the same stack        portable  experimental tamar@zhox.com None The allocation structure/1record that is used to keep track of allocations DIdentifier which shows which function was invoked to do allocations 0The directory in which to write the results to. )The file to write the results too *Synchronization variable between threads. 5Write out a single allocation structure out to file.        portable  experimental tamar@zhox.com NonePRe-export of the Foreign.Marshal.Alloc.alloca function taking an explicit stack PRe-export of the Foreign.Marshal.Alloc.malloc function taking an explicit stack cRe-export of the Foreign.Marshal.Alloc.realloc function taking an explicit stack EThis function record the allocation information about a Ptr we couldn' t override it's allocation function for. !This function mirrors record* in its function. Except that the value it'!s given might not be a ptr value "AFree a ptr that is not a normal Ptr type, (e.g. ForeignPtr etc) #BFree a ptr that is not a normal Ptr type, (e.g. ForeignPtr etc), I however it does not record the size of the value held by the pointer. 8 as such, it has no need for the Storable requirement $PRe-export of the Foreign.Marshal.Alloc.free function taking an explicit stack  !"#$ !"#$ !"#$ !"#$ portable  experimental tamar@zhox.com None%&'(%&'(%&'(%&'(portable experimentaltamar@zhox.comNone)*+,-.)*+,-.+,-.*))*+,-.portable experimentaltamar@zhox.com Safe-Inferred0List containing mapping to C/ C++ Types 1#Contains a list of mapping types. 8 This is the first list to be extended by the pragmas 7 We need to preserve the Haskell type name for later  transformations and for FFI 2List of type conversion from C/C++ to C# types 3List containing mapping to C# Types 4#List containing mapping to CSizes /012345/012345/012345/012345portable experimentaltamar@zhox.comNone6\Annotated type, basically a 4-tuple that holds all possible information on a datatype field 8FThe field name, if this is a record the name will be the record name. 9#The preprocessed type of the field :%The type annotations for the antType ;!The original unpreprocessed type <,The module that originally defined the type =HAnnotation on functions, This allows more complex types to be expressed ?KOffsets into the type list to indicate which fields are counters for lists @-Indicates if the field type is a List type. AIndices/COffsets to indicate whether this function has any StablePtr values BBCopy of the definition list for the Haskell translation functions C<Copy of the definition list for the C translation functions DBCopy of the definition list for the C sizes translation functions E%Copy of the definition list for the C# translation functions F9Indicates is debugging has been enabled for this session RGeneric empty annotation S8Find any Names embedded within any arbitraty structures !6789:;<=>?@ABCDEFGHIJKLMNOPQRS6789:;<=>?@ABCDEFGHIJKLMNOPQRSQPONMLKJIH=>?@ABCDEFG6789:;<RS6789:;<= >?@ABCDEFGHIJKLMNOPQRSportable experimentaltamar@zhox.comNone#T1Tranform functions to and from the correct types Q TODO: Update this variant to use the impure variants, This will be an issue.. > TODO: Can this even be defined using the native functions?  This instance can't be generated. It'&ll stay here for now, buy it can only & be used by types which define toFFIfromFFI instead of toNative fromNative H instance (FFIType a b, FFIType c d) => FFIType (a -> c) (b -> d) where 0 toFFI st f x = toFFI st (f (fromFFI st x)) . fromFFI st f x = fromFFI st (f (toFFI st x)) W0A class that manages the conversion between the normal and type supported by ffi. C Minimal implementation requires atleast one of the pair toNativetoFFI and fromNative fromFFI. f The implementation will almost always call fromNative and toNative because all exported functions m are in IO since they all might have side-effects. The only exception to this is for the defaults provided  in this module. ^`Typeclase to allow Left LoaD transform. It is basically to allow a transformation to take place  at the last argument/Nreturn type of the function. This is because most of the functions are in IO. `(Tuples are not FFI compatible, As such i'/ll translate them to a build in tuple datatype  . W This function translates the embedded types of a Ty to the correct forms using the  function translate' (see below) aGTranslate everything but applied types. e.g. Foo Token -> FooPtr Token : And lists, since lists are implicitly an applied type:  e.g [Token] -->> [] Token -->> Ptr Token bFCheck to see if the next type is a Simple type. e.g. A TyVar or TyCon cIContrary to translate translatePrimitive will only transform the defined  primitive types in the convList +below. This is because while a transformed X signature should only be partially transformed till the first application (Since that'll be e the main pointer) we should pre-transform the primitive types into their well known static forms. dOHelper function to define translatePrimitive. It attemps to lookup the type in convList but  in the case where it'*s not found the search query is returned. ePTranslate Partial Form, This is basically translatePrimitive . translatePartial f[Look up the FFI type representation of the given type. Moreover when the type is not found N it is assumed to be a new structure and it is assumed to be a pointer value. g"Remove all spaces from a sentence h>A function to split a list of elements by the given seperator Instance for Functor classes  TODO: rewrite this. @ instance (Functor f, FFIType a b) => FFIType (f a) (f b) where  toFFI st = fmap (toFFI st)  fromFFI st = fmap (fromFFI st) =Convertion instance for Integer types to CLLongs (long long) *Simplistic instance of Storable for list. " untested but (new [(1::Int)..10]. >>=return.castPtr >>= peekArray 10 :: IO [Int] ) works GOne way instance for returning lists as the result of a function call. K We assume to have an int* as an argument and then fill that in with the  length @Cover lists to array convertion IF the type is also an FFI type RAny class implementing Storable has implemented enough to be considered a FFIType CInstance for unboxed integers, which are first boxed then returned % instance FFIType FastInt CInt where  toFFI = toFFI . iBox  fromFFI = iUnbox . fromFFI Fix float instances EFix integers from the machine dependend values to fixed 32bit values (Convert between FastString and CWString RAnother simple identity instance, I really need to get that overlapping instances  looked at. RAnother simple identity instance, I really need to get that overlapping instances  looked at. RAnother simple identity instance, I really need to get that overlapping instances  looked at. RAnother simple identity instance, I really need to get that overlapping instances  looked at. RAnother simple identity instance, I really need to get that overlapping instances  looked at. >Intermediate conversion instance for storing values of arrays QI decided to use a CWString because on windows this gives me a constant 16 value A FunPtr instance A StorablePtr instance [Convert booleans to Int8 to save space for use when using the ccall or stdcall conventions \Convert booleans to Word8 to save space for use when using the ccall or stdcall conventions NConvert booleans to Cints for use when using the ccall or stdcall conventions 4Numeral values are all also already FFI values, If I'%ve read the documentation correctly @ Due to GHC matching only the instance heads this instance can'(t unfortunately be used. (Booo bad GHC) % instance Num a => FFIType a a where  toFFI = const id  fromFFI = const id -Booleans are by default already an FFI value PDefault values needed to satisfy .NET marshaller when having unused structures. 2 class FFIType phi ix => FFIDefaults phi ix where  class Default phi where  nDefault :: phi +Wrapper functions for dealing with FunPtrs R wrapFn :: (FFIType (IO a) ca, FFIType b (IO cb)) => (a -> IO b) -> (ca -> IO cb) & wrapFn fn = fromFFI >=> fn >=> toFFI Dedicated instance for () 7TUVWXYZ[\]^_`abcdefghTUVWXYZ[\]^_`abcdefgh^_WXYZ[\]TUV`abcdefgh.TUVWXYZ[\]^_`abcdefgh portable experimentaltamar@zhox.comNone8ijklmnopqrstuvwxyz{|}ijklmnopqrstuvwxyz{|}|}z{xyvwturspqonmlkji1ijklmnopqrstuvwxyz{|} portable experimentaltamar@zhox.comNone#~1Tranform functions to and from the correct types Q TODO: Update this variant to use the impure variants, This will be an issue.. > TODO: Can this even be defined using the native functions?  This instance can't be generated. It'&ll stay here for now, buy it can only & be used by types which define toFFIfromFFI instead of toNative fromNative H instance (FFIType a b, FFIType c d) => FFIType (a -> c) (b -> d) where * toFFI f x = toFFI (f (fromFFI x)) ( fromFFI f x = fromFFI (f (toFFI x)) 0A class that manages the conversion between the normal and type supported by ffi. C Minimal implementation requires atleast one of the pair toNativetoFFI and fromNative fromFFI. f The implementation will almost always call fromNative and toNative because all exported functions m are in IO since they all might have side-effects. The only exception to this is for the defaults provided  in this module. `Typeclase to allow Left LoaD transform. It is basically to allow a transformation to take place  at the last argument/Nreturn type of the function. This is because most of the functions are in IO. (Tuples are not FFI compatible, As such i'/ll translate them to a build in tuple datatype  . W This function translates the embedded types of a Ty to the correct forms using the  function translate' (see below) GTranslate everything but applied types. e.g. Foo Token -> FooPtr Token : And lists, since lists are implicitly an applied type:  e.g [Token] -->> [] Token -->> Ptr Token FCheck to see if the next type is a Simple type. e.g. A TyVar or TyCon IContrary to translate translatePrimitive will only transform the defined  primitive types in the convList +below. This is because while a transformed X signature should only be partially transformed till the first application (Since that'll be e the main pointer) we should pre-transform the primitive types into their well known static forms. OHelper function to define translatePrimitive. It attemps to lookup the type in convList but  in the case where it'*s not found the search query is returned. PTranslate Partial Form, This is basically translatePrimitive . translatePartial [Look up the FFI type representation of the given type. Moreover when the type is not found N it is assumed to be a new structure and it is assumed to be a pointer value. "Remove all spaces from a sentence >A function to split a list of elements by the given seperator Instance for Functor classes  TODO: rewrite this. @ instance (Functor f, FFIType a b) => FFIType (f a) (f b) where  toFFI = fmap (toFFI )  fromFFI = fmap (fromFFI ) =Convertion instance for Integer types to CLLongs (long long)  *Simplistic instance of Storable for list. " untested but (new [(1::Int)..10]. >>=return.castPtr >>= peekArray 10 :: IO [Int] ) works  GOne way instance for returning lists as the result of a function call. K We assume to have an int* as an argument and then fill that in with the  length  @Cover lists to array convertion IF the type is also an FFI type  RAny class implementing Storable has implemented enough to be considered a FFIType  CInstance for unboxed integers, which are first boxed then returned % instance FFIType FastInt CInt where  toFFI = toFFI . iBox  fromFFI = iUnbox . fromFFI Fix float instances EFix integers from the machine dependend values to fixed 32bit values (Convert between FastString and CWString RAnother simple identity instance, I really need to get that overlapping instances  looked at. RAnother simple identity instance, I really need to get that overlapping instances  looked at. RAnother simple identity instance, I really need to get that overlapping instances  looked at. RAnother simple identity instance, I really need to get that overlapping instances  looked at. RAnother simple identity instance, I really need to get that overlapping instances  looked at. >Intermediate conversion instance for storing values of arrays QI decided to use a CWString because on windows this gives me a constant 16 value A FunPtr instance A StorablePtr instance [Convert booleans to Int8 to save space for use when using the ccall or stdcall conventions \Convert booleans to Word8 to save space for use when using the ccall or stdcall conventions NConvert booleans to Cints for use when using the ccall or stdcall conventions 4Numeral values are all also already FFI values, If I'%ve read the documentation correctly @ Due to GHC matching only the instance heads this instance can'(t unfortunately be used. (Booo bad GHC) % instance Num a => FFIType a a where  toFFI = id  fromFFI = id -Booleans are by default already an FFI value PDefault values needed to satisfy .NET marshaller when having unused structures. 2 class FFIType phi ix => FFIDefaults phi ix where  class Default phi where  nDefault :: phi +Wrapper functions for dealing with FunPtrs R wrapFn :: (FFIType (IO a) ca, FFIType b (IO cb)) => (a -> IO b) -> (ca -> IO cb) & wrapFn fn = fromFFI >=> fn >=> toFFI Dedicated instance for () 7~      !"#$%&'(~~.~      !"#$%&'( portable experimentaltamar@zhox.comNone8)*+,-./0123456789:;<=>?@ABCDEFGHIJK1)*+,-./0123456789:;<=>?@ABCDEFGHIJK portable experimentaltamar@zhox.com Safe-InferredL !"#$%&'()*+,-./0123456789:;<=>?@ABCCDEFGHIIJKLMNOPQRSTUVWXYZ[\]^__`abcdefghijklmnopqr s t u v w x y z z { { | | } } ~ ~     _ _ ` a b c d e f g h i j k l m n o p q r s t u v w x y z z { { | | } } ~ ~      Hs2lib-0.6.0WinDll.Debug.StackWinDll.Debug.RecordsWinDll.Debug.AllocWinDll.Debug.ExportsWinDll.Lib.InstancesTypesWinDll.Lib.NativeWinDll.Structs.TypesWinDll.Lib.NativeMapping_DebugWinDll.Lib.Tuples_DebugWinDll.Lib.NativeMappingWinDll.Lib.Tuples Paths_Hs2libWinDll.Lib.Converter StackabletoStackStack FunctionName printStack emptyStacknewStack pushStackpopStacktopStack sizeStack shrinkStackMemAllocMemFreememFunmemStackmemStartmemStopmemSizememTimeCallerRecordOtherReAllocAllocMallocfileName writeMemAllocallocamallocreallocrecordrecordM freeDefault freeUnknownfreefreeSfreeCrecordSrecordC EitherPtrMaybePtr maybenothing maybejust eitherleft eitherrightDefsnativeLisths2cnativeConvListnativeC2cslist nativeCslist nativeC_sizesdefaultPointerSizeAnnTypeantNameantTypeantAnn antOrigType antModuleAnnannArrayIndicesannArrayIsListannStableIndices annWorkingSetannWorkingSetCannWorkingSetCSizeannWorkingSetCsannDebug annModuleTypes AnnNamedTypes NamedTypes TypeNamesTypeNameType ExportNameImport ModuleNameNamenoAnn findStrings'PurepureFFITypetoFFIfromFFIfromList fromNativetoNativefreeFFILLDlld translatetranslatePartial isSimpleTypetranslatePrimitive translatePtranslatePForm translate'trimsplit Tuple8Ptr Tuple7Ptr Tuple6Ptr Tuple5Ptr Tuple4Ptr Tuple3Ptr Tuple2PtrTuple8Tuple7Tuple6Tuple5Tuple4Tuple3Tuple2catchIOversionbindirlibdirdatadir libexecdir sysconfdir getBinDir getLibDir getDataDir getLibexecDir getSysconfDirgetDataFileNameRecursedCombinedThenEmpty $fStackable[]$fStackableStack directoryfileLockMemSize PtrLocation $fShow(->)$fEq(->) $fMonoidAnn$fFFITypeCharCChar$fFFITypeIntegera $fStorable[]$fFFIType[](->)$fFFIType[]Ptr $fFFITypeaPtr$fFFITypeFloatCFloat$fFFITypeIntCInt$fFFITypeFastStringPtr$fFFITypeCLLongCLLong$fFFITypeCDoubleCDouble$fFFITypeCIntCInt$fFFITypePtrPtr$fFFITypeCWcharCWchar$fFFIType[]Ptr0$fFFIType[]Ptr1$fFFITypeFunPtrFunPtr$fFFITypeStablePtrStablePtr$fFFITypeBoolInt8$fFFITypeBoolWord8$fFFITypeBoolCInt$fFFITypeBoolBool $fFFIType()()$fFFITypeCharCWchar$fFFITypeRatioCDouble$fFFITypePurePure$fFFITypePurePure0$fFFITypePurePure1$fFFITypePurePure2$fFFITypePurePure3$fFFITypePurePure4$fFFITypePurePure5$fFFITypePurePure6 $fLLD(->)abIO$fStorable(,,,,,,,)$fStorable(,,,,,,)$fStorable(,,,,,)$fStorable(,,,,)$fStorable(,,,)$fStorable(,,) $fStorable(,)$fStorableTuple8$fStorableTuple7$fStorableTuple6$fStorableTuple5$fStorableTuple4$fStorableTuple3$fStorableTuple2$fFFIType(,,,,,,,)Ptr$fFFIType(,,,,,,)Ptr$fFFIType(,,,,,)Ptr$fFFIType(,,,,)Ptr$fFFIType(,,,)Ptr$fFFIType(,,)Ptr$fFFIType(,)Ptr$fFFIType(,,,,,,,)Tuple8$fFFIType(,,,,,,)Tuple7$fFFIType(,,,,,)Tuple6$fFFIType(,,,,)Tuple5$fFFIType(,,,)Tuple4$fFFIType(,,)Tuple3$fFFIType(,)Tuple2$fFunctorTuple8$fFunctorTuple7$fFunctorTuple6$fFunctorTuple5$fFunctorTuple4$fFunctorTuple3$fFunctorTuple2