private unsafe IntPtr ConvertStringBuilderToNative(StringBuilder pManagedHome, int dwFlags)
        {
            IntPtr intPtr;

            if (AsAnyMarshaler.IsAnsi(dwFlags))
            {
                StubHelpers.CheckStringLength(pManagedHome.Capacity);
                int num = pManagedHome.Capacity * Marshal.SystemMaxDBCSCharSize + 4;
                intPtr = Marshal.AllocCoTaskMem(num);
                byte *ptr = (byte *)((void *)intPtr);
                *(ptr + num - 3) = 0;
                *(ptr + num - 2) = 0;
                *(ptr + num - 1) = 0;
                if (AsAnyMarshaler.IsIn(dwFlags))
                {
                    int    num2;
                    byte[] src = AnsiCharMarshaler.DoAnsiConversion(pManagedHome.ToString(), AsAnyMarshaler.IsBestFit(dwFlags), AsAnyMarshaler.IsThrowOn(dwFlags), out num2);
                    Buffer.Memcpy(ptr, 0, src, 0, num2);
                    ptr[num2] = 0;
                }
                if (AsAnyMarshaler.IsOut(dwFlags))
                {
                    this.backPropAction = AsAnyMarshaler.BackPropAction.StringBuilderAnsi;
                }
            }
            else
            {
                int num3 = pManagedHome.Capacity * 2 + 4;
                intPtr = Marshal.AllocCoTaskMem(num3);
                byte *ptr2 = (byte *)((void *)intPtr);
                *(ptr2 + num3 - 1) = 0;
                *(ptr2 + num3 - 2) = 0;
                if (AsAnyMarshaler.IsIn(dwFlags))
                {
                    int num4 = pManagedHome.Length * 2;
                    pManagedHome.InternalCopy(intPtr, num4);
                    ptr2[num4]       = 0;
                    (ptr2 + num4)[1] = 0;
                }
                if (AsAnyMarshaler.IsOut(dwFlags))
                {
                    this.backPropAction = AsAnyMarshaler.BackPropAction.StringBuilderUnicode;
                }
            }
            return(intPtr);
        }
        private unsafe IntPtr ConvertArrayToNative(object pManagedHome, int dwFlags)
        {
            Type    elementType = pManagedHome.GetType().GetElementType();
            VarEnum varEnum;

            switch (Type.GetTypeCode(elementType))
            {
            case TypeCode.Object:
                if (elementType == typeof(IntPtr))
                {
                    varEnum = ((IntPtr.Size == 4) ? VarEnum.VT_I4 : VarEnum.VT_I8);
                    goto IL_10D;
                }
                if (elementType == typeof(UIntPtr))
                {
                    varEnum = ((IntPtr.Size == 4) ? VarEnum.VT_UI4 : VarEnum.VT_UI8);
                    goto IL_10D;
                }
                break;

            case TypeCode.Boolean:
                varEnum = (VarEnum)254;
                goto IL_10D;

            case TypeCode.Char:
                varEnum = (AsAnyMarshaler.IsAnsi(dwFlags) ? ((VarEnum)253) : VarEnum.VT_UI2);
                goto IL_10D;

            case TypeCode.SByte:
                varEnum = VarEnum.VT_I1;
                goto IL_10D;

            case TypeCode.Byte:
                varEnum = VarEnum.VT_UI1;
                goto IL_10D;

            case TypeCode.Int16:
                varEnum = VarEnum.VT_I2;
                goto IL_10D;

            case TypeCode.UInt16:
                varEnum = VarEnum.VT_UI2;
                goto IL_10D;

            case TypeCode.Int32:
                varEnum = VarEnum.VT_I4;
                goto IL_10D;

            case TypeCode.UInt32:
                varEnum = VarEnum.VT_UI4;
                goto IL_10D;

            case TypeCode.Int64:
                varEnum = VarEnum.VT_I8;
                goto IL_10D;

            case TypeCode.UInt64:
                varEnum = VarEnum.VT_UI8;
                goto IL_10D;

            case TypeCode.Single:
                varEnum = VarEnum.VT_R4;
                goto IL_10D;

            case TypeCode.Double:
                varEnum = VarEnum.VT_R8;
                goto IL_10D;
            }
            throw new ArgumentException(Environment.GetResourceString("Arg_NDirectBadObject"));
IL_10D:
            int num = (int)varEnum;

            if (AsAnyMarshaler.IsBestFit(dwFlags))
            {
                num |= 65536;
            }
            if (AsAnyMarshaler.IsThrowOn(dwFlags))
            {
                num |= 16777216;
            }
            MngdNativeArrayMarshaler.CreateMarshaler(this.pvArrayMarshaler, IntPtr.Zero, num);
            IntPtr result;
            IntPtr pNativeHome = new IntPtr((void *)(&result));

            MngdNativeArrayMarshaler.ConvertSpaceToNative(this.pvArrayMarshaler, ref pManagedHome, pNativeHome);
            if (AsAnyMarshaler.IsIn(dwFlags))
            {
                MngdNativeArrayMarshaler.ConvertContentsToNative(this.pvArrayMarshaler, ref pManagedHome, pNativeHome);
            }
            if (AsAnyMarshaler.IsOut(dwFlags))
            {
                this.backPropAction = AsAnyMarshaler.BackPropAction.Array;
            }
            return(result);
        }
Ejemplo n.º 3
0
        private unsafe IntPtr ConvertStringBuilderToNative(StringBuilder pManagedHome, int dwFlags)
        {
            IntPtr dest;

            if (AsAnyMarshaler.IsAnsi(dwFlags))
            {
                System.StubHelpers.StubHelpers.CheckStringLength(pManagedHome.Capacity);
                int cb = pManagedHome.Capacity * Marshal.SystemMaxDBCSCharSize + 4;
                dest = Marshal.AllocCoTaskMem(cb);
                byte *pDest = (byte *)(void *)dest;
                *(pDest + cb - 3) = (byte)0;
                *(pDest + cb - 2) = (byte)0;
                *(pDest + cb - 1) = (byte)0;
                if (AsAnyMarshaler.IsIn(dwFlags))
                {
                    int    cbLength;
                    byte[] src = AnsiCharMarshaler.DoAnsiConversion(pManagedHome.ToString(), AsAnyMarshaler.IsBestFit(dwFlags), AsAnyMarshaler.IsThrowOn(dwFlags), out cbLength);
                    Buffer.Memcpy(pDest, 0, src, 0, cbLength);
                    pDest[cbLength] = (byte)0;
                }
                if (AsAnyMarshaler.IsOut(dwFlags))
                {
                    this.backPropAction = AsAnyMarshaler.BackPropAction.StringBuilderAnsi;
                }
            }
            else
            {
                int cb = pManagedHome.Capacity * 2 + 4;
                dest = Marshal.AllocCoTaskMem(cb);
                byte *numPtr = (byte *)(void *)dest;
                *(numPtr + cb - 1) = (byte)0;
                *(numPtr + cb - 2) = (byte)0;
                if (AsAnyMarshaler.IsIn(dwFlags))
                {
                    int len = pManagedHome.Length * 2;
                    pManagedHome.InternalCopy(dest, len);
                    (numPtr + len)[0] = (byte)0;
                    (numPtr + len)[1] = (byte)0;
                }
                if (AsAnyMarshaler.IsOut(dwFlags))
                {
                    this.backPropAction = AsAnyMarshaler.BackPropAction.StringBuilderUnicode;
                }
            }
            return(dest);
        }