rOEI             ! " # $ % & ' ( ) * + , - . / 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 defghijklmnopqrstuvwxyz{|}~                   ! " # $ % & ' ( ) * + , -!.!/!0!1!2!3!4"5"6"7"8"9:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~###$$$$$$$$%%&&&&&''''''''''''''''''''''''()))********+++++++,,,---...///0000000112344 Safe-Inferred $HMT   Safe-Inferred $HMTConstruct the  representation of a showable.Throw an error with the given .3Capitalize the first character of the given string.7Make the first character of the given string lowercase.None $HMT     Safe-Inferred $HMT8Try asking pkg-config for the version of a given module.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.None $HMTNone $HMT Wrapper for  GITypelib Wrapper for  GIBaseInfo`Ensure that the given version of the namespace is loaded. If that is not possible we error out.GFind a given baseinfo by name, or give an error if it cannot be found.ZFind out the size of a struct, and the map from field names to offsets inside the struct.XFind out the size of a union, and the map from field names to offsets inside the union.ILoad a symbol from the dynamic library associated to the given namespace.LLoad a GType given the namespace where it lives and the type init function.None $HMT:Split a list into sublists delimited by the given element.Search for an appropriate .gir| file in the search path. This is either passed in explicitly, or if that is absent, loaded from the environment variable HASKELL_GI_GIR_SEARCH_PATH. 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.ATry to load the `.gir` file corresponding to the given repositoryverbosenameversion searchPath  Safe-Inferred $HMTInformation 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.@Allocation/deallocation information for a given foreign pointer. FA convenience function, filling in all the allocation info to unknown.     None $HMT !GIR namespaces we know about.$>Turn a node into an element (if it is indeed an element node).%JFind 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.,GLookup an attribute for an element, given the namespace where it lives.- Construct a  by only giving the local name.. Construct a  specifying a namespace too.!"#$%&'()*+,-.!"#$%&'()*+,-.$%&+!#",'()*-. !#"$%&'()*+,-. None $HMT/$Deprecation information on a symbol.0Encode the given // for the given symbol as a deprecation pragma.1HParse the deprecation information for the given element of the GIR file./01/01/01/01 None $HMT2"Documentation for a given element.5CParse the documentation node for the given element of the GIR file.2345234523452345  Safe-Inferred $HMT&6rThis type represents the types found in GObject Introspection interfaces: the types of constants, arguments, etc.7"A reference to some API in the GIR8 GHashTable9GSList:GList; GByteArray< GPtrArray=GArray>>Zero terminated, Array Fixed Size, Array Length, Element Type? GParamSpec@GVariantAGErrorC`Basic types. These are generally trivial to marshal, and the GIR assumes that they are defined.DguintptrEgintptrFgpointerGgchar*, encoding a filenameHgchar*, encoded as UTF-8IGTypeJgunicharKgdoubleLgfloatMguint64Ngint64Oguint32Pgint32Qguint16Rgint16Sguint8Tgint8UgulongVglongWguintXgintYgbooleanZ,An alias, which is simply (Namespace, name).\*Transfer mode for an argument or property.`"Name for a symbol in the GIR file..6789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abc.6789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abc.`abc\_^]Z[6BA@?>=<;:987CYXWVUTSRQPONMLKJIHGFED6 BA@?>=<;:987CYXWVUTSRQPONMLKJIHGFEDZ[\_^]`abcNone $HMTdbMonad where parsers live: we carry a context around, and can throw errors that abort the parsing.e<A message describing a parsing error in human readable form."Info to carry around when parsing.fThrow a parse error.DBuild a textual description (for debug purposes) of a given element.&Build a name in the current namespace.gReturn the current namespace.hCheck whether there is an alias for the given name, and return the corresponding type in case it exists, and otherwise a TInterface.inReturn the value of an attribute for the given element. If the attribute is not present this throws an error.jLike i), but allow for specifying the namespace.kIReturn the value of an attribute if it is present, and Nothing otherwise.lLike k), but allow for specifying the namespace.mAsk for an optional attribute, applying the given parser to it. If the argument does not exist return the default value provided.nBuild 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.o/Get the qualified name for the current element.p'Parse the deprecation text, if present.q)Parse the documentation text, if present.rParse a signed integral number.s.A boolean value given by a numerical constant.tCParse all the introspectable subelements with the given local name.u0Parse all subelements with the given local name.vKParse all introspectable children with the given namespace and local name. <Run the given parser for a given subelement in the XML tree.w;Run the given parser, returning either success or an error.de    fghijklmnopqrstuv w!"#/2`abcdefghijklmnopqrstuvwdefwopqrstuvijklmgnh`abc!#"/2de    fghijklmnopqrstuv wNone $FHMT Map the given type name to a C3 (defined in Data.GI.GIR.BasicTypes), if possible.The different array types. A C array A hash table.For GLists and GSLists there is sometimes no information about the type of the elements. In these cases we report them as pointers.)A type which is not a BasicType or array.8Parse information on a "type" element. Returns either a 6, or ] indicating that the name of the type in the introspection data was "none" (associated with void in C).7Find the children giving the type of the given element.Try 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".x\Parse the type of a node (which will be described by a child node named "type" or "array").yLike x, but allow for none, returned as . xyxyxy xyNone $HMT&Bytes used for storage of this struct.Parse a struct member.`Return the number of bytes that should be allocated for storage of the given values in an enum.1Parse an "enumeration" element from the GIR file. z{|}~z{|}~z{|}~z{|}~None $HMTNone $HMTCH name for the argument. For a escaped name valid in Haskell code, use 56. None $HMT   None $HMTNone $HMTNone $HMT9A function taking the parent instance as first argument.A function in the namespace)Constructs an instance of the parent type None $HMTNone $HMTInfo about a constant.-Parse a "constant" element from the GIR file.None $HMT!Parse 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."#! #"!None $HMT  None $HMT None $HMTNone $HMT   None $HMT                   Safe-Inferred $HMT ,Type constructor applied to the given types. Embed in the $ monad.A Ptr to the type.A FunPtr to the type. Embed in the % monad. )6789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXY )6BA@?>=<;:987CYXWVUTSRQPONMLKJIHGFED  None $HMT&&Find all aliases in a given namespace.'.Parse all the aliases in the current namespace(Parse a single alias%Find all aliases in a given document.&'(&'( None $HMT"A rule for modifying the GIR file.&(Path to element, attrName), newValue)Node selector for a path in the GIR file. Combination of the above.!Node of the given type." Node with the given "name" attr.#Path 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.)/Parse the list of includes in a given document.*(Load a set of dependencies, recursively.+6Load a given GIR file and recursively its dependencies,UTurn a GIRInfoParse into a proper GIRInfo, doing some sanity checking along the way.+Bare minimum loading and parsing of a single repository, without loading or parsing its dependencies, resolving aliases, or fixing up structs or interfaces.,6Load and parse a GIR file, including its dependencies.-List the prerequisites for a  corresponding to an interface..oThe 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./tThere 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.0%Find out whether the struct is boxed.1}Fix the size and alignment of fields. This is much easier to do by using libgirepository than reading the GIR file directly.2Same thing for unions.3Like fixupStructSizeAndOffset above.47Fixup the offsets of fields using the given offset map.5Fixup 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.6DGiven a XML document containing GIR data, apply the given overrides.7Looks 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.8DSet an attribute for the child element specified by the given path.9<See if a given node specification applies to the given node.? !"#:;<=>?@ABCD$%&'()*EFGHIJKLM)*Verbose Requested Loaded so farextra path to searchfixupsNew loaded set+verbosenameversionextra paths to searchfixups(loaded doc, dependencies),+verbosenameversionextra paths to searchbare parsed document,verbosenameversionextra paths to searchfixups(parsed doc, parsed deps)-./0123456789 /0\]^_`abcz{|}~    !"#$%&'()*+,$%&'()*,+#"! `abc\_^] 0/   z{|}~# "! #:;<=>?@ABCD$%&'()*EFGHIJKLM)*+,+,-./0123456789!None  $HMT(NXWe have a bit of context (the current namespace), and can fail, encode this in a monad.O Conditional flags for the parserP"The state of the overrides parser.QThe current namespace.RCurrently loaded flags.S Ignored elements of a given API.T?Ignored APIs (all elements in this API will just be discarded).U9Structs for which accessors should not be auto-generated.VExplicit calloccopyfree for structs/unions..;Mapping from GObject Introspection namespaces to pkg-config/0Version number for the generated .cabal package.0"Prefered version of the namespace.1Fixups for the GIR data.W*Construct the generic config for a module.XDefault, empty, parser state.YGet the current namespace.Z8Run the given parser only if the flags can be satisfied.[#Check whether the given flag holds.\FCheck whether we are running under the given OS. We take the OS from 78Q, but it is possible to override this value by setting the environment variable HASKELL_GI_OVERRIDE_OS.2Parse the given config file (as a set of lines) for a given introspection namespace, filling in the configuration as needed. In case the parsing fails we return a description of the error instead.]TParse a single line of the config file, modifying the configuration as appropriate.^Ignored elements._Sealed structures.`.Explicit allocation info for wrapped pointers.a:Parse a explicit key=value pair into a (key, value) tuple.b<Mapping from GObject Introspection namespaces to pkg-config.c-Choose a preferred namespace version to load.d-Specifying the cabal package version by hand.e&Set a given attribute in the GIR file.f<Parse a path specification, which is of the form "nodeSpec1 nodeSpec2_../nodeSpecN", where nodeSpec is a node specification of the form "nodeType[:name attribute]".g"Parse a single node specification.h+Parse an XML name, with an optional prefix.iParse a 'if' directive.j Parse an endif directive.kIFilter a set of named objects based on a lookup list of names to ignore.lGiven the previous allocation info, and a new allocation info, replace those entries in the old allocation info which are specified in the new info.m-Filter one API according to the given config.n?Given a list of APIs modify them according to the given config.3LLoad a given API, applying filtering. Load also any necessary dependencies.oThere 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..NOpqrPsQR-tSTUV./01WXYZ[\2]^_`abcdefghijklmn3o-./0123-./0123NOrqpPsQR- tSTUV./01WXYZ[\2]^_`abcdefghijklmn3o"None $HMT6#Name of the module being generated.7Whether to print extra info.80List of loaded overrides for the code generator.45678456784567845678None $HMTn9&Code generators that can throw errors.:+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 9Y computations, while disallowing the opposite embedding without explicit error handling.u#Information for the code generator.vAmbient config.w APIs available to the generator.@4Minimal version of base supported by a given module.A 8.0B 7.0C!Flags for module code generation.D'Reexport the module (as is) from .TypesEDo not import a  Callbacks submodule.FDo not import a Types submodule.GDUse the standard prelude, instead of the haskell-gi-base short one.H"Information on a generated module.JFull module name: [GI, Gtk, Label].KGenerated code for the module.L'Interface going into the .hs-boot file.M%Indexed by the relative module name.N$Set of dependencies for this module.OExports for the module.P'Set of language pragmas for the module.Q%GHC options for compiling the module.RFlags for the module.SDocumentation for the module.T1Minimal version of base the module will work on.xPossible types of exports.yReexport of a whole module.z!A signal for an object/interface.{#A property for an object/interface.|!A method for a struct/union, etc.}!An export in no specific section.~A type declaration.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.Which kind of export.Actual symbol to export.Symbol to export.LSubsection of the haddock documentation where the export should be located.VA grouped set of linesWThe basic sequence of codeXIndented regionY.A single line, indented to current indentationZNo code[A 0 representation of the given base version bound.Generate the empty module.Run a : with given 4 and initial H[, returning either the resulting exception, or the result and final state of the codegen.4This is useful when we plan run a subgenerator, and - the result to the original structure later.zRun the given code generator using the state and config of an ambient CodeGen, but without adding the generated code to K", instead returning it explicitly.\Like recurseA, giving explicitly the set of loaded APIs for the subgenerator.:Merge everything but the generated code for the two given H.$Merge the infos, including code too.IAdd the given submodule to the list of submodules of the current module.]NRun the given CodeGen in order to generate a submodule 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.a&Return the name of the current module.b3Return the list of APIs available to the generator. Due to the forall in the definition of :A, if we want to run the monad transformer stack until we get an $D action, our only option is ignoring the possible error code from S. 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.cLike d), but discard the resulting output value.d{Run a code generator, and return the information for the generated module together with the return value of the generator.e0Mark the given dependency as used by the module.ftReturn the transitive set of dependencies, i.e. the union of those of the module and (transitively) its submodules.gPReturn the minimal base version supported by the module and all its submodules.hMGive a friendly textual description of the error for presenting to the user.'Add some code to the current generator.n&Print out a (newline-terminated) line.oLPrint out the given line both to the normal module, and to the HsBoot file.p A blank lineq.Increase the indent level for code generation.rGroup a set of related code.sCWrite the given code into the .hs-boot file for the current module.#Add a export to the current module.tReexport a whole module.u8Export a toplevel (i.e. belonging to no section) symbol.v&Add a type declaration-related export.w,Add a method export under the given section.x6Add a property-related export under the given section.y4Add a signal-related export under the given section.z0Set the language pragmas for the current module.{HSet 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.~UAdd the given text to the module-level documentation for the module being generated.$Return a text representation of the U.PPad a line to the given number of leading spaces, and add a newline at the end.,Put a (padded) comma at the end of the text.$Format the list of exported modules.%Format the toplevel exported symbols.%Format the type declarations section.+Format a given section made of subsections.Format the list of methods.Format the list of properties.Format the list of signals.JFormat the given export list. This is just the inside of the parenthesis.(Write down the list of language pragmas.#Write down the list of GHC options.!Standard fields for every module.FThe haddock header for the module, including optionally a description.:Generic module prelude. We reexport all of the submodules.)Code for loading the needed dependencies.Standard imports.{Write to disk the code for a module, under the given base directory. Does not write submodules recursively, for that use .0Generate the .hs-boot file for the given module.9Construct the filename corresponding to the given module.MTurn an abstract module name into its dotted representation. For instance, [GI, Gtk, Types] -> GI.Gtk.Types.Write down the code for a module and its submodules to disk under the given base directory. It returns the list of written modules.+List of reexports from the ".Types" module.$Import the given (.hs-boot) modules.Write down the ".Types" file reexporting all the interfaces defined in .hs-boot files. Returns the module name for the ".Types" file.Write down the code for a module and its submodules to disk under the given base directory. This also writes the submodules, and a Typesi submodule reexporting all interfaces defined in .hs-boot files. It returns the list of written modules.9:;<=>?uvw@ABCDEFGHIJKLMNOPQRSTxyz{|}~UVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~J9:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~JUZYXWVHIJKLMNOPQRSTCGFED;:9<?>=cdfg@BA[e_\^hijkqonprs]z{|}~utvwxylmb`aY9:;<?>=uvw@BACGFEDH IJKLMNOPQRSTx~}|{zyUZYXWV[\]^_`abcdefghijklmnopqrstuvwxyz{|}~#None $HMTnObtain the minor version. That is, if the given version numbers are x.y.z, so branch is [x,y,z], we return y.EObtain 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.If 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!ODetermine the next version for which the minor of the package has been bumped.Determine the pkg-config name and installed version (major.minor only) for a given module, or throw an exception if that fails.Given 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).[Try to generate the cabal project. In case of error return the corresponding error string.  $None  $HMTnMove leading underscores to the end (for example in GObject::_Value_Data_Union -> GObject::Value_Data_Union_)Return a qualified prefix for the given namespace. In case the namespace corresponds to the current module the empty string is returned, otherwise the namespace ++ suffix is returned. Suffix is typically just ".", see  below.dReturn the qualified namespace (ns ++ "." or "", depending on whether ns is the current namespace).VSave a bit of typing for optional arguments in the case that we want to pass Nothing.4For a string of the form "one-sample-string" return OneSampleStringSimilarly, 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.gName 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.  %None $HMT 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.ZGuess 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.  &None $HMT3Check whether the given name descends from GObject.'None $-FHMTThe free monad.$Lift some command to the Free monad.Try to find the hash and equalO 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.JReturns whether the given type is represented by a pointer on the C side.;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.G<(None $HMTData 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 :: TypetAssign to the given name the given constant value, in a way that can be assigned to the corresponding Haskell type.TShow a basic type, in a way that can be assigned to the corresponding Haskell type.  )None $HMTPFree a container and/or the contained elements, depending on the transfer mode.Given 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).Same 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.*None $HMT 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)).eThe 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. vMarshal 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.FGenerate 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 out6 argumens in the introspection data, we treat them as inoutO 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 "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.& !"#$     & !"#$     +None $HMT%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.<Compute the (ordered) list of parents of the current object.UList all properties defined for an object, including those defined by its ancestors.\List all properties defined for an interface, including those defined by its prerequisites.RList all signals defined for an object, including those defined by its ancestors.YList all signals defined for an interface, including those defined by its prerequisites.RList all methods defined for an object, including those defined by its ancestors.YList all methods defined for an interface, including those defined by its prerequisites.&'()%*+,-./01&'()%*+,-./01,None $HMT2sGiven a property, return the set of constraints on the types, and the type variables for the object and its value.3The 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".4NThe name of the type encoding the information for the property of the object.5QGenerate a placeholder property for those cases in which code generation failed.kGenerate 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.62789:3;4<5=>62789:3;4<5=>-None $HMT?/Qualified name for the info for a given method.@AAppropriate instances so overloaded labels are properly resolved. Generate the  MethodList> instance given the list of methods for the given named type. Generate the  MethodInfo( type and instance for the given method.kGenerate a method info that is not actually callable, but rather gives a type error when trying to use it.?@?@.None $HMT@Return the name for the signal in Haskell CamelCase conventions.ABCDEFGHIJKABCDEFGHIJK/None $HMT+Generate the overloaded signal connectors: Clicked,  ActivateLink, ...L@Qualified name for the "(sigName, info)" tag for a given signal.M<Generate the given signal instance for the given API object./Signal instances for (GObject-derived) objects. Signal instances for interfaces.NLMNLM0None $HMT8Whether (not) to generate bindings for the given struct.OKCanonical name for the type of a callback type embedded in a struct field.PrFix the interface names of callback fields in the struct to correspond to the ones that we are going to generate.Fix 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.Extract 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.QMThe name of the type encoding the information for a field in a struct/union.RExtract a field from a struct.SbWrite 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.TWrite a NULL" into a field of a struct of type Ptr.UName for the getter functionVName for the setter functionWName for the clear functionXHaskell name for the fieldYSupport 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.ZGenerate a constructor for a zero-filled struct/union of the given type, using the boxed (or GLib, for unboxed types) allocator.Specialization for structs of Z.Specialization for unions of Z.[)Construct a import with the given prefix.\Same as [, but import a FunPtr to the symbol.cGenerate the typeclass with information for how to allocate/deallocate unboxed structs and unions.OPQRSTUVWXY]Z[\OPQRSTUVWXY]Z[\1None $HMT^ Generate wrapper for structures._Generated wrapper for unions.`abcdef^_ghijklmno`abcdef^_ghijklmno2None $HMTpA convenience helper for q@, such that bindings for the given module are generated in the  configure step of cabal. A version of r( which generates the bindings as needed.spnameversionverboseoverrides file output dir previous qnameversionverboseoverrides file output dirsp3None $HMTt\A list of all overloadable identifiers in the set of APIs (current properties and methods).tutuv9:;<=>?@ABCDEFGHIJKLMNOPQRSTUV W W X Y Y Z [ \ ] ^ _ ` a b c d e f g h i j k l m n o o p q r s t u v w x y z { | } ~                                      !"#$%%&'()*+,--./0123456789:;<= > ? @ A B C D E F G H I J K L M N O O P Q R S T U V!W!X!Y!Z![!\!]"^"^"_"`"abcdefghijklmnopqqrstuvwxyz{|}~###$$$$$$$$6%%&&&&&''''''''''''''''''''''''()))********+++++++,,,---...///000000011234444444444444      !"#$%& '() l * +,-./,0123456789:9;<=>?@ABCDEFGHIJKL9;MNOP Q R S T U V W X Y Z [ \ ] ^ _ ` a b b c d e f f g h i j k l m n o p q r s!!t!u!v!w!x!y!z!{!|!}!~!!!!!!!!!!!!!!!!!!!!!!!!!!u!W9:##### ##$$$$%%%%%%%&&''''''''''''''''''''''''''''''''''''''''' ' ' ' ' ''(((((((((())))))) )!)")#)$)%)&*'*(*)***+*,*-*.*/*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.9.:.<.g.h/i/j/k0l0m0T0n0o0p0q0r0s0t0u0v0w0x0y1z1{1|1}1~11111111111112233haskell-gi-0.15Data.GI.CodeGen.CodeData.GI.CodeGen.UtilData.GI.CodeGen.ProjectInfoData.GI.CodeGen.PkgConfigData.GI.CodeGen.GTypeData.GI.CodeGen.LibGIRepositoryData.GI.GIR.ParserData.GI.GIR.RepositoryData.GI.GIR.AllocationData.GI.GIR.XMLUtilsData.GI.GIR.DeprecationData.GI.GIR.DocumentationData.GI.GIR.BasicTypesData.GI.GIR.TypeData.GI.GIR.EnumData.GI.GIR.FlagsData.GI.GIR.ArgData.GI.GIR.CallableData.GI.GIR.CallbackData.GI.GIR.FunctionData.GI.GIR.MethodData.GI.GIR.SignalData.GI.GIR.ConstantData.GI.GIR.FieldData.GI.GIR.StructData.GI.GIR.UnionData.GI.GIR.PropertyData.GI.GIR.InterfaceData.GI.GIR.ObjectData.GI.CodeGen.TypeData.GI.GIR.AliasData.GI.CodeGen.APIData.GI.CodeGen.OverridesData.GI.CodeGen.ConfigData.GI.CodeGen.CabalData.GI.CodeGen.SymbolNamingData.GI.CodeGen.FixupsData.GI.CodeGen.GObjectData.GI.CodeGen.ConversionsData.GI.CodeGen.ConstantData.GI.CodeGen.TransferData.GI.CodeGen.CallableData.GI.CodeGen.InheritanceData.GI.CodeGen.Properties!Data.GI.CodeGen.OverloadedMethodsData.GI.CodeGen.Signal!Data.GI.CodeGen.OverloadedSignalsData.GI.CodeGen.StructData.GI.CodeGen.CodeGenData.GI.CodeGen.CabalHooks Data.GI.CodeGen.OverloadedLabelsPaths_haskell_giGI.SymbolNamingescapedArgName System.Infoosbase Data.Monoid<>padTo withCommentprime parenthesizetshowterrorucFirstlcFirsthomepageauthors maintainerslicense licenseTextpkgConfigGetVersionhaskell-gi-base-0.15Data.GI.Base.BasicTypesGTypegtypeIsA gtypeIsBoxed girRequiregirStructSizeAndOffsetsgirUnionSizeAndOffsets girLoadGTypexml-conduit-1.3.4.2Text.XMLElementreadGiRepository AllocationOpAllocationOpUnknownAllocationInfo allocCalloc allocCopy allocFreeunknownAllocationInfoGIRXMLNamespaceCGIRNS GLibGIRNS nodeToElement subelements localNamechildElemsWithLocalNamechildElemsWithNSNamefirstChildWithLocalNamegetElementContent lookupAttrlookupAttrWithNamespace xmlLocalName xmlNSNameDeprecationInfodeprecatedPragmaqueryDeprecated DocumentationdocTextqueryDocumentationType TInterfaceTGHashTGSListTGList TByteArray TPtrArrayTGArrayTCArray TParamSpecTVariantTError TBasicType BasicTypeTUIntPtrTIntPtrTPtr TFileNameTUTF8TGTypeTUniCharTDoubleTFloatTUInt64TInt64TUInt32TInt32TUInt16TInt16TUInt8TInt8TULongTLongTUIntTIntTBooleanAliasTransferTransferEverythingTransferContainerTransferNothingName namespacenameParser ParseError parseErrorcurrentNamespaceresolveQualifiedTypeNamegetAttrgetAttrWithNamespace queryAttrqueryAttrWithNamespace optionalAttr qualifyName parseNameparseDeprecationparseDocumentation parseIntegral parseBoolparseChildrenWithLocalNameparseAllChildrenWithLocalNameparseChildrenWithNSName runParser parseTypeparseOptionalType Enumeration enumValues errorDomain enumTypeInitenumStorageBytesenumDeprecated parseEnumFlags parseFlagsArgargCNameargType direction mayBeNullargScope argClosure argDestroyargCallerAllocatestransferScopeScopeTypeNotifiedScopeTypeAsync ScopeTypeCallScopeTypeInvalid DirectionDirectionInout DirectionOut DirectionIn parseTransferparseArgCallable returnTypereturnMayBeNullreturnTransferargs skipReturncallableDeprecated parseCallableCallback parseCallbackFunctionfnSymbolfnThrows fnMovedTo fnCallable parseFunctionMethod methodName methodSymbol methodThrows methodType methodMovedTomethodCallable MethodTypeOrdinaryMethodMemberFunction Constructor parseMethodSignalsigName sigCallable sigDeprecated parseSignalConstant constantType constantValueconstantDeprecated parseConstant FieldInfoFlagField fieldName fieldVisible fieldType fieldCallback fieldOffset fieldFlagsfieldDeprecated parseFieldsStruct structIsBoxedstructAllocationInfostructTypeInit structSizegtypeStructForstructIsDisguised structFields structMethodsstructDeprecatedstructDocumentation parseStructUnion unionIsBoxedunionAllocationInfo unionSize unionTypeInit unionFields unionMethodsunionDeprecated parseUnionPropertypropNamepropType propFlagspropReadNullablepropWriteNullable propTransferpropDeprecated PropertyFlagPropertyConstructOnlyPropertyConstructPropertyWritablePropertyReadable parseProperty Interface ifTypeInitifPrerequisites ifProperties ifSignals ifMethods ifDeprecatedparseInterfaceObject objParent objTypeInit objTypeName objInterfaces objDeprecatedobjDocumentation objMethods objProperties objSignals parseObjectconioptrfunptrmaybeTdocumentListAliasesAPIAPIUnion APIStruct APIObject APIInterfaceAPIFlagsAPIEnum APICallback APIFunctionAPIConstGIRRule GIRSetAttr GIRNodeSpec GIRTypedNameGIRTypeGIRNamedGIRPathGIRInfo girPCPackages girNSName girNSVersiongirAPIs girCTypesloadRawGIRInfo loadGIRInfo Overrides pkgConfigMapcabalPkgVersionnsChooseVersion girFixupsparseOverridesFilefilterAPIsAndDepsConfigmodNameverbose overrides ExcCodeGenCodeGen BaseCodeGenCGErrorCGErrorMissingInfoCGErrorBadIntrospectionInfoCGErrorNotImplemented BaseVersionBase48Base47 ModuleFlagReexportNoCallbacksImport NoTypesImportImplicitPrelude ModuleInfo moduleName moduleCodebootCode submodules moduleDeps moduleExports modulePragmas moduleGHCOpts moduleFlags moduleDoc moduleMinBaseCodeGroupSequenceIndentLineNoCodeshowBaseVersionrecurseWithAPIs submodule handleCGExcgetDepsconfig currentModulegetAPIsgenCode evalCodeGenloadDependencytransitiveModuleDepsminBaseVersiondescribeCGErrornotImplementedError badIntroErrormissingInfoErrorfindAPI findAPIByNamelineblineblankindentgrouphsBoot exportModuleexportToplevel exportDecl exportMethodexportProperty exportSignalsetLanguagePragmas setGHCOptionssetModuleFlagssetModuleMinBaseaddModuleDocumentation codeToTextwriteModuleCodewriteModuleTree cabalConfigsetupHsgenCabalProjectclassConstraint lowerName upperNamequalifynoNamehyphensToCamelCaseunderscoresToCamelCasedropMovedItemsguessPropertyNullability isGObject nameIsGObject apiIsGObjectisInitiallyUnownedapiIsInitiallyUnownedIdMPapplymapCliteral genConversioncomputeArrayLengthconverthToFfToH unpackCArray argumentType haskellType foreignType getIsScalar requiresAlloc isManaged typeIsPtrtypeIsNullableelementTypeAndMap elementType elementMap genConstantfreeContainerType freeInArgfreeInArgOnErrorhOutType wrapMaybeinArgInterfacesarrayLengthsMap arrayLengthscallableSignaturefixupCallerAllocates genCallable instanceTreefullObjectPropertyListfullInterfacePropertyListfullObjectSignalListfullInterfaceSignalListfullObjectMethodListfullInterfaceMethodListgenObjectPropertiesgenInterfacePropertiesgenNamespacedPropLabels genMethodList genMethodInfogenUnsupportedMethodInfo genCallbacksignalHaskellName genSignalgenOverloadedSignalConnectorsgenObjectSignalsgenInterfaceSignals ignoreStruct fixAPIStructsextractCallbacksInStructgenStructOrUnionFields genZeroStruct genZeroUnion genWrappedPtr genFunction genModulesimpleHaskellGIHooksgenOverloadedLabelscatchIOversionbindirlibdirdatadir libexecdir sysconfdir getBinDir getLibDir getDataDir getLibexecDir getSysconfDirgetDataFileName text-1.2.2.1Data.Text.InternalText tryPkgConfig g_type_is_a gtypeBoxedTypelibBaseInfo girFindByName girSymbol GTypeInit gtypeInitg_typelib_symbolg_union_info_get_fieldg_union_info_get_n_fieldsg_union_info_get_sizeg_struct_info_get_fieldg_struct_info_get_n_fieldsg_struct_info_get_sizeg_base_info_get_nameg_field_info_get_offsetg_irepository_find_by_nameg_irepository_requirec_g_base_info_gtype_get_type$fBoxedObjectBaseInfosplitOngirFile girDataDirs girFilePathgirFile' girNamespacexml-types-0.3.6Data.XML.TypesdeprecatedSinceVersiondeprecationMessage ParseContextelementDescriptionnameInCurrentNS withElement ctxNamespace treePositioncurrentElement knownAliasesnameToBasicTypeparseArrayInfoparseCArrayTypeparseHashTable parseListTypeparseFundamentalType parseTypeInfo Data.MaybeNothingparseTypeElements queryTypeparseEnumMemberextractEnumStorageBytesget_storage_bytes parseScopeparseDirection parseArgsparseOneReturn parseReturn parseFieldFieldIsWritableFieldIsReadableghc-prim GHC.TypesIOMaybenamespaceListAliases parseAliases parseAliasdocumentListIncludesloadDependencies loadGIRFile toGIRInfogtypeInterfaceListPrereqsfixupInterface fixupStructfixupStructIsBoxedfixupStructSizeAndOffsets fixupUnionfixupUnionSizeAndOffsets fixupField fixupGIRInfosfixupGIRDocumentfixupGIR girSetAttr specMatch GIRInfoParse girIPPackage girIPIncludesgirIPNamespaces GIRNamespacensName nsVersionnsAPIsnsCTypesg_type_interface_prerequisitesparseAPIparseNSElementparseNamespace parseInclude parsePackageparseRootElementemptyGIRInfoParseparseGIRDocument ParserFlag ParserState currentNSflags ignoredElems ignoredAPIs sealedStructs allocInfodefaultOverridesemptyParserStategetNS withFlags checkFlagcheckOS parseOneLine parseIgnore parseSealparseAllocInfoparseKeyValuePairparsePkgConfigNameparseNsVersionparseCabalPkgVersion parseSetAttr parsePathSpec parseNodeSpec parseXMLNameparseIf parseEndif filterMethodsfilterAllocInfo filterOneAPI filterAPIs$fMonoidOverrides FlagWindowsFlagOSX FlagLinux CodeGenConfighConfig loadedAPIs ExportType ExportModule ExportSignalExportProperty ExportMethodExportToplevelExportTypeDeclExport exportType exportSymbol SymbolNameHaddockSection emptyModule runCodeGen cleanInfomconcat recurseCGmergeInfoState mergeInfo addSubmodule unwrapCodeGentransformers-0.5.2.0Control.Monad.Trans.Except runExceptTtellCodeexport paddedLinecommaformatExportedModulesformatToplevelformatTypeDecls formatSection formatMethodsformatProperties formatSignalsformatExportListlanguagePragmas ghcOptionsstandardFields moduleHaddock modulePrelude importDeps moduleImportswriteModuleInfo genHsBootmoduleNameToPath dotModuleName typeReexports hsBootImports writeTypes ModuleNameDeps $fMonoidCode minorVersionhaskellGIMinorgiModuleVersion giNextMinorreadMajorMinorhaskellGIAPIVersionsanitizequalifyWithSuffixescapeReservedupperNameWithSuffixfilterMovedMethodsguessObjectPropertyNullability!guessInterfacePropertyNullabilityguessNullabilityguessReadNullabilityguessWriteNullability findMethodtypeDoParentSearchapiDoParentSearchFreeliftFhashTableKeyMappingshashTablePtrPackersMap MapSecondMapFirst ConverterFExprLiteralMapCApplyPuremapNamemonadicMapNamemapFirst mapSecond hObjectToF hVariantToF hParamSpecToF hBoxedToF hStructToF hUnionToFhToF'getForeignConstructorhToF_PackedTypehToF_PackGHashTableboxedForeignPtr suForeignPtrstructForeignPtrunionForeignPtr fObjectToH fCallbackToH fVariantToH fParamSpecToHfToH'getHaskellConstructorfToH_PackedTypefToH_UnpackGHashTablehaskellBasicTypeforeignBasicType$fIsStringConstructor $fMonadFree$fApplicativeFree $fFunctorFreePatternSynonym assignValue showBasicType PSExpressionPSViewPSTypePSValueExplicitSynonym SimpleSynonym writePattern basicFreeFnbasicFreeFnOnError freeContainerfreeElem fullyFreefullyFreeOnError freeElementsfreeGHashTablefreeElementsOnErrorfreeIn freeInOnErrorfreeInGHashTablefreeOutcallableHInArgscallableHOutArgs convertResult convertOutArgconvertOutArgsinvokeCFunction returnResultgenHaskellWrappergenWrapperBodymkForeignImportclassifyDuplicatesreadInArrayLengthsreadInArrayLengthcheckInArrayLength skipRetVal freeInArgs' freeInArgsfreeInArgsOnErrorprepareArgForCall prepareInArgprepareInCallbackprepareInoutArg prepareOutArgconvertOutCArrayreadOutArrayLengths touchInArgclosureToCallbackMapprepareClosuresfreeCallCallbacksformatHSignature getParent InheritableifInheritablesobjInheritablesiNameapiInheritablesfullAPIInheritableListfullObjectInheritableListfullInterfaceInheritableListremoveDuplicates$fInheritableMethod$fInheritableSignal$fInheritablePropertyattrType hPropNameinfoTypegenPlaceholderProperty propTypeStrgenPropertySettergenPropertyGettergenPropertyConstructorgenPropertyClearaccessorOrUndefinedgenOneProperty genPropertiesgenNamespacedAttrLabelsmethodInfoNamegenMethodResolvergenHaskellCallbackPrototypegenCCallbackPrototypegenCallbackWrapperFactory genClosureconvertNullableconvertCallbackInCArray saveOutArggenCallbackWrappersignalInfoName genInstancefindSignalNamesfieldCallbackTypefixCallbackStructFieldsbuildFieldReaderbuildFieldWriterbuildFieldClear fieldGetter fieldSetter fieldClearfName genAttrInfo genZeroSUprefixedForeignImportprefixedFunPtrImportbuildFieldAttributes genStructgenUniongenBoxedObjectgenEnumOrFlags genBoxedEnumgenEnum genBoxedFlagsgenFlagsgenErrorDomain fixMethodArgsfixConstructorReturnType genMethodgenGObjectCasts genObject genInterfacesymbolFromFunctiongenAPI genModule'confCodeGenHookCabal-1.24.0.0Distribution.Simple.UserHooksconfHookDistribution.SimplesimpleUserHooksConfHookfindOverloadedgenOverloadedLabel