public override void CLIMarshalToManaged(MarshalContext ctx) { var type = Type as TemplateSpecializationType; Class @class; if (!type.Arguments[0].Type.Type.IsTagDecl(out @class)) return; var instance = string.Format("{0}.get()", ctx.ReturnVarName); ctx.MarshalToManaged.WriteClassInstance(@class, instance); }
private void GeneratePropertyGetter <T>(T decl, Class @class, string name, Type type) where T : Declaration, ITypedDecl { if (decl == null) { return; } var method = decl as Method; var isIndexer = method != null && method.OperatorKind == CXXOperatorKind.Subscript; var args = new List <string>(); if (isIndexer) { var indexParameter = method.Parameters[0]; args.Add(string.Format("{0} {1}", indexParameter.Type, indexParameter.Name)); } WriteLine("{0} {1}::{2}::get({3})", type, QualifiedIdentifier(@class), name, string.Join(", ", args)); WriteStartBraceIndent(); if (decl is Function) { var func = decl as Function; if (isIndexer && func.Type.IsAddress()) { GenerateFunctionCall(func, @class, type); } else { GenerateFunctionCall(func, @class); } } else { if (@class.IsValueType && decl is Field) { WriteLine("return {0};", decl.Name); WriteCloseBraceIndent(); NewLine(); return; } string variable; if (decl is Variable) { variable = string.Format("::{0}::{1}", @class.QualifiedOriginalName, decl.OriginalName); } else { variable = string.Format("((::{0}*)NativePtr)->{1}", @class.QualifiedOriginalName, decl.OriginalName); } var ctx = new MarshalContext(Driver) { Declaration = decl, ArgName = decl.Name, ReturnVarName = variable, ReturnType = decl.QualifiedType }; var marshal = new CLIMarshalNativeToManagedPrinter(ctx); decl.Visit(marshal); if (!string.IsNullOrWhiteSpace(marshal.Context.SupportBefore)) { Write(marshal.Context.SupportBefore); } WriteLine("return {0};", marshal.Context.Return); } WriteCloseBraceIndent(); NewLine(); }
private ParamMarshal GenerateFunctionParamMarshal(Parameter param, int paramIndex, Function function = null) { var paramMarshal = new ParamMarshal { Name = param.Name, Param = param }; if (param.Type is BuiltinType) { return(paramMarshal); } var argName = "arg" + paramIndex.ToString(CultureInfo.InvariantCulture); var isRef = param.IsOut || param.IsInOut; // Since both pointers and references to types are wrapped as CLI // tracking references when using in/out, we normalize them here to be able // to use the same code for marshaling. var paramType = param.Type; if (paramType is PointerType && isRef) { if (!paramType.IsReference()) { paramMarshal.Prefix = "&"; } paramType = (paramType as PointerType).Pointee; } var effectiveParam = new Parameter(param) { QualifiedType = new QualifiedType(paramType) }; var ctx = new MarshalContext(Driver) { Parameter = effectiveParam, ParameterIndex = paramIndex, ArgName = argName, Function = function }; var marshal = new CLIMarshalManagedToNativePrinter(ctx); effectiveParam.Visit(marshal); if (string.IsNullOrEmpty(marshal.Context.Return)) { throw new Exception(string.Format("Cannot marshal argument of function '{0}'", function.QualifiedOriginalName)); } if (isRef) { var typePrinter = new CppTypePrinter(); var type = paramType.Visit(typePrinter); if (param.IsInOut) { if (!string.IsNullOrWhiteSpace(marshal.Context.SupportBefore)) { Write(marshal.Context.SupportBefore); } WriteLine("{0} {1} = {2};", type, argName, marshal.Context.Return); } else { WriteLine("{0} {1};", type, argName); } } else { if (!string.IsNullOrWhiteSpace(marshal.Context.SupportBefore)) { Write(marshal.Context.SupportBefore); } WriteLine("auto {0}{1} = {2};", marshal.VarPrefix, argName, marshal.Context.Return); paramMarshal.Prefix = marshal.ArgumentPrefix; } paramMarshal.Name = argName; return(paramMarshal); }
public CLIMarshalNativeToManagedPrinter(MarshalContext marshalContext) : base(marshalContext) { Context.MarshalToManaged = this; }
public override void CSharpMarshalToNative(MarshalContext ctx) { ctx.Return.Write(ctx.Parameter.Name); }
private ParamMarshal GenerateFunctionParamMarshal(Parameter param, int paramIndex, Function function = null) { var paramMarshal = new ParamMarshal { Name = param.Name, Param = param }; if (param.Type is BuiltinType) { return(paramMarshal); } var argName = Generator.GeneratedIdentifier("arg") + paramIndex.ToString(CultureInfo.InvariantCulture); Parameter effectiveParam = param; var isRef = param.IsOut || param.IsInOut; var paramType = param.Type; var ctx = new MarshalContext(Context, CurrentIndentation) { Parameter = effectiveParam, ParameterIndex = paramIndex, ArgName = argName, Function = function }; var marshal = new CppMarshalManagedToNativePrinter(ctx); effectiveParam.Visit(marshal); if (string.IsNullOrEmpty(marshal.Context.Return)) { throw new Exception($"Cannot marshal argument of function '{function.QualifiedOriginalName}'"); } if (isRef) { var type = paramType.Visit(CTypePrinter); if (param.IsInOut) { if (!string.IsNullOrWhiteSpace(marshal.Context.Before)) { Write(marshal.Context.Before); } WriteLine($"{type} {argName} = {marshal.Context.Return};"); } else { WriteLine($"{type} {argName};"); } } else { if (!string.IsNullOrWhiteSpace(marshal.Context.Before)) { Write(marshal.Context.Before); } WriteLine($"auto {marshal.VarPrefix}{argName} = {marshal.Context.Return};"); paramMarshal.Prefix = marshal.ArgumentPrefix; } paramMarshal.Name = argName; return(paramMarshal); }
public override void CSharpMarshalToNative(MarshalContext ctx) { var type = Type as TemplateSpecializationType; ctx.Return.Write("{0}._Instance", ctx.Parameter.Name); }
public override void CLIMarshalToNative(MarshalContext ctx) { ctx.Return.Write("(HandleId){0}.Id", ctx.Parameter.Name); }
public virtual void CSharpMarshalCopyCtorToManaged(MarshalContext ctx) { }
public override MarshalPrinter <MarshalContext> GetMarshalNativeToManagedPrinter(MarshalContext ctx) { return(new QuickJSMarshalNativeToManagedPrinter(ctx)); }
public override MarshalPrinter <MarshalContext, CppTypePrinter> GetMarshalManagedToNativePrinter(MarshalContext ctx) { return(new QuickJSMarshalManagedToNativePrinter(ctx)); }
private void GenerateEventInvoke(Event @event) { var invokeId = $"event_invoke_{@event.OriginalName}"; PushBlock(); { CTypePrinter.PushContext(TypePrinterContextKind.Native); var functionType = @event.Type as FunctionType; var retType = functionType.ReturnType.Visit(CTypePrinter); CTypePrinter.PopContext(); Write($"{retType} {invokeId}("); var @params = new List <string>(); foreach (var param in @event.Parameters) { CTypePrinter.PushContext(TypePrinterContextKind.Native); var paramType = param.Type.Visit(CTypePrinter); CTypePrinter.PopContext(); @params.Add($"{paramType} {param.Name}"); } Write(string.Join(", ", @params)); WriteLine(")"); WriteOpenBraceAndIndent(); WriteLine($"JSValue event = JS_Interop_FindEvent(&events, {@event.GlobalId});"); WriteLine($"if (JS_IsUndefined(event))"); var isVoidReturn = functionType.ReturnType.Type.IsPrimitiveType(PrimitiveType.Void); if (isVoidReturn) { WriteLineIndent($"return;"); } else { var defaultValuePrinter = new CppDefaultValuePrinter(Context); var defaultValue = functionType.ReturnType.Visit(defaultValuePrinter); WriteLineIndent($"return {defaultValue};"); } NewLine(); // Marshal the arguments. var marshalers = new List <MarshalPrinter <MarshalContext, CppTypePrinter> >(); foreach (var param in @event.Parameters) { var ctx = new MarshalContext(Context, CurrentIndentation) { ArgName = param.Name, ReturnVarName = param.Name, ReturnType = param.QualifiedType, Parameter = param }; var marshal = GetMarshalNativeToManagedPrinter(ctx); marshalers.Add(marshal); param.Visit(marshal); if (!string.IsNullOrWhiteSpace(marshal.Context.Before)) { Write(marshal.Context.Before); } } var args = marshalers.Select(m => m.Context.Return.ToString()); WriteLine($"JSValueConst argv[] = {{ { string.Join(", ", args)} }};"); WriteLine($"auto data = (JS_SignalContext*) JS_GetOpaque(event, 0);"); WriteLine($"JSValue ret = JS_Call(ctx, data->function, JS_UNDEFINED, {@event.Parameters.Count}, argv);"); WriteLine($"JS_FreeValue(ctx, ret);"); //WriteLine($"{@class.QualifiedOriginalName}* instance = data->instance;"); /* * * if (!isVoidReturn) * { * CTypePrinter.PushContext(TypePrinterContextKind.Native); * var returnType = function.ReturnType.Visit(CTypePrinter); * CTypePrinter.PopContext(); * * Write($"{returnType} {Helpers.ReturnIdentifier} = "); * } * * var @class = function.Namespace as Class; */ UnindentAndWriteCloseBrace(); } PopBlock(NewLineKind.BeforeNextBlock); }
public override void CLIMarshalToManaged(MarshalContext ctx) { ctx.Return.Write("{0}({1}.id)", CLISignature(null), ctx.ReturnVarName); }
public override void CSharpMarshalToNative(MarshalContext ctx) { ctx.Return.Write("IntPtr.Zero"); }
private ParamMarshal GenerateFunctionParamMarshal(Parameter param, int paramIndex, Function function = null) { var paramMarshal = new ParamMarshal { Name = param.Name, Param = param }; if (param.Type is BuiltinType) { return(paramMarshal); } var argName = Generator.GeneratedIdentifier("arg") + paramIndex.ToString(CultureInfo.InvariantCulture); var isRef = param.IsOut || param.IsInOut; var paramType = param.Type; // Get actual type if the param type is a typedef but not a function type because function types have to be typedef. // We need to get the actual type this early before we visit any marshalling code to ensure we hit the marshalling // logic for the actual type and not the typedef. // This fixes issues where typedefs to primitive pointers are involved. FunctionType functionType; var paramTypeAsTypedef = paramType as TypedefType; if (paramTypeAsTypedef != null && !paramTypeAsTypedef.Declaration.Type.IsPointerTo(out functionType)) { paramType = param.Type.Desugar(); } // Since both pointers and references to types are wrapped as CLI // tracking references when using in/out, we normalize them here to be able // to use the same code for marshaling. if (paramType is PointerType && isRef) { if (!paramType.IsReference()) { paramMarshal.Prefix = "&"; } paramType = (paramType as PointerType).Pointee; } var effectiveParam = new Parameter(param) { QualifiedType = new QualifiedType(paramType) }; var ctx = new MarshalContext(Context, CurrentIndentation) { Parameter = effectiveParam, ParameterIndex = paramIndex, ArgName = argName, Function = function }; var marshal = new CLIMarshalManagedToNativePrinter(ctx); effectiveParam.Visit(marshal); if (string.IsNullOrEmpty(marshal.Context.Return)) { throw new Exception($"Cannot marshal argument of function '{function.QualifiedOriginalName}'"); } if (isRef) { var typePrinter = new CppTypePrinter(Context) { ResolveTypeMaps = false }; var type = paramType.Visit(typePrinter); if (param.IsInOut) { if (!string.IsNullOrWhiteSpace(marshal.Context.Before)) { Write(marshal.Context.Before); } WriteLine("{0} {1} = {2};", type, argName, marshal.Context.Return); } else { WriteLine("{0} {1};", type, argName); } } else { if (!string.IsNullOrWhiteSpace(marshal.Context.Before)) { Write(marshal.Context.Before); } WriteLine("auto {0}{1} = {2};", marshal.VarPrefix, argName, marshal.Context.Return); paramMarshal.Prefix = marshal.ArgumentPrefix; } paramMarshal.Name = argName; return(paramMarshal); }
public virtual void CLIMarshalToNative(MarshalContext ctx) { throw new NotImplementedException(); }
public override void CSharpMarshalToNative(MarshalContext ctx) { ctx.Return.Write("new Std.WString()"); }
public void GenerateFunctionCall(Function function) { var @params = GenerateFunctionParamsMarshal(function.Parameters, function); var needsReturn = !function.ReturnType.Type.IsPrimitiveType(PrimitiveType.Void); if (needsReturn) { CTypePrinter.PushContext(TypePrinterContextKind.Native); var returnType = function.ReturnType.Visit(CTypePrinter); CTypePrinter.PopContext(); Write($"{returnType} {Helpers.ReturnIdentifier} = "); } var method = function as Method; var @class = function.Namespace as Class; var property = method?.AssociatedDeclaration as Property; var field = property?.Field; if (field != null) { Write($"((::{@class.QualifiedOriginalName}*){Helpers.InstanceIdentifier})->"); Write($"{field.OriginalName}"); var isGetter = property.GetMethod == method; if (isGetter) { WriteLine(";"); } else { WriteLine($" = {@params[0].Name};"); } } else { if (IsNativeFunctionOrStaticMethod(function)) { Write($"::{function.QualifiedOriginalName}("); } else { if (IsNativeMethod(function)) { Write($"((::{@class.QualifiedOriginalName}*){Helpers.InstanceIdentifier})->"); } Write($"{base.GetMethodIdentifier(function, TypePrinterContextKind.Native)}("); } GenerateFunctionParams(@params); WriteLine(");"); } foreach (var paramInfo in @params) { var param = paramInfo.Param; if (param.Usage != ParameterUsage.Out && param.Usage != ParameterUsage.InOut) { continue; } if (param.Type.IsPointer() && !param.Type.GetFinalPointee().IsPrimitiveType()) { param.QualifiedType = new QualifiedType(param.Type.GetFinalPointee()); } var nativeVarName = paramInfo.Name; var ctx = new MarshalContext(Context, CurrentIndentation) { ArgName = nativeVarName, ReturnVarName = nativeVarName, ReturnType = param.QualifiedType }; var marshal = new CppMarshalNativeToManagedPrinter(ctx); param.Visit(marshal); if (!string.IsNullOrWhiteSpace(marshal.Context.Before)) { Write(marshal.Context.Before); } WriteLine($"{param.Name} = {marshal.Context.Return};"); } if (needsReturn) { var ctx = new MarshalContext(Context, CurrentIndentation) { ArgName = Helpers.ReturnIdentifier, ReturnVarName = Helpers.ReturnIdentifier, ReturnType = function.ReturnType }; var marshal = new CppMarshalNativeToManagedPrinter(ctx); function.ReturnType.Visit(marshal); if (!string.IsNullOrWhiteSpace(marshal.Context.Before)) { Write(marshal.Context.Before); } WriteLine($"return {marshal.Context.Return};"); } }
public override void CLIMarshalToNative(MarshalContext ctx) { var templateType = Type as TemplateSpecializationType; var type = templateType.Arguments[0].Type; var isPointerToPrimitive = type.Type.IsPointerToPrimitiveType(); var managedType = isPointerToPrimitive ? new CILType(typeof(System.IntPtr)) : type.Type; var entryString = (ctx.Parameter != null) ? ctx.Parameter.Name : ctx.ArgName; var tmpVarName = "_tmp" + entryString; var cppTypePrinter = new CppTypePrinter(); var nativeType = type.Type.Visit(cppTypePrinter); ctx.Before.WriteLine("auto {0} = std::vector<{1}>();", tmpVarName, nativeType); ctx.Before.WriteLine("for each({0} _element in {1})", managedType, entryString); ctx.Before.WriteOpenBraceAndIndent(); { var param = new Parameter { Name = "_element", QualifiedType = type }; var elementCtx = new MarshalContext(ctx.Context, ctx.Indentation) { Parameter = param, ArgName = param.Name, }; var marshal = new CLIMarshalManagedToNativePrinter(elementCtx); type.Type.Visit(marshal); if (!string.IsNullOrWhiteSpace(marshal.Context.Before)) { ctx.Before.Write(marshal.Context.Before); } if (isPointerToPrimitive) { ctx.Before.WriteLine("auto _marshalElement = {0}.ToPointer();", marshal.Context.Return); } else { ctx.Before.WriteLine("auto _marshalElement = {0};", marshal.Context.Return); } ctx.Before.WriteLine("{0}.push_back(_marshalElement);", tmpVarName); } ctx.Before.UnindentAndWriteCloseBrace(); ctx.Return.Write(tmpVarName); }
public override void CSharpMarshalToNative(MarshalContext ctx) { // pointless, put just so that the generated code compiles ctx.Return.Write("new QList.Internal()"); }
public override void CLIMarshalToManaged(MarshalContext ctx) { throw new System.NotImplementedException(); }
public override void CSharpMarshalToManaged(MarshalContext ctx) { ctx.Return.Write(ctx.ReturnVarName); }
public override void CLIMarshalToNative(MarshalContext ctx) { ctx.Return.Write("::TypeMappedIndex()"); }
public void GenerateFunctionCall(Function function, Class @class = null, Type publicRetType = null) { CheckArgumentRange(function); if (function.OperatorKind == CXXOperatorKind.EqualEqual || function.OperatorKind == CXXOperatorKind.ExclaimEqual) { WriteLine("bool {0}Null = ReferenceEquals({0}, nullptr);", function.Parameters[0].Name); WriteLine("bool {0}Null = ReferenceEquals({0}, nullptr);", function.Parameters[1].Name); WriteLine("if ({0}Null || {1}Null)", function.Parameters[0].Name, function.Parameters[1].Name); WriteLineIndent("return {0}{1}Null && {2}Null{3};", function.OperatorKind == CXXOperatorKind.EqualEqual ? string.Empty : "!(", function.Parameters[0].Name, function.Parameters[1].Name, function.OperatorKind == CXXOperatorKind.EqualEqual ? string.Empty : ")"); } var retType = function.ReturnType; if (publicRetType == null) { publicRetType = retType.Type; } var needsReturn = !retType.Type.IsPrimitiveType(PrimitiveType.Void); const string valueMarshalName = "_this0"; var isValueType = @class != null && @class.IsValueType; if (isValueType && !IsNativeFunctionOrStaticMethod(function)) { WriteLine("auto {0} = ::{1}();", valueMarshalName, @class.QualifiedOriginalName); var param = new Parameter { Name = "(*this)" }; var ctx = new MarshalContext(Driver) { MarshalVarPrefix = valueMarshalName, Parameter = param }; var marshal = new CLIMarshalManagedToNativePrinter(ctx); marshal.MarshalValueClassProperties(@class, valueMarshalName); if (!string.IsNullOrWhiteSpace(marshal.Context.SupportBefore)) { Write(marshal.Context.SupportBefore); } } var @params = GenerateFunctionParamsMarshal(function.Parameters, function); var returnIdentifier = Helpers.ReturnIdentifier; if (needsReturn) { if (retType.Type.IsReference()) { Write("auto &{0} = ", returnIdentifier); } else { Write("auto {0} = ", returnIdentifier); } } if (function.OperatorKind == CXXOperatorKind.Conversion || function.OperatorKind == CXXOperatorKind.ExplicitConversion) { var method = function as Method; var typePrinter = new CppTypePrinter(); var typeName = method.ConversionType.Visit(typePrinter); WriteLine("({0}) {1};", typeName, @params[0].Name); } else if (function.IsOperator && function.OperatorKind != CXXOperatorKind.Subscript) { var opName = function.Name.Replace("operator", "").Trim(); switch (Operators.ClassifyOperator(function)) { case CXXOperatorArity.Unary: WriteLine("{0} {1};", opName, @params[0].Name); break; case CXXOperatorArity.Binary: WriteLine("{0} {1} {2};", @params[0].Name, opName, @params[1].Name); break; } } else { if (IsNativeFunctionOrStaticMethod(function)) { Write("::{0}(", function.QualifiedOriginalName); } else { if (isValueType) { Write("{0}.", valueMarshalName); } else if (IsNativeMethod(function)) { Write("((::{0}*)NativePtr)->", @class.QualifiedOriginalName); } Write("{0}(", function.OriginalName); } GenerateFunctionParams(@params); WriteLine(");"); } foreach (var paramInfo in @params) { var param = paramInfo.Param; if (param.Usage != ParameterUsage.Out && param.Usage != ParameterUsage.InOut) { continue; } if (param.Type.IsPointer() && !param.Type.GetFinalPointee().IsPrimitiveType()) { param.QualifiedType = new QualifiedType(param.Type.GetFinalPointee()); } var nativeVarName = paramInfo.Name; var ctx = new MarshalContext(Driver) { ArgName = nativeVarName, ReturnVarName = nativeVarName, ReturnType = param.QualifiedType }; var marshal = new CLIMarshalNativeToManagedPrinter(ctx); param.Visit(marshal); if (!string.IsNullOrWhiteSpace(marshal.Context.SupportBefore)) { Write(marshal.Context.SupportBefore); } WriteLine("{0} = {1};", param.Name, marshal.Context.Return); } if (isValueType && !IsNativeFunctionOrStaticMethod(function)) { GenerateStructMarshaling(@class, valueMarshalName + "."); } if (needsReturn) { var retTypeName = retType.Visit(TypePrinter); var isIntPtr = retTypeName.Contains("IntPtr"); if (retType.Type.IsPointer() && (isIntPtr || retTypeName.EndsWith("^"))) { WriteLine("if ({0} == nullptr) return {1};", returnIdentifier, isIntPtr ? "System::IntPtr()" : "nullptr"); } var ctx = new MarshalContext(Driver) { ArgName = returnIdentifier, ReturnVarName = returnIdentifier, ReturnType = retType }; var marshal = new CLIMarshalNativeToManagedPrinter(ctx); retType.Visit(marshal); if (!string.IsNullOrWhiteSpace(marshal.Context.SupportBefore)) { Write(marshal.Context.SupportBefore); } // Special case for indexer - needs to dereference if the internal // function is a pointer type and the property is not. if (retType.Type.IsPointer() && retType.Type.GetPointee().Equals(publicRetType) && publicRetType.IsPrimitiveType()) { WriteLine("return *({0});", marshal.Context.Return); } else if (retType.Type.IsReference() && publicRetType.IsReference()) { WriteLine("return ({0})({1});", publicRetType, marshal.Context.Return); } else { WriteLine("return {0};", marshal.Context.Return); } } }
public virtual void CppMarshalToNative(MarshalContext ctx) { ctx.Return.Write(ctx.Parameter.Name); }
private void GeneratePropertySetter <T>(T decl, Class @class, string name, Type type, Parameter indexParameter = null) where T : Declaration, ITypedDecl { if (decl == null) { return; } var args = new List <string>(); var isIndexer = indexParameter != null; if (isIndexer) { args.Add(string.Format("{0} {1}", indexParameter.Type, indexParameter.Name)); } var function = decl as Function; var argName = function != null && !isIndexer ? function.Parameters[0].Name : "value"; args.Add(string.Format("{0} {1}", type, argName)); WriteLine("void {0}::{1}::set({2})", QualifiedIdentifier(@class), name, string.Join(", ", args)); WriteStartBraceIndent(); if (decl is Function && !isIndexer) { var func = decl as Function; GenerateFunctionCall(func, @class); } else { if (@class.IsValueType && decl is Field) { WriteLine("{0} = value;", decl.Name); WriteCloseBraceIndent(); NewLine(); return; } var param = new Parameter { Name = "value", QualifiedType = new QualifiedType(type) }; string variable; if (decl is Variable) { variable = string.Format("::{0}::{1}", @class.QualifiedOriginalName, decl.OriginalName); } else { variable = string.Format("((::{0}*)NativePtr)->{1}", @class.QualifiedOriginalName, decl.OriginalName); } var ctx = new MarshalContext(Driver) { Parameter = param, ArgName = param.Name, ReturnVarName = variable }; var marshal = new CLIMarshalManagedToNativePrinter(ctx); param.Visit(marshal); if (isIndexer) { var ctx2 = new MarshalContext(Driver) { Parameter = indexParameter, ArgName = indexParameter.Name }; var marshal2 = new CLIMarshalManagedToNativePrinter(ctx2); indexParameter.Visit(marshal2); variable += string.Format("({0})", marshal2.Context.Return); } if (!string.IsNullOrWhiteSpace(marshal.Context.SupportBefore)) { Write(marshal.Context.SupportBefore); } if (marshal.Context.Return.StringBuilder.Length > 0) { if (isIndexer && decl.Type.IsPointer()) { WriteLine("*({0}) = {1};", variable, marshal.Context.Return); } else { WriteLine("{0} = {1};", variable, marshal.Context.Return); } } } WriteCloseBraceIndent(); NewLine(); }
public virtual void CppMarshalToManaged(MarshalContext ctx) { ctx.Return.Write(ctx.ReturnVarName); }
public override void CLIMarshalToNative(MarshalContext ctx) { ctx.Return.Write("clix::marshalString<clix::E_UTF16>({0})", ctx.Parameter.Name); }
public override void CLIMarshalToManaged(MarshalContext ctx) { ctx.Return.Write($"gcnew CLI::Employee({ctx.ReturnVarName}.m_employee)"); }
private void MarshalValueClassProperty(Property property, string marshalVar) { var fieldRef = string.Format("{0}.{1}", Context.Parameter.Name, property.Name); var marshalCtx = new MarshalContext(Context.Driver) { ArgName = fieldRef, ParameterIndex = Context.ParameterIndex++, MarshalVarPrefix = Context.MarshalVarPrefix }; var marshal = new CLIMarshalManagedToNativePrinter(marshalCtx); property.Visit(marshal); Context.ParameterIndex = marshalCtx.ParameterIndex; if (!string.IsNullOrWhiteSpace(marshal.Context.SupportBefore)) Context.SupportBefore.Write(marshal.Context.SupportBefore); Type type; Class @class; var isRef = property.Type.IsPointerTo(out type) && !(type.TryGetClass(out @class) && @class.IsValueType) && !type.IsPrimitiveType(); if (isRef) { Context.SupportBefore.WriteLine("if ({0} != nullptr)", fieldRef); Context.SupportBefore.PushIndent(); } Context.SupportBefore.WriteLine("{0}.{1} = {2};", marshalVar, property.Field.OriginalName, marshal.Context.Return); if (isRef) Context.SupportBefore.PopIndent(); }
public override void CLIMarshalToManaged(MarshalContext ctx) { ctx.Return.Write("clix::marshalString<clix::E_UTF8>({0}.m_str)", ctx.ReturnVarName); }
public override void CLIMarshalToManaged(MarshalContext ctx) { ctx.Return.Write("{0}({1}.id)", CLISignature(), ctx.ReturnVarName); }
public virtual void CSharpMarshalToManaged(MarshalContext ctx) { throw new NotImplementedException(); }
public override void CLIMarshalToNative(MarshalContext ctx) { var type = Type as TemplateSpecializationType; Class @class; if (!type.Arguments[0].Type.Type.IsTagDecl(out @class)) return; ctx.Return.Write("(::{0}*){1}->NativePtr", @class.QualifiedOriginalName, ctx.Parameter.Name); }
private void MarshalValueClassField(Field field, string marshalVar) { var fieldRef = string.Format("{0}.{1}", Context.Parameter.Name, field.Name); var marshalCtx = new MarshalContext(Context.Driver) { ArgName = fieldRef, ParameterIndex = Context.ParameterIndex++, MarshalVarPrefix = Context.MarshalVarPrefix }; var marshal = new CLIMarshalManagedToNativePrinter(marshalCtx); field.Visit(marshal); Context.ParameterIndex = marshalCtx.ParameterIndex; if (!string.IsNullOrWhiteSpace(marshal.Context.SupportBefore)) Context.SupportBefore.Write(marshal.Context.SupportBefore); if(field.Type.IsPointer()) { Context.SupportBefore.WriteLine("if ({0} != nullptr)", fieldRef); Context.SupportBefore.PushIndent(); } Context.SupportBefore.WriteLine("{0}.{1} = {2};", marshalVar, field.OriginalName, marshal.Context.Return); if(field.Type.IsPointer()) Context.SupportBefore.PopIndent(); }
public CLIMarshalManagedToNativePrinter(MarshalContext ctx) : base(ctx) { VarPrefix = new TextGenerator(); ArgumentPrefix = new TextGenerator(); Context.MarshalToNative = this; }