Global Namespace

// namespaces

namespace jnc;

// typedefs

typedef const jnc_Error* jnc_GetLastErrorFunc();
typedef void jnc_SetErrorFunc(const jnc_Error *error);
typedef void jnc_SetErrnoFunc(int code);
typedef void jnc_SetStringErrorFunc(const char *string);
typedef const char* jnc_GetErrorDescriptionFunc(const jnc_Error *error);
typedef bool_t jnc_IsEveryCapabilityEnabledFunc();
typedef bool_t jnc_IsCapabilityEnabledFunc(const char *capability);

typedef size_t jnc_ReadCapabilityParamFunc(
    const char *param,
    void *value,
    size_t size
    );

typedef const char* jnc_ModuleItemDecl_GetNameFunc(jnc_ModuleItemDecl *decl);
typedef const char* jnc_ModuleItemDecl_GetQualifiedNameFunc(jnc_ModuleItemDecl *decl);
typedef jnc_StorageKind jnc_ModuleItemDecl_GetStorageKindFunc(jnc_ModuleItemDecl *decl);
typedef jnc_AccessKind jnc_ModuleItemDecl_GetAccessKindFunc(jnc_ModuleItemDecl *decl);
typedef jnc_AttributeBlock* jnc_ModuleItemDecl_GetAttributeBlockFunc(jnc_ModuleItemDecl *decl);

typedef jnc_Attribute* jnc_ModuleItemDecl_FindAttributeFunc(
    jnc_ModuleItemDecl *decl,
    const char *name
    );

typedef jnc_Namespace* jnc_ModuleItemDecl_GetParentNamespaceFunc(jnc_ModuleItemDecl *decl);
typedef jnc_Unit* jnc_ModuleItemDecl_GetParentUnitFunc(jnc_ModuleItemDecl *decl);
typedef int jnc_ModuleItemDecl_GetLineFunc(jnc_ModuleItemDecl *decl);
typedef int jnc_ModuleItemDecl_GetColFunc(jnc_ModuleItemDecl *decl);
typedef jnc_Module* jnc_ModuleItem_GetModuleFunc(jnc_ModuleItem *item);
typedef jnc_ModuleItemKind jnc_ModuleItem_GetItemKindFunc(jnc_ModuleItem *item);
typedef uint_t jnc_ModuleItem_GetFlagsFunc(jnc_ModuleItem *item);
typedef jnc_ModuleItemDecl* jnc_ModuleItem_GetDeclFunc(jnc_ModuleItem *item);
typedef jnc_Namespace* jnc_ModuleItem_GetNamespaceFunc(jnc_ModuleItem *item);
typedef jnc_Type* jnc_ModuleItem_GetTypeFunc(jnc_ModuleItem *item);

typedef const char* jnc_ModuleItem_GetSynopsisFunc(
    jnc_ModuleItem *item,
    bool_t isQualifiedName
    );

typedef size_t jnc_AttributeBlock_GetAttributeCountFunc(jnc_AttributeBlock *block);

typedef jnc_Attribute* jnc_AttributeBlock_GetAttributeFunc(
    jnc_AttributeBlock *block,
    size_t index
    );

typedef jnc_Attribute* jnc_AttributeBlock_FindAttributeFunc(
    jnc_AttributeBlock *block,
    const char *name
    );

typedef bool_t jnc_Namespace_IsReadyFunc(jnc_Namespace *nspace);
typedef jnc_NamespaceKind jnc_Namespace_GetNamespaceKindFunc(jnc_Namespace *nspace);
typedef jnc_Namespace* jnc_Namespace_GetParentNamespaceFunc(jnc_Namespace *nspace);
typedef jnc_ModuleItem* jnc_Namespace_GetParentItemFunc(jnc_Namespace *nspace);
typedef size_t jnc_Namespace_GetItemCountFunc(jnc_Namespace *nspace);

typedef jnc_ModuleItem* jnc_Namespace_GetItemFunc(
    jnc_Namespace *nspace,
    size_t index
    );

typedef jnc_FindModuleItemResult jnc_Namespace_FindItemFunc(
    jnc_Namespace *nspace,
    const char *name
    );

typedef uint_t jnc_Variable_GetPtrTypeFlagsFunc(jnc_Variable *variable);
typedef bool_t jnc_Variable_HasInitializerFunc(jnc_Variable *variable);
typedef const char* jnc_Variable_GetInitializerStringFunc(jnc_Variable *variable);
typedef jnc_FunctionKind jnc_Function_GetFunctionKindFunc(jnc_Function *function);
typedef bool_t jnc_Function_IsMemberFunc(jnc_Function *function);
typedef bool_t jnc_Function_IsUnusedExternalFunc(jnc_Function *function);
typedef void* jnc_Function_GetMachineCodeFunc(jnc_Function *function);
typedef jnc_FunctionKind jnc_FunctionOverload_GetFunctionKindFunc(jnc_FunctionOverload *function);
typedef size_t jnc_FunctionOverload_GetOverloadCountFunc(jnc_FunctionOverload *function);

typedef jnc_Function* jnc_FunctionOverload_GetOverloadFunc(
    jnc_FunctionOverload *function,
    size_t index
    );

typedef jnc_Function* jnc_Property_GetGetterFunc(jnc_Property *prop);
typedef jnc_OverloadableFunction jnc_Property_GetSetterFunc(jnc_Property *prop);
typedef jnc_TypeKind jnc_Type_GetTypeKindFunc(jnc_Type *type);
typedef size_t jnc_Type_GetSizeFunc(jnc_Type *type);
typedef const char* jnc_Type_GetTypeStringFunc(jnc_Type *type);

typedef int jnc_Type_CmpFunc(
    jnc_Type *type,
    jnc_Type *type2
    );

typedef jnc_ArrayType* jnc_Type_GetArrayTypeFunc(
    jnc_Type *type,
    size_t elementCount
    );

typedef jnc_DataPtrType* jnc_Type_GetBitFieldDataPtrTypeFunc(
    jnc_Type *type,
    uint_t bitOffset,
    uint_t bitCount,
    jnc_TypeKind typeKind,
    jnc_DataPtrTypeKind ptrTypeKind,
    uint_t flags
    );

typedef jnc_DataPtrType* jnc_Type_GetDataPtrTypeFunc(
    jnc_Type *type,
    jnc_TypeKind typeKind,
    jnc_DataPtrTypeKind ptrTypeKind,
    uint_t flags
    );

typedef bool_t jnc_Type_ensureLayoutFunc(jnc_Type *type);
typedef bool_t jnc_Type_ensureNoImportsFunc(jnc_Type *type);

typedef void jnc_Type_MarkGcRootsFunc(
    jnc_Type *type,
    const void *p,
    jnc_GcHeap *gcHeap
    );

typedef size_t jnc_BaseTypeSlot_GetOffsetFunc(jnc_BaseTypeSlot *baseType);
typedef size_t jnc_BaseTypeSlot_GetVtableIndexFunc(jnc_BaseTypeSlot *baseType);
typedef jnc_Function* jnc_DerivableType_GetMethodFunc(jnc_DerivableType *type);
typedef jnc_OverloadableFunction jnc_DerivableType_GetOverloadableMethodFunc(jnc_DerivableType *type);

typedef jnc_OverloadableFunction jnc_DerivableType_GetUnaryOperatorFunc(
    jnc_DerivableType *type,
    jnc_UnOpKind opKind
    );

typedef jnc_OverloadableFunction jnc_DerivableType_GetBinaryOperatorFunc(
    jnc_DerivableType *type,
    jnc_BinOpKind opKind
    );

typedef size_t jnc_DerivableType_GetCastOperatorCountFunc(jnc_DerivableType *type);

typedef jnc_Function* jnc_DerivableType_GetCastOperatorFunc(
    jnc_DerivableType *type,
    size_t index
    );

typedef jnc_Type* jnc_ArrayType_GetElementTypeFunc(jnc_ArrayType *type);
typedef size_t jnc_ArrayType_GetElementCountFunc(jnc_ArrayType *type);
typedef jnc_Type* jnc_FunctionType_GetReturnTypeFunc(jnc_FunctionType *type);
typedef size_t jnc_FunctionType_GetArgCountFunc(jnc_FunctionType *type);

typedef jnc_FunctionArg* jnc_FunctionType_GetArgFunc(
    jnc_FunctionType *type,
    size_t index
    );

typedef jnc_FunctionPtrType* jnc_FunctionType_GetFunctionPtrTypeFunc(
    jnc_FunctionType *type,
    jnc_TypeKind typeKind,
    jnc_FunctionPtrTypeKind ptrTypeKind,
    uint_t flags
    );

typedef jnc_FunctionType* jnc_FunctionType_GetShortTypeFunc(jnc_FunctionType *type);
typedef int64_t jnc_EnumConst_GetValueFunc(jnc_EnumConst *enumConst);
typedef jnc_Type* jnc_EnumType_GetBaseTypeFunc(jnc_EnumType *type);
typedef jnc_Type* jnc_EnumType_GetRootTypeFunc(jnc_EnumType *type);
typedef size_t jnc_EnumType_GetConstCountFunc(jnc_EnumType *type);

typedef jnc_EnumConst* jnc_EnumType_GetConstFunc(
    jnc_EnumType *type,
    size_t index
    );

typedef jnc_Type* jnc_Field_GetTypeFunc(jnc_Field *field);
typedef uint_t jnc_Field_GetBitOffsetFunc(jnc_Field *field);
typedef uint_t jnc_Field_GetBitCountFunc(jnc_Field *field);
typedef uint_t jnc_Field_GetPtrTypeFlagsFunc(jnc_Field *field);
typedef size_t jnc_Field_GetOffsetFunc(jnc_Field *field);
typedef jnc_ClassTypeKind jnc_ClassType_GetClassTypeKindFunc(jnc_ClassType *type);
typedef jnc_StructType* jnc_ClassType_GetIfaceStructTypeFunc(jnc_ClassType *type);

typedef jnc_ClassPtrType* jnc_ClassType_GetClassPtrTypeFunc(
    jnc_ClassType *type,
    jnc_TypeKind typeKind,
    jnc_ClassPtrTypeKind ptrTypeKind,
    uint_t flags
    );

typedef jnc_FunctionPtrType* jnc_MulticastClassType_GetTargetTypeFunc(jnc_MulticastClassType *type);

typedef jnc_Function* jnc_MulticastClassType_GetMethodFunc(
    jnc_MulticastClassType *type,
    jnc_MulticastMethodKind method
    );

typedef jnc_FunctionPtrType* jnc_McSnapshotClassType_GetTargetTypeFunc(jnc_McSnapshotClassType *type);

typedef jnc_Function* jnc_McSnapshotClassType_GetMethodFunc(
    jnc_McSnapshotClassType *type,
    jnc_McSnapshotMethodKind method
    );

typedef jnc_DataPtrTypeKind jnc_DataPtrType_GetPtrTypeKindFunc(jnc_DataPtrType *type);
typedef jnc_Type* jnc_DataPtrType_GetTargetTypeFunc(jnc_DataPtrType *type);
typedef uint_t jnc_DataPtrType_GetBitOffsetFunc(jnc_DataPtrType *type);
typedef uint_t jnc_DataPtrType_GetBitCountFunc(jnc_DataPtrType *type);
typedef jnc_ClassPtrTypeKind jnc_ClassPtrType_GetPtrTypeKindFunc(jnc_ClassPtrType *type);
typedef jnc_ClassType* jnc_ClassPtrType_GetTargetTypeFunc(jnc_ClassPtrType *type);
typedef jnc_FunctionPtrTypeKind jnc_FunctionPtrType_GetPtrTypeKindFunc(jnc_FunctionPtrType *type);
typedef jnc_FunctionType* jnc_FunctionPtrType_GetTargetTypeFunc(jnc_FunctionPtrType *type);

typedef bool_t jnc_Variant_CreateFunc(
    jnc_Variant *variant,
    const void *p,
    jnc_Type *type
    );

typedef bool_t jnc_Variant_CastFunc(
    const jnc_Variant *variant,
    jnc_Type *type,
    void *buffer
    );

typedef bool_t jnc_Variant_UnaryOperatorFunc(
    const jnc_Variant *variant,
    jnc_UnOpKind opKind,
    jnc_Variant *result
    );

typedef bool_t jnc_Variant_BinaryOperatorFunc(
    const jnc_Variant *variant,
    const jnc_Variant *variant2,
    jnc_BinOpKind opKind,
    jnc_Variant *result
    );

typedef bool_t jnc_Variant_RelationalOperatorFunc(
    const jnc_Variant *variant,
    const jnc_Variant *variant2,
    jnc_BinOpKind opKind,
    bool_t *result
    );

typedef bool_t jnc_Variant_GetMemberFunc(
    const jnc_Variant *variant,
    const char *name,
    jnc_Variant *result
    );

typedef bool_t jnc_Variant_SetMemberFunc(
    jnc_Variant *variant,
    const char *name,
    jnc_Variant value
    );

typedef bool_t jnc_Variant_GetElementFunc(
    const jnc_Variant *variant,
    size_t index,
    jnc_Variant *result
    );

typedef bool_t jnc_Variant_SetElementFunc(
    jnc_Variant *variant,
    size_t index,
    jnc_Variant value
    );

typedef size_t jnc_Variant_HashFunc(const jnc_Variant *variant);

typedef const char* jnc_Variant_FormatFunc(
    const jnc_Variant *variant,
    const char *fmtSpecifier
    );

typedef jnc_DataPtr jnc_String_SzFunc(const jnc_String *string);

typedef void jnc_String_SetPtrFunc(
    jnc_String *string,
    jnc_DataPtr ptr,
    size_t length
    );

typedef jnc_Promise* jnc_Promise_CreateFunc(jnc_Runtime *runtime);

typedef void jnc_Promise_CompleteFunc(
    jnc_Promise *promise,
    jnc_Variant result,
    jnc_DataPtr errorPtr
    );

typedef jnc_ExtensionLib* jnc_Unit_GetLibFunc(jnc_Unit *unit);
typedef const char* jnc_Unit_GetFilePathFunc(jnc_Unit *unit);
typedef const char* jnc_Unit_GetFileNameFunc(jnc_Unit *unit);
typedef const char* jnc_Unit_GetDirFunc(jnc_Unit *unit);
typedef const char* jnc_Module_GetNameFunc(jnc_Module *module);
typedef jnc_GlobalNamespace* jnc_Module_GetGlobalNamespaceFunc(jnc_Module *module);

typedef jnc_GlobalNamespace* jnc_Module_GetStdNamespaceFunc(
    jnc_Module *module,
    jnc_StdNamespace stdNamespace
    );

typedef jnc_Type* jnc_Module_GetPrimitiveTypeFunc(
    jnc_Module *module,
    jnc_TypeKind typeKind
    );

typedef jnc_Type* jnc_Module_GetStdTypeFunc(
    jnc_Module *module,
    jnc_StdType stdType
    );

typedef handle_t jnc_Module_GetExtensionSourceFileIteratorFunc(jnc_Module *module);

typedef const char* jnc_Module_GetNextExtensionSourceFileFunc(
    jnc_Module *module,
    handle_t *iterator
    );

typedef jnc_FindModuleItemResult jnc_Module_FindExtensionLibItemFunc(
    jnc_Module *module,
    const char *name,
    const jnc_Guid *libGuid,
    size_t itemCacheSlot
    );

typedef const char* jnc_Module_GetExtensionLibZipFilePathFunc(
    jnc_Module *module,
    jnc_ExtensionLib *lib
    );

typedef bool_t jnc_Module_MapVariableFunc(
    jnc_Module *module,
    jnc_Variable *variable,
    void *p
    );

typedef bool_t jnc_Module_MapFunctionFunc(
    jnc_Module *module,
    jnc_Function *function,
    void *p
    );

typedef void jnc_Module_AddSourceFunc(
    jnc_Module *module,
    jnc_ExtensionLib *lib,
    const char *fileName,
    const char *source,
    size_t length
    );

typedef handle_t jnc_Module_GetImportDirIteratorFunc(jnc_Module *module);

typedef const char* jnc_Module_GetNextImportDirFunc(
    jnc_Module *module,
    handle_t *iterator
    );

typedef void jnc_Module_AddImportDirFunc(
    jnc_Module *module,
    const char *dir
    );

typedef bool_t jnc_Module_AddImportFunc(
    jnc_Module *module,
    const char *fileName
    );

typedef void jnc_Module_AddSourceImportFunc(
    jnc_Module *module,
    const char *fileName,
    const char *source,
    size_t length
    );

typedef void jnc_Module_AddOpaqueClassTypeInfoFunc(
    jnc_Module *module,
    const char *qualifiedName,
    const jnc_OpaqueClassTypeInfo *info
    );

typedef void jnc_Module_AddStaticLibFunc(
    jnc_Module *module,
    jnc_ExtensionLib *lib
    );

typedef void jnc_Module_RequireFunc(
    jnc_Module *module,
    jnc_ModuleItemKind itemKind,
    const char *name,
    uint_t flags
    );

typedef void jnc_Module_RequireTypeFunc(
    jnc_Module *module,
    jnc_TypeKind typeKind,
    const char *name,
    uint_t flags
    );

typedef bool_t jnc_Module_ParseFunc(
    jnc_Module *module,
    const char *fileName,
    const char *source,
    size_t length
    );

typedef bool_t jnc_Module_ParseFileFunc(
    jnc_Module *module,
    const char *fileName
    );

typedef bool_t jnc_Module_ParseImportsFunc(jnc_Module *module);
typedef bool_t jnc_Module_CompileFunc(jnc_Module *module);
typedef bool_t jnc_Module_JitFunc(jnc_Module *module);
typedef const char* jnc_Module_getLlvmIrStringFunc(jnc_Module *module);
typedef jnc_Runtime* jnc_Runtime_CreateFunc();
typedef void jnc_Runtime_DestroyFunc(jnc_Runtime *runtime);
typedef jnc_Module* jnc_Runtime_GetModuleFunc(jnc_Runtime *runtime);
typedef jnc_GcHeap* jnc_Runtime_GetGcHeapFunc(jnc_Runtime *runtime);
typedef bool_t jnc_Runtime_IsAbortedFunc(jnc_Runtime *runtime);

typedef bool_t jnc_Runtime_StartupFunc(
    jnc_Runtime *runtime,
    jnc_Module *module
    );

typedef void jnc_Runtime_ShutdownFunc(jnc_Runtime *runtime);
typedef void jnc_Runtime_AbortFunc(jnc_Runtime *runtime);

typedef void jnc_Runtime_InitializeCallSiteFunc(
    jnc_Runtime *runtime,
    jnc_CallSite *callSite
    );

typedef void jnc_Runtime_UninitializeCallSiteFunc(
    jnc_Runtime *runtime,
    jnc_CallSite *callSite
    );

typedef jnc_SjljFrame* jnc_Runtime_SetSjljFrameFunc(
    jnc_Runtime *runtime,
    jnc_SjljFrame *frame
    );

typedef void* jnc_Runtime_GetUserDataFunc(jnc_Runtime *runtime);

typedef void* jnc_Runtime_SetUserDataFunc(
    jnc_Runtime *runtime,
    void *data
    );

typedef jnc_Runtime* jnc_GetCurrentThreadRuntimeFunc();
typedef jnc_Tls* jnc_GetCurrentThreadTlsFunc();
typedef void jnc_DynamicThrowFunc();
typedef void jnc_SaveSignalInfoFunc(jnc_SjljFrame *sjljFrame);

typedef void jnc_PrimeClassFunc(
    jnc_Box *box,
    jnc_Box *root,
    jnc_ClassType *type,
    const void *vtable
    );

typedef jnc_Runtime* jnc_GcHeap_GetRuntimeFunc(jnc_GcHeap *gcHeap);

typedef void jnc_GcHeap_GetStatsFunc(
    jnc_GcHeap *gcHeap,
    jnc_GcStats *stats
    );

typedef void jnc_GcHeap_GetSizeTriggersFunc(
    jnc_GcHeap *gcHeap,
    jnc_GcSizeTriggers *triggers
    );

typedef void jnc_GcHeap_SetSizeTriggersFunc(
    jnc_GcHeap *gcHeap,
    const jnc_GcSizeTriggers *triggers
    );

typedef void jnc_GcHeap_CollectFunc(jnc_GcHeap *gcHeap);
typedef void jnc_GcHeap_EnterNoCollectRegionFunc(jnc_GcHeap *gcHeap);

typedef void jnc_GcHeap_LeaveNoCollectRegionFunc(
    jnc_GcHeap *gcHeap,
    bool_t canCollectNow
    );

typedef void jnc_GcHeap_EnterWaitRegionFunc(jnc_GcHeap *gcHeap);
typedef void jnc_GcHeap_LeaveWaitRegionFunc(jnc_GcHeap *gcHeap);

typedef jnc_IfaceHdr* jnc_GcHeap_AllocateClassFunc(
    jnc_GcHeap *gcHeap,
    jnc_ClassType *type
    );

typedef jnc_DataPtr jnc_GcHeap_AllocateDataFunc(
    jnc_GcHeap *gcHeap,
    jnc_Type *type
    );

typedef jnc_DataPtr jnc_GcHeap_AllocateArrayFunc(
    jnc_GcHeap *gcHeap,
    jnc_Type *type,
    size_t count
    );

typedef jnc_DataPtr jnc_GcHeap_AllocateBufferFunc(
    jnc_GcHeap *gcHeap,
    size_t size
    );

typedef jnc_DataPtrValidator* jnc_GcHeap_CreateDataPtrValidatorFunc(
    jnc_GcHeap *gcHeap,
    jnc_Box *box,
    const void *rangeBegin,
    size_t rangeLength
    );

typedef jnc_DetachedDataBox* jnc_GcHeap_CreateForeignDataBoxFunc(
    jnc_GcHeap *gcHeap,
    jnc_Type *type,
    size_t elementCount,
    const void *p,
    bool_t isCallSiteLocal
    );

typedef jnc_DataPtr jnc_GcHeap_CreateForeignBufferPtrFunc(
    jnc_GcHeap *gcHeap,
    const void *p,
    size_t size,
    bool_t isCallSiteLocal
    );

typedef void jnc_GcHeap_InvalidateDataPtrValidatorFunc(
    jnc_GcHeap *gcHeap,
    jnc_DataPtrValidator *validator
    );

typedef void jnc_GcHeap_WeakMarkFunc(
    jnc_GcHeap *gcHeap,
    jnc_Box *box
    );

typedef void jnc_GcHeap_MarkDataFunc(
    jnc_GcHeap *gcHeap,
    jnc_Box *box
    );

typedef void jnc_GcHeap_MarkClassFunc(
    jnc_GcHeap *gcHeap,
    jnc_Box *box
    );

typedef void jnc_GcHeap_MarkVariantFunc(
    jnc_GcHeap *gcHeap,
    jnc_Variant variant
    );

typedef void jnc_GcHeap_AddBoxToCallSiteFunc(jnc_Box *box);

typedef jnc_StdHashTable* jnc_CreateStdHashTableFunc(
    jnc_Runtime *runtime,
    jnc_StdHashFunc *hashFunc,
    jnc_StdIsEqualFunc *isEqualFunc
    );

typedef void jnc_StdHashTable_ClearFunc(jnc_StdHashTable *hashTable);

typedef jnc_StdMapEntry* jnc_StdHashTable_FindFunc(
    jnc_StdHashTable *hashTable,
    jnc_Variant key
    );

typedef jnc_StdMapEntry* jnc_StdHashTable_AddFunc(
    jnc_StdHashTable *hashTable,
    jnc_Variant key,
    jnc_Variant value
    );

typedef void jnc_StdHashTable_RemoveFunc(
    jnc_StdHashTable *hashTable,
    jnc_StdMapEntry *entry
    );

typedef bool_t jnc_StdHashTable_RemoveKeyFunc(
    jnc_StdHashTable *hashTable,
    jnc_Variant key
    );

typedef jnc_StdRbTree* jnc_CreateStdRbTreeFunc(
    jnc_Runtime *runtime,
    jnc_StdCmpFunc *cmpFunc
    );

typedef void jnc_StdRbTree_ClearFunc(jnc_StdRbTree *RbTree);

typedef jnc_StdMapEntry* jnc_StdRbTree_FindFunc(
    jnc_StdRbTree *RbTree,
    jnc_Variant key
    );

typedef jnc_StdMapEntry* jnc_StdRbTree_AddFunc(
    jnc_StdRbTree *RbTree,
    jnc_Variant key,
    jnc_Variant value
    );

typedef void jnc_StdRbTree_RemoveFunc(
    jnc_StdRbTree *RbTree,
    jnc_StdMapEntry *entry
    );

typedef bool_t jnc_StdRbTree_RemoveKeyFunc(
    jnc_StdRbTree *RbTree,
    jnc_Variant key
    );

typedef jnc_StdBuffer* jnc_CreateStdBufferFunc(jnc_Runtime *runtime);

typedef bool_t jnc_StdBuffer_ReserveFunc(
    jnc_StdBuffer *buffer,
    size_t size
    );

typedef size_t jnc_StdBuffer_CopyFunc(
    jnc_StdBuffer *buffer,
    const void *p,
    size_t size
    );

typedef size_t jnc_StdBuffer_InsertFunc(
    jnc_StdBuffer *buffer,
    size_t offset,
    const void *p,
    size_t size
    );

typedef size_t jnc_StdBuffer_RemoveFunc(
    jnc_StdBuffer *Buffer,
    size_t offset,
    size_t size
    );

typedef void jnc_ExtensionLib_AddSourcesFunc(jnc_Module *module);
typedef void jnc_ExtensionLib_AddOpaqueClassTypeInfosFunc(jnc_Module *module);
typedef bool_t jnc_ExtensionLib_MapAddressesFunc(jnc_Module *module);
typedef void jnc_ExtensionLib_UpdateCapabilitiesFunc();
typedef jnc_ExtensionLib* jnc_DynamicExtensionLibMainFunc(jnc_DynamicExtensionLibHost *host);
typedef bool_t jnc_DynamicExtensionLibUnloadFunc();

typedef size_t jnc_StdLib_StdInputFunc(
    void *p,
    size_t size
    );

typedef size_t jnc_StdLib_StdOutputFunc(
    const void *p,
    size_t size
    );

typedef bool_t jnc_ModuleCompileErrorHandlerFunc(
    void *context,
    jnc_ModuleCompileErrorKind errorKind
    );

typedef void jnc_AttributeObserverFunc(
    void *context,
    jnc_ModuleItem *item,
    jnc_AttributeBlock *attributeBlock
    );

typedef enum jnc_OptLevel nc_OptLevel;
typedef int bool_t;
typedef unsigned int uint_t;
typedef unsigned char uchar_t;
typedef unsigned short ushort_t;
typedef unsigned long ulong_t;
typedef uint8_t byte_t;
typedef uint16_t word_t;
typedef uint32_t dword_t;
typedef uint64_t qword_t;

typedef void jnc_Scheduler_ScheduleFunc(
    jnc_Scheduler *scheduler,
    jnc_FunctionPtr functionPtr
    );

typedef void jnc_MarkOpaqueGcRootsFunc(
    jnc_IfaceHdr *iface,
    jnc_GcHeap *gcHeap
    );

typedef void jnc_RequireOpaqueItemsFunc(jnc_Module *module);
typedef void jnc_StaticConstructFunc();
typedef void jnc_StaticDestructFunc();
typedef void jnc_ConstructFunc(jnc_IfaceHdr *iface);
typedef void jnc_DestructFunc(jnc_IfaceHdr *iface);
typedef size_t jnc_StdHashFunc(jnc_Variant key);

typedef bool_t jnc_StdIsEqualFunc(
    jnc_Variant key1,
    jnc_Variant key2
    );

typedef int jnc_StdCmpFunc(
    jnc_Variant key1,
    jnc_Variant key2
    );

// enums

enum {
    jnc_Variant_DataSize = sizeof(void*)* 6,
};

enum jnc_AccessKind;
enum jnc_ArrayTypeFlag;
enum jnc_BinOpKind;
enum jnc_BoxFlag;
enum jnc_ClassPtrTypeKind;
enum jnc_ClassTypeFlag;
enum jnc_ClassTypeKind;
enum jnc_CodeAssistFlag;
enum jnc_CodeAssistKind;
enum jnc_DataPtrTypeKind;
enum jnc_DynamicLayoutMode;
enum jnc_DynamicSectionKind;
enum jnc_EnumTypeFlag;
enum jnc_FunctionFlag;
enum jnc_FunctionKind;
enum jnc_FunctionKindFlag;
enum jnc_FunctionOverloadFlag;
enum jnc_FunctionPtrTypeKind;
enum jnc_FunctionTypeFlag;
enum jnc_GcDef;
enum jnc_GcShadowStackFrameMapOp;
enum jnc_JitKind;
enum jnc_McSnapshotFieldKind;
enum jnc_McSnapshotMethodKind;
enum jnc_ModuleCompileErrorKind;
enum jnc_ModuleCompileFlag;
enum jnc_ModuleCompileState;
enum jnc_ModuleItemFlag;
enum jnc_ModuleItemKind;
enum jnc_ModuleRequireFlag;
enum jnc_MulticastFieldKind;
enum jnc_MulticastMethodFlag;
enum jnc_MulticastMethodKind;
enum jnc_NamespaceKind;
enum jnc_OptLevel;
enum jnc_PropertyFlag;
enum jnc_PropertyKind;
enum jnc_PropertyPtrTypeKind;
enum jnc_PropertyTypeFlag;
enum jnc_PtrTypeFlag;
enum jnc_StdNamespace;
enum jnc_StdType;
enum jnc_StorageKind;
enum jnc_TypeFlag;
enum jnc_TypeKind;
enum jnc_TypeKindFlag;
enum jnc_UnOpKind;
enum jnc_VariableFlag;

// structs

struct jnc_ArrayType;
struct jnc_ArrayTypeFuncTable;
struct jnc_AttributeBlockFuncTable;
struct jnc_AttributeFuncTable;
struct jnc_BaseTypeSlotFuncTable;
struct jnc_Box;
struct jnc_CallSite;
struct jnc_CapabilityFuncTable;
struct jnc_ClassPtrTypeFuncTable;
struct jnc_ClassType;
struct jnc_ClassTypeFuncTable;
struct jnc_CodeAuthenticatorConfig;
struct jnc_DataBox;
struct jnc_DataPtr;
struct jnc_DataPtrTypeFuncTable;
struct jnc_DataPtrValidator;
struct jnc_DerivableType;
struct jnc_DerivableTypeFuncTable;
struct jnc_DetachedDataBox;
struct jnc_DynamicExtensionLibHost;
struct jnc_EnumConstFuncTable;
struct jnc_EnumType;
struct jnc_EnumTypeFuncTable;
struct jnc_Error;
struct jnc_ErrorFuncTable;
struct jnc_ExtensionLib;
struct jnc_FieldFuncTable;
struct jnc_FindModuleItemResult;
struct jnc_FmtLiteral;
struct jnc_Function;
struct jnc_FunctionArgFuncTable;
struct jnc_FunctionFuncTable;
struct jnc_FunctionOverloadFuncTable;
struct jnc_FunctionPtr;
struct jnc_FunctionPtrTypeFuncTable;
struct jnc_FunctionType;
struct jnc_FunctionTypeFuncTable;
struct jnc_GcHeap;
struct jnc_GcHeapFuncTable;
struct jnc_GcMutatorThread;
struct jnc_GcShadowStackFrame;
struct jnc_GcShadowStackFrameMapBuffer;
struct jnc_GcSizeTriggers;
struct jnc_GcStats;
struct jnc_GlobalNamespaceFuncTable;
struct jnc_Guid;
struct jnc_IfaceHdr;
struct jnc_ListLink;
struct jnc_McSnapshot;
struct jnc_McSnapshotClassTypeFuncTable;
struct jnc_Module;
struct jnc_ModuleConfig;
struct jnc_ModuleFuncTable;
struct jnc_ModuleItem;
struct jnc_ModuleItemDecl;
struct jnc_ModuleItemDeclFuncTable;
struct jnc_ModuleItemFuncTable;
struct jnc_Multicast;
struct jnc_MulticastClassTypeFuncTable;
struct jnc_NamedTypeFuncTable;
struct jnc_Namespace;
struct jnc_NamespaceFuncTable;
struct jnc_OpaqueClassTypeInfo;
struct jnc_Promise;
struct jnc_PromiseFuncTable;
struct jnc_Property;
struct jnc_PropertyFuncTable;
struct jnc_PropertyPtr;
struct jnc_PropertyPtrTypeFuncTable;
struct jnc_PropertyType;
struct jnc_PropertyTypeFuncTable;
struct jnc_Reactor;
struct jnc_ReactorClosure;
struct jnc_Runtime;
struct jnc_RuntimeFuncTable;
struct jnc_Scheduler;
struct jnc_SchedulerVtable;
struct jnc_SjljFrame;
struct jnc_StdBuffer;
struct jnc_StdBufferFuncTable;
struct jnc_StdHashTable;
struct jnc_StdHashTableFuncTable;
struct jnc_StdMap;
struct jnc_StdMapEntry;
struct jnc_StdRbTree;
struct jnc_StdRbTreeFuncTable;
struct jnc_String;
struct jnc_StringFuncTable;
struct jnc_StructType;
struct jnc_StructTypeFuncTable;
struct jnc_Tls;
struct jnc_TlsVariableTable;
struct jnc_Type;
struct jnc_TypeFuncTable;
struct jnc_TypedefFuncTable;
struct jnc_UnionType;
struct jnc_UnionTypeFuncTable;
struct jnc_UnitFuncTable;
struct jnc_Variable;
struct jnc_VariableFuncTable;
struct jnc_Variant;
struct jnc_VariantFuncTable;

// unions

union jnc_OverloadableFunction;

// global variables

JNC_SELECT_ANY char jnc_g_dynamicExtensionLibMainFuncName[] = "jncDynamicExtensionLibMain";
JNC_SELECT_ANY char jnc_g_dynamicExtensionLibUnloadFuncName[] = "jncDynamicExtensionLibUnload";
JNC_SELECT_ANY jnc_ModuleConfig jnc_g_defaultModuleConfig = {  jnc_JitKind_Auto,   jnc_OptLevel_Default,   jnc_ModuleCompileFlag_StdFlags, };
JNC_SELECT_ANY jnc_FindModuleItemResult jnc_g_errorFindModuleItemResult = { 0, NULL };
JNC_SELECT_ANY jnc_FindModuleItemResult jnc_g_nullFindModuleItemResult = { 1, NULL };
JNC_SELECT_ANY jnc_DataPtr jnc_g_nullDataPtr = { 0 };
JNC_SELECT_ANY jnc_FunctionPtr jnc_g_nullFunctionPtr = { 0 };
JNC_SELECT_ANY jnc_PropertyPtr jnc_g_nullPropertyPtr = { 0 };
JNC_SELECT_ANY jnc_String jnc_g_nullString = { 0 };
JNC_SELECT_ANY jnc_Variant jnc_g_nullVariant = { 0 };

// global functions

const char*
jnc_Alias_getInitializerString_v(jnc_Alias* alias);

bool_t
jnc_Alias_isResolved(jnc_Alias* alias);

jnc_ModuleItem*
jnc_Alias_getTargetItem(jnc_Alias* alias);

jnc_Type*
jnc_ArrayType_getElementType(jnc_ArrayType* type);

size_t
jnc_ArrayType_getElementCount(jnc_ArrayType* type);

static
bool_t
jnc_isAutoSizeArrayType(jnc_Type* type);

static
bool_t
jnc_isCharArrayType(jnc_Type* type);

static
bool_t
jnc_isCharArrayRefType(jnc_Type* type);

jnc_Variant
jnc_Attribute_getValue(jnc_Attribute* attr);

size_t
jnc_AttributeBlock_getAttributeCount(jnc_AttributeBlock* block);

jnc_Attribute*
jnc_AttributeBlock_getAttribute(
    jnc_AttributeBlock* block,
    size_t index
);

jnc_Attribute*
jnc_AttributeBlock_findAttribute(
    jnc_AttributeBlock* block,
    const char* name
);

bool_t
jnc_AttributeBlock_ensureAttributeValuesReady(jnc_AttributeBlock* block);

JNC_EXTERN_C bool_t
jnc_isEveryCapabilityEnabled();

JNC_EXTERN_C bool_t
jnc_isCapabilityEnabled(const char* capability);

JNC_EXTERN_C size_t
jnc_readCapabilityParam(
    const char* param,
    void* value,
    size_t size
);

JNC_INLINE size_t
jnc_getCapabilityParamSize(const char* param);

JNC_EXTERN_C size_t
jnc_writeCapabilityParam(
    const char* param,
    const void* value,
    size_t size
);

JNC_EXTERN_C bool_t
jnc_failWithCapabilityError(const char* capability);

JNC_INLINE bool_t
jnc_requireCapability(const char* capability);

JNC_EXTERN_C void
jnc_enableCapability(
    const char* capability,
    bool_t isEnabled
);

JNC_EXTERN_C void
jnc_initializeCapabilities(const char* initializer);

const char*
jnc_getClassPtrTypeKindString(jnc_ClassPtrTypeKind ptrTypeKind);

jnc_ClassTypeKind
jnc_ClassType_getClassTypeKind(jnc_ClassType* type);

jnc_StructType*
jnc_ClassType_getIfaceStructType(jnc_ClassType* type);

jnc_ClassPtrType*
jnc_ClassType_getClassPtrType(
    jnc_ClassType* type,
    jnc_TypeKind typeKind,
    jnc_ClassPtrTypeKind ptrTypeKind,
    uint_t flags
);

jnc_ClassPtrTypeKind
jnc_ClassPtrType_getPtrTypeKind(jnc_ClassPtrType* type);

jnc_ClassType*
jnc_ClassPtrType_getTargetType(jnc_ClassPtrType* type);

jnc_FunctionPtrType*
jnc_MulticastClassType_getTargetType(jnc_MulticastClassType* type);

static
jnc_FunctionType*
jnc_MulticastClassType_getFunctionType(jnc_MulticastClassType* type);

jnc_Function*
jnc_MulticastClassType_getMethod(
    jnc_MulticastClassType* type,
    jnc_MulticastMethodKind method
);

jnc_FunctionPtrType*
jnc_McSnapshotClassType_getTargetType(jnc_McSnapshotClassType* type);

static
jnc_FunctionType*
jnc_McSnapshotClassType_getFunctionType(jnc_McSnapshotClassType* type);

jnc_Function*
jnc_McSnapshotClassType_getMethod(
    jnc_McSnapshotClassType* type,
    jnc_McSnapshotMethodKind method
);

static
bool_t
jnc_isClassType(
    jnc_Type* type,
    jnc_ClassTypeKind classTypeKind
);

static
bool_t
jnc_isOpaqueClassType(jnc_Type* type);

static
bool_t
jnc_isClosureClassType(jnc_Type* type);

static
bool_t
jnc_isDestructibleClassType(jnc_Type* type);

static
void*
jnc_getMulticastCallMethodMachineCode(jnc_Multicast* multicast);

jnc_CodeAssistKind
jnc_CodeAssist_getCodeAssistKind(jnc_CodeAssist* codeAssist);

uint_t
jnc_CodeAssist_getFlags(jnc_CodeAssist* codeAssist);

size_t
jnc_CodeAssist_getOffset(jnc_CodeAssist* codeAssist);

jnc_Module*
jnc_CodeAssist_getModule(jnc_CodeAssist* codeAssist);

jnc_ModuleItem*
jnc_CodeAssist_getModuleItem(jnc_CodeAssist* codeAssist);

jnc_Namespace*
jnc_CodeAssist_getNamespace(jnc_CodeAssist* codeAssist);

jnc_FunctionTypeOverload*
jnc_CodeAssist_getFunctionTypeOverload(jnc_CodeAssist* codeAssist);

size_t
jnc_CodeAssist_getArgumentIdx(jnc_CodeAssist* codeAssist);

void
jnc_initialize(const char* reserved);

static
jnc_DerivableType*
jnc_BaseTypeSlot_getType(jnc_BaseTypeSlot* baseType);

size_t
jnc_BaseTypeSlot_getOffset(jnc_BaseTypeSlot* baseType);

size_t
jnc_BaseTypeSlot_getVtableIndex(jnc_BaseTypeSlot* baseType);

jnc_Type*
jnc_Field_getType(jnc_Field* field);

uint_t
jnc_Field_getBitOffset(jnc_Field* field);

uint_t
jnc_Field_getBitCount(jnc_Field* field);

uint_t
jnc_Field_getPtrTypeFlags(jnc_Field* field);

size_t
jnc_Field_getOffset(jnc_Field* field);

jnc_Function*
jnc_DerivableType_getStaticConstructor(jnc_DerivableType* type);

jnc_OverloadableFunction
jnc_DerivableType_getConstructor(jnc_DerivableType* type);

jnc_Function*
jnc_DerivableType_getDestructor(jnc_DerivableType* type);

jnc_OverloadableFunction
jnc_DerivableType_getUnaryOperator(
    jnc_DerivableType* type,
    jnc_UnOpKind opKind
);

jnc_OverloadableFunction
jnc_DerivableType_getBinaryOperator(
    jnc_DerivableType* type,
    jnc_BinOpKind opKind
);

jnc_OverloadableFunction
jnc_DerivableType_getCallOperator(jnc_DerivableType* type);

size_t
jnc_DerivableType_getCastOperatorCount(jnc_DerivableType* type);

jnc_Function*
jnc_DerivableType_getCastOperator(
    jnc_DerivableType* type,
    size_t index
);

size_t
jnc_DerivableType_getBaseTypeCount(jnc_DerivableType* type);

jnc_BaseTypeSlot*
jnc_DerivableType_getBaseType(
    jnc_DerivableType* type,
    size_t index
);

size_t
jnc_DerivableType_findBaseTypeOffset(
    jnc_DerivableType* type,
    jnc_Type* baseType
);

size_t
jnc_DerivableType_getStaticVariableCount(jnc_DerivableType* type);

jnc_Variable*
jnc_DerivableType_getStaticVariable(
    jnc_DerivableType* type,
    size_t index
);

size_t
jnc_DerivableType_getFieldCount(jnc_DerivableType* type);

jnc_Field*
jnc_DerivableType_getField(
    jnc_DerivableType* type,
    size_t index
);

size_t
jnc_DerivableType_getMethodCount(jnc_DerivableType* type);

jnc_Function*
jnc_DerivableType_getMethod(
    jnc_DerivableType* type,
    size_t index
);

size_t
jnc_DerivableType_getPropertyCount(jnc_DerivableType* type);

jnc_Property*
jnc_DerivableType_getProperty(
    jnc_DerivableType* type,
    size_t index
);

static
bool_t
jnc_isConstructibleType(jnc_Type* type);

size_t
jnc_DynamicSectionGroup_getSectionCount(jnc_DynamicSectionGroup* sectionGroup);

jnc_DynamicSection*
jnc_DynamicSectionGroup_getSection(
    jnc_DynamicSectionGroup* sectionGroup,
    size_t i
);

jnc_DynamicSectionKind
jnc_DynamicSection_getSectionKind(jnc_DynamicSection* section);

size_t
jnc_DynamicSection_getOffset(jnc_DynamicSection* section);

size_t
jnc_DynamicSection_getSize(jnc_DynamicSection* section);

size_t
jnc_DynamicSection_getElementCount(jnc_DynamicSection* section);

uint_t
jnc_DynamicSection_getBitOffset(jnc_DynamicSection* section);

uint_t
jnc_DynamicSection_getBitCount(jnc_DynamicSection* section);

uint_t
jnc_DynamicSection_getPtrTypeFlags(jnc_DynamicSection* section);

jnc_Type*
jnc_DynamicSection_getType(jnc_DynamicSection* section);

jnc_ModuleItemDecl*
jnc_DynamicSection_getDecl(jnc_DynamicSection* section);

jnc_DynamicLayout*
jnc_createDynamicLayout(
    jnc_Runtime* runtime,
    uint_t mode,
    jnc_DataPtr ptr,
    size_t size
);

size_t
jnc_DynamicLayout_getSize(jnc_DynamicLayout* layout);

size_t
jnc_DynamicLayout_getBufferSize(jnc_DynamicLayout* layout);

size_t
jnc_DynamicLayout_getSizeLimit(jnc_DynamicLayout* layout);

void
jnc_DynamicLayout_setSizeLimit(
    jnc_DynamicLayout* layout,
    size_t size
);

uint_t
jnc_DynamicLayout_getMode(jnc_DynamicLayout* layout);

void
jnc_DynamicLayout_reset(
    jnc_DynamicLayout* layout,
    uint_t mode,
    jnc_DataPtr ptr,
    size_t size
);

static
void
jnc_DynamicLayout_clear(jnc_DynamicLayout* layout);

void
jnc_DynamicLayout_updateGroupSizes(jnc_DynamicLayout* layout);

int64_t
jnc_EnumConst_getValue(jnc_EnumConst* enumConst);

jnc_Type*
jnc_EnumType_getBaseType(jnc_EnumType* type);

jnc_Type*
jnc_EnumType_getRootType(jnc_EnumType* type);

size_t
jnc_EnumType_getConstCount(jnc_EnumType* type);

jnc_EnumConst*
jnc_EnumType_getConst(
    jnc_EnumType* type,
    size_t index
);

void
jnc_setErrorRouter(jnc_ErrorRouter* router);

const jnc_Error*
jnc_getLastError();

void
jnc_setError(const jnc_Error* error);

void
jnc_setErrno(int code);

void
jnc_setStringError(const char* string);

const char*
jnc_getErrorDescription_v(const jnc_Error* error);

static
const char*
jnc_getLastErrorDescription_v();

jnc_ExtensionLib*
jnc_CoreLib_getLib();

jnc_ExtensionLib*
jnc_IntrospectionLib_getLib();

jnc_ExtensionLib*
jnc_StdLib_getLib();

jnc_ExtensionLib*
jnc_SysLib_getLib();

void
jnc_StdLib_setStdIo(
    jnc_StdLib_StdInputFunc* getsFunc,
    jnc_StdLib_StdOutputFunc* printOutFunc,
    jnc_StdLib_StdOutputFunc* printErrFunc
);

const char*
jnc_getFunctionKindString(jnc_FunctionKind functionKind);

uint_t
jnc_getFunctionKindFlags(jnc_FunctionKind functionKind);

jnc_FunctionKind
jnc_Function_getFunctionKind(jnc_Function* function);

static
jnc_FunctionType*
jnc_Function_getType(jnc_Function* function);

bool_t
jnc_Function_isMember(jnc_Function* function);

bool_t
jnc_Function_isUnusedExternal(jnc_Function* function);

void*
jnc_Function_getMachineCode(jnc_Function* function);

jnc_FunctionKind
jnc_FunctionOverload_getFunctionKind(jnc_FunctionOverload* function);

size_t
jnc_FunctionOverload_getOverloadCount(jnc_FunctionOverload* function);

jnc_Function*
jnc_FunctionOverload_getOverload(
    jnc_FunctionOverload* function,
    size_t index
);

const char*
jnc_getFunctionTypeFlagString(jnc_FunctionTypeFlag flag);

const char*
jnc_getFunctionPtrTypeKindString(jnc_FunctionPtrTypeKind ptrTypeKind);

bool_t
jnc_FunctionArg_hasDefaultValue(jnc_FunctionArg* arg);

const char*
jnc_FunctionArg_getDefaultValueString_v(jnc_FunctionArg* arg);

jnc_Type*
jnc_FunctionType_getReturnType(jnc_FunctionType* type);

size_t
jnc_FunctionType_getArgCount(jnc_FunctionType* type);

jnc_FunctionArg*
jnc_FunctionType_getArg(
    jnc_FunctionType* type,
    size_t index
);

jnc_FunctionPtrType*
jnc_FunctionType_getFunctionPtrType(
    jnc_FunctionType* type,
    jnc_TypeKind typeKind,
    jnc_FunctionPtrTypeKind ptrTypeKind,
    uint_t flags
);

jnc_FunctionType*
jnc_FunctionType_getShortType(jnc_FunctionType* type);

jnc_FunctionPtrTypeKind
jnc_FunctionPtrType_getPtrTypeKind(jnc_FunctionPtrType* type);

jnc_FunctionType*
jnc_FunctionPtrType_getTargetType(jnc_FunctionPtrType* type);

size_t
jnc_FunctionTypeOverload_getOverloadCount(jnc_FunctionTypeOverload* typeOverload);

jnc_FunctionType*
jnc_FunctionTypeOverload_getOverload(
    jnc_FunctionTypeOverload* typeOverload,
    size_t index
);

static
void
jnc_GcStats_add(
    jnc_GcStats* gcStats,
    const jnc_GcStats* gcStats2
);

jnc_Runtime*
jnc_GcHeap_getRuntime(jnc_GcHeap* gcHeap);

void
jnc_GcHeap_getStats(
    jnc_GcHeap* gcHeap,
    jnc_GcStats* stats
);

void
jnc_GcHeap_getSizeTriggers(
    jnc_GcHeap* gcHeap,
    jnc_GcSizeTriggers* triggers
);

void
jnc_GcHeap_setSizeTriggers(
    jnc_GcHeap* gcHeap,
    const jnc_GcSizeTriggers* triggers
);

void
jnc_GcHeap_collect(jnc_GcHeap* gcHeap);

void
jnc_GcHeap_enterNoCollectRegion(jnc_GcHeap* gcHeap);

void
jnc_GcHeap_leaveNoCollectRegion(
    jnc_GcHeap* gcHeap,
    bool_t canCollectNow
);

void
jnc_GcHeap_enterWaitRegion(jnc_GcHeap* gcHeap);

void
jnc_GcHeap_leaveWaitRegion(jnc_GcHeap* gcHeap);

void
jnc_GcHeap_safePoint(jnc_GcHeap* gcHeap);

void
jnc_GcHeap_setFrameMap(
    jnc_GcHeap* gcHeap,
    jnc_GcShadowStackFrame* frame,
    jnc_GcShadowStackFrameMap* map,
    jnc_GcShadowStackFrameMapOp op
);

void
jnc_GcHeap_addStaticDestructor(
    jnc_GcHeap* gcHeap,
    jnc_StaticDestructFunc* destructFunc
);

void
jnc_GcHeap_addStaticClassDestructor(
    jnc_GcHeap* gcHeap,
    jnc_DestructFunc* destructFunc,
    jnc_IfaceHdr* iface
);

void
jnc_GcHeap_addStaticRoot(
    jnc_GcHeap* gcHeap,
    const void* p,
    jnc_Type* type
);

jnc_IfaceHdr*
jnc_GcHeap_allocateClass(
    jnc_GcHeap* gcHeap,
    jnc_ClassType* type
);

jnc_IfaceHdr*
jnc_GcHeap_tryAllocateClass(
    jnc_GcHeap* gcHeap,
    jnc_ClassType* type
);

jnc_DataPtr
jnc_GcHeap_allocateData(
    jnc_GcHeap* gcHeap,
    jnc_Type* type
);

jnc_DataPtr
jnc_GcHeap_tryAllocateData(
    jnc_GcHeap* gcHeap,
    jnc_Type* type
);

jnc_DataPtr
jnc_GcHeap_allocateArray(
    jnc_GcHeap* gcHeap,
    jnc_Type* type,
    size_t count
);

jnc_DataPtr
jnc_GcHeap_tryAllocateArray(
    jnc_GcHeap* gcHeap,
    jnc_Type* type,
    size_t count
);

jnc_DataPtr
jnc_GcHeap_allocateBuffer(
    jnc_GcHeap* gcHeap,
    size_t size
);

jnc_DataPtr
jnc_GcHeap_tryAllocateBuffer(
    jnc_GcHeap* gcHeap,
    size_t size
);

jnc_DataPtrValidator*
jnc_GcHeap_createDataPtrValidator(
    jnc_GcHeap* gcHeap,
    jnc_Box* box,
    const void* rangeBegin,
    size_t rangeLength
);

jnc_DetachedDataBox*
jnc_GcHeap_createForeignDataBox(
    jnc_GcHeap* gcHeap,
    jnc_Type* type,
    size_t elementCount,
    const void* p,
    bool_t isCallSiteLocal
);

jnc_DataPtr
jnc_GcHeap_createForeignBufferPtr(
    jnc_GcHeap* gcHeap,
    const void* p,
    size_t size,
    bool_t isCallSiteLocal
);

void
jnc_GcHeap_invalidateDataPtrValidator(
    jnc_GcHeap* gcHeap,
    jnc_DataPtrValidator* validator
);

static
void
jnc_GcHeap_invalidateDataPtr(
    jnc_GcHeap* gcHeap,
    jnc_DataPtr ptr
);

void
jnc_GcHeap_weakMark(
    jnc_GcHeap* gcHeap,
    jnc_Box* box
);

void
jnc_GcHeap_markData(
    jnc_GcHeap* gcHeap,
    jnc_Box* box
);

static
void
jnc_GcHeap_markDataPtr(
    jnc_GcHeap* gcHeap,
    jnc_DataPtr ptr
);

void
jnc_GcHeap_markClass(
    jnc_GcHeap* gcHeap,
    jnc_Box* box
);

static
void
jnc_GcHeap_markClassPtr(
    jnc_GcHeap* gcHeap,
    jnc_IfaceHdr* iface
);

static
void
jnc_GcHeap_markString(
    jnc_GcHeap* gcHeap,
    jnc_String string
);

void
jnc_GcHeap_markVariant(
    jnc_GcHeap* gcHeap,
    jnc_Variant variant
);

void
jnc_GcHeap_addRoot(
    jnc_GcHeap* gcHeap,
    const void* p,
    jnc_Type* type
);

void
jnc_GcHeap_addBoxToCallSite(jnc_Box* box);

jnc_Module*
jnc_Module_create();

void
jnc_Module_destroy(jnc_Module* module);

void
jnc_Module_clear(jnc_Module* module);

void
jnc_Module_unloadDynamicLibs(jnc_Module* module);

void
jnc_Module_initialize(
    jnc_Module* module,
    const char* name,
    const jnc_ModuleConfig* config
);

void
jnc_Module_updateCapabilities(jnc_Module* module);

void
jnc_Module_setDynamicExtensionAuthenticatorConfig(
    jnc_Module* module,
    const jnc_CodeAuthenticatorConfig* config
);

const char*
jnc_Module_getName(jnc_Module* module);

uint_t
jnc_Module_getCompileFlags(jnc_Module* module);

jnc_ModuleCompileState
jnc_Module_getCompileState(jnc_Module* module);

size_t
jnc_Module_getCompileErrorCountLimit(jnc_Module* module);

void
jnc_Module_setCompileErrorCountLimit(
    jnc_Module* module,
    size_t limit
);

size_t
jnc_Module_getCompileErrorCount(jnc_Module* module);

void
jnc_Module_setCompileErrorHandler(
    jnc_Module* module,
    jnc_ModuleCompileErrorHandlerFunc* handler,
    void* context
);

void
jnc_Module_setAttributeObserver(
    jnc_Module* module,
    jnc_AttributeObserverFunc* observer,
    void* context,
    uint_t itemKindMask
);

jnc_GlobalNamespace*
jnc_Module_getGlobalNamespace(jnc_Module* module);

jnc_GlobalNamespace*
jnc_Module_getStdNamespace(
    jnc_Module* module,
    jnc_StdNamespace stdNamespace
);

jnc_Type*
jnc_Module_getPrimitiveType(
    jnc_Module* module,
    jnc_TypeKind typeKind
);

jnc_Type*
jnc_Module_getStdType(
    jnc_Module* module,
    jnc_StdType stdType
);

handle_t
jnc_Module_getExtensionSourceFileIterator(jnc_Module* module);

const char*
jnc_Module_getNextExtensionSourceFile(
    jnc_Module* module,
    handle_t* iterator
);

jnc_FindModuleItemResult
jnc_Module_findExtensionLibItem(
    jnc_Module* module,
    const char* name,
    const jnc_Guid* libGuid,
    size_t itemCacheSlot
);

const char*
jnc_Module_getExtensionLibFilePath(
    jnc_Module* module,
    jnc_ExtensionLib* lib
);

bool_t
jnc_Module_mapVariable(
    jnc_Module* module,
    jnc_Variable* variable,
    void* p
);

bool_t
jnc_Module_mapFunction(
    jnc_Module* module,
    jnc_Function* function,
    void* p
);

void
jnc_Module_addSource(
    jnc_Module* module,
    jnc_ExtensionLib* lib,
    const char* fileName,
    const char* source,
    size_t length
);

handle_t
jnc_Module_getImportDirIterator(jnc_Module* module);

const char*
jnc_Module_getNextImportDir(
    jnc_Module* module,
    handle_t* iterator
);

void
jnc_Module_addImportDir(
    jnc_Module* module,
    const char* dir
);

bool_t
jnc_Module_addImport(
    jnc_Module* module,
    const char* fileName
);

void
jnc_Module_addSourceImport(
    jnc_Module* module,
    const char* fileName,
    const char* source,
    size_t length
);

void
jnc_Module_addIgnoredImport(
    jnc_Module* module,
    const char* fileName
);

void
jnc_Module_addOpaqueClassTypeInfo(
    jnc_Module* module,
    const char* qualifiedName,
    const jnc_OpaqueClassTypeInfo* info
);

void
jnc_Module_addStaticLib(
    jnc_Module* module,
    jnc_ExtensionLib* lib
);

void
jnc_Module_require(
    jnc_Module* module,
    jnc_ModuleItemKind itemKind,
    const char* name,
    uint_t flags
);

void
jnc_Module_requireType(
    jnc_Module* module,
    jnc_TypeKind typeKind,
    const char* name,
    uint_t flags
);

bool_t
jnc_Module_parse(
    jnc_Module* module,
    const char* fileName,
    const char* source,
    size_t length
);

bool_t
jnc_Module_parseFile(
    jnc_Module* module,
    const char* fileName
);

bool_t
jnc_Module_parseImports(jnc_Module* module);

bool_t
jnc_Module_compile(jnc_Module* module);

bool_t
jnc_Module_optimize(
    jnc_Module* module,
    uint_t level
);

bool_t
jnc_Module_ensureJitCreated(jnc_Module* module);

bool_t
jnc_Module_jit(jnc_Module* module);

bool_t
jnc_Module_generateDocumentation(
    jnc_Module* module,
    const char* outputDir
);

const char*
jnc_Module_getLlvmIrString_v(jnc_Module* module);

jnc_CodeAssist*
jnc_Module_generateCodeAssist(
    jnc_Module* module,
    jnc_CodeAssistKind kind,
    jnc_Module* cacheModule,
    size_t offset,
    const char* source,
    size_t length
);

void
jnc_Module_cancelCodeAssist(jnc_Module* module);

jnc_CodeAssist*
jnc_Module_getCodeAssist(jnc_Module* module);

const char*
jnc_getModuleItemKindString(jnc_ModuleItemKind itemKind);

const char*
jnc_getStorageKindString(jnc_StorageKind storageKind);

const char*
jnc_getAccessKindString(jnc_AccessKind accessKind);

const char*
jnc_ModuleItemDecl_getName(jnc_ModuleItemDecl* decl);

const char*
jnc_ModuleItemDecl_getQualifiedName(jnc_ModuleItemDecl* decl);

jnc_StorageKind
jnc_ModuleItemDecl_getStorageKind(jnc_ModuleItemDecl* decl);

jnc_AccessKind
jnc_ModuleItemDecl_getAccessKind(jnc_ModuleItemDecl* decl);

jnc_AttributeBlock*
jnc_ModuleItemDecl_getAttributeBlock(jnc_ModuleItemDecl* decl);

jnc_Attribute*
jnc_ModuleItemDecl_findAttribute(
    jnc_ModuleItemDecl* decl,
    const char* name
);

jnc_Namespace*
jnc_ModuleItemDecl_getParentNamespace(jnc_ModuleItemDecl* decl);

jnc_Unit*
jnc_ModuleItemDecl_getParentUnit(jnc_ModuleItemDecl* decl);

int
jnc_ModuleItemDecl_getLine(jnc_ModuleItemDecl* decl);

int
jnc_ModuleItemDecl_getCol(jnc_ModuleItemDecl* decl);

jnc_Module*
jnc_ModuleItem_getModule(jnc_ModuleItem* item);

jnc_ModuleItemKind
jnc_ModuleItem_getItemKind(jnc_ModuleItem* item);

uint_t
jnc_ModuleItem_getFlags(jnc_ModuleItem* item);

jnc_ModuleItemDecl*
jnc_ModuleItem_getDecl(jnc_ModuleItem* item);

jnc_Namespace*
jnc_ModuleItem_getNamespace(jnc_ModuleItem* item);

jnc_Type*
jnc_ModuleItem_getType(jnc_ModuleItem* item);

const char*
jnc_ModuleItem_getSynopsis_v(
    jnc_ModuleItem* item,
    bool_t isQualifiedName
);

const char*
jnc_getNamespaceKindString(jnc_NamespaceKind namespaceKind);

bool_t
jnc_Namespace_isReady(jnc_Namespace* nspace);

jnc_NamespaceKind
jnc_Namespace_getNamespaceKind(jnc_Namespace* nspace);

jnc_Namespace*
jnc_Namespace_getParentNamespace(jnc_Namespace* nspace);

jnc_ModuleItem*
jnc_Namespace_getParentItem(jnc_Namespace* nspace);

size_t
jnc_Namespace_getItemCount(jnc_Namespace* nspace);

jnc_ModuleItem*
jnc_Namespace_getItem(
    jnc_Namespace* nspace,
    size_t index
);

jnc_FindModuleItemResult
jnc_Namespace_findDirectChildItem(
    jnc_Namespace* nspace,
    const char* name
);

jnc_FindModuleItemResult
jnc_Namespace_findItem(
    jnc_Namespace* nspace,
    const char* name
);

jnc_FindModuleItemResult
jnc_Namespace_findItemNoParse(
    jnc_Namespace* nspace,
    const char* name
);

const char*
jnc_getUnOpKindString(jnc_UnOpKind opKind);

const char*
jnc_getBinOpKindString(jnc_BinOpKind opKind);

jnc_Promise*
jnc_createPromise(jnc_Runtime* runtime);

void
jnc_Promise_complete(
    jnc_Promise* promise,
    jnc_Variant result,
    jnc_DataPtr errorPtr
);

static
jnc_PropertyType*
jnc_Property_getType(jnc_Property* prop);

jnc_Function*
jnc_Property_getGetter(jnc_Property* prop);

jnc_OverloadableFunction
jnc_Property_getSetter(jnc_Property* prop);

const char*
jnc_getPropertyTypeFlagString(jnc_PropertyTypeFlag flag);

const char*
jnc_getPropertyPtrTypeKindString(jnc_PropertyPtrTypeKind ptrTypeKind);

jnc_Runtime*
jnc_Runtime_create();

void
jnc_Runtime_destroy(jnc_Runtime* runtime);

jnc_Module*
jnc_Runtime_getModule(jnc_Runtime* runtime);

jnc_GcHeap*
jnc_Runtime_getGcHeap(jnc_Runtime* runtime);

bool_t
jnc_Runtime_isAborted(jnc_Runtime* runtime);

bool_t
jnc_Runtime_startup(
    jnc_Runtime* runtime,
    jnc_Module* module
);

void
jnc_Runtime_shutdown(jnc_Runtime* runtime);

void
jnc_Runtime_abort(jnc_Runtime* runtime);

void
jnc_Runtime_initializeCallSite(
    jnc_Runtime* runtime,
    jnc_CallSite* callSite
);

void
jnc_Runtime_uninitializeCallSite(
    jnc_Runtime* runtime,
    jnc_CallSite* callSite
);

jnc_SjljFrame*
jnc_Runtime_setSjljFrame(
    jnc_Runtime* runtime,
    jnc_SjljFrame* frame
);

void*
jnc_Runtime_getUserData(jnc_Runtime* runtime);

void*
jnc_Runtime_setUserData(
    jnc_Runtime* runtime,
    void* data
);

jnc_Runtime*
jnc_getCurrentThreadRuntime();

static
jnc_GcHeap*
jnc_getCurrentThreadGcHeap();

jnc_Tls*
jnc_getCurrentThreadTls();

void
jnc_dynamicThrow();

void
jnc_saveSignalInfo(jnc_SjljFrame* sjljFrame);

void
jnc_primeClass(
    jnc_Box* box,
    jnc_Box* root,
    jnc_ClassType* type,
    const void* vtable
);

jnc_IfaceHdr*
jnc_strengthenClassPtr(jnc_IfaceHdr* iface);

size_t
jnc_strLen(jnc_DataPtr ptr);

jnc_DataPtr
jnc_strDup(
    const char* p,
    size_t length
);

jnc_DataPtr
jnc_strDup_w(
    const wchar_t* p,
    size_t length
);

jnc_DataPtr
jnc_strDup_utf16(
    const utf16_t* p,
    size_t length
);

jnc_String
jnc_allocateString(
    const char* p,
    size_t length
);

jnc_String
jnc_allocateString_w(
    const wchar_t* p,
    size_t length
);

jnc_String
jnc_allocateString_utf16(
    const utf16_t* p,
    size_t length
);

jnc_DataPtr
jnc_memDup(
    const void* p,
    size_t size
);

static
intptr_t
jnc_getDataPtrLeftRadius(jnc_DataPtr ptr);

static
intptr_t
jnc_getDataPtrRightRadius(jnc_DataPtr ptr);

jnc_DataPtr
jnc_limitDataPtr(
    jnc_DataPtr ptr,
    size_t length
);

jnc_DataPtrValidator*
jnc_createDataPtrValidator(
    jnc_Box* box,
    const void* rangeBegin,
    size_t rangeLength
);

jnc_DataPtr
jnc_createForeignBufferPtr(
    const void* p,
    size_t size,
    bool_t isCallSiteLocal
);

jnc_String
jnc_createForeignString(
    const char* p,
    size_t length,
    bool_t isCallSiteLocal
);

jnc_String
jnc_createForeignString_sz(
    const char* p,
    size_t length,
    bool_t isCallSiteLocal
);

jnc_StdBuffer*
jnc_createStdBuffer(jnc_Runtime* runtime);

static
size_t
jnc_StdBuffer_getSize(jnc_StdBuffer* buffer);

static
bool_t
jnc_StdBuffer_isEmpty(jnc_StdBuffer* buffer);

static
bool_t
jnc_StdBuffer_setSize(
    jnc_StdBuffer* buffer,
    size_t size
);

static
void
jnc_StdBuffer_clear(jnc_StdBuffer* buffer);

bool_t
jnc_StdBuffer_reserve(
    jnc_StdBuffer* buffer,
    size_t size
);

size_t
jnc_StdBuffer_copy(
    jnc_StdBuffer* buffer,
    const void* p,
    size_t size
);

static
size_t
jnc_StdBuffer_append(
    jnc_StdBuffer* buffer,
    const void* p,
    size_t size
);

size_t
jnc_StdBuffer_insert(
    jnc_StdBuffer* buffer,
    size_t offset,
    const void* p,
    size_t size
);

size_t
jnc_StdBuffer_remove(
    jnc_StdBuffer* buffer,
    size_t offset,
    size_t size
);

jnc_StdHashTable*
jnc_createStdHashTable(
    jnc_Runtime* runtime,
    jnc_StdHashFunc* hashFunc,
    jnc_StdIsEqualFunc* isEqualFunc
);

void
jnc_StdHashTable_clear(jnc_StdHashTable* hashTable);

jnc_StdMapEntry*
jnc_StdHashTable_find(
    jnc_StdHashTable* hashTable,
    jnc_Variant key
);

jnc_StdMapEntry*
jnc_StdHashTable_add(
    jnc_StdHashTable* hashTable,
    jnc_Variant key,
    jnc_Variant value
);

void
jnc_StdHashTable_remove(
    jnc_StdHashTable* hashTable,
    jnc_StdMapEntry* entry
);

bool_t
jnc_StdHashTable_removeKey(
    jnc_StdHashTable* hashTable,
    jnc_Variant key
);

static
jnc_StdMapEntry*
jnc_StdMapEntry_getNext(jnc_StdMapEntry* entry);

static
jnc_StdMapEntry*
jnc_StdMapEntry_getPrev(jnc_StdMapEntry* entry);

static
size_t
jnc_StdMap_getItemCount(jnc_StdMap* map);

static
bool_t
jnc_StdMap_isEmpty(jnc_StdMap* map);

static
jnc_StdMapEntry*
jnc_StdMap_getHead(jnc_StdMap* map);

static
jnc_StdMapEntry*
jnc_StdMap_getTail(jnc_StdMap* map);

jnc_StdRbTree*
jnc_createStdRbTree(
    jnc_Runtime* runtime,
    jnc_StdCmpFunc* cmpFunc
);

void
jnc_StdRbTree_clear(jnc_StdRbTree* RbTree);

jnc_StdMapEntry*
jnc_StdRbTree_find(
    jnc_StdRbTree* RbTree,
    jnc_Variant key
);

jnc_StdMapEntry*
jnc_StdRbTree_add(
    jnc_StdRbTree* RbTree,
    jnc_Variant key,
    jnc_Variant value
);

void
jnc_StdRbTree_remove(
    jnc_StdRbTree* RbTree,
    jnc_StdMapEntry* entry
);

bool_t
jnc_StdRbTree_removeKey(
    jnc_StdRbTree* RbTree,
    jnc_Variant key
);

static
bool_t
jnc_String_isEmpty(const jnc_String* string);

bool_t
jnc_String_isEqual(
    const jnc_String* string,
    const jnc_String* string2
);

bool_t
jnc_String_isEqualIgnoreCase(
    const jnc_String* string,
    const jnc_String* string2
);

int
jnc_String_cmp(
    const jnc_String* string,
    const jnc_String* string2
);

int
jnc_String_cmpIgnoreCase(
    const jnc_String* string,
    const jnc_String* string2
);

size_t
jnc_String_hash(const jnc_String* string);

size_t
jnc_String_hashIgnoreCase(const jnc_String* string);

jnc_DataPtr
jnc_String_sz(const jnc_String* string);

static
jnc_DataPtr
jnc_String_szn(const jnc_String* string);

void
jnc_String_setPtr(
    jnc_String* string,
    jnc_DataPtr ptr,
    size_t length
);

uint_t
jnc_getTypeKindFlags(jnc_TypeKind typeKind);

const char*
jnc_getPtrTypeFlagString_v(uint_t flags);

const char*
jnc_getDataPtrTypeKindString(jnc_DataPtrTypeKind ptrTypeKind);

jnc_TypeKind
jnc_Type_getTypeKind(jnc_Type* type);

static
uint_t
jnc_Type_getTypeKindFlags(jnc_Type* type);

size_t
jnc_Type_getSize(jnc_Type* type);

const char*
jnc_Type_getTypeString(jnc_Type* type);

const char*
jnc_Type_getTypeStringPrefix(jnc_Type* type);

const char*
jnc_Type_getTypeStringSuffix(jnc_Type* type);

int
jnc_Type_cmp(
    jnc_Type* type,
    jnc_Type* type2
);

jnc_ArrayType*
jnc_Type_getArrayType(
    jnc_Type* type,
    size_t elementCount
);

jnc_DataPtrType*
jnc_Type_getBitFieldDataPtrType(
    jnc_Type* type,
    uint_t bitOffset,
    uint_t bitCount,
    jnc_TypeKind typeKind,
    jnc_DataPtrTypeKind ptrTypeKind,
    uint_t flags
);

jnc_DataPtrType*
jnc_Type_getDataPtrType(
    jnc_Type* type,
    jnc_TypeKind typeKind,
    jnc_DataPtrTypeKind ptrTypeKind,
    uint_t flags
);

bool_t
jnc_Type_ensureNoImports(jnc_Type* type);

bool_t
jnc_Type_ensureLayout(jnc_Type* type);

void
jnc_Type_markGcRoots(
    jnc_Type* type,
    const void* p,
    jnc_GcHeap* gcHeap
);

jnc_DataPtrTypeKind
jnc_DataPtrType_getPtrTypeKind(jnc_DataPtrType* type);

jnc_Type*
jnc_DataPtrType_getTargetType(jnc_DataPtrType* type);

uint_t
jnc_DataPtrType_getBitOffset(jnc_DataPtrType* type);

uint_t
jnc_DataPtrType_getBitCount(jnc_DataPtrType* type);

static
bool_t
jnc_isCharPtrType(jnc_Type* type);

static
bool_t
jnc_isDerivableTypePtrType(jnc_Type* type);

static
bool_t
jnc_isArrayRefType(jnc_Type* type);

static
bool_t
jnc_isDataPtrType(
    jnc_Type* type,
    jnc_DataPtrTypeKind kind
);

jnc_ExtensionLib*
jnc_Unit_getLib(jnc_Unit* unit);

const char*
jnc_Unit_getFilePath(jnc_Unit* unit);

const char*
jnc_Unit_getFileName(jnc_Unit* unit);

const char*
jnc_Unit_getDir(jnc_Unit* unit);

uint_t
jnc_Variable_getPtrTypeFlags(jnc_Variable* variable);

bool_t
jnc_Variable_hasInitializer(jnc_Variable* variable);

const char*
jnc_Variable_getInitializerString_v(jnc_Variable* variable);

bool_t
jnc_Variant_cast(
    const jnc_Variant* variant,
    jnc_Type* type,
    void* buffer
);

bool_t
jnc_Variant_unaryOperator(
    const jnc_Variant* variant,
    jnc_UnOpKind opKind,
    jnc_Variant* result
);

bool_t
jnc_Variant_binaryOperator(
    const jnc_Variant* variant,
    const jnc_Variant* variant2,
    jnc_BinOpKind opKind,
    jnc_Variant* result
);

bool_t
jnc_Variant_relationalOperator(
    const jnc_Variant* variant,
    const jnc_Variant* variant2,
    jnc_BinOpKind opKind,
    bool_t* result
);

bool_t
jnc_Variant_getMember(
    const jnc_Variant* variant,
    const char* name,
    jnc_Variant* result
);

bool_t
jnc_Variant_setMember(
    jnc_Variant* variant,
    const char* name,
    jnc_Variant value
);

bool_t
jnc_Variant_getElement(
    const jnc_Variant* variant,
    size_t index,
    jnc_Variant* result
);

bool_t
jnc_Variant_setElement(
    jnc_Variant* variant,
    size_t index,
    jnc_Variant value
);

static
bool_t
jnc_Variant_isNull(const jnc_Variant* variant);

static
bool_t
jnc_Variant_isEqual(
    const jnc_Variant* variant,
    const jnc_Variant* variant2
);

size_t
jnc_Variant_hash(const jnc_Variant* variant);

bool_t
jnc_Variant_create(
    jnc_Variant* variant,
    const void* p,
    jnc_Type* type
);

const char*
jnc_Variant_format_v(
    const jnc_Variant* variant,
    const char* fmtSpecifier
);

// macros

#define JNC_ASSERT
#define JNC_BEGIN_CALL_SITE(runtime)
#define JNC_BEGIN_CALL_SITE_IMPL(runtime)
#define JNC_BEGIN_CLASS_TYPE_VTABLE(TypePrefix)
#define JNC_BEGIN_LIB_FUNCTION_MAP(LibPrefix)
#define JNC_BEGIN_LIB_OPAQUE_CLASS_TYPE_TABLE(LibPrefix)
#define JNC_BEGIN_LIB_SOURCE_FILE_TABLE(LibPrefix)
#define JNC_BEGIN_OPAQUE_CLASS_REQUIRE_TABLE(TypePrefix)
#define JNC_BEGIN_TYPE_FUNCTION_MAP(TypePrefix)
#define JNC_CALL_SITE_CATCH()
#define JNC_CALL_SITE_FINALLY()
#define JNC_CLASS_TYPE_VTABLE_ENTRY(function)
#define JNC_DECLARE_CLASS_TYPE(TypePrefix)
#define JNC_DECLARE_CLASS_TYPE_STATIC_METHODS(TypePrefix)
#define JNC_DECLARE_LIB(LibPrefix)
#define JNC_DECLARE_OPAQUE_CLASS_TYPE(TypePrefix)
#define JNC_DECLARE_OPAQUE_CLASS_TYPE_STATIC_METHODS(TypePrefix)
#define JNC_DECLARE_TYPE(TypePrefix)

#define JNC_DECLARE_TYPE_EX( \
    TypePrefix, \
    JncType \
)

#define JNC_DECLARE_TYPE_STATIC_METHODS(TypePrefix)

#define JNC_DECLARE_TYPE_STATIC_METHODS_EX( \
    TypePrefix, \
    JncType \
)

#define JNC_DEFINE_CLASS_TYPE( \
    TypePrefix, \
    qualifiedName, \
    libGuid, \
    cacheSlot \
)

#define JNC_DEFINE_GUID( \
    n, \
    l, \
    s1, \
    s2, \
    b1, \
    b2, \
    b3, \
    b4, \
    b5, \
    b6, \
    b7, \
    b8 \
)

#define JNC_DEFINE_LIB( \
    LibPrefix, \
    libGuid, \
    libName, \
    libDescription \
)

#define JNC_DEFINE_LIB_EX( \
    LibPrefix, \
    libGuid, \
    libName, \
    libDescription, \
    updateCapabilities \
)

#define JNC_DEFINE_OPAQUE_CLASS_TYPE( \
    TypePrefix, \
    qualifiedName, \
    libGuid, \
    cacheSlot, \
    Type, \
    markOpaqueGcRootsFunc \
)

#define JNC_DEFINE_OPAQUE_CLASS_TYPE_EX( \
    TypePrefix, \
    qualifiedName, \
    libGuid, \
    cacheSlot, \
    Type, \
    markOpaqueGcRootsFunc, \
    requireOpaqueItemsFunc, \
    isNonCreatable \
)

#define JNC_DEFINE_OPAQUE_CLASS_TYPE_NC( \
    TypePrefix, \
    qualifiedName, \
    libGuid, \
    cacheSlot, \
    Type, \
    markOpaqueGcRootsFunc \
)

#define JNC_DEFINE_OPAQUE_CLASS_TYPE_REQ( \
    TypePrefix, \
    qualifiedName, \
    libGuid, \
    cacheSlot, \
    Type, \
    markOpaqueGcRootsFunc \
)

#define JNC_DEFINE_TYPE( \
    TypePrefix, \
    qualifiedName, \
    libGuid, \
    cacheSlot \
)

#define JNC_DEFINE_TYPE_EX( \
    TypePrefix, \
    JncType, \
    qualifiedName, \
    libGuid, \
    cacheSlot \
)

#define JNC_EDIT_EXPORT
#define JNC_END_CALL_SITE()
#define JNC_END_CALL_SITE_EX(result)
#define JNC_END_CALL_SITE_IMPL()
#define JNC_END_CLASS_TYPE_VTABLE()
#define JNC_END_LIB_FUNCTION_MAP()
#define JNC_END_LIB_OPAQUE_CLASS_TYPE_TABLE()
#define JNC_END_LIB_SOURCE_FILE_TABLE()
#define JNC_END_OPAQUE_CLASS_REQUIRE_TABLE()
#define JNC_END_TYPE_FUNCTION_MAP()
#define JNC_EXTERN_C

#define JNC_FIND_ITEM_IMPL( \
    name, \
    findMethod, \
    itemKind, \
    ItemType, \
    item \
)

#define JNC_GLOBAL_NAMESPACE_DOXID
#define JNC_INLINE
#define JNC_LIB_IMPORT(fileName)
#define JNC_LIB_OPAQUE_CLASS_TYPE_TABLE_ENTRY(TypePrefix)

#define JNC_LIB_REQUIRE( \
    itemKind, \
    name \
)

#define JNC_LIB_REQUIRE_EX( \
    itemKind, \
    name, \
    flags \
)

#define JNC_LIB_REQUIRE_TYPE( \
    typeKind, \
    name \
)

#define JNC_LIB_REQUIRE_TYPE_EX( \
    typeKind, \
    name, \
    flags \
)

#define JNC_LIB_SOURCE_FILE( \
    fileName, \
    sourceVar \
)

#define JNC_MAP_AUTOGET_PROPERTY( \
    name, \
    setter \
)

#define JNC_MAP_AUTOGET_PROPERTY_IMPL( \
    name, \
    findMethod, \
    setter \
)

#define JNC_MAP_AUTOGET_PROPERTY_Q( \
    name, \
    setter \
)

#define JNC_MAP_BINARY_OPERATOR( \
    opKind, \
    p \
)

#define JNC_MAP_CALL_OPERATOR(p)

#define JNC_MAP_CAST_OPERATOR( \
    i, \
    p \
)

#define JNC_MAP_CONSTRUCTOR(p)

#define JNC_MAP_CONST_PROPERTY( \
    name, \
    getter \
)

#define JNC_MAP_CONST_PROPERTY_IMPL( \
    name, \
    findMethod, \
    getter \
)

#define JNC_MAP_CONST_PROPERTY_Q( \
    name, \
    getter \
)

#define JNC_MAP_DESTRUCTOR(p)

#define JNC_MAP_FUNCTION( \
    name, \
    p \
)

#define JNC_MAP_FUNCTION_IMPL( \
    function, \
    p \
)

#define JNC_MAP_FUNCTION_Q( \
    name, \
    p \
)

#define JNC_MAP_OVERLOAD(p)

#define JNC_MAP_OVERLOADABLE_FUNCTION( \
    item, \
    p \
)

#define JNC_MAP_PROPERTY( \
    name, \
    getter, \
    setter \
)

#define JNC_MAP_PROPERTY_GETTER( \
    prop, \
    p \
)

#define JNC_MAP_PROPERTY_IMPL( \
    name, \
    findMethod, \
    getter, \
    setter \
)

#define JNC_MAP_PROPERTY_Q( \
    name, \
    getter, \
    setter \
)

#define JNC_MAP_PROPERTY_SETTER( \
    prop, \
    p \
)

#define JNC_MAP_TYPE(TypePrefix)

#define JNC_MAP_TYPE_IMPL( \
    TypePrefix, \
    isRequired \
)

#define JNC_MAP_TYPE_REQ(TypePrefix)

#define JNC_MAP_UNARY_OPERATOR( \
    opKind, \
    p \
)

#define JNC_MAP_VARIABLE( \
    name, \
    p \
)

#define JNC_MAP_VARIABLE_IMPL( \
    name, \
    findMethod, \
    p \
)

#define JNC_MAP_VARIABLE_Q( \
    name, \
    p \
)

#define JNC_OPAQUE_CLASS_REQUIRE( \
    itemKind, \
    name \
)

#define JNC_OPAQUE_CLASS_REQUIRE_TYPE( \
    typeKind, \
    name \
)

#define JNC_PTR_BITS
#define JNC_PTR_SIZE
#define JNC_RESTORE_SJLJ_FRAME()
#define JNC_SELECT_ANY
#define _JNC_CPP_CLANG
#define _JNC_CPP_GCC
#define _JNC_CPP_MSC
#define _JNC_CPU_AMD64
#define _JNC_CPU_X86
#define _JNC_DEBUG
#define _JNC_OS_BSD
#define _JNC_OS_DARWIN
#define _JNC_OS_LINUX
#define _JNC_OS_POSIX
#define _JNC_OS_SOLARIS
#define _JNC_OS_WIN
#define __STDC_CONSTANT_MACROS
#define __STDC_LIMIT_MACROS
#define jnc_longJmp
#define jnc_pvoid_cast(x)
#define jnc_setJmp