$Ev      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^ _ ` 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 { | } ~        !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~ !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!"""""""""""""######$$$$$%%&&&&&&&&&&& & & & & &&&&&&&&&&&&&&&&&&& &!&"&#&$&%&&&'&(&)&*&+&,&-&.&/&0&1&2&3&4&5&6&7&8&9&:&;&<&=&>&?&@&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&[&\&]&^&_&`&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'{'|%}%~%%%%())))))))))*********+++,,,--..............................................///0000000111233333333333333333333344555667777777888889NoneSX_'SafeSX_% haskell-gi;A parsed representation of gtk-doc formatted documentation. haskell-gi&A reference to some symbol in the API. haskell-gi(The language for an embedded code block. haskell-giAn item in a list, given by a list of lines (not including ending newlines). The list is always non-empty, so we represent it by the first line and then a possibly empty list with the rest of the lines. haskell-giGA link to a resource, either offline or a section of the documentation. haskell-giA parsed gtk-doc token.  haskell-gi$A section header of the given depth." haskell-gi0Parse the given gtk-doc formatted documentation.ExamplesparseGtkDoc "" GtkDoc []parseGtkDoc "func()"'GtkDoc [SymbolRef (FunctionRef "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"RGtkDoc [Literal "Call ",SymbolRef (FunctionRef "foo"),Literal " for free cookies"]HparseGtkDoc "The signal ::activate is related to gtk_button_activate()."GtkDoc [Literal "The signal ",SymbolRef (LocalSignalRef "activate"),Literal " is related to ",SymbolRef (FunctionRef "gtk_button_activate"),Literal "."]UparseGtkDoc "The signal ##%#GtkButton::activate is related to gtk_button_activate()."GtkDoc [Literal "The signal ##%",SymbolRef (SignalRef "GtkButton" "activate"),Literal " is related to ",SymbolRef (FunctionRef "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",List [ListItem (GtkDoc [Literal "First item"]) [],ListItem (GtkDoc [Literal "Second item"]) []]];parseGtkDoc "Spaced list:\n\n- First item\n\n- Second item"GtkDoc [Literal "Spaced list:\n",List [ListItem (GtkDoc [Literal "First item"]) [],ListItem (GtkDoc [Literal "Second item"]) []]]FparseGtkDoc "List with urls:\n- [test](http://test)\n- ![](image.png)"GtkDoc [Literal "List with urls:\n",List [ListItem (GtkDoc [ExternalLink (Link {linkName = "test", linkAddress = "http://test"})]) [],ListItem (GtkDoc [Image (Link {linkName = "", linkAddress = "image.png"})]) []]] haskell-gi2 eats the newline before the section header, but e does not, since it only matches at the beginning of the text. This restores the newlines eaten by , so a  / returned by the parser can always be assumed not& to have an implicit starting newline. haskell-gi. eats the newline before the list, restore it. haskell-gi6Accumulate consecutive literals into a single literal. haskell-giParser for tokens.  haskell-giParse a single token.Examples-parseOnly (parseToken <* endOfInput) "func()"&Right (SymbolRef (FunctionRef "func"))  haskell-gi3Parse a signal name, of the form > #Object::signalExamples<parseOnly (parseSignal <* endOfInput) "#GtkButton::activate"4Right (SymbolRef (SignalRef "GtkButton" "activate"))  haskell-giTParse a reference to a signal defined in the current module, of the form > ::signalExamples7parseOnly (parseLocalSignal <* endOfInput) "::activate"-Right (SymbolRef (LocalSignalRef "activate"))  haskell-gi6Parse a property name, of the form > #Object:propertyExamplesFparseOnly (parseProperty <* endOfInput) "#GtkButton:always-show-image"?Right (SymbolRef (PropertyRef "GtkButton" "always-show-image"))  haskell-gi%Parse an xml comment, of the form >  !-- comment --' Note that this function keeps spaces.Examples9parseOnly (parseComment <* endOfInput) "<!-- comment -->"Right (Comment " comment ") haskell-giFParse a reference to a virtual method, of the form > #Struct.method()Examples3parseOnly (parseVMethod <* endOfInput) "#Foo.bar()"*Right (SymbolRef (VMethodRef "Foo" "bar")) haskell-giAParse 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 (parseType <* endOfInput) "#Foo"!Right (SymbolRef (TypeRef "Foo")) haskell-gi/Parse a constant, of the form > %CONSTANT_NAMEExamples8parseOnly (parseConstant <* endOfInput) "%TEST_CONSTANT"/Right (SymbolRef (ConstantRef "TEST_CONSTANT")) haskell-gi<Parse a reference to a parameter, of the form > @param_nameExamples2parseOnly (parseParam <* endOfInput) "@test_param")Right (SymbolRef (ParamRef "test_param")) haskell-gi7Whether the given character is valid in a C identifier. haskell-gi[Name of a signal or property name. Similar to a C identifier, but hyphens are allowed too. haskell-gigSomething that could be a valid C identifier (loosely speaking, we do not need to be too strict here). haskell-giAParse a function ref, given by a valid C identifier followed by ()o, 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 (FunctionRef "test_func"))7parseOnly (parseFunctionRef <* endOfInput) "not_a_func"Right (Literal "not_a_func") 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 > urlnameExamplesBparseOnly (parseUrl <* endOfInput) "[haskell](http://haskell.org)"VRight (ExternalLink (Link {linkName = "haskell", linkAddress = "http://haskell.org"})) haskell-gi)Parse an image reference, of the form > urllabelExamples7parseOnly (parseImage <* endOfInput) "![](diagram.png)"ARight (Image (Link {linkName = "", linkAddress = "diagram.png"})) haskell-gi1Parse a code block embedded in the documentation. haskell-gi;Parse the language of a code block, specified as a comment. 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-giOParse 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.ExamplesFparseOnly (parseInitialSectionHeader <* endOfInput) "### Hello! ###\n"4Right (SectionHeader 3 (GtkDoc [Literal "Hello! "]))@parseOnly (parseInitialSectionHeader <* endOfInput) "# Hello!\n"3Right (SectionHeader 1 (GtkDoc [Literal "Hello!"])) haskell-gi~Parse a list header. Note that the newline before the start of the list is "eaten" by this parser, but is restored later by ".ExamplesCparseOnly (parseList <* endOfInput) "\n- First item\n- Second item"gRight (List [ListItem (GtkDoc [Literal "First item"]) [],ListItem (GtkDoc [Literal "Second item"]) []])`parseOnly (parseList <* endOfInput) "\n\n- Two line\n item\n\n- Second item,\n also two lines"Right (List [ListItem (GtkDoc [Literal "Two line"]) [GtkDoc [Literal "item"]],ListItem (GtkDoc [Literal "Second item,"]) [GtkDoc [Literal "also two lines"]]])  !"" ! SafeSX_S0 haskell-gipTry asking pkg-config for the version of a given module, and return the package name together with its version.1 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.0110SafeSX_6 haskell-giIDefault list of extensions to turn on when compiling the generated code.7 haskell-giXExtensions that will be used in some modules, but we do not wish to turn on by default.8 haskell-gi6Default options for GHC when compiling generated code.9 haskell-gi%Default version of the report to use.: haskell-gi#List 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-giHUnder which category in hackage should the generated bindings be listed. 23456789:;< 235<;46789:SafeSX_A haskell-giConstruct the  representation of a showable.B haskell-giThrow an error with the given .C haskell-gi3Capitalize the first character of the given string.D haskell-gi7Make the first character of the given string lowercase.E haskell-giApply the given modification function to the given symbol. If the symbol is qualified the modification will only apply to the last component.F haskell-gi:Split a list into sublists delimited by the given element.G haskell-giHRead a file assuming it is UTF-8 encoded. If decoding fails this calls  .H haskell-giWrite the given  into an UTF-8 encoded file. =>?@ABCDEFGH ?@=>CDEABGHFNoneMSX_ I haskell-giA path to a module.L 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"M 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"N haskell-gi4Append the given component to the given module path.ExamplesdotModulePath ("Foo" /. "Bar") "Foo.Bar"O haskell-gi Construct a I from a !.IJKLMNIJKLNMNoneSX_ۗ U 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  GITypelib# haskell-gi Wrapper for  GIBaseInfo$ haskell-giQAdd the given directory to the typelib search path, this is a thin wrapper over %.X 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_PATHk will be checked. In either case the system directories will be searched after the passed in directories.Y haskell-gi`Ensure that the given version of the namespace is loaded. If that is not possible we error out.& haskell-giGFind a given baseinfo by name, or give an error if it cannot be found.' haskell-gi.Get the extra information for the given field.Z haskell-giZFind out the size of a struct, and the map from field names to offsets inside the struct.[ haskell-giXFind out the size of a union, and the map from field names to offsets inside the union.( haskell-giILoad a symbol from the dynamic library associated to the given namespace.\ haskell-giLLoad a GType given the namespace where it lives and the type init function.UVWXYZ[\YXUVWZ[\ SafeSX_^ haskell-giInformation about a given allocation operation. It is either disallowed, allowed via the given function, or it is unknown at the current stage how to perform the operation.a haskell-gi@Allocation/deallocation information for a given foreign pointer.f haskell-giFA convenience function, filling in all the allocation info to unknown. ^`_abcdef abcde^`_f SafeSX_'j haskell-girThis type represents the types found in GObject Introspection interfaces: the types of constants, arguments, etc.l haskell-giGErrorm haskell-giGVariantn haskell-gi GParamSpeco haskell-gi>Zero terminated, Array Fixed Size, Array Length, Element Typep haskell-giGArrayq haskell-gi GPtrArrayr haskell-gi GByteArrays haskell-giGListt haskell-giGSListu haskell-gi GHashTablev haskell-gi,GClosure containing the given API (if known)w haskell-gi"A reference to some API in the GIRx haskell-gi`Basic types. These are generally trivial to marshal, and the GIR assumes that they are defined.y haskell-gigbooleanz haskell-gigint{ haskell-giguint| haskell-giglong} haskell-gigulong~ haskell-gigint8 haskell-giguint8 haskell-gigint16 haskell-giguint16 haskell-gigint32 haskell-giguint32 haskell-gigint64 haskell-giguint64 haskell-gigfloat haskell-gigdouble haskell-gigunichar haskell-giGType haskell-gigchar*, encoded as UTF-8 haskell-gigchar*, encoding a filename haskell-gigpointer haskell-gigintptr haskell-giguintptr haskell-gi,An alias, which is simply (Namespace, name). haskell-gi*Transfer mode for an argument or property. haskell-gi"Name for a symbol in the GIR file./jwklmnopqrstuvxyz{|}~/jwklmnopqrstuvxyz{|}~ SafeSX_/ ) haskell-gi}A 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-giGReturn 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..jwklmnopqrstuvxyz{|}~.jwklmnopqrstuvxyz{|}~ NoneSX_ , haskell-gi:Split a list into sublists delimited by the given element.- 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-giATry to load the `.gir` file corresponding to the given repository haskell-giverbose haskell-giname haskell-giversion haskell-gi searchPath NoneSX_  haskell-giGIR namespaces we know about. haskell-gi>Turn a node into an element (if it is indeed an element node). haskell-giJFind 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-giGLookup an attribute for an element, given the namespace where it lives. haskell-gi Construct a 0 by only giving the local name. haskell-gi Construct a 0 specifying a namespace too.NoneSX_ haskell-gilDocumentation 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 9:. haskell-giCParse the documentation node for the given element of the GIR file.NoneSX_  haskell-gi$Deprecation information on a symbol. haskell-giHParse the deprecation information for the given element of the GIR file.NoneSX_>u haskell-gibMonad where parsers live: we carry a context around, and can throw errors that abort the parsing. haskell-gi<A message describing a parsing error in human readable form.1 haskell-gi"Info to carry around when parsing. haskell-giThrow a parse error.2 haskell-giDBuild a textual description (for debug purposes) of a given element.3 haskell-gi&Build a name in the current namespace. haskell-giReturn the current namespace. haskell-giCheck whether there is an alias for the given name, and return the corresponding type in case it exists, and otherwise a TInterface. haskell-ginReturn the value of an attribute for the given element. If the attribute is not present this throws an error. haskell-giLike ), but allow for specifying the namespace. haskell-giIReturn the value of an attribute if it is present, and Nothing otherwise. haskell-giLike ), but allow for specifying the namespace. haskell-giAsk for an optional attribute, applying the given parser to it. If the argument does not exist return the default value provided. haskell-giBuild a  out of the (possibly qualified) supplied name. If the supplied name is unqualified we qualify with the current namespace, and otherwise we simply parse it. haskell-gi/Get the qualified name for the current element. haskell-gi'Parse the deprecation text, if present. haskell-gi2Parse the documentation info for the current node. haskell-giParse a signed integral number. haskell-gi.A boolean value given by a numerical constant. haskell-giCParse all the introspectable subelements with the given local name. haskell-gi0Parse all subelements with the given local name. haskell-giKParse all introspectable children with the given namespace and local name.4 haskell-gi<Run the given parser for a given subelement in the XML tree. haskell-gi;Run the given parser, returning either success or an error.None"#SX_T5 haskell-giMap the given type name to a x3 (defined in Data.GI.GIR.BasicTypes), if possible.6 haskell-giThe different array types.7 haskell-gi A C array8 haskell-gi A hash table.9 haskell-giParse a GClosure declaration.: haskell-giFor GLists and GSLists there is sometimes no information about the type of the elements. In these cases we report them as pointers.; haskell-gi)A type which is not a BasicType or array.< haskell-giParse a type given as a string.= haskell-gi8Parse information on a "type" element. Returns either a j, or >] indicating that the name of the type in the introspection data was "none" (associated with void in C).? haskell-gi7Find the children giving the type of the given element. haskell-gi(Find the C name for the current element. haskell-gi&Parse the C type for the current node.@ haskell-gi4Find the children giving the C type for the element.A haskell-giTry to find a type node, but do not error out if it is not found. This _does_ give an error if more than one type node is found, or if the type name is "none". haskell-gi\Parse the type of a node (which will be described by a child node named "type" or "array"). haskell-giLike , but allow for none, returned as >. haskell-gi5Parse the C-type associated to the element, if found.NoneSX_Y haskell-giMember of an enumeration. haskell-gi&Bytes used for storage of this struct.B haskell-giParse a struct member.C haskell-gi`Return the number of bytes that should be allocated for storage of the given values in an enum. haskell-gi1Parse an "enumeration" element from the GIR file.NoneSX_YNoneSX_[ haskell-giInfo about a constant.  haskell-gi-Parse a "constant" element from the GIR file.    NoneSX_] haskell-giCH name for the argument. For a escaped name valid in Haskell code, use ;<.   !"   "!NoneSX_^,-./0123456789:;,-./0123456789:;NoneSX__ @AFBCDEGHIJK @AFBCDEGHIJKNoneSX_`NOPQRSTUNOPQRSTUNoneSX_c` haskell-gi)Constructs an instance of the parent typea haskell-giA function in the namespaceb haskell-gi9A function taking the parent instance as first argument. XYZ[\]^_`abc XYZ[\]^_`abcNoneSX_d hijklmnopqrst hijklmnopqrstNoneSX_eE vwxyz{|}~ vwxyz{|}~NoneSX_fNoneSX_fNoneSX_k^ haskell-gi> if not known.D haskell-giParse a single field in a struct or union. We parse non-introspectable fields too (but set fieldVisible = False for them), this is necessary since they affect the computation of offsets of fields and sizes of containing structs.  NoneSX_l$  NoneSX_l NoneSX_pE haskell-gi&Find all aliases in a given namespace.F haskell-gi.Parse all the aliases in the current namespaceG haskell-giParse a single alias haskell-gi%Find all aliases in a given document.!None"#$SX_  haskell-gi"A rule for modifying the GIR file. haskell-gi'(Path to element, attrName), newValue. haskell-gi(Add a child node at the given selector. haskell-gi.Delete any nodes matching the given selector. haskell-gi;A name tag, which is either a name or a regular expression. haskell-gi)Node selector for a path in the GIR file. haskell-gi Node with the given "name" attr. haskell-giNode of the given type. haskell-giCombination of the above. haskell-giPath to a node in the GIR file, starting from the document root of the GIR file. This is a very simplified version of something like XPath.H haskell-gi/Parse the list of includes in a given document.I haskell-gi(Load a set of dependencies, recursively.J haskell-gi6Load a given GIR file and recursively its dependenciesK haskell-giUTurn a GIRInfoParse into a proper GIRInfo, doing some sanity checking along the way. haskell-giBare minimum loading and parsing of a single repository, without loading or parsing its dependencies, resolving aliases, or fixing up structs or interfaces. haskell-gi6Load and parse a GIR file, including its dependencies.L haskell-giList the prerequisites for a  corresponding to an interface.M haskell-gioThe list of prerequisites in GIR files is not always accurate. Instead of relying on this, we instantiate the E associated to the interface, and listing the interfaces from there.N haskell-gitThere is not enough info in the GIR files to determine whether a struct is boxed. We find out by instantiating the  corresponding to the struct (if known) and checking whether it descends from the boxed GType. Similarly, the size of the struct and offset of the fields is hard to compute from the GIR data, we simply reuse the machinery in libgirepository.O haskell-gi%Find out whether the struct is boxed.P haskell-gi}Fix the size and alignment of fields. This is much easier to do by using libgirepository than reading the GIR file directly.Q haskell-giSame thing for unions.R haskell-giLike fixupStructSizeAndOffset above.S haskell-gi7Fixup the offsets of fields using the given offset map.T haskell-giFixup parsed GIRInfos: some of the required information is not found in the GIR files themselves, but can be obtained by instantiating the required GTypes from the installed libraries.U haskell-giDGiven a XML document containing GIR data, apply the given overrides.V 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.W haskell-giDSet an attribute for the child element specified by the given path.X haskell-gi:Add the given subnode to any nodes matching the given pathY haskell-gi)Delete any nodes matching the given path.Z haskell-giMLookup the given attribute and if present see if it matches the given regex.[ haskell-gi<See if a given node specification applies to the given node.I haskell-giVerbose haskell-gi Requested haskell-gi Loaded so far haskell-giextra path to search haskell-gifixups haskell-giNew loaded setJ haskell-giverbose haskell-giname haskell-giversion haskell-giextra paths to search haskell-gifixups haskell-gi(loaded doc, dependencies) haskell-giverbose haskell-giname haskell-giversion haskell-giextra paths to search haskell-gibare parsed document haskell-giverbose haskell-giname haskell-giversion haskell-giextra paths to search haskell-gifixups haskell-gi(parsed doc, parsed deps)^`_abcdef    ,-./0123456789:@AFBCDEGHIJNOPQRSTXYZ[\]^_`abhijklmnopqrsvwxyz{|}~abcde^`_f 6789:_`ab   @AFBCDEGHIJNOPQRST,-./012345vwxyz{|}~XYZ[\]^hijklmnopqrs"None%SX_1\ haskell-giKnown operating systems.] haskell-giXWe 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 current namespace.` haskell-giCThe contents of the override file will be ignored if there is any a value here. if( primitive push (prepend) values here, endif pop them.b haskell-gi Ignored elements of a given API.c haskell-gi?Ignored APIs (all elements in this API will just be discarded).d haskell-gi9Structs for which accessors should not be auto-generated.e haskell-gi-Explicit calloc/copy/free for structs/unions. haskell-gi;Mapping from GObject Introspection namespaces to pkg-config haskell-gi0Version number for the generated .cabal package. haskell-gi"Prefered version of the namespace. haskell-giFixups for the GIR data. haskell-gi&Known places where to find the C docs.f haskell-gi*Construct the generic config for a module.g haskell-gi$Addition of overrides is meaningful.h haskell-giDefault, empty, parser state.i haskell-giGet the current namespace.j 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.k haskell-giTParse a single line of the config file, modifying the configuration as appropriate.l haskell-giIgnored elements.m haskell-giSealed structures.n haskell-gi.Explicit allocation info for wrapped pointers.o haskell-gi:Parse a explicit key=value pair into a (key, value) tuple.p haskell-gi<Mapping from GObject Introspection namespaces to pkg-config.q haskell-gi-Choose a preferred namespace version to load.r haskell-gi-Specifying the cabal package version by hand.s haskell-gi&Set a given attribute in the GIR file.t haskell-gi8Add the given child node to all nodes matching the path.u haskell-gi)Delete all nodes matching the given path.v haskell-gi/Parse a documentation URL for the given module.w haskell-gi<Parse a path specification, which is of the form "nodeSpec1 nodeSpec2_../nodeSpecN", where nodeSpec is a node specification of the form "nodeType[:name attribute]".x haskell-giXA specification of a name, which is either a regex (prefixed with "~") or a plain name.y haskell-gi"Parse a single node specification.z haskell-gi+Parse an XML name, with an optional prefix.{ haskell-gi0Check whether we are running under the given OS.| haskell-gi3Parse a textual representation of a version into a =>.} haskell-gi\Check 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-giAParse the given overrides file, and merge into the given context. haskell-giIFilter 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-giLLoad 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.#NoneSX_  haskell-gi#Name of the module being generated. haskell-giWhether to print extra info. haskell-gi0List of loaded overrides for the code generator.$NoneSX_j 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-giZGuess the nullability for a property, given the list of methods for the object/interface. haskell-gi|Guess whether "get" on the given property may return NULL, based on the corresponding "get_prop_name" method, if it exists. haskell-gi|Guess 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-ginDrop 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 a associated destroyer for the user_data, but no associated user_data, drop the destroyer annotation.&NoneMSX_ haskell-gi0A subsection name, with an optional anchor name. haskell-gi"Possible features to test via CPP. haskell-giEnable overloading haskell-gi&Code generators that can throw errors. haskell-gi+The code generator monad, for generators that cannot throw errors. The fact that they cannot throw errors is encoded in the forall, which disallows any operation on the error, except discarding it or passing it along without inspecting. This last operation is useful in order to allow embedding  computations inside Y computations, while disallowing the opposite embedding without explicit error handling. haskell-gi+The base type for the code generator monad. 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-gi4Active CPP conditionals, outermost condition first. haskell-giNext unused type variable. haskell-gi%Set of errors for the code generator. haskell-gi#Information for the code generator. haskell-giAmbient config. haskell-gi APIs available to the generator. haskell-gi*Map from C references to Haskell symbols. 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-giDUse the standard prelude, instead of the haskell-gi-base short one.  haskell-gi"Information on a generated module. haskell-giFull module name: [Gtk, Label].  haskell-giGenerated code for the module. haskell-gi(Interfaces going into the .hs-boot file. haskell-gi%Indexed by the relative module name. haskell-gi$Set of dependencies for this module. haskell-giExports for the module. haskell-giQualified (source) imports. haskell-gi'Set of language pragmas for the module. haskell-gi%GHC options for compiling the module. haskell-giFlags for the module. haskell-gi9Documentation for the different sections in the module. haskell-gi1Minimal version of base the module will work on. 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-giWhich kind of export. haskell-giActual symbol to export. haskell-gi3Protect the export by the given CPP export guards. haskell-giSymbol to export. haskell-gi`Known subsections. The ordering here is the ordering in which they will appear in the haddocks. haskell-gisSubsection 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-giAIncrease 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 c 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-gizRun 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 M, but we allow for explicitly setting the state of the inner code generator. haskell-giLike V, 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-giIAdd 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-gimRun 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 T. 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-gi{Run 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-gitReturn the transitive set of dependencies, i.e. the union of those of the module and (transitively) its submodules.& haskell-giwGiven 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-giTConstruct a simplified version of the module name, suitable for a qualified import.' haskell-giPReturn the minimal base version supported by the module and all its submodules.( haskell-giMGive a friendly textual description of the error for presenting to the user., haskell-gi0Get a type variable unused in the current scope.- haskell-giXIntroduce a new scope for type variable naming: the next fresh variable will be called a./ haskell-giVFind 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.1 haskell-gi&Print out a (newline-terminated) line.2 haskell-giLPrint out the given line both to the normal module, and to the HsBoot file.3 haskell-gi A blank line4 haskell-gi.Increase the indent level for code generation.5 haskell-giOIncrease the indentation level for the rest of the lines in the current group.6 haskell-giGroup a set of related code. haskell-giGuard a block of code with #if.7 haskell-gieGuard a code block with CPP code, such that it is included only if the specified feature is enabled.8 haskell-giCWrite the given code into the .hs-boot file for the current module. haskell-gi#Add a export to the current module.9 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-giHSet 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.A haskell-gi&Add documentation for a given section. haskell-giFormat a CPP conditional.B haskell-gi$Return a text representation of the . haskell-giPPad a line to the given number of leading spaces, and add a newline at the end. 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-gi<User-facing name in the Haddocks for the given main section. haskell-gi+Format a given section made of subsections. haskell-gi1Format the list of exports into grouped sections. haskell-giJFormat the given export list. This is just the inside of the parenthesis. haskell-gi(Write down the list of language pragmas. haskell-gi#Write down the list of GHC options. haskell-gi%Generate some convenience CPP macros. haskell-gi!Standard fields for every module. haskell-giFThe haddock header for the module, including optionally a description. haskell-gi1Format the comment with the module documentation. haskell-gi:Generic module prelude. We reexport all of the submodules. haskell-giCode for loading the needed dependencies. One needs to give the prefix for the namespace being currently generated, modules with this prefix will be imported as {- SOURCE --}, and otherwise will be imported normally. haskell-giStandard imports. haskell-giLike M, but add a "GI." prefix. haskell-gi{Write to disk the code for a module, under the given base directory. Does not write submodules recursively, for that use C. haskell-gi0Generate the .hs-boot file for the given module. haskell-gi9Construct the filename corresponding to the given module.C haskell-giWrite down the code for a module and its submodules to disk under the given base directory. It returns the list of written modules.D haskell-giReturn the list of modules C9 would write, without actually writing anything to disk.G      !"#$%&'()*+,-./0123456789:;<=>?@ABCDG    #"CDB%' $&()*+45213678<=>?@,-9:;A./0 !'None%SX_f haskell-gibReturn a qualified form of the constraint for the given name (which should correspond to a valid w).g haskell-giSame as f;, but applicable directly to a type. The type should be a w$, otherwise an error will be raised.h haskell-giMForeign type associated with a callback type. It can be passed in qualified.i haskell-giIHaskell type exposing the closure arguments, which are generally elided.j haskell-gi\The name of the dynamic wrapper for the given callback type. It can be passed in qualified.k haskell-gigThe name of the Haskell to foreign wrapper for the given callback type. It can be passed in qualified.l 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.m 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.n haskell-gi,The name for the foreign wrapper allocator (foreign import "wrapper" ...>) for the given callback type. It can be passed in qualified.o haskell-gi_The 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_"p haskell-giSame as q, but accepts a 4. The namespace part of the name will be discarded.Examples"lowerName (Name "Gtk" "main_quit") "mainQuit"q haskell-giLTurn the given identifier into camelCase, starting with a lowercase letter.ExampleslowerSymbol "main_quit" "mainQuit"r haskell-giTurn the given 0 into CamelCase, starting with a capital letter.Examples upperName (Name "Foo" "bar_baz")"BarBaz"s 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.t haskell-giOReturn an identifier for the given interface type valid in the current module.u haskell-gi>Construct an identifier for the given symbol in the given API.v haskell-giVSave a bit of typing for optional arguments in the case that we want to pass Nothing.w haskell-gi3Turn a hyphen-separated identifier into camel case.Examples&hyphensToCamelCase "one-sample-string""OneSampleString"x haskell-gi Similarly to w, 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"y haskell-gigName 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.z haskell-gi@Qualified name for the "(sigName, info)" tag for a given signal.{ haskell-gi@Return the name for the signal in Haskell CamelCase conventions.fghijklmnopqrstuvwxyz{pqrvyfgwxhimjnklo{zstu%NoneSX_ 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 ?@.| haskell-giDAn identifier at the value level: functions, data constructors, ...} haskell-gi An identifier at the type level.~ haskell-giLink to a module. haskell-giALink to an anchor inside a given module, with an optional label. haskell-gi;Obtain the absolute location of the module where the given  lives. haskell-gi6Obtain the fully qualified symbol pointing to a value. haskell-gi5Obtain the fully qualified symbol pointing to a type. haskell-gi^Extract 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-gi\Extract 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-giXGiven 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.|}~|}~(NoneSX_B haskell-gi\A list of all overloadable identifiers in the set of APIs (current properties and methods).)NoneSX_  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<Compute the (ordered) list of parents of the current object. haskell-giIt is sometimes the case that a property name or signal is defined both in an object and in one of its ancestors/implemented interfaces. This is harmless if the properties are isomorphic (there will be more than one qualified set of property setters/getters that we can call, but they are all isomorphic). If they are not isomorphic we print a warning, and choose to use the one closest to the leaves of the object hierarchy. haskell-giUList all properties defined for an object, including those defined by its ancestors. haskell-gi\List all properties defined for an interface, including those defined by its prerequisites. haskell-giRList all signals defined for an object, including those defined by its ancestors. haskell-giYList all signals defined for an interface, including those defined by its prerequisites. haskell-giRList all methods defined for an object, including those defined by its ancestors. haskell-giYList all methods defined for an interface, including those defined by its prerequisites.*NoneSX_& haskell-gi~Where is the documentation located with respect to the relevant symbol, useful for determining whether we want to start with | or ^. haskell-giGiven a , a map from C identifiers to Haskell symbols, and a location online where to find the C documentation, render the corresponding Haddock-formatted text. Note that the comment delimiters are not included in the output.ExamplesFformatHaddock M.empty "" (GtkDoc [Literal "Hello ", Literal "World!"])"Hello World!"Alet c2h = M.fromList [(FunctionRef "foo", ValueIdentifier "foo")]=formatHaddock c2h "" (GtkDoc [SymbolRef (FunctionRef "foo")])"'foo'"*let onlineDocs = "http://wiki.haskell.org"[formatHaddock M.empty onlineDocs (GtkDoc [ExternalLink (Link "GI" "GObjectIntrospection")])3"<http://wiki.haskell.org/GObjectIntrospection GI>"aformatHaddock M.empty "a" (GtkDoc [List [ListItem (GtkDoc [Image (Link "test" "test.png")]) []]])"\n* <<a/test.png test>>\n" haskell-gi Format a + whose Haskell representation is not known. 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-giNQualify 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-gi2Escape the reserved Haddock characters in a given .Examples escape "\"""\\\""escape "foo@bar.com""foo\\@bar.com"escape "C:\\Applications""C:\\\\Applications" haskell-gicGet 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-gizFormat 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 A, 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-giHAdd the given text to the documentation for the section being generated.  +NoneSX_(R haskell-gi3Check whether the given name descends from GObject.,NoneSX_+ haskell-gi+Generate the overloaded signal connectors: Clicked,  ActivateLink, ... haskell-gi/Signal instances for (GObject-derived) objects. haskell-gi Signal instances for interfaces.-NoneSX_0 haskell-gioGiven a list of named enum members, filter out those that have the same value as a previous entry in the list. haskell-giZVery similar to enums, but we also declare ourselves as members of the IsGFlag typeclass. haskell-gi,Support for enums encapsulating error codes..None4SX_w8 haskell-gi#Distinct types of foreign pointers. haskell-gi Ordinary Ptr. haskell-giFunPtr. haskell-gi&Information on how to allocate a type. haskell-gi In bytes. haskell-gi^Whether 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-giPGiven an array, together with its type, return the code for reading its length.  haskell-giTry to find the hash and equalO 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 C, but with slightly different borrowing semantics: in the case of < 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.3This 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/97MAnother 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-giFThis translates GI types to the types used for generated Haskell code. haskell-giOWhether the callable has closure arguments (i.e. "user_data" style arguments). haskell-gi7Check whether the given type corresponds to a callback. haskell-giBasically like , but for types which admit a "isomorphic" version of the Haskell type distinct from the usual Haskell type. Generally the Haskell type we expose is isomorphic to the foreign type, but in some cases, such as callbacks with closure arguments, this does not hold, as we omit the closure arguments. This function returns a type which is actually isomorphic. There is another case this function deals with: for convenience untyped v types have a type variable on the Haskell side when they are arguments to functions, but we do not want this when they appear as arguments to callbacks/signals, or return types of properties, as it would force the type synonym/type family to depend on the type variable.  haskell-gi6Foreign (C) type associated to one of the basic types.  haskell-gi5Whether the give type corresponds to an enum or flag. haskell-gi8Information on how to allocate the given type, if known. haskell-gi0Returns whether the given type corresponds to a  ManagedPtr" instance (a thin wrapper over a  ForeignPtr). haskell-giJReturns whether the given type is represented by a pointer on the C side. haskell-gi|For those types represented by pointers on the C side, return the type of pointer which represents them on the Haskell FFI. haskell-gijIf the passed in type is nullable, return the conversion function between the FFI pointer type (may be a Ptr or a FunPtr) and the corresponding + type. haskell-giiAn appropriate NULL value for the given type, for types which are represented by pointers on the C side. haskell-gi;Returns whether the given type should be represented by a +& type on the Haskell side. This applies to all properties which have a C representation in terms of pointers, except for G(S)Lists, for which NULL is a valid G(S)List, and raw pointers, which we just pass through to the Haskell side. Notice that introspection annotations can override this. haskell-gitIf the given type maps to a list in Haskell, return the type of the elements, and the function that maps over them.$$/NoneSX_H haskell-giPFree a container and/or the contained elements, depending on the transfer mode. haskell-giGiven an input argument to a C callable, and its label in the code, return the list of actions relevant to freeing the memory allocated for the argument (if appropriate, depending on the ownership transfer semantics of the callable). haskell-giSame thing as freeInArg, but called in case the call to C didn't succeed. We thus free everything we allocated in preparation for the call, including args that would have been transferred to C.0NoneSX_  haskell-gi8Whether (not) to generate bindings for the given struct. haskell-gi8Whether the given type corresponds to an ignored struct. haskell-giKCanonical name for the type of a callback type embedded in a struct field. haskell-girFix the interface names of callback fields in the struct to correspond to the ones that we are going to generate. haskell-giFix the interface names of callback fields in an APIStruct to correspond to the ones that we are going to generate. If something other than an APIStruct is passed in we don't touch it. haskell-giExtract the callback types embedded in the fields of structs, and at the same time fix the type of the corresponding fields. Returns the list of APIs associated to this struct, not including the struct itself. haskell-giMThe name of the type encoding the information for a field in a struct/union. haskell-gi2Whether a given field is an embedded struct/union. haskell-giName for the getter function haskell-gi,Generate documentation for the given getter. haskell-giExtract a field from a struct. haskell-giName for the setter function haskell-gi,Generate documentation for the given setter. haskell-gibWrite a field into a struct. Note that, since we cannot know for sure who will be deallocating the fields in the struct, we leave any conversions that involve pointers to the caller. What this means in practice is that scalar fields will get marshalled to/from Haskell, while anything that involves pointers will be returned in the C representation. haskell-giName for the clear function haskell-giDocumentation for the clear method. haskell-giWrite a NULL" into a field of a struct of type Ptr. haskell-giReturn whether the given type corresponds to a callback that does not throw exceptions. See [Note: Callables that throw] for the reason why we do not try to wrap callbacks that throw exceptions. haskell-giSThe types accepted by the allocating set function 'Data.GI.Base.Attributes.(:&=)'. haskell-giThe type generated by AB0 for this field. This type should satisfy the CD for the type.  haskell-giGenerate the field transfer function, which marshals Haskell values to types that we can set, even if we need to allocate memory.! haskell-giHaskell name for the field" haskell-giLabel associated to the field.# haskell-giSupport for modifying fields as attributes. Returns a tuple with the name of the overloaded label to be used for the field, and the associated info type.$ haskell-giBuild code for a single field. haskell-gi+Generate code for the given list of fields.% haskell-giGenerate a constructor for a zero-filled struct/union of the given type, using the boxed (or GLib, for unboxed types) allocator. haskell-giSpecialization for structs of %. haskell-giSpecialization for unions of %.& haskell-gi)Construct a import with the given prefix.' haskell-giSame as &, but import a FunPtr to the symbol. haskell-giUGenerate the typeclass with information for how to allocate/deallocate a given type.1NoneSX_Ɍ ( haskell-gi8The constraint for setting the given type in properties.) haskell-gi?The constraint for transferring the given type into a property.* haskell-gi The type of the return value of  attrTransfer for the given type.+ haskell-giUGiven a value "v" of the given Haskell type, satisfying the constraint generated by )D, convert it (allocating memory is necessary) to the type given by *., haskell-gisGiven a property, return the set of constraints on the types, and the type variables for the object and its value.- haskell-gi,Generate documentation for the given setter.. haskell-gi,Generate documentation for the given getter./ haskell-gi1Generate documentation for the given constructor.0 haskell-gi,Generate documentation for the given setter.1 haskell-giThe property name as a lexically valid Haskell identifier. Note that this is not escaped, since it is assumed that it will be used with a prefix, so if a property is named "class", for example, this will return "class".2 haskell-giNThe name of the type encoding the information for the property of the object.3 haskell-giQGenerate a placeholder property for those cases in which code generation failed. haskell-gikGenerate gtk2hs compatible attribute labels (to ease porting). These are namespaced labels, for examples widgetSensitive. We take the list of methods, since there may be name clashes (an example is Auth::is_for_proxy method in libsoup, and the corresponding Auth::is-for-proxy property). When there is a clash we give priority to the method.2NoneSX_I4 haskell-giData for a bidrectional pattern synonym. It is either a simple one of the form "pattern Name = value :: Type" or an explicit one of the form > pattern Name  -(view -; value) :: Type where > Name = expression value :: Type5 haskell-gitAssign to the given name the given constant value, in a way that can be assigned to the corresponding Haskell type.6 haskell-giTShow a basic type, in a way that can be assigned to the corresponding Haskell type.3NoneSX_ 7 haskell-gi$Information about a dynamic wrapper.8 haskell-giHaskell dynamic wrapper9 haskell-giEName of the type synonym for the type of the function to be wrapped. 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-gikGenerate a foreign import for the given C symbol. Return the name of the corresponding Haskell identifier.; haskell-giMake a wrapper for foreign FunPtrOs 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-gidGiven 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-gieThe 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.A haskell-gi2Convert the result of the foreign call to Haskell.B haskell-givMarshal a foreign out argument to Haskell, returning the name of the variable containing the converted Haskell value.C haskell-giConvert the list of out arguments to Haskell, returning the names of the corresponding variables containing the marshaled values.D haskell-gi3Invoke the given C function, taking care of errors.E haskell-gi@Return the result of the call, possibly including out arguments.F haskell-gi:Generate a Haskell wrapper for the given foreign function.G haskell-giFGenerate the body of the Haskell wrapper for the given foreign symbol. haskell-gi{caller-allocates arguments are arguments that the caller allocates, and the called function modifies. They are marked as outA 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.H haskell-gi!Some debug info for the callable. haskell-gi(Generate a wrapper for a known C symbol.I haskell-giLFor callbacks we do not need to keep track of which arguments are closures. haskell-gi|Generate a wrapper for a dynamic C symbol (i.e. a Haskell function that will invoke its first argument, which should be a FunPtru of the appropriate type). The caller should have created a type synonym with the right type for the foreign symbol.4NoneSX_,k J haskell-giWThe prototype of the callback on the Haskell side (what users of the binding will see)K haskell-giwGenerate the type synonym for the prototype of the callback on the C side. Returns the name given to the type synonym.L haskell-gi&Generator for wrappers callable from CM haskell-giWrap the Haskell cb\ callback into a foreign function of the right type. Returns the name of the wrapped value.N haskell-giGenerator of closuresO haskell-gi3A simple wrapper that drops every closure argument.P 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).Q haskell-gi<Generate the given signal instance for the given API object.R haskell-ginWrite some simple debug message when signal generation fails, and generate a placeholder SignalInfo instance. haskell-gi Generate a wrapper for a signal.S haskell-giXGenerate the code for connecting the given signal. This assumes that it lives inside a do block.S haskell-gi Callback type haskell-gi)SignalConnectBefore or SignalConnectAfter haskell-giDetail{{5NoneSX_3T haskell-gi/Qualified name for the info for a given method.U haskell-giAAppropriate instances so overloaded labels are properly resolved. haskell-gi Generate the  MethodList> instance given the list of methods for the given named type. haskell-gi Generate the  MethodInfo( type and instance for the given method. haskell-gikGenerate a method info that is not actually callable, but rather gives a type error when trying to use it.6NoneSX_@V haskell-gi1Standard derived instances for newtypes wrapping  ManagedPtrs.W haskell-gi4Generate the GValue instances for the given GObject.X haskell-gi Generate wrapper for structures.Y haskell-giGenerated wrapper for unions.Z 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-gi4Generate the GValue instances for the given GObject.\ 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.7NoneSX_Th haskell-giIncluded overrides file. haskell-gi3Tag for the override, for error reporting purposes.^ haskell-gi'Generate the code for the given module._ haskell-giOWrite a module containing information about the configuration for the package.` haskell-giA convenience helper for a@, 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-giThe entry point for Setup.hs files in bindings. haskell-gi Return the list of modules that X would create, together with the set of dependencies loaded while generating the code.^ haskell-giname haskell-giversion haskell-giverbose haskell-giExplicit overrides` haskell-giname haskell-giversion haskell-giverbose haskell-gioverrides file haskell-giother overrides haskell-gi output dir haskell-gi previous a haskell-giname haskell-giversion haskell-giverbose haskell-gioverrides file haskell-gi output dir haskell-giname haskell-giversion haskell-giverbose haskell-gioverrides file haskell-giExplicit overrides haskell-gi output dir haskell-giname haskell-giversion haskell-giOverrides file haskell-giOther overrides to loadESafeSX_Tbcdefghi8NoneSX_uj haskell-giInfo for a given package.k haskell-ginObtain the minor version. That is, if the given version numbers are x.y.z, so branch is [x,y,z], we return y.l haskell-giEObtain the haskell-gi minor version. Notice that we only append the minor version here, ignoring revisions. (So if the version is x.y.z, we drop the "z" part.) This gives us a mechanism for releasing bug-fix releases of haskell-gi without increasing the necessary dependency on haskell-gi-base, which only depends on x.y.m haskell-giIf the haskell-gi version is of the form x.y[.z] and the pkgconfig version of the package being wrapped is a.b.c, this gives something of the form x.a.b.y.This strange seeming-rule is so that the packages that we produce follow the PVP, assuming that the package being wrapped follows the usual semantic versioning convention (http://semver.org) that increases in "a" indicate non-backwards compatible changes, increases in "b" backwards compatible additions to the API, and increases in "c" denote API compatible changes (so we do not need to regenerate bindings for these, at least in principle, so we do not encode them in the cabal version).In order to follow the PVP, then everything we need to do in the haskell-gi side is to increase x everytime the generated API changes (for a fixed a.b.c version).HIn any case, if such "strange" package numbers are undesired, or the wrapped package does not follow semver, it is possible to add an explicit cabal-pkg-version override. This needs to be maintained by hand (including in the list of dependencies of packages depending on this one), so think carefully before using this override!n haskell-giODetermine the next version for which the minor of the package has been bumped. haskell-giDetermine the pkg-config name and installed version (major.minor only) for a given module, or throw an exception if that fails.o haskell-giGiven a string a.b.c..., representing a version number, determine the major and minor versions, i.e. "a" and "b". If successful, return (a,b). haskell-giGenerate the cabal project.pFGHIJKLMNNOPQRSTUVWXYYZZ[[\]^_`abcdefg:hijklmnopqrstuvwxyz{|}~                                                                 !"#$%&'()**+,-.//0123456789::;<==>?@ABCDEEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcddefghijklmnopqrstuvwwxyz{|}~ !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!! ! ! ! ! !!"""""""""""""##### #!$"$#$$$%$&%'%(&)&*&+&,&-&.&/&0&1&2&3&4&5&6&7&8&9&:&;&<&=&>&?&@&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&[&\&]&^&_&`&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&{&|&}&~&&&&&&&&&&&&&&&&&&''''''''''''''''''''<''%%%%%%())))))))))*********+++,,,--..............................................///00000001112333333333 3 3 3 3 33333333445556677777 7!7"8#8$8u8%8&'()*+,-./r012'C3456789:;<=>?@ABCDECFGHIJKLMN OPQRCST U V WXYZ[\]^_`abcdefCSghijklm n o p!q!r!s!t!u!v!w!x!y!z!{!|!}!~!!!!!!"""""PQ"""""""""""""""""""""""""""""""""""$$$$$$$$$&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&CF&&&&&&&&&&&&&&&&&&&&&&&&&&}&&&&&&&&&& & ' ' % %%%%%%%%%%%%%())*** *!*"*#*$*%*&*'*(*)**-+-,.-.../.0.1.2.3.4.5.6.708090:0;0<0=0>0?0@0A0B0C0D0E0F0G0H0I0J0K0L0M0N0O0P1Q1R1S1T1U1A1>1V1D1W1;1X2Y2Z2[3\3]3^3_3`3a3b3c3d3e3f3g3h3i3j3k3l3m3n4o4p4q4r4s4t4u4v4w4x5y5z6{6|6}6~6666777EEEEEEEE888888haskell-gi-0.23.0-inplaceData.GI.CodeGen.GTypeData.GI.GIR.ParserData.GI.CodeGen.GtkDocData.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.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.SymbolNaming Data.GI.CodeGen.OverloadedLabelsData.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.CabalHooksData.GI.CodeGen.Cabal Data.GI.GIR parseGtkDocGI.SymbolNamingescapedArgName Data.VersionVersionGI.Gtk.Objects.Widgetshow Data.GI.Base attrTransferData.GI.Base.AttributesAttrSetTypeConstraintPaths_haskell_gihaskell-gi-base-0.23.0-inplaceData.GI.Base.BasicTypesGTypeTxml-conduit-1.8.0.1-56a86325ee4dda20f43e9d367880b1bf92475fe0f8424aaf476e5ca0d5482c77Text.XMLElementgtypeIsA gtypeIsBoxedGtkDocCRef FunctionRefParamRef ConstantRef SignalRefLocalSignalRef PropertyRef VMethodRefStructFieldRefTypeRefLanguageListItemLinklinkName linkAddressTokenLiteralCommentVerbatim CodeBlock ExternalLinkImageList SectionHeader SymbolRef $fShowLink$fEqLink$fShowLanguage $fEqLanguage $fShowCRef$fEqCRef $fOrdCRef $fShowGtkDoc $fEqGtkDoc $fShowToken $fEqToken$fShowListItem $fEqListItem tryPkgConfigpkgConfigGetVersionhomepageauthors maintainerslicensedefaultExtensionsotherExtensions ghcOptionsdefaultLanguage standardDepscategory licenseTextpadTo withCommentprime parenthesizetshowterrorucFirstlcFirstmodifyQualifiedsplitOn utf8ReadFile utf8WriteFile ModulePathmodulePathToList toModulePath dotModulePath/.$fIsStringModulePath$fSemigroupModulePath$fMonoidModulePath$fEqModulePath$fShowModulePath$fOrdModulePath FieldInfofieldInfoOffsetsetupTypelibSearchPath girRequiregirStructFieldInfogirUnionFieldInfo girLoadGType$fBoxedObjectBaseInfo AllocationOpAllocationOpUnknownAllocationInfo allocCalloc allocCopy allocFreeunknownAllocationInfo$fShowAllocationOp$fEqAllocationOp$fShowAllocationInfoType TBasicTypeTErrorTVariant TParamSpecTCArrayTGArray TPtrArray TByteArrayTGListTGSListTGHash TGClosure TInterface BasicTypeTBooleanTIntTUIntTLongTULongTInt8TUInt8TInt16TUInt16TInt32TUInt32TInt64TUInt64TFloatTDoubleTUniCharTGTypeTUTF8 TFileNameTPtrTIntPtrTUIntPtrAliasTransferTransferNothingTransferContainerTransferEverythingName namespacename$fEqName $fOrdName $fShowName$fShowTransfer $fEqTransfer $fOrdTransfer $fOrdAlias $fEqAlias $fShowAlias $fEqBasicType$fShowBasicType$fOrdBasicType$fEqType $fShowType $fOrdTypeTypeReptypeShow typeConNameconcon0ioptrfunptrmaybeT $fEqTypeCon $fEqTypeRepreadGiRepositoryGIRXMLNamespace GLibGIRNSCGIRNS CoreGIRNS nodeToElement subelements localNamechildElemsWithLocalNamechildElemsWithNSNamefirstChildWithLocalNamegetElementContent lookupAttrlookupAttrWithNamespace xmlLocalName xmlNSName$fShowGIRXMLNamespace Documentation rawDocText sinceVersionqueryDocumentation$fShowDocumentation$fEqDocumentation$fOrdDocumentationDeprecationInfodeprecatedSinceVersiondeprecationMessagequeryDeprecated$fShowDeprecationInfo$fEqDeprecationInfoParser ParseError parseErrorcurrentNamespaceresolveQualifiedTypeNamegetAttrgetAttrWithNamespace queryAttrqueryAttrWithNamespace optionalAttr qualifyName parseNameparseDeprecationparseDocumentation parseIntegral parseBoolparseChildrenWithLocalNameparseAllChildrenWithLocalNameparseChildrenWithNSName runParser$fShowParseContext queryCType parseCType parseTypeparseOptionalTypequeryElementCTypeEnumerationMemberenumMemberNameenumMemberValue enumMemberCId enumMemberDoc Enumeration enumMembersenumErrorDomain enumTypeInitenumDocumentation enumCTypeenumStorageBytesenumDeprecated parseEnum$fShowEnumerationMember$fShowEnumerationFlags parseFlags $fShowFlagsConstant constantType constantValue constantCTypeconstantDocumentationconstantDeprecated parseConstant$fShowConstantArgargCNameargType direction mayBeNullargDocargScope argClosure argDestroyargCallerAllocatestransferScopeScopeTypeInvalid ScopeTypeCallScopeTypeAsyncScopeTypeNotified Direction DirectionIn DirectionOutDirectionInout parseTransferparseArg$fShowDirection $fEqDirection$fOrdDirection $fShowScope $fEqScope $fOrdScope $fShowArg$fEqArg$fOrdArgPropertypropNamepropType propFlagspropReadNullablepropWriteNullable propTransferpropDocpropDeprecated PropertyFlagPropertyReadablePropertyWritablePropertyConstructPropertyConstructOnly parseProperty$fShowPropertyFlag$fEqPropertyFlag$fShowProperty $fEqPropertyCallable returnTypereturnMayBeNullreturnTransferreturnDocumentationargs skipReturncallableThrowscallableDeprecatedcallableDocumentation parseCallable$fShowCallable $fEqCallableSignalsigName sigCallable sigDeprecated sigDetailedsigDoc parseSignal $fShowSignal $fEqSignalMethod methodName methodSymbol methodType methodMovedTomethodCallable MethodType ConstructorMemberFunctionOrdinaryMethod parseMethod$fEqMethodType$fShowMethodType $fEqMethod $fShowMethodObject objParent objTypeInit objTypeNameobjCType objInterfaces objDeprecatedobjDocumentation objMethods objProperties objSignals parseObject $fShowObject Interface ifTypeInitifCTypeifDocumentationifPrerequisites ifProperties ifSignals ifMethodsifAllocationInfo ifDeprecatedparseInterface$fShowInterfaceFunctionfnSymbol fnMovedTo fnCallable parseFunction$fShowFunctionCallback cbCallablecbCTypecbDocumentation parseCallback$fShowCallback FieldInfoFlagField fieldName fieldVisible fieldTypefieldIsPointer fieldCallback fieldOffset fieldFlagsfieldDocumentationfieldDeprecated parseFields$fShowFieldInfoFlag $fShowFieldUnion unionIsBoxedunionAllocationInfounionDocumentation unionSize unionTypeInit unionFields unionMethods unionCTypeunionDeprecated parseUnion $fShowUnionStruct structIsBoxedstructAllocationInfostructTypeInit structCType structSizegtypeStructForstructIsDisguisedstructForceVisible structFields structMethodsstructDeprecatedstructDocumentation parseStruct $fShowStructdocumentListAliasesAPIAPIConst APIFunction APICallbackAPIEnumAPIFlags APIInterface APIObject APIStructAPIUnionGIRRule GIRSetAttr GIRAddNode GIRDeleteNode GIRNameTag GIRPlainNameGIRRegex GIRNodeSpecGIRNamedGIRType GIRTypedNameGIRPathGIRInfo girPCPackages girNSName girNSVersiongirAPIs girCTypesloadRawGIRInfo loadGIRInfo$fShowGIRNameTag$fShowGIRNodeSpec $fShowGIRRule $fShowAPI$fShowGIRNamespace$fShowGIRInfoParse $fShowGIRInfo Overrides pkgConfigMapcabalPkgVersionnsChooseVersion girFixups onlineDocsMapparseOverridesfilterAPIsAndDeps$fSemigroupOverrides$fMonoidOverrides$fShowOverrides$fShowParserState $fShowOSTypeConfigmodNameverbose overrides $fShowConfigdropMovedItemsguessPropertyNullability detectGObjectdropDuplicatedFieldscheckClosureDestructors Hyperlink cToHaskellMapCPPGuardCPPOverloading ExcCodeGenCodeGen BaseCodeGenCGErrorCGErrorNotImplementedCGErrorBadIntrospectionInfoCGErrorMissingInfo BaseVersionBase47Base48 ModuleFlagImplicitPrelude ModuleInfo moduleCode sectionDocs NamedSection MethodSectionPropertySection SignalSection EnumSection FlagSectionHaddockSectionToplevelSectionNamedSubsectionCodeshowBaseVersionrecurseWithAPIs submodule handleCGExcgetDepsconfig currentModulegetAPIs getC2HMap evalCodeGengenCoderegisterNSDependencytransitiveModuleDeps qualifiedminBaseVersiondescribeCGErrornotImplementedError badIntroErrormissingInfoErrorgetFreshTypeVariableresetTypeVariableScopefindAPIgetAPI findAPIByNamelineblineblankindentincreaseIndentgroupcppIfhsBoot exportModule exportDeclexportsetLanguagePragmasaddLanguagePragma setGHCOptionssetModuleFlagssetModuleMinBaseaddSectionFormattedDocs codeToTextwriteModuleTreelistModuleTree$fEqCPPConditional$fShowCPPConditional$fOrdCPPConditional $fEqCodeToken$fOrdCodeToken$fShowCodeToken$fSemigroupCode $fMonoidCode$fEqCode $fShowCode $fOrdCode$fShowNamedSection$fEqNamedSection$fOrdNamedSection$fShowHaddockSection$fEqHaddockSection$fOrdHaddockSection$fShowExportType$fEqExportType$fOrdExportType $fShowExport $fEqExport $fOrdExport$fShowModuleFlag$fEqModuleFlag$fOrdModuleFlag$fShowBaseVersion$fEqBaseVersion$fOrdBaseVersion $fShowCGError$fEqSubsection$fShowSubsection$fOrdSubsectionclassConstrainttypeConstraint callbackCTypecallbackHTypeWithClosurescallbackDynamicWrappercallbackHaskellToForeign$callbackHaskellToForeignWithClosurescallbackDropClosurescallbackWrapperAllocatorcallbackClosureGenerator lowerName lowerSymbol upperNamesubmoduleLocation qualifiedAPIqualifiedSymbolnoNamehyphensToCamelCaseunderscoresToCamelCasesignalInfoNamesignalHaskellNameValueIdentifierTypeIdentifier ModuleLinkModuleLinkWithAnchor$fShowHyperlink $fEqHyperlinkgenOverloadedLabels instanceTreefullObjectPropertyListfullInterfacePropertyListfullObjectSignalListfullInterfaceSignalListfullObjectMethodListfullInterfaceMethodList$fInheritableMethod$fInheritableSignal$fInheritablePropertyRelativeDocPositionDocBeforeSymbolDocAfterSymboldeprecatedPragmawriteDocumentation writeHaddockwriteArgDocumentationwriteReturnDocumentationaddSectionDocumentation isGObject nameIsGObject apiIsGObjectgenOverloadedSignalConnectorsgenObjectSignalsgenInterfaceSignalsgenEnumgenFlags TypeAllocInfotypeAllocInfoIsBoxedtypeAllocInfoSizeExposeClosures WithClosuresWithoutClosuresPMIdapplymapCliteral genConversioncomputeArrayLengthconverthToFfToH transientToH unpackCArray argumentType haskellTypecallableHasClosurestypeIsCallbackisoHaskellType foreignType typeAllocInfo isManaged typeIsPtrmaybeNullConvertnullPtrForTypetypeIsNullableelementTypeAndMap elementType elementMap $fMonadFree$fApplicativeFree $fFunctorFree$fIsStringConstructor$fEqConstructor$fShowConstructor $fShowMap $fShowFExpr$fFunctorFExpr$fEqExposeClosuresfreeContainerType freeInArgfreeInArgOnError ignoreStruct fixAPIStructsextractCallbacksInStructgenStructOrUnionFields genZeroStruct genZeroUnion genWrappedPtrgenObjectPropertiesgenInterfacePropertiesgenNamespacedPropLabels genConstant ForeignSymbolKnownForeignSymbolDynamicForeignSymbol SignaturesignatureCallablesignatureConstraintssignatureArgTypessignatureReturnTypehOutType wrapMaybeinArgInterfacesarrayLengthsMap arrayLengths skipRetValcallableSignaturecallableHInArgscallableHOutArgsfixupCallerAllocatesgenCCallableWrappergenDynamicCallableWrapper genCallback genSignal genMethodList genMethodInfogenUnsupportedMethodInfo genFunction genModuleTaggedOverride overrideTag overrideTextsetupHaskellGIBinding setupBindingconfigureDryRun cabalConfigsetupHsgenCabalProject $fShowPkgInforestoreSHPreNewlinesparseSectionHeaderparseInitialSectionHeaderrestoreListPreNewline parseListcoalesceLiterals parseTokens parseTokenparseLocalSignal parseComment parseVMethodparseStructField parseParamisCIdentsignalOrPropName parseCIdentparseFunctionRef parseEscapedparseBoringLiteralspecial parseVerbatimparseUrl parseImageparseCodeBlock parseLanguage text-1.2.3.1Data.Text.InternalTextbaseGHC.ErrerrorGHC.BaseStringTypelibBaseInfogirPrependSearchPath!g_irepository_prepend_search_path girFindByName getFieldInfo girSymbolTypeConghc-prim GHC.TypesIO GHC.MaybeMaybebuildSearchPathgirFile girNamespacePxml-types-0.3.6-f76b420608375bde189ef5f28ba7c08c8af6bb61bb3843ee26065b4f4606622fData.XML.Types ParseContextelementDescriptionnameInCurrentNS withElementnameToBasicTypeparseArrayInfoparseCArrayTypeparseHashTable parseClosure parseListTypeparseFundamentalType parseTypeName parseTypeInfoNothingparseTypeElementsparseCTypeNameElements queryTypeparseEnumMemberextractEnumStorageBytes parseFieldnamespaceListAliases parseAliases parseAliasdocumentListIncludesloadDependencies loadGIRFile toGIRInfogtypeInterfaceListPrereqsfixupInterface fixupStructfixupStructIsBoxedfixupStructSizeAndOffsets fixupUnionfixupUnionSizeAndOffsets fixupField fixupGIRInfosfixupGIRDocumentfixupGIR girSetAttr girAddNodegirDeleteNodeslookupAndMatch specMatchOSType ParserState currentNSflagsFalse ignoredElems ignoredAPIs sealedStructs allocInfodefaultOverridesconcatOverridesemptyParserStategetNS withFlags parseOneLine parseIgnore parseSealparseAllocInfoparseKeyValuePairparsePkgConfigNameparseNsVersionparseCabalPkgVersion parseSetAttrparseAdd parseDelete parseDocsUrl parsePathSpecparseGIRNameTag parseNodeSpec parseXMLNamecheckOS parseVersioncheckPkgConfigVersionparseIf parseEndif parseInclude filterMethodsfilterAllocInfo filterOneAPI filterAPIsfilterMovedMethodsguessObjectPropertyNullability!guessInterfacePropertyNullabilityguessNullabilityguessReadNullabilityguessWriteNullability findMethoddropDuplicatedEnumFieldscheckCallableDestructors Subsection NamedTyvarSingleCharTyvar IndexedTyvarCGStatecgsCPPConditionalscgsNextAvailableTyvar CodeGenConfighConfig loadedAPIsc2hMap modulePathbootCode submodules moduleDeps moduleExportsqualifiedImports modulePragmas moduleGHCOpts moduleFlags moduleMinBase ExportType ExportSymbolExportTypeDecl ExportModuleExport exportType exportSymbol exportGuards SymbolName CodeTokenLineIndentGroupIncreaseIndentCPPBlockCPPConditionalCPPIf emptyCode isCodeEmpty codeSingleton emptyModule emptyCGState runCodeGen cleanInfomconcat recurseCGrecurseWithStatemergeInfoState mergeInfo addSubmodule submodule' unwrapCodeGentransformers-0.5.6.2Control.Monad.Trans.Except runExceptqualifiedImportqualifiedModuleNametellCode cppIfBlock exportPartial cppCondFormat paddedLinecomma formatExportformatExportedModulesformatToplevelformatTypeDeclssubsecWithPrefixmainSectionName formatSectionformatSubsectionExportsformatExportListlanguagePragmas cppMacrosstandardFields moduleHaddockformatHaddockComment modulePrelude importDeps moduleImports dotWithPrefixwriteModuleInfo genHsBootmodulePathToFilePathsanitizeescapeReservedlocationfullyQualifiedValuefullyQualifiedType constRefsfuncRefsenumRefs methodRefs signalRefs maybeCType callbackRefs structRefs unionRefs ifaceRefs objectRefsfindOverloaded getParentremoveDuplicates formatHaddockformatUnknownCRef formatCRefformatHyperlinkformatCodeBlock qualifiedWith formatLink formatImageformatSectionHeader formatListescape getDocBaseformatDocumentationdropDuplicatedgenErrorDomain FFIPtrTypeFFIPtr FFIFunPtrFreeliftFhashTableKeyMappingshashTablePtrPackers wrapTransientforeignBasicTypetypeIsEnumOrFlag typePtrTypeisIgnoredStructTypefieldCallbackTypefixCallbackStructFieldsinfoType isEmbedded fieldGetter getterDocbuildFieldReader fieldSetter setterDocbuildFieldWriter fieldClearclearDocbuildFieldClearisRegularCallbackfieldTransferTypeConstraintfieldTransferTypegenFieldTransferfName labelName genAttrInfobuildFieldAttributes genZeroSUprefixedForeignImportprefixedFunPtrImportpropSetTypeConstraintpropTransferTypeConstraintpropTransferTypegenPropTransferattrTypeconstructorDoc hPropNamegenPlaceholderPropertyPatternSynonym assignValue showBasicTypeDynamicWrapperdynamicWrapper dynamicTypemkForeignImportmkDynamicImport freeInArgsfreeInArgsOnErrorprepareInCallbackformatHSignaturefunPtr convertResult convertOutArgconvertOutArgsinvokeCFunction returnResultgenHaskellWrappergenWrapperBodygenCallableDebugInfoforgetClosuresgenHaskellCallbackPrototypegenCCallbackPrototypegenCallbackWrapperFactorygenWrappedCallback genClosuregenDropClosuresgenCallbackWrappergenSignalInfoInstanceprocessSignalErrorgenSignalConnectormethodInfoNamegenMethodResolvernewtypeDerivinggenBoxedGValueInstance genStructgenUnion fixMethodArgsgenGObjectGValueInstance genObject genAPIModule genModuleCodegenConfigModuleconfCodeGenHook Cabal-3.0.0.0Distribution.Simple.UserHooksconfHookversion getBinDir getLibDir getDynLibDir getDataDir getLibexecDir getSysconfDirgetDataFileNamePkgInfo minorVersionhaskellGIMinorgiModuleVersion giNextMinorreadMajorMinor