private delegate void RawScheduleForwardingException()

in ClearScript/V8/SplitProxy/V8SplitProxyManaged.cs [42:407]
305 lines of code
1 McCabe index (conditional complexity)

        private delegate void RawScheduleForwardingException(
            [In] V8Value.Ptr pException
        );

        [UnmanagedFunctionPointer(CallingConvention.StdCall)]
        private delegate void RawScheduleInvalidOperationException(
            [In] StdString.Ptr pMessage
        );

        [UnmanagedFunctionPointer(CallingConvention.StdCall)]
        private delegate void RawScheduleScriptEngineException(
            [In] StdString.Ptr pEngineName,
            [In] StdString.Ptr pMessage,
            [In] StdString.Ptr pStackTrace,
            [In] [MarshalAs(UnmanagedType.I1)] bool isFatal,
            [In] [MarshalAs(UnmanagedType.I1)] bool executionStarted,
            [In] V8Value.Ptr pScriptException,
            [In] V8Value.Ptr pInnerException
        );

        [UnmanagedFunctionPointer(CallingConvention.StdCall)]
        private delegate void RawScheduleScriptInterruptedException(
            [In] StdString.Ptr pEngineName,
            [In] StdString.Ptr pMessage,
            [In] StdString.Ptr pStackTrace,
            [In] [MarshalAs(UnmanagedType.I1)] bool isFatal,
            [In] [MarshalAs(UnmanagedType.I1)] bool executionStarted,
            [In] V8Value.Ptr pScriptException,
            [In] V8Value.Ptr pInnerException
        );

        [UnmanagedFunctionPointer(CallingConvention.StdCall)]
        private delegate void RawInvokeAction(
            [In] IntPtr pAction
        );

        [UnmanagedFunctionPointer(CallingConvention.StdCall)]
        private delegate void RawProcessArrayBufferOrViewData(
            [In] IntPtr pData,
            [In] IntPtr pAction
        );

        [UnmanagedFunctionPointer(CallingConvention.StdCall)]
        private delegate void RawProcessCpuProfile(
            [In] V8CpuProfile.Ptr pProfile,
            [In] IntPtr pAction
        );

        [UnmanagedFunctionPointer(CallingConvention.StdCall)]
        private delegate IntPtr RawCreateV8ObjectCache();

        [UnmanagedFunctionPointer(CallingConvention.StdCall)]
        private delegate void RawCacheV8Object(
            [In] IntPtr pCache,
            [In] IntPtr pObject,
            [In] IntPtr pV8Object
        );

        [UnmanagedFunctionPointer(CallingConvention.StdCall)]
        private delegate IntPtr RawGetCachedV8Object(
            [In] IntPtr pCache,
            [In] IntPtr pObject
        );

        [UnmanagedFunctionPointer(CallingConvention.StdCall)]
        private delegate void RawGetAllCachedV8Objects(
            [In] IntPtr pCache,
            [In] StdPtrArray.Ptr pV8ObjectPtrs
        );

        [UnmanagedFunctionPointer(CallingConvention.StdCall)]
        [return: MarshalAs(UnmanagedType.I1)]
        private delegate bool RawRemoveV8ObjectCacheEntry(
            [In] IntPtr pCache,
            [In] IntPtr pObject
        );

        [UnmanagedFunctionPointer(CallingConvention.StdCall)]
        private delegate IntPtr RawCreateDebugAgent(
            [In] StdString.Ptr pName,
            [In] StdString.Ptr pVersion,
            [In] int port,
            [In] [MarshalAs(UnmanagedType.I1)] bool remote,
            [In] V8DebugCallback.Handle hCallback
        );

        [UnmanagedFunctionPointer(CallingConvention.StdCall)]
        private delegate void RawSendDebugMessage(
            [In] IntPtr pAgent,
            [In] StdString.Ptr pContent
        );

        [UnmanagedFunctionPointer(CallingConvention.StdCall)]
        private delegate void RawDestroyDebugAgent(
            [In] IntPtr pAgent
        );

        [UnmanagedFunctionPointer(CallingConvention.StdCall)]
        private delegate uint RawGetMaxScriptCacheSize();

        [UnmanagedFunctionPointer(CallingConvention.StdCall)]
        private delegate uint RawGetMaxModuleCacheSize();

        [UnmanagedFunctionPointer(CallingConvention.StdCall)]
        private delegate IntPtr RawAddRefHostObject(
            [In] IntPtr pObject
        );

        [UnmanagedFunctionPointer(CallingConvention.StdCall)]
        private delegate void RawReleaseHostObject(
            [In] IntPtr pObject
        );

        [UnmanagedFunctionPointer(CallingConvention.StdCall)]
        private delegate Invocability RawGetHostObjectInvocability(
            [In] IntPtr pObject
        );

        [UnmanagedFunctionPointer(CallingConvention.StdCall)]
        private delegate void RawGetHostObjectNamedProperty(
            [In] IntPtr pObject,
            [In] StdString.Ptr pName,
            [In] V8Value.Ptr pValue
        );

        [UnmanagedFunctionPointer(CallingConvention.StdCall)]
        private delegate void RawGetHostObjectNamedPropertyWithCacheability(
            [In] IntPtr pObject,
            [In] StdString.Ptr pName,
            [In] V8Value.Ptr pValue,
            [Out] [MarshalAs(UnmanagedType.I1)] out bool isCacheable
        );

        [UnmanagedFunctionPointer(CallingConvention.StdCall)]
        private delegate void RawSetHostObjectNamedProperty(
            [In] IntPtr pObject,
            [In] StdString.Ptr pName,
            [In] V8Value.Ptr pValue
        );

        [UnmanagedFunctionPointer(CallingConvention.StdCall)]
        [return: MarshalAs(UnmanagedType.I1)]
        private delegate bool RawDeleteHostObjectNamedProperty(
            [In] IntPtr pObject,
            [In] StdString.Ptr pName
        );

        [UnmanagedFunctionPointer(CallingConvention.StdCall)]
        private delegate void RawGetHostObjectPropertyNames(
            [In] IntPtr pObject,
            [In] StdStringArray.Ptr pNames
        );

        [UnmanagedFunctionPointer(CallingConvention.StdCall)]
        private delegate void RawGetHostObjectIndexedProperty(
            [In] IntPtr pObject,
            [In] int index,
            [In] V8Value.Ptr pValue
        );

        [UnmanagedFunctionPointer(CallingConvention.StdCall)]
        private delegate void RawSetHostObjectIndexedProperty(
            [In] IntPtr pObject,
            [In] int index,
            [In] V8Value.Ptr pValue
        );

        [UnmanagedFunctionPointer(CallingConvention.StdCall)]
        [return: MarshalAs(UnmanagedType.I1)]
        private delegate bool RawDeleteHostObjectIndexedProperty(
            [In] IntPtr pObject,
            [In] int index
        );

        [UnmanagedFunctionPointer(CallingConvention.StdCall)]
        private delegate void RawGetHostObjectPropertyIndices(
            [In] IntPtr pObject,
            [In] StdInt32Array.Ptr pIndices
        );

        [UnmanagedFunctionPointer(CallingConvention.StdCall)]
        private delegate void RawInvokeHostObject(
            [In] IntPtr pObject,
            [In] [MarshalAs(UnmanagedType.I1)] bool asConstructor,
            [In] StdV8ValueArray.Ptr pArgs,
            [In] V8Value.Ptr pResult
        );

        [UnmanagedFunctionPointer(CallingConvention.StdCall)]
        private delegate void RawInvokeHostObjectMethod(
            [In] IntPtr pObject,
            [In] StdString.Ptr pName,
            [In] StdV8ValueArray.Ptr pArgs,
            [In] V8Value.Ptr pResult
        );

        [UnmanagedFunctionPointer(CallingConvention.StdCall)]
        private delegate void RawGetHostObjectEnumerator(
            [In] IntPtr pObject,
            [In] V8Value.Ptr pResult
        );

        [UnmanagedFunctionPointer(CallingConvention.StdCall)]
        private delegate void RawGetHostObjectAsyncEnumerator(
            [In] IntPtr pObject,
            [In] V8Value.Ptr pResult
        );

        [UnmanagedFunctionPointer(CallingConvention.StdCall)]
        private delegate void RawQueueNativeCallback(
            [In] NativeCallback.Handle hCallback
        );

        [UnmanagedFunctionPointer(CallingConvention.StdCall)]
        private delegate IntPtr RawCreateNativeCallbackTimer(
            [In] int dueTime,
            [In] int period,
            [In] NativeCallback.Handle hCallback
        );

        [UnmanagedFunctionPointer(CallingConvention.StdCall)]
        [return: MarshalAs(UnmanagedType.I1)]
        private delegate bool RawChangeNativeCallbackTimer(
            [In] IntPtr pTimer,
            [In] int dueTime,
            [In] int period
        );

        [UnmanagedFunctionPointer(CallingConvention.StdCall)]
        private delegate void RawDestroyNativeCallbackTimer(
            [In] IntPtr pTimer
        );

        [UnmanagedFunctionPointer(CallingConvention.StdCall)]
        private delegate void RawLoadModule(
            [In] IntPtr pSourceDocumentInfo,
            [In] StdString.Ptr pSpecifier,
            [In] StdString.Ptr pResourceName,
            [In] StdString.Ptr pSourceMapUrl,
            [Out] out ulong uniqueId,
            [Out] [MarshalAs(UnmanagedType.I1)] out bool isModule,
            [In] StdString.Ptr pCode,
            [Out] out IntPtr pDocumentInfo
        );

        [UnmanagedFunctionPointer(CallingConvention.StdCall)]
        private delegate void RawCreateModuleContext(
            [In] IntPtr pDocumentInfo,
            [In] StdStringArray.Ptr pNames,
            [In] StdV8ValueArray.Ptr pValues
        );

        [UnmanagedFunctionPointer(CallingConvention.StdCall)]
        private delegate void RawWriteBytesToStream(
            [In] IntPtr pStream,
            [In] IntPtr pBytes,
            [In] int count
        );

        [UnmanagedFunctionPointer(CallingConvention.StdCall)]
        [return: MarshalAs(UnmanagedType.I1)]
        private delegate bool RawGetTopLevelAwait();

        // ReSharper restore UnusedType.Local

        #endregion

        #region method table construction

        private static IntPtr CreateMethodTable()
        {
            IntPtr[] methodPtrs =
            {
                //----------------------------------------------------------------------------
                // IMPORTANT: maintain synchronization with V8_SPLIT_PROXY_MANAGED_METHOD_LIST
                //----------------------------------------------------------------------------

                GetMethodPtr<RawScheduleForwardingException>(ScheduleForwardingException),
                GetMethodPtr<RawScheduleInvalidOperationException>(ScheduleInvalidOperationException),
                GetMethodPtr<RawScheduleScriptEngineException>(ScheduleScriptEngineException),
                GetMethodPtr<RawScheduleScriptInterruptedException>(ScheduleScriptInterruptedException),

            #if NET5_0_OR_GREATER
                InvokeHostActionFastMethodPtr,
            #else
                GetMethodPtr<RawInvokeAction>(InvokeHostAction),
            #endif

                GetMethodPtr<RawProcessArrayBufferOrViewData>(ProcessArrayBufferOrViewData),
                GetMethodPtr<RawProcessCpuProfile>(ProcessCpuProfile),
                GetMethodPtr<RawCreateV8ObjectCache>(CreateV8ObjectCache),

            #if NET5_0_OR_GREATER
                CacheV8ObjectFastMethodPtr,
                GetCachedV8ObjectFastMethodPtr,
            #else
                GetMethodPtr<RawCacheV8Object>(CacheV8Object),
                GetMethodPtr<RawGetCachedV8Object>(GetCachedV8Object),
            #endif

                GetMethodPtr<RawGetAllCachedV8Objects>(GetAllCachedV8Objects),
                GetMethodPtr<RawRemoveV8ObjectCacheEntry>(RemoveV8ObjectCacheEntry),
                GetMethodPtr<RawCreateDebugAgent>(CreateDebugAgent),
                GetMethodPtr<RawSendDebugMessage>(SendDebugMessage),
                GetMethodPtr<RawDestroyDebugAgent>(DestroyDebugAgent),
                GetMethodPtr<RawGetMaxScriptCacheSize>(GetMaxScriptCacheSize),
                GetMethodPtr<RawGetMaxModuleCacheSize>(GetMaxModuleCacheSize),

            #if NET5_0_OR_GREATER
                AddRefHostObjectFastMethodPtr,
                ReleaseHostObjectFastMethodPtr,
                GetHostObjectInvocabilityFastMethodPtr,
            #else
                GetMethodPtr<RawAddRefHostObject>(AddRefHostObject),
                GetMethodPtr<RawReleaseHostObject>(ReleaseHostObject),
                GetMethodPtr<RawGetHostObjectInvocability>(GetHostObjectInvocability),
            #endif

            #if NET5_0_OR_GREATER
                GetHostObjectNamedPropertyFastMethodPtr,
                GetHostObjectNamedPropertyWithCacheabilityFastMethodPtr,
                SetHostObjectNamedPropertyFastMethodPtr,
            #else
                GetMethodPtr<RawGetHostObjectNamedProperty>(GetHostObjectNamedProperty),
                GetMethodPtr<RawGetHostObjectNamedPropertyWithCacheability>(GetHostObjectNamedPropertyWithCacheability),
                GetMethodPtr<RawSetHostObjectNamedProperty>(SetHostObjectNamedProperty),
            #endif

                GetMethodPtr<RawDeleteHostObjectNamedProperty>(DeleteHostObjectNamedProperty),
                GetMethodPtr<RawGetHostObjectPropertyNames>(GetHostObjectPropertyNames),

            #if NET5_0_OR_GREATER
                GetHostObjectIndexedPropertyFastMethodPtr,
                SetHostObjectIndexedPropertyFastMethodPtr,
            #else
                GetMethodPtr<RawGetHostObjectIndexedProperty>(GetHostObjectIndexedProperty),
                GetMethodPtr<RawSetHostObjectIndexedProperty>(SetHostObjectIndexedProperty),
            #endif

                GetMethodPtr<RawDeleteHostObjectIndexedProperty>(DeleteHostObjectIndexedProperty),
                GetMethodPtr<RawGetHostObjectPropertyIndices>(GetHostObjectPropertyIndices),

            #if NET5_0_OR_GREATER
                InvokeHostObjectFastMethodPtr,
                InvokeHostObjectMethodFastMethodPtr,
            #else
                GetMethodPtr<RawInvokeHostObject>(InvokeHostObject),
                GetMethodPtr<RawInvokeHostObjectMethod>(InvokeHostObjectMethod),
            #endif

                GetMethodPtr<RawGetHostObjectEnumerator>(GetHostObjectEnumerator),
                GetMethodPtr<RawGetHostObjectAsyncEnumerator>(GetHostObjectAsyncEnumerator),
                GetMethodPtr<RawQueueNativeCallback>(QueueNativeCallback),
                GetMethodPtr<RawCreateNativeCallbackTimer>(CreateNativeCallbackTimer),
                GetMethodPtr<RawChangeNativeCallbackTimer>(ChangeNativeCallbackTimer),
                GetMethodPtr<RawDestroyNativeCallbackTimer>(DestroyNativeCallbackTimer),
                GetMethodPtr<RawLoadModule>(LoadModule),
                GetMethodPtr<RawCreateModuleContext>(CreateModuleContext),
                GetMethodPtr<RawWriteBytesToStream>(WriteBytesToStream),
                GetMethodPtr<RawGetTopLevelAwait>(GetTopLevelAwait)
            };

            var pMethodTable = Marshal.AllocCoTaskMem(IntPtr.Size * methodPtrs.Length);
            Marshal.Copy(methodPtrs, 0, pMethodTable, methodPtrs.Length);
            return pMethodTable;
        }