private static extern IntPtr V8SplitProxyManaged_SetMethodTable()

in ClearScript/V8/SplitProxy/V8SplitProxyNative.Generated.cs [11019:12002]


            private static extern IntPtr V8SplitProxyManaged_SetMethodTable(
                [In] IntPtr pMethodTable
            );

            [DllImport("ClearScriptV8.linux-arm.so", CallingConvention = CallingConvention.StdCall)]
            private static extern void V8Environment_InitializeICU(
                [In] [MarshalAs(UnmanagedType.LPWStr)] string dataPath
            );

            #endregion

            #region StdString methods

            [DllImport("ClearScriptV8.linux-arm.so", CallingConvention = CallingConvention.StdCall)]
            private static extern StdString.Ptr StdString_New(
                [In] [MarshalAs(UnmanagedType.LPWStr)] string value,
                [In] int length
            );

            [DllImport("ClearScriptV8.linux-arm.so", CallingConvention = CallingConvention.StdCall)]
            private static extern IntPtr StdString_GetValue(
                [In] StdString.Ptr pString,
                [Out] out int length
            );

            [DllImport("ClearScriptV8.linux-arm.so", CallingConvention = CallingConvention.StdCall)]
            private static extern void StdString_SetValue(
                [In] StdString.Ptr pString,
                [In] [MarshalAs(UnmanagedType.LPWStr)] string value,
                [In] int length
            );

            [DllImport("ClearScriptV8.linux-arm.so", CallingConvention = CallingConvention.StdCall)]
            private static extern void StdString_Delete(
                [In] StdString.Ptr pString
            );

            #endregion

            #region StdStringArray methods

            [DllImport("ClearScriptV8.linux-arm.so", CallingConvention = CallingConvention.StdCall)]
            private static extern StdStringArray.Ptr StdStringArray_New(
                [In] int elementCount
            );

            [DllImport("ClearScriptV8.linux-arm.so", CallingConvention = CallingConvention.StdCall)]
            private static extern int StdStringArray_GetElementCount(
                [In] StdStringArray.Ptr pArray
            );

            [DllImport("ClearScriptV8.linux-arm.so", CallingConvention = CallingConvention.StdCall)]
            private static extern void StdStringArray_SetElementCount(
                [In] StdStringArray.Ptr pArray,
                [In] int elementCount
            );

            [DllImport("ClearScriptV8.linux-arm.so", CallingConvention = CallingConvention.StdCall)]
            private static extern IntPtr StdStringArray_GetElement(
                [In] StdStringArray.Ptr pArray,
                [In] int index,
                [Out] out int length
            );

            [DllImport("ClearScriptV8.linux-arm.so", CallingConvention = CallingConvention.StdCall)]
            private static extern void StdStringArray_SetElement(
                [In] StdStringArray.Ptr pArray,
                [In] int index,
                [In] [MarshalAs(UnmanagedType.LPWStr)] string value,
                [In] int length
            );

            [DllImport("ClearScriptV8.linux-arm.so", CallingConvention = CallingConvention.StdCall)]
            private static extern void StdStringArray_Delete(
                [In] StdStringArray.Ptr pArray
            );

            #endregion

            #region StdByteArray methods

            [DllImport("ClearScriptV8.linux-arm.so", CallingConvention = CallingConvention.StdCall)]
            private static extern StdByteArray.Ptr StdByteArray_New(
                [In] int elementCount
            );

            [DllImport("ClearScriptV8.linux-arm.so", CallingConvention = CallingConvention.StdCall)]
            private static extern int StdByteArray_GetElementCount(
                [In] StdByteArray.Ptr pArray
            );

            [DllImport("ClearScriptV8.linux-arm.so", CallingConvention = CallingConvention.StdCall)]
            private static extern void StdByteArray_SetElementCount(
                [In] StdByteArray.Ptr pArray,
                [In] int elementCount
            );

            [DllImport("ClearScriptV8.linux-arm.so", CallingConvention = CallingConvention.StdCall)]
            private static extern IntPtr StdByteArray_GetData(
                [In] StdByteArray.Ptr pArray
            );

            [DllImport("ClearScriptV8.linux-arm.so", CallingConvention = CallingConvention.StdCall)]
            private static extern void StdByteArray_Delete(
                [In] StdByteArray.Ptr pArray
            );

            #endregion

            #region StdInt32Array methods

            [DllImport("ClearScriptV8.linux-arm.so", CallingConvention = CallingConvention.StdCall)]
            private static extern StdInt32Array.Ptr StdInt32Array_New(
                [In] int elementCount
            );

            [DllImport("ClearScriptV8.linux-arm.so", CallingConvention = CallingConvention.StdCall)]
            private static extern int StdInt32Array_GetElementCount(
                [In] StdInt32Array.Ptr pArray
            );

            [DllImport("ClearScriptV8.linux-arm.so", CallingConvention = CallingConvention.StdCall)]
            private static extern void StdInt32Array_SetElementCount(
                [In] StdInt32Array.Ptr pArray,
                [In] int elementCount
            );

            [DllImport("ClearScriptV8.linux-arm.so", CallingConvention = CallingConvention.StdCall)]
            private static extern IntPtr StdInt32Array_GetData(
                [In] StdInt32Array.Ptr pArray
            );

            [DllImport("ClearScriptV8.linux-arm.so", CallingConvention = CallingConvention.StdCall)]
            private static extern void StdInt32Array_Delete(
                [In] StdInt32Array.Ptr pArray
            );

            #endregion

            #region StdUInt32Array methods

            [DllImport("ClearScriptV8.linux-arm.so", CallingConvention = CallingConvention.StdCall)]
            private static extern StdUInt32Array.Ptr StdUInt32Array_New(
                [In] int elementCount
            );

            [DllImport("ClearScriptV8.linux-arm.so", CallingConvention = CallingConvention.StdCall)]
            private static extern int StdUInt32Array_GetElementCount(
                [In] StdUInt32Array.Ptr pArray
            );

            [DllImport("ClearScriptV8.linux-arm.so", CallingConvention = CallingConvention.StdCall)]
            private static extern void StdUInt32Array_SetElementCount(
                [In] StdUInt32Array.Ptr pArray,
                [In] int elementCount
            );

            [DllImport("ClearScriptV8.linux-arm.so", CallingConvention = CallingConvention.StdCall)]
            private static extern IntPtr StdUInt32Array_GetData(
                [In] StdUInt32Array.Ptr pArray
            );

            [DllImport("ClearScriptV8.linux-arm.so", CallingConvention = CallingConvention.StdCall)]
            private static extern void StdUInt32Array_Delete(
                [In] StdUInt32Array.Ptr pArray
            );

            #endregion

            #region StdUInt64Array methods

            [DllImport("ClearScriptV8.linux-arm.so", CallingConvention = CallingConvention.StdCall)]
            private static extern StdUInt64Array.Ptr StdUInt64Array_New(
                [In] int elementCount
            );

            [DllImport("ClearScriptV8.linux-arm.so", CallingConvention = CallingConvention.StdCall)]
            private static extern int StdUInt64Array_GetElementCount(
                [In] StdUInt64Array.Ptr pArray
            );

            [DllImport("ClearScriptV8.linux-arm.so", CallingConvention = CallingConvention.StdCall)]
            private static extern void StdUInt64Array_SetElementCount(
                [In] StdUInt64Array.Ptr pArray,
                [In] int elementCount
            );

            [DllImport("ClearScriptV8.linux-arm.so", CallingConvention = CallingConvention.StdCall)]
            private static extern IntPtr StdUInt64Array_GetData(
                [In] StdUInt64Array.Ptr pArray
            );

            [DllImport("ClearScriptV8.linux-arm.so", CallingConvention = CallingConvention.StdCall)]
            private static extern void StdUInt64Array_Delete(
                [In] StdUInt64Array.Ptr pArray
            );

            #endregion

            #region StdPtrArray methods

            [DllImport("ClearScriptV8.linux-arm.so", CallingConvention = CallingConvention.StdCall)]
            private static extern StdPtrArray.Ptr StdPtrArray_New(
                [In] int elementCount
            );

            [DllImport("ClearScriptV8.linux-arm.so", CallingConvention = CallingConvention.StdCall)]
            private static extern int StdPtrArray_GetElementCount(
                [In] StdPtrArray.Ptr pArray
            );

            [DllImport("ClearScriptV8.linux-arm.so", CallingConvention = CallingConvention.StdCall)]
            private static extern void StdPtrArray_SetElementCount(
                [In] StdPtrArray.Ptr pArray,
                [In] int elementCount
            );

            [DllImport("ClearScriptV8.linux-arm.so", CallingConvention = CallingConvention.StdCall)]
            private static extern IntPtr StdPtrArray_GetData(
                [In] StdPtrArray.Ptr pArray
            );

            [DllImport("ClearScriptV8.linux-arm.so", CallingConvention = CallingConvention.StdCall)]
            private static extern void StdPtrArray_Delete(
                [In] StdPtrArray.Ptr pArray
            );

            #endregion

            #region StdV8ValueArray methods

            [DllImport("ClearScriptV8.linux-arm.so", CallingConvention = CallingConvention.StdCall)]
            private static extern StdV8ValueArray.Ptr StdV8ValueArray_New(
                [In] int elementCount
            );

            [DllImport("ClearScriptV8.linux-arm.so", CallingConvention = CallingConvention.StdCall)]
            private static extern int StdV8ValueArray_GetElementCount(
                [In] StdV8ValueArray.Ptr pArray
            );

            [DllImport("ClearScriptV8.linux-arm.so", CallingConvention = CallingConvention.StdCall)]
            private static extern void StdV8ValueArray_SetElementCount(
                [In] StdV8ValueArray.Ptr pArray,
                [In] int elementCount
            );

            [DllImport("ClearScriptV8.linux-arm.so", CallingConvention = CallingConvention.StdCall)]
            private static extern V8Value.Ptr StdV8ValueArray_GetData(
                [In] StdV8ValueArray.Ptr pArray
            );

            [DllImport("ClearScriptV8.linux-arm.so", CallingConvention = CallingConvention.StdCall)]
            private static extern void StdV8ValueArray_Delete(
                [In] StdV8ValueArray.Ptr pArray
            );

            #endregion

            #region V8Value methods

            [DllImport("ClearScriptV8.linux-arm.so", CallingConvention = CallingConvention.StdCall)]
            private static extern V8Value.Ptr V8Value_New();

            [DllImport("ClearScriptV8.linux-arm.so", CallingConvention = CallingConvention.StdCall)]
            private static extern void V8Value_SetNonexistent(
                [In] V8Value.Ptr pV8Value
            );

            [DllImport("ClearScriptV8.linux-arm.so", CallingConvention = CallingConvention.StdCall)]
            private static extern void V8Value_SetUndefined(
                [In] V8Value.Ptr pV8Value
            );

            [DllImport("ClearScriptV8.linux-arm.so", CallingConvention = CallingConvention.StdCall)]
            private static extern void V8Value_SetNull(
                [In] V8Value.Ptr pV8Value
            );

            [DllImport("ClearScriptV8.linux-arm.so", CallingConvention = CallingConvention.StdCall)]
            private static extern void V8Value_SetBoolean(
                [In] V8Value.Ptr pV8Value,
                [In] [MarshalAs(UnmanagedType.I1)] bool value
            );

            [DllImport("ClearScriptV8.linux-arm.so", CallingConvention = CallingConvention.StdCall)]
            private static extern void V8Value_SetNumber(
                [In] V8Value.Ptr pV8Value,
                [In] double value
            );

            [DllImport("ClearScriptV8.linux-arm.so", CallingConvention = CallingConvention.StdCall)]
            private static extern void V8Value_SetInt32(
                [In] V8Value.Ptr pV8Value,
                [In] int value
            );

            [DllImport("ClearScriptV8.linux-arm.so", CallingConvention = CallingConvention.StdCall)]
            private static extern void V8Value_SetUInt32(
                [In] V8Value.Ptr pV8Value,
                [In] uint value
            );

            [DllImport("ClearScriptV8.linux-arm.so", CallingConvention = CallingConvention.StdCall)]
            private static extern void V8Value_SetString(
                [In] V8Value.Ptr pV8Value,
                [In] [MarshalAs(UnmanagedType.LPWStr)] string value,
                [In] int length
            );

            [DllImport("ClearScriptV8.linux-arm.so", CallingConvention = CallingConvention.StdCall)]
            private static extern void V8Value_SetDateTime(
                [In] V8Value.Ptr pV8Value,
                [In] double value
            );

            [DllImport("ClearScriptV8.linux-arm.so", CallingConvention = CallingConvention.StdCall)]
            private static extern void V8Value_SetBigInt(
                [In] V8Value.Ptr pV8Value,
                [In] int signBit,
                [In] [MarshalAs(UnmanagedType.LPArray)] byte[] bytes,
                [In] int length
            );

            [DllImport("ClearScriptV8.linux-arm.so", CallingConvention = CallingConvention.StdCall)]
            private static extern void V8Value_SetV8Object(
                [In] V8Value.Ptr pV8Value,
                [In] V8Object.Handle hObject,
                [In] V8Value.Subtype subtype,
                [In] V8Value.Flags flags
            );

            [DllImport("ClearScriptV8.linux-arm.so", CallingConvention = CallingConvention.StdCall)]
            private static extern void V8Value_SetHostObject(
                [In] V8Value.Ptr pV8Value,
                [In] IntPtr pObject
            );

            [DllImport("ClearScriptV8.linux-arm.so", CallingConvention = CallingConvention.StdCall)]
            private static extern V8Value.Type V8Value_Decode(
                [In] V8Value.Ptr pV8Value,
                [Out] out int intValue,
                [Out] out uint uintValue,
                [Out] out double doubleValue,
                [Out] out IntPtr ptrOrHandle
            );

            [DllImport("ClearScriptV8.linux-arm.so", CallingConvention = CallingConvention.StdCall)]
            private static extern void V8Value_Delete(
                [In] V8Value.Ptr pV8Value
            );

            #endregion

            #region V8CpuProfile methods

            [DllImport("ClearScriptV8.linux-arm.so", CallingConvention = CallingConvention.StdCall)]
            private static extern void V8CpuProfile_GetInfo(
                [In] V8CpuProfile.Ptr pProfile,
                [In] V8Entity.Handle hEntity,
                [In] StdString.Ptr pName,
                [Out] out ulong startTimestamp,
                [Out] out ulong endTimestamp,
                [Out] out int sampleCount,
                [Out] out V8CpuProfile.Node.Ptr pRootNode
            );

            [DllImport("ClearScriptV8.linux-arm.so", CallingConvention = CallingConvention.StdCall)]
            [return: MarshalAs(UnmanagedType.I1)]
            private static extern bool V8CpuProfile_GetSample(
                [In] V8CpuProfile.Ptr pProfile,
                [In] int index,
                [Out] out ulong nodeId,
                [Out] out ulong timestamp
            );

            [DllImport("ClearScriptV8.linux-arm.so", CallingConvention = CallingConvention.StdCall)]
            private static extern void V8CpuProfileNode_GetInfo(
                [In] V8CpuProfile.Node.Ptr pNode,
                [In] V8Entity.Handle hEntity,
                [Out] out ulong nodeId,
                [Out] out long scriptId,
                [In] StdString.Ptr pScriptName,
                [In] StdString.Ptr pFunctionName,
                [In] StdString.Ptr pBailoutReason,
                [Out] out long lineNumber,
                [Out] out long columnNumber,
                [Out] out ulong hitCount,
                [Out] out uint hitLineCount,
                [Out] out int childCount
            );

            [DllImport("ClearScriptV8.linux-arm.so", CallingConvention = CallingConvention.StdCall)]
            [return: MarshalAs(UnmanagedType.I1)]
            private static extern bool V8CpuProfileNode_GetHitLines(
                [In] V8CpuProfile.Node.Ptr pNode,
                [In] StdInt32Array.Ptr pLineNumbers,
                [In] StdUInt32Array.Ptr pHitCounts
            );

            [DllImport("ClearScriptV8.linux-arm.so", CallingConvention = CallingConvention.StdCall)]
            private static extern V8CpuProfile.Node.Ptr V8CpuProfileNode_GetChildNode(
                [In] V8CpuProfile.Node.Ptr pNode,
                [In] int index
            );

            #endregion

            #region V8 isolate methods

            [DllImport("ClearScriptV8.linux-arm.so", CallingConvention = CallingConvention.StdCall)]
            private static extern V8Isolate.Handle V8Isolate_Create(
                [In] StdString.Ptr pName,
                [In] int maxNewSpaceSize,
                [In] int maxOldSpaceSize,
                [In] double heapExpansionMultiplier,
                [In] ulong maxArrayBufferAllocation,
                [In] [MarshalAs(UnmanagedType.I1)] bool enableDebugging,
                [In] [MarshalAs(UnmanagedType.I1)] bool enableRemoteDebugging,
                [In] [MarshalAs(UnmanagedType.I1)] bool enableDynamicModuleImports,
                [In] int debugPort
            );

            [DllImport("ClearScriptV8.linux-arm.so", CallingConvention = CallingConvention.StdCall)]
            private static extern V8Context.Handle V8Isolate_CreateContext(
                [In] V8Isolate.Handle hIsolate,
                [In] StdString.Ptr pName,
                [In] [MarshalAs(UnmanagedType.I1)] bool enableDebugging,
                [In] [MarshalAs(UnmanagedType.I1)] bool enableRemoteDebugging,
                [In] [MarshalAs(UnmanagedType.I1)] bool disableGlobalMembers,
                [In] [MarshalAs(UnmanagedType.I1)] bool enableDateTimeConversion,
                [In] [MarshalAs(UnmanagedType.I1)] bool enableDynamicModuleImports,
                [In] int debugPort
            );

            [DllImport("ClearScriptV8.linux-arm.so", CallingConvention = CallingConvention.StdCall)]
            private static extern UIntPtr V8Isolate_GetMaxHeapSize(
                [In] V8Isolate.Handle hIsolate
            );

            [DllImport("ClearScriptV8.linux-arm.so", CallingConvention = CallingConvention.StdCall)]
            private static extern void V8Isolate_SetMaxHeapSize(
                [In] V8Isolate.Handle hIsolate,
                [In] UIntPtr size
            );

            [DllImport("ClearScriptV8.linux-arm.so", CallingConvention = CallingConvention.StdCall)]
            private static extern double V8Isolate_GetHeapSizeSampleInterval(
                [In] V8Isolate.Handle hIsolate
            );

            [DllImport("ClearScriptV8.linux-arm.so", CallingConvention = CallingConvention.StdCall)]
            private static extern void V8Isolate_SetHeapSizeSampleInterval(
                [In] V8Isolate.Handle hIsolate,
                [In] double milliseconds
            );

            [DllImport("ClearScriptV8.linux-arm.so", CallingConvention = CallingConvention.StdCall)]
            private static extern UIntPtr V8Isolate_GetMaxStackUsage(
                [In] V8Isolate.Handle hIsolate
            );

            [DllImport("ClearScriptV8.linux-arm.so", CallingConvention = CallingConvention.StdCall)]
            private static extern void V8Isolate_SetMaxStackUsage(
                [In] V8Isolate.Handle hIsolate,
                [In] UIntPtr size
            );

            [DllImport("ClearScriptV8.linux-arm.so", CallingConvention = CallingConvention.StdCall)]
            private static extern void V8Isolate_AwaitDebuggerAndPause(
                [In] V8Isolate.Handle hIsolate
            );

            [DllImport("ClearScriptV8.linux-arm.so", CallingConvention = CallingConvention.StdCall)]
            private static extern void V8Isolate_CancelAwaitDebugger(
                [In] V8Isolate.Handle hIsolate
            );

            [DllImport("ClearScriptV8.linux-arm.so", CallingConvention = CallingConvention.StdCall)]
            private static extern V8Script.Handle V8Isolate_Compile(
                [In] V8Isolate.Handle hIsolate,
                [In] StdString.Ptr pResourceName,
                [In] StdString.Ptr pSourceMapUrl,
                [In] ulong uniqueId,
                [In] [MarshalAs(UnmanagedType.I1)] bool isModule,
                [In] IntPtr pDocumentInfo,
                [In] StdString.Ptr pCode
            );

            [DllImport("ClearScriptV8.linux-arm.so", CallingConvention = CallingConvention.StdCall)]
            private static extern V8Script.Handle V8Isolate_CompileProducingCache(
                [In] V8Isolate.Handle hIsolate,
                [In] StdString.Ptr pResourceName,
                [In] StdString.Ptr pSourceMapUrl,
                [In] ulong uniqueId,
                [In] [MarshalAs(UnmanagedType.I1)] bool isModule,
                [In] IntPtr pDocumentInfo,
                [In] StdString.Ptr pCode,
                [In] V8CacheKind cacheKind,
                [In] StdByteArray.Ptr pCacheBytes
            );

            [DllImport("ClearScriptV8.linux-arm.so", CallingConvention = CallingConvention.StdCall)]
            private static extern V8Script.Handle V8Isolate_CompileConsumingCache(
                [In] V8Isolate.Handle hIsolate,
                [In] StdString.Ptr pResourceName,
                [In] StdString.Ptr pSourceMapUrl,
                [In] ulong uniqueId,
                [In] [MarshalAs(UnmanagedType.I1)] bool isModule,
                [In] IntPtr pDocumentInfo,
                [In] StdString.Ptr pCode,
                [In] V8CacheKind cacheKind,
                [In] StdByteArray.Ptr pCacheBytes,
                [Out] [MarshalAs(UnmanagedType.I1)] out bool cacheAccepted
            );

            [DllImport("ClearScriptV8.linux-arm.so", CallingConvention = CallingConvention.StdCall)]
            [return: MarshalAs(UnmanagedType.I1)]
            private static extern bool V8Isolate_GetEnableInterruptPropagation(
                [In] V8Isolate.Handle hIsolate
            );

            [DllImport("ClearScriptV8.linux-arm.so", CallingConvention = CallingConvention.StdCall)]
            private static extern void V8Isolate_SetEnableInterruptPropagation(
                [In] V8Isolate.Handle hIsolate,
                [In] [MarshalAs(UnmanagedType.I1)] bool value
            );

            [DllImport("ClearScriptV8.linux-arm.so", CallingConvention = CallingConvention.StdCall)]
            private static extern void V8Isolate_GetHeapStatistics(
                [In] V8Isolate.Handle hIsolate,
                [Out] out ulong totalHeapSize,
                [Out] out ulong totalHeapSizeExecutable,
                [Out] out ulong totalPhysicalSize,
                [Out] out ulong usedHeapSize,
                [Out] out ulong heapSizeLimit
            );

            [DllImport("ClearScriptV8.linux-arm.so", CallingConvention = CallingConvention.StdCall)]
            private static extern void V8Isolate_GetStatistics(
                [In] V8Isolate.Handle hIsolate,
                [Out] out ulong scriptCount,
                [Out] out ulong scriptCacheSize,
                [Out] out ulong moduleCount,
                [In] StdUInt64Array.Ptr pPostedTaskCounts,
                [In] StdUInt64Array.Ptr pInvokedTaskCounts
            );

            [DllImport("ClearScriptV8.linux-arm.so", CallingConvention = CallingConvention.StdCall)]
            private static extern void V8Isolate_CollectGarbage(
                [In] V8Isolate.Handle hIsolate,
                [In] [MarshalAs(UnmanagedType.I1)] bool exhaustive
            );

            [DllImport("ClearScriptV8.linux-arm.so", CallingConvention = CallingConvention.StdCall)]
            [return: MarshalAs(UnmanagedType.I1)]
            private static extern bool V8Isolate_BeginCpuProfile(
                [In] V8Isolate.Handle hIsolate,
                [In] StdString.Ptr pName,
                [In] [MarshalAs(UnmanagedType.I1)] bool recordSamples
            );

            [DllImport("ClearScriptV8.linux-arm.so", CallingConvention = CallingConvention.StdCall)]
            private static extern void V8Isolate_EndCpuProfile(
                [In] V8Isolate.Handle hIsolate,
                [In] StdString.Ptr pName,
                [In] IntPtr pAction
            );

            [DllImport("ClearScriptV8.linux-arm.so", CallingConvention = CallingConvention.StdCall)]
            private static extern void V8Isolate_CollectCpuProfileSample(
                [In] V8Isolate.Handle hIsolate
            );

            [DllImport("ClearScriptV8.linux-arm.so", CallingConvention = CallingConvention.StdCall)]
            private static extern uint V8Isolate_GetCpuProfileSampleInterval(
                [In] V8Isolate.Handle hIsolate
            );

            [DllImport("ClearScriptV8.linux-arm.so", CallingConvention = CallingConvention.StdCall)]
            private static extern void V8Isolate_SetCpuProfileSampleInterval(
                [In] V8Isolate.Handle hIsolate,
                [In] uint value
            );

            [DllImport("ClearScriptV8.linux-arm.so", CallingConvention = CallingConvention.StdCall)]
            private static extern void V8Isolate_WriteHeapSnapshot(
                [In] V8Isolate.Handle hIsolate,
                [In] IntPtr pStream
            );

            #endregion

            #region V8 context methods

            [DllImport("ClearScriptV8.linux-arm.so", CallingConvention = CallingConvention.StdCall)]
            private static extern UIntPtr V8Context_GetMaxIsolateHeapSize(
                [In] V8Context.Handle hContext
            );

            [DllImport("ClearScriptV8.linux-arm.so", CallingConvention = CallingConvention.StdCall)]
            private static extern void V8Context_SetMaxIsolateHeapSize(
                [In] V8Context.Handle hContext,
                [In] UIntPtr size
            );

            [DllImport("ClearScriptV8.linux-arm.so", CallingConvention = CallingConvention.StdCall)]
            private static extern double V8Context_GetIsolateHeapSizeSampleInterval(
                [In] V8Context.Handle hContext
            );

            [DllImport("ClearScriptV8.linux-arm.so", CallingConvention = CallingConvention.StdCall)]
            private static extern void V8Context_SetIsolateHeapSizeSampleInterval(
                [In] V8Context.Handle hContext,
                [In] double milliseconds
            );

            [DllImport("ClearScriptV8.linux-arm.so", CallingConvention = CallingConvention.StdCall)]
            private static extern UIntPtr V8Context_GetMaxIsolateStackUsage(
                [In] V8Context.Handle hContext
            );

            [DllImport("ClearScriptV8.linux-arm.so", CallingConvention = CallingConvention.StdCall)]
            private static extern void V8Context_SetMaxIsolateStackUsage(
                [In] V8Context.Handle hContext,
                [In] UIntPtr size
            );

            [DllImport("ClearScriptV8.linux-arm.so", CallingConvention = CallingConvention.StdCall)]
            private static extern void V8Context_InvokeWithLock(
                [In] V8Context.Handle hContext,
                [In] IntPtr pAction
            );

            [DllImport("ClearScriptV8.linux-arm.so", CallingConvention = CallingConvention.StdCall)]
            private static extern void V8Context_GetRootItem(
                [In] V8Context.Handle hContext,
                [In] V8Value.Ptr pItem
            );

            [DllImport("ClearScriptV8.linux-arm.so", CallingConvention = CallingConvention.StdCall)]
            private static extern void V8Context_AddGlobalItem(
                [In] V8Context.Handle hContext,
                [In] StdString.Ptr pName,
                [In] V8Value.Ptr pValue,
                [In] [MarshalAs(UnmanagedType.I1)] bool globalMembers
            );

            [DllImport("ClearScriptV8.linux-arm.so", CallingConvention = CallingConvention.StdCall)]
            private static extern void V8Context_AwaitDebuggerAndPause(
                [In] V8Context.Handle hContext
            );

            [DllImport("ClearScriptV8.linux-arm.so", CallingConvention = CallingConvention.StdCall)]
            private static extern void V8Context_CancelAwaitDebugger(
                [In] V8Context.Handle hContext
            );

            [DllImport("ClearScriptV8.linux-arm.so", CallingConvention = CallingConvention.StdCall)]
            private static extern void V8Context_ExecuteCode(
                [In] V8Context.Handle hContext,
                [In] StdString.Ptr pResourceName,
                [In] StdString.Ptr pSourceMapUrl,
                [In] ulong uniqueId,
                [In] [MarshalAs(UnmanagedType.I1)] bool isModule,
                [In] IntPtr pDocumentInfo,
                [In] StdString.Ptr pCode,
                [In] [MarshalAs(UnmanagedType.I1)] bool evaluate,
                [In] V8Value.Ptr pResult
            );

            [DllImport("ClearScriptV8.linux-arm.so", CallingConvention = CallingConvention.StdCall)]
            private static extern V8Script.Handle V8Context_Compile(
                [In] V8Context.Handle hContext,
                [In] StdString.Ptr pResourceName,
                [In] StdString.Ptr pSourceMapUrl,
                [In] ulong uniqueId,
                [In] [MarshalAs(UnmanagedType.I1)] bool isModule,
                [In] IntPtr pDocumentInfo,
                [In] StdString.Ptr pCode
            );

            [DllImport("ClearScriptV8.linux-arm.so", CallingConvention = CallingConvention.StdCall)]
            private static extern V8Script.Handle V8Context_CompileProducingCache(
                [In] V8Context.Handle hContext,
                [In] StdString.Ptr pResourceName,
                [In] StdString.Ptr pSourceMapUrl,
                [In] ulong uniqueId,
                [In] [MarshalAs(UnmanagedType.I1)] bool isModule,
                [In] IntPtr pDocumentInfo,
                [In] StdString.Ptr pCode,
                [In] V8CacheKind cacheKind,
                [In] StdByteArray.Ptr pCacheBytes
            );

            [DllImport("ClearScriptV8.linux-arm.so", CallingConvention = CallingConvention.StdCall)]
            private static extern V8Script.Handle V8Context_CompileConsumingCache(
                [In] V8Context.Handle hContext,
                [In] StdString.Ptr pResourceName,
                [In] StdString.Ptr pSourceMapUrl,
                [In] ulong uniqueId,
                [In] [MarshalAs(UnmanagedType.I1)] bool isModule,
                [In] IntPtr pDocumentInfo,
                [In] StdString.Ptr pCode,
                [In] V8CacheKind cacheKind,
                [In] StdByteArray.Ptr pCacheBytes,
                [Out] [MarshalAs(UnmanagedType.I1)] out bool cacheAccepted
            );

            [DllImport("ClearScriptV8.linux-arm.so", CallingConvention = CallingConvention.StdCall)]
            private static extern void V8Context_ExecuteScript(
                [In] V8Context.Handle hContext,
                [In] V8Script.Handle hScript,
                [In] [MarshalAs(UnmanagedType.I1)] bool evaluate,
                [In] V8Value.Ptr pResult
            );

            [DllImport("ClearScriptV8.linux-arm.so", CallingConvention = CallingConvention.StdCall)]
            private static extern void V8Context_Interrupt(
                [In] V8Context.Handle hContext
            );

            [DllImport("ClearScriptV8.linux-arm.so", CallingConvention = CallingConvention.StdCall)]
            private static extern void V8Context_CancelInterrupt(
                [In] V8Context.Handle hContext
            );

            [DllImport("ClearScriptV8.linux-arm.so", CallingConvention = CallingConvention.StdCall)]
            [return: MarshalAs(UnmanagedType.I1)]
            private static extern bool V8Context_GetEnableIsolateInterruptPropagation(
                [In] V8Context.Handle hContext
            );

            [DllImport("ClearScriptV8.linux-arm.so", CallingConvention = CallingConvention.StdCall)]
            private static extern void V8Context_SetEnableIsolateInterruptPropagation(
                [In] V8Context.Handle hContext,
                [In] [MarshalAs(UnmanagedType.I1)] bool value
            );

            [DllImport("ClearScriptV8.linux-arm.so", CallingConvention = CallingConvention.StdCall)]
            private static extern void V8Context_GetIsolateHeapStatistics(
                [In] V8Context.Handle hContext,
                [Out] out ulong totalHeapSize,
                [Out] out ulong totalHeapSizeExecutable,
                [Out] out ulong totalPhysicalSize,
                [Out] out ulong usedHeapSize,
                [Out] out ulong heapSizeLimit
            );

            [DllImport("ClearScriptV8.linux-arm.so", CallingConvention = CallingConvention.StdCall)]
            private static extern void V8Context_GetIsolateStatistics(
                [In] V8Context.Handle hContext,
                [Out] out ulong scriptCount,
                [Out] out ulong scriptCacheSize,
                [Out] out ulong moduleCount,
                [In] StdUInt64Array.Ptr pPostedTaskCounts,
                [In] StdUInt64Array.Ptr pInvokedTaskCounts
            );

            [DllImport("ClearScriptV8.linux-arm.so", CallingConvention = CallingConvention.StdCall)]
            private static extern void V8Context_GetStatistics(
                [In] V8Context.Handle hContext,
                [Out] out ulong scriptCount,
                [Out] out ulong moduleCount,
                [Out] out ulong moduleCacheSize
            );

            [DllImport("ClearScriptV8.linux-arm.so", CallingConvention = CallingConvention.StdCall)]
            private static extern void V8Context_CollectGarbage(
                [In] V8Context.Handle hContext,
                [In] [MarshalAs(UnmanagedType.I1)] bool exhaustive
            );

            [DllImport("ClearScriptV8.linux-arm.so", CallingConvention = CallingConvention.StdCall)]
            private static extern void V8Context_OnAccessSettingsChanged(
                [In] V8Context.Handle hContext
            );

            [DllImport("ClearScriptV8.linux-arm.so", CallingConvention = CallingConvention.StdCall)]
            [return: MarshalAs(UnmanagedType.I1)]
            private static extern bool V8Context_BeginCpuProfile(
                [In] V8Context.Handle hContext,
                [In] StdString.Ptr pName,
                [In] [MarshalAs(UnmanagedType.I1)] bool recordSamples
            );

            [DllImport("ClearScriptV8.linux-arm.so", CallingConvention = CallingConvention.StdCall)]
            private static extern void V8Context_EndCpuProfile(
                [In] V8Context.Handle hContext,
                [In] StdString.Ptr pName,
                [In] IntPtr pAction
            );

            [DllImport("ClearScriptV8.linux-arm.so", CallingConvention = CallingConvention.StdCall)]
            private static extern void V8Context_CollectCpuProfileSample(
                [In] V8Context.Handle hContext
            );

            [DllImport("ClearScriptV8.linux-arm.so", CallingConvention = CallingConvention.StdCall)]
            private static extern uint V8Context_GetCpuProfileSampleInterval(
                [In] V8Context.Handle hContext
            );

            [DllImport("ClearScriptV8.linux-arm.so", CallingConvention = CallingConvention.StdCall)]
            private static extern void V8Context_SetCpuProfileSampleInterval(
                [In] V8Context.Handle hContext,
                [In] uint value
            );

            [DllImport("ClearScriptV8.linux-arm.so", CallingConvention = CallingConvention.StdCall)]
            private static extern void V8Context_WriteIsolateHeapSnapshot(
                [In] V8Context.Handle hContext,
                [In] IntPtr pStream
            );

            #endregion

            #region V8 object methods

            [DllImport("ClearScriptV8.linux-arm.so", CallingConvention = CallingConvention.StdCall)]
            private static extern void V8Object_GetNamedProperty(
                [In] V8Object.Handle hObject,
                [In] StdString.Ptr pName,
                [In] V8Value.Ptr pValue
            );

            [DllImport("ClearScriptV8.linux-arm.so", CallingConvention = CallingConvention.StdCall)]
            private static extern void V8Object_SetNamedProperty(
                [In] V8Object.Handle hObject,
                [In] StdString.Ptr pName,
                [In] V8Value.Ptr pValue
            );

            [DllImport("ClearScriptV8.linux-arm.so", CallingConvention = CallingConvention.StdCall)]
            [return: MarshalAs(UnmanagedType.I1)]
            private static extern bool V8Object_DeleteNamedProperty(
                [In] V8Object.Handle hObject,
                [In] StdString.Ptr pName
            );

            [DllImport("ClearScriptV8.linux-arm.so", CallingConvention = CallingConvention.StdCall)]
            private static extern void V8Object_GetPropertyNames(
                [In] V8Object.Handle hObject,
                [In] StdStringArray.Ptr pNames
            );

            [DllImport("ClearScriptV8.linux-arm.so", CallingConvention = CallingConvention.StdCall)]
            private static extern void V8Object_GetIndexedProperty(
                [In] V8Object.Handle hObject,
                [In] int index,
                [In] V8Value.Ptr pValue
            );

            [DllImport("ClearScriptV8.linux-arm.so", CallingConvention = CallingConvention.StdCall)]
            private static extern void V8Object_SetIndexedProperty(
                [In] V8Object.Handle hObject,
                [In] int index,
                [In] V8Value.Ptr pValue
            );

            [DllImport("ClearScriptV8.linux-arm.so", CallingConvention = CallingConvention.StdCall)]
            [return: MarshalAs(UnmanagedType.I1)]
            private static extern bool V8Object_DeleteIndexedProperty(
                [In] V8Object.Handle hObject,
                [In] int index
            );

            [DllImport("ClearScriptV8.linux-arm.so", CallingConvention = CallingConvention.StdCall)]
            private static extern void V8Object_GetPropertyIndices(
                [In] V8Object.Handle hObject,
                [In] StdInt32Array.Ptr pIndices
            );

            [DllImport("ClearScriptV8.linux-arm.so", CallingConvention = CallingConvention.StdCall)]
            private static extern void V8Object_Invoke(
                [In] V8Object.Handle hObject,
                [In] [MarshalAs(UnmanagedType.I1)] bool asConstructor,
                [In] StdV8ValueArray.Ptr pArgs,
                [In] V8Value.Ptr pResult
            );

            [DllImport("ClearScriptV8.linux-arm.so", CallingConvention = CallingConvention.StdCall)]
            private static extern void V8Object_InvokeMethod(
                [In] V8Object.Handle hObject,
                [In] StdString.Ptr pName,
                [In] StdV8ValueArray.Ptr pArgs,
                [In] V8Value.Ptr pResult
            );

            [DllImport("ClearScriptV8.linux-arm.so", CallingConvention = CallingConvention.StdCall)]
            private static extern void V8Object_GetArrayBufferOrViewInfo(
                [In] V8Object.Handle hObject,
                [In] V8Value.Ptr pArrayBuffer,
                [Out] out ulong offset,
                [Out] out ulong size,
                [Out] out ulong length
            );

            [DllImport("ClearScriptV8.linux-arm.so", CallingConvention = CallingConvention.StdCall)]
            private static extern void V8Object_InvokeWithArrayBufferOrViewData(
                [In] V8Object.Handle hObject,
                [In] IntPtr pAction
            );

            #endregion

            #region V8 debug callback methods

            [DllImport("ClearScriptV8.linux-arm.so", CallingConvention = CallingConvention.StdCall)]
            private static extern void V8DebugCallback_ConnectClient(
                [In] V8DebugCallback.Handle hCallback
            );

            [DllImport("ClearScriptV8.linux-arm.so", CallingConvention = CallingConvention.StdCall)]
            private static extern void V8DebugCallback_SendCommand(
                [In] V8DebugCallback.Handle hCallback,
                [In] StdString.Ptr pCommand
            );

            [DllImport("ClearScriptV8.linux-arm.so", CallingConvention = CallingConvention.StdCall)]
            private static extern void V8DebugCallback_DisconnectClient(
                [In] V8DebugCallback.Handle hCallback
            );

            #endregion

            #region native callback methods

            [DllImport("ClearScriptV8.linux-arm.so", CallingConvention = CallingConvention.StdCall)]
            private static extern void NativeCallback_Invoke(
                [In] NativeCallback.Handle hCallback
            );

            #endregion

            #region V8 entity cleanup

            [DllImport("ClearScriptV8.linux-arm.so", CallingConvention = CallingConvention.StdCall)]
            private static extern void V8Entity_Release(
                [In] V8Entity.Handle hEntity
            );

            [DllImport("ClearScriptV8.linux-arm.so", CallingConvention = CallingConvention.StdCall)]
            private static extern void V8Entity_DestroyHandle(
                [In] V8Entity.Handle hEntity
            );

            #endregion

            #region error handling

            [DllImport("ClearScriptV8.linux-arm.so", CallingConvention = CallingConvention.StdCall)]
            private static extern void HostException_Schedule(
                [In] StdString.Ptr pMessage,
                [In] V8Value.Ptr pException
            );

            #endregion

            #region unit test support

            [DllImport("ClearScriptV8.linux-arm.so", CallingConvention = CallingConvention.StdCall)]
            private static extern UIntPtr V8UnitTestSupport_GetTextDigest(
                [In] StdString.Ptr pString
            );

            [DllImport("ClearScriptV8.linux-arm.so", CallingConvention = CallingConvention.StdCall)]
            private static extern void V8UnitTestSupport_GetStatistics(
                [Out] out ulong isolateCount,
                [Out] out ulong contextCount
            );

            #endregion

            #endregion
        }

        #endregion

        
        #region Nested type: Impl_OSX_X64

        private sealed class Impl_OSX_X64 : IV8SplitProxyNative
        {