private unsafe static int TryExcelImpl12(int xlFunction, out object result, params object[] parameters) { int xlReturn; // Set up the memory to hold the result from the call XlOper12 resultOper = new XlOper12(); resultOper.xlType = XlType12.XlTypeEmpty; XlOper12 *pResultOper = &resultOper; // No need to pin for local struct // Special kind of ObjectArrayMarshaler for the parameters (rank 1) using (XlObjectArray12Marshaler.XlObjectArray12MarshalerImpl paramMarshaler = new XlObjectArray12Marshaler.XlObjectArray12MarshalerImpl(1, true)) { XlOper12 **ppOperParameters = (XlOper12 **)paramMarshaler.MarshalManagedToNative(parameters); xlReturn = Excel12v(xlFunction, parameters.Length, ppOperParameters, pResultOper); } // pResultOper now holds the result of the evaluated function // Get ObjectMarshaler for the return value ICustomMarshaler m = XlObject12Marshaler.GetInstance(""); result = m.MarshalNativeToManaged((IntPtr)pResultOper); // And free any memory allocated by Excel Excel12v(xlFree, 1, &pResultOper, (XlOper12 *)IntPtr.Zero); return(xlReturn); }
public static ICustomMarshaler GetInstance(string cookie) { if (null == _marshaler) { _marshaler = new ParamStructArrayMarshaler(); } return(_marshaler); }
public static ICustomMarshaler GetInstance(string cookie) { if (instance == null) { instance = new Win32WindowMarshaler(); } return(instance); }
public static ICustomMarshaler GetInstance(string cookie) { if (_instance == null) { _instance = new StringCustomMarshaler(); } return(_instance); }
public static ICustomMarshaler GetInstance(string cookie) { if (instance == null) { instance = new IconMarshaler(); } return instance; }
public static ICustomMarshaler GetInstance(string cookie) { if (instance == null) { instance = new ItemIdListMarshaler(); } return(instance); }
public byte[] GetBuffer() { MakeSeflRelative(); // Makes the SD one contiguous buffer. int size = Size; byte[] Buffer = new byte[size]; ICustomMarshaler sdm = SecurityDescriptorMarshaler.GetInstance(null); IntPtr pSD = sdm.MarshalManagedToNative(this); Marshal.Copy(pSD, Buffer, 0, size); return(Buffer); }
internal static IntPtr XlAddInManagerInfo12(IntPtr pXloperAction12) { Debug.WriteLine("In XlAddIn.XlAddInManagerInfo12"); ICustomMarshaler m = XlObject12Marshaler.GetInstance(""); object action = m.MarshalNativeToManaged(pXloperAction12); object result; if ((action is double && (double)action == 1.0)) { InitializeIntegration(); result = IntegrationHelpers.DnaLibraryGetName(); } else { result = IntegrationMarshalHelpers.GetExcelErrorObject(IntegrationMarshalHelpers.ExcelError_ExcelErrorValue); } return(m.MarshalManagedToNative(result)); }
internal static IntPtr RegistrationInfo(IntPtr pParam) { if (!_initialized) { return(IntPtr.Zero); } // CONSIDER: This might not be the right place for this. ICustomMarshaler m = XlObject12Marshaler.GetInstance(""); object param = m.MarshalNativeToManaged(pParam); object regInfo = XlRegistration.GetRegistrationInfo(param); if (regInfo == null) { return(IntPtr.Zero); // Converted to #NUM } return(m.MarshalManagedToNative(regInfo)); }
public static ICustomMarshaler GetInstance(string marshalCookie) { if (instance == null) instance = new XlAsyncHandleParameter12Marshaler(); return instance; }
public static ICustomMarshaler GetInstance(string marshalCookie) { if (instance == null) instance = new XlDecimalParameterMarshaler(); return instance; }
private object CallFunction(IntPtr Function, CallingConvention callingConvention, CharSet charSet, object[] Paramaters, Type[] ParamaterTypes, MarshalAsAttribute[] Marshalling, bool[] IsByRef, Type ReturnType, MarshalAsAttribute ReturnMarshalling) { if (Function == IntPtr.Zero) { throw new ArgumentNullException("Function"); } if (ReturnType == null) { throw new ArgumentNullException("ReturnType"); } this.ThrowIfDisposed(); this.ThrowIfNoHandle(); if (callingConvention == 0) { callingConvention = CallingConvention.Winapi; } if (charSet == 0) { charSet = CharSet.Ansi; } if (Paramaters == null) { Paramaters = new object[0]; } if (ParamaterTypes == null) { ParamaterTypes = Type.GetTypeArray(Paramaters); } if (Marshalling == null) { Marshalling = new MarshalAsAttribute[Paramaters.Length]; } if (IsByRef == null) { IsByRef = new bool[Paramaters.Length]; } if (ReturnMarshalling == null) { ReturnMarshalling = DefaultMarshalling(ReturnType); } object[] OrigParmaters = new object[Paramaters.Length]; Type[] AfterMarshalTypes = new Type[Paramaters.Length]; ICustomMarshaler[] CustomMarshalers = new ICustomMarshaler[Paramaters.Length]; IntPtr[] PtrParamaters = new IntPtr[Paramaters.Length]; for (int i = 0; i < Paramaters.Length; i++) { OrigParmaters[i] = Paramaters[i]; if (Marshalling[i] == null) { Marshalling[i] = DefaultMarshalling(ParamaterTypes[i]); } this.MarshalToNative(ref Paramaters[i], Marshalling[i], ParamaterTypes[i], out CustomMarshalers[i], charSet); if (IsByRef[i]) { if (Paramaters[i] == null) { AfterMarshalTypes[i] = ParamaterTypes[i]; Paramaters[i] = IntPtr.Zero; } else { AfterMarshalTypes[i] = Paramaters[i].GetType(); Paramaters[i] = this.WriteStruct(Paramaters[i]).Value; } } if (Paramaters[i] is IntPtr) { PtrParamaters[i] = (IntPtr)Paramaters[i]; if (this.Is64BitProcess) { Paramaters[i] = PtrParamaters[i].ToInt64(); } else { Paramaters[i] = (int)PtrParamaters[i].ToInt64(); } } } CallFunctionParam Param = new CallFunctionParam() { Function = Function }; if (this.Is64BitProcess) { int SkipOnStack = 0; if (Paramaters.Length >= 1 && Marshal.SizeOf(Paramaters[0]) <= sizeof(ulong)) { Param.Argumentsx64.RCX = StructToStruct <ulong>(Paramaters[0]); SkipOnStack = 1; if (Paramaters.Length >= 2 && Marshal.SizeOf(Paramaters[1]) <= sizeof(ulong)) { Param.Argumentsx64.RDX = StructToStruct <ulong>(Paramaters[1]); SkipOnStack = 2; if (Paramaters.Length >= 3 && Marshal.SizeOf(Paramaters[2]) <= sizeof(ulong)) { Param.Argumentsx64.R8 = StructToStruct <ulong>(Paramaters[2]); SkipOnStack = 3; if (Paramaters.Length >= 4 && Marshal.SizeOf(Paramaters[3]) <= sizeof(ulong)) { Param.Argumentsx64.R9 = StructToStruct <ulong>(Paramaters[3]); SkipOnStack = 4; } } } } for (int i = SkipOnStack; i < Paramaters.Length; i++) { Param.Argumentsx64.StackLength += Utilities.Align(Marshal.SizeOf(Paramaters[i]), StackPointerAlignment); } if (Param.Argumentsx64.StackLength != 0) { IntPtr args = Marshal.AllocHGlobal(Param.Argumentsx64.StackLength); try { IntPtr _args = args; for (int i = SkipOnStack; i < Paramaters.Length; i++) { Marshal.StructureToPtr(Paramaters[i], _args, false); _args += Utilities.Align(Marshal.SizeOf(Paramaters[i]), StackPointerAlignment); } Param.Argumentsx64.Stack = this.WriteMemory(args, Param.Argumentsx64.StackLength); } finally { Marshal.FreeHGlobal(args); } } } else { int SkipOnStack = 0; switch (callingConvention) { case CallingConvention.Cdecl: case CallingConvention.StdCall: case CallingConvention.Winapi: for (int i = SkipOnStack; i < Paramaters.Length; i++) { Param.Argumentsx86.StackLength += Utilities.Align(Marshal.SizeOf(Paramaters[i]), StackPointerAlignment); } if (Param.Argumentsx86.StackLength != 0) { IntPtr args = Marshal.AllocHGlobal(Param.Argumentsx86.StackLength); try { IntPtr _args = args; for (int i = SkipOnStack; i < Paramaters.Length; i++) { Marshal.StructureToPtr(Paramaters[i], _args, false); _args += Utilities.Align(Marshal.SizeOf(Paramaters[i]), StackPointerAlignment); } Param.Argumentsx86.Stack = this.WriteMemory(args, Param.Argumentsx86.StackLength); } finally { if (args != IntPtr.Zero) { Marshal.FreeHGlobal(args); } } } break; case CallingConvention.FastCall: if (Paramaters.Length >= 1 && Marshal.SizeOf(Paramaters[0]) <= sizeof(uint)) { Param.Argumentsx86.ECX = StructToStruct <uint>(Paramaters[0]); SkipOnStack = 1; if (Paramaters.Length >= 2 && Marshal.SizeOf(Paramaters[1]) <= sizeof(uint)) { Param.Argumentsx86.EDX = StructToStruct <uint>(Paramaters[1]); SkipOnStack = 2; } } goto case CallingConvention.StdCall; case CallingConvention.ThisCall: if (Paramaters.Length < 1) { throw new ArgumentException("Calling convention requires at least one argument."); } if (Marshal.SizeOf(Paramaters[0]) > sizeof(uint)) { throw new ArgumentException("Paramater 0 must be this paramater and less than or equal to 32-bits."); } Param.Argumentsx86.ECX = StructToStruct <uint>(Paramaters[0]); SkipOnStack = 1; goto case CallingConvention.Cdecl; default: throw new ArgumentException(null, "callingConvention"); } } try { uint res = this.CallFunctionThreadProc(this.NativeCallFunction, ref Param); if (res != Win32.ERROR_SUCCESS) { throw new Exception("CallFunction failed", new Win32Exception((int)res)); } } finally { if (Param.Argumentsx86.Stack != IntPtr.Zero) { this.FreeMemory(Param.Argumentsx86.Stack); } for (int i = 0; i < Paramaters.Length; i++) { if (IsByRef[i]) { IntPtr PtrParamater = PtrParamaters[i]; try { if (AfterMarshalTypes[i] == typeof(IntPtr)) { Paramaters[i] = PtrParamaters[i] = this.ReadIntPtr(PtrParamater); } else if (PtrParamater == IntPtr.Zero) { Paramaters[i] = null; } else { Paramaters[i] = this.ReadStruct(PtrParamater, AfterMarshalTypes[i]); } } finally { if (PtrParamater != IntPtr.Zero) { this.FreeMemory(PtrParamater); } } } this.MarshalToManaged(ref Paramaters[i], OrigParmaters[i], PtrParamaters[i], Marshalling[i], ParamaterTypes[i], CustomMarshalers[i], charSet, IsByRef[i]); } } FunctionReturn ReturnValue; if (this.Is64BitProcess) { ReturnValue = Param.ReturnValuex64; } else { ReturnValue = Param.ReturnValuex86; } if (ReturnMarshalling != null) { object _ReturnValue = ReturnValue.Int64; this.MarshalToManaged(ref _ReturnValue, null, ReturnValue.IntPtr, ReturnMarshalling, ReturnType, null, charSet, true); return(_ReturnValue); } else if (ReturnType == typeof(FunctionReturn)) { return(ReturnValue); } else if (ReturnType == typeof(sbyte)) { return(ReturnValue.Int8); } else if (ReturnType == typeof(byte)) { return(ReturnValue.UInt8); } else if (ReturnType == typeof(short)) { return(ReturnValue.Int16); } else if (ReturnType == typeof(ushort)) { return(ReturnValue.UInt16); } else if (ReturnType == typeof(int)) { return(ReturnValue.Int32); } else if (ReturnType == typeof(uint)) { return(ReturnValue.UInt32); } else if (ReturnType == typeof(long)) { return(ReturnValue.Int64); } else if (ReturnType == typeof(ulong)) { return(ReturnValue.UInt64); } else if (ReturnType == typeof(IntPtr)) { return(ReturnValue.IntPtr); } else if (ReturnType == typeof(UIntPtr)) { return(ReturnValue.UIntPtr); } else { throw new NotSupportedException(string.Format("Return type `{0}` is not supported", ReturnType)); } }
public static ICustomMarshaler GetInstance(string marshalCookie) { if (instance == null) instance = new XlDateTimeMarshaler(); return instance; }
public static ICustomMarshaler GetInstance(string marshalCookie) { if (instance == null) instance = new XlBooleanReturnMarshaler(); return instance; }
private void MarshalToManaged(ref object Paramater, object OrigParmater, IntPtr PtrParamater, MarshalAsAttribute Marshalling, Type ParamaterType, ICustomMarshaler CustomMarshaler, CharSet charSet, bool IsByRef) { if (Marshalling == null) { return; } switch (Marshalling.Value) { case UnmanagedType.AnsiBStr: try { if (ParamaterType == typeof(StringBuilder)) { StringBuilder StrParam = (StringBuilder)OrigParmater; if (IsByRef && StrParam == null) { Paramater = StrParam = new StringBuilder(); } if (StrParam == null) { break; } if (PtrParamater == IntPtr.Zero) { StrParam.Clear(); } else { this.ReadPrefixedStringAnsi(PtrParamater, StrParam); } } else if (IsByRef && ParamaterType == typeof(string)) { if (PtrParamater == IntPtr.Zero) { Paramater = null; } else { Paramater = this.ReadPrefixedStringAnsi(PtrParamater); } } } finally { if (PtrParamater != IntPtr.Zero) { this.FreeMemory(PtrParamater); } } break; case UnmanagedType.Bool: if (IsByRef) { Paramater = Convert.ToUInt32(Paramater) != 0U; } break; case UnmanagedType.BStr: try { if (ParamaterType == typeof(StringBuilder)) { StringBuilder StrParam = (StringBuilder)OrigParmater; if (IsByRef && StrParam == null) { Paramater = StrParam = new StringBuilder(); } if (StrParam == null) { break; } if (PtrParamater == IntPtr.Zero) { StrParam.Clear(); } else { this.ReadPrefixedStringUni(PtrParamater, StrParam); } } else if (IsByRef && ParamaterType == typeof(string)) { if (PtrParamater == IntPtr.Zero) { Paramater = null; } else { Paramater = this.ReadPrefixedStringUni(PtrParamater); } } } finally { if (PtrParamater != IntPtr.Zero) { this.FreeMemory(PtrParamater); } } break; case UnmanagedType.CustomMarshaler: if (CustomMarshaler == null) { CustomMarshaler = this.CreateCustomMarshaller(Marshalling); } try { if (IsByRef) { Paramater = CustomMarshaler.MarshalNativeToManaged(PtrParamater); } } finally { CustomMarshaler.CleanUpNativeData(PtrParamater); } break; case UnmanagedType.I1: case UnmanagedType.I2: case UnmanagedType.I4: case UnmanagedType.I8: case UnmanagedType.SysInt: case UnmanagedType.SysUInt: case UnmanagedType.U1: case UnmanagedType.U2: case UnmanagedType.U4: case UnmanagedType.U8: if (IsByRef) { Paramater = StructToStruct(Paramater, ParamaterType); } break; case UnmanagedType.LPArray: try { if (PtrParamater == IntPtr.Zero) { Paramater = null; } else { Type ArrElementType = ParamaterType.GetElementType(); Array ArrParam; int ArrLength = 0; if (IsByRef) { ArrLength = Marshalling.SizeConst; Paramater = ArrParam = Array.CreateInstance(ArrElementType, ArrLength); } else { ArrParam = (Array)OrigParmater; if (ArrParam != null) { ArrLength = ArrParam.Length; } } if (ArrLength > 0) { int bSize = ArrLength * Marshal.SizeOf(ArrElementType); Buffer.BlockCopy(this.ReadBytes(PtrParamater, bSize), 0, ArrParam, 0, bSize); } } } finally { if (PtrParamater != IntPtr.Zero) { this.FreeMemory(PtrParamater); } } break; case UnmanagedType.LPStruct: try { if (IsByRef && PtrParamater != IntPtr.Zero) { Paramater = this.ReadStruct(PtrParamater, ParamaterType); } } finally { if (PtrParamater != IntPtr.Zero) { this.FreeMemory(PtrParamater); } } break; case UnmanagedType.LPStr: try { if (ParamaterType == typeof(StringBuilder)) { StringBuilder StrParam = (StringBuilder)OrigParmater; if (IsByRef && StrParam == null) { Paramater = StrParam = new StringBuilder(); } if (StrParam == null) { break; } if (PtrParamater == IntPtr.Zero) { StrParam.Clear(); } else { this.ReadStringAnsi(PtrParamater, StrParam); } } else if (IsByRef && ParamaterType == typeof(string)) { if (PtrParamater == IntPtr.Zero) { Paramater = null; } else { Paramater = this.ReadStringAnsi(PtrParamater); } } } finally { if (PtrParamater != IntPtr.Zero) { this.FreeMemory(PtrParamater); } } break; case UnmanagedType.LPTStr: if (charSet == CharSet.Ansi || charSet == CharSet.None) { goto case UnmanagedType.LPStr; } else if (charSet == CharSet.Auto || charSet == CharSet.Unicode) { goto case UnmanagedType.LPWStr; } else { throw new NotSupportedException(); } case UnmanagedType.LPWStr: try { if (ParamaterType == typeof(StringBuilder)) { StringBuilder StrParam = (StringBuilder)OrigParmater; if (IsByRef && StrParam == null) { Paramater = StrParam = new StringBuilder(); } if (StrParam == null) { break; } if (PtrParamater == IntPtr.Zero) { StrParam.Clear(); } else { this.ReadStringUni(PtrParamater, StrParam); } } else if (IsByRef && ParamaterType == typeof(string)) { if (PtrParamater == IntPtr.Zero) { Paramater = null; } else { Paramater = this.ReadStringUni(PtrParamater); } } } finally { if (PtrParamater != IntPtr.Zero) { this.FreeMemory(PtrParamater); } } break; case UnmanagedType.TBStr: if (charSet == CharSet.Ansi || charSet == CharSet.None) { goto case UnmanagedType.AnsiBStr; } else if (charSet == CharSet.Auto || charSet == CharSet.Unicode) { goto case UnmanagedType.BStr; } else { throw new NotSupportedException(); } case UnmanagedType.VariantBool: if (IsByRef) { Paramater = Convert.ToInt16(Paramater) == -1; } break; } }
private void MarshalToNative(ref object Paramater, MarshalAsAttribute Marshalling, Type ParamaterType, out ICustomMarshaler CustomMarshaler, CharSet charSet) { CustomMarshaler = null; if (ParamaterType == typeof(SafeHandle) || ParamaterType.IsSubclassOf(typeof(SafeHandle))) { Paramater = ((SafeHandle)Paramater).Value; } if (Marshalling == null) { return; } switch (Marshalling.Value) { default: case UnmanagedType.AsAny: case UnmanagedType.ByValArray: case UnmanagedType.ByValTStr: case UnmanagedType.Currency: case UnmanagedType.Error: case UnmanagedType.FunctionPtr: case UnmanagedType.IDispatch: case UnmanagedType.Interface: case UnmanagedType.IUnknown: case UnmanagedType.R4: case UnmanagedType.R8: case UnmanagedType.SafeArray: case UnmanagedType.Struct: case UnmanagedType.VBByRefStr: throw new NotSupportedException(string.Format("MarshalAs type {0} not supported", Marshalling.Value)); case UnmanagedType.AnsiBStr: if (Paramater == null) { Paramater = IntPtr.Zero; } else if (ParamaterType == typeof(string)) { Paramater = this.WritePrefixedStringAnsi((string)Paramater); } else if (ParamaterType == typeof(StringBuilder)) { Paramater = this.WritePrefixedStringAnsi((StringBuilder)Paramater); } else { throw new NotSupportedException(); } break; case UnmanagedType.Bool: Paramater = Convert.ToBoolean(Paramater) ? 1U : 0U; break; case UnmanagedType.BStr: if (Paramater == null) { Paramater = IntPtr.Zero; } else if (ParamaterType == typeof(string)) { Paramater = this.WritePrefixedStringUni((string)Paramater); } else if (ParamaterType == typeof(StringBuilder)) { Paramater = this.WritePrefixedStringUni((StringBuilder)Paramater); } else { throw new NotSupportedException(); } break; case UnmanagedType.CustomMarshaler: CustomMarshaler = this.CreateCustomMarshaller(Marshalling); Paramater = CustomMarshaler.MarshalManagedToNative(Paramater); break; case UnmanagedType.I1: Paramater = StructToStruct <sbyte>(Paramater); break; case UnmanagedType.I2: Paramater = StructToStruct <short>(Paramater); break; case UnmanagedType.I4: Paramater = StructToStruct <int>(Paramater); break; case UnmanagedType.I8: Paramater = StructToStruct <long>(Paramater); break; case UnmanagedType.LPArray: Array ArrParam = (Array)Paramater; if (ArrParam == null) { Paramater = IntPtr.Zero; } else { Paramater = this.WriteArray(ArrParam); } break; case UnmanagedType.LPStruct: Paramater = this.WriteStruct(Paramater); break; case UnmanagedType.LPStr: if (Paramater == null) { Paramater = IntPtr.Zero; } else if (ParamaterType == typeof(string)) { Paramater = this.WriteStringAnsi((string)Paramater); } else if (ParamaterType == typeof(StringBuilder)) { Paramater = this.WriteStringAnsi((StringBuilder)Paramater); } else { throw new NotSupportedException(); } break; case UnmanagedType.LPTStr: if (charSet == CharSet.Ansi || charSet == CharSet.None) { goto case UnmanagedType.LPStr; } else if (charSet == CharSet.Auto || charSet == CharSet.Unicode) { goto case UnmanagedType.LPWStr; } else { throw new NotSupportedException(); } case UnmanagedType.LPWStr: if (Paramater == null) { Paramater = IntPtr.Zero; } else if (ParamaterType == typeof(string)) { Paramater = this.WriteStringUni((string)Paramater); } else if (ParamaterType == typeof(StringBuilder)) { Paramater = this.WriteStringUni((StringBuilder)Paramater); } else { throw new NotSupportedException(); } break; case UnmanagedType.SysInt: if (this.Is64BitProcess) { Paramater = StructToStruct <long>(Paramater); } else { Paramater = StructToStruct <int>(Paramater); } break; case UnmanagedType.SysUInt: if (this.Is64BitProcess) { Paramater = StructToStruct <ulong>(Paramater); } else { Paramater = StructToStruct <uint>(Paramater); } break; case UnmanagedType.TBStr: if (charSet == CharSet.Ansi || charSet == CharSet.None) { goto case UnmanagedType.AnsiBStr; } else if (charSet == CharSet.Auto || charSet == CharSet.Unicode) { goto case UnmanagedType.BStr; } else { throw new NotSupportedException(); } case UnmanagedType.U1: Paramater = StructToStruct <byte>(Paramater); break; case UnmanagedType.U2: Paramater = StructToStruct <ushort>(Paramater); break; case UnmanagedType.U4: Paramater = StructToStruct <uint>(Paramater); break; case UnmanagedType.U8: Paramater = StructToStruct <ulong>(Paramater); break; case UnmanagedType.VariantBool: Paramater = (short)(Convert.ToBoolean(Paramater) ? -1 : 0); break; } if (Paramater is SafeHandle) { Paramater = ((SafeHandle)Paramater).Value; } }