h,\>l      !"#$%&'()*+,-./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.117None" Safe-Inferred"VTry asking pkg-config for the version of a given module, and return the package name together with its version.Get 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" Default list of extensions to turn on when compiling the generated code. Extensions that will be used in some modules, but we do not wish to turn on by default. 6Default options for GHC when compiling generated code. %Default version of the report to use.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.Under which category in hackage should the generated bindings be listed.        Safe-Inferred" Construct the  representation of a showable.3Capitalize the first character of the given string.7Make the first character of the given string lowercase.Apply the given modification function to the given symbol. If the symbol is qualified the modification will only apply to the last component.:Split a list into sublists delimited by the given element.Read a file assuming it is UTF-8 encoded. If decoding fails this calls .Write the given  into an UTF-8 encoded file.+Print a (colored) warning message to stderrThrow an error with the given .  None"A path to a module.!9Construct 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""Turn 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"#4Append the given component to the given module path.ExamplesdotModulePath ("Foo" /. "Bar") "Foo.Bar"$ Construct a  from a .#"!  !#"None "1 *Extra 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.)- Wrapper for  GITypelib5, remembering the originating namespace and version. Wrapper for  GIBaseInfoAdd the given directory to the typelib search path, this is a thin wrapper over ..A 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./Ensure that the given version of the namespace is loaded. If that is not possible we error out.Find a given baseinfo by name, or give an error if it cannot be found..Get the extra information for the given field.0Find out the size of a struct, and the map from field names to offsets inside the struct.1Find out the size of a union, and the map from field names to offsets inside the union.Try to load a symbol from the dynamic library associated to the given typelib.Load a symbol from the dynamic library associated to the given typelib. If the symbol does not exist this will raise an error.2Load a GType given the -, where it lives and the type init function.3=8:9 ;=8:9@  Safe-Inferred"&3DThis type represents the types found in GObject Introspection interfaces: the types of constants, arguments, etc.FGErrorGGVariantHGValueI GParamSpecJ>Zero terminated, Array Fixed Size, Array Length, Element TypeKGArrayL GPtrArrayM GByteArrayNGListOGSListP GHashTableQ,GClosure containing the given API (if known)R"A reference to some API in the GIRSBasic types. These are generally trivial to marshal, and the GIR assumes that they are defined.TgbooleanUgintVguintWglongXgulongYgint8Zguint8[gint16\guint16]gint32^guint32_gint64`guint64agfloatbgdoublecgunichardGTypeegchar*, encoded as UTF-8fgchar*, encoding a filenameggpointerhgintptriguintptrjgshortkgushortlgsizemgssizentime_tooff_tpdev_tqgid_trpid_ts socklen_ttuid_tu,An alias, which is simply (Namespace, name).w*Transfer mode for an argument or property.{"Name for a symbol in the GIR file.;uvSTbfadU[]_YhWgmjlV\^`ZiXkecpqorsnt{|}~wyzxDEMJFKQPNOHRILG;{}|~wxyzuvDREFGHIJKLMNOPQSTUVWXYZ[\]^_`abcdefghijklmnopqrst  Safe-Inferred"){ A type constructor. We single out some specific constructors since they have special syntax in their Haskell representation.A fully applied type.9Give a valid Haskell source representation of the given .Return a textual representation of the type constructor for the given .,Type constructor applied to the given types.7A shorthand for a type constructor taking no arguments. Embed in the  monad.A Ptr to the type.A FunPtr to the type. Embed in the  monad.:STbfadU[]_YhWgmjlV\^`ZiXkecpqorsntDEMJFKQPNOHRILG:DREFGHIJKLMNOPQSTUVWXYZ[\]^_`abcdefghijklmnopqrst  Safe-Inferred"T70A parsed gtk-doc with fully resolved references.Reference 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.(The symbol without a namespace specifiedNamespace and symbol&A reference to some symbol in the API.(The language for an embedded code block.An 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.A link to a resource, either offline or a section of the documentation.A parsed gtk-doc token.$A section header of the given depth.0Parse 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",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"]) []]]parseGtkDoc "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"})]) []]]2 eats the newline before the section header, but  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.. eats the newline before the list, restore it.6Accumulate consecutive literals into a single literal.Parser for tokens.Parse a single token.Examples-parseOnly (parseToken <* endOfInput) "func()")Right (SymbolRef (OldFunctionRef "func"))7Whether the given character is valid in a C identifier.Something that could be a valid C identifier (loosely speaking, we do not need to be too strict here).Parse a function refParse an unresolved reference to a C symbol in new gtk-doc notation.Parse 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")Parse 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"))Parse 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"))2Parse a reference to a type, of the form > [class3Namespace.Name] an interface of the form > [iface:Namespace.Name] or an enum type: > [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")))>Parse an old style signal name, of the form > #Object::signalExamples?parseOnly (parseOldSignal <* endOfInput) "#GtkButton::activate"7Right (SymbolRef (OldSignalRef "GtkButton" "activate"))Parse 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"))Parse a reference to a signal defined in the current module, of the form > ::signalExamples7parseOnly (parseLocalSignal <* endOfInput) "::activate"-Right (SymbolRef (LocalSignalRef "activate"))Parse 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"))Parse 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"))Parse a property%Parse an xml comment, of the form >  !-- comment --' Note that this function keeps spaces.Examples9parseOnly (parseComment <* endOfInput) ""Right (Comment " comment ")Parse an old style reference to a virtual method, of the form > #Struct.method()Examples6parseOnly (parseOldVMethod <* endOfInput) "#Foo.bar()"*Right (SymbolRef (VMethodRef "Foo" "bar"))Parse 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"))%Parse a reference to a virtual methodParse a reference to a struct field, of the form > #Struct.fieldExamples5parseOnly (parseStructField <* endOfInput) "#Foo.bar".Right (SymbolRef (StructFieldRef "Foo" "bar"))3Parse a reference to a C type, of the form > #TypeExamples+parseOnly (parseCType <* endOfInput) "#Foo""Right (SymbolRef (CTypeRef "Foo"))/Parse a constant, of the form > %CONSTANT_NAMEExamples8parseOnly (parseConstant <* endOfInput) "%TEST_CONSTANT"/Right (SymbolRef (ConstantRef "TEST_CONSTANT")) @param_nameExamples2parseOnly (parseParam <* endOfInput) "@test_param")Right (SymbolRef (ParamRef "test_param"))Name of a signal or property name. Similar to a C identifier, but hyphens are allowed too.8Parse a escaped special character, i.e. one preceded by '\'.Parse a literal, i.e. anything without a known special meaning. Note that this parser always consumes the first character, regardless of what it is.List 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).7Parse a verbatim string, of the form > `verbatim text`Examples:parseOnly (parseVerbatim <* endOfInput) "`Example quote!`"!Right (Verbatim "Example quote!")/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"})))Parse an image reference, of the form > urllabelExamples7parseOnly (parseImage <* endOfInput) "![](diagram.png)"Right (Image (Link {linkName = "", linkAddress = "diagram.png"}))1Parse a code block embedded in the documentation.Parse 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")0Parse 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");Parse the language of a code block, specified as a comment.Parse 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.Parse 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!"]))Parse a list header. Note that the newline before the start of the list is "eaten" by this parser, but is restored later by .ExamplesparseOnly (parseList <* endOfInput) "\n- First item\n- Second item"Right (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"]]])Turn an ordinary { into a  Return a { from a potentially relative , using the provided default namespace if the name is relative.** None"X:Split a list into sublists delimited by the given element.-Return the paths where to look for gir files.: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.Search for an appropriate .gir file in the search path.Try to load the `.gir` file corresponding to the given repositoryverbosenameversion searchPath None"[ GIR namespaces we know about.>Turn a node into an element (if it is indeed an element node).Find all children of the given element which are XML Elements themselves.The local name of an element.,Restrict to those with the given local name."Restrict to those with given name.1Find the first child element with the given name.1Get the content of a given element, if it exists.4Lookup an attribute for an element (with no prefix).;Return the text representation of the known GIR namespaces.Lookup an attribute for an element, given the namespace where it lives. Construct a 89 by only giving the local name. Construct a 89 specifying a namespace too.None"\Documentation 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 :;.Parse the documentation node for the given element of the GIR file.None"]D$Deprecation information on a symbol.Parse the deprecation information for the given element of the GIR file.None"dSMonad where parsers live: we carry a context around, and can throw errors that abort the parsing.Mark whether the methods can be resolved in the given typelib.Check that the symbol the function refers to is actually present in the dynamic library.6Load and parse a GIR file, including its dependencies.Given a XML document containing GIR data, apply the given overrides.Looks 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.Set an attribute for the child element specified by the given path.Delete an attribute for the child element specified by the given path, if the attribute exists.:Add the given subnode to any nodes matching the given path)Delete any nodes matching the given path.Lookup the given attribute and if present see if it matches the given regex.=8:9{|}~wyzx{}|~wxyz;=8:9@"None"(2Known operating systems.We have a bit of context (the current namespace), and can fail, encode this in a monad."The state of the overrides parser.The contents of the override file will be ignored if there is any  value here. if( primitive push (prepend) values here, endif pop them.The current namespace.&Known places where to find the C docs.Fixups for the GIR data."Prefered version of the namespace.0Version number for the generated .cabal package.;Mapping from GObject Introspection namespaces to pkg-config-Explicit calloc/copy/free for structs/unions.9Structs for which accessors should not be auto-generated.?Ignored APIs (all elements in this API will just be discarded). Ignored elements of a given API.*Construct the generic config for a module.$Addition of overrides is meaningful.Default, empty, parser state.Get the current namespace.8Run the given parser only if the flags can be satisfied.Parse the given overrides, filling in the configuration as needed. In case the parsing fails we return a description of the error instead.Parse a single line of the config file, modifying the configuration as appropriate.Ignored elements.Sealed structures..Explicit allocation info for wrapped pointers.:Parse a explicit key=value pair into a (key, value) tuple.?.Check that the given pkg-config package has a version compatible with the given constraint.Parse a 'if' directive. Parse an endif directive.Parse the given overrides file, and merge into the given context.Filter a set of named objects based on a lookup list of names to ignore.Given the previous allocation info, and a new allocation info, replace those entries in the old allocation info which are specified in the new info.-Filter one API according to the given config.?Given a list of APIs modify them according to the given config.Load a given API, applying filtering. Load also any necessary dependencies.There 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.There 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"0List of loaded overrides for the code generator.Whether to print extra info.9Version of the haskell package ("3.0.35", "2.0.21", ...).:Haskell package being generated (gi-gtk, gi-gobject, ...).Version of the GIR API for the package being generated ("3.0", "2.0", ...).;GIR name of the module being generated (Gtk, GObject, ...).$None"7Remove functions and methods annotated with "moved-to".Drop the moved methods.GObject-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.2Guess nullability for the properties of an object.5Guess nullability for the properties of an interface.Guess the nullability for a property, given the list of methods for the object/interface.Guess whether "get" on the given property may return NULL, based on the corresponding "get_prop_name" method, if it exists.Guess whether "set" on the given property may return NULL, based on the corresponding "set_prop_name" method, if it exists.2Find the first method with the given name, if any.Not every interface that provides signals/properties is marked as requiring GObject, but this is necessarily the case, so fix the introspection data accordingly.Drop any fields whose name coincides with that of a previous element. Note that this function keeps ordering.?Some libraries include duplicated flags by mistake, drop those.Sometimes arguments are marked as being a user_data destructor, but there is no associated user_data argument. In this case we drop the annotation.If any argument for the callable has an associated destroyer for the user_data, but no associated user_data, drop the destroyer annotation.Sometimes 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.Closures 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.*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.Any argument with a closure index pointing to itself is a "user_data" type argument.Some symbols have names that are not valid Haskell identifiers, fix that here.Make 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"90A subsection name, with an optional anchor name."Possible features to test via CPP.Enable overloading0Require a specific version of the given package.&Code generators that can throw errors.The base type for the code generator monad. Generators that cannot throw errors are parametric in the exception type excType.The name for a type variable.!A single variable type variable: a, b, etc...An indexed type variable: a17, key1, ...'Temporaty state for the code generator.Next unused type variable.4Active CPP conditionals, outermost condition first.%Set of errors for the code generator.#Information for the code generator.*Map from C references to Haskell symbols. APIs available to the generator.Ambient config.4Minimal version of base supported by a given module. 7.0 8.0!Flags for module code generation.Use the standard prelude, instead of the haskell-gi-base short one."Information on a generated module.1Minimal version of base the module will work on.9Documentation for the different sections in the module.Flags for the module.%GHC options for compiling the module.'Set of language pragmas for the module.Qualified (source) imports.Exports for the module.$Set of dependencies for this module.%Indexed by the relative module name.(Interfaces going into the .hs-boot file.Generated code for the module.Full module name: [Gtk, Label].Possible types of exports.(An export in the given haddock section.A type declaration.Reexport of a whole module.Possible 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.3Protect the export by the given CPP export guards.Actual symbol to export.Which kind of export.Symbol to export.Known subsections. The ordering here is the ordering in which they will appear in the haddocks.Subsection of the haddock documentation where the export should be located, or alternatively the toplevel section.Possible code tokens./A single line, indented to current indentation.Indented region.A grouped set of linesA (possibly multi line) commentIncrease the indentation for the rest of the lines in the group.5A block of code guarded by the given CPP conditionalThe generated  is a sequence of s.9Set of CPP conditionals understood by the code generator.#if Foo/Initializes a code block to the empty sequence.-Checks whether the given code block is empty.-A block of code consisting of a single token.A 0 representation of the given base version bound.Generate the empty module.Clean slate for .Run a  with given  and initial state, returning either the resulting exception, or the result and final module info.4This is useful when we plan run a subgenerator, and - the result to the original structure later.Run the given code generator using the state and config of an ambient CodeGen, but without adding the generated code to ", instead returning it explicitly.Like , but we allow for explicitly setting the state of the inner code generator.Like , giving explicitly the set of loaded APIs and C to Haskell map for the subgenerator.:Merge everything but the generated code for the two given .$Merge the infos, including code too.Add the given submodule to the list of submodules of the current module.Run 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.Run the given CodeGen in order to generate a submodule (specified an an ordered list) of the current module.Try running the given action, and if it fails run fallback instead.0Return the currently loaded set of dependencies.8Return the ambient configuration for the code generator.&Return the name of the current module.3Return the list of APIs available to the generator.3Return the C -> Haskell available to the generator. 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.Run a code generator, and return the information for the generated module together with the return value of the generator.Like ), but discard the resulting output value.0Mark the given dependency as used by the module.Return the transitive set of dependencies, i.e. the union of those of the module and (transitively) its submodules.Given a module name and a symbol in the module (including a proper namespace), return a qualified name for the symbol.Import 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.Construct a simplified version of the module name, suitable for a qualified import.Return the minimal base version supported by the module and all its submodules.Print, as a comment, a friendly textual description of the error.0Get a type variable unused in the current scope.Introduce a new scope for type variable naming: the next fresh variable will be called a.;Try to find the API associated with a given type, if known.Find the API associated with a given type. If the API cannot be found this raises an .'Add some code to the current generator.&Print out a (newline-terminated) line.Print out the given line both to the normal module, and to the HsBoot file. A blank line6A (possibly multi line) comment, separated by newlines.Increase the indent level for code generation.Increase the indentation level for the rest of the lines in the current group.Group a set of related code.Guard a block of code with #if.Guard a code block with CPP code, such that it is included only if the specified feature is enabled.Write the given code into the .hs-boot file for the current module.#Add a export to the current module.Reexport a whole module.&Add a type declaration-related export.0Export a symbol in the given haddock subsection.0Set the language pragmas for the current module.-Add a language pragma for the current module.Set the GHC options for compiling this module (in a OPTIONS_GHC pragma).#Set the given flags for the module.=Set the minimum base version supported by the current module.&Add documentation for a given section.:Prepend documentation at the beginning of a given section.Format a CPP conditional.$Return a text representation of the .Pad a line to the given number of leading tabs (with one tab equal to four spaces), and add a newline at the end.Pad 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.,Put a (padded) comma at the end of the text.Format the given export symbol.$Format the list of exported modules.%Format the toplevel exported symbols.%Format the type declarations section.3A subsection with an anchor given by the title and  prefix:title& anchor, and the given documentation.Return a qualified form of the function mapping instances of IsX to haskell values of type X.Same as ;, but applicable directly to a type. The type should be a R$, otherwise an error will be raised.Foreign type associated with a callback type. It can be passed in qualified.Haskell type exposing the closure arguments, which are generally elided.The name of the dynamic wrapper for the given callback type. It can be passed in qualified.The name of the Haskell to foreign wrapper for the given callback type. It can be passed in qualified.The 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.The name of a function which takes a callback without closure arguments, and generates a function which does accep the closures, but simply ignores them.,The name for the foreign wrapper allocator (foreign import "wrapper" ...>) for the given callback type. It can be passed in qualified.The name for the closure generator for the given callback type. It can be passed in qualified.$Move leading underscores to the end.Examplessanitize "_Value_Data_Union""Value_Data_Union_"Same as , but accepts a {4. The namespace part of the name will be discarded.Examples"lowerName (Name "Gtk" "main_quit") "mainQuit"Turn the given identifier into camelCase, starting with a lowercase letter.ExampleslowerSymbol "main_quit" "mainQuit"Turn the given {0 into CamelCase, starting with a capital letter.Examples upperName (Name "Foo" "bar_baz")"BarBaz"Construct 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.;Obtain the absolute location of the module where the given  lives.Construct the Haskell version of the name associated to the given API.Return an identifier for the given interface type valid in the current module.>Construct an identifier for the given symbol in the given API.3Turn a hyphen-separated identifier into camel case.Examples&hyphensToCamelCase "one-sample-string""OneSampleString" 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"Name for the given argument, making sure it is a valid Haskell argument name (and escaping it if not).Reserved symbols, either because they are Haskell syntax or because the clash with symbols in scope for the generated bindings.Qualified name for the "(sigName, info)" tag for a given signal.Return the name for the signal in Haskell CamelCase conventions.Return 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.(Prefix in Haddock for the signal anchor.+Prefix in Haddock for the attribute anchor.%None"#Link to an identifier, module, etc.Given 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.An identifier at the value level: functions, data constructors, ... An identifier at the type level.Link to a module.Link to an anchor inside a given module, with an optional label.6Obtain the fully qualified symbol pointing to a value.5Obtain the fully qualified symbol pointing to a type.Extract the C name of a constant. These are often referred to as types, so we allow that too.!Extract the C name of a function.Extract the C names of the fields in an enumeration/flags, and the name of the type itself.&Refs to the methods for a given owner.&Refs to the signals for a given owner.)Refs to the properties for a given owner.Given an optional C type and the API constructor construct the list of associated refs.!Extract the C name of a callback.%Extract the C references in a struct.$Extract the C references in a union.)Extract the C references in an interface.&Extract the C references in an object.(None"! Find 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."formatHaddock M.empty "a" "Test" (GtkDoc [List [ListItem (GtkDoc [Image (Link "test" "test.png")]) []]])"\n* <>\n" Format a  whose Haskell representation is not known, using a provided default namespace for relative symbols.Format the given symbol name in a fully qualified way, using the default namespace if needed.&Formatting for an unknown C reference. Format a  into plain .,Format a code block in a specified language.Qualify the given address with the docBase, if it is not an absolute address.(Format a link to some external resource.Format an embedded image.Format 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.Format a list of items.2Escape the reserved Haddock characters in a given .Examples escape "\"""\\\""escape "foo@bar.com""foo\\@bar.com"escape "C:\\Applications""C:\\\\Applications"Get the base url for the online C language documentation for the module being currently generated.+Write the deprecation pragma for the given  , if not .Format the given documentation into a set of lines. Note that this does include the opening or ending comment delimiters.2Write the given documentation into generated code.Like , but allows us to pass explicitly the Haddock comment to write./Write the documentation for the given argument.3Write the documentation for the given return value.Add the given text to the documentation for the section being generated.  *None"C3Check whether the given type descends from GObject.3Check whether the given name descends from GObject.2Check whether the given API descends from GObject.+None"/Signal instances for (GObject-derived) objects. Signal instances for interfaces.,None"Given a list of named enum members, filter out those that have the same value as a previous entry in the list.Very similar to enums, but we also declare ourselves as members of the IsGFlag typeclass.,Support for enums encapsulating error codes.-None":)#Distinct types of foreign pointers. Ordinary Ptr.FunPtr.Information on how to allocate a type: allocator function and size of the struct.Whether to expose closures and the associated destroy notify handlers in the Haskell wrapper.The free monad.$Lift some command to the Free monad.Given an array, together with its type, return the code for reading its length.Try to find the hash and equal functions appropriate for the given type, when used as a key in a GHashTable. GHashTable tries to fit every type into a pointer, the following function tries to find the appropriate (destroy,packer,unpacker) for the given type.Somewhat 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.Wrap the given transient.Given 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. pattern Name  -(view -; value) :: Type where > Name = expression value :: Type Assign to the given name the given constant value, in a way that can be assigned to the corresponding Haskell type. Show a basic type, in a way that can be assigned to the corresponding Haskell type.2None", $Information about a dynamic wrapper. Name of the type synonym for the type of the function to be wrapped. Haskell dynamic wrapperThe 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 symbol in scope.Info about the dynamic wrapper.Signature for a callable. Generate a foreign import for the given C symbol. Return the name of the corresponding Haskell identifier. Make a wrapper for foreign FunPtrs of the given type. Return the name of the resulting dynamic Haskell wrapper.Given 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)).Given the list of arguments returns the list of constraints and the list of types in the signature.Whether 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 Return 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. Return the list of actions freeing the memory associated with the callable variables. This is run in case there is an error during the call. >Callbacks are a fairly special case, we treat them separately. 4Format the signature of the Haskell binding for the . 5Name for the first argument in dynamic wrappers (the FunPtr).The Haskell signature for the given callable. It returns a tuple ([constraints], [(type, argname)]).In arguments for the given callable on the Haskell side, together with the omitted arguments.Out6 arguments for the given callable on the Haskell side. 2Convert the result of the foreign call to Haskell. Marshal a foreign out argument to Haskell, returning the name of the variable containing the converted Haskell value. Convert the list of out arguments to Haskell, returning the names of the corresponding variables containing the marshaled values. 3Invoke the given C function, taking care of errors. Return the result of the call, possibly including out arguments. :Generate a Haskell wrapper for the given foreign function. Generate the body of the Haskell wrapper for the given foreign symbol.caller-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. !Some debug info for the callable.(Generate a wrapper for a known C symbol. For callbacks we do not need to keep track of which arguments are closures.Generate 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"2^ The prototype of the callback on the Haskell side (what users of the binding will see) Generate the type synonym for the prototype of the callback on the C side. Returns the name given to the type synonym. &Generator for wrappers callable from C Wrap the Haskell cb callback into a foreign function of the right type. Returns the name of the wrapped value. Generator of closures ,Wrap a conversion of a nullable object into Maybe2 object, by checking whether the pointer is NULL. 3A simple wrapper that drops every closure argument. 9The 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). Create the newtype wrapping the ManagedPtr for the given type.  Generate wrapper for structures. Generated wrapper for unions. When 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. Generate an import for the gvalue getter for the given type. It returns the name of the function on the Haskell side. Generate an import for the gvalue setter for the given type. It returns the name of the function on the Haskell side. 4Generate the GValue instances for the given GObject. Type casting with type checking, returns the function returning the GType for the oject. Wrap 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. >Generate the code for a given API in the corresponding module.6None">Included overrides file.3Tag for the override, for error reporting purposes. 'Generate the code for the given module. Write a module containing information about the configuration for the package. A convenience helper for  , such that bindings for the given module are generated in the  configure step of cabal.The entry point for Setup.hs files in bindings. Return the list of modules that setupHaskellGIBinding would create, together with the set of dependencies loaded while generating the code. nameversionpkgName pkgVersionverboseExplicit overrides nameversionpkgName pkgVersionverboseoverrides fileother overrides output dir previous  nameversionpkgName pkgVersionverboseoverrides fileExplicit overrides output dirnameversionpkgName pkgVersionOverrides fileOther overrides to loadF Safe-Inferred">V  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.11-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.3-4d9edfff3316b92647c8673a59d0c6bac7c1993c772c4215c4140adfb1426e0dElementhaskell-gi-base-0.26.6-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 VMethodRefVFuncRefStructFieldRefCTypeRefTypeRefLanguageListItemLink linkAddresslinkNameTokenLiteralCommentVerbatim CodeBlock ExternalLinkImageList SectionHeader SymbolRefdocNameresolveDocSymbol $fShowGtkDoc $fEqGtkDoc $fShowToken $fEqToken$fShowListItem $fEqListItem $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 DirectionOutDirectionInout parseTransferparseArg $fShowArg$fEqArg$fOrdArg $fShowScope $fEqScope $fOrdScope$fShowDirection $fEqDirection$fOrdDirectionPropertypropDeprecatedpropDoc propTransferpropWriteNullablepropReadNullable 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.1-e965Data.Text.InternalText ghc-internalGHC.Internal.ErrerrorGHC.Internal.BaseStringBaseInfogirPrependSearchPath!g_irepository_prepend_search_path girFindByName getFieldInfogirLookupSymbol girSymbolTypeConghc-prim GHC.TypesIOGHC.Internal.MaybeMayberestoreSHPreNewlinesparseSectionHeaderparseInitialSectionHeaderrestoreListPreNewline parseListcoalesceLiterals parseTokens parseTokenisCIdent parseCIdentparseFunctionRefparseIdparseOldFunctionRefparseNewFunctionRefparseConstructor parseClassparseOldSignalparseNewSignalparseLocalSignalparseOldPropertyparseNewProperty parseCommentparseOldVMethod parseVFunc parseVMethodparseStructField parseParamsignalOrPropName parseEscapedparseBoringLiteralspecial parseVerbatimparseUrl parseImageparseCodeBlockparseNewStyleCodeBlockparseOldStyleCodeBlock parseLanguage girDataDirsbuildSearchPathgirFile girNamespaceelementDescriptionnameInCurrentNS withElementnameToBasicTypeparseArrayInfoparseCArrayTypeparseHashTable parseClosure parseListTypeparseFundamentalType parseTypeName parseTypeInfoNothingparseTypeElementsparseCTypeNameElements queryTypeparseEnumMemberextractEnumStorageBytesresolveInternalTypepspec_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.1-0f5fControl.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 formatImageformatSectionHeader formatListescape 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.0.0-7126Distribution.Simple.UserHooks UserHooksconfHook getBinDir getDataDirgetDataFileName getDynLibDir getLibDir getLibexecDir getSysconfDirversion