C# Generators.MarshalContext类代码示例

        public override void CSharpMarshalToManaged(MarshalContext ctx)
        {
            TemplateSpecializationType templateType = (TemplateSpecializationType) this.Type;
            QualifiedType type = templateType.Arguments[0].Type;

            TextGenerator supportBefore = ctx.SupportBefore;
            supportBefore.WriteLine("var __qlistData = new QListData({0}._0.d);", ctx.ReturnVarName);
            supportBefore.WriteLine("var __size = __qlistData.Size;");
            supportBefore.WriteLine("var __list = new System.Collections.Generic.List<{0}>(__size);", type);
            supportBefore.WriteLine("for (int i = 0; i < __size; i++)");
            supportBefore.WriteStartBraceIndent();
            // TODO: handle pointers to primitives, they cannot be used as a placeholder type and use IntPtr instead
            if (type.Type.IsPrimitiveType() || type.Type.IsEnumType())
            {
                supportBefore.WriteLine("__list.Add(*({0}*) __qlistData.At(i));", type);
            }
            else
            {
                Class @class;
                Type pointee;
                if ((type.Type.IsTagDecl(out @class) ||
                     (type.Type.IsPointerTo(out pointee) && pointee.IsTagDecl(out @class))) && @class.IsAbstract)
                {
                    supportBefore.WriteLine("__list.Add(new {0}Internal(new global::System.IntPtr(__qlistData.At(i))));", type, ctx.ReturnVarName);
                }
                else
                {
                    supportBefore.WriteLine("__list.Add(new {0}(new global::System.IntPtr(__qlistData.At(i))));", type, ctx.ReturnVarName);
                }
            }
            supportBefore.WriteCloseBraceIndent();
            ctx.Return.Write("__list");
        }

 public override void CSharpMarshalToManaged(MarshalContext ctx)
 {
     if (ctx.ReturnType.Type.Desugar().IsAddress())
     {
         var finalType = ctx.ReturnType.Type.GetFinalPointee() ?? ctx.ReturnType.Type;
         var enumType = GetEnumType(finalType);
         ctx.Return.Write("*({0}*) {1}", enumType, ctx.ReturnVarName);
     }
     else
     {
         ctx.Return.Write(ctx.ReturnVarName);
     }
 }

 public override void CSharpMarshalCopyCtorToManaged(MarshalContext ctx)
 {
     ctx.SupportBefore.WriteLine("var __instance = new {0}.Internal();", ctx.ReturnType);
     ctx.SupportBefore.WriteLine("QListData.Data.Internal* qListData = (QListData.Data.Internal*) __instance._0.d;");
     ctx.SupportBefore.WriteLine("QListData.Data.Internal* result = (QListData.Data.Internal*) __ret._0.d;");
     ctx.SupportBefore.WriteLine("qListData->begin = result->begin;");
     ctx.SupportBefore.WriteLine("qListData->end = result->end;");
     ctx.SupportBefore.WriteLine("qListData->alloc = result->alloc;");
     ctx.SupportBefore.WriteLine("fixed (void** v = new void*[qListData->end])");
     ctx.SupportBefore.WriteStartBraceIndent();
     ctx.SupportBefore.WriteLine("for (int i = 0; i < qListData->end; i++)");
     ctx.SupportBefore.WriteStartBraceIndent();
     ctx.SupportBefore.WriteLine("v[i] = *(result->array + i);");
     ctx.SupportBefore.WriteCloseBraceIndent();
     ctx.SupportBefore.WriteLine("qListData->array = v;");
     ctx.SupportBefore.WriteCloseBraceIndent();
     ctx.SupportBefore.WriteLine("__instance._0.d = (IntPtr) qListData;");
 }

 public override void CSharpMarshalToNative(MarshalContext ctx)
 {
     ctx.SupportBefore.WriteLine("var __qstring{0} = QString.FromUtf16((ushort*) Marshal.StringToHGlobalUni({1}).ToPointer(), {1}.Length);",
                                 ctx.ParameterIndex, ctx.Parameter.Name);
     Type type = ctx.Parameter.Type.Desugar();
     if (type.IsAddress())
     {
         ctx.Return.Write("ReferenceEquals(__qstring{0}, null) ? global::System.IntPtr.Zero : __qstring{0}.{1}",
                          ctx.ParameterIndex, Helpers.InstanceIdentifier);
         return;
     }
     Class @class;
     type.IsTagDecl(out @class);
     if (@class == null)
     {
         Type.IsTagDecl(out @class);
     }
     var qualifiedIdentifier = CSharpMarshalNativeToManagedPrinter.QualifiedIdentifier(@class.OriginalClass ?? @class);
     ctx.Return.Write("ReferenceEquals(__qstring{0}, null) ? new {1}.Internal() : *({1}.Internal*) (__qstring{0}.{2})",
                      ctx.ParameterIndex, qualifiedIdentifier, Helpers.InstanceIdentifier);
 }

 public override void CSharpMarshalToNative(MarshalContext ctx)
 {
     ctx.SupportBefore.WriteLine("var __stringPtr{0} = (ushort*) Marshal.StringToHGlobalUni({1}).ToPointer();",
                                 ctx.ParameterIndex, ctx.Parameter.Name);
     ctx.SupportBefore.WriteLine("var __qstring{0} = QtCore.QString.FromUtf16(ref *__stringPtr{0}, {1}.Length);",
                                 ctx.ParameterIndex, ctx.Parameter.Name);
     Type type = ctx.Parameter.Type.Desugar();
     if (type.IsAddress())
     {
         ctx.Return.Write("ReferenceEquals(__qstring{0}, null) ? global::System.IntPtr.Zero : __qstring{0}.{1}",
                          ctx.ParameterIndex, Helpers.InstanceIdentifier);
         return;
     }
     Class @class;
     type.TryGetClass(out @class);
     if (@class == null)
     {
         Type.TryGetClass(out @class);
     }
     typePrinter = typePrinter ?? (typePrinter = new CSharpTypePrinter(ctx.Driver));
     var qualifiedIdentifier = (@class.OriginalClass ?? @class).Visit(typePrinter);
     ctx.Return.Write("ReferenceEquals(__qstring{0}, null) ? new {1}.Internal() : *({1}.Internal*) (__qstring{0}.{2})",
                      ctx.ParameterIndex, qualifiedIdentifier, Helpers.InstanceIdentifier);
 }

 public override void CSharpMarshalToManaged(MarshalContext ctx)
 {
     ctx.Return.Write("Marshal.PtrToStringUni(new IntPtr(new QString({0}).Utf16))", ctx.ReturnVarName);
 }

 public override void CSharpMarshalToNative(MarshalContext ctx)
 {
     ctx.Return.Write("IntPtr.Zero");
 }

        public override void CSharpMarshalToManaged(MarshalContext ctx)
        {
            var templateType = Type as TemplateSpecializationType;
            var type = templateType.Arguments[0].Type;

            ctx.Return.Write("new Std.Vector<{0}>({1})", type,
                ctx.ReturnVarName);
        }

 public override void CSharpMarshalCopyCtorToManaged(MarshalContext ctx)
 {
     ctx.SupportBefore.WriteLine("var __instance = new {0}.Internal();", ctx.ReturnType);
     ctx.SupportBefore.WriteLine("__instance.i = {0}.i;", ctx.ReturnVarName);
 }

 public override void CSharpMarshalToNative(MarshalContext ctx)
 {
     if (ctx.Parameter.Type.Desugar().IsAddress())
         ctx.Return.Write("new global::System.IntPtr(&{0})", ctx.Parameter.Name);
     else
         ctx.Return.Write(ctx.Parameter.Name);
 }

 public override void CLIMarshalToNative(MarshalContext ctx)
 {
     var marshal = (CLIMarshalManagedToNativePrinter) ctx.MarshalToNative;
     if (!ctx.Parameter.Type.Desugar().IsPointer())
         marshal.ArgumentPrefix.Write("*");
     var marshalCtxName = string.Format("ctx_{0}", ctx.Parameter.Name);
     ctx.SupportBefore.WriteLine("msclr::interop::marshal_context {0};", marshalCtxName);
     ctx.Return.Write("{0}.marshal_as<std::ostream*>({1})",
         marshalCtxName, ctx.Parameter.Name);
 }

 protected MarshalPrinter(MarshalContext ctx)
 {
     Context = ctx;
 }

 public override void CSharpMarshalToNative(MarshalContext ctx)
 {
     TextGenerator supportBefore = ctx.SupportBefore;
     string suffix = ctx.ParameterIndex > 0 ? ctx.ParameterIndex.ToString(CultureInfo.InvariantCulture) : string.Empty;
     string qList = string.Format("__qList{0}", suffix);
     supportBefore.WriteLine(string.Format("var {0} = new QtCore.QList.Internal();", qList));
     string qListDataData = string.Format("__qlistDataData{0}", suffix);
     supportBefore.WriteLine("var {0} = (QListData.Data.Internal*) {1}._0.d;", qListDataData, qList);
     // TODO: tests with Qt shows that while alloc is not smaller than end, it's not equal, it reserves more space actually
     supportBefore.WriteLine("{0}->alloc = {1}.Count;", qListDataData, ctx.Parameter.Name);
     supportBefore.WriteLine("{0}->begin = 0;", qListDataData, ctx.Parameter.Name);
     supportBefore.WriteLine("{0}->end = {1}.Count;", qListDataData, ctx.Parameter.Name);
     supportBefore.WriteLine("fixed (void** __v = new void*[{0}.Count])", ctx.Parameter.Name);
     supportBefore.WriteStartBraceIndent();
     supportBefore.WriteLine("{0}->array = __v;", qListDataData);
     supportBefore.WriteCloseBraceIndent();
     supportBefore.WriteLine("", qListDataData, ctx.Parameter.Name);
     var parameterType = ctx.Parameter.Type.Desugar();
     TemplateSpecializationType type = parameterType as TemplateSpecializationType;
     if (type == null)
     {
         TypedefType typedef;
         if (parameterType.IsPointerTo(out typedef))
         {
             type = (TemplateSpecializationType) typedef.Desugar();
         }
         else
         {
             parameterType.IsPointerTo(out type);
         }
     }
     Type elementType = type.Arguments[0].Type.Type.Desugar();
     string instance = string.Empty;
     if (!elementType.IsPointerToPrimitiveType())
     {
         instance = string.Format(".{0}", Helpers.InstanceIdentifier);
     }
     supportBefore.WriteLine("for (int i = 0; i < {0}.Count; i++)", ctx.Parameter.Name);
     supportBefore.WriteStartBraceIndent();
     Type desugared = ctx.Parameter.Type.Desugar();
     TemplateSpecializationType templateSpecializationType = desugared as TemplateSpecializationType;
     if (templateSpecializationType == null)
     {
         Type paramType;
         desugared.IsPointerTo(out paramType);
         templateSpecializationType = (TemplateSpecializationType) paramType.Desugar();
     }
     TemplateArgument templateArgument = templateSpecializationType.Arguments[0];
     if (templateArgument.Type.ToString() == "string")
     {
         supportBefore.WriteLine("{0}->array[i] = Marshal.StringToHGlobalUni({1}[i]).ToPointer();", qListDataData, ctx.Parameter.Name, instance);
     }
     else
     {
         Class @class;
         if (templateArgument.Type.Type.IsTagDecl(out @class) && @class.IsValueType)
         {
             supportBefore.WriteLine("{0}.Internal __value = {1}[i].ToInternal();", @class.Name, ctx.Parameter.Name, instance);
             supportBefore.WriteLine("{0}->array[i] = &__value;", qListDataData, ctx.Parameter.Name, instance);
         }
         else
         {
             supportBefore.WriteLine("{0}->array[i] = (void*) {1}[i]{2};", qListDataData, ctx.Parameter.Name, instance);
         }
     }
     supportBefore.WriteCloseBraceIndent();
     ctx.Return.Write(qList);
 }

 public override void CSharpMarshalToManaged(MarshalContext ctx)
 {
 }

 public override void CLIMarshalToNative(MarshalContext ctx)
 {
     ctx.Return.Write("::TypeMappedIndex()");
 }