!X~jP      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{| } ~                                                                   ! " # $ % & ' ( ) * + ,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~                                                                !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOSafe =>?@ACEX_FOPhoppy-generatorfilterMaybe bad converts a Just bad into a Nothing, returning all other Maybe values as is.Qhoppy-generator !fromMaybeM m x = maybe m return xRhoppy-generator #fromEitherM f x = either f return xShoppy-generator  maybeFail s x = maybe (fail s) xThoppy-generatorwhileJust_ gen act runs act on values generated from gen until gen returns a Nothing.Uhoppy-generator for = flip mapVhoppy-generator0Drops the last item from the list, if non-empty.Whoppy-generatorlistSubst a b xs replaces all x in xs such that x == a with b.Xhoppy-generatorlistSubst' a bs xs replaces all x in xs such that x == a with the sequence of items bs.Yhoppy-generatorRenders a double-quoted string, enclosing the given characters in double quotes and escaping double quotes and backslashes with backslashes.Zhoppy-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 RightV 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-generatoroUpper 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-generatorVAdds 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.PQRSTUVWXYZ[\]^_`Safe =>?@ACEX_Nahoppy-generatorA monad transformer for b.bhoppy-generator<A typeclass for monads that can consume items from a stream.choppy-generatorZAttempts to consume an item from the stream. Returns an item if the stream is not empty.dhoppy-generatorYRuns the consume action, returning the remainder of the stream, and the action's result.ehoppy-generator7Runs the consume action, returning the action's result.fhoppy-generator?Runs the consume action, returning the remainder of the stream. gabcdefhijNone =>?@ACEX_qhoppy-generatorA  C that allows plugging arbitary logic into the compilation process.hoppy-generator(A label to display when the compiler is kn. The string is ""<CustomCompiler " ++ label ++ ">".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.hoppy-generatorZA compiler that can compile a source file into a binary with a single program invocation.UWithin the strings in this data type, including the program path, all occurences of {in} and {out}C are expanded to the input and desired output files, respectively.hoppy-generatorxThe name of the compiler program to call. Lookup is subject to the regular search path rules of your operating system.hoppy-generatorvArguments 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<A compiler that exists on the system for compiling C++ code. hoppy-generator&compileProgram compiler infile outfile invokes the given compiler in the input file, to produce the output file. If the compiler fails or can't be called for whatever reason, then an error message is printed to standard error, and false is returned. hoppy-generator:Adds arguments to the start of a compiler's argument list. hoppy-generator8Adds arguments to the end of a compiler's argument list.hoppy-generator Modifies a  based on environment variables.If CXX7 is set and non-empty, it will override the compiler's .If CXXFLAGSf is set and non-empty, it will be split into words and each word will be prepended as an argument to . Quoting is not supported.hoppy-generator!The default compiler, used by an ) that doesn't specify its own. This is: l $  hoppy-generator!The GNU C++ compiler, invoked as g++ -o {out} {in}.mhoppy-generatorInvokes a program as part of running a compiler. Performs argument interpolation on the program and argument strings. Returns true if the program executes successfully, and false otherwise (logging to stderr).    Safe =>?@ACEX_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 n 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.ohoppy-generator;Extracts a value, possibly overridden based on a parameter.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 .ZIt 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 .ZIt 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 .ZIt 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.ZIt 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 F, with the possibility that the value is overridden by the parameter p.  !"#$%  "#$!%None =>?@ACEMX_&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-generatoriA path to some C++ object, including namespaces. An identifier consists of multiple parts separated by "::"z. Each part has a name string followed by an optional template argument list, where each argument gets rendered from a E (non-type arguments for template metaprogramming are not supported).The p instance inserts a ::\ between joined identifiers. Usually an identifier needs to contain at least one part, so qd 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-generatorbA set of requirements of needed to use an identifier in C++ (function, type, etc.), via a set of s. The monoid instance has q# as an empty set of includes, and r unions two include sets..hoppy-generator*Indicates strings that are error messages.Shoppy-generator!Specifies how a name is imported.Thoppy-generator3The name is imported, and nothing underneath it is.Uhoppy-generatorGThe name is imported, as are specific names underneath it. This is a  X (a, b, c) import.Vhoppy-generatorEThe name is imported, along with all names underneath it. This is a X (..) import.Whoppy-generator{An identifier that can be imported from a module. Symbols may be used here when surrounded by parentheses. Examples are "fmap" and "(++)".Xhoppy-generator9A specification of bindings to import from a module. If s+, then the entire module is imported. If t u$, then only instances are imported.\hoppy-generatoryReferences an occurrence of an import statement, under which bindings can be imported. Only imported specs under equal \s may be merged.`hoppy-generatorA Haskell module name.ahoppy-generatorNReturns the import set's internal map from module names to imported bindings.bhoppy-generator0A map whose values may be overridden based on a d.choppy-generator*A value that may be overridden based on a d.dhoppy-generatorJLanguages that Hoppy supports binding to. Currently this is only Haskell.ehoppy-generatorThe Haskell language.fhoppy-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.ghoppy-generator(A manually specified numeric enum value.hhoppy-generatormA numeric enum value that will be determined when the generator is run, by means of compiling a C++ program.ihoppy-generator$Describes the entries in a C++ enum.'Equality is defined as having the same m.khoppy-generator-The 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.lhoppy-generator+Per-language renames of enum value entries.mhoppy-generator#A map specifying for each entry in k., how to determine the entry's numeric value.nhoppy-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 .ohoppy-generator`Structural information about a C++ enum. This is used when Hoppy is evaluating enum data, see .See  .qhoppy-generatorThe external name of the enum.rhoppy-generatorThe enum's identifier.shoppy-generatorXThe 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  ).thoppy-generator$Requirements for accessing the enum.uhoppy-generator'Whether the enum is scoped or unscoped.vhoppy-generatorThe entries in the enum.whoppy-generator,A typeclass for types that have an addendum.xhoppy-generatorReturns an object's addendum.yhoppy-generator,Replaces and object's addendum with another.zhoppy-generatorModified an object's addendum.{hoppy-generatorqA literal piece of code that will be inserted into a generated source file after the regular binding glue. The p' instance concatenates code (actions).}hoppy-generatorOCode 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-generator^Represents 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-generator@Indicates the ability to handle a certain type of C++ exception.hoppy-generatorSIndicates 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-generatorBContains the numeric values for each of the entries in a C++ enum.hoppy-generatorInformation about the enum that has been completed beyond what the interface definition provides, possibly by building actual C++ code.hoppy-generatorYThe numeric type that C++ uses to hold the enum's values, or an equivalently-sized type.hoppy-generator0Calculated values for all of the enum's entries.hoppy-generator[Controls how conversions between C++ values and Haskell values happen in Haskell bindings.Prefer a) 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 vL 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-generatorFIf 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-generator@This defines how a Haskell value is passed to C++. If this is , then Z 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.RThe generator should output code and may add imports, but should not add exports.hoppy-generatorBThis defines how a Haskell value is passed from C++. If this is , then Z must be present, and the generator should output a function that takes a value of type  and return a value of .RThe generator should output code and may add imports, but should not add exports.hoppy-generatorFor a B, defines the C++ type and conversions to and from a C FFI layer.Prefer `) to using this data constructor directly.r 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 D may define custom code generation for passing values over the FFI.hoppy-generatorFThe name of the C++ type. May identify a primitive C++ type such as "unsigned int", or a more complex type like std::list<std::string>.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 m 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-generatorlThis 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 P. 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-generatorYThe 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-generatorzThe 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-generatorBConversion 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-generatoraAn 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 ww, 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.TypesY for values of this type; these data constructors are subject to change without notice.hoppy-generator@Specifies 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-generatorGAttempts to cast an exportable object to a specific type, pulling off  wrappers as necessary. The default  castExport = x 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  p when it is time to generate Haskell binding code later in the module. Hoppy may also call the function with !, if necessary.See /.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-generatorxIf 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.yhoppy-generatorTypes that contain !s that can be looked up by their +s.zhoppy-generator Looks up the  for an + in the given object.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-generator_A regular, "alphanumeric" name. The exact type depends on what kind of object is being named.hoppy-generatorAn operator name.hoppy-generatornTypes that have an external name, and also optionally have nested entities with external names as well. See D.hoppy-generator@Returns the external name by which a given entity is referenced.hoppy-generatordReturns external names nested within the given entity. Does not include the primary external name.hoppy-generator7Contains the data types for bindings to C++ entities:  , H , 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.MC++ 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. >A, 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-generatorKThe module's name. A module name must identify a unique module within an .hoppy-generatorxA relative path under a C++ sources root to which the generator will write a header file for the module's C++ bindings.hoppy-generatorxA 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 G 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-generatorSee $.hoppy-generator_Short 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-generatorEMaps from external names of exception classes to their exception IDs.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_ptrH class to use, and the requirements to use it. This defaults to using std::shared_ptr from <memory>', but can be changed if necessary via +.hoppy-generatorrThe compiler to use when building code for the interface. This can be overridden or disabled. This defaults to .hoppy-generatoryHooks allowing the interface to execute code at various points during the code generator's execution. This defaults to .hoppy-generatorBEvaluated numeric types and values for all enums in the interface. 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.YThis 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-generatorbThe name of the parent Haskell module under which a Haskell module will be generated for a Hoppy F. 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-generatorQThe default Haskell module under which Hoppy modules will be generated. This is Foreign.Hoppy.Generated , that is: !["Foreign", "Hoppy", "Generated"]&hoppy-generator^Sets 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 "g for all callbacks in an interface that don't have it set explicitly at the module or callback level.*hoppy-generatorRSets 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 <T> can be appended, for example "std::shared_ptr".A  shared_ptr<T> implementation foo0 must at least provide the following interface: Ifoo(); // 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-generatorAReplaces the default compiler used by the interface. When given NothingU, the interface will not be allowed to compile any code when it generates bindings..hoppy-generatorFSets 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-generatorMControls whether the interface will validate manually specified enum types ( #) by compiling a C++ program.See  .0hoppy-generator0Modifies the hooks associated with an interface.1hoppy-generator]Returns the map containing the calculated values for all entries in the enum with the given +(. This requires hooks to have been run.2hoppy-generator Creates an #include <...> directive.3hoppy-generator Creates an #include "..." directive.4hoppy-generator5Creates an empty module, ready to be configured with 5.5hoppy-generatorSExtends a module. To be used with the module state-monad actions in this package.6hoppy-generatorSame as 5 , but calls ~a in the case of failure, which is okay in for a generator which would abort in this case anyway.7hoppy-generatorReplaces a module's .8hoppy-generatorReplaces a module's .9hoppy-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 "B 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 +G that contains the given string, erroring if the string is an invalid +.@hoppy-generator7Returns true if the given string is represents a valid +.Ahoppy-generator Generates an + from an ), if the given name is absent.Bhoppy-generator Generates an + from an  ), if the given name is absent.Choppy-generator Generates an +, from a string, if the given name is absent.Dhoppy-generatorUReturns a list of all of the external names an entity contains. This combines both  and .Ehoppy-generator-Returns a conventional string to use for the + of an operator.Fhoppy-generator6Returns a conventional name for an operator, as with E, but as a string.Ghoppy-generator Returns the type of an operator.hoppy-generatorMetadata for operators. TODO Test out this missing data.Hhoppy-generator+Creates an identifier from a collection of (s, with :: s between.Ihoppy-generator>Creates an object representing one component of an identifier.Jhoppy-generator!Creates a identifier of the form a$, without any namespace operators (::).Khoppy-generator"Creates an identifier of the form a1::a2::...::aN.Lhoppy-generator"Creates an identifier of the form a::b.Mhoppy-generator"Creates an identifier of the form a::b::c.Nhoppy-generator"Creates an identifier of the form  a::b::c::d.Ohoppy-generator"Creates an identifier of the form  a::b::c::d::e.Phoppy-generator"Creates an identifier of the form a::b::c::d::e::f.Qhoppy-generator"Creates an identifier of the form a<...>.Rhoppy-generatorMCreates an identifier with arbitrary many templated and non-templated parts.Shoppy-generator"Creates an identifier of the form  a::b<...>.Thoppy-generator"Creates an identifier of the form  a::b::c<...>.Uhoppy-generator"Creates an identifier of the form a::b::c::d<...>.Vhoppy-generator"Creates an identifier of the form a::b::c::d::e<...>.Whoppy-generator"Creates an identifier of the form a::b::c::d::e::f<...>.Xhoppy-generatorCanonicalizes a 1 without changing its meaning. Multiple nested "s are collapsed into a single one.Yhoppy-generatorStrips leading s off of a type.Zhoppy-generatorReturns true if a . value is scoped, and false if it is unscoped.[hoppy-generator%Returns the opposite constness value.\hoppy-generatorCAn empty parameter list. This should be used instead of a literal []E when declaring an empty parameter list, because in the context of  a => [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 H that can be given as a function or method parameter, instead of a raw P. 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 a1 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.ahoppy-generator Builds a % with the mandatory parameters given.bhoppy-generator4The exception ID that represents the catch-all type.hoppy-generator/The lowest exception ID to be used for classes.choppy-generator3Appends additional exception handlers to an object.dhoppy-generator%Adds a Haskell addendum to an object.ehoppy-generatorConstructor for an import set.fhoppy-generator>Sets all of the import specifications in an import set to be {-SOURCE-} imports.hoppy-generator Combines two X@s into one that imports everything that the two did separately.ghoppy-generator6An import for the entire contents of a Haskell module.hhoppy-generator'A qualified import of a Haskell module.ihoppy-generator1An import of a single name from a Haskell module.jhoppy-generator9A detailed import of a single name from a Haskell module.khoppy-generator2An import of multiple names from a Haskell module.lhoppy-generator:A detailed import of multiple names from a Haskell module.mhoppy-generatorImports  Data.Bits qualified as HoppyDB.nhoppy-generatorImports Control.Exception qualified as HoppyCE.ohoppy-generatorImports Data.Int qualified as HoppyDI.phoppy-generatorImports  Data.Word qualified as HoppyDW.qhoppy-generatorImports Foreign qualified as HoppyF.rhoppy-generatorImports  Foreign.C qualified as HoppyFC.shoppy-generatorImports Data.Map qualified as HoppyDM.thoppy-generatorImports Prelude qualified as HoppyP.uhoppy-generatorImports Foreign.Hoppy.Runtime qualified as HoppyFHR.vhoppy-generatorImports System.Posix.Types qualified as HoppySPT.whoppy-generatorImports System.IO.Unsafe qualified as HoppySIU.xhoppy-generator*Returns an error message indicating that  %? is used where data is going from a foreign language into C++.yhoppy-generator*Returns an error message indicating that  %? is used where data is going from a foreign language into C++.zhoppy-generator*Returns an error message indicating that  &? is used where data is going from a foreign language into C++."hoppy-generatorhoppy-generator#hoppy-generatorhoppy-generator4hoppy-generatorhoppy-generatorhoppy-generator_hoppy-generatorhoppy-generatorahoppy-generatorhoppy-generatorhoppy-generatorhoppy-generator1&a'()*+,-.STVUWXY[Z\]^_`bcdefghijklmnopqrstuvwxyz{|}~      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz^0 None =>?@ACEX_X(hoppy-generatorC++ void , Haskell ().hoppy-generatorC++ bool , Haskell .JC++ 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 '. . See also .hoppy-generatorC++  unsigned int , Haskell '/.hoppy-generatorC++ long int , Haskell '0.hoppy-generatorC++ unsigned long int , Haskell '1.hoppy-generatorC++  long long int , Haskell '2.hoppy-generatorC++ unsigned long long int , Haskell '3.hoppy-generatorC++ float , Haskell  . See also .hoppy-generatorC++ float , Haskell '4 . See also .hoppy-generatorC++ double , Haskell  . See also .hoppy-generatorC++ double , Haskell '5 . See also .hoppy-generatorC++ int8_t , Haskell 67.hoppy-generatorC++ int16_t , Haskell 68.hoppy-generatorC++ int32_t , Haskell 69.hoppy-generatorC++ int64_t , Haskell 6:.hoppy-generatorC++ uint8_t , Haskell ;<.hoppy-generatorC++ uint16_t , Haskell ;=.hoppy-generatorC++ uint32_t , Haskell ;>.hoppy-generatorC++ uint64_t , Haskell ;?.hoppy-generatorC++  ptrdiff_t , Haskell '@.hoppy-generatorC++ size_t , Haskell 'A.hoppy-generatorC++ ssize_t , Haskell BC.hoppy-generator%Builds a new numeric type definition.For convenience,  and . may be used as conversion methods, for both  arguments this function takes.hoppy-generatorMConversion method for passing a numeric values to and from Haskell by using $Foreign.Hoppy.Runtime.coerceIntegral.hoppy-generatorMConversion 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-generatorWAn 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 r that is only allowed when passing objects from C++ to a foreign language. Rather than looking at the object's D, the object will be copied to the heap, and a pointer to the heap object will be passed. The object must be copy-constructable.CThe 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-generator@Constructs 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-generator\Generator 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-generatorUMethod to use to convert a Haskell value to a value to be passed over the FFI. See .hoppy-generatorSMethod to use to convert a value received over the FFI into a Haskell value. See .,|~,|~None =>?@ACEX_U>9/hoppy-generator<The section of code that Hoppy is generating, for an export.0hoppy-generatorTA chunk of generated Haskell code, including information about imports and exports.1hoppy-generator0Context information for generating Haskell code.2hoppy-generator#A generator monad for Haskell code.,Errors thrown in this monad are of the form: 5"$problem; $context; $moreContext; $evenMoreContext."rFor example, "Class Foo is not convertible (use classModifyConversion); generating function bar; in module baz.". The main error message given to  should be capitalized and should not end with punctuation. If there is a suggestion, include it in parentheses at the end of the message. 9 and L add context information, and should be given clauses, without punctuation.3hoppy-generatorJIndicates who is managing the lifetime of an object via an object pointer.4hoppy-generator0The object's lifetime is being managed manually.5hoppy-generatorIThe object's lifetime is being managed by the Haskell garbage collector.6hoppy-generatorPrints a value like , but removes newlines so that they don't cause problems with this module's textual generation. Should be mainly used for printing types; stripping newlines from definitions for example could go badly.7hoppy-generatorOutputs a line of Haskell code. A newline will be added on the end of the input. Newline characters must not be given to this function.8hoppy-generator#Adds imports to the current module.9hoppy-generatorUAdds context information to the end of any error message thrown by the action. See 2.hoppy-generatorThe Haskell side of bindings performs conversions between C FFI types and Haskell types. This denotes which side's type is being used.hoppy-generatorThe C type sent from C++.hoppy-generatorThe Haskell-native type.hoppy-generatorHoppy is generating foreign import< statements for an export. This is separate from the main D phase because foreign import statements are emitted directly by a 20, and these need to appear earlier in the code.hoppy-generatoryHoppy is generating Haskell code to bind to the export. This is the main step of Haskell code generation for an export.6Here, imports of Haskell modules should be added with E rather than emitting an import2 statement yourself in the foreign import step. FK may be used to import and reference the Haskell module of another export.hoppy-generatorIf Hoppy needs to generate hs-boot files to break circular dependences between generated modules, then for each export in each module involved in a cycle, it will call the generator in this mode to produce hs-bootY code. This code should provide a minimal declaration of Haskell entities generated by (, without providing any implementation.)For information on the special format of hs-boot files, see the  https://downloads.haskell.org/~ghc/latest/docs/html/users_guide/separate_compilation.html#how-to-compile-mutually-recursive-modulesGHC User's Guide.hoppy-generatorIIndicates strings that represent an item in a Haskell module export list.hoppy-generatorHaskell module exports. Each  should include one item to go in the export list of the generated module. Should only contain objects imported or defined in the same 0.hoppy-generatorDHaskell module imports. Should include all imports needed for the .hoppy-generatorLines of Haskell code (possibly empty). These lines may not contain the newline character in them. There is an implicit newline between each string, as given by intercalate "\n" . outputBody.hoppy-generator&Language extensions to enable via the {- LANGUAGE -} pragma for the whole module.hoppy-generatorA partially-rendered T. Contains all of the module's bindings, but may be subject to further processing.hoppy-generatorThis is just the module name.hoppy-generator/Returns the complete Haskell module name for a  in an , taking into account the $ and the  .hoppy-generatoroPerforms case conversions on the given string to ensure that it is a valid component of a Haskell module name.hoppy-generator=Renders a set of imports in Haskell syntax on multiple lines.hoppy-generator+Returns the currently generating interface.hoppy-generator(Returns the currently generating module.hoppy-generator>Returns the currently generating module's Haskell module name.hoppy-generator Looks up the K 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-generatorUAdds 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-generatorCOutputs multiple words to form a line of Haskell code (effectively saysLn = sayLn . concat).hoppy-generatorTOutputs an empty line of Haskell code. This is reportedly valid Perl code as well.hoppy-generatorIRuns the given action, indenting all code output by the action one level.hoppy-generatorHRuns the given action, indenting all code output by the action N spaces.hoppy-generatorATakes a list of binding actions and a body action, and outputs a let expression. By passing in s' for the body, it will be omitted, so let statements in do8 blocks can be created as well. Output is of the form: 3let <binding1> ... <bindingN> in <body>KTo stretch a binding over multiple lines, lines past the first should use  manually.hoppy-generatorjLooks up the module that exports an external name. Throws an error if the external name is not exported.hoppy-generator_Returns a module's unique short name that should be used for a qualified import of the module.hoppy-generatorAdds a qualified import of the given external name's module into the current module, and returns the qualified name of the import. If the external name is defined in the current module, then this is a no-op and s is returned.hoppy-generator Used like !addExtNameModule extName hsEntity. hsEntityE is a name in Haskell code that is generated from the definition of extName, and thus lives in extNameo'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-generatorSConverts 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-generatorFReturns a distinct argument variable name for each nonnegative number.hoppy-generator Returns the  corresponding to a  , and also adds imports to the 2) as necessary for Haskell types that the - references. On failure, an error is thrown.hoppy-generator Returns the @ 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.=/0123546789=35402198/76None %=>?@ACEX_+:hoppy-generator<The section of code that Hoppy is generating, for an export.;hoppy-generator1A chunk is a string that contains an arbitrary portion of C++ code, together with a set of includes. The only requirement is that chunk's code boundaries are also C++ token boundaries, because the generator monad automates the process of inserting whitespace between chunk boundaries where necessary.>hoppy-generator,Context information for generating C++ code.?hoppy-generatorA generator monad for C++ code..TODO This should not simply be a type synonym.hoppy-generatorHoppy is generating the C++ source file for a module. The generator should emit C++ definitions that will be imported over foreign language's FFIs. This is the main place for code generation in C++ bindings.hoppy-generatoroHoppy is generating the C++ header file for a module. The generator should emit C++ declarations that can be #included during the source file generation of other exportable entities, in order to refer to the current entity. If it is not possible for other entities to refer to this one, then nothing needs to be generated.hoppy-generatorURuns a generator action and returns its output, or an error message if unsuccessful.hoppy-generatorAdds #includeY statements to the includes block generated at the top of the currently generating file.hoppy-generatorAdds an #includeX statement to the includes block generated at the top of the currently generating file.hoppy-generatorAdds requirements (-a i.e. C++ includes) to the includes block generated at the top of the currently generating file.Have to call this addReqsM, = is taken by .hoppy-generator+Returns the currently generating interface.hoppy-generator(Returns the currently generating module.hoppy-generator5Halts generation and returns the given error message.hoppy-generator@Constructs a C++ identifier by combining a list of strings with __.hoppy-generator@"genpop" is the prefix used for individually exported functions.hoppy-generator;Returns the C++ binding function name for an external name.hoppy-generatorFReturns a distinct argument variable name for each nonnegative number.hoppy-generatorSame as 9, but with distinct names, with with similarity between  toArgName n and toArgNameAlt n.hoppy-generatorRThe C++ variable name to use for the exception ID argument in a gateway function.hoppy-generatorWThe C++ variable name to use for the exception pointer argument in a gateway function.hoppy-generator"The C++ variable name to use in a catch! statement in a gateway function.hoppy-generatorfThe name of the C++ function that receives an exception from a foreign language and throws it in C++.hoppy-generator Builds a ;% that contains the given code string.hoppy-generator Builds a ;" that contains the given includes.hoppy-generatorRuns a ; writer, combining them with  to form a single string.hoppy-generatorRuns a ;& writer and returns the monad's value.hoppy-generatorRuns a ;$ writer and returns the written log.hoppy-generatorRuns a ;) writer transformer, combining them with  to form a single string.hoppy-generatorRuns a ;2 writer transformer and returns the monad's value.hoppy-generatorRuns a ;0 writer transformer and returns the written log.hoppy-generatorFlattens a list of chunks down into a single chunk. Inserts spaces between chunks where the ends of adjacent chunks would otherwise merge into a single C++ token. Combines include sets into a single include set.hoppy-generatorEmits a single ;.hoppy-generatorEmits a ; for each string in a list.hoppy-generator Emits an ).hoppy-generator Renders an ) to a string.hoppy-generatorsayVar name maybeParamNames t, speaks a variable declaration of the form  <type> <name>, where <name> is the given name, and <type> 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-generatorImplementation of Q, deals with recursion, precedence, and the inside-out style of C++ type syntax.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-generatorRLooks 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).+:;<=>?   +?>;<=:   None %=>?@ACEX_ #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 Haskell type of a , as computed by . This combines a  with a list of parameter names. hoppy-generatorThe name of a function to call. hoppy-generator*A call to the given operator, for example x++, x * y, a[i].hoppy-generatorAA call to the function whose name is emitted by the given action.hoppy-generator[Not a function call, but a read from a variable whose name is emitted by the given action.hoppy-generatorZNot a function call, but a write to a variable whose name is emitted by the given action.hoppy-generatorAThe 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 o 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-generatormGenerates code to marshal a value between a C++ type and the intermediate type to be used over the FFI. If dir is I, 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 p). The generated function handles Haskell-side marshalling of values and propagating exceptions as requested."hoppy-generatoraGenerates 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 B 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-generator#Implements special logic on top of , that computes the Haskell  qualified\ type for a function, including typeclass constraints, and bundles it with parameter names.hoppy-generator Renders a U as a Haskell type, ignoring parameter names. This implementation uses haskell-src.hoppy-generator Renders a ; as a Haskell type, including Haddock for parameter names.;Unfortunately, we have to implement this ourselves, because haskell-src doesn't support comments, and haskell-src-exts's comments implementation relies on using specific source spans, and we don't want all that complexity here. So instead we render it ourselves, inserting "{- ^ ... -}" tags where appropriate.hoppy-generatorXAn 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-generator`If 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-generatorHException handlers configured on the function itself. No need to call  o to combine the function's handlers with those from the module and interface; this function does that already.hoppy-generatornWhether 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-generator>An 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-generatorfAny 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.hoppy-generatorTThese should be the effective exception handlers for the function, as returned by  . =, not just the function's exception handlers directly from fnExceptionHandlers.   !"#   !"#None =>?@ACEX_@,@hoppy-generator\Controls how conversions between C++ objects and Haskell values happen in Haskell bindings.Bhoppy-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.Choppy-generatoraProduces a Haskell expression that evaluates to a function that takes an value of the type that B 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 B must also be present.Dhoppy-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 B 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 B must also be present.Ehoppy-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.YTo 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.Ghoppy-generator Conversions to and from Haskell.Hhoppy-generatorA C++ class declaration. See Iq for more information about the interaction between a class's names and the names of entities within the class.Use this data type's u instance to make the class accessible. You do not need to add requirements for methods' parameter or return types.Ihoppy-generatorCThe name of a data constructor for one of the object pointer types.Jhoppy-generatorcThe name of the data type that represents a pointer to an object of the given class and constness.Khoppy-generatorYThe name of the function that upcasts pointers to the specific class type and constness.Lhoppy-generatoryThe name for the typeclass of types that are (possibly const) pointers to objects of the given C++ class, or subclasses.Mhoppy-generator"The name of the method within the N= typeclass for accessing an object of the type as a pointer.Nhoppy-generator^The name for the typeclass of types that can be represented as values of the given C++ class.Ohoppy-generator<Behaviour for converting objects to and from foriegn values.Phoppy-generator/Requirements for bindings to access this class.Qhoppy-generator*The identifier used to refer to the class.Rhoppy-generatorThe class's external name.,hoppy-generator A "property" getter/setter pair.-hoppy-generator"Whether or not a method is static.0hoppy-generatorhHow a method is associated to its class. A method may be static, const, or neither (a regular method).4hoppy-generatorThe C++ code to which a 7 is bound.5hoppy-generatorThe 7$ is bound to an actual class method.6hoppy-generatorThe 7v is bound to a wrapper function. When wrapping a method with another function, this is preferrable to just using a  Y binding because a method will still appear to be part of the class in foreign bindings.7hoppy-generatorA C++ class method declaration.Any operator function that can be written as a method may have its binding be written either as part of the associated class or as a separate entity, independently of how the function is declared in C++.8hoppy-generator+The underlying code that the binding calls.9hoppy-generatorThe method's external name.:hoppy-generator*How the method is associated to its class.;hoppy-generatorWhether the method is pure.<hoppy-generatorThe method's parameters.=hoppy-generatorThe method's return type.>hoppy-generator'Exceptions that the method might throw.?hoppy-generator$A C++ class constructor declaration.@hoppy-generator The constructor's external name.Ahoppy-generatorThe constructor's parameters.Bhoppy-generator*Exceptions that the constructor may throw.Choppy-generatorA C++ member variable.hoppy-generatorThe variable's external name.hoppy-generatorThe variable's C++ name.hoppy-generator#The variable's type. This may be - to indicate that the variable is read-only.hoppy-generatorkWhether the variable is static (i.e. whether it exists once in the class itself and not in each instance).hoppy-generatorWhether the variable should have an accompanying getter. Note this exists only for disabling getters on callback variables - as there is currently no functionality to pass callbacks out of c++Dhoppy-generator%A C++ entity that belongs to a class.Ihoppy-generatorThings that live inside of a class, and have the class's external name prepended to their own in generated code. With an external name of "bar"! and a class with external name "foo", the resulting name will be  "foo_bar".See R and T.Jhoppy-generatorGExtracts the external name of the object, without the class name added.Khoppy-generator The class's public superclasses.Lhoppy-generatorThe class's entities.Mhoppy-generatorThe class's methods.Nhoppy-generatorThe class's addendum.Ohoppy-generator)This is true for classes passed through Z.Phoppy-generator)This is true for classes passed through [.Qhoppy-generator6Whether to support using the class as a C++ exception.Rhoppy-generatorThe prefix applied to the external names of entities (methods, etc.) within this class when determining the names of foreign languages' corresponding bindings. This defaults to the external name of the class, plus an underscore. Changing this allows you to potentially have entities with the same foreign name in separate modules. This may be the empty string, in which case the foreign name will simply be the external name of the entity. This does not affect the things' external names themselves; external names must still be unique in an interface. For instance, a method with external name bar in a class with external name Flab and prefix Flob_& will use the effective external name Flab_bar2, but the generated name in say Haskell would be Flob_bar.See I and T.Shoppy-generator3Creates a binding for a C++ class and its contents.Thoppy-generatorfSets the prefix applied to foreign languages' entities generated from methods, etc. within the class.See I and R.Uhoppy-generatorAdds constructors to a class.Vhoppy-generator%Returns all of the class's variables.Whoppy-generator(Returns all of the class's constructors.Xhoppy-generatorFReturns all of the class's methods, including methods generated from ,s.Yhoppy-generatorTMarks a class's destructor as private, so that a binding for it won't be generated.Zhoppy-generatorExplicitly marks a class as being monomorphic (i.e. not having any virtual methods or destructors). By default, Hoppy assumes that a class that is derived is also polymorphic, but it can happen that this is not the case. Downcasting with  dynamic_cast0 from such classes is not available. See also [.[hoppy-generatorMarks a class as being derived from some monomorphic superclass. This prevents any downcasting to this class. Generally it is better to use Z on the specific superclasses that are monomorphic, but in cases where this is not possible, this function can be applied to the subclass instead.\hoppy-generator\Marks a class as being used as an exception. This makes the class throwable and catchable.]hoppy-generator9Conversion behaviour for a class that is not convertible.^hoppy-generatorModifies a class's E! structure with a given function._hoppy-generatorReplaces a class's E structure.hoppy-generatorMConversion behaviour for a class that is not convertible to or from Haskell.`hoppy-generatorReplaces a class's G with a given value.ahoppy-generatorComputes the external name to use in generated code, containing both the class's and object's external names. This is the concatenation of the class's and entity's external names, separated by an underscore.bhoppy-generatorComputes the name under which a class entity is to be exposed in foreign languages. This is the concatenation of a class's entity prefix, and the external name of the entity.choppy-generatorComputes the name under which a class entity is to be exposed in foreign languages, given a class and an entity's external name. The result is the concatenation of a class's entity prefix, and the external name of the entity.dhoppy-generatorReturns all of the names in a D within the corresponding H.ehoppy-generator Creates a C4 with full generality and manual name specification.The result is wrapped in a E . For an unwrapped value, use f.fhoppy-generatorThe unwrapped version of e.ghoppy-generator Creates a C% for a nonstatic class variable for class::varName whose external name is  class_varName.The result is wrapped in a E . For an unwrapped value, use h.hhoppy-generatorThe unwrapped version of g.ihoppy-generatorSame as g(, but returns a static variable instead.The result is wrapped in a E . For an unwrapped value, use j.jhoppy-generatorThe unwrapped version of i.hoppy-generatorHReturns the external name of the getter function for the class variable.hoppy-generatorGReturns the foreign name of the getter function for the class variable.hoppy-generatorHReturns the external name of the setter function for the class variable.hoppy-generatorGReturns the foreign name of the setter function for the class variable.khoppy-generator Creates a ? with full generality.The result is wrapped in a F . For an unwrapped value, use l.lhoppy-generatorThe unwrapped version of k.mhoppy-generator mkCtor name creates a ? whose external name is className_name.The result is wrapped in a F . For an unwrapped value, use l.nhoppy-generatorThe unwrapped version of m.ohoppy-generator?Searches a class for a copy constructor, returning it if found.phoppy-generator0Returns the constness of a method, based on its :.qhoppy-generator1Returns the staticness of a method, based on its :.rhoppy-generator Creates a 74 with full generality and manual name specification.The result is wrapped in a G . For an unwrapped value, use s.shoppy-generatorThe unwrapped version of r.thoppy-generator Creates a 7< that is in fact backed by a C++ non-member function (a la  G), but appears to be a regular method. This is useful for wrapping a method on the C++ side when its arguments aren't right for binding directly.A this pointer parameter is notP automatically added to the parameter list for non-static methods created with  makeFnMethod.The result is wrapped in a G . For an unwrapped value, use u.uhoppy-generatorThe unwrapped version of t.hoppy-generatorThis function is internal.Creates a method similar to rB, but with automatic naming. The method's external name will be !className ++ "_" ++ cppMethodName. If the method name is a  then the E& will be appeneded to the class name.0For creating multiple bindings to a method, see  makeMethod''.hoppy-generatorThis function is internal.Creates a method similar to  makeMethod', but with an custom string that will be appended to the class name to form the method's external name. This is useful for making multiple bindings to a method, e.g. for overloading and optional arguments.hoppy-generatorThe implementation of  makeMethod' and  makeMethod''.vhoppy-generatorCreates a nonconst, nonstatic 7 for class::methodName and whose external name is class_methodName). If the name is an operator, then the E# will be used in the external name.0For creating multiple bindings to a method, see x.The result is wrapped in a G . For an unwrapped value, use w.whoppy-generatorThe unwrapped version of v.xhoppy-generatorCreates a nonconst, nonstatic 7 for method class::methodName and whose external name is class_methodName. This enables multiple 7s with different foreign names (and hence different external names) to bind to the same method, e.g. to make use of optional arguments or overloading. See v for a simpler form.The result is wrapped in a G . For an unwrapped value, use y.yhoppy-generatorThe unwrapped version of x.zhoppy-generatorSame as v, but returns an 3 method.The result is wrapped in a G . For an unwrapped value, use {.{hoppy-generatorThe unwrapped version of z.|hoppy-generatorSame as x, but returns an 3 method.The result is wrapped in a G . For an unwrapped value, use }.}hoppy-generatorThe unwrapped version of |.~hoppy-generatorSame as v, but returns an 2 method.The result is wrapped in a G . For an unwrapped value, use .hoppy-generatorThe unwrapped version of ~.hoppy-generatorSame as x, but returns an 2 method.The result is wrapped in a G . For an unwrapped value, use .hoppy-generatorThe unwrapped version of .hoppy-generator1Creates a getter/setter binding pair for methods: T foo() const void setFoo(T)The result is wrapped in a H . For an unwrapped value, use .hoppy-generatorThe unwrapped version of .hoppy-generator8Creates a getter/setter binding pair for static methods: *static T foo() const static void setFoo(T)hoppy-generatorThe unwrapped version of .hoppy-generator]Creates a getter/setter binding pair for boolean methods, where the getter is prefixed with is: $bool isFoo() const void setFoo(bool)The result is wrapped in a H . For an unwrapped value, use .hoppy-generatorThe unwrapped version of .hoppy-generator]Creates a getter/setter binding pair for boolean methods, where the getter is prefixed with has: %bool hasFoo() const void setFoo(bool)The result is wrapped in a H . For an unwrapped value, use .hoppy-generatorThe unwrapped version of .hoppy-generator-"gendel" is the prefix used for wrappers for delete calls.hoppy-generatorXReturns the C++ binding function name of the wrapper for the delete method for a class.hoppy-generatorcppCastFnName fromCls toClsK returns the name of the generated C++ function that casts a pointer from fromCls to toCls.hoppy-generatorGenerates a non-const  CppException. instance if the class is an exception class.hoppy-generatorPure version of N& that doesn't create a qualified name.hoppy-generatorPure version of M& that doesn't create a qualified name.hoppy-generatorPure version of L& that doesn't create a qualified name.hoppy-generatorPure version of K& that doesn't create a qualified name.hoppy-generator]The name of the typeclass that provides a method to downcast to a specific class type. See .hoppy-generatorPure version of ' that doesn't create a qualified name.hoppy-generator[The name of the function that downcasts pointers to the specific class type and constness.hoppy-generatorPure version of ' that doesn't create a qualified name.hoppy-generator}The import name for the foreign function that casts between two specific pointer types. Used for upcasting and downcasting.We need to know which module the cast function resides in, and while we could look this up, the caller always knows, so we just have them pass it in.hoppy-generatorPure version of ' that doesn't create a qualified name.hoppy-generator)The name of one of the functions that addremove const to%from a class's pointer type. Given :, it will return the function that adds const, and given 1, it will return the function that removes const.hoppy-generatorPure version of & that doesn't create a qualified name.hoppy-generatorPure version of J& that doesn't create a qualified name.hoppy-generatorPure version of I& that doesn't create a qualified name.hoppy-generator1The name of the foreign function import wrapping deleteZ for the given class type. This is in internal to the binding; normal users should use HI._This is internal to a generated Haskell module, so it does not have a public (qualified) form.hoppy-generatorBThe name of the foreign import that imports the same function as  , but as a JK! rather than an actual function._This is internal to a generated Haskell module, so it does not have a public (qualified) form.hoppy-generatorMReturns the name of the Haskell function that invokes the given constructor.hoppy-generatorPure version of & that doesn't create a qualified name.hoppy-generatorGReturns the name of the Haskell function that invokes the given method.hoppy-generatorPure version of & that doesn't create a qualified name.hoppy-generatorBReturns the name of the Haskell function for an entity in a class.hoppy-generatorPure version of & that doesn't create a qualified name.hoppy-generator%Generates C++ gateway functions (via B) for getting and setting a variable (possibly a class variable).hoppy-generator)Generates Haskell gateway functions (via !B) for getting and setting a variable (possibly a class variable). Shoppy-generatorAn optional external name; will be automatically derived from the identifier if absent by dropping leading namespaces, and taking the last component (sans template arguments).hoppy-generator Superclasses.rhoppy-generatorThe C++ name of the method.hoppy-generator The external name of the method.hoppy-generatorParameter types.hoppy-generator Return type.hoppy-generatorThe C++ name of the method.hoppy-generatorParameter types.hoppy-generator Return type.hoppy-generatorThe C++ name of the method.hoppy-generatorA foreign name for the method.hoppy-generatorParameter types.hoppy-generator Return type.hoppy-generatorThe C++ name of the method.hoppy-generatorA foreign name for the method.hoppy-generatorParameter types.hoppy-generator Return type.vhoppy-generatorThe C++ name of the method.hoppy-generatorParameter types.hoppy-generator Return type.xhoppy-generatorThe C++ name of the method.hoppy-generatorA foreign name for the method.hoppy-generatorParameter types.hoppy-generator Return type.hoppy-generator!The type that the variable holds.hoppy-generatorNothing if the variable is not a class variable. If it is, then the first type is the generated getter's argument type for the object, and the second is the generated setter's argument type. For a class cls, this can be: :Just ('ptrT' $ 'constT' $ 'objT' cls, 'ptrT' $ 'objT' cls)hoppy-generatorWhether to generate a getter. Passing false here is useful when a variable's type can't be sensibly converted to a foreign language's value.hoppy-generator?An external name from which to generate a getter function name.hoppy-generator?An external name from which to generate a setter function name.hoppy-generator-A C++ generator that emits the variable name.hoppy-generatorThe phase of code generation.hoppy-generator!The type that the variable holds.hoppy-generatorUThe type of the class holding the variable, if generating code for a class variable.hoppy-generatorWhether to generate a getter. Passing false here is useful when a variable's type can't be sensibly converted to a foreign language's value.hoppy-generator An external name for the getter.hoppy-generator-A foreign external name for the getter. See !.hoppy-generator An external name for the setter.hoppy-generator-A foreign external name for the setter. See !.@ABCDEFGHQOMRLPOKNPQRIJKLMN,-./01234567>=<;:89?BA@CDEFGHIJSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~HSRQPNKOZP[LUVWXRTMYOQ\DEFGHIJadbcCefghij?klmn@AB70123-./456rstuvwxyz{|}~98:pq;<=>,EFG]^_@ABCD`NMLKJIo None =>?@ACEX_Ps 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  L- 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-generatorDReturns whether the variable is constant, i.e. whether its type is  L ....hoppy-generatorBReturns the external name of the getter function for the variable.hoppy-generatorBReturns the external name of the setter function for the variable.  MNone =>?@ACEX_[Khoppy-generatorModifies a class's E 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 E 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 =>?@ACEX_evhoppy-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-generatoreAdds the contents of a feature to a class. Does not check for overlap with existing class contents.None =>?@ACEX_'{hoppy-generatorNA 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-generator[Sets whether a callback supports handling thrown C++ exceptions and passing them into C++.hoppy-generatorAReturns the name of the outer, copyable C++ class for a callback.hoppy-generatorXReturns 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-generator_Prints "foreign import" statements and an internal callback construction function for a given {1 specification. For example, for a callback of  type Int -> String -> IO Int+, we will generate the following bindings: foreign import ccall "wrapper" name'newFunPtr :: (CInt -> Ptr CChar -> IO CInt) -> IO (FunPtr (CInt -> Ptr CChar -> IO CInt)) -- (This is an ad-hoc generated binding for C++ callback impl class constructor.) foreign import ccall "genpop__name_impl" name'newCallback :: FunPtr (CInt -> Ptr CChar -> IO CInt) -> FunPtr (FunPtr (IO ()) -> IO ()) -> Bool -> IO (CCallback (CInt -> Ptr CChar -> IO CInt)) name_newFunPtr :: (Int -> String -> IO Int) -> IO (FunPtr (CInt -> Ptr CChar -> IO CInt)) name_newFunPtr f'hs = name'newFunPtr $ \excIdPtr excPtrPtr arg1 arg2 -> internalHandleCallbackExceptions excIdPtr excPtrPtr $ coerceIntegral arg1 >>= \arg1' -> (...decode the C string) >>= \arg2' -> fmap coerceIntegral (f'hs arg1' arg2') name_new :: (Int -> String -> IO Int) -> IO (CCallback (CInt -> Ptr CChar -> IO CInt)) name_new f = do f'p <- name_newFunPtr f name'newCallback f'p freeHaskellFunPtrFunPtr Falsehoppy-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-generatorbThe name of the function that takes a Haskell function with Haskell-side types and wraps it in a JK= that does appropriate conversions to and from C-side types.hoppy-generatorPure version of ' that doesn't create a qualified name.hoppy-generator`Constructs 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 =>?@ACEX_ 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"]y). Numbers are treated as their own words, and non-alphanumeric characters are treated as word separators and dropped.hoppy-generator&Creates 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-generator1Creates 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 =>?@ACEX_}hoppy-generatorA C++ enum declaration.See N.~hoppy-generator$Constructs a type value for an enum.hoppy-generatorKValues that can be used as a name for an enum's unknown value entry. See .hoppy-generatorMConverts a value to a list of words to use for an enum's unknown entry name.hoppy-generatorBRepresents a mapping to an automatically evaluated C++ enum entry.The (n , 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 binding's entries.The StringI 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-generator~An optional, explicit numeric type provided for the enum's values, that matches what the C++ compiler uses. Hoppy will use O[ 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-generator'Whether the enum is scoped or unscoped.hoppy-generator1The numeric values and names of the enum entires.hoppy-generator]Requirements 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 ia) 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.CppEnumq 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 X 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-generatorbWhether 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 C++ program.hoppy-generatorIAdds overrides for some of an enum's entry names, in a specific language.hoppy-generatorDRetrieves the name for an enum entry in a specific foreign language.hoppy-generatorWSets 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 i9) for the fallback enum entry that holds unknown values.Set , .hoppy-generator,Sets an enum to have no unknown value entry.Set , .hoppy-generatorMSets whether generated bindings will support bitwise operations on the enum.See .hoppy-generatorKReads evaluated data for the named enum from the C++ generator environment.hoppy-generatorPReads 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-generatorXAn 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-generatorXAn optional external name; will be automatically derived from the identifier if absent.hoppy-generatorIs the enum scoped ( enum class or  enum structy)? That is, are its entries scoped underneath its name, rather than being at the same level as its name (as with just enum).hoppy-generatorEA list of enum entries to calculate and generate bindings for. See .}~   }~   None =>?@ACEX_&a'()*+,-.@ABCDEFGHQPORNKOPLRMQIJKLMNSTVUWXY[Z\]^_`bcdefghijklmnopqrstuvwxyz{|}~      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~   !"#,-./0123456798:;<=>?@ABCDEFGHIJSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~   3.!"#$%&)'*+,-. /023    ; 456789:-<=>+?ABC@,DEFG)H*(IJKLMNOPQRSTUVWXYZ'[]\^_`ab~c{|}wxyzdopqrstuvnijklmfghdecb`&\]^_XY[ZWSTVUghijklf(1eamnopqrstuvwxyzPNone =>?@ACEX_hoppy-generatorAThe 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.hoppy-generator Outputs the  ExceptionDbD needed by all Haskell gateway functions that deal with exceptions.QNone =>?@ACEX_#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.hoppy-generatorOutputs interface-wide code needed to support exceptions. Currently, this comprises the function for rethrowing in C++ an exception transferred from a foreign language.None =>?@ACEX_2hoppy-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 l8 internally and won't cope with a changing environment.   None =>?@ACEX_`hoppy-generatorHThese hooks can be used to customize the behaviour of a Hoppy generator.hoppy-generatorCThe default set of hooks associated with an interface. This sets 7 to 8.hoppy-generator&Bound information about numeric types.&hoppy-generator8Raw outputs parsed from the output of an enum evaluator.(hoppy-generator$The sizeof() for each identifier in 2-. The lengths of these two lists must match.)hoppy-generator)The numeric value for each identifier in 3-. The lengths of these two lists must match.*hoppy-generatorpAn 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.0hoppy-generator8The interface that enum values are being calculated for.1hoppy-generatorXRequirements (includes, etc.) needed to reference the enum identifiers being evaluated.2hoppy-generator=The list of identifiers that we need to compute sizeof() for.3hoppy-generator,The list of entries to calculate values for.4hoppy-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.)5hoppy-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.7hoppy-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 T). This will be called at most once per interface per invocation of the generator.hoppy-generatorAn & without any data in it.8hoppy-generator5Calculates enum values using an interface's compiler.9hoppy-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 :H, 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.hoppy-generatornNumeric types usable to hold enum values. These are ordered by decreasing precedence (increasing word size).hoppy-generatorRSelects the preferred numeric type for holding numeric values in the given range.67&'()*+,-./01234589:;<675./01234*+,-&'()98:;<None =>?@ACEX_} Choppy-generator-Actions that can be requested of the program.Dhoppy-generator<Sets the interface that will be used for subsequent actions.Ehoppy-generator1Lists the interfaces compiled into the generator.Fhoppy-generator*Lists the generated files in C++ bindings.Ghoppy-generator.Lists the generated files in Haskell bindings.Hhoppy-generator>Generates C++ wrappers for an interface in the given location.Ihoppy-generatorBGenerates Haskell bindings for an interface in the given location.Jhoppy-generatoreInstructs the generator to keep on disk any temporary programs or files created, in case of failure.Khoppy-generatorODumps to stdout information about all external names in the current interface.Lhoppy-generatorEDumps to stdout information about all enums in the current interface.Mhoppy-generatorThis provides a simple main( function for a generator. Define your main as: main = defaultMain $ " ...  Refer to O1 for how to use the command-line interface. Use N? if you want to include multiple interfaces in your generator.Nhoppy-generatorThis is a version of M" that accepts multiple interfaces.Ohoppy-generatorrun interfaces args7 runs the driver with the command-line arguments from argsK against the listed interfaces, and returns the list of actions performed.UThe recognized arguments are listed below. The exact forms shown are required; the --long-arg=value style is not supported.--help:, Displays a menu listing the valid commands.--list-interfaces:2 Lists the interfaces compiled into the generator.--interface <iface>:B Sets the interface that will be used for subsequent arguments.--gen-cpp <outdir>:/ Generates C++ bindings in the given directory.--gen-hs <outdir>:J Generates Haskell bindings under the given top-level source directory. CDEFGHIJKLMNO CDEFGHIJKLMNORRSTUUVWXXYZ[\]^_`abcdeOfghijklmnopqrstuvwxyz{|}~E}DDNN      !"#$%&'()*+,-./01123456789:;<=>?@ABCDEFGGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~                                         % &  L !~F      !"#$%&'()*+, - . / 0 1 2 3 4  5 6 7 8 9 : ; < G = > ? @ A B C D E F G H I JKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz${|}~                MM        "        #                 ! " # $ % & ' ( ) * + , - . / 0123456789:;<=>?@AABCDDEFGGHIJKLMONOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~     PPPPQQQQ,hoppy-generator-0.7.0-8Yq0kbklNswJCvYifU3Wvw 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.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 SayExportBootcallbackThrowsenumNumericTypeclassMakeException 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 ccCompileSimpleCompiler scProgram scArguments SomeCompilerCompilercompileProgramprependArgumentsappendArgumentsoverrideCompilerFromEnvironmentdefaultCompiler 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 ExceptionIdgetExceptionIdEvaluatedEnumValueMapEvaluatedEnumDataevaluatedEnumTypeevaluatedEnumValueMapConversionSpecHaskellconversionSpecHaskellHsTypeconversionSpecHaskellHsArgTypeconversionSpecHaskellCTypeconversionSpecHaskellToCppFnconversionSpecHaskellFromCppFnConversionSpecCppconversionSpecCppNameconversionSpecCppReqsconversionSpecCppConversionType$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!interfaceHaskellModuleImportNamesinterfaceExceptionHandlersinterfaceCallbacksThrowinterfaceExceptionSupportModuleinterfaceSharedPtrinterfaceCompilerinterfaceHooksinterfaceEvaluatedEnumDatainterfaceValidateEnumTypesdefaultInterfaceOptions interface interface'interfaceHaskellModuleBase!interfaceDefaultHaskellModuleBaseinterfaceAddHaskellModuleBaseinterfaceExceptionClassIdinterfaceAllExceptionClassesinterfaceSetCallbacksThrow"interfaceSetExceptionSupportModuleinterfaceSetSharedPtrinterfaceSetCompilerinterfaceSetCompiler'interfaceSetNoCompilerinterfaceSetValidateEnumTypesinterfaceModifyHooksinterfaceGetEvaluatedEnumData includeStd includeLocal makeModule moduleModify moduleModify'moduleSetHppPathmoduleSetCppPathmoduleAddExportsmoduleAddHaskellNamemoduleSetCallbacksThrow reqIncludeaddReqsaddReqIncludes toExtNameisValidExtNameextNameOrIdentifierextNameOrFnIdentifierextNameOrStringgetAllExtNamesoperatorPreferredExtNameoperatorPreferredExtName' operatorTypemakeIdentifier makeIdPartidentident'ident1ident2ident3ident4ident5identTidentT'ident1Tident2Tident3Tident4Tident5T normalizeType stripConstisScoped constNegatenp toParameters~:makeConversionSpecmakeConversionSpecCppmakeConversionSpecHaskellexceptionCatchAllIdhandleExceptionsaddAddendumHaskellmakeHsImportSethsImportSetMakeSourcehsWholeModuleImporthsQualifiedImport hsImport1 hsImport1' hsImports hsImports'hsImportForBitshsImportForExceptionhsImportForInthsImportForWordhsImportForForeignhsImportForForeignChsImportForMaphsImportForPreludehsImportForRuntimehsImportForSystemPosixTypeshsImportForUnsafeIO objToHeapTWrongDirectionErrorMsgtToGcInvalidFormErrorMessagetoGcTWrongDirectionErrorMsg callbackTenumTfnT'fnTvoidTboolTboolT'charTucharTwcharTshortTushortTintTintT'uintTlongTulongTllongTullongTfloatTfloatT'doubleTdoubleT'int8Tint16Tint32Tint64Tword8Tword16Tword32Tword64TptrdiffTsizeTssizeTmakeNumericTypeconvertByCoercingIntegralconvertByCoercingFloatingptrTrefTobjTmanualT HsTypeSideHsCSideHsHsSideHsExport outputExports outputImports outputBodyoutputExtensionsPartialpartialModuleHsName partialOutput envInterface envModule envModuleName getModuleName toModuleName askInterface askModule askModuleNamegetModuleForExtName runGenerator evalGenerator execGenerator renderPartial inFunction addExport addExport' addExports addExtensionsaysLnlnindent indentSpacessayLetgetExtNameModule toHsTypeName toHsTypeName' toHsFnName toHsFnName' toArgNamecppTypeToHsTypeAndUsegetClassHaskellConversiongetEffectiveExceptionHandlers$fMonoidOutput$fSemigroupOutput $fOrdPartial $fEqPartial$fBoundedManaged $fEnumManaged $fEqManaged $fOrdManaged$fEqSayExportMode$fShowSayExportMode$fEqHsTypeSide$fShowHsTypeSide 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$fEqMethodImpl$fShowMethodImpl$fBoundedMethodApplicability$fEnumMethodApplicability$fEqMethodApplicability$fShowMethodApplicability$fBoundedStaticness$fEnumStaticness$fEqStaticness$fShowStaticnessVariable 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 enumAddendumenumValuePrefixenumUnknownValueEntryenumHasBitOperationsenumSetNumericTypeenumUnknownValueEntryDefaultmakeEnum makeAutoEnumenumAddEntryNameOverridesenumGetOverriddenEntryNameenumSetValuePrefixenumSetUnknownValueEntryenumSetNoUnknownValueEntryenumSetHasBitOperationscppGetEvaluatedEnumDatahsGetEvaluatedEnumDatatoHsEnumTypeNametoHsEnumTypeName'toHsEnumCtorNametoHsEnumCtorName'$fHasAddendumCppEnum$fHasReqsCppEnum$fHasExtNamesCppEnum$fExportableCppEnum $fShowCppEnum $fEqCppEnum$fIsAutoEnumValue[]$fIsAutoEnumValue(,)$fIsEnumUnknownValueEntry[]$fIsEnumUnknownValueEntry[]0 CppVersionCpp1998Cpp2011Cpp2014FilteredcollectnonejusttestdefaultCppVersionactiveCppVersion$fBoundedCppVersion$fEnumCppVersion$fEqCppVersion$fOrdCppVersion$fShowCppVersionEnumEvaluatorResultenumEvaluatorResultSizesenumEvaluatorResultValuesEnumEvaluatorEntryenumEvaluatorEntryScopedenumEvaluatorEntryIdentifierEnumEvaluatorArgsenumEvaluatorArgsInterfaceenumEvaluatorArgsReqs"enumEvaluatorArgsSizeofIdentifiersenumEvaluatorArgsEntries%enumEvaluatorArgsKeepOutputsOnFailure EnumEvaluatorhookEvaluateEnums evaluateEnumsWithDefaultCompilerevaluateEnumsWithCompilermakeCppSourceToEvaluateEnumsinterpretOutputToEvaluateEnums!internalEvaluateEnumsForInterface$fOrdOrdIdentifier$fOrdEnumEvaluatorEntry$fEqEnumEvaluatorEntry$fShowEnumEvaluatorResult$fEqOrdIdentifier$fShowOrdIdentifierActionSelectInterfaceListInterfaces ListCppFiles ListHsFilesGenCpp GenHaskellKeepTempOutputsOnFailure DumpExtNames DumpEnums defaultMain defaultMain'run filterMaybe fromMaybeM fromEitherM maybeFail whileJust_forbutLast listSubst listSubst' doubleQuotestrInterpolatezipWithM capitalize lowerFirst upperFirst pluralizewriteFileIfDifferentConsumeT MonadConsumenext runConsumeT evalConsumeT execConsumeTConsume runConsume evalConsume execConsumebaseGHC.Showshow GHC.IO.UnsafeunsafePerformIO runProgramghc-prim GHC.ClassesOrd getOverrideGHC.BaseMonoidmemptymappend GHC.MaybeNothingJustcontainers-0.6.0.1Data.Map.Internalempty)haskell-src-1.0.3.0-70Aeu852fgRIkDQ5lS3oFHsName GHC.TypesIO Data.Typeablecast HasExports lookupExportinterfaceHaskellModuleBase'interfaceExceptionNamesToIds Data.OldList intercalateGHC.Errerror operatorInfoexceptionFirstFreeIdmergeImportSpecsBoolIntFloatDoubleGHC.Real realToFrac mtl-2.2.2Control.Monad.Error.Class throwErrorLanguage.Haskell.Pretty renderImportsgetModuleImportNameimportHsModuleForExtNameHsTypeexternalNamePrefix combineChunkssayType'FnHsTypefnToHsTypeAndUse HsQualTyperenderFnHsTyperenderFnHsTypeWithNamesclassVarExtName classVarCName classVarTypeclassVarStaticclassVarGettableclassHaskellConversionNoneclassVarGetterExtNameclassVarGetterForeignNameclassVarSetterExtNameclassVarSetterForeignName makeMethod' makeMethod'' makeMethod'''cppDeleteFnPrefixcppDeleteFnName cppCastFnName sayHsExportClassExceptionSupport sayHsExport enumScoped GenerationgeneratedFilesgeneratesayExceptionSupportMaybeNumericTypeInfoemptyEnumEvaluatorResultnumericTypeInfopickNumericType