!P\*h      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefg Safe;<=>?A]+ hhoppy-generator !fromMaybeM m x = maybe m return xihoppy-generator #fromEitherM f x = either f return xjhoppy-generator  maybeFail s x = maybe (fail s) xkhoppy-generator for = flip maplhoppy-generatorlistSubst a b xs replaces all x in xs such that x == a with b.mhoppy-generator(Zips two lists using a monadic function.nhoppy-generatorIf the file specified does not exist or its contents does not match the given string, then this writes the string to the file.ohoppy-generatoroUpper cases the first character of a string, and lower cases the rest of it. Does nothing to an empty string.phoppy-generator9Lower cases the first character of a string, if nonempty.qhoppy-generator9Upper cases the first character of a string, if nonempty. hijklmnopq Safe;<=>?A]3rhoppy-generatorA monad transformer for s.shoppy-generator<A typeclass for monads that can consume items from a stream.thoppy-generatorZAttempts to consume an item from the stream. Returns an item if the stream is not empty.uhoppy-generatorYRuns the consume action, returning the remainder of the stream, and the action's result.vhoppy-generator7Runs the consume action, returning the action's result.whoppy-generator?Runs the consume action, returning the remainder of the stream.rstuvw None ;<=>?AK]vhoppy-generator!Specifies how a name is imported.hoppy-generator3The name is imported, and nothing underneath it is.hoppy-generatorGThe name is imported, as are specific names underneath it. This is a  X (a, b, c) import.hoppy-generatorEThe name is imported, along with all names underneath it. This is a X (..) import.hoppy-generator{An identifier that can be imported from a module. Symbols may be used here when surrounded by parentheses. Examples are "fmap" and "(++)".hoppy-generator9A specification of bindings to import from a module. If x+, then the entire module is imported. If y z$, 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.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-generatorNReturns the import set's internal map from module names to imported bindings.hoppy-generator,A typeclass for types that have an addendum.hoppy-generatorReturns an object's addendum.hoppy-generator,Replaces and object's addendum with another.hoppy-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 {' 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-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-generatorThe callback's external name.'hoppy-generatorThe callback's parameter types.(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 A "property" getter/setter pair.,hoppy-generator"Whether or not a method is static./hoppy-generator!Whether or not a method is const.2hoppy-generatorhHow a method is associated to its class. A method may be static, const, or neither (a regular method).6hoppy-generatorThe C++ code to which a 9 is bound.7hoppy-generatorThe 9$ is bound to an actual class method.8hoppy-generatorThe 9u is bound to a wrapper function. When wrapping a method with another function, this is preferrable to just using a fZ binding because a method will still appear to be part of the class in foreign bindings.9hoppy-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++.:hoppy-generator+The underlying code that the binding calls.;hoppy-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 parameter types.?hoppy-generatorThe method's return type.@hoppy-generator'Exceptions that the method might throw.Ahoppy-generator$A C++ class constructor declaration.Bhoppy-generator The constructor's external name.Choppy-generator"The constructor's parameter types.Dhoppy-generator*Exceptions that the constructor may throw.Ehoppy-generatorA C++ member variable.Fhoppy-generatorThe variable's C++ name.Ghoppy-generatorThe variable's external name.Hhoppy-generator#The variable's type. This may be  - to indicate that the variable is read-only.Ihoppy-generatorkWhether the variable is static (i.e. whether it exists once in the class itself and not in each instance).Jhoppy-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++Khoppy-generator%A C++ entity that belongs to a class.Phoppy-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 e and K.Qhoppy-generatorGExtracts the external name of the object, without the class name added.Rhoppy-generator\Controls how conversions between C++ objects and Haskell values happen in Haskell bindings.Thoppy-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.Uhoppy-generatoraProduces a Haskell expression that evaluates to a function that takes an value of the type that T 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 T must also be present.Vhoppy-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 T 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 T must also be present.Whoppy-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.Yhoppy-generator Conversions to and from Haskell.Zhoppy-generatorA C++ class declaration. See Pq 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.[hoppy-generator*The identifier used to refer to the class.\hoppy-generatorThe class's external name.]hoppy-generator The class's public superclasses.^hoppy-generatorThe class's entities._hoppy-generatorThe class's methods.`hoppy-generator<Behaviour for converting objects to and from foriegn values.ahoppy-generator/Requirements for bindings to access this class.~hoppy-generatorThe class's addendum.bhoppy-generator)This is true for classes passed through Q.choppy-generator)This is true for classes passed through R.dhoppy-generator6Whether to support using the class as a C++ exception.ehoppy-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 P and K.fhoppy-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.ghoppy-generator)The identifier used to call the function.hhoppy-generatorThe function's external name.ihoppy-generatorWhether the function is pure.jhoppy-generatorThe function's parameter types.khoppy-generatorThe function's return type.lhoppy-generator2Requirements for bindings to access this function.mhoppy-generator)Exceptions that the function might throw.hoppy-generatorThe function's addendum.nhoppy-generator1Whether or not a function may cause side-effects.3Haskell bindings for pure functions will not be in w, 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.ohoppy-generatorSide-affects are possible.phoppy-generatorSide-affects will not happen.qhoppy-generatorDA C++ numeric space with bitwise operations. This is similar to a {`, but in addition to the extra operations, this differs in that these values aren't enumerable.EAdditionally, as a kludge for Qtah, a bitspace may have a C++ type (v#) separate from its numeric type (s?). Qt bitspaces aren't raw numbers but are instead type-safe QFlags objects that don't implicitly convert from integers, so we need a means to do so manually. Barring general ad-hoc argument and return value conversion support, we allow this as follows: when given a C++ type, then a bitspace may also have a conversion function between the numeric and C++ type, in each direction. If a conversion function is present, it will be used for conversions in its respective direction. The C++ type is not a full , but only an 3, since additional information is not needed. See H.rhoppy-generatorThe bitspace's external name.shoppy-generatorVThe C++ type used for bits values. This should be a primitive numeric type, usually .thoppy-generator;The numeric values and names of the bitspace values. See ~.uhoppy-generatorMAn associated enum, whose values may be converted to values in the bitspace.vhoppy-generator%The optional C++ type for a bitspace.whoppy-generator+The name of a C++ function to convert from s to the bitspace's C++ type.xhoppy-generatorGThe name of a C++ function to convert from the bitspace's C++ type to s.yhoppy-generator[Requirements for emitting the bindings for a bitspace, i.e. what's necessary to reference v, x, and w. sd can take some numeric types that require includes as well, but you don't need to list these here.hoppy-generatorThe bitspace's addendum.zhoppy-generator#The prefix applied to value names (t) when determining the names of values in foreign languages. This defaults to the external name of the bitspace, plus an underscore.See F.{hoppy-generator[A C++ enum declaration. An enum should actually be enumerable (in the sense of Haskell's !); if it's not, consider using a q instead.|hoppy-generator)The identifier used to refer to the enum.}hoppy-generatorThe enum's external name.~hoppy-generatorThe numeric values and names of the enum values. A single value's name is broken up into words. How the words and ext name get combined to make a name in a particular foreign language depends on the language.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 D.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  - to indicate that the variable is read-only.hoppy-generator2Requirements for bindings to access this variable.hoppy-generatorThe variable's addendum.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-generatorA single component of an  , between ::s.hoppy-generator$The name within the enclosing scope.hoppy-generatorTemplate arguments, if present.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).hoppy-generator.The separate parts of the identifier, between ::s.hoppy-generator@Specifies some C++ object (function or class) to give access to.hoppy-generatorExports a variable.hoppy-generatorExports an enum.hoppy-generatorExports a bitspace.hoppy-generatorExports a function.hoppy-generator)Exports a class with all of its contents.hoppy-generatorExports a callback.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 *.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-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-generator6Contains the data types for bindings to C++ entities: f, Z , 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-generatorbA set of requirements of needed to use an identifier in C++ (function, type, etc.), via a set of s. The monoid instance has # as an empty set of includes, and  unions two include sets.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-generator*Indicates strings that are error messages.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-generator~Returns 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 S).hoppy-generator5Returns all of the exception classes in an interface.hoppy-generatorChanges )f 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-generator Creates an #include <...> directive.hoppy-generator Creates an #include "..." directive.hoppy-generator5Creates an empty module, ready to be configured with .hoppy-generatorSExtends a module. To be used with the module state-monad actions in this package.hoppy-generatorSame as  , but calls a in the case of failure, which is okay in for a generator which would abort in this case anyway. hoppy-generatorReplaces a module's .!hoppy-generatorReplaces a module's ."hoppy-generatorAdds exports to a module. An export must only be added to any module at most once, and must not be added to multiple modules.#hoppy-generatorChanges a module's > from the default. This can only be called once on a module.$hoppy-generatorChanges )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 .hoppy-generator Generates an  from an , if the given name is absent.hoppy-generator Generates an  from an  , if the given name is absent.hoppy-generator Generates an , from a string, if the given name is absent.*hoppy-generatorUReturns a list of all of the external names an entity contains. This combines both  and .+hoppy-generator-Returns a conventional string to use for the  of an operator.,hoppy-generator6Returns a conventional name for an operator, as with +, but as a string.-hoppy-generator Returns the type of an operator.hoppy-generatorMetadata for operators. TODO Test out this missing data..hoppy-generator Returns the export's addendum.  doesn't have a L instance because you normally wouldn't want to modify the addendum of one./hoppy-generator"Creates an identifier of the form a.0hoppy-generator"Creates an identifier of the form a1::a2::...::aN.1hoppy-generator"Creates an identifier of the form a::b.2hoppy-generator"Creates an identifier of the form a::b::c.3hoppy-generator"Creates an identifier of the form  a::b::c::d.4hoppy-generator"Creates an identifier of the form  a::b::c::d::e.5hoppy-generator"Creates an identifier of the form a::b::c::d::e::f.6hoppy-generator"Creates an identifier of the form a<...>.7hoppy-generatorMCreates an identifier with arbitrary many templated and non-templated parts.8hoppy-generator"Creates an identifier of the form  a::b<...>.9hoppy-generator"Creates an identifier of the form  a::b::c<...>.:hoppy-generator"Creates an identifier of the form a::b::c::d<...>.;hoppy-generator"Creates an identifier of the form a::b::c::d::e<...>.<hoppy-generator"Creates an identifier of the form a::b::c::d::e::f<...>.=hoppy-generatorCanonicalizes a 1 without changing its meaning. Multiple nested "s are collapsed into a single one.>hoppy-generatorStrips leading s off of a type.?hoppy-generator%Creates a binding for a C++ variable.@hoppy-generatorDReturns whether the variable is constant, i.e. whether its type is   ....Ahoppy-generatorBReturns the external name of the getter function for the variable.Bhoppy-generatorBReturns the external name of the setter function for the variable.Choppy-generator!Creates a binding for a C++ enum.Dhoppy-generatorWSets the prefix applied to the names of enum values' identifiers in foreign languages.See .Ehoppy-generator%Creates a binding for a C++ bitspace.Fhoppy-generatorWSets the prefix applied to the names of enum values' identifiers in foreign languages.See .Ghoppy-generator+Associates an enum with the bitspace. See u.Hhoppy-generator@bitspaceAddCppType cppTypeIdentifier toCppValueFn fromCppValueFn associates a C++ type (plus optional conversion functions) with a bitspace. At least one conversion should be specified, otherwise adding the C++ type will mean nothing. You should also add use requirements to the bitspace for all of these arguments; see .Ihoppy-generator%Creates a binding for a C++ function.Jhoppy-generator3Creates a binding for a C++ class and its contents.Khoppy-generatorfSets the prefix applied to foreign languages' entities generated from methods, etc. within the class.See P and e.Lhoppy-generatorAdds constructors to a class.Mhoppy-generator%Returns all of the class's variables.Nhoppy-generator(Returns all of the class's constructors.Ohoppy-generatorFReturns all of the class's methods, including methods generated from +s.Phoppy-generatorTMarks a class's destructor as private, so that a binding for it won't be generated.Qhoppy-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 R.Rhoppy-generatorMarks a class as being derived from some monomorphic superclass. This prevents any downcasting to this class. Generally it is better to use Q on the specific superclasses that are monomorphic, but in cases where this is not possible, this function can be applied to the subclass instead.Shoppy-generator\Marks a class as being used as an exception. This makes the class throwable and catchable.Thoppy-generator9Conversion behaviour for a class that is not convertible.Uhoppy-generatorModifies a class's W! structure with a given function.Vhoppy-generatorReplaces a class's W structure.Whoppy-generatorMConversion behaviour for a class that is not convertible to or from Haskell.Xhoppy-generatorReplaces a class's Y with a given value.Yhoppy-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.Zhoppy-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.[hoppy-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.hoppy-generatorReturns all of the names in a K within the corresponding Z.\hoppy-generator Creates a E4 with full generality and manual name specification.The result is wrapped in a L . For an unwrapped value, use ].]hoppy-generatorThe unwrapped version of \.^hoppy-generator Creates a E% for a nonstatic class variable for class::varName whose external name is  class_varName.The result is wrapped in a L . For an unwrapped value, use _._hoppy-generatorThe unwrapped version of ^.`hoppy-generatorSame as ^(, but returns a static variable instead.The result is wrapped in a L . For an unwrapped value, use a.ahoppy-generatorThe unwrapped version of `.bhoppy-generatorHReturns the external name of the getter function for the class variable.choppy-generatorGReturns the foreign name of the getter function for the class variable.dhoppy-generatorHReturns the external name of the setter function for the class variable.ehoppy-generatorGReturns the foreign name of the setter function for the class variable.fhoppy-generator Creates a A with full generality.The result is wrapped in a M . For an unwrapped value, use g.ghoppy-generatorThe unwrapped version of f.hhoppy-generator mkCtor name creates a A whose external name is className_name.The result is wrapped in a M . For an unwrapped value, use g.ihoppy-generatorThe unwrapped version of h.jhoppy-generator?Searches a class for a copy constructor, returning it if found.khoppy-generator%Returns the opposite constness value.lhoppy-generator0Returns the constness of a method, based on its <.mhoppy-generator1Returns the staticness of a method, based on its <.nhoppy-generator Creates a 94 with full generality and manual name specification.The result is wrapped in a N . For an unwrapped value, use o.ohoppy-generatorThe unwrapped version of n.phoppy-generator Creates a 9< that is in fact backed by a C++ non-member function (a la I), 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 N . For an unwrapped value, use q.qhoppy-generatorThe unwrapped version of p.hoppy-generatorThis function is internal.Creates a method similar to nB, but with automatic naming. The method's external name will be !className ++ "_" ++ cppMethodName. If the method name is a  then the +& will be appeneded to the class name.0For creating multiple bindings to a method, see .hoppy-generatorThis function is internal.Creates a method similar to , 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  and .rhoppy-generatorCreates a nonconst, nonstatic 9 for class::methodName and whose external name is class_methodName). If the name is an operator, then the +# will be used in the external name.0For creating multiple bindings to a method, see t.The result is wrapped in a N . For an unwrapped value, use s.shoppy-generatorThe unwrapped version of r.thoppy-generatorCreates a nonconst, nonstatic 9 for method class::methodName and whose external name is class_methodName. This enables multiple 9s 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 r for a simpler form.The result is wrapped in a N . For an unwrapped value, use u.uhoppy-generatorThe unwrapped version of t.vhoppy-generatorSame as r, but returns an 5 method.The result is wrapped in a N . For an unwrapped value, use w.whoppy-generatorThe unwrapped version of v.xhoppy-generatorSame as t, but returns an 5 method.The result is wrapped in a N . For an unwrapped value, use y.yhoppy-generatorThe unwrapped version of x.zhoppy-generatorSame as r, but returns an 4 method.The result is wrapped in a N . For an unwrapped value, use {.{hoppy-generatorThe unwrapped version of z.|hoppy-generatorSame as t, but returns an 4 method.The result is wrapped in a N . 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 O . 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 O . 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 O . For an unwrapped value, use .hoppy-generatorThe unwrapped version of .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-generator4The exception ID that represents the catch-all type.hoppy-generator/The lowest exception ID to be used for classes.hoppy-generator3Appends additional exception handlers to an object.hoppy-generator%Adds a Haskell addendum to an object.hoppy-generatorConstructor for an import set.hoppy-generator>Sets all of the import specifications in an import set to be {-SOURCE-} imports.hoppy-generator Combines two @s into one that imports everything that the two did separately.hoppy-generator6An import for the entire contents of a Haskell module.hoppy-generator'A qualified import of a Haskell module.hoppy-generator1An import of a single name from a Haskell module.hoppy-generator9A detailed import of a single name from a Haskell module.hoppy-generator2An import of multiple names from a Haskell module.hoppy-generator:A detailed import of multiple names from a Haskell module.hoppy-generatorImports  Data.Bits qualified as HoppyDB.hoppy-generatorImports Control.Exception qualified as HoppyCE.hoppy-generatorImports Data.Int qualified as HoppyDI.hoppy-generatorImports  Data.Word qualified as HoppyDW.hoppy-generatorImports Foreign qualified as HoppyF.hoppy-generatorImports  Foreign.C qualified as HoppyFC.hoppy-generatorImports Data.Map qualified as HoppyDM.hoppy-generatorImports Prelude qualified as HoppyP.hoppy-generatorImports Foreign.Hoppy.Runtime qualified as HoppyFHR.hoppy-generatorImports System.Posix.Types qualified as HoppySPT.hoppy-generatorImports  Data.Typeable qualified as HoppyDT.hoppy-generatorImports System.IO.Unsafe qualified as HoppySIU.hoppy-generator*Returns an error message indicating that ? is used where data is going from a foreign language into C++.hoppy-generator*Returns an error message indicating that ? is used where data is going from a foreign language into C++.hoppy-generator*Returns an error message indicating that ? is used where data is going from a foreign language into C++.hoppy-generatorhoppy-generatorhoppy-generatorhoppy-generatorhoppy-generatorhoppy-generatorhoppy-generatorChoppy-generator|hoppy-generatorXAn optional external name; will be automatically derived from the identifier if absent.hoppy-generator~Ehoppy-generatorrhoppy-generatorshoppy-generatortIhoppy-generatorXAn optional external name; will be automatically derived from the identifier if absent.hoppy-generatorParameter types.hoppy-generator Return type.Jhoppy-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.fhoppy-generatorParameter types.hhoppy-generatorParameter types.nhoppy-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.rhoppy-generatorThe C++ name of the method.hoppy-generatorParameter types.hoppy-generator Return type.thoppy-generatorThe C++ name of the method.hoppy-generatorA foreign name for the method.hoppy-generatorParameter types.hoppy-generator Return type.hoppy-generatorParameter types.hoppy-generator Return type.  !"#$%*)('&+,-./1023456789@?>=<;:ADCBEJIHGFKLMNOPQRSUVTWXYZdcbea`_^]\[fmlkjihgnpoqzywxvutsr{~}|      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~None;<=>?A]˵#hoppy-generatorC++ void , Haskell ().hoppy-generatorC++ bool , Haskell .hoppy-generatorC++ char , Haskell .hoppy-generatorC++  unsigned char , Haskell .hoppy-generatorC++  short int , Haskell .hoppy-generatorC++ unsigned short int , Haskell .hoppy-generatorC++ int , Haskell .hoppy-generatorC++  unsigned int , Haskell .hoppy-generatorC++ long int , Haskell .hoppy-generatorC++ unsigned long int , Haskell .hoppy-generatorC++  long long int , Haskell .hoppy-generatorC++ unsigned long long int , Haskell .hoppy-generatorC++ float , Haskell .hoppy-generatorC++ double , Haskell .hoppy-generatorC++ int8_t , Haskell  .hoppy-generatorC++ int16_t , Haskell !.hoppy-generatorC++ int32_t , Haskell ".hoppy-generatorC++ int64_t , Haskell #.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 *.hoppy-generatorC++ ssize_t , Haskell +,.hoppy-generatorA C++ enum value.hoppy-generatorA C++ bitspace value.hoppy-generatorA pointer to another type.hoppy-generatorA reference to another type.hoppy-generator7A function taking parameters and returning a value (or #). Function pointers must wrap a  in a .hoppy-generator+A handle for calling foreign code from C++.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 W, 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-generatorA const version of another type.##None;<=>?A]hoppy-generator=Sets of functionality that can be stamped onto a class with .hoppy-generator"Provides the assignment operator, Foo& Foo::operator=(const Foo&).hoppy-generatorProvides operators <, <=, >, >=, for example  bool Foo::operator<(const Foo&)0. This feature does not automatically include .hoppy-generatorProvides copy construction, Foo::Foo(const Foo&).hoppy-generator Provides  operator== and  operator!=, for example !bool Foo::operator==(const Foo&).hoppy-generatoreAdds the contents of a feature to a class. Does not check for overlap with existing class contents.None;<=>?A]^bhoppy-generatorTA chunk of generated Haskell code, including information about imports and exports.hoppy-generator0Context information for generating Haskell code.hoppy-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.  and L add context information, and should be given clauses, without punctuation.hoppy-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.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-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 .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-generatorJIndicates who is managing the lifetime of an object via an object pointer.hoppy-generator0The object's lifetime is being managed manually.hoppy-generatorIThe object's lifetime is being managed by the Haskell garbage collector.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 context information to the end of any error message thrown by the action. See .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-generator#Adds imports to the current module.hoppy-generator8Adds a Haskell language extension to the current module.hoppy-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.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 x' 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-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 x 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-generatorInternal helper function for constructing Haskell names from external names. Returns a name that is a suitable Haskell type name for the external name, and if given 1 , then with "Const" appended.hoppy-generatorPure version of & that doesn't create a qualified name.hoppy-generator%Returns the Haskell name for an enum.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; see ~.hoppy-generatorPure version of & that doesn't create a qualified name.hoppy-generator.Returns the Haskell name for a bitspace. See .hoppy-generatorPure version of & that doesn't create a qualified name.hoppy-generatorFConstructs the data constructor name for a value in a bitspace. See .hoppy-generatorPure version of & that doesn't create a qualified name.hoppy-generator^Returns the name of the function that will convert a bitspace value into a raw numeric value.hoppy-generatorPure version of & that doesn't create a qualified name.hoppy-generator]The name of the Haskell typeclass that contains a method for converting to a bitspace value.hoppy-generatorPure version of & that doesn't create a qualified name.hoppy-generatorThe name of the method in the , typeclass that constructs bitspace values.hoppy-generatorPure version of & that doesn't create a qualified name.hoppy-generator^The name for the typeclass of types that can be represented as values of the given C++ class.hoppy-generatorPure version of & that doesn't create a qualified name.hoppy-generator"The name of the method within the = typeclass for accessing an object of the type as a pointer.hoppy-generatorPure version of & that doesn't create a qualified name.hoppy-generatoryThe name for the typeclass of types that are (possibly const) pointers to objects of the given C++ class, or subclasses.hoppy-generatorPure version of & that doesn't create a qualified name.hoppy-generatorYThe name of the function that upcasts pointers to the specific class type and constness. hoppy-generatorPure version of & 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 1:, it will return the function that adds const, and given 01, it will return the function that removes const.hoppy-generatorPure version of & that doesn't create a qualified name.hoppy-generatorcThe name of the data type that represents a pointer to an object of the given class and constness.hoppy-generatorPure version of & that doesn't create a qualified name.hoppy-generatorCThe name of a data constructor for one of the object pointer types.hoppy-generatorPure version of & 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 -.._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 toHsClassDeleteFnName , but as a /0! 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-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 /0= that does appropriate conversions to and from C-side types.!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 ) as necessary for Haskell types that the - references. On failure, an error is thrown.&hoppy-generator Returns the R of a class.'hoppy-generatorConstructs the function type for a callback. For Haskell, the type depends on the side; the C++ side has additional parameters.3Keep this in sync with the C++ generator's version.^      !"#$%&'^      !"#$%&'1None;<=>?A]2hoppy-generatorModifies a class's W, structure by setting all languages to use ClassConversionToHeap.3hoppy-generatorModifies a class's WL structure by setting all languages that support garbage collection to use ClassConversionToGc.23None;<=>?A]  !"#$%&'()*+,-./1023456789:;<=>?@ABCDEFGHIJKLMNOPQRSUVTWXYZ[\]^_`aebcdfghijklmnpoqrstuvxwyz{|}~      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~23     $ !"#%&'()*+,-./0123456789:;<=>?@AB{C|}~DqErstuGvxwHyzFnpofIghijklmZJ[\]^LMNO_P`aeKbQcRdSKLMNOPQYZ[E\]^_`aFGHIJbcdeAfghiBCD96782345/10k,-.nopqrstuvwxyz{|}+~:;<=>?@lmWXYTUVRSUVTWX%&'()*"#$ !  j23None%;<=>?A]B4hoppy-generatorA chunk is a string that contains an arbitrary portion of C++ code. The only requirement is that chunk boundaries are also C++ token boundaries, because the generator monad automates the process of inserting whitespace between chunk boundaries where necessary.hoppy-generator@"genpop" is the prefix used for individually exported functions.7hoppy-generator;Returns the C++ binding function name for an external name.hoppy-generator-"gendel" is the prefix used for wrappers for delete calls.8hoppy-generatorXReturns the C++ binding function name of the wrapper for the delete method for a class.9hoppy-generator classCastFnCppName fromCls toClsK returns the name of the generated C++ function that casts a pointer from fromCls to toCls.:hoppy-generator=Returns the name of the outer, copyable class for a callback.;hoppy-generatorTReturns the name of the internal, non-copyable implementation 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-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.Ahoppy-generator"The C++ variable name to use in a catch! statement in a gateway function.Bhoppy-generatorfThe name of the C++ function that receives an exception from a foreign language and throws it in C++.Choppy-generatorRuns a 4 writer, combining them with  to form a single string.Dhoppy-generatorRuns a 4& writer and returns the monad's value.Ehoppy-generatorRuns a 4$ writer and returns the written log.Fhoppy-generatorRuns a 4) writer transformer, combining them with  to form a single string.Ghoppy-generatorRuns a 42 writer transformer and returns the monad's value.Hhoppy-generatorRuns a 40 writer transformer and returns the written log.hoppy-generatorFlattens a list of chunks down into a single string. Inserts spaces between chunks where the ends of adjacent chunks would otherwise merge into a single C++ token.Ihoppy-generatorEmits a single 4.Jhoppy-generatorEmits a 4 for each string in a list.Khoppy-generator Emits an .Lhoppy-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 M.This function is useful for generating variable declarations, declarations with assignments, and function prototypes and definitions.Mhoppy-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 MQ, deals with recursion, precedence, and the inside-out style of C++ type syntax.456789:;<=>?@ABCDEFGHIJKLM789:;<=>?@AB456CDEFGHIJKLM2None;<=>?A] hoppy-generator#Haskell code is calling out to C++.hoppy-generatorC++ is invoking a callback.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_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-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-generatorGenerates a non-const  CppException. instance if the class is an exception class.hoppy-generator Outputs the  ExceptionDbD needed by all Haskell gateway functions that deal with exceptions.hoppy-generator#Implements special logic on top of %, that computes the Haskell  qualified7 type for a function, including typeclass constraints.3None %;<=>?A]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-generator5Halts generation and returns the given error message.hoppy-generator1Runs the C++ code generator against an interface.hoppy-generatorIf 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-generatorOutputs interface-wide code needed to support exceptions. Currently, this comprises the function for rethrowing in C++ an exception transferred from a foreign language.hoppy-generator Returns a \ iff there is a C type distinct from the given C++ type that should be used for conversion.hoppy-generator`Constructs the function type for a callback. A callback that throws has additional parameters.7Keep this in sync with the Haskell generator's version.None;<=>?A] Nhoppy-generator-Actions that can be requested of the program.Ohoppy-generator<Sets the interface that will be used for subsequent actions.Phoppy-generator1Lists the interfaces compiled into the generator.Qhoppy-generator*Lists the generated files in C++ bindings.Rhoppy-generator.Lists the generated files in Haskell bindings.Shoppy-generator>Generates C++ wrappers for an interface in the given location.Thoppy-generatorBGenerates Haskell bindings for an interface in the given location.Uhoppy-generatorThis provides a simple main( function for a generator. Define your main as: main = defaultMain $  ...  Refer to W1 for how to use the command-line interface. Use V? if you want to include multiple interfaces in your generator.Vhoppy-generatorThis is a version of U" that accepts multiple interfaces.Whoppy-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. NOPQRSTUVW NOPQRSTUVWNone;<=>?A])Xhoppy-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.ahoppy-generatorThe X8 chosen when one is not explicitly requested. This is Z.bhoppy-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 X values. If a value other than these is set, then a warning is printed and the default is used. If no value is set, the default is used. This uses 8 internally and won't cope with a changing environment. XYZ[\]^_`ab \]^_`XYZ[ab456 7 7 8 9 : ; ; < = > > ? @ A B C D E F G H H I J K L L M N O P Q Q R S T U V W X Y Z [ \ ] ^ _ ` a b c d e f g h i j k l m n o p q r s t u v w x y z { | } ~                                                                                                                           ! " # $ % & ' ( ) * + , - . . / 0 1 2 3 4 5 6 7 8 9 : ; < = > ? @ A B C D E F G H I J K L M N O P Q R S T U V W X Y Z [ \ ] ^ _ ` a b c d e f g h i j k l m n o p q r s t u v w x y z { | } ~                                                                                4      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQ1R1STTUVWXYZ[D\]^_`abcdefghijklmnopqrstuvwxyz{|}~                         6222222222223333333333G,hoppy-generator-0.5.2-AKTN8rrho7X1zefzQCB1Qo(Foreign.Hoppy.Generator.Language.HaskellForeign.Hoppy.Generator.SpecForeign.Hoppy.Generator.Types)Foreign.Hoppy.Generator.Spec.ClassFeature$Foreign.Hoppy.Generator.Language.CppForeign.Hoppy.Generator.MainForeign.Hoppy.Generator.VersionForeign.Hoppy.Generator.Common&Foreign.Hoppy.Generator.Common.Consume!Foreign.Hoppy.Generator.Spec.BaseconstTptrTobjTrefTintT objToHeapTtoGcT Foreign.CCCharCUCharCShortCUShortCIntCUIntCLongCULongCLLongCULLongCFloatCDoubleData.IntInt8Int16Int32Int64 Data.WordWord8Word16Word32Word64CPtrdiffCSizeSystem.Posix.TypesCSsizeForeign.Hoppy.Runtimedelete Foreign.PtrFunPtr'Foreign.Hoppy.Generator.Spec.Conversion1Foreign.Hoppy.Generator.Language.Haskell.Internal-Foreign.Hoppy.Generator.Language.Cpp.InternalOutput Generator prettyPrint HsImportValHsImportValSomeHsImportValAll HsImportName HsImportSpecsgetHsImportSpecshsImportSource HsImportKeyhsImportModulehsImportQualifiedName HsModuleName HsImportSetgetHsImportSet HasAddendum getAddendum setAddendummodifyAddendumAddendumaddendumHaskellHandlesExceptionsgetExceptionHandlersExceptionHandlersexceptionHandlersListExceptionHandler CatchClassCatchAll ExceptionIdgetExceptionIdCallbackcallbackExtNamecallbackParamscallbackReturncallbackThrows callbackReqsProp Staticness NonstaticStatic ConstnessNonconstConstMethodApplicabilityMNormalMStaticMConst MethodImpl RealMethodFnMethodMethod methodImpl methodExtNamemethodApplicability methodPurity methodParams methodReturnmethodExceptionHandlersCtor ctorExtName ctorParamsctorExceptionHandlers ClassVariable classVarCNameclassVarExtName classVarTypeclassVarStaticclassVarGettable ClassEntityCEVarCECtorCEMethodCEProp IsClassEntityclassEntityExtNameSuffixClassHaskellConversionclassHaskellConversionTypeclassHaskellConversionToCppFnclassHaskellConversionFromCppFnClassConversionclassHaskellConversionClassclassIdentifier classExtNameclassSuperclasses classEntitiesclassDtorIsPublicclassConversion classReqsclassIsMonomorphicSuperclassclassIsSubclassOfMonomorphicclassIsExceptionclassEntityPrefixFunctionfnCName fnExtNamefnPurityfnParamsfnReturnfnReqsfnExceptionHandlersPurityNonpurePureBitspacebitspaceExtName bitspaceTypebitspaceValueNames bitspaceEnumbitspaceCppTypeIdentifierbitspaceToCppValueFnbitspaceFromCppValueFn bitspaceReqsbitspaceValuePrefixCppEnumenumIdentifier enumExtNameenumValueNamesenumReqsenumValuePrefixVariable varIdentifier varExtNamevarTypevarReqsTypeInternal_TVoidInternal_TBoolInternal_TCharInternal_TUCharInternal_TShortInternal_TUShort Internal_TIntInternal_TUIntInternal_TLongInternal_TULongInternal_TLLongInternal_TULLongInternal_TFloatInternal_TDoubleInternal_TInt8Internal_TInt16Internal_TInt32Internal_TInt64Internal_TWord8Internal_TWord16Internal_TWord32Internal_TWord64Internal_TPtrdiffInternal_TSizeInternal_TSSizeInternal_TEnumInternal_TBitspace Internal_TPtr Internal_TRef Internal_TFnInternal_TCallback Internal_TObjInternal_TObjToHeapInternal_TToGcInternal_TConstIdPart idPartBase idPartArgs IdentifieridentifierPartsExportExportVariable ExportEnumExportBitspaceExportFn ExportClassExportCallback OperatorTypeUnaryPrefixOperatorUnaryPostfixOperatorBinaryOperator CallOperator ArrayOperatorOperatorOpCallOpCommaOpAssignOpArrayOpDeref OpAddressOpAdd OpAddAssign OpSubtractOpSubtractAssign OpMultiplyOpMultiplyAssignOpDivideOpDivideAssignOpModuloOpModuloAssignOpPlusOpMinusOpIncPre OpIncPostOpDecPre OpDecPostOpEqOpNeOpLtOpLeOpGtOpGeOpNotOpAndOpOrOpBitNotOpBitAndOpBitAndAssignOpBitOr OpBitOrAssignOpBitXorOpBitXorAssignOpShl OpShlAssignOpShr OpShrAssignIsFnNametoFnNameFnNameFnOp HasExtNamesgetPrimaryExtNamegetNestedExtNamesExtName fromExtNameHasReqsgetReqssetReqs modifyReqsReqs reqsIncludesModule moduleName moduleHppPath moduleCppPath moduleExports moduleReqsmoduleHaskellNamemoduleExceptionHandlersmoduleCallbacksThrowmoduleAddendumIncludeincludeToStringInterfaceOptions!interfaceOptionsExceptionHandlers Interface interfaceNameinterfaceModulesinterfaceNamesToModules!interfaceHaskellModuleImportNamesinterfaceExceptionHandlersinterfaceCallbacksThrowinterfaceExceptionSupportModuleinterfaceSharedPtrErrorMsgdefaultInterfaceOptions interface interface'interfaceHaskellModuleBase!interfaceDefaultHaskellModuleBaseinterfaceAddHaskellModuleBaseinterfaceExceptionClassIdinterfaceAllExceptionClassesinterfaceSetCallbacksThrow"interfaceSetExceptionSupportModuleinterfaceSetSharedPtr includeStd includeLocal makeModule moduleModify moduleModify'moduleSetHppPathmoduleSetCppPathmoduleAddExportsmoduleAddHaskellNamemoduleSetCallbacksThrow reqIncludeaddReqsaddReqIncludes toExtNameisValidExtNamegetAllExtNamesoperatorPreferredExtNameoperatorPreferredExtName' operatorTypeexportAddendumidentident'ident1ident2ident3ident4ident5identTidentT'ident1Tident2Tident3Tident4Tident5T normalizeType stripConst makeVariable varIsConstvarGetterExtNamevarSetterExtNamemakeEnumenumSetValuePrefix makeBitspacebitspaceSetValuePrefixbitspaceAddEnumbitspaceAddCppTypemakeFn makeClassclassSetEntityPrefixclassAddEntitiesclassVariables classCtors classMethodsclassSetDtorPrivateclassSetMonomorphicSuperclassclassSetSubclassOfMonomorphicclassMakeExceptionclassConversionNoneclassModifyConversionclassSetConversionclassHaskellConversionNoneclassSetHaskellConversionclassEntityExtNameclassEntityForeignNameclassEntityForeignName'makeClassVariablemakeClassVariable_mkClassVariablemkClassVariable_mkStaticClassVariablemkStaticClassVariable_classVarGetterExtNameclassVarGetterForeignNameclassVarSetterExtNameclassVarSetterForeignNamemakeCtor makeCtor_mkCtormkCtor_classFindCopyCtor constNegate methodConst methodStatic makeMethod makeMethod_ makeFnMethod makeFnMethod_mkMethod mkMethod_ mkMethod' mkMethod'_ mkConstMethodmkConstMethod_mkConstMethod'mkConstMethod'_mkStaticMethodmkStaticMethod_mkStaticMethod'mkStaticMethod'_mkPropmkProp_ mkStaticProp mkStaticProp_ mkBoolIsProp mkBoolIsProp_ mkBoolHasPropmkBoolHasProp_ makeCallbackcallbackSetThrowsexceptionCatchAllIdhandleExceptionsaddAddendumHaskellmakeHsImportSethsImportSetMakeSourcehsWholeModuleImporthsQualifiedImport hsImport1 hsImport1' hsImports hsImports'hsImportForBitshsImportForExceptionhsImportForInthsImportForWordhsImportForForeignhsImportForForeignChsImportForMaphsImportForPreludehsImportForRuntimehsImportForSystemPosixTypeshsImportForTypeablehsImportForUnsafeIO objToHeapTWrongDirectionErrorMsgtToGcInvalidFormErrorMessagetoGcTWrongDirectionErrorMsgvoidTboolTcharTucharTshortTushortTuintTlongTulongTllongTullongTfloatTdoubleTint8Tint16Tint32Tint64Tword8Tword16Tword32Tword64TptrdiffTsizeTssizeTenumT bitspaceTfnT callbackT ClassFeature Assignable ComparableCopyable EquatableclassAddFeatures$fEqClassFeature$fShowClassFeature HsTypeSideHsCSideHsHsSideHsExport outputExports outputImports outputBodyoutputExtensionsPartialpartialModuleHsName partialOutputManaged Unmanaged getModuleName toModuleName askInterface askModule askModuleNamegetModuleForExtName runGenerator evalGenerator execGenerator renderPartialwithErrorContext inFunction addExport addExport' addExports addImports addExtensionsayLnsaysLnlnindent indentSpacessayLettoHsEnumTypeNametoHsEnumTypeName'toHsEnumCtorNametoHsEnumCtorName'toHsBitspaceTypeNametoHsBitspaceTypeName'toHsBitspaceValueNametoHsBitspaceValueName'toHsBitspaceToNumNametoHsBitspaceToNumName'toHsBitspaceClassNametoHsBitspaceClassName'toHsBitspaceFromValueNametoHsBitspaceFromValueName'toHsValueClassNametoHsValueClassName'toHsWithValuePtrNametoHsWithValuePtrName'toHsPtrClassNametoHsPtrClassName'toHsCastMethodNametoHsCastMethodName'toHsDownCastClassNametoHsDownCastClassName'toHsDownCastMethodNametoHsDownCastMethodName'toHsCastPrimitiveNametoHsCastPrimitiveName'toHsConstCastFnNametoHsConstCastFnName'toHsDataTypeNametoHsDataTypeName'toHsDataCtorNametoHsDataCtorName'toHsClassDeleteFnName'toHsClassDeleteFnPtrName' toHsCtorName toHsCtorName'toHsMethodNametoHsMethodName'toHsClassEntityNametoHsClassEntityName'toHsCallbackCtorNametoHsCallbackCtorName'toHsCallbackNewFunPtrFnNametoHsCallbackNewFunPtrFnName' toHsFnName toHsFnName' toArgNamecppTypeToHsTypeAndUsegetClassHaskellConversion callbackToTFn$fMonoidOutput$fSemigroupOutput $fOrdPartial $fEqPartial$fBoundedManaged $fEnumManaged $fEqManaged $fOrdManaged$fEqHsTypeSide$fShowHsTypeSideclassSetConversionToHeapclassSetConversionToGcChunk chunkContentsexternalNameToCppclassDeleteFnCppNameclassCastFnCppNamecallbackClassNamecallbackImplClassNamecallbackFnName toArgNameAltexceptionIdArgNameexceptionPtrArgNameexceptionVarNameexceptionRethrowFnNamerunChunkWriterevalChunkWriterexecChunkWriterrunChunkWriterTevalChunkWriterTexecChunkWriterTsaysays sayIdentifiersayVarsayTypeActionSelectInterfaceListInterfaces ListCppFiles ListHsFilesGenCpp GenHaskell defaultMain defaultMain'run CppVersionCpp1998Cpp2011Cpp2014FilteredcollectnonejusttestdefaultCppVersionactiveCppVersion$fBoundedCppVersion$fEnumCppVersion$fEqCppVersion$fOrdCppVersion$fShowCppVersion fromMaybeM fromEitherM maybeFailfor listSubstzipWithMwriteFileIfDifferent capitalize lowerFirst upperFirstConsumeT MonadConsumenext runConsumeT evalConsumeT execConsumeTbaseGHC.BaseNothingJustcontainers-0.5.11.0Data.Map.InternalemptyMonoidmodifyExceptionHandlerscallbackAddendum classAddendum fnAddendumghc-prim GHC.TypesIObitspaceAddendumGHC.EnumEnum enumAddendum varAddendummemptymappendinterfaceHaskellModuleBase'interfaceExceptionNamesToIds Data.OldList intercalateGHC.ErrerrorextNameOrIdentifierextNameOrFnIdentifierextNameOrString operatorInfoclassEntityExtNames makeMethod' makeMethod'' makeMethod'''exceptionFirstFreeIdmergeImportSpecsBoolEnv mtl-2.2.2Control.Monad.Error.Class throwError*haskell-src-1.0.3.0-L8qCfH4pvJCHVOth3UmRjgLanguage.Haskell.Pretty renderImportsgetModuleImportNameimportHsModuleForExtNameaddExtNameModule toHsTypeName toHsTypeName'Language.Haskell.SyntaxHsTypeexternalNamePrefixclassDeleteFnPrefix combineChunkssayType'ToCppFromCpp GenerationgeneratedFilesgeneratesayExportCallbacksayCallAndProcessReturn CallDirectionsayExportClassExceptionSupportsayExceptionSupportfnToHsTypeAndUseabort sayArgReadDoDecodeDoEncode typeToCTypeMaybe GHC.IO.UnsafeunsafePerformIO