h$nΗ      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~                                                                                                                                                          Safe-Inferred >?[hoppy-generatorfilterMaybe bad converts a Just bad into a Nothing, returning all other Maybe values as is.hoppy-generator !fromMaybeM m x = maybe m return xhoppy-generator #fromEitherM f x = either f return xhoppy-generator  maybeFail s x = maybe (fail s) xhoppy-generatorwhileJust_ gen act runs act on values generated from gen until gen returns a Nothing.hoppy-generator for = flip maphoppy-generator0Drops the last item from the list, if non-empty.hoppy-generatorlistSubst a b xs replaces all x in xs such that x == a with b.hoppy-generatorlistSubst' a bs xs replaces all x in xs such that x == a with the sequence of items bs.hoppy-generatorRenders a double-quoted string, enclosing the given characters in double quotes and escaping double quotes and backslashes with backslashes.hoppy-generatorTakes a map of strings and a target string, and replaces references to keys enclosed in braces in the target string with their values. Returns a Right with the replaced string on success, and when an unknown key is encountered then a Left with the unknown key.hoppy-generator(Zips two lists using a monadic function.hoppy-generatorUpper cases the first character of a string, and lower cases the rest of it. Does nothing to an empty string.hoppy-generator9Lower cases the first character of a string, if nonempty.hoppy-generator9Upper cases the first character of a string, if nonempty.hoppy-generatorAdds a noun onto a number in either singular or plural form, depending on the number.hoppy-generatorIf the file specified does not exist or its contents does not match the given string, then this writes the string to the file. Safe-Inferred >?hoppy-generatorA monad transformer for .hoppy-generator?&hoppy-generatorA   that allows plugging arbitary logic into the compilation process.hoppy-generator(A label to display when the compiler is n. The string is """.hoppy-generatorGiven a source file path and an output path, compiles the source file, producing a binary at the output path. Returns true on success. Logs to standard error and returns false on failure.>This should inspect the compiler argument to make use of its .The first argument is the  object that this function was pulled out of. This is passed in explicitly by  ! because due to the presence of   it's not always possible to have access to the final compiler object ahead of time.hoppy-generatorPaths to be searched for C++ header files, in addition to the compiler's default search directories.hoppy-generatorA compiler that can compile a source file into a binary with a single program invocation.Within the strings in this data type, including the program path, all occurences of {in} and {out} are expanded to the input and desired output files, respectively.hoppy-generatorThe name of the compiler program to call. Lookup is subject to the regular search path rules of your operating system.hoppy-generatorArguments to pass to the compiler. Each string is passed as a separate argument. No further word splitting is done. hoppy-generatorAn existential data type for  s. hoppy-generator?/p hoppy-generatorRepresents a map from k values to v values, where each entry can be overridden based on parameter p. A key is either present with a default value and possibly some overridden values, or it is completely absent -- it is not possible for a key to have overridden values but no default value.hoppy-generator#Represents a default value of type v2 with optional overrides keyed by parameter type p . The type p must have an  instance.hoppy-generator'The default, unoverriden value for the . Lookups on the override will return this value a given parameter doesn't have an override.hoppy-generator2Any overridden values that have been added to the .hoppy-generator Creates a  with the given default value v, and no overridden values. hoppy-generator Creates a  with the given default value v$, and overridden values in the map.!hoppy-generatorConverts a plain map to a  without any overrides."hoppy-generatorDirect constructor for .#hoppy-generatorAdds an override v for key k under parameter p to a .It is an error for a parameter to override a key that is not present in the defaults map.$hoppy-generatorAdds a collection of overrides v for multiple keys k , all under a single parameter p, to a .It is an error for a parameter to override a key that is not present in the defaults map.%hoppy-generatorAdds overrides v for multiple keys k under multiple parameters p to a .It is an error for a parameter to override a key that is not present in the defaults map.&hoppy-generator Constructs a  from a map of default values and a bunch of parameter-specific maps overlaid on top of it.It is an error for a parameter to override a key that is not present in the defaults map.'hoppy-generatorLooks up a value for k in the given , with the possibility that the value is overridden by the parameter p.  !"#$%&'  !"$%&#'None >?(hoppy-generatorA collection of imports for a Haskell module. This is a monoid: import Statements are merged to give the union of imported bindings.>This structure supports two specific types of imports: - import Foo (...) - import qualified Foo as Bar Imports with as but without  qualified, and  qualified imports with a spec list, are not supported. This satisfies the needs of the code generator, and keeps the merging logic simple.)hoppy-generatorWhether or not const is applied to an entity.*hoppy-generatorA single component of an + , between ::s.+hoppy-generatorA path to some C++ object, including namespaces. An identifier consists of multiple parts separated by "::". Each part has a name string followed by an optional template argument list, where each argument gets rendered from a  (non-type arguments for template metaprogramming are not supported).The  instance inserts a :: between joined identifiers. Usually an identifier needs to contain at least one part, so  is an invalid argument to many functions in Hoppy, but it is useful as a base case for appending.,hoppy-generator.The separate parts of the identifier, between ::s.-hoppy-generatorAn external name is a string that generated bindings use to uniquely identify an object at runtime. An external name must start with an alphabetic character, and may only contain alphanumeric characters and '_'. You are free to use whatever naming style you like; case conversions will be performed automatically when required. Hoppy does make use of some conventions though, for example with =s and in the provided bindings for the C++ standard library.External names must be unique within an interface. They may not be reused between modules. This assumption is used for symbol naming in compiled shared objects and to freely import modules in Haskell bindings..hoppy-generatorReturns the string an an - contains./hoppy-generatorA set of requirements of needed to use an identifier in C++ (function, type, etc.), via a set of s. The monoid instance has # as an empty set of includes, and  unions two include sets.0hoppy-generator*Indicates strings that are error messages.Uhoppy-generator!Specifies how a name is imported.Vhoppy-generator3The name is imported, and nothing underneath it is.Whoppy-generatorThe name is imported, as are specific names underneath it. This is a  X (a, b, c) import.Xhoppy-generatorThe name is imported, along with all names underneath it. This is a X (..) import.Yhoppy-generatorAn identifier that can be imported from a module. Symbols may be used here when surrounded by parentheses. Examples are "fmap" and "(++)".Zhoppy-generator9A specification of bindings to import from a module. If +, then the entire module is imported. If  $, then only instances are imported.^hoppy-generatorReferences an occurrence of an import statement, under which bindings can be imported. Only imported specs under equal ^s may be merged.bhoppy-generatorA Haskell module name.choppy-generatorReturns the import set's internal map from module names to imported bindings.dhoppy-generator0A map whose values may be overridden based on a f.ehoppy-generator*A value that may be overridden based on a f.fhoppy-generatorLanguages that Hoppy supports binding to. Currently this is only Haskell.ghoppy-generatorThe Haskell language.hhoppy-generatorDescribes the value of an entry in a C++ enum. A numeric value may either be provided manually, or if omitted, Hoppy can determine it automatically.ihoppy-generator(A manually specified numeric enum value.jhoppy-generatorA numeric enum value that will be determined when the generator is run, by means of compiling a C++ program.khoppy-generator$Describes the entries in a C++ enum.'Equality is defined as having the same o.mhoppy-generatorThe names of all entries in the enum being generated, in the order specified by the enum definition. These are the strings used to name generated bindings. Each name is broken up into words. How the words and get combined to make a name in a particular foreign language depends on the language.nhoppy-generator+Per-language renames of enum value entries.ohoppy-generator#A map specifying for each entry in m., how to determine the entry's numeric value.phoppy-generatorA list of words that comprise the name of an enum entry. Each string in this list is treated as a distinct word for the purpose of performing case conversion to create identifiers in foreign languages. These values are most easily created from a C++ identifier using .qhoppy-generatorStructural information about a C++ enum. This is used when Hoppy is evaluating enum data, see .See  .shoppy-generatorThe external name of the enum.thoppy-generatorThe enum's identifier.uhoppy-generatorThe enum's numeric type, if explicitly known to the bindings. This does not need to be provided. If absent, then Hoppy will calculate the enum's numeric type on its own, using a C++ compiler. If this is present however, Hoppy will use it, and additionally validate it against what the C++ compiler thinks, if validation is enabled (see ).vhoppy-generator$Requirements for accessing the enum.whoppy-generator'Whether the enum is scoped or unscoped.xhoppy-generatorThe entries in the enum.yhoppy-generator,A typeclass for types that have an addendum.zhoppy-generatorReturns an object's addendum.{hoppy-generator,Replaces and object's addendum with another.|hoppy-generatorModified an object's addendum.}hoppy-generatorA literal piece of code that will be inserted into a generated source file after the regular binding glue. The ' instance concatenates code (actions).hoppy-generatorCode to be output into the Haskell binding. May also add imports and exports.hoppy-generator!Types that can handle exceptions.hoppy-generator.Extracts the exception handlers for an object.hoppy-generator>Modifies an object's exception handlers with a given function.hoppy-generatorRepresents a list of exception handlers to be used for a body of code. Order is important; a : will prevent all subsequent handlers from being invoked.hoppy-generator(Extracts the list of exception handlers.hoppy-generatorIndicates the ability to handle a certain type of C++ exception.hoppy-generatorIndicates that instances of the given class are handled (including derived types).hoppy-generator4Indicates that all C++ exceptions are handled, i.e.  catch (...).hoppy-generator/Each exception class has a unique exception ID.hoppy-generator Internal.hoppy-generatorControls how conversions between C++ values and Haskell values happen in Haskell bindings.Prefer ) to using this data constructor directly.hoppy-generatorThe type exposed to users of the Haskell side of a binding. Functions that take one of these values as an argument will expect this type, and functions returning one of these values will return this type.This type is wrapped in a generator in order to be able to specify any necessary imports. This generator should not generate code or add exports.hoppy-generatorIf present, then for bindings for C++ functions that expect one of these values as an argument, rather than taking a fixed concrete type (3), this qualified type will be used instead. The  parameter receives a unique name from the generator that can be used with  like so: ?\name -> return $ HsQualType [...constraints...] (HsTyVar name)/ should satisfy this constraint, when present.This type is wrapped in a generator in order to be able to specify any necessary imports. This generator should not generate code or add exports.hoppy-generatorIf present, then rather than passing a value of native Haskell type () directly over the FFI, this is an intermediate type that will be passed instead. This is needed any time that the former type isn't a simple type that the FFI supports. and : marshal values into and out of this type, respsectively.This type is wrapped in a generator in order to be able to specify any necessary imports. This generator should not generate code or add exports.hoppy-generatorThis defines how a Haskell value is passed to C++. If this is , then  must be present, and the generator should output a function that takes a value of type  and return a value of .If  is present, then the function should be able to accept that more general type instead. This is used for bindings that call into C++ functions. This function is still specialized to 2 when generating code for callback return values.The generator should output code and may add imports, but should not add exports.hoppy-generatorThis defines how a Haskell value is passed from C++. If this is , then  must be present, and the generator should output a function that takes a value of type  and return a value of .The generator should output code and may add imports, but should not add exports.hoppy-generatorFor a , defines the C++ type and conversions to and from a C FFI layer.Prefer ) to using this data constructor directly. specifies the C++ type of the conversion. This will be the type that is passed over the C FFI as well, unless  overrides it.  and  may define custom code generation for passing values over the FFI.hoppy-generatorThe name of the C++ type. May identify a primitive C++ type such as "unsigned int", or a more complex type like std::list.hoppy-generatorComputes requirements to refer to the C++ type. Being in the generator monad, this may use its environment, but should not emit code or / to the generator directly.hoppy-generator6Specifies the type that will be passed over the C FFI.,If absent (default), then the type named by 4 is also used for marshalling to foreign languages.1If present, this represents a type distinct from  that will be exchanged across the FFI boundary. In this case, you may also want to define one or both of  and .This is a monadic value so that it has access to the generator's environment. The action should not add imports or emit code.hoppy-generatorThis controls behaviour for receiving a value passed into C++ over the FFI. Specifically, this powers the ConversionSpec being used as   arguments and  return values.When absent (default), generated code assumes that it can implicitly convert a value passed over the FFI from the C FFI type (see ) to the C++ type (i.e. 4). When the former is absent, this is always fine.When present, this provides custom conversion behaviour for receiving a value passed into C++ over the FFI. The function should generate C++ code to convert a value from the type passed over the C FFI into the actual C++ type.This is a function of the form: #\emitFromExpr maybeEmitToVar -> ...If the function's second argument is present, then the function should emit a variable declaration for that name, created from the expression emitted by the first argument.If the function's second argument is absent, then the function should emit an expression that converts the expression emitted by the first argument into the appropriate type.In both cases, the first generator argument should only be evaluated once by the resulting C++ expression; it is not guaranteed to be pure.hoppy-generatorThis is the opposite of . This being present enables custom conversion behaviour for passing a value out of' C++ through the FFI. This powers the ConversionSpec being used as   return values and  arguments.hoppy-generatorThe root data type for specifying how conversions happen between C++ and foreign values.The Cpp component of this data structure specifies a C++ type, and conversions between it and something that can be marshalled over a C FFI layer, if such a conversion is possible in each direction.Each foreign language has its own component that must be specified in order for types using this specification to be usable in that language.hoppy-generator?An identifying name, used for rendering in e.g. error messages.hoppy-generator+Fundamental information about the C++ type.hoppy-generator6A specification for how values can be used in Haskell.hoppy-generatorDefines the process for converting a value in one direction between C++ and a foreign language. The type parameter varies depending on the actual conversion being defined.hoppy-generatorThe conversion is unsupported. If part of an interface depends on performing this conversion, code generation will fail.hoppy-generatorThe input value and its corresponding output have the same binary representation in memory, and require no explicit conversion. Numeric types may use this conversion method.hoppy-generatorConversion requires a custom process as specified by the argument.+TODO Split into pure (let) vs nonpure (<-)?hoppy-generator>Objects that can be coerced to function parameter definitions.hoppy-generatorA parameter to a function, including a type and an optional name. A name can be conveniently associated with a type with the () operator.Two  Parameter%s are equal if their types are equal.hoppy-generatorThe parameter's data type.hoppy-generatorAn optional variable name to describe the parameter. This name should follow the same rules as - for its contents.hoppy-generator1Whether or not a function may cause side-effects.3Haskell bindings for pure functions will not be in , and calls to pure functions will be executed non-strictly. Calls to impure functions will execute in the IO monad.Member functions for mutable classes should not be made pure, because it is difficult in general to control when the call will be made.hoppy-generatorSide-affects are possible.hoppy-generatorSide-affects will not happen.hoppy-generator2Indicates whether an entity is scoped or unscoped.,This is used to distinguish unscoped enums (enum) or scoped ones ( enum class or  enum struct).hoppy-generator,Indicates an unscoped entity (e.g. an enum).hoppy-generator)Indicates a scoped entity (e.g. an enum).hoppy-generator*A concrete C++ type. Use the bindings in Foreign.Hoppy.Generator.Types for values of this type; these data constructors are subject to change without notice.hoppy-generatorSpecifies some C++ object (function or class) to give access to.hoppy-generatorInstances of this typeclass are C++ entities that Hoppy can expose to foreign languages: functions, classes, global variables, etc. s are largely composed of exports (grouped into modules). Hoppy uses this interface to perform code generation for each entity.hoppy-generator7Wraps an exportable object in an existential data type.The default instance is just  toExport = 3, which does not need to be overridden in general.hoppy-generatorAttempts to cast an exportable object to a specific type, pulling off  wrappers as necessary. The default  castExport =  is fine.hoppy-generator4Generates the C++ side of the binding for an entity.5For an entity, Hoppy invokes this function once with > when generating the header file for a module, and once with 0 when generating the corresponding source file.hoppy-generator8Generates the Haskell side of the binding for an entity.6For an entity, Hoppy invokes this function once with  9 when it is time to emit foreign imports, and once with ! when it is time to generate Haskell binding code later in the module. Hoppy may also call the function with ", if necessary.See 1.hoppy-generatorIf the export is backed by an C++ enum, then this returns known structural information about the enum. This provides information to the "evaluate enums" hook so that Hoppy can determine enum values on its own.By default, this returns Nothing.See .hoppy-generatorIf the export is backed by a C++ class that is marked as supporting exceptions, then this returns the class definition.By default, this returns Nothing.hoppy-generator$The name within the enclosing scope.hoppy-generatorTemplate arguments, if present.hoppy-generator$The arity and syntax of an operator.hoppy-generator#Prefix unary operators. Examples: !x, *x, ++x.hoppy-generator$Postfix unary operators. Examples: x--, x++.hoppy-generator#Infix binary operators. Examples: x * y, x >>= y.hoppy-generatorx(...) with arbitrary arity.hoppy-generatorx[y]*, a binary operator with non-infix syntax.hoppy-generatorOverloadable C++ operators.hoppy-generator x(...)hoppy-generator x, yhoppy-generator x = yhoppy-generator x[y]hoppy-generator *xhoppy-generator &xhoppy-generator x + yhoppy-generator x += yhoppy-generator x - yhoppy-generator x -= yhoppy-generator x * yhoppy-generator x *= yhoppy-generator x / yhoppy-generator x /= yhoppy-generator x % yhoppy-generator x %= yhoppy-generator +xhoppy-generator -xhoppy-generator ++xhoppy-generator x++hoppy-generator --xhoppy-generator x--hoppy-generator x == yhoppy-generator x != yhoppy-generator x < yhoppy-generator x <= yhoppy-generator x > yhoppy-generator x >= yhoppy-generator !xhoppy-generator x && yhoppy-generator x || yhoppy-generator ~xhoppy-generator x & yhoppy-generator x &= yhoppy-generator x | yhoppy-generator x |= yhoppy-generator x ^ yhoppy-generator x ^= yhoppy-generator x << yhoppy-generator x <<= yhoppy-generator x >> yhoppy-generator x >>= yhoppy-generator0Enables implementing automatic conversions to a  t.hoppy-generator%The C++ name of a function or method.hoppy-generatorA regular, "alphanumeric" name. The exact type depends on what kind of object is being named.hoppy-generatorAn operator name.hoppy-generatorTypes that have an external name, and also optionally have nested entities with external names as well. See .hoppy-generatorReturns the external name by which a given entity is referenced.hoppy-generatorReturns external names nested within the given entity. Does not include the primary external name.hoppy-generator7Contains the data types for bindings to C++ entities:  , J , etc. Use  or  to specify requirements for these entities, e.g. header files that must be included in order to access the underlying entities that are being bound.C++ types that have requirements in order to use them in generated bindings.hoppy-generator!Returns an object's requirements.hoppy-generator0Replaces an object's requirements with new ones.hoppy-generator"Modifies an object's requirements.hoppy-generatorThe includes specified by a /.hoppy-generator-A portion of functionality in a C++ API. An  is composed of multiple modules. A module will generate a single compilation unit containing bindings for all of the module's exports. The C++ code for a generated module will #include everything necessary for what is written to the header and source files separately. You can declare include dependencies with e.g. , either for individual exports or at the module level (via the   instance). Dependencies between modules are handled automatically, and circularity is supported to a certain extent. See the documentation for the individual language modules for further details.hoppy-generatorThe module's name. A module name must identify a unique module within an .hoppy-generatorA relative path under a C++ sources root to which the generator will write a header file for the module's C++ bindings.hoppy-generatorA relative path under a C++ sources root to which the generator will write a source file for the module's C++ bindings.hoppy-generatorAll of the exports in a module.hoppy-generatorModule-level requirements.hoppy-generator3The generated Haskell module name, underneath the . If absent (by default), the ! is used. May be modified with .hoppy-generator6Exceptions that all functions in the module may throw.hoppy-generatorWhether callbacks exported from the module support exceptions being thrown during their execution. When present, this overrides . This maybe overridden by #.hoppy-generatorThe module's addendum.hoppy-generatorAn #include directive in a C++ file.hoppy-generatorReturns the complete  #include ...2 line for an include, including trailing newline.hoppy-generator)Optional parameters when constructing an  with .hoppy-generatorA complete specification of a C++ API. Generators for different languages, including the binding generator for C++, use these to produce their output. does not have a  instance because  does not work for it (handled exceptions cannot be modified after an  is constructed).hoppy-generator"The textual name of the interface.hoppy-generator"All of the individual modules, by .hoppy-generator Maps each -> exported by some module to the module that exports the name.hoppy-generatorShort qualified module import names that generated modules use to refer to each other tersely.hoppy-generator9Exceptions that all functions in the interface may throw.hoppy-generatorWhether callbacks within the interface support throwing C++ exceptions from Haskell into C++ during their execution. This may be overridden by  and #.hoppy-generatorWhen an interface uses C++ exceptions, then one module needs to manually be selected to contain some interface-specific runtime support. This is the selected module.hoppy-generatorThe name of the  shared_ptr class to use, and the requirements to use it. This defaults to using std::shared_ptr from ', but can be changed if necessary via .hoppy-generatorThe C++ compiler for the generator itself to use when building temporary code for the interface. This can be overridden or disabled. This defaults to .This is separate from the ./configure && make compilation process used by #Foreign.Hoppy.Runtime.Setup.cppMain to build generated C++ bindings (see hoppy-runtime). This compiler is used to evaluate enums' numeric values when the generator is called, and is not used otherwise. See  $ and Foreign.Hoppy.Generator.Hooks.hoppy-generatorHooks allowing the interface to execute code at various points during the code generator's execution. This defaults to .hoppy-generator;Whether to validate manually-provided enum numeric types ( %) using a compiled C++ sizeof()*, as is done for enums that don't have an enumNumericType set.This defaults to true, but can be set to false to discourage requiring a compiler. See .hoppy-generatorOptions used by '. This contains no exception handlers.hoppy-generatorConstructs an  from the required parts. Some validation is performed; if the resulting interface would be invalid, an error message is returned instead.This function passes  to .hoppy-generatorSame as &, but accepts some optional arguments.hoppy-generatorThe name of the parent Haskell module under which a Haskell module will be generated for a Hoppy . This is a list of Haskell module path components, in other words,  "."< on the list produces a Haskell module name. Defaults to , and may be overridden with .hoppy-generatorThe default Haskell module under which Hoppy modules will be generated. This is Foreign.Hoppy.Generated , that is: !["Foreign", "Hoppy", "Generated"]hoppy-generatorSets an interface to generate all of its modules under the given Haskell module prefix. See .hoppy-generatorReturns the the exception ID for a class in an interface, if it has one (i.e. if it's been marked as an exception class with &).hoppy-generator5Returns all of the exception classes in an interface.hoppy-generatorChanges # for all callbacks in an interface that don't have it set explicitly at the module or callback level.hoppy-generatorSets an interface's exception support module, for interfaces that use exceptions.hoppy-generatorInstalls a custom std::shared_ptr implementation for use by an interface. Hoppy uses shared pointers for generated callback code. This function is useful for building code with compilers that don't provide a conforming std::shared_ptr implementation.&interfaceSetSharedPtr ident reqs iface modifies iface to use as a  shared_ptr class the C++ identifier ident, which needs reqs in order to be accessed. ident9 should be the name of a template to which an arbitrary  can be appended, for example "std::shared_ptr".A  shared_ptr implementation foo0 must at least provide the following interface: foo(); // Initialization with a null pointer. foo(T*); // Initialization with a given pointer. foo(const foo&); // Copy-construction. T& operator*() const; // Dereferencing (when non-null). T* operator->() const; // Dereferencing and invocation (when non-null). explicit operator bool() const; // Is the target object null?hoppy-generator4Replaces the default compiler used by the interface. interfaceSetCompiler c =  (  c)hoppy-generatorReplaces the default compiler used by the interface. When given Nothing, the interface will not be allowed to compile any code when it generates bindings.hoppy-generatorSets an interface to never compile C++ code during binding generation.This sets the interface to have no compiler, and also asks the interface not to do things that require a compiler, which would otherwise cause a runtime failure: currently just validation of provided enum numeric types ( False).hoppy-generatorControls whether the interface will validate manually specified enum types ( %) by compiling a C++ program.See .hoppy-generator0Modifies the hooks associated with an interface.hoppy-generator Creates an #include <...> directive.5This can be added to most types of C++ entities with .hoppy-generator Creates an #include "..." directive.5This can be added to most types of C++ entities with .hoppy-generator5Creates an empty module, ready to be configured with .hoppy-generatorExtends a module. To be used with the module state-monad actions in this package.hoppy-generatorSame as  , but calls  in the case of failure, which is okay in for a generator which would abort in this case anyway.hoppy-generatorReplaces a module's .hoppy-generatorReplaces a module's .hoppy-generatorAdds exports to a module. An export must only be added to any module at most once, and must not be added to multiple modules.hoppy-generatorChanges a module's > from the default. This can only be called once on a module.hoppy-generatorChanges # for all callbacks in a module that don't have it set explicitly.hoppy-generator Creates a /! that contains the given include.hoppy-generator Adds to a object's requirements.hoppy-generator9Adds a list of includes to the requirements of an object.hoppy-generator Creates an - that contains the given string, erroring if the string is an invalid -.hoppy-generator7Returns true if the given string is represents a valid -.hoppy-generator Generates an - from an +, if the given name is absent.hoppy-generator Generates an - from an  +, if the given name is absent.hoppy-generator Generates an -, from a string, if the given name is absent.hoppy-generatorReturns a list of all of the external names an entity contains. This combines both  and .hoppy-generator-Returns a conventional string to use for the - of an operator.hoppy-generator6Returns a conventional name for an operator, as with , but as a string.hoppy-generator Returns the type of an operator.hoppy-generator+Creates an identifier from a collection of *s, with :: s between.hoppy-generator>Creates an object representing one component of an identifier.hoppy-generator!Creates a identifier of the form a$, without any namespace operators (::).hoppy-generator"Creates an identifier of the form a1::a2::...::aN.hoppy-generator"Creates an identifier of the form a::b.hoppy-generator"Creates an identifier of the form a::b::c.hoppy-generator"Creates an identifier of the form  a::b::c::d.hoppy-generator"Creates an identifier of the form  a::b::c::d::e.hoppy-generator"Creates an identifier of the form a::b::c::d::e::f.hoppy-generator"Creates an identifier of the form a<...>.hoppy-generatorCreates an identifier with arbitrary many templated and non-templated parts.hoppy-generator"Creates an identifier of the form  a::b<...>.hoppy-generator"Creates an identifier of the form  a::b::c<...>.hoppy-generator"Creates an identifier of the form a::b::c::d<...>.hoppy-generator"Creates an identifier of the form a::b::c::d::e<...>.hoppy-generator"Creates an identifier of the form a::b::c::d::e::f<...>.hoppy-generatorCanonicalizes a 1 without changing its meaning. Multiple nested "s are collapsed into a single one.hoppy-generatorStrips leading s off of a type.hoppy-generatorStrips a leading  off of a type.hoppy-generatorReturns true if a . value is scoped, and false if it is unscoped.hoppy-generator%Returns the opposite constness value.hoppy-generator(Maps a function over a parameter's type.hoppy-generatorAn empty parameter list. This should be used instead of a literal [] when declaring an empty parameter list, because in the context of  a => [a], the empty list is ambiguously typed, even though it doesn't matter which instance is selected.hoppy-generator8Converts a list of parameter-like objects to parameters.hoppy-generator1Associates a name string with a type to create a  that can be given as a function or method parameter, instead of a raw . The name given here will be included as documentation in the generated code.An empty string given for the name means not to associate a name with the parameter. This is useful to leave some parameters unnamed in a parameter list while naming other parameters, since the list must either contain all  s or all s.hoppy-generator Creates a  from an identifying name and a specification of the C++ conversion behaviour. By default, no foreign language conversion behaviour is configured. For Haskell, this should be done by using 1 to specify behaviour, then writing that to the  field of the  returned here.hoppy-generator Builds a . with a C++ type, with no conversions defined.hoppy-generator Builds a % with the mandatory parameters given.hoppy-generator4The exception ID that represents the catch-all type.hoppy-generator3Appends additional exception handlers to an object.hoppy-generator%Adds a Haskell addendum to an object.hoppy-generatorConstructor for an import set.hoppy-generator>Sets all of the import specifications in an import set to be {-SOURCE-} imports.hoppy-generator6An import for the entire contents of a Haskell module.hoppy-generator'A qualified import of a Haskell module.hoppy-generator1An import of a single name from a Haskell module.hoppy-generator9A detailed import of a single name from a Haskell module.hoppy-generator2An import of multiple names from a Haskell module.hoppy-generator:A detailed import of multiple names from a Haskell module.hoppy-generatorImports  Data.Bits qualified as HoppyDB.hoppy-generatorImports Control.Exception qualified as HoppyCE.hoppy-generatorImports Data.Int qualified as HoppyDI.hoppy-generatorImports  Data.Word qualified as HoppyDW.hoppy-generatorImports Foreign qualified as HoppyF.hoppy-generatorImports  Foreign.C qualified as HoppyFC.hoppy-generatorImports Data.Map qualified as HoppyDM.hoppy-generatorImports Prelude qualified as HoppyP.hoppy-generatorImports Foreign.Hoppy.Runtime qualified as HoppyFHR.hoppy-generatorImports System.Posix.Types qualified as HoppySPT.hoppy-generatorImports System.IO.Unsafe qualified as HoppySIU.hoppy-generator*Returns an error message indicating that  '? is used where data is going from a foreign language into C++.hoppy-generator*Returns an error message indicating that  '? is used where data is going from a foreign language into C++.hoppy-generator*Returns an error message indicating that  (? is used where data is going from a foreign language into C++.hoppy-generatorhoppy-generatorhoppy-generatorhoppy-generatorhoppy-generatorhoppy-generatorhoppy-generatorhoppy-generatorhoppy-generatorhoppy-generatorhoppy-generatorhoppy-generatorhoppy-generator(c)*+,-./0UVXWYZ[]\^_`abdefghijklmnopqrstuvwxyz{|}~0 None >?8(hoppy-generatorC++ void , Haskell ().hoppy-generatorC++ bool , Haskell .C++ has sizeof(bool) == 1, whereas Haskell can > 1, so we have to convert.hoppy-generatorC++ bool , Haskell )*.hoppy-generatorC++ char , Haskell )+.hoppy-generatorC++  unsigned char , Haskell ),.hoppy-generatorC++ wchar_t , Haskell )-.hoppy-generatorC++  short int , Haskell )..hoppy-generatorC++ unsigned short int , Haskell )/.hoppy-generatorC++ int , Haskell  . See also .hoppy-generatorC++ int , Haskell )0 . See also .hoppy-generatorC++  unsigned int , Haskell )1.hoppy-generatorC++ long int , Haskell )2.hoppy-generatorC++ unsigned long int , Haskell )3.hoppy-generatorC++  long long int , Haskell )4.hoppy-generatorC++ unsigned long long int , Haskell )5.hoppy-generatorC++ float , Haskell  . See also .hoppy-generatorC++ float , Haskell )6 . See also .hoppy-generatorC++ double , Haskell  . See also .hoppy-generatorC++ double , Haskell )7 . See also .hoppy-generatorC++ int8_t , Haskell 89.hoppy-generatorC++ int16_t , Haskell 8:.hoppy-generatorC++ int32_t , Haskell 8;.hoppy-generatorC++ int64_t , Haskell 8<.hoppy-generatorC++ uint8_t , Haskell =>.hoppy-generatorC++ uint16_t , Haskell =?.hoppy-generatorC++ uint32_t , Haskell =@.hoppy-generatorC++ uint64_t , Haskell =A.hoppy-generatorC++  ptrdiff_t , Haskell )B.hoppy-generatorC++ size_t , Haskell )C.hoppy-generatorC++ ssize_t , Haskell DE.hoppy-generator%Builds a new numeric type definition.For convenience,  and . may be used as conversion methods, for both  arguments this function takes.hoppy-generatorConversion method for passing a numeric values to and from Haskell by using $Foreign.Hoppy.Runtime.coerceIntegral.hoppy-generatorConversion method for passing a numeric values to and from Haskell by using .hoppy-generatorA pointer to another type.hoppy-generatorA reference to another type.hoppy-generatorAn instance of a class. When used in a parameter or return type and not wrapped in a  or , this is a by-value object.hoppy-generatorA special case of  that is only allowed when passing objects from C++ to a foreign language. Rather than looking at the object's F, the object will be copied to the heap, and a pointer to the heap object will be passed. The object must be copy-constructable.The foreign language owns the pointer, even for callback arguments.hoppy-generatorThis type transfers ownership of the object to the foreign language's garbage collector, and results in a managed pointer in the foreign language. This may only be used in one of the forms below, when passing data from C++ to a foreign language (i.e. in a C++ function return type or in a callback argument). In the first case, the temporary object is copied to the heap, and the result is a managed pointer to the heap object instead of the temporary.  ( cls)  ( ( ( cls)))  ( ( cls))  ( ( ( cls)))  ( ( cls))hoppy-generatorConstructs a type from a specification of how to convert values.hoppy-generatorA const version of another type.hoppy-generatorThe name of the C++ type.hoppy-generator'Includes necessary to use the C++ type.hoppy-generatorGenerator for rendering the Haskell type to be used, along with any required imports. See .hoppy-generatorIf there is a Haskell type distinct from the previous argument to be used for passing over the FFI boundary, then provide it here. See .hoppy-generatorMethod to use to convert a Haskell value to a value to be passed over the FFI. See .hoppy-generatorMethod to use to convert a value received over the FFI into a Haskell value. See .,, None >?hoppy-generator&Bound information about numeric types.hoppy-generator.The numeric data type described by the record.hoppy-generator+The number of bytes in a value of the type.hoppy-generator;The lowest (most negative) value representable by the type.hoppy-generator?71hoppy-generatorReturns the currently generating module's Haskell module name.hoppy-generator Looks up the  containing a given external name, throwing an error if it can't be found.hoppy-generatorRuns a generator action for the given interface and module name string. Returns an error message if an error occurred, otherwise the action's output together with its value.hoppy-generator2Runs a generator action and returns the its value.hoppy-generator/Runs a generator action and returns its output.hoppy-generator Converts a  into a complete Haskell module.hoppy-generatorAdds the given function name to any error message thrown by the action, for context.hoppy-generator%Adds an export to the current module.hoppy-generatoraddExport' "x" adds an export of the form x (..) to the current module.hoppy-generator,Adds multiple exports to the current module.hoppy-generator8Adds a Haskell language extension to the current module.hoppy-generatorOutputs multiple words to form a line of Haskell code (effectively saysLn = sayLn . concat).hoppy-generatorOutputs an empty line of Haskell code. This is reportedly valid Perl code as well.hoppy-generatorRuns the given action, indenting all code output by the action one level.hoppy-generatorRuns the given action, indenting all code output by the action N spaces.hoppy-generatorTakes a list of binding actions and a body action, and outputs a let expression. By passing in ' for the body, it will be omitted, so let statements in do8 blocks can be created as well. Output is of the form: 3let ... in To stretch a binding over multiple lines, lines past the first should use  manually.hoppy-generatorLooks up the module that exports an external name. Throws an error if the external name is not exported.hoppy-generator Used like !addExtNameModule extName hsEntity. hsEntity is a name in Haskell code that is generated from the definition of extName, and thus lives in extName's module. This function adds imports and returns a qualified name as necessary to refer to the given entity.hoppy-generatorConstructs Haskell names from external names. Returns a name that is a suitable Haskell type name for the external name, and if given  , then with "Const" appended.hoppy-generatorPure version of & that doesn't create a qualified name.hoppy-generatorConverts an external name into a name suitable for a Haskell function or variable.hoppy-generatorPure version of & that doesn't create a qualified name.hoppy-generatorReturns a distinct argument variable name for each nonnegative number.hoppy-generator Returns the  corresponding to a  , and also adds imports to the 4) as necessary for Haskell types that the - references. On failure, an error is thrown.hoppy-generator Returns the B of a class.hoppy-generatorCombines the given exception handlers (from a particular exported entity) with the handlers from the current module and interface. The given handlers have highest precedence, followed by module handlers, followed by interface handlers.?123457689:;?576243;:198None &>? )<hoppy-generator , where  is the given name, and  is rendered by giving maybeParamNames and t to .This function is useful for generating variable declarations, declarations with assignments, and function prototypes and definitions.hoppy-generatorsayType maybeParamNames t renders t in C++ syntax. If t is a , then maybeParamNames9 will provide variable names for parameters, if present.hoppy-generatorRenders a C++ function.hoppy-generator Returns a  iff there is a C type distinct from the given C++ type that should be used for conversion. This returns Nothing for #. TManual needs special handling.hoppy-generatorReturns the requirements to refer to a type from C++ code. This is a monadic function so that it has access to the environment, but it does not emit any code.hoppy-generatorLooks up the module exporting the given external name in the current interface. - is called if the external name is not found.hoppy-generatorCombines the given exception handlers (from a particular exported entity) with the handlers from the current module and interface. The given handlers have highest precedence, followed by module handlers, followed by interface handlers.hoppy-generatorFunction name.hoppy-generatorParameter names.hoppy-generator Function type. This should use  or .hoppy-generatorIf present, then the function is defined and the action here is used to render its body. If absent, then the function is only declared (no function body).,<=>?@A,A@=>?< None &>?#hoppy-generator A version of 6 that accepts additional information about parameters.hoppy-generator7A function taking parameters and returning a value (or #). Function pointers must wrap a  in a . See also % which accepts parameter information.hoppy-generatorThe name of a function to call.hoppy-generator*A call to the given operator, for example x++, x * y, a[i].hoppy-generatorA call to the function whose name is emitted by the given action.hoppy-generatorNot a function call, but a read from a variable whose name is emitted by the given action.hoppy-generatorNot a function call, but a write to a variable whose name is emitted by the given action.hoppy-generatorThe direction between languages in which a value is being passed.hoppy-generator#Haskell code is calling out to C++.hoppy-generatorC++ is invoking a callback.hoppy-generatorA C++ function declaration.Use this data type's  instance to make the function accessible. You do not need to add requirements for parameter or return types.hoppy-generator)The identifier used to call the function.hoppy-generatorThe function's external name.hoppy-generatorWhether the function is pure.hoppy-generatorThe function's parameters.hoppy-generatorThe function's return type.hoppy-generator2Requirements for bindings to access this function.hoppy-generator)Exceptions that the function might throw.hoppy-generatorThe function's addendum.hoppy-generator%Creates a binding for a C++ function.hoppy-generatorGenerates a C++ wrapper function for calling a C++ function (or method, or reading from or writing to a variable). The generated function handles C++-side marshalling of values and propagating exceptions as requested. See also .hoppy-generatorGenerates code to marshal a value between a C++ type and the intermediate type to be used over the FFI. If dir is , then we are a C++ function reading an argument from foreign code. If dir is +, then we are invoking a foreign callback.hoppy-generatorPrints a comma-separated list of the argument names used for C++ gateway functions. The number specifies how many names to print.hoppy-generatorGenerates a Haskell wrapper function for calling a C++ function (or method, or reading from or writing to a variable, as with ). The generated function handles Haskell-side marshalling of values and propagating exceptions as requested.hoppy-generatorGenerates Haskell code to perform marshalling of a function's argument in a specified direction.This function either generates a line or lines such that subsequent lines can refer to the output binding. The final line is either terminated with ... $ \value ->or  let ... in#so that precedence is not an issue.hoppy-generatorNote that the  is the direction of the call, not the direction of the return. 1 means we're returning to the foreign language,  means we're returning from it.hoppy-generatorAn optional external name; will be automatically derived from the identifier if absent.hoppy-generatorParameter types.hoppy-generator Return type.hoppy-generator"The external name of the function.hoppy-generator2The C++ name at which the function can be invoked.hoppy-generatorIf present, then we are wrapping a method within some class, and the type is that of the class.hoppy-generator%Info about the function's parameters.hoppy-generatorThe function's return type.hoppy-generatorException handlers configured on the function itself. No need to call  to combine the function's handlers with those from the module and interface; this function does that already.hoppy-generatorWhether to generate the function definition. If false, only the declaration is generated (no function body).hoppy-generatorThe phase of code generation.hoppy-generatorThe external name for the entity we're generating. For class entities, this will include the class's external name as a prefix.hoppy-generatorAn alternate external name to use to generate Haskell function names. For non-class entities, this can be just the regular external name. For class entities, in order to strip off the class name that was added so that the entity's external name is unique, this can just be the name of the function, variable, etc.hoppy-generator;Whether or not the function is pure (free of side effects).hoppy-generatorParameter info.hoppy-generatorThe return type.hoppy-generatorAny exception handlers to apply to the binding, in addition to what its module and interface provide.hoppy-generatorThe direction of the FFI call.hoppy-generator'The type of the value to be marshalled.hoppy-generator0The name of the binding holding the input value.hoppy-generator7The name of the binding to create for the output value.None >?mBhoppy-generatorControls how conversions between C++ objects and Haskell values happen in Haskell bindings.Dhoppy-generatorProduces the Haskell type that represents a value of the corresponding C++ class. This generator may add imports, but must not output code or add exports.Ehoppy-generatorProduces a Haskell expression that evaluates to a function that takes an value of the type that D generates, and returns a non-const handle for a new C++ object in IO. The generator must output code and may add imports, but must not add exports.If this field is present, then D must also be present.Fhoppy-generatorProduces a Haskell expression that evaluates to a function that takes a const handle for a C++ object, and returns a value of the type that D generates, in IO. It should not delete the handle. The generator must output code and may add imports, but must not add exports.If this field is present, then D must also be present.Ghoppy-generatorSeparately from passing object handles between C++ and foreign languages, objects can also be made to implicitly convert to native values in foreign languages. A single such type may be associated with any C++ class for each foreign language. The foreign type and the conversion process in each direction are specified using this object. Converting a C++ object to a foreign value is also called decoding, and vice versa is called encoding. A class may be convertible in one direction and not the other.To use these implicit conversions, instead of specifying an object handle type such as  .  or  . , use  directly.The subfields in this object specify how to do conversions between C++ and foreign languages.Ihoppy-generator Conversions to and from Haskell.Jhoppy-generatorA C++ class declaration. See  for more information about the interaction between a class's names and the names of entities within the class.Use this data type's  instance to make the class accessible. You do not need to add requirements for methods' parameter or return types.Khoppy-generatorThe name of a data constructor for one of the object pointer types.Lhoppy-generatorThe name of the data type that represents a pointer to an object of the given class and constness.Mhoppy-generatorThe name of the function that upcasts pointers to the specific class type and constness.Nhoppy-generatorThe name for the typeclass of types that are (possibly const) pointers to objects of the given C++ class, or subclasses.Ohoppy-generator"The name of the method within the P= typeclass for accessing an object of the type as a pointer.Phoppy-generatorThe name for the typeclass of types that can be represented as values of the given C++ class.Qhoppy-generator?s[ hoppy-generatorA C++ variable.Use this data type's * instance to make the variable accessible.hoppy-generator-The identifier used to refer to the variable.hoppy-generatorThe variable's external name.hoppy-generator#The variable's type. This may be  N- to indicate that the variable is read-only.hoppy-generator2Requirements for bindings to access this variable.hoppy-generatorThe variable's addendum.hoppy-generator%Creates a binding for a C++ variable.hoppy-generatorReturns whether the variable is constant, i.e. whether its type is  N ....hoppy-generatorReturns the external name of the getter function for the variable.hoppy-generatorReturns the external name of the setter function for the variable.  ONone >?vdhoppy-generatorModifies a class's G structure by setting all languages to copy objects to the heap when being passed out of C++. Lifetimes of the resulting objects must be managed by code in the foreign language.Calling this on a class makes  behave like % for values being passed out of C++.hoppy-generatorModifies a class's G structure by setting all languages that support garbage collection to copy objects to the heap when being passed out of C++, and put those objects under the care of the foreign language's garbage collector.Calling this on a class makes  behave like % for values being passed out of C++.None >?y_hoppy-generator=Sets of functionality that can be stamped onto a class with .hoppy-generator"Provides the assignment operator, Foo& Foo::operator=(const Foo&).hoppy-generatorProvides operators <, <=, >, >=, for example  bool Foo::operator<(const Foo&)0. This feature does not automatically include .hoppy-generatorProvides copy construction, Foo::Foo(const Foo&).hoppy-generator Provides  operator== and  operator!=, for example !bool Foo::operator==(const Foo&).hoppy-generatorAdds the contents of a feature to a class. Does not check for overlap with existing class contents.None >?hoppy-generatorA non-C++ function that can be invoked via a C++ functor or function pointer.Use this data type's  instance to add extra requirements, however manually adding requirements for parameter and return types is not necessary.hoppy-generator'Constructs a type value for a callback.hoppy-generatorThe callback's external name.hoppy-generatorThe callback's parameters.hoppy-generatorThe callback's return type.hoppy-generatorWhether the callback supports throwing C++ exceptions from Haskell into C++ during its execution. When absent, the value is inherited from  and .hoppy-generator$Extra requirements for the callback.hoppy-generatorThe callback's addendum.hoppy-generator?Creates a binding for constructing callbacks into foreign code.hoppy-generatorSets whether a callback supports handling thrown C++ exceptions and passing them into C++.hoppy-generatorReturns the name of the outer, copyable C++ class for a callback.hoppy-generatorReturns the name of the internal, non-copyable implementation C++ class for a callback.hoppy-generatorReturns the name of the C++ binding function that creates a C++ callback wrapper object from a function pointer to foreign code.hoppy-generatorThe name of the function that takes a Haskell function and wraps it in a callback object. This is internal to the binding; normal users can pass Haskell functions to be used as callbacks inplicitly.hoppy-generatorPure version of ' that doesn't create a qualified name.hoppy-generatorThe name of the function that takes a Haskell function with Haskell-side types and wraps it in a LM= that does appropriate conversions to and from C-side types.hoppy-generatorPure version of ' that doesn't create a qualified name.hoppy-generatorConstructs the function type for a callback. A callback that throws has additional parameters.Keep this in sync with .hoppy-generatorConstructs the function type for a callback. For Haskell, the type depends on the side; the C++ side has additional parameters.Keep this in sync with .hoppy-generatorParameter types.hoppy-generator Return type. Safe-Inferred >?hoppy-generatorSplits a C++ identifier string into multiple words, doing smart inspection of the case convention of the string. This supports  snake_case and  CONSTANT_CASE, and recognition of  camelCase+, including when acronyms are uppercased ( "HTMLElement" gives ["HTML", "Element"]). Numbers are treated as their own words, and non-alphanumeric characters are treated as word separators and dropped.hoppy-generatorCreates a temporary file whose name is based on the given template string, and runs the given function with the path to the file. The file is deleted when the function completes, if the boolean that the function returns (or, in case of an exception, the boolean that was passed directly to  ) is true.hoppy-generatorCreates a temporary directory whose name is based on the given template string, and runs the given function with the directory's path. The directory is deleted when the function completes, if the boolean that the function returns (or, in case of an exception, the boolean that was passed directly to  ) is true. None >?yhoppy-generatorA C++ enum declaration.See P.hoppy-generator$Constructs a type value for an enum.hoppy-generatorValues that can be used as a name for an enum's unknown value entry. See .hoppy-generatorConverts a value to a list of words to use for an enum's unknown entry name.hoppy-generatorRepresents a mapping to an automatically evaluated C++ enum entry.The (p , String)& instance is the canonical one, with  defined as id. The string on the right is the C++ name of the entry, and the list of strings on the left are the words from which to generate foreign bindings' entry names.The String instance takes the C++ name of the entry, and splits it into words via .hoppy-generatorThe enum's external name.hoppy-generator)The identifier used to refer to the enum.hoppy-generatorAn optional, explicit numeric type provided for the enum's values, that matches what the C++ compiler uses. Hoppy will use Q to compute this automatically, if not given manually. This does not need to be provided. If absent (default), then Hoppy will calculate the enum's numeric type on its own, using a C++ compiler. If this is present however, Hoppy will use it, and additionally validate it against what the C++ compiler thinks, if validation is enabled (see ).hoppy-generator1The numeric values and names of the enum entires.hoppy-generatorRequirements for bindings to access this enum. Currently unused, but will be in the future.hoppy-generatorThe enum's addendum.hoppy-generator#The prefix applied to value names () when determining the names of values in foreign languages. This defaults to the external name of the enum, plus an underscore.See .hoppy-generator,A name (a list of words, a la the fields in k) for an optional fallback enum "entry" in generated bindings for holding unknown values. See .When this is a Just, then the generated foreign binding gets an extra entry that takes an argument holding an arbitrary numeric value (an extra data constructor in Haskell), and this value is used whenever an unknown value is seen. When this is Nothing-, the enum will not support unknown values.  toCppEnum in the Foreign.Hoppy.Runtime.CppEnum typeclass, as well as calls or returns from C++ that pass a value not defined in the interface, will raise an .Enums that have this set to Nothing should also have  set to false, to avoid potential errors at runtime; see that function's documentation.The > applies to this name, just as it does to other enum entries.hoppy-generatorWhether generated bindings should support bitwise operations on the enum. This defaults to true.;It is not recommended to disable the unknown value entry () while having this be true, because any computation involving enum values not explicitly defined will cause a runtime error. This includes undefined combinations of defined values.hoppy-generator1Sets an explicit numeric type for the enum. See .hoppy-generatorThe default value for  . This is  ["Unknown"].hoppy-generator!Creates a binding for a C++ enum.The numeric values of each of the enum's entries must be specified manually using this function. To have these determined automatically, instead use .hoppy-generator!Creates a binding for a C++ enum.An enum created using this function will determine its entries' numeric values automatically when the generator is run, by compiling a temporary, autogenerated C++ helper program.This helper program needs to be able to access the C++ declaration of the enum. In addition to any  or  requirements added to the enum for the generated C++ bindings to use, the interface's compiler () will need to be able to use these includes to access the enum from C++ file built in a temporary directory. To add -I arguments or otherwise change the compiler, you can reconfigure the interface: myInterface =  (prependArguments ["-I" ++ pathToIncludes] defaultCompiler) $  ... See  Foreign.Hoppy.Generator.Compiler.hoppy-generatorAdds overrides for some of an enum's entry names, in a specific language.hoppy-generatorRetrieves the name for an enum entry in a specific foreign language.hoppy-generatorSets the prefix applied to the names of enum values' identifiers in foreign languages.See .hoppy-generator9Sets the entry name (a list of words, a la the fields in k9) for the fallback enum entry that holds unknown values.Set , .hoppy-generator,Sets an enum to have no unknown value entry.Set , .hoppy-generatorSets whether generated bindings will support bitwise operations on the enum.See .hoppy-generatorReads evaluated data for the named enum from the C++ generator environment.hoppy-generatorReads evaluated data for the named enum from the Haskell generator environment.hoppy-generator%Returns the Haskell name for an enum.6TODO Clarify, and split into type and data ctor names.hoppy-generatorPure version of & that doesn't create a qualified name.hoppy-generatorConstructs the data constructor name for a value in an enum. Like C++ and unlike say Java, Haskell enum values aren't in a separate enum-specific namespace, so we prepend the enum name to the value name to get the data constructor name. The value name is a list of words.hoppy-generatorPure version of & that doesn't create a qualified name.hoppy-generatorhoppy-generatorAn optional external name; will be automatically derived from the identifier if absent.hoppy-generatorA list of (numeric value, symbolic name) pairs describing enum entries to generate bindings for. Each symbolic name is a list of words, which will be combined into a single identifier of appropriate naming style for the target language (title case, for Haskell) with  prepended.hoppy-generatorhoppy-generatorAn optional external name; will be automatically derived from the identifier if absent.hoppy-generatorIs the enum scoped ( enum class or  enum struct)? That is, are its entries scoped underneath its name, rather than being at the same level as its name (as with just enum).hoppy-generatorA list of enum entries to calculate and generate bindings for. See .None >?#(c)*+,-./0BCFDEGHIJTQSRKLMNOPUWVXYZ[]\^_`abdefghijklomnpqrxwvusty|z{}~0/-.+,*)}~yz{|qrstuvwxpklmnohijfgedb(^_`aZ[]\YUVXWcRNone >?hoppy-generatorThe in-memory result of generating Haskell code for an interface.hoppy-generatorA map from paths of generated files to the contents of those files. The file paths are relative paths below the Haskell generation root.hoppy-generator1Runs the C++ code generator against an interface.SNone >?.hoppy-generator=The in-memory result of generating C++ code for an interface.hoppy-generatorA map from paths of generated files to the contents of those files. The file paths are relative paths below the C++ generation root.hoppy-generator1Runs the C++ code generator against an interface.None >?hhoppy-generatorVersions of the C++ standard.hoppy-generator Placeholder 2-like type that may be more general in the future.hoppy-generatorFilters a list of 8 values down to the elements that are actually present.hoppy-generatorA  value that is always absent.hoppy-generator Returns a  value that is always present.hoppy-generator Returns a 3 value that is only present if the boolean is true.hoppy-generatorThe 8 chosen when one is not explicitly requested. This is .hoppy-generator;The active version of the C++ standard. This looks to the  HOPPY_CPP_STD/ environment variable, and accepts the values c++98, c++11, and c++14", which map to the corresponding  values. If a value other than these is set, then a warning is printed and the default is used. If no value is set, the default is used. This uses 8 internally and won't cope with a changing environment.  None >?hoppy-generatorThese hooks can be used to customize the behaviour of a Hoppy generator.hoppy-generatorThe default set of hooks associated with an interface. This sets  to .hoppy-generator8Raw outputs parsed from the output of an enum evaluator.hoppy-generator$The sizeof() for each identifier in -. The lengths of these two lists must match.hoppy-generator)The numeric value for each identifier in -. The lengths of these two lists must match.hoppy-generatorAn entry in an enumeration. This also tracks whether the entry came from a scoped enum, for assertion reasons.hoppy-generator+Whether the entry comes from a scoped enum.hoppy-generator&The identifier referring to the entry.hoppy-generator7Inputs to the process of automatically evaluting enums.hoppy-generator8The interface that enum values are being calculated for.hoppy-generatorAdditional paths to prepend to the C++ include path during compilation.hoppy-generatorRequirements (includes, etc.) needed to reference the enum identifiers being evaluated.hoppy-generator=The list of identifiers that we need to compute sizeof() for.hoppy-generator,The list of entries to calculate values for.hoppy-generatorWhether to leave temporary build inputs and outputs on disk in case the calculation fails. If failure does occur and this is true, then the calculation should print to standard error the location of these files (this is taken care of by the calculateEnumValues* functions here.)hoppy-generatorA function that answers with representation information about an enum (e.g. entries' numeric values) for a given request. On success, it returns the requested data. On failure, it prints a message to standard error and returns Nothing.hoppy-generatorThis hook is invoked once for an interface when the generator needs information about some enums beyond what's been baked into the interface (for example, to compute the enum's numeric type or entry values, see ). This will be called at most once per interface per invocation of the generator.hoppy-generator5Calculates enum values using an interface's compiler.hoppy-generator*Evaluate enums using a specified compiler.hoppy-generator4Constructs the C++ source program to evaluate enums.hoppy-generator1Interprets the output of a program generated by , returning parsed values if successful, and an error string otherwise.hoppy-generatorCollects all of the enum values that need calculating in an interface, runs the hook to evaluate them, and stores the result in the interface. This won't recalculate enum data if it's already been calculated.None >??hoppy-generatorControls the behaviour of a generatior with respect to the enum cache file, when a file path provided (--enum-eval-cache-path).If enum evaluation is required, based on the presence of the cache file and which of these modes is selected, then the compiler will be called and the results will be written to the cache fileIf an enum cache file path is not provided, then this mode is ignored, and enum evaluation is attempted if a generator requires it.Change detection is not currently supported. There is no ability to detect whether the cache file is up to date and contains all of the enum entries for the current state of the enums defined in an interface. The cache file is meant to be refreshed with  when building the C++ binding package, and installed with them so that the Haskell binding package can use .hoppy-generatorThe default. Ignore the presence of an existing cache file, and evaluate enums freshly, updating the cache file with new contents.hoppy-generatorRequire the cache file to exist. If it does not, enum evaluation will not be attempted; the generator will exit unsuccessfully instead.hoppy-generator-Actions that can be requested of the program.hoppy-generatorGenerates C++ wrappers for an interface in the given location.hoppy-generatorGenerates Haskell bindings for an interface in the given location.hoppy-generator,Removes the generated files in C++ bindings.hoppy-generator0Removes the generated files in Haskell bindings.hoppy-generatorInstructs the generator to keep on disk any temporary programs or files created, in case of failure.hoppy-generatorDumps to stdout information about all external names in the current interface.hoppy-generatorDumps to stdout information about all enums in the current interface.hoppy-generator:Specifies the path to a enum evaluation cache file to use.hoppy-generatorSpecifies the behaviour with respect to how the enum evaluation cache cache file is used.hoppy-generatorThis provides a simple main( function for a generator. Define your main as: main = defaultMain $  ...  Refer to 1 for how to use the command-line interface. Use ? if you want to include multiple interfaces in your generator.hoppy-generatorThis is a version of " that accepts multiple interfaces.hoppy-generatorEnsures that all of the entries in a list of results coming from ) are successful, and returns the list of  values. If any results are unsuccessful, then an error message is printed, and the program exits with an error ().hoppy-generatorrun interfaces args7 runs the driver with the command-line arguments from args against the listed interfaces, and returns the list of actions performed.The recognized arguments are listed below. The exact forms shown are required; the --long-arg=value style is not supported.Arguments are processed in the order given, this means that settings must come before action arguments.--help:, Displays a menu listing the valid commands.--list-interfaces:2 Lists the interfaces compiled into the generator.--interface : Sets the interface that will be used for subsequent arguments.--gen-cpp :/ Generates C++ bindings in the given directory.--gen-hs : Generates Haskell bindings under the given top-level source directory."--enum-eval-cache-path : Specifies a cache file to use for the results of enum evaluation. If the cache file already exists, then it may be loaded to save calling the compiler, depending on the cache mode (--enum-eval-cache-mode). Because enum evaluation results are required when generating both the C++ and Haskell interfaces and these are normally separate packages, this allows the C++ package's evaluation work to be shared with the Haskell package.+--enum-eval-cache-mode : Controls the specific behaviour of the generator with respect to the enum evaluation cache file. See .TTUVWXXYZ[[\]^_`abcdefghiQjklmnopqrstuvwxyz{|}~GFFPP                                         ' (  N                      !"H                  I              &                OO#       %          $                      QRRRSSS,hoppy-generator-0.8.0-7O163u3Tc9NCvvDRz4k7r1 Foreign.Hoppy.Generator.CompilerForeign.Hoppy.Generator.Hook Foreign.Hoppy.Generator.OverrideForeign.Hoppy.Generator.Spec(Foreign.Hoppy.Generator.Language.Haskell$Foreign.Hoppy.Generator.Language.Cpp"Foreign.Hoppy.Generator.Spec.Class%Foreign.Hoppy.Generator.Spec.CallbackForeign.Hoppy.Generator.Types!Foreign.Hoppy.Generator.Spec.Enum%Foreign.Hoppy.Generator.Spec.Computed%Foreign.Hoppy.Generator.Spec.Function%Foreign.Hoppy.Generator.Spec.Variable)Foreign.Hoppy.Generator.Spec.ClassFeatureForeign.Hoppy.Generator.UtilForeign.Hoppy.Generator.VersionForeign.Hoppy.Generator.MainForeign.Hoppy.Generator.Common&Foreign.Hoppy.Generator.Common.Consume Interface!Foreign.Hoppy.Generator.Spec.BasesplitIntoWordsCppEnumLanguage.Haskell.SyntaxHsTyVarFunctionCallbackLC SayHeader SaySourceLHSayExportForeignImportsSayExportDecls SayExportBootcallbackThrows makeAutoEnumenumNumericTypeclassMakeException objToHeapTtoGcT Foreign.CCBoolCCharCUCharCWcharCShortCUShortCIntCUIntCLongCULongCLLongCULLongCFloatCDoubleData.IntInt8Int16Int32Int64 Data.WordWord8Word16Word32Word64CPtrdiffCSizeSystem.Posix.TypesCSsizeClassConversion addImportsaddExtNameModulemakeFnForeign.Hoppy.Runtimedelete Foreign.PtrFunPtrconstT'Foreign.Hoppy.Generator.Spec.ConversionEnumInfoHooks1Foreign.Hoppy.Generator.Language.Haskell.Internal-Foreign.Hoppy.Generator.Language.Cpp.InternalCustomCompilerccLabel ccCompileccHeaderSearchPathSimpleCompiler scProgram scArguments SomeCompilerCompilercompileProgramprependIncludePathprependArgumentsappendArgumentsoverrideCompilerFromEnvironmentdefaultCompiler gppCompiler$fCompilerSomeCompiler$fShowSomeCompiler$fCompilerSimpleCompiler$fShowSimpleCompiler$fCompilerCustomCompiler$fShowCustomCompiler defaultHooksMapWithOverrides WithOverridesunoverriddenValueoverriddenValuesplain overriddenplainMapmapWithOverridesinsertMapOverrideaddOverrideMapaddOverrideMapsapplyOverrideMapsoverriddenMapLookup HsImportSet ConstnessIdPart IdentifieridentifierPartsExtName fromExtNameReqsErrorMsg SayExportModeOutputEnv GeneratorManaged Unmanaged prettyPrintsayLnwithErrorContextChunk chunkContentsClassHaskellConversionclassHaskellConversionTypeclassHaskellConversionToCppFnclassHaskellConversionFromCppFnclassHaskellConversionClasstoHsDataCtorNametoHsDataTypeNametoHsCastMethodNametoHsPtrClassNametoHsWithValuePtrNametoHsValueClassNameclassConversion classReqsclassIdentifier classExtName HsImportValHsImportValSomeHsImportValAll HsImportName HsImportSpecsgetHsImportSpecshsImportSource HsImportKeyhsImportModulehsImportQualifiedName HsModuleNamegetHsImportSetMapWithForeignLanguageOverridesWithForeignLanguageOverridesForeignLanguageHaskell EnumValueEnumValueManual EnumValueAuto EnumValueMapenumValueMapNamesenumValueMapForeignNamesenumValueMapValuesEnumEntryWordsenumInfoExtNameenumInfoIdentifierenumInfoNumericType enumInfoReqsenumInfoScopedenumInfoValues HasAddendum getAddendum setAddendummodifyAddendumAddendumaddendumHaskellHandlesExceptionsgetExceptionHandlersmodifyExceptionHandlersExceptionHandlersexceptionHandlersListExceptionHandler CatchClassCatchAll ExceptionIdgetExceptionIdConversionSpecHaskellconversionSpecHaskellHsTypeconversionSpecHaskellHsArgTypeconversionSpecHaskellCTypeconversionSpecHaskellToCppFnconversionSpecHaskellFromCppFnConversionSpecCppconversionSpecCppNameconversionSpecCppReqsconversionSpecCppConversionType$conversionSpecCppConversionToCppExpr&conversionSpecCppConversionFromCppExprConversionSpecconversionSpecNameconversionSpecCppconversionSpecHaskellConversionMethodConversionUnsupportedBinaryCompatibleCustomConversion IsParameter toParameter Parameter parameterType parameterNamePurityNonpurePureNonconstConstScopedUnscopedTypeInternal_TVoid Internal_TPtr Internal_TRef Internal_TFn Internal_TObjInternal_TObjToHeapInternal_TToGcInternal_TManualInternal_TConstExport ExportabletoExport castExport sayExportCppsayExportHaskellgetExportEnumInfogetExportExceptionClass idPartBase idPartArgs OperatorTypeUnaryPrefixOperatorUnaryPostfixOperatorBinaryOperator CallOperator ArrayOperatorOperatorOpCallOpCommaOpAssignOpArrayOpDeref OpAddressOpAdd OpAddAssign OpSubtractOpSubtractAssign OpMultiplyOpMultiplyAssignOpDivideOpDivideAssignOpModuloOpModuloAssignOpPlusOpMinusOpIncPre OpIncPostOpDecPre OpDecPostOpEqOpNeOpLtOpLeOpGtOpGeOpNotOpAndOpOrOpBitNotOpBitAndOpBitAndAssignOpBitOr OpBitOrAssignOpBitXorOpBitXorAssignOpShl OpShlAssignOpShr OpShrAssignIsFnNametoFnNameFnNameFnOp HasExtNamesgetPrimaryExtNamegetNestedExtNamesHasReqsgetReqssetReqs modifyReqs reqsIncludesModule moduleName moduleHppPath moduleCppPath moduleExports moduleReqsmoduleHaskellNamemoduleExceptionHandlersmoduleCallbacksThrowmoduleAddendumIncludeincludeToStringInterfaceOptions!interfaceOptionsExceptionHandlers interfaceNameinterfaceModulesinterfaceNamesToModules!interfaceHaskellModuleImportNamesinterfaceExceptionHandlersinterfaceCallbacksThrowinterfaceExceptionSupportModuleinterfaceSharedPtrinterfaceCompilerinterfaceHooksinterfaceValidateEnumTypesdefaultInterfaceOptions interface interface'interfaceHaskellModuleBase!interfaceDefaultHaskellModuleBaseinterfaceAddHaskellModuleBaseinterfaceExceptionClassIdinterfaceAllExceptionClassesinterfaceSetCallbacksThrow"interfaceSetExceptionSupportModuleinterfaceSetSharedPtrinterfaceSetCompilerinterfaceSetCompiler'interfaceSetNoCompilerinterfaceSetValidateEnumTypesinterfaceModifyHooks includeStd includeLocal makeModule moduleModify moduleModify'moduleSetHppPathmoduleSetCppPathmoduleAddExportsmoduleAddHaskellNamemoduleSetCallbacksThrow reqIncludeaddReqsaddReqIncludes toExtNameisValidExtNameextNameOrIdentifierextNameOrFnIdentifierextNameOrStringgetAllExtNamesoperatorPreferredExtNameoperatorPreferredExtName' operatorTypemakeIdentifier makeIdPartidentident'ident1ident2ident3ident4ident5identTidentT'ident1Tident2Tident3Tident4Tident5T normalizeType stripConst stripToGcisScoped constNegateonParameterTypenp toParameters~:makeConversionSpecmakeConversionSpecCppmakeConversionSpecHaskellexceptionCatchAllIdhandleExceptionsaddAddendumHaskellmakeHsImportSethsImportSetMakeSourcehsWholeModuleImporthsQualifiedImport hsImport1 hsImport1' hsImports hsImports'hsImportForBitshsImportForExceptionhsImportForInthsImportForWordhsImportForForeignhsImportForForeignChsImportForMaphsImportForPreludehsImportForRuntimehsImportForSystemPosixTypeshsImportForUnsafeIO objToHeapTWrongDirectionErrorMsgtToGcInvalidFormErrorMessagetoGcTWrongDirectionErrorMsg callbackTenumTfnT'fnTvoidTboolTboolT'charTucharTwcharTshortTushortTintTintT'uintTlongTulongTllongTullongTfloatTfloatT'doubleTdoubleT'int8Tint16Tint32Tint64Tword8Tword16Tword32Tword64TptrdiffTsizeTssizeTmakeNumericTypeconvertByCoercingIntegralconvertByCoercingFloatingptrTrefTobjTmanualTNumericTypeInfonumTypenumBytes numMinBound numMaxBoundEvaluatedEnumValueMapEvaluatedEnumDataevaluatedEnumNumericTypeevaluatedEnumValueMapComputedInterfaceDatacomputedInterfaceNameevaluatedEnumMapgetEvaluatedEnumDatafindNumericTypeInfopickNumericType$fReadNumericTypeInfo$fShowNumericTypeInfo$fReadEvaluatedEnumData$fShowEvaluatedEnumData HsTypeSideHsCSideHsHsSideHsExport outputExports outputImports outputBodyoutputExtensionsPartialpartialModuleHsName partialOutput envInterfaceenvComputedInterfaceData envModule envModuleName getModuleName toModuleName askInterfaceaskComputedInterfaceData askModule askModuleNamegetModuleForExtName runGenerator evalGenerator execGenerator renderPartial inFunction addExport addExport' addExports addExtensionsaysLnlnindent indentSpacessayLetgetExtNameModule toHsTypeName toHsTypeName' toHsFnName toHsFnName' toArgNamecppTypeToHsTypeAndUsegetClassHaskellConversiongetEffectiveExceptionHandlers$fMonoidOutput$fSemigroupOutput $fOrdPartial $fEqPartial$fEqHsTypeSide$fShowHsTypeSide$fEqSayExportMode$fShowSayExportMode$fBoundedManaged $fEnumManaged $fEqManaged $fOrdManaged chunkIncludes addIncludes addIncludeaddReqsMabort makeCppNameexternalNameToCpp toArgNameAltexceptionIdArgNameexceptionPtrArgNameexceptionVarNameexceptionRethrowFnName codeChunk includesChunkrunChunkWriterevalChunkWriterexecChunkWriterrunChunkWriterTevalChunkWriterTexecChunkWriterTsaysays sayIdentifierrenderIdentifiersayVarsayType sayFunction typeToCTypetypeReqsfindExportModule CppCallTypeCallOpCallFnVarReadVarWrite CallDirectionToCppFromCppfnCName fnExtNamefnPurityfnParamsfnReturnfnReqsfnExceptionHandlers fnAddendumsayCppExportFn sayCppArgReadsayCppArgNames sayHsExportFnsayHsArgProcessingsayHsCallAndProcessReturn$fHandlesExceptionsFunction$fHasAddendumFunction$fHasReqsFunction$fHasExtNamesFunction$fExportableFunction$fShowFunction $fEqFunction$fShowCallDirectionProp Staticness NonstaticStaticMethodApplicabilityMNormalMStaticMConst MethodImpl RealMethodFnMethodMethod methodImpl methodExtNamemethodApplicability methodPurity methodParams methodReturnmethodExceptionHandlersCtor ctorExtName ctorParamsctorExceptionHandlers ClassVariable ClassEntityCEVarCECtorCEMethodCEProp IsClassEntityclassEntityExtNameSuffixclassSuperclasses classEntitiesclassDtorIsPublic classAddendumclassIsMonomorphicSuperclassclassIsSubclassOfMonomorphicclassIsExceptionclassEntityPrefix makeClassclassSetEntityPrefixclassAddEntitiesclassVariables classCtors classMethodsclassSetDtorPrivateclassSetMonomorphicSuperclassclassSetSubclassOfMonomorphicclassConversionNoneclassModifyConversionclassSetConversionclassSetHaskellConversionclassEntityExtNameclassEntityForeignNameclassEntityForeignName'classEntityExtNamesmakeClassVariablemakeClassVariable_mkClassVariablemkClassVariable_mkStaticClassVariablemkStaticClassVariable_makeCtor makeCtor_mkCtormkCtor_classFindCopyCtor methodConst methodStatic makeMethod makeMethod_ makeFnMethod makeFnMethod_mkMethod mkMethod_ mkMethod' mkMethod'_ mkConstMethodmkConstMethod_mkConstMethod'mkConstMethod'_mkStaticMethodmkStaticMethod_mkStaticMethod'mkStaticMethod'_mkPropmkProp_ mkStaticProp mkStaticProp_ mkBoolIsProp mkBoolIsProp_ mkBoolHasPropmkBoolHasProp_toHsValueClassName'toHsWithValuePtrName'toHsPtrClassName'toHsCastMethodName'toHsDownCastClassNametoHsDownCastClassName'toHsDownCastMethodNametoHsDownCastMethodName'toHsCastPrimitiveNametoHsCastPrimitiveName'toHsConstCastFnNametoHsConstCastFnName'toHsDataTypeName'toHsDataCtorName'toHsClassDeleteFnName'toHsClassDeleteFnPtrName' toHsCtorName toHsCtorName'toHsMethodNametoHsMethodName'toHsClassEntityNametoHsClassEntityName'sayCppExportVarsayHsExportVar$fIsClassEntityCtor$fHandlesExceptionsCtor $fShowCtor$fIsClassEntityMethod$fHandlesExceptionsMethod $fShowMethod$fIsClassEntityClassVariable$fShowClassVariable$fHasAddendumClass$fHasReqsClass$fHasExtNamesClass$fExportableClass $fShowClass $fOrdClass $fEqClass$fBoundedStaticness$fEnumStaticness$fEqStaticness$fShowStaticness$fBoundedMethodApplicability$fEnumMethodApplicability$fEqMethodApplicability$fShowMethodApplicability$fEqMethodImpl$fShowMethodImplVariable varIdentifier varExtNamevarTypevarReqs varAddendum makeVariable varIsConstvarGetterExtNamevarSetterExtName$fHasAddendumVariable$fHasReqsVariable$fHasExtNamesVariable$fExportableVariable$fShowVariable $fEqVariableclassSetConversionToHeapclassSetConversionToGc ClassFeature Assignable ComparableCopyable EquatableclassAddFeatures$fEqClassFeature$fShowClassFeaturecallbackExtNamecallbackParamscallbackReturn callbackReqscallbackAddendum makeCallbackcallbackSetThrowscallbackClassNamecallbackImplClassNamecallbackFnNametoHsCallbackCtorNametoHsCallbackCtorName'toHsCallbackNewFunPtrFnNametoHsCallbackNewFunPtrFnName'cppCallbackToTFnhsCallbackToTFn$fHasAddendumCallback$fHasReqsCallback$fHasExtNamesCallback$fExportableCallback$fShowCallback $fEqCallback withTempFilewithTempDirectoryIsEnumUnknownValueEntrytoEnumUnknownValueEntryIsAutoEnumValuetoAutoEnumValue enumExtNameenumIdentifier enumValuesenumReqs enumAddendumenumValuePrefixenumUnknownValueEntryenumHasBitOperationsenumSetNumericTypeenumUnknownValueEntryDefaultmakeEnumenumAddEntryNameOverridesenumGetOverriddenEntryNameenumSetValuePrefixenumSetUnknownValueEntryenumSetNoUnknownValueEntryenumSetHasBitOperationscppGetEvaluatedEnumDatahsGetEvaluatedEnumDatatoHsEnumTypeNametoHsEnumTypeName'toHsEnumCtorNametoHsEnumCtorName'$fHasAddendumCppEnum$fHasReqsCppEnum$fHasExtNamesCppEnum$fExportableCppEnum $fShowCppEnum $fEqCppEnum$fIsAutoEnumValue[]$fIsAutoEnumValue(,)$fIsEnumUnknownValueEntry[]$fIsEnumUnknownValueEntry[]0 CppVersionCpp1998Cpp2011Cpp2014FilteredcollectnonejusttestdefaultCppVersionactiveCppVersion$fBoundedCppVersion$fEnumCppVersion$fEqCppVersion$fOrdCppVersion$fShowCppVersionEnumEvaluatorResultenumEvaluatorResultSizesenumEvaluatorResultValuesEnumEvaluatorEntryenumEvaluatorEntryScopedenumEvaluatorEntryIdentifierEnumEvaluatorArgsenumEvaluatorArgsInterface%enumEvaluatorArgsPrependedIncludeDirsenumEvaluatorArgsReqs"enumEvaluatorArgsSizeofIdentifiersenumEvaluatorArgsEntries%enumEvaluatorArgsKeepOutputsOnFailure EnumEvaluatorhookEvaluateEnums evaluateEnumsWithDefaultCompilerevaluateEnumsWithCompilermakeCppSourceToEvaluateEnumsinterpretOutputToEvaluateEnums!internalEvaluateEnumsForInterface$fOrdOrdIdentifier$fOrdEnumEvaluatorEntry$fEqOrdIdentifier$fShowOrdIdentifier$fShowEnumEvaluatorResult$fEqEnumEvaluatorEntryEnumEvalCacheModeRefreshEnumCacheEnumCacheMustExistActionSelectInterfaceListInterfaces ListCppFiles ListHsFilesGenCpp GenHaskellCleanCppCleanHsKeepTempOutputsOnFailure DumpExtNames DumpEnumsEnumEvalCachePath defaultMain defaultMain'ensureInterfacesrun filterMaybe fromMaybeM fromEitherM maybeFail whileJust_forbutLast listSubst listSubst' doubleQuotestrInterpolatezipWithM capitalize lowerFirst upperFirst pluralizewriteFileIfDifferentConsumeT MonadConsumenext runConsumeT evalConsumeT execConsumeTConsume runConsume evalConsume execConsumebaseGHC.Showshow GHC.IO.UnsafeunsafePerformIOghc-prim GHC.ClassesOrdGHC.BaseMonoidmemptymappend GHC.MaybeNothingJustcontainers-0.6.2.1Data.Map.Internalempty*haskell-src-1.0.3.1-LmqBH3mTpZfC1NFS0mBeCxHsName GHC.TypesIO Data.Typeablecast Data.OldList intercalateGHC.ErrerrorBoolIntFloatDoubleGHC.Real realToFrac mtl-2.2.2Control.Monad.Error.Class throwErrorLanguage.Haskell.PrettyHsType combineChunks GenerationgeneratedFilesgenerateMaybe System.Exit exitFailure