h,a{      !"#$%&'()*+,-./0123456789:;<=>?@ABCD E F G H I J K L M N O P Q R S T U V W X Y 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 { | } ~                                                                                                      !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!"""""""""""""#########$$$$$$$$%%&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&'''''''''''''''''''''''''''%%%%%%(((((((((()))))))))***++,,--------------------------------------------...////////0001222222222222222222222334445566666670.26.137None" Safe-Inferred"x haskell-giTry asking pkg-config for the version of a given module, and return the package name together with its version. haskell-giGet the pkg-config name and associated installed version of a given gobject-introspection namespace. Since the mapping is not one-to-one some guessing is involved, although in most cases the required information is listed in the GIR file. Safe-Inferred"|  haskell-giDefault list of extensions to turn on when compiling the generated code.  haskell-giExtensions that will be used in some modules, but we do not wish to turn on by default.  haskell-gi6Default options for GHC when compiling generated code.  haskell-gi%Default version of the report to use. haskell-giList of dependencies for all bindings. Notice that base is not included here, since not all bindings use the same base version. haskell-gi and haskell-gi-base are not included either, since the versions to use may change depending on whether we are using old style or new style bindings. haskell-giUnder which category in hackage should the generated bindings be listed.        Safe-Inferred"  haskell-giConstruct the  representation of a showable. haskell-gi3Capitalize the first character of the given string. haskell-gi7Make the first character of the given string lowercase. haskell-giApply the given modification function to the given symbol. If the symbol is qualified the modification will only apply to the last component. haskell-gi:Split a list into sublists delimited by the given element. haskell-giRead a file assuming it is UTF-8 encoded. If decoding fails this calls . haskell-giWrite the given  into an UTF-8 encoded file. haskell-gi+Print a (colored) warning message to stderr haskell-giThrow an error with the given .  None" haskell-giA path to a module.! haskell-gi9Construct a path into the given GIR namespace. The given  will be split along ".".Examples"dotModulePath (toModulePath "Foo")"Foo"/dotModulePath ("Foo" <> toModulePath "Bar.Baz") "Foo.Bar.Baz"/dotModulePath ("Foo" <> toModulePath "bar.baz") "Foo.Bar.Baz"" haskell-giTurn a module path into the corresponding dotted string. Note that the implementation ensures that the module names start with a capital letter.Examples'dotModulePath ("Foo" /. "Bar" /. "Baz") "Foo.Bar.Baz"'dotModulePath ("foo" /. "bar" /. "baz") "Foo.Bar.Baz"# haskell-gi4Append the given component to the given module path.ExamplesdotModulePath ("Foo" /. "Bar") "Foo.Bar"$ haskell-gi Construct a  from a .#"!  !#"None "1"* haskell-giExtra info about a field in a struct or union which is not easily determined from the GIR file. (And which we determine by using libgirepository.)- haskell-gi Wrapper for  GITypelib5, remembering the originating namespace and version. haskell-gi Wrapper for  GIBaseInfo haskell-giAdd the given directory to the typelib search path, this is a thin wrapper over .. haskell-giA convenience function for setting up the typelib search path from the environment. Note that for efficiency reasons this should only be called once per program run. If the list of paths passed in is empty, the environment variable HASKELL_GI_TYPELIB_SEARCH_PATH will be checked. In either case the system directories will be searched after the passed in directories./ haskell-giEnsure that the given version of the namespace is loaded. If that is not possible we error out. haskell-giFind a given baseinfo by name, or give an error if it cannot be found. haskell-gi.Get the extra information for the given field.0 haskell-giFind out the size of a struct, and the map from field names to offsets inside the struct.1 haskell-giFind out the size of a union, and the map from field names to offsets inside the union. haskell-giTry to load a symbol from the dynamic library associated to the given typelib. haskell-giLoad a symbol from the dynamic library associated to the given typelib. If the symbol does not exist this will raise an error.2 haskell-giLoad a GType given the -, where it lives and the type init function.3 haskell-gi=8:9 ;=8:9@  Safe-Inferred"*3D haskell-giThis type represents the types found in GObject Introspection interfaces: the types of constants, arguments, etc.F haskell-giGErrorG haskell-giGVariantH haskell-giGValueI haskell-gi GParamSpecJ haskell-gi>Zero terminated, Array Fixed Size, Array Length, Element TypeK haskell-giGArrayL haskell-gi GPtrArrayM haskell-gi GByteArrayN haskell-giGListO haskell-giGSListP haskell-gi GHashTableQ haskell-gi,GClosure containing the given API (if known)R haskell-gi"A reference to some API in the GIRS haskell-giBasic types. These are generally trivial to marshal, and the GIR assumes that they are defined.T haskell-gigbooleanU haskell-gigintV haskell-giguintW haskell-giglongX haskell-gigulongY haskell-gigint8Z haskell-giguint8[ haskell-gigint16\ haskell-giguint16] haskell-gigint32^ haskell-giguint32_ haskell-gigint64` haskell-giguint64a haskell-gigfloatb haskell-gigdoublec haskell-gigunichard haskell-giGTypee haskell-gigchar*, encoded as UTF-8f haskell-gigchar*, encoding a filenameg haskell-gigpointerh haskell-gigintptri haskell-giguintptrj haskell-gigshortk haskell-gigushortl haskell-gigsizem haskell-gigssizen haskell-gitime_to haskell-gioff_tp haskell-gidev_tq haskell-gigid_tr haskell-gipid_ts haskell-gi socklen_tt haskell-giuid_tu haskell-gi,An alias, which is simply (Namespace, name).w haskell-gi*Transfer mode for an argument or property.{ haskell-gi"Name for a symbol in the GIR file.;uvSTbfadU[]_YhWgmjlV\^`ZiXkecpqorsnt{|}~wyzxDEMJFKQPNOHRILG;{}|~wxyzuvDREFGHIJKLMNOPQSTUVWXYZ[\]^_`abcdefghijklmnopqrst  Safe-Inferred".M  haskell-giA type constructor. We single out some specific constructors since they have special syntax in their Haskell representation. haskell-giA fully applied type. haskell-gi9Give a valid Haskell source representation of the given . haskell-giReturn a textual representation of the type constructor for the given . haskell-gi,Type constructor applied to the given types. haskell-gi7A shorthand for a type constructor taking no arguments. haskell-gi Embed in the  monad. haskell-giA Ptr to the type. haskell-giA FunPtr to the type. haskell-gi Embed in the  monad.:STbfadU[]_YhWgmjlV\^`ZiXkecpqorsntDEMJFKQPNOHRILG:DREFGHIJKLMNOPQSTUVWXYZ[\]^_`abcdefghijklmnopqrst  Safe-Inferred"q?> haskell-giThe indent parsing mode. In strict mode we require that all the text in the lines is indented relative to the label, as in the following example: .The first line, and the second lineIn this mode we allow empty lines in the entry. 2. This is the second entry.In lenient mode we drop this restriction, so the following is valid: 1. The first line, and the second line In this mode we _do not_ allow empty lines in the entry. 2. This is the second entry. haskell-gi0A parsed gtk-doc with fully resolved references. haskell-giReference to a name (of a class, for instance) in the documentation. It can be either relative to the module where the documentation is, of in some other namespace. haskell-gi(The symbol without a namespace specified haskell-giNamespace and symbol haskell-gi&A reference to some symbol in the API. haskell-gi(The language for an embedded code block. haskell-giA link to a resource, either offline or a section of the documentation. haskell-giA parsed gtk-doc token. haskell-giAn unnumbered list of items. haskell-giA list of numbered list items. The first element in the pair is the index. haskell-gi$A section header of the given depth. haskell-gi0Parse the given gtk-doc formatted documentation.ExamplesparseGtkDoc "" GtkDoc []parseGtkDoc "func()"*GtkDoc [SymbolRef (OldFunctionRef "func")]parseGtkDoc "literal"GtkDoc [Literal "literal"]$parseGtkDoc "This is a long literal")GtkDoc [Literal "This is a long literal"])parseGtkDoc "Call foo() for free cookies"GtkDoc [Literal "Call ",SymbolRef (OldFunctionRef "foo"),Literal " for free cookies"]parseGtkDoc "The signal ::activate is related to gtk_button_activate()."GtkDoc [Literal "The signal ",SymbolRef (LocalSignalRef "activate"),Literal " is related to ",SymbolRef (OldFunctionRef "gtk_button_activate"),Literal "."]parseGtkDoc "The signal ##%#GtkButton::activate is related to gtk_button_activate()."GtkDoc [Literal "The signal ##%",SymbolRef (OldSignalRef "GtkButton" "activate"),Literal " is related to ",SymbolRef (OldFunctionRef "gtk_button_activate"),Literal "."]5parseGtkDoc "# A section\n\n## and a subsection ##\n"GtkDoc [SectionHeader 1 (GtkDoc [Literal "A section"]),Literal "\n",SectionHeader 2 (GtkDoc [Literal "and a subsection "])]8parseGtkDoc "Compact list:\n- First item\n- Second item"GtkDoc [Literal "Compact list:\n",UnnumberedList [GtkDoc [Literal "First item"],GtkDoc [Literal "Second item"]]];parseGtkDoc "Spaced list:\n\n- First item\n\n- Second item"GtkDoc [Literal "Spaced list:\n\n",UnnumberedList [GtkDoc [Literal "First item"],GtkDoc [Literal "Second item"]]]parseGtkDoc "List with urls:\n- [test](http://test)\n- ![](image.png)"GtkDoc [Literal "List with urls:\n",UnnumberedList [GtkDoc [ExternalLink (Link {linkName = "test", linkAddress = "http://test"})],GtkDoc [Image (Link {linkName = "", linkAddress = "image.png"})]]] haskell-giLike ., but it does not annotate beginning of lines. haskell-giA character indicating the start of the string, to simplify the GtkDoc parser (part of the syntax is sensitive to the start of lines, which we can represent as any character after 'n' or SOS). haskell-giRemove the SOS marker from the input. Since this only appears at the beginning of the text, we only need to worry about replacing it in the first token, and only if it's a literal. haskell-gi6Accumulate consecutive literals into a single literal. haskell-giParser for tokens. haskell-giParse a single token. This can sometimes return more than a single token, when parsing a logical token produces multiple output tokens (for example when keeping the initial structure requires adding together literals and other tokens).Examples-parseOnly (parseToken <* endOfInput) "func()")Right [SymbolRef (OldFunctionRef "func")] haskell-gi7Whether the given character is valid in a C identifier. haskell-giSomething that could be a valid C identifier (loosely speaking, we do not need to be too strict here). haskell-giParse a function ref haskell-giParse an unresolved reference to a C symbol in new gtk-doc notation. haskell-giParse a function ref, given by a valid C identifier followed by (), for instance 'gtk_widget_show()'. If the identifier is not followed by "()", return it as a literal instead.Examples8parseOnly (parseFunctionRef <* endOfInput) "test_func()".Right [SymbolRef (OldFunctionRef "test_func")]7parseOnly (parseFunctionRef <* endOfInput) "not_a_func"Right [Literal "not_a_func"] haskell-giParse a function name in new style, of the form > [func@Namespace.c_func_name]Examples [method@Namespace.Object.c_func_name]ExamplesparseOnly (parseMethod <* endOfInput) "[method@Gtk.Button.set_child]"Right [SymbolRef (MethodRef (AbsoluteName "Gtk" "Button") "set_child")]parseOnly (parseMethod <* endOfInput) "[func@Gtk.Settings.get_for_display]"Right [SymbolRef (MethodRef (AbsoluteName "Gtk" "Settings") "get_for_display")] haskell-giParse a reference to a constructor, of the form > [ctor@Namespace.Object.c_func_name]ExamplesparseOnly (parseConstructor <* endOfInput) "[ctor@Gtk.Builder.new_from_file]"Right [SymbolRef (MethodRef (AbsoluteName "Gtk" "Builder") "new_from_file")] haskell-gi2Parse a reference to a type, of the form > [class3Namespace.Name] an interface of the form > [ifaceNamespace.Name] or an enumeration type, of the form > [enum@Namespace.Name]Examples9parseOnly (parseClass <* endOfInput) "[class@Gtk.Dialog]"9Right [SymbolRef (TypeRef (AbsoluteName "Gtk" "Dialog"))];parseOnly (parseClass <* endOfInput) "[iface@Gtk.Editable]";Right [SymbolRef (TypeRef (AbsoluteName "Gtk" "Editable"))]parseOnly (parseClass <* endOfInput) "[enum@Gtk.SizeRequestMode]"Right [SymbolRef (TypeRef (AbsoluteName "Gtk" "SizeRequestMode"))] [enum@Gtk.FontRendering.AUTOMATIC]ExamplesparseOnly (parseEnumMember <* endOfInput) "[enum@Gtk.FontRendering.AUTOMATIC]"Right [SymbolRef (EnumMemberRef (AbsoluteName "Gtk" "FontRendering") "automatic")] haskell-gi>Parse an old style signal name, of the form > #Object::signalExamples?parseOnly (parseOldSignal <* endOfInput) "#GtkButton::activate"7Right [SymbolRef (OldSignalRef "GtkButton" "activate")] haskell-giParse a new style signal ref, of the form > [signal@Namespace.Object::signal-name]ExamplesparseOnly (parseNewSignal <* endOfInput) "[signal@Gtk.AboutDialog::activate-link]"Right [SymbolRef (SignalRef (AbsoluteName "Gtk" "AboutDialog") "activate-link")] haskell-giParse a reference to a signal defined in the current module, of the form > ::signalExamples7parseOnly (parseLocalSignal <* endOfInput) "::activate"-Right [SymbolRef (LocalSignalRef "activate")] haskell-giParse a property name in the old style, of the form > #Object:propertyExamplesparseOnly (parseOldProperty <* endOfInput) "#GtkButton:always-show-image"Right [SymbolRef (OldPropertyRef "GtkButton" "always-show-image")] haskell-giParse a property name in the new style: > [property@Namespace.Object:property-name]ExamplesparseOnly (parseNewProperty <* endOfInput) "[property@Gtk.ProgressBar:show-text]"Right [SymbolRef (PropertyRef (AbsoluteName "Gtk" "ProgressBar") "show-text")]parseOnly (parseNewProperty <* endOfInput) "[property@Gtk.Editable:width-chars]"Right [SymbolRef (PropertyRef (AbsoluteName "Gtk" "Editable") "width-chars")] haskell-giParse a property haskell-gi%Parse an xml comment, of the form >  !-- comment --' Note that this function keeps spaces.Examples9parseOnly (parseComment <* endOfInput) ""Right [Comment " comment "] haskell-giParse an old style reference to a virtual method, of the form > #Struct.method()Examples6parseOnly (parseOldVMethod <* endOfInput) "#Foo.bar()"*Right [SymbolRef (VMethodRef "Foo" "bar")] haskell-giParse a new style reference to a virtual function, of the form > [vfunc@Namespace.Object.vfunc_name]parseOnly (parseVFunc <* endOfInput) "[vfunc@Gtk.Widget.get_request_mode]"Right [SymbolRef (VFuncRef (AbsoluteName "Gtk" "Widget") "get_request_mode")] haskell-gi%Parse a reference to a virtual method haskell-giParse a reference to a struct field, of the form > #Struct.fieldExamples5parseOnly (parseStructField <* endOfInput) "#Foo.bar".Right [SymbolRef (StructFieldRef "Foo" "bar")] haskell-gi3Parse a reference to a C type, of the form > #TypeExamples+parseOnly (parseCType <* endOfInput) "#Foo""Right [SymbolRef (CTypeRef "Foo")] haskell-gi/Parse a constant, of the form > %CONSTANT_NAMEExamples8parseOnly (parseConstant <* endOfInput) "%TEST_CONSTANT"/Right [SymbolRef (ConstantRef "TEST_CONSTANT")] haskell-gi @param_nameExamples2parseOnly (parseParam <* endOfInput) "@test_param")Right [SymbolRef (ParamRef "test_param")] haskell-giName of a signal or property name. Similar to a C identifier, but hyphens are allowed too. haskell-gi8Parse a escaped special character, i.e. one preceded by '\'. haskell-giParse a literal, i.e. anything without a known special meaning. Note that this parser always consumes the first character, regardless of what it is. haskell-giList of special characters from the point of view of the parser (in the sense that they may be the beginning of something with a special interpretation). haskell-gi7Parse a verbatim string, of the form > `verbatim text`Examples:parseOnly (parseVerbatim <* endOfInput) "`Example quote!`"!Right [Verbatim "Example quote!"] haskell-gi/Parse a URL in Markdown syntax, of the form > urlnameExamplesparseOnly (parseUrl <* endOfInput) "[haskell](http://haskell.org)"Right [ExternalLink (Link {linkName = "haskell", linkAddress = "http://haskell.org"})] haskell-gi)Parse an image reference, of the form > urllabelExamples7parseOnly (parseImage <* endOfInput) "![](diagram.png)"Right [Image (Link {linkName = "", linkAddress = "diagram.png"})] haskell-gi1Parse a code block embedded in the documentation. haskell-giParse a new style code block, of the form > ```c > some c code > ```ExamplesparseOnly (parseNewStyleCodeBlock <* endOfInput) "```c\nThis is C code\n```"8Right [CodeBlock (Just (Language "c")) "This is C code"]parseOnly (parseNewStyleCodeBlock <* endOfInput) "```\nThis is langless\n```",Right [CodeBlock Nothing "This is langless"]parseOnly (parseNewStyleCodeBlock <* endOfInput) " ```py\n This has space in front\n ```"Right [CodeBlock (Just (Language "py")) " This has space in front"]parseOnly (parseNewStyleCodeBlock <* endOfInput) " ```c\n new_type_id = g_type_register_dynamic (parent_type_id,\n \"TypeName\",\n new_type_plugin,\n type_flags);\n ```"Right [CodeBlock (Just (Language "c")) " new_type_id = g_type_register_dynamic (parent_type_id,\n \"TypeName\",\n new_type_plugin,\n type_flags);"] haskell-gi0Parse an old style code block, of the form > |[ !--language="C" -- code ]|ExamplesparseOnly (parseOldStyleCodeBlock <* endOfInput) "|[this is code]|"(Right [CodeBlock Nothing "this is code"]parseOnly (parseOldStyleCodeBlock <* endOfInput) "|[this is C code]|"8Right [CodeBlock (Just (Language "C")) "this is C code"] haskell-gi;Parse the language of a code block, specified as a comment. haskell-giParse at least one newline (or Start of String (SOS)), and keep going while we see newlines. Return either the empty list (for the case that we see a single SOS), or a singleton list with the Literal representing the seen newlines, and removing the SOS. haskell-giParse a section header, given by a number of hash symbols, and then ordinary text. Note that this parser "eats" the newline before and after the section header. haskell-giParse a section header at the beginning of the text. I.e. this is the same as 7, but we do not expect a newline as a first character.ExamplesparseOnly (parseInitialSectionHeader <* endOfInput) "### Hello! ###\n"4Right [SectionHeader 3 (GtkDoc [Literal "Hello! "])]parseOnly (parseInitialSectionHeader <* endOfInput) "# Hello!\n"3Right [SectionHeader 1 (GtkDoc [Literal "Hello!"])] haskell-giParse an unnumbered list.Examples:{parseOnly (parseUnnumberedList <* endOfInput) $ T.stripEnd $ T.unlines [T.cons startOfString"- First item","- Second item"]:}Right [UnnumberedList [GtkDoc [Literal "First item"],GtkDoc [Literal "Second item"]]]:{ parseOnly (parseUnnumberedList <* endOfInput) $ T.stripEnd $ T.unlines ["","", "- Two line", " item","","- Second item,"," with three lines", " of text."]:}Right [Literal "\n\n",UnnumberedList [GtkDoc [Literal "Two line\nitem"],GtkDoc [Literal "Second item,\nwith three lines\nof text."]]] haskell-giParse a numbered list header.Examples:{ parseOnly (parseNumberedList <* endOfInput) $ T.stripEnd $ T.unlines [T.cons startOfString"1. First item,"," written in two lines","","2. Second item,"," also in two lines"]:}Right [NumberedList [("1",GtkDoc [Literal "First item,\nwritten in two lines"]),("2",GtkDoc [Literal "Second item,\nalso in two lines"])]]:{ parseOnly (parseNumberedList <* endOfInput) $ T.stripEnd $ T.unlines [T.cons startOfString"1. First item,"," written in two lines","2. Second item,"," now in three lines,"," written compactly"]:}Right [NumberedList [("1",GtkDoc [Literal "First item,\nwritten in two lines"]),("2",GtkDoc [Literal "Second item,\nnow in three lines,\nwritten compactly"])]]:{parseOnly (parseNumberedList <* endOfInput) $ T.stripEnd $ T.unlines [T.cons startOfString*"9. This is a list entry with two lines,",+" with the second line in its own line.",""10. If the label width changes,"," the indentation of the second line should also be adjusted.","",?"11. You can optionally include an empty line between entries",!" without stopping the list.",""," This also applies within list entries, this is still part of"," entry 11.","12. But you don't have to."]:}Right [NumberedList [("9",GtkDoc [Literal "This is a list entry with two lines,\nwith the second line in its own line."]),("10",GtkDoc [Literal "If the label width changes,\nthe indentation of the second line should also be adjusted."]),("11",GtkDoc [Literal "You can optionally include an empty line between entries\nwithout stopping the list.\n\nThis also applies within list entries, this is still part of\nentry 11."]),("12",GtkDoc [Literal "But you don't have to."])]]:{&parseGtkDoc $ T.stripEnd $ T.unlines [""1. A list with a single element","",:"And this is text not in the list, so we use parseGtkDoc."]:}GtkDoc [NumberedList [("1",GtkDoc [Literal "A list with a single element"])],Literal "\n\nAnd this is text not in the list, so we use parseGtkDoc."]:{ parseOnly (parseNumberedList <* endOfInput) $ T.stripEnd $ T.unlines [T.cons startOfString+"1. An example of a list in lenient mode,",5"where we don't require indenting this second line.","","2. In this mode entries can be optionally separated by an empty line.","3. But they don't need to"]:}Right [NumberedList [("1",GtkDoc [Literal "An example of a list in lenient mode,\nwhere we don't require indenting this second line."]),("2",GtkDoc [Literal "In this mode entries can be optionally separated by an empty line."]),("3",GtkDoc [Literal "But they don't need to"])]] haskell-gi*Parse an unnumbered or numbered list. See  and  for examples. haskell-giTurn an ordinary { into a  haskell-gi Return a { from a potentially relative , using the provided default namespace if the name is relative.** None"t haskell-gi:Split a list into sublists delimited by the given element. haskell-gi-Return the paths where to look for gir files. haskell-gi:Construct the GIR search path, possibly looking into the HASKELL_GI_GIR_SEARCH_PATH environment variable if no explicit list of extra paths is given. In either case the system data dirs are also searched if nothing can be found in the explicitly passed paths, or in the contents of HASKELL_GI_GIR_SEARCH_PATH. haskell-giSearch for an appropriate .gir file in the search path. haskell-giTry to load the `.gir` file corresponding to the given repository haskell-giverbose haskell-giname haskell-giversion haskell-gi searchPath None"x  haskell-giGIR namespaces we know about. haskell-gi>Turn a node into an element (if it is indeed an element node). haskell-giFind all children of the given element which are XML Elements themselves. haskell-giThe local name of an element. haskell-gi,Restrict to those with the given local name. haskell-gi"Restrict to those with given name. haskell-gi1Find the first child element with the given name. haskell-gi1Get the content of a given element, if it exists. haskell-gi4Lookup an attribute for an element (with no prefix). haskell-gi;Return the text representation of the known GIR namespaces. haskell-giLookup an attribute for an element, given the namespace where it lives. haskell-gi Construct a 89 by only giving the local name. haskell-gi Construct a 89 specifying a namespace too.None"z, haskell-giDocumentation for a given element. The documentation text is typically encoded in the gtk-doc format, see  +https://developer.gnome.org/gtk-doc-manual/ . This can be parsed with :;. haskell-giParse the documentation node for the given element of the GIR file.None"z haskell-gi$Deprecation information on a symbol. haskell-giParse the deprecation information for the given element of the GIR file.None"& haskell-giMonad where parsers live: we carry a context around, and can throw errors that abort the parsing. haskell-giMark whether the methods can be resolved in the given typelib. haskell-giCheck that the symbol the function refers to is actually present in the dynamic library. haskell-gi6Load and parse a GIR file, including its dependencies. haskell-giGiven a XML document containing GIR data, apply the given overrides. haskell-giLooks for the given path in the given subelements of the given element. If the path is empty apply the corresponding rule, otherwise return the element ummodified. haskell-giSet an attribute for the child element specified by the given path. haskell-giDelete an attribute for the child element specified by the given path, if the attribute exists. haskell-gi:Add the given subnode to any nodes matching the given path haskell-gi)Delete any nodes matching the given path. haskell-giLookup the given attribute and if present see if it matches the given regex. haskell-gi=8:9{|}~wyzx{}|~wxyz;=8:9@"None"(2 haskell-giKnown operating systems. haskell-giWe have a bit of context (the current namespace), and can fail, encode this in a monad. haskell-gi"The state of the overrides parser. haskell-giThe contents of the override file will be ignored if there is any  value here. if( primitive push (prepend) values here, endif pop them. haskell-giThe current namespace. haskell-gi&Known places where to find the C docs. haskell-giFixups for the GIR data. haskell-gi"Prefered version of the namespace. haskell-gi0Version number for the generated .cabal package. haskell-gi;Mapping from GObject Introspection namespaces to pkg-config haskell-gi-Explicit calloc/copy/free for structs/unions. haskell-gi9Structs for which accessors should not be auto-generated. haskell-gi?Ignored APIs (all elements in this API will just be discarded). haskell-gi Ignored elements of a given API. haskell-gi*Construct the generic config for a module. haskell-gi$Addition of overrides is meaningful. haskell-giDefault, empty, parser state. haskell-giGet the current namespace. haskell-gi8Run the given parser only if the flags can be satisfied. haskell-giParse the given overrides, filling in the configuration as needed. In case the parsing fails we return a description of the error instead. haskell-giParse a single line of the config file, modifying the configuration as appropriate. haskell-giIgnored elements. haskell-giSealed structures. haskell-gi.Explicit allocation info for wrapped pointers. haskell-gi:Parse a explicit key=value pair into a (key, value) tuple. haskell-gi?. haskell-giCheck that the given pkg-config package has a version compatible with the given constraint. haskell-giParse a 'if' directive. haskell-gi Parse an endif directive. haskell-giParse the given overrides file, and merge into the given context. haskell-giFilter a set of named objects based on a lookup list of names to ignore. haskell-giGiven the previous allocation info, and a new allocation info, replace those entries in the old allocation info which are specified in the new info. haskell-gi-Filter one API according to the given config. haskell-gi?Given a list of APIs modify them according to the given config. haskell-giLoad a given API, applying filtering. Load also any necessary dependencies. haskell-giThere is a sensible notion of zero and addition of Overridess, encode this so that we can view the parser as a writer monad of configs. haskell-giThere is a sensible notion of zero and addition of Overridess, encode this so that we can view the parser as a writer monad of configs.#None" haskell-gi0List of loaded overrides for the code generator. haskell-giWhether to print extra info. haskell-gi9Version of the haskell package ("3.0.35", "2.0.21", ...). haskell-gi:Haskell package being generated (gi-gtk, gi-gobject, ...). haskell-giVersion of the GIR API for the package being generated ("3.0", "2.0", ...). haskell-gi;GIR name of the module being generated (Gtk, GObject, ...).$None"O haskell-gi7Remove functions and methods annotated with "moved-to". haskell-giDrop the moved methods. haskell-giGObject-introspection does not currently support nullability annotations, so we try to guess the nullability from the nullability annotations of the curresponding get/set methods, which in principle should be reliable. haskell-gi2Guess nullability for the properties of an object. haskell-gi5Guess nullability for the properties of an interface. haskell-giGuess the nullability for a property, given the list of methods for the object/interface. haskell-giGuess whether "get" on the given property may return NULL, based on the corresponding "get_prop_name" method, if it exists. haskell-giGuess whether "set" on the given property may return NULL, based on the corresponding "set_prop_name" method, if it exists. haskell-gi2Find the first method with the given name, if any. haskell-giNot every interface that provides signals/properties is marked as requiring GObject, but this is necessarily the case, so fix the introspection data accordingly. haskell-giDrop any fields whose name coincides with that of a previous element. Note that this function keeps ordering. haskell-gi?Some libraries include duplicated flags by mistake, drop those. haskell-giSometimes arguments are marked as being a user_data destructor, but there is no associated user_data argument. In this case we drop the annotation. haskell-giIf any argument for the callable has an associated destroyer for the user_data, but no associated user_data, drop the destroyer annotation. haskell-giSometimes it is the callback that is annotated with the (closure user_data) annotation, and sometimes the user_data parameter itself, with (closure callback) pointing to the callback. The following code makes sure that the annotation is on the callable only. Note that this goes against the official gobject introspection spec, but there is more code using this convention than otherwise, and the gir generator seems to add closure annotations in both directions when using the new convention anyway. haskell-giClosures are often incorrectly assigned, with the closure annotation on the callback, instead of in the closure (user_data) parameter itself. The following makes sure that things are as they should. haskell-gi*The last argument of callbacks is often a  user_data argument, but currently gobject-introspection does not have an annotation representing this. This is generally OK, since the gir generator will mark these arguments as  (closure) if they are named  user_data, and we do the right things in this case, but recently there has been a push to "fix" these annotations by removing them without providing any replacement, which breaks the bindings. See  https://gitlab.gnome.org/GNOME/gobject-introspection/-/issues/450 Here we try to guess which arguments in callbacks are user_data arguments. haskell-giAny argument with a closure index pointing to itself is a "user_data" type argument. haskell-giSome symbols have names that are not valid Haskell identifiers, fix that here. haskell-giMake sure that the given name is a valid Haskell identifier in patterns.Examples!fixConstantName (Name "IBus" "0")'Name {namespace = "IBus", name = "C'0"}!fixConstantName (Name "IBus" "a")'Name {namespace = "IBus", name = "C'a"}!fixConstantName (Name "IBus" "A")%Name {namespace = "IBus", name = "A"}&None"7 haskell-gi0A subsection name, with an optional anchor name. haskell-gi"Possible features to test via CPP. haskell-giEnable overloading haskell-gi0Require a specific version of the given package. haskell-gi&Code generators that can throw errors. haskell-giThe base type for the code generator monad. Generators that cannot throw errors are parametric in the exception type excType. haskell-giThe name for a type variable. haskell-gi!A single variable type variable: a, b, etc... haskell-giAn indexed type variable: a17, key1, ... haskell-gi'Temporaty state for the code generator. haskell-giNext unused type variable. haskell-gi4Active CPP conditionals, outermost condition first. haskell-gi%Set of errors for the code generator. haskell-gi#Information for the code generator. haskell-gi*Map from C references to Haskell symbols. haskell-gi APIs available to the generator. haskell-giAmbient config. haskell-gi4Minimal version of base supported by a given module. haskell-gi 7.0 haskell-gi 8.0 haskell-gi!Flags for module code generation. haskell-giUse the standard prelude, instead of the haskell-gi-base short one. haskell-gi"Information on a generated module. haskell-gi1Minimal version of base the module will work on. haskell-gi9Documentation for the different sections in the module. haskell-giFlags for the module. haskell-gi%GHC options for compiling the module. haskell-gi'Set of language pragmas for the module. haskell-giQualified (source) imports. haskell-giExports for the module. haskell-gi$Set of dependencies for this module. haskell-gi%Indexed by the relative module name. haskell-gi(Interfaces going into the .hs-boot file. haskell-giGenerated code for the module. haskell-giFull module name: [Gtk, Label]. haskell-giPossible types of exports. haskell-gi(An export in the given haddock section. haskell-giA type declaration. haskell-giReexport of a whole module. haskell-giPossible exports for a given module. Every export type constructor has two parameters: the section of the haddocks where it should appear, and the symbol name to export in the export list of the module. haskell-gi3Protect the export by the given CPP export guards. haskell-giActual symbol to export. haskell-giWhich kind of export. haskell-giSymbol to export. haskell-giKnown subsections. The ordering here is the ordering in which they will appear in the haddocks. haskell-giSubsection of the haddock documentation where the export should be located, or alternatively the toplevel section. haskell-giPossible code tokens. haskell-gi/A single line, indented to current indentation. haskell-giIndented region. haskell-giA grouped set of lines haskell-giA (possibly multi line) comment haskell-giIncrease the indentation for the rest of the lines in the group. haskell-gi5A block of code guarded by the given CPP conditional haskell-giThe generated  is a sequence of s. haskell-gi9Set of CPP conditionals understood by the code generator. haskell-gi#if Foo haskell-gi/Initializes a code block to the empty sequence. haskell-gi-Checks whether the given code block is empty. haskell-gi-A block of code consisting of a single token. haskell-giA 0 representation of the given base version bound. haskell-giGenerate the empty module. haskell-giClean slate for . haskell-giRun a  with given  and initial state, returning either the resulting exception, or the result and final module info. haskell-gi4This is useful when we plan run a subgenerator, and - the result to the original structure later. haskell-giRun the given code generator using the state and config of an ambient CodeGen, but without adding the generated code to ", instead returning it explicitly. haskell-giLike , but we allow for explicitly setting the state of the inner code generator. haskell-giLike , giving explicitly the set of loaded APIs and C to Haskell map for the subgenerator. haskell-gi:Merge everything but the generated code for the two given . haskell-gi$Merge the infos, including code too. haskell-giAdd the given submodule to the list of submodules of the current module. haskell-giRun the given CodeGen in order to generate a single submodule of the current module. Note that we do not generate the submodule if the code generator generated no code and the module does not have submodules. haskell-giRun the given CodeGen in order to generate a submodule (specified an an ordered list) of the current module. haskell-giTry running the given action, and if it fails run fallback instead. haskell-gi0Return the currently loaded set of dependencies. haskell-gi8Return the ambient configuration for the code generator. haskell-gi&Return the name of the current module. haskell-gi3Return the list of APIs available to the generator. haskell-gi3Return the C -> Haskell available to the generator. haskell-gi Due to the forall in the definition of , if we want to run the monad transformer stack until we get a result, our only option is ignoring the possible error code from . This is perfectly safe, since there is no way to construct a computation in the > monad that throws an exception, due to the higher rank type. haskell-giRun a code generator, and return the information for the generated module together with the return value of the generator. haskell-giLike ), but discard the resulting output value. haskell-gi0Mark the given dependency as used by the module. haskell-giReturn the transitive set of dependencies, i.e. the union of those of the module and (transitively) its submodules. haskell-giGiven a module name and a symbol in the module (including a proper namespace), return a qualified name for the symbol. haskell-giImport the given module name qualified (as a source import if the namespace is the same as the current one), and return the name under which the module was imported. haskell-giConstruct a simplified version of the module name, suitable for a qualified import. haskell-giReturn the minimal base version supported by the module and all its submodules. haskell-giPrint, as a comment, a friendly textual description of the error. haskell-gi0Get a type variable unused in the current scope. haskell-giIntroduce a new scope for type variable naming: the next fresh variable will be called a. haskell-gi;Try to find the API associated with a given type, if known. haskell-giFind the API associated with a given type. If the API cannot be found this raises an . haskell-gi'Add some code to the current generator. haskell-gi&Print out a (newline-terminated) line. haskell-giPrint out the given line both to the normal module, and to the HsBoot file. haskell-gi A blank line haskell-gi6A (possibly multi line) comment, separated by newlines haskell-gi.Increase the indent level for code generation. haskell-giIncrease the indentation level for the rest of the lines in the current group. haskell-giGroup a set of related code. haskell-giGuard a block of code with #if. haskell-giGuard a code block with CPP code, such that it is included only if the specified feature is enabled. haskell-giWrite the given code into the .hs-boot file for the current module. haskell-gi#Add a export to the current module. haskell-giReexport a whole module. haskell-gi&Add a type declaration-related export. haskell-gi0Export a symbol in the given haddock subsection. haskell-gi0Set the language pragmas for the current module. haskell-gi-Add a language pragma for the current module. haskell-giSet the GHC options for compiling this module (in a OPTIONS_GHC pragma). haskell-gi#Set the given flags for the module. haskell-gi=Set the minimum base version supported by the current module. haskell-gi&Add documentation for a given section. haskell-gi:Prepend documentation at the beginning of a given section. haskell-giFormat a CPP conditional. haskell-gi$Return a text representation of the . haskell-giPad a line to the given number of leading tabs (with one tab equal to four spaces), and add a newline at the end. haskell-giPad a set of lines to the given number of leading tabs (with one tab equal to four spaces), and add a newline at the end of each line. haskell-gi,Put a (padded) comma at the end of the text. haskell-giFormat the given export symbol. haskell-gi$Format the list of exported modules. haskell-gi%Format the toplevel exported symbols. haskell-gi%Format the type declarations section. haskell-gi3A subsection with an anchor given by the title and  prefix:title& anchor, and the given documentation. haskell-giReturn a qualified form of the function mapping instances of IsX to haskell values of type X. haskell-giSame as ;, but applicable directly to a type. The type should be a R$, otherwise an error will be raised. haskell-giForeign type associated with a callback type. It can be passed in qualified. haskell-giHaskell type exposing the closure arguments, which are generally elided. haskell-giThe name of the dynamic wrapper for the given callback type. It can be passed in qualified. haskell-giThe name of the Haskell to foreign wrapper for the given callback type. It can be passed in qualified. haskell-giThe name of the Haskell to foreign wrapper for the given callback type, keeping the closure arguments (we usually elide them). The callback type can be passed in qualified. haskell-giThe name of a function which takes a callback without closure arguments, and generates a function which does accep the closures, but simply ignores them. haskell-gi,The name for the foreign wrapper allocator (foreign import "wrapper" ...>) for the given callback type. It can be passed in qualified. haskell-giThe name for the closure generator for the given callback type. It can be passed in qualified. haskell-gi$Move leading underscores to the end.Examplessanitize "_Value_Data_Union""Value_Data_Union_" haskell-giTurn the given { into CamelCase, starting with a lowercase letter. The resulting identifier will be qualified by the namespace if necessary.Examples"lowerName (Name "Gtk" "main_quit") "mainQuit"!lowerName (Name "NM" "80211Test") "nM80211Test" haskell-giTurn the given identifier into camelCase, starting with a lowercase letter.ExampleslowerSymbol "main_quit" "mainQuit" haskell-giTurn the given { into CamelCase, starting with a capital letter. The resulting identifier will be qualified by the namespace if necessary.Examples upperName (Name "Foo" "bar_baz")"BarBaz"$upperName (Name "NM" "80211ApFlags")"NM80211ApFlags" haskell-giConstruct the submodule path where the given API element will live. This is the path relative to the root for the corresponding namespace. I.e. the GI.Gtk part is not prepended. haskell-gi;Obtain the absolute location of the module where the given  lives. haskell-giConstruct the Haskell version of the name associated to the given API. haskell-giReturn an identifier for the given interface type valid in the current module. haskell-gi>Construct an identifier for the given symbol in the given API. haskell-gi3Turn a hyphen-separated identifier into camel case.Examples&hyphensToCamelCase "one-sample-string""OneSampleString" haskell-gi Similarly to , turn a name separated_by_underscores into CamelCase. We preserve final and initial underscores, and n>1 consecutive underscores are transformed into n-1 underscores.Examples"underscoresToCamelCase "sample_id" "SampleId"&underscoresToCamelCase "_internal_id_""_InternalId_"/underscoresToCamelCase "multiple___underscores""Multiple__Underscores" haskell-giName for the given argument, making sure it is a valid Haskell argument name (and escaping it if not). haskell-giReserved symbols, either because they are Haskell syntax or because the clash with symbols in scope for the generated bindings. haskell-giQualified name for the "(sigName, info)" tag for a given signal. haskell-giReturn the name for the signal in Haskell CamelCase conventions. haskell-giReturn a link to the hackage package for the given name. Note that the generated link will only be valid if the name belongs to the binding which is currently being generated. haskell-gi(Prefix in Haddock for the signal anchor. haskell-gi+Prefix in Haddock for the attribute anchor.%None"; haskell-gi#Link to an identifier, module, etc. haskell-giGiven a set of APIs, build a Map that given a Text corresponding to a certain C identifier returns the corresponding Haskell element in the bindings. For instance, gtk_widget_show will get mapped to @A. haskell-giAn identifier at the value level: functions, data constructors, ... haskell-gi An identifier at the type level. haskell-giLink to a module. haskell-giLink to an anchor inside a given module, with an optional label. haskell-gi6Obtain the fully qualified symbol pointing to a value. haskell-gi5Obtain the fully qualified symbol pointing to a type. haskell-giExtract the C name of a constant. These are often referred to as types, so we allow that too. haskell-gi!Extract the C name of a function. haskell-giExtract the C names of the fields in an enumeration/flags, and the name of the type itself. haskell-gi&Refs to the methods for a given owner. haskell-gi&Refs to the signals for a given owner. haskell-gi)Refs to the properties for a given owner. haskell-giGiven an optional C type and the API constructor construct the list of associated refs. haskell-gi!Extract the C name of a callback. haskell-gi%Extract the C references in a struct. haskell-gi$Extract the C references in a union. haskell-gi)Extract the C references in an interface. haskell-gi&Extract the C references in an object.(None"  haskell-giFind the parent of a given object when building the instanceTree. For the purposes of the binding we do not need to distinguish between GObject.Object and GObject.InitiallyUnowned. haskell-gi"formatHaddock M.empty "a" "Test" (GtkDoc [UnnumberedList [GtkDoc [Image (Link "test" "test.png")]]])"* <>\n"formatHaddock M.empty "a" "Test" (GtkDoc [NumberedList [("1", GtkDoc [Literal "Hi!"]), ("2", GtkDoc [Literal "Second and very long, so split\n line."])]]);"1. Hi!\n\n2. Second and very long, so split\n line.\n\n" haskell-gi Format a  whose Haskell representation is not known, using a provided default namespace for relative symbols. haskell-giFormat the given symbol name in a fully qualified way, using the default namespace if needed. haskell-gi&Formatting for an unknown C reference. haskell-gi Format a  into plain . haskell-gi,Format a code block in a specified language. haskell-giQualify the given address with the docBase, if it is not an absolute address. haskell-gi(Format a link to some external resource. haskell-giFormat an embedded image. haskell-giFormat a section header of the given level and with the given text. Note that the level will be truncated to 2, if it is larger than that. haskell-giFormat a list of items. haskell-gi Format a numbered list of items. haskell-gi2Escape the reserved Haddock characters in a given .Examples escape "\"""\\\""escape "foo@bar.com""foo\\@bar.com"escape "C:\\Applications""C:\\\\Applications" haskell-giGet the base url for the online C language documentation for the module being currently generated. haskell-gi+Write the deprecation pragma for the given  , if not . haskell-giFormat the given documentation into a set of lines. Note that this does include the opening or ending comment delimiters. haskell-gi2Write the given documentation into generated code. haskell-giLike , but allows us to pass explicitly the Haddock comment to write. haskell-gi/Write the documentation for the given argument. haskell-gi3Write the documentation for the given return value. haskell-giAdd the given text to the documentation for the section being generated.  *None"# haskell-gi3Check whether the given type descends from GObject. haskell-gi3Check whether the given name descends from GObject. haskell-gi2Check whether the given API descends from GObject.+None"$+ haskell-gi/Signal instances for (GObject-derived) objects. haskell-gi Signal instances for interfaces.,None"% haskell-giGiven a list of named enum members, filter out those that have the same value as a previous entry in the list. haskell-giVery similar to enums, but we also declare ourselves as members of the IsGFlag typeclass. haskell-gi,Support for enums encapsulating error codes.-None"99 haskell-gi#Distinct types of foreign pointers. haskell-gi Ordinary Ptr. haskell-giFunPtr. haskell-giInformation on how to allocate a type: allocator function and size of the struct. haskell-giWhether to expose closures and the associated destroy notify handlers in the Haskell wrapper. haskell-giThe free monad. haskell-gi$Lift some command to the Free monad. haskell-giGiven an array, together with its type, return the code for reading its length. haskell-giTry to find the hash and equal functions appropriate for the given type, when used as a key in a GHashTable. haskell-gi GHashTable tries to fit every type into a pointer, the following function tries to find the appropriate (destroy,packer,unpacker) for the given type. haskell-giSomewhat like , but with slightly different borrowing semantics: in the case of x< we wrap incoming pointers to boxed structs into transient  ManagedPtr s (every other case behaves as  ). These are  ManagedPtrs for which we do not make a copy, and which will be disowned when the function exists, instead of making a copy that the GC will collect eventually.This is necessary in order to get the semantics of callbacks and signals right: in some cases making a copy of the object does not simply increase the refcount, but rather makes a full copy. In this cases modification of the original object is not possible, but this is sometimes useful, see for example 2https://github.com/haskell-gi/haskell-gi/issues/97Another situation where making a copy of incoming arguments is problematic is when the underlying library is not thread-safe. When running under the threaded GHC runtime it can happen that the GC runs on a different OS thread than the thread where the object was created, and this leads to rather mysterious bugs, see for example 2https://github.com/haskell-gi/haskell-gi/issues/962This case is particularly nasty, since it affects  onWidgetDraw, which is very common. haskell-giWrap the given transient. haskell-giGiven a type find the typeclasses the type belongs to, and return the representation of the type in the function signature and the list of typeclass constraints for the type. haskell-gi pattern Name  -(view -; value) :: Type where > Name = expression value :: Type  haskell-giAssign to the given name the given constant value, in a way that can be assigned to the corresponding Haskell type.  haskell-giShow a basic type, in a way that can be assigned to the corresponding Haskell type.2None"fX  haskell-gi$Information about a dynamic wrapper.  haskell-giName of the type synonym for the type of the function to be wrapped.  haskell-giHaskell dynamic wrapper haskell-giThe foreign symbol to wrap. It is either a foreign symbol wrapped in a foreign import, in which case we are given the name of the Haskell wrapper, or alternatively the information about a "dynamic" wrapper in scope. haskell-giHaskell symbol in scope. haskell-giInfo about the dynamic wrapper. haskell-giSignature for a callable.  haskell-giGenerate a foreign import for the given C symbol. Return the name of the corresponding Haskell identifier.  haskell-giMake a wrapper for foreign FunPtrs of the given type. Return the name of the resulting dynamic Haskell wrapper. haskell-giGiven an argument to a function, return whether it should be wrapped in a maybe type (useful for nullable types). We do some sanity checking to make sure that the argument is actually nullable (a relatively common annotation mistake is to mix up (optional) with (nullable)). haskell-giGiven the list of arguments returns the list of constraints and the list of types in the signature. haskell-giWhether to skip the return value in the generated bindings. The C convention is that functions throwing an error and returning a gboolean set the boolean to TRUE iff there is no error, so the information is always implicit in whether we emit an exception or not, so the return value can be omitted from the generated bindings without loss of information (and omitting it gives rise to a nicer API). See 1https://bugzilla.gnome.org/show_bug.cgi?id=649657  haskell-giReturn the list of actions freeing the memory associated with the callable variables. This is run if the call to the C function succeeds, if there is an error freeInArgsOnError below is called instead.  haskell-giReturn the list of actions freeing the memory associated with the callable variables. This is run in case there is an error during the call.  haskell-gi>Callbacks are a fairly special case, we treat them separately.  haskell-gi4Format the signature of the Haskell binding for the .  haskell-gi5Name for the first argument in dynamic wrappers (the FunPtr). haskell-giThe Haskell signature for the given callable. It returns a tuple ([constraints], [(type, argname)]). haskell-giIn arguments for the given callable on the Haskell side, together with the omitted arguments. haskell-giOut6 arguments for the given callable on the Haskell side.  haskell-gi2Convert the result of the foreign call to Haskell.  haskell-giMarshal a foreign out argument to Haskell, returning the name of the variable containing the converted Haskell value.  haskell-giConvert the list of out arguments to Haskell, returning the names of the corresponding variables containing the marshaled values.  haskell-gi3Invoke the given C function, taking care of errors.  haskell-giReturn the result of the call, possibly including out arguments.  haskell-gi:Generate a Haskell wrapper for the given foreign function.  haskell-giGenerate the body of the Haskell wrapper for the given foreign symbol. haskell-gicaller-allocates arguments are arguments that the caller allocates, and the called function modifies. They are marked as out argumens in the introspection data, we sometimes treat them as inout arguments instead. The semantics are somewhat tricky: for memory management purposes they should be treated as "in" arguments, but from the point of view of the exposed API they should be treated as "out" or "inout". Unfortunately we cannot always just assume that they are purely "out", so in many cases the generated API is somewhat suboptimal (since the initial values are not important): for example for g_io_channel_read_chars the size of the buffer to read is determined by the caller-allocates argument. As a compromise, we assume that we can allocate anything that is not a TCArray of length determined by an argument.  haskell-gi!Some debug info for the callable. haskell-gi(Generate a wrapper for a known C symbol.  haskell-giFor callbacks we do not need to keep track of which arguments are closures. haskell-giGenerate a wrapper for a dynamic C symbol (i.e. a Haskell function that will invoke its first argument, which should be a FunPtr of the appropriate type). The caller should have created a type synonym with the right type for the foreign symbol.3None"l  haskell-giThe prototype of the callback on the Haskell side (what users of the binding will see)  haskell-giGenerate the type synonym for the prototype of the callback on the C side. Returns the name given to the type synonym.  haskell-gi&Generator for wrappers callable from C  haskell-giWrap the Haskell cb callback into a foreign function of the right type. Returns the name of the wrapped value.  haskell-giGenerator of closures  haskell-gi,Wrap a conversion of a nullable object into Maybe2 object, by checking whether the pointer is NULL.  haskell-gi3A simple wrapper that drops every closure argument.  haskell-gi9The wrapper itself, marshalling to and from Haskell. The  argument is possibly a pointer to a FunPtr to free (via freeHaskellFunPtr) once the callback is run once, or Nothing if the FunPtr will be freed by someone else (the function registering the callback for ScopeTypeCall, or a destroy notifier for ScopeTypeNotified).  haskell-giCreate the newtype wrapping the ManagedPtr for the given type.  haskell-gi Generate wrapper for structures.  haskell-giGenerated wrapper for unions.  haskell-giWhen parsing the GIR file we add the implicit object argument to methods of an object. Since we are prepending an argument we need to adjust the offset of the length arguments of CArrays, and closure and destroyer offsets.  haskell-giGenerate an import for the gvalue getter for the given type. It returns the name of the function on the Haskell side.  haskell-giGenerate an import for the gvalue setter for the given type. It returns the name of the function on the Haskell side.  haskell-gi4Generate the GValue instances for the given GObject.  haskell-giType casting with type checking, returns the function returning the GType for the oject.  haskell-giWrap a given Object. We enforce that every Object that we wrap is a GObject. This is the case for everything except the ParamSpec* set of objects, we deal with these separately.  haskell-gi>Generate the code for a given API in the corresponding module.6None"{" haskell-giIncluded overrides file. haskell-gi3Tag for the override, for error reporting purposes.  haskell-gi'Generate the code for the given module.  haskell-giWrite a module containing information about the configuration for the package.  haskell-giA convenience helper for  , such that bindings for the given module are generated in the  configure step of cabal. haskell-giThe entry point for Setup.hs files in bindings. haskell-gi Return the list of modules that setupHaskellGIBinding would create, together with the set of dependencies loaded while generating the code.  haskell-giname haskell-giversion haskell-gipkgName haskell-gi pkgVersion haskell-giverbose haskell-giExplicit overrides  haskell-giname haskell-giversion haskell-gipkgName haskell-gi pkgVersion haskell-giverbose haskell-gioverrides file haskell-giother overrides haskell-gi output dir haskell-gi previous   haskell-giname haskell-giversion haskell-gipkgName haskell-gi pkgVersion haskell-giverbose haskell-gioverrides file haskell-giExplicit overrides haskell-gi output dir haskell-giname haskell-giversion haskell-gipkgName haskell-gi pkgVersion haskell-giOverrides file haskell-giOther overrides to loadF Safe-Inferred"{i  G8HIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghhhijklmnopqrssstuvwxyz{|}~                                                        9 9 9 9                                                                  ;                                   !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!"""""""""""""#########$$$$$$$$%%&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&''''''''''''''''''''''='''''%%%%%%(((((((((()))))))))***++,,--------------------------------------------...////////00012222222222222222222223344455666666                                                  c       !!!!!!!!!!!!!!!!!!!!!!!!!"""""""""""""""""""""""""""""""""""""""""$$$$$$$$$$$$&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&V&&&&&&&&&&&&''%%%%%%%%%%%%%%(())))))))))))))),,--- - - - - - - - - - - / / / / / / / / / / / / / / / / / / / / / / / / / 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 1 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 3 3 3 3 3 3 3 3 3 3 3 4 4 4 4 5 5 5 5 5 5 5 5 5 5 6 6 6  F F F F F F F F haskell-gi-0.26.13-inplaceData.GI.GIR.ParserData.GI.CodeGen.GTypeData.GI.CodeGen.PkgConfigData.GI.CodeGen.ProjectInfoData.GI.CodeGen.UtilData.GI.CodeGen.ModulePathData.GI.CodeGen.LibGIRepositoryData.GI.GIR.AllocationData.GI.GIR.BasicTypesData.GI.CodeGen.TypeData.GI.CodeGen.GtkDocData.GI.GIR.RepositoryData.GI.GIR.XMLUtilsData.GI.GIR.DocumentationData.GI.GIR.DeprecationData.GI.GIR.TypeData.GI.GIR.EnumData.GI.GIR.FlagsData.GI.GIR.ConstantData.GI.GIR.ArgData.GI.GIR.PropertyData.GI.GIR.CallableData.GI.GIR.SignalData.GI.GIR.MethodData.GI.GIR.ObjectData.GI.GIR.InterfaceData.GI.GIR.FunctionData.GI.GIR.CallbackData.GI.GIR.FieldData.GI.GIR.UnionData.GI.GIR.StructData.GI.GIR.AliasData.GI.CodeGen.APIData.GI.CodeGen.OverridesData.GI.CodeGen.ConfigData.GI.CodeGen.FixupsData.GI.CodeGen.CtoHaskellMapData.GI.CodeGen.CodeData.GI.CodeGen.SymbolNamingData.GI.CodeGen.InheritanceData.GI.CodeGen.HaddockData.GI.CodeGen.GObject!Data.GI.CodeGen.OverloadedSignalsData.GI.CodeGen.EnumFlagsData.GI.CodeGen.ConversionsData.GI.CodeGen.TransferData.GI.CodeGen.StructData.GI.CodeGen.PropertiesData.GI.CodeGen.ConstantData.GI.CodeGen.CallableData.GI.CodeGen.Signal!Data.GI.CodeGen.OverloadedMethodsData.GI.CodeGen.CodeGenData.GI.CodeGen.CabalHooks haskell-giText.XMLName Data.GI.GIR parseGtkDocGI.SymbolNamingescapedArgName Data.VersionVersionGI.Gtk.Objects.Widgetshow Data.GI.Base attrTransferData.GI.Base.AttributesAttrSetTypeConstraintPaths_haskell_gixml-conduit-1.9.1.4-69309dcd7400e667517943f43170ee2855986f1724cbdd7c86acf9a8c8882313Elementhaskell-gi-base-0.26.8-inplaceData.GI.Base.BasicTypesGTypegtypeIsA gtypeIsBoxed tryPkgConfigpkgConfigGetVersionhomepageauthors maintainerslicensedefaultExtensionsotherExtensions ghcOptionsdefaultLanguage standardDepscategory licenseTextpadTo withCommentprime parenthesizetshowucFirstlcFirstmodifyQualifiedsplitOn utf8ReadFile utf8WriteFile printWarningterror ModulePathmodulePathToList toModulePath dotModulePath/.$fIsStringModulePath$fSemigroupModulePath$fMonoidModulePath$fEqModulePath$fShowModulePath$fOrdModulePath FieldInfofieldInfoOffsetTypelibsetupTypelibSearchPath girRequiregirStructFieldInfogirUnionFieldInfo girLoadGTypegirIsSymbolResolvable$fGBoxedBaseInfo$fTypedObjectBaseInfo$fHasParentTypesBaseInfo $fShowTypelib AllocationOpAllocationOpUnknownAllocationInfo allocFree allocCopy allocCallocunknownAllocationInfo$fShowAllocationInfo$fShowAllocationOp$fEqAllocationOpType TBasicTypeTErrorTVariantTGValue TParamSpecTCArrayTGArray TPtrArray TByteArrayTGListTGSListTGHash TGClosure TInterface BasicTypeTBooleanTIntTUIntTLongTULongTInt8TUInt8TInt16TUInt16TInt32TUInt32TInt64TUInt64TFloatTDoubleTUniCharTGTypeTUTF8 TFileNameTPtrTIntPtrTUIntPtrTShortTUShortTSizeTSSizeTtime_tToff_tTdev_tTgid_tTpid_t Tsocklen_tTuid_tAliasTransferTransferNothingTransferContainerTransferEverythingname namespace$fEqType $fShowType $fOrdType $fEqBasicType$fShowBasicType$fOrdBasicType $fOrdAlias $fEqAlias $fShowAlias$fShowTransfer $fEqTransfer $fOrdTransfer$fEqName $fOrdName $fShowNameTypeReptypeShow typeConNameconcon0ioptrfunptrmaybeT $fEqTypeRep $fEqTypeConGtkDoc DocSymbolName RelativeName AbsoluteNameCRef FunctionRefOldFunctionRef MethodRefParamRef ConstantRef SignalRef OldSignalRefLocalSignalRef PropertyRefOldPropertyRef VMethodRefVFuncRefStructFieldRef EnumMemberRefCTypeRefTypeRefLanguageLink linkAddresslinkNameTokenLiteralCommentVerbatim CodeBlock ExternalLinkImageUnnumberedList NumberedList SectionHeader SymbolRefdocNameresolveDocSymbol$fEqIndentParsingMode $fShowGtkDoc $fEqGtkDoc $fShowToken $fEqToken $fShowCRef$fEqCRef $fOrdCRef$fShowDocSymbolName$fEqDocSymbolName$fOrdDocSymbolName$fShowLanguage $fEqLanguage $fShowLink$fEqLinkreadGiRepositoryGIRXMLNamespace GLibGIRNSCGIRNS CoreGIRNS nodeToElement subelements localNamechildElemsWithLocalNamechildElemsWithNSNamefirstChildWithLocalNamegetElementContent lookupAttrlookupAttrWithNamespace xmlLocalName xmlNSName$fShowGIRXMLNamespace Documentation sinceVersion rawDocTextqueryDocumentation$fShowDocumentation$fEqDocumentation$fOrdDocumentationDeprecationInfodeprecationMessagedeprecatedSinceVersionqueryDeprecated$fShowDeprecationInfo$fEqDeprecationInfoParser ParseError ParseContext knownAliasescurrentElement treePosition ctxNamespace parseErrorcurrentNamespaceresolveQualifiedTypeNamegetAttrgetAttrWithNamespace queryAttrqueryAttrWithNamespace optionalAttr qualifyName parseNameparseDeprecationparseDocumentation parseIntegral parseBoolparseChildrenWithLocalNameparseAllChildrenWithLocalNameparseChildrenWithNSName runParser$fShowParseContext queryCType parseCType parseTypeparseOptionalTypequeryElementCTypeEnumerationMember enumMemberDoc enumMemberCIdenumMemberValueenumMemberName EnumerationenumDeprecatedenumStorageBytes enumCTypeenumDocumentation enumTypeInitenumErrorDomain enumMembers parseEnum$fShowEnumeration$fShowEnumerationMemberFlags parseFlags $fShowFlagsConstantconstantDeprecatedconstantDocumentation constantCType constantValue constantType parseConstant$fShowConstantArgtransferargCallbackUserDataargCallerAllocates argDestroy argClosureargScopeargDoc mayBeNull directionargTypeargCNameScopeScopeTypeInvalid ScopeTypeCallScopeTypeAsyncScopeTypeNotifiedScopeTypeForever Direction DirectionIn DirectionOutDirectionInoutparseTransferString parseTransferparseArg $fShowArg$fEqArg$fOrdArg $fShowScope $fEqScope $fOrdScope$fShowDirection $fEqDirection$fOrdDirectionPropertypropDeprecatedpropDoc propTransfer propGetter propSetterpropWriteNullablepropReadNullable propFlagspropTypepropName PropertyFlagPropertyReadablePropertyWritablePropertyConstructPropertyConstructOnly parseProperty$fShowProperty $fEqProperty$fShowPropertyFlag$fEqPropertyFlagCallablecallableResolvablecallableDocumentationcallableDeprecatedcallableThrows skipReturnargsreturnDocumentationreturnTransferreturnMayBeNull returnType parseCallable$fShowCallable $fEqCallableSignalsigDoc sigDetailed sigDeprecated sigCallablesigName parseSignal $fShowSignal $fEqSignalMethodmethodCallable methodMovedTo methodType methodSymbol methodName MethodType ConstructorMemberFunctionOrdinaryMethod parseMethod $fEqMethod $fShowMethod$fEqMethodType$fShowMethodTypeObject objSignals objProperties objMethodsobjDocumentation objDeprecated objInterfacesobjGetValueFuncobjSetValueFunc objUnrefFunc objRefFuncobjCType objTypeName objTypeInit objParent parseObject $fShowObject Interface ifDeprecatedifAllocationInfo ifMethods ifSignals ifPropertiesifPrerequisitesifDocumentationifCType ifTypeInitparseInterface$fShowInterfaceFunction fnCallable fnMovedTofnSymbol parseFunction$fShowFunctionCallbackcbDocumentationcbCType cbCallable parseCallback$fShowCallback FieldInfoFlagFieldfieldDeprecatedfieldDocumentation fieldFlags fieldOffset fieldCallbackfieldIsPointer fieldType fieldVisible fieldName parseFields $fShowField$fShowFieldInfoFlagUnionunionDeprecated unionCType unionMethods unionFields unionTypeInit unionSizeunionDocumentationunionAllocationInfo unionIsBoxed parseUnion $fShowUnionStructstructDocumentationstructDeprecated structMethods structFieldsstructForceVisiblestructIsDisguisedgtypeStructFor structSize structCTypestructTypeInitstructAllocationInfo structIsBoxed parseStruct $fShowStructdocumentListAliasesAPIAPIConst APIFunction APICallbackAPIEnumAPIFlags APIInterface APIObject APIStructAPIUnionGIRRule GIRSetAttr GIRDeleteAttr GIRAddNode GIRDeleteNode GIRNameTag GIRPlainNameGIRRegex GIRNodeSpecGIRNamedGIRType GIRTypedNameGIRPathGIRInfo girCTypesgirAPIs girNSVersion girNSName girPCPackagesloadRawGIRInfo loadGIRInfo $fShowGIRInfo$fShowGIRInfoParse$fShowGIRNamespace $fShowAPI $fShowGIRRule$fShowGIRNodeSpec$fShowGIRNameTag Overrides onlineDocsMap girFixupsnsChooseVersioncabalPkgVersion pkgConfigMapparseOverridesfilterAPIsAndDeps$fSemigroupOverrides$fMonoidOverrides $fShowOSType$fShowParserState$fShowOverridesConfig overridesverbose ghcPkgVersion ghcPkgName modVersionmodName $fShowConfigdropMovedItemsguessPropertyNullability detectGObjectdropDuplicatedFieldscheckClosureDestructors fixClosuresfixCallbackUserDatafixSymbolNaming Hyperlink cToHaskellMapCPPGuardCPPOverloading CPPMinVersion ExcCodeGenCodeGenCGError BaseVersionBase47Base48 ModuleFlagImplicitPrelude ModuleInfo sectionDocs moduleCode NamedSection MethodSectionPropertySection SignalSection EnumSection FlagSectionHaddockSectionToplevelSectionSectionNamedSubsectionCodeshowBaseVersionrecurseWithAPIs submodule handleCGExcgetDepsconfig currentModulegetAPIs getC2HMap evalCodeGengenCoderegisterNSDependencytransitiveModuleDeps qualifiedminBaseVersion printCGErrornotImplementedError badIntroErrormissingInfoErrorgetFreshTypeVariableresetTypeVariableScopefindAPIgetAPI findAPIByNamelineblineblankcommentindentincreaseIndentgroupcppIfhsBoot exportModule exportDeclexportsetLanguagePragmasaddLanguagePragma setGHCOptionssetModuleFlagssetModuleMinBaseaddSectionFormattedDocsprependSectionFormattedDocs codeToTextwriteModuleTreelistModuleTree$fEqSubsection$fShowSubsection$fOrdSubsection $fShowCGError$fShowBaseVersion$fEqBaseVersion$fOrdBaseVersion$fShowModuleFlag$fEqModuleFlag$fOrdModuleFlag $fShowExport $fEqExport $fOrdExport$fShowExportType$fEqExportType$fOrdExportType$fShowHaddockSection$fEqHaddockSection$fOrdHaddockSection$fShowNamedSection$fEqNamedSection$fOrdNamedSection $fEqCodeToken$fOrdCodeToken$fShowCodeToken$fSemigroupCode $fMonoidCode$fEqCode $fShowCode $fOrdCode$fEqCPPConditional$fShowCPPConditional$fOrdCPPConditionalclassConstraintsafeCasttypeConstraint callbackCTypecallbackHTypeWithClosurescallbackDynamicWrappercallbackHaskellToForeign$callbackHaskellToForeignWithClosurescallbackDropClosurescallbackWrapperAllocatorcallbackClosureGenerator lowerName lowerSymbol upperNamesubmoduleLocationmoduleLocationnormalizedAPIName qualifiedAPIqualifiedSymbolhyphensToCamelCaseunderscoresToCamelCasesignalInfoNamesignalHaskellNamehackageModuleLinkhaddockSignalAnchorhaddockAttrAnchorValueIdentifierTypeIdentifier ModuleLinkModuleLinkWithAnchor$fShowHyperlink $fEqHyperlink instanceTreefullObjectPropertyListfullInterfacePropertyListfullObjectSignalListfullInterfaceSignalListfullObjectMethodListfullInterfaceMethodList$fInheritableMethod$fInheritableSignal$fInheritablePropertyRelativeDocPositionDocBeforeSymbolDocAfterSymboldeprecatedPragmawriteDocumentation writeHaddockwriteArgDocumentationwriteReturnDocumentationaddSectionDocumentation isGObject nameIsGObject apiIsGObjectgenObjectSignalsgenInterfaceSignalsgenEnumgenFlags TypeAllocInfo TypeAllocExposeClosures WithClosuresWithoutClosuresPMIdapplymapCliteral genConversioncomputeArrayLengthconverthToFfToH transientToH unpackCArray argumentType haskellTypecallableHasClosurestypeIsCallbackisoHaskellType foreignType typeAllocInfo isManaged typeIsPtrmaybeNullConvertnullPtrForTypetypeIsNullableelementTypeAndMap elementType elementMap $fMonadFree$fApplicativeFree $fFunctorFree$fIsStringConstructor$fEqExposeClosures $fShowFExpr$fFunctorFExpr $fShowMap$fEqConstructor$fShowConstructorfreeContainerType freeInArgfreeInArgOnError ignoreStruct fixAPIStructsextractCallbacksInStructgenStructOrUnionFields genZeroStruct genZeroUniongenBoxed genWrappedPtrgenObjectPropertiesgenInterfacePropertiesgenNamespacedPropLabels genConstant ForeignSymbolKnownForeignSymbolDynamicForeignSymbol SignaturesignatureReturnTypesignatureArgTypessignatureConstraintssignatureCallablehOutType wrapMaybeinArgInterfacesarrayLengthsMap arrayLengths skipRetValcallableSignaturecallableHInArgscallableHOutArgsfixupCallerAllocatesgenCCallableWrappergenDynamicCallableWrapper genCallback genSignal genMethodList genMethodInfogenUnsupportedMethodInfo genFunction genModuleTaggedOverride overrideText overrideTag setupBindingconfigureDryRuntext-2.1.2-5b410c0d267d538afae63eb831ebb3018f43995e65cb95cf3c5161a28a35588fData.Text.InternalTextbaseGHC.ErrerrorGHC.BaseStringBaseInfogirPrependSearchPath!g_irepository_prepend_search_path girFindByName getFieldInfogirLookupSymbol girSymbolTypeConghc-prim GHC.TypesIO GHC.MaybeMaybeIndentParsingModerawParseGtkDoc startOfString removeSOScoalesceLiterals parseTokens parseTokenisCIdent parseCIdentparseFunctionRefparseIdparseOldFunctionRefparseNewFunctionRefparseConstructor parseClassparseEnumMemberparseOldSignalparseNewSignalparseLocalSignalparseOldPropertyparseNewProperty parseCommentparseOldVMethod parseVFunc parseVMethodparseStructField parseParamsignalOrPropName parseEscapedparseBoringLiteralspecial parseVerbatimparseUrl parseImageparseCodeBlockparseNewStyleCodeBlockparseOldStyleCodeBlock parseLanguageparseInitialNewlinesparseSectionHeaderparseInitialSectionHeaderparseUnnumberedListparseNumberedList parseList girDataDirsbuildSearchPathgirFile girNamespaceelementDescriptionnameInCurrentNS withElementnameToBasicTypeparseArrayInfoparseCArrayTypeparseHashTable parseClosure parseListTypeparseFundamentalType parseTypeName parseTypeInfoNothingparseTypeElementsparseCTypeNameElements queryTypeextractEnumStorageBytesresolveInternalTypepspec_type_init parseFieldnamespaceListAliases parseAliases parseAliasdocumentListIncludesloadDependencies loadGIRFile toGIRInfo fixupGIRInfosgtypeInterfaceListPrereqsfixupInterface fixupStructfixupStructIsBoxedfixupStructSizeAndOffsets fixupUnionfixupUnionSizeAndOffsets fixupFieldfixupMissingSymbolsresolveTypelibfixupMethodMissingSymbolsfixupFunctionSymbolsoverrideGIRDocument overrideGIR girSetAttr girDeleteAttr girAddNodegirDeleteNodeslookupAndMatch specMatchOSType ParserStateflagsFalse currentNS allocInfo sealedStructs ignoredAPIs ignoredElemsdefaultOverridesconcatOverridesemptyParserStategetNS withFlags parseOneLine parseIgnore parseSealparseAllocInfoparseKeyValuePairparsePkgConfigNameparseNsVersionparseCabalPkgVersion parseSetAttrparseDeleteAttrparseAdd parseDelete parseDocsUrl parsePathSpecparseGIRNameTag parseNodeSpec parseXMLNamecheckOS parseVersioncheckPkgConfigVersionparseIf parseEndif parseInclude filterMethodsfilterAllocInfo filterOneAPI filterAPIsfilterMovedMethodsguessObjectPropertyNullability!guessInterfacePropertyNullabilityguessNullabilityguessReadNullabilityguessWriteNullability findMethoddropDuplicatedEnumFieldscheckCallableDestructorsfixCallableClosuresfixCallableUserDatafixConstantName Subsection NamedTyvarSingleCharTyvar IndexedTyvarCGStatecgsNextAvailableTyvarcgsCPPConditionals CodeGenConfigc2hMap loadedAPIshConfig moduleMinBase moduleFlags moduleGHCOpts modulePragmasqualifiedImports moduleExports moduleDeps submodulesbootCode modulePath ExportType ExportSymbolExportTypeDecl ExportModuleExport exportGuards exportSymbol exportType SymbolName CodeTokenLineIndentGroupIncreaseIndentCPPBlockCPPConditionalCPPIf emptyCode isCodeEmpty codeSingleton emptyModule emptyCGState runCodeGen cleanInfomconcat recurseCGrecurseWithStatemergeInfoState mergeInfo addSubmodule submodule' unwrapCodeGentransformers-0.6.1.0-2e3aControl.Monad.Trans.Except runExceptqualifiedImportqualifiedModuleNametellCode cppIfBlock exportPartial cppCondFormat paddedLine paddedLinescomma formatExportformatExportedModulesformatToplevelformatTypeDeclssubsecWithPrefixmainSectionName formatSectionformatSubsectionExportsformatExportListlanguagePragmas cppMacrosstandardFields moduleHaddockformatHaddockComment modulePrelude importDeps moduleImports dotWithPrefixwriteModuleInfotransitiveImports genHsBootmodulePathToFilePathsanitizeescapeReservedfullyQualifiedValuefullyQualifiedType constRefsfuncRefsenumRefs methodRefs signalRefspropRefs maybeCType callbackRefs structRefs unionRefs ifaceRefs objectRefs getParentremoveDuplicates formatHaddockformatUnknownCRefformatDocSymbol formatCRefformatHyperlinkformatCodeBlock qualifiedWith formatLink formatImageformatSectionHeaderformatUnnumberedListformatNumberedListescape getDocBaseformatDocumentationdropDuplicatedgenErrorDomain FFIPtrTypeFFIPtr FFIFunPtrFreeliftFhashTableKeyMappingshashTablePtrPackers wrapTransientuintintforeignBasicTypetypeIsEnumOrFlag typePtrTypeisIgnoredStructTypefieldCallbackTypefixCallbackStructFieldsinfoType isEmbedded fieldGetter getterDocbuildFieldReader fieldSetter setterDocbuildFieldWriter fieldClearclearDocbuildFieldClearisRegularCallbackfieldTransferTypeConstraintfieldTransferTypegenFieldTransferfName labelName genAttrInfobuildFieldAttributes genZeroSUprefixedForeignImportgenBoxedGValueInstancecastProppropSetTypeConstraintpropTransferTypeConstraintpropTransferTypegenPropTransferattrTypeconstructorDoc hPropNamegenPlaceholderPropertyPatternSynonym assignValue showBasicTypeDynamicWrapper dynamicTypedynamicWrappermkForeignImportmkDynamicImport freeInArgsfreeInArgsOnErrorprepareInCallbackformatHSignaturefunPtr convertResult convertOutArgconvertOutArgsinvokeCFunction returnResultgenHaskellWrappergenWrapperBodygenCallableDebugInfoforgetClosuresgenHaskellCallbackPrototypegenCCallbackPrototypegenCallbackWrapperFactorygenWrappedCallback genClosureconvertNullablegenDropClosuresgenCallbackWrappergenSignalInfoInstanceprocessSignalErrorgenSignalConnectormethodInfoNamegenMethodResolvermethodListDocumentationnonNullableInstanceArg genNewtype genStructgenUnion fixMethodArgsgenGValueGettergenGValueSettergenGValueInstancegenCasts genObject genAPIModule genModuleCodegenConfigModuleconfCodeGenHookCabal-3.12.1.0-836f43dce0c8e8407819d14bf3e132a0bc5d74a88b39591baca03ae531902623Distribution.Simple.UserHooks UserHooksconfHook getBinDir getDataDirgetDataFileName getDynLibDir getLibDir getLibexecDir getSysconfDirversion