public override TypePrinterResult VisitPointerType(PointerType pointer,
TypeQualifiers quals)
{
var pointee = pointer.Pointee.Desugar();
if (pointee is FunctionType)
{
var function = pointee as FunctionType;
return(string.Format("{0}^", function.Visit(this, quals)));
}
if (CSharpTypePrinter.IsConstCharString(pointer))
{
return("System::String^");
}
// From http://msdn.microsoft.com/en-us/library/y31yhkeb.aspx
// Any of the following types may be a pointer type:
// * sbyte, byte, short, ushort, int, uint, long, ulong, char, float, double, decimal, or bool.
// * Any enum type.
// * Any pointer type.
// * Any user-defined struct type that contains fields of unmanaged types only.
var finalPointee = pointer.GetFinalPointee();
if (finalPointee.IsPrimitiveType())
{
// Skip one indirection if passed by reference
bool isRefParam = Parameter != null && (Parameter.IsOut || Parameter.IsInOut);
if (isRefParam)
{
return(pointer.QualifiedPointee.Visit(this));
}
if (pointee.IsPrimitiveType(PrimitiveType.Void))
{
return("::System::IntPtr");
}
var result = pointer.QualifiedPointee.Visit(this).ToString();
return(!isRefParam && result == "::System::IntPtr" ? "void**" : result + "*");
}
Enumeration @enum;
if (pointee.TryGetEnum(out @enum))
{
var typeName = @enum.Visit(this);
// Skip one indirection if passed by reference
if (Parameter != null && (Parameter.IsOut || Parameter.IsInOut) &&
pointee == finalPointee)
{
return(string.Format("{0}", typeName));
}
return(string.Format("{0}*", typeName));
}
return(pointer.QualifiedPointee.Visit(this));
}
public override void CSharpMarshalToNative(CSharpMarshalContext ctx)
{
var type = ctx.Parameter.Type.Desugar();
ClassTemplateSpecialization basicString = GetBasicString(type);
var typePrinter = new CSharpTypePrinter(ctx.Driver);
typePrinter.PushContext(CSharpTypePrinterContextKind.Native);
if (!ctx.Parameter.Type.Desugar().IsAddress())
ctx.Return.Write("*({0}*) ", basicString.Visit(typePrinter));
typePrinter.PopContext();
var allocator = ctx.Driver.ASTContext.FindClass("allocator", false, true).First(
a => a.IsSupportedStdType());
if (type.IsPointer() || (type.IsReference() && ctx.Declaration is Field))
{
ctx.Return.Write("new {0}({1}, new {2}()).{3}",
basicString.Visit(typePrinter), ctx.Parameter.Name,
allocator.Visit(typePrinter), Helpers.InstanceIdentifier);
}
else
{
string varBasicString = "__basicString" + ctx.ParameterIndex;
ctx.SupportBefore.WriteLine("using (var {0} = new {1}({2}, new {3}()))",
varBasicString, basicString.Visit(typePrinter),
ctx.Parameter.Name, allocator.Visit(typePrinter));
ctx.SupportBefore.WriteStartBraceIndent();
ctx.Return.Write("{0}.{1}", varBasicString, Helpers.InstanceIdentifier);
ctx.HasCodeBlock = true;
}
}
public override void CSharpMarshalToNative(CSharpMarshalContext ctx)
{
var type = ctx.Parameter.Type.Desugar();
ClassTemplateSpecialization basicString = GetBasicString(type);
var typePrinter = new CSharpTypePrinter(ctx.Context);
typePrinter.PushContext(CSharpTypePrinterContextKind.Native);
if (!ctx.Parameter.Type.Desugar().IsAddress())
ctx.Return.Write("*({0}*) ", basicString.Visit(typePrinter));
typePrinter.PopContext();
var allocator = ctx.Context.ASTContext.FindClass("allocator", false, true).First(
a => a.IsDependent);
if (type.IsPointer() || (type.IsReference() && ctx.Declaration is Field))
{
ctx.Return.Write("new {0}({1}, new {2}()).{3}",
basicString.Visit(typePrinter), ctx.Parameter.Name,
allocator.Visit(typePrinter), Helpers.InstanceIdentifier);
}
else
{
string varAllocator = "__allocator" + ctx.ParameterIndex;
string varBasicString = "__basicString" + ctx.ParameterIndex;
ctx.SupportBefore.WriteLine("var {0} = new {1}();",
varAllocator, allocator.Visit(typePrinter));
ctx.SupportBefore.WriteLine("var {0} = new {1}({2}, {3});",
varBasicString, basicString.Visit(typePrinter),
ctx.Parameter.Name, varAllocator);
ctx.Return.Write("{0}.{1}", varBasicString, Helpers.InstanceIdentifier);
ctx.Cleanup.WriteLine("{0}.Dispose({1});", varBasicString,
type.IsPointer() ? "true" : "false");
ctx.Cleanup.WriteLine("{0}.Dispose();", varAllocator);
}
}
public override void CSharpMarshalToManaged(CSharpMarshalContext ctx)
{
var type = ctx.ReturnType.Type.Desugar();
ClassTemplateSpecialization basicString = GetBasicString(type);
Declaration c_str = basicString.Methods.FirstOrDefault(m => m.OriginalName == "c_str");
if (!c_str.IsGenerated)
{
c_str = basicString.Properties.First(p => p.OriginalName == "c_str");
}
var typePrinter = new CSharpTypePrinter(ctx.Context);
if (type.IsAddress() || ctx.Declaration is Field)
{
ctx.Return.Write("{0}.{1}({2}).{3}{4}",
basicString.Visit(typePrinter), Helpers.CreateInstanceIdentifier,
ctx.ReturnVarName, c_str.Name, c_str is Method ? "()" : string.Empty);
}
else
{
const string varBasicString = "__basicStringRet";
ctx.SupportBefore.WriteLine("using (var {0} = {1}.{2}({3}))",
varBasicString, basicString.Visit(typePrinter),
Helpers.CreateInstanceIdentifier, ctx.ReturnVarName);
ctx.SupportBefore.WriteStartBraceIndent();
ctx.Return.Write("{0}.{1}{2}", varBasicString, c_str.Name,
c_str is Method ? "()" : string.Empty);
ctx.HasCodeBlock = true;
}
}
public override void CSharpMarshalToNative(CSharpMarshalContext ctx)
{
Type type = ctx.Parameter.Type.Desugar();
ClassTemplateSpecialization basicString = GetBasicString(type);
var typePrinter = new CSharpTypePrinter(ctx.Context);
if (!ctx.Parameter.Type.Desugar().IsAddress() &&
ctx.MarshalKind != MarshalKind.NativeField)
{
ctx.Return.Write($"*({typePrinter.PrintNative(basicString)}*) ");
}
string qualifiedBasicString = GetQualifiedBasicString(basicString);
var assign = basicString.Methods.First(m => m.OriginalName == "assign");
if (ctx.MarshalKind == MarshalKind.NativeField)
{
ctx.Return.Write($@"{qualifiedBasicString}Extensions.{
Helpers.InternalStruct}.{assign.Name}(new {
typePrinter.IntPtrType}(&{
ctx.ReturnVarName}), {ctx.Parameter.Name})");
ctx.ReturnVarName = string.Empty;
}
else
{
var varBasicString = $"__basicString{ctx.ParameterIndex}";
ctx.Before.WriteLine($@"var {varBasicString} = new {
basicString.Visit(typePrinter)}();");
ctx.Before.WriteLine($@"{qualifiedBasicString}Extensions.{
assign.Name}({varBasicString}, {ctx.Parameter.Name});");
ctx.Return.Write($"{varBasicString}.{Helpers.InstanceIdentifier}");
ctx.Cleanup.WriteLine($@"{varBasicString}.Dispose({
(!Type.IsAddress() || ctx.Parameter?.IsIndirect == true ? "false" : string.Empty)});");
}
}
public override void CSharpMarshalToManaged(CSharpMarshalContext ctx)
{
var type = Type.Desugar(resolveTemplateSubstitution: false);
ClassTemplateSpecialization basicString = GetBasicString(type);
var c_str = basicString.Methods.First(m => m.OriginalName == "c_str");
var typePrinter = new CSharpTypePrinter(ctx.Context);
string qualifiedBasicString = GetQualifiedBasicString(basicString);
string varBasicString = $"__basicStringRet{ctx.ParameterIndex}";
ctx.Before.WriteLine($@"var {varBasicString} = {
basicString.Visit(typePrinter)}.{Helpers.CreateInstanceIdentifier}({
ctx.ReturnVarName});");
if (type.IsAddress())
{
ctx.Return.Write($@"{qualifiedBasicString}Extensions.{c_str.Name}({
varBasicString})");
}
else
{
string varString = $"__stringRet{ctx.ParameterIndex}";
ctx.Before.WriteLine($@"var {varString} = {
qualifiedBasicString}Extensions.{c_str.Name}({varBasicString});");
ctx.Before.WriteLine($"{varBasicString}.Dispose(false);");
ctx.Return.Write(varString);
}
}
private TypePrinter GetTypePrinter(GeneratorKind kind, BindingContext context)
{
TypePrinter typePrinter;
switch (kind)
{
case GeneratorKind.C:
typePrinter = new CppTypePrinter(Context)
{
PrintFlavorKind = CppTypePrintFlavorKind.C
};
break;
case GeneratorKind.CPlusPlus:
case GeneratorKind.QuickJS:
case GeneratorKind.NAPI:
case GeneratorKind.TypeScript:
typePrinter = new CppTypePrinter(Context);
break;
case GeneratorKind.CLI:
typePrinter = new CLITypePrinter(Context);
break;
case GeneratorKind.CSharp:
typePrinter = new CSharpTypePrinter(Context);
break;
default:
throw new System.NotImplementedException();
}
return(typePrinter);
}
public override Type CSharpSignatureType(TypePrinterContext ctx)
{
if (ctx.Kind == TypePrinterContextKind.Managed)
{
return(new CILType(typeof(string)));
}
if (ctx.Parameter == null || ctx.Parameter.Name == Helpers.ReturnIdentifier)
{
var typePrinter = new CSharpTypePrinter(Context);
return(new CustomType(typePrinter.IntPtrType));
}
if (Context.Options.Encoding == Encoding.ASCII)
{
return(new CustomType("[MarshalAs(UnmanagedType.LPStr)] string"));
}
if (Context.Options.Encoding == Encoding.Unicode ||
Context.Options.Encoding == Encoding.BigEndianUnicode)
{
return(new CustomType("[MarshalAs(UnmanagedType.LPWStr)] string"));
}
throw new System.NotSupportedException(
$"{Context.Options.Encoding.EncodingName} is not supported yet.");
}
public override void CSharpMarshalToNative(CSharpMarshalContext ctx)
{
var type = ctx.Parameter.Type.Desugar();
ClassTemplateSpecialization basicString = GetBasicString(type);
var typePrinter = new CSharpTypePrinter(ctx.Context);
typePrinter.PushContext(CSharpTypePrinterContextKind.Native);
if (!ctx.Parameter.Type.Desugar().IsAddress())
ctx.Return.Write("*({0}*) ", basicString.Visit(typePrinter));
typePrinter.PopContext();
var allocator = ctx.Context.ASTContext.FindClass("allocator", false, true).First(
a => a.IsDependent && a.TranslationUnit.IsSystemHeader);
if (type.IsPointer() || (type.IsReference() && ctx.Declaration is Field))
{
ctx.Return.Write("new {0}({1}, new {2}()).{3}",
basicString.Visit(typePrinter), ctx.Parameter.Name,
allocator.Visit(typePrinter), Helpers.InstanceIdentifier);
}
else
{
string varAllocator = "__allocator" + ctx.ParameterIndex;
string varBasicString = "__basicString" + ctx.ParameterIndex;
ctx.SupportBefore.WriteLine("var {0} = new {1}();",
varAllocator, allocator.Visit(typePrinter));
ctx.SupportBefore.WriteLine("var {0} = new {1}({2}, {3});",
varBasicString, basicString.Visit(typePrinter),
ctx.Parameter.Name, varAllocator);
ctx.Return.Write("{0}.{1}", varBasicString, Helpers.InstanceIdentifier);
ctx.Cleanup.WriteLine("{0}.Dispose({1});", varBasicString,
type.IsPointer() ? "true" : "false");
ctx.Cleanup.WriteLine("{0}.Dispose();", varAllocator);
}
}
public CSharpGenerator(Driver driver)
: base(driver)
{
typePrinter = new CSharpTypePrinter(driver);
expressionPrinter = new CSharpExpressionPrinter();
CppSharp.AST.Type.TypePrinterDelegate += type => type.Visit(typePrinter).Type;
}
public override string CSharpSignature(CSharpTypePrinterContext ctx)
{
if (ctx.CSharpKind == CSharpTypePrinterContextKind.Managed)
return "string";
ClassTemplateSpecialization basicString = GetBasicString(ctx.Type);
var typePrinter = new CSharpTypePrinter(null);
typePrinter.PushContext(CSharpTypePrinterContextKind.Native);
return basicString.Visit(typePrinter).Type;
}
public override string CSharpSignature(CSharpTypePrinterContext ctx)
{
if (ctx.CSharpKind == CSharpTypePrinterContextKind.Managed)
return "string";
ClassTemplateSpecialization basicString = GetBasicString(ctx.Type);
var typePrinter = new CSharpTypePrinter(null);
typePrinter.PushContext(CSharpTypePrinterContextKind.Native);
return basicString.Visit(typePrinter).Type;
}
public override void CSharpMarshalToNative(CSharpMarshalContext ctx)
{
// pointless, put just so that the generated code compiles
var type = (TemplateSpecializationType)ctx.Parameter.Type.Desugar();
var specialization = type.GetClassTemplateSpecialization();
var typePrinter = new CSharpTypePrinter(null);
typePrinter.PushContext(TypePrinterContextKind.Native);
ctx.Return.Write("new {0}()", specialization.Visit(typePrinter));
}
public override Type CSharpSignatureType(TypePrinterContext ctx)
{
if (ctx.Kind == TypePrinterContextKind.Managed)
{
return(new CILType(typeof(string)));
}
ClassTemplateSpecialization basicString = GetBasicString(ctx.Type);
var typePrinter = new CSharpTypePrinter(null);
typePrinter.PushContext(TypePrinterContextKind.Native);
return(new CustomType(basicString.Visit(typePrinter).Type));
}
private static bool CheckForEnumValue(BindingContext context, Type desugared, Statement statement,
ref string result)
{
var enumItem = statement.Declaration as Enumeration.Item;
if (enumItem != null)
{
return(true);
}
var call = statement.Declaration as Function;
if (call != null && statement.String != "0")
{
var @params = regexFunctionParams.Match(statement.String).Groups[1].Value;
result = TranslateEnumExpression(desugared, @params);
return(true);
}
if (desugared.TryGetEnum(out Enumeration @enum) &&
int.TryParse(statement.String, out int value))
{
var typePrinter = new CSharpTypePrinter(context);
var printedEnum = @enum.Visit(typePrinter);
if (value < 0)
{
switch (@enum.BuiltinType.Type)
{
case PrimitiveType.UShort:
case PrimitiveType.UInt:
case PrimitiveType.ULong:
case PrimitiveType.ULongLong:
case PrimitiveType.UInt128:
result = $@"({printedEnum}) unchecked(({
@enum.BuiltinType.Visit(typePrinter)}) {
statement.String})";
break;
default:
result = $"({printedEnum}) ({statement.String})";
break;
}
}
else
{
result = $"({printedEnum}) {statement.String}";
}
return(true);
}
return(false);
}
public override void CSharpMarshalToManaged(CSharpMarshalContext ctx)
{
var type = Type.Desugar(resolveTemplateSubstitution: false);
ClassTemplateSpecialization basicString = GetBasicString(type);
var data = basicString.Methods.First(m => m.OriginalName == "data");
var typePrinter = new CSharpTypePrinter(ctx.Context);
string qualifiedBasicString = GetQualifiedBasicString(basicString);
string varBasicString = $"__basicStringRet{ctx.ParameterIndex}";
bool usePointer = type.IsAddress() || ctx.MarshalKind == MarshalKind.NativeField ||
ctx.MarshalKind == MarshalKind.ReturnVariableArray;
ctx.Before.WriteLine($@"var {varBasicString} = {
basicString.Visit(typePrinter)}.{Helpers.CreateInstanceIdentifier}({
(usePointer ? string.Empty : $"new {typePrinter.IntPtrType}(&")}{
public override string CSharpSignature(TypePrinterContext ctx)
{
if (ctx.Kind == TypePrinterContextKind.Native)
{
var type = (TemplateSpecializationType)ctx.Type.Desugar();
var specialization = type.GetClassTemplateSpecialization();
var typePrinter = new CSharpTypePrinter(null);
typePrinter.PushContext(TypePrinterContextKind.Native);
return(string.Format($"{specialization.Visit(typePrinter)}{(Type.IsAddress() ? "*" : string.Empty)}", specialization.Visit(typePrinter),
Type.IsAddress() ? "*" : string.Empty));
}
return(string.Format("System.Collections.Generic.{0}<{1}>",
ctx.MarshalKind == MarshalKind.DefaultExpression ? "List" : "IList",
ctx.GetTemplateParameterList()));
}
public override bool VisitASTContext(ASTContext context)
{
TypePrinter typePrinter = null;
switch (Options.GeneratorKind)
{
case GeneratorKind.CLI:
typePrinter = new CLITypePrinter(Context);
break;
case GeneratorKind.CSharp:
typePrinter = new CSharpTypePrinter(Context);
break;
}
DeclarationName.ParameterTypeComparer.TypePrinter = typePrinter;
return(base.VisitASTContext(context));
}
public static System.Type GetSystemType(BindingContext context, Type type)
{
if (context.TypeMaps.FindTypeMap(type, out TypeMap typeMap))
{
var cilType = typeMap.CSharpSignatureType(new TypePrinterContext {
Type = type, Kind = TypePrinterContextKind.Managed
}) as CILType;
if (cilType != null)
{
return(cilType.Type);
}
}
if (type is BuiltinType builtInType)
{
if (builtInType.Type == PrimitiveType.Float)
{
return(typeof(float));
}
else if (builtInType.Type == PrimitiveType.Double)
{
return(typeof(double));
}
try
{
CSharpTypePrinter.GetPrimitiveTypeWidth(builtInType.Type, context.TargetInfo, out var w, out var signed);
var cilType = (signed ? CSharpTypePrinter.GetSignedType(w) : CSharpTypePrinter.GetUnsignedType(w)) as CILType;
if (cilType != null)
{
return(cilType.Type);
}
}
catch
{
return(null);
}
}
return(null);
}
public override void CSharpMarshalToNative(CSharpMarshalContext ctx)
{
var type = ctx.Parameter.Type.Desugar();
ClassTemplateSpecialization basicString = GetBasicString(type);
var typePrinter = new CSharpTypePrinter(ctx.Context);
typePrinter.PushContext(TypePrinterContextKind.Native);
if (!ctx.Parameter.Type.Desugar().IsAddress())
{
ctx.Return.Write($"*({basicString.Visit(typePrinter)}*) ");
}
typePrinter.PopContext();
var allocator = ctx.Context.ASTContext.FindClass("allocator", false, true).First(
a => a.IsDependent && a.TranslationUnit.IsSystemHeader);
var allocatorChar = allocator.Specializations.First(s => !s.Ignore);
string qualifiedBasicString = GetQualifiedBasicString(basicString);
if (type.IsPointer() || (type.IsReference() && ctx.Declaration is Field))
{
ctx.Return.Write($@"{qualifiedBasicString}Extensions.{basicString.Name}({
ctx.Parameter.Name}, new {allocatorChar.Visit(typePrinter)}()).{
Helpers.InstanceIdentifier}");
}
else
{
var varAllocator = $"__allocator{ctx.ParameterIndex}";
var varBasicString = $"__basicString{ctx.ParameterIndex}";
ctx.Before.WriteLine($@"var {varAllocator} = new {
allocatorChar.Visit(typePrinter)}();");
ctx.Before.WriteLine($@"var {varBasicString} = {
qualifiedBasicString}Extensions.{basicString.Name}({ctx.Parameter.Name}, {
varAllocator});");
ctx.Return.Write($"{varBasicString}.{Helpers.InstanceIdentifier}");
ctx.Cleanup.WriteLine($@"{varBasicString}.Dispose({
(type.IsPointer() ? "true" : "false")});");
ctx.Cleanup.WriteLine($"{varAllocator}.Dispose();");
}
}
public override Type CSharpSignatureType(TypePrinterContext ctx)
{
if (ctx.Kind == TypePrinterContextKind.Managed)
{
return(new CILType(typeof(string)));
}
if (ctx.Parameter == null || ctx.Parameter.Name == Helpers.ReturnIdentifier)
{
var typePrinter = new CSharpTypePrinter(Context);
return(new CustomType(typePrinter.IntPtrType));
}
var(encoding, _) = GetEncoding();
if (encoding == Encoding.ASCII || encoding == Encoding.Default)
{
// This is not really right. ASCII is 7-bit only - the 8th bit is stripped; ANSI has
// multi-byte support via a code page. MarshalAs(UnmanagedType.LPStr) marshals as ANSI.
// Perhaps we need a CppSharp.Runtime.ASCIIMarshaller?
return(new CustomType("[MarshalAs(UnmanagedType.LPStr)] string"));
}
else if (encoding == Encoding.UTF8)
{
return(new CustomType("[MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof(CppSharp.Runtime.UTF8Marshaller))] string"));
}
else if (encoding == Encoding.Unicode || encoding == Encoding.BigEndianUnicode)
{
return(new CustomType("[MarshalAs(UnmanagedType.LPWStr)] string"));
}
else if (encoding == Encoding.UTF32)
{
return(new CustomType("[MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof(CppSharp.Runtime.UTF32Marshaller))] string"));
}
throw new System.NotSupportedException(
$"{Context.Options.Encoding.EncodingName} is not supported yet.");
}
private string GenerateDelegateSignature(IEnumerable <Parameter> @params, QualifiedType returnType)
{
var typePrinter = new CSharpTypePrinter(Driver);
typePrinter.PushContext(CSharpTypePrinterContextKind.Native);
var typesBuilder = new StringBuilder();
if (!returnType.Type.IsPrimitiveType(PrimitiveType.Void))
{
typesBuilder.Insert(0, returnType.Type.CSharpType(typePrinter));
typesBuilder.Append('_');
}
foreach (var parameter in @params)
{
typesBuilder.Append(parameter.CSharpType(typePrinter));
typesBuilder.Append('_');
}
if (typesBuilder.Length > 0)
{
typesBuilder.Remove(typesBuilder.Length - 1, 1);
}
var delegateName = typesBuilder.Replace("global::System.", string.Empty).Replace(
"*", "Ptr").Replace('.', '_').ToString();
if (returnType.Type.IsPrimitiveType(PrimitiveType.Void))
{
delegateName = "Action_" + delegateName;
}
else
{
delegateName = "Func_" + delegateName;
}
typePrinter.PopContext();
return(delegateName);
}
public override void CSharpMarshalToNative(CSharpMarshalContext ctx)
{
ctx.SupportBefore.WriteLine("var __stringPtr{0} = ReferenceEquals({1}, null) ? null : (ushort*) Marshal.StringToHGlobalUni({1}).ToPointer();",
ctx.ParameterIndex, ctx.Parameter.Name);
ctx.SupportBefore.WriteLine("var __qstring{0} = __stringPtr{0} == null ? null : QtCore.QString.FromUtf16(ref *__stringPtr{0}, {1}.Length);",
ctx.ParameterIndex, ctx.Parameter.Name);
var 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)
{
this.Type.TryGetClass(out @class);
}
this.typePrinter = this.typePrinter ?? (this.typePrinter = new CSharpTypePrinter(ctx.Context));
var qualifiedIdentifier = (@class.OriginalClass ?? @class).Visit(this.typePrinter);
ctx.Return.Write("ReferenceEquals(__qstring{0}, null) ? new {1}.{2}() : *({1}.{2}*) (__qstring{0}.{3})",
ctx.ParameterIndex, qualifiedIdentifier, Helpers.InternalStruct, Helpers.InstanceIdentifier);
}
public override bool VisitPointerType(PointerType pointer, TypeQualifiers quals)
{
if (!VisitType(pointer, quals))
{
return(false);
}
var pointee = pointer.Pointee.Desugar();
if (pointee.IsPrimitiveType(PrimitiveType.Void))
{
Context.Return.Write("::System::IntPtr({0})", Context.ReturnVarName);
return(true);
}
if (CSharpTypePrinter.IsConstCharString(pointer))
{
Context.Return.Write(MarshalStringToManaged(Context.ReturnVarName,
pointer.Pointee.Desugar() as BuiltinType));
return(true);
}
PrimitiveType primitive;
var param = Context.Parameter;
if (param != null && (param.IsOut || param.IsInOut) &&
pointee.IsPrimitiveType(out primitive))
{
Context.Return.Write(Context.ReturnVarName);
return(true);
}
if (pointee.IsPrimitiveType(out primitive))
{
var returnVarName = Context.ReturnVarName;
if (quals.IsConst != Context.ReturnType.Qualifiers.IsConst)
{
var nativeTypePrinter = new CppTypePrinter(Context.Driver.TypeDatabase, false);
var returnType = Context.ReturnType.Type.Desugar();
var constlessPointer = new PointerType()
{
IsDependent = pointer.IsDependent,
Modifier = pointer.Modifier,
QualifiedPointee = new QualifiedType(returnType.GetPointee())
};
var nativeConstlessTypeName = constlessPointer.Visit(nativeTypePrinter, new TypeQualifiers());
returnVarName = string.Format("const_cast<{0}>({1})",
nativeConstlessTypeName, Context.ReturnVarName);
}
if (pointer.Pointee is TypedefType)
{
var desugaredPointer = new PointerType()
{
IsDependent = pointer.IsDependent,
Modifier = pointer.Modifier,
QualifiedPointee = new QualifiedType(pointee)
};
var nativeTypePrinter = new CppTypePrinter(Context.Driver.TypeDatabase);
var nativeTypeName = desugaredPointer.Visit(nativeTypePrinter, quals);
Context.Return.Write("reinterpret_cast<{0}>({1})", nativeTypeName,
returnVarName);
}
else
{
Context.Return.Write(returnVarName);
}
return(true);
}
TypeMap typeMap = null;
Context.Driver.TypeDatabase.FindTypeMap(pointee, out typeMap);
Class @class;
if (pointee.TryGetClass(out @class) && typeMap == null)
{
var instance = (pointer.IsReference) ? "&" + Context.ReturnVarName
: Context.ReturnVarName;
WriteClassInstance(@class, instance);
return(true);
}
return(pointer.Pointee.Visit(this, quals));
}
public override Type CSharpSignatureType(TypePrinterContext ctx) => CSharpTypePrinter.GetUnsignedType(Context.TargetInfo.LongWidth);
public CSharpGenerator(BindingContext context) : base(context)
{
typePrinter = new CSharpTypePrinter(context);
expressionPrinter = new CSharpExpressionPrinter(typePrinter);
}
private bool?CheckForDefaultConstruct(Type desugared, Expression arg, TypeQualifiers qualifiers)
{
// Unwrapping the underlying type behind a possible pointer/reference
Type type = desugared.GetFinalPointee() ?? desugared;
Class decl;
if (!type.TryGetClass(out decl))
{
return(false);
}
var ctor = arg.Declaration as Method;
TypeMap typeMap;
var typePrinterContext = new CSharpTypePrinterContext
{
CSharpKind = CSharpTypePrinterContextKind.DefaultExpression,
Type = type
};
string typePrinterResult = null;
if (Driver.TypeDatabase.FindTypeMap(decl, type, out typeMap))
{
var typeInSignature = typeMap.CSharpSignatureType(typePrinterContext).SkipPointerRefs();
Enumeration @enum;
if (typeInSignature.TryGetEnum(out @enum))
{
return(false);
}
if (ctor == null || !ctor.IsConstructor)
{
return(false);
}
typePrinterResult = typeMap.CSharpSignature(typePrinterContext);
if (typePrinterResult == "string" && ctor.Parameters.Count == 0)
{
arg.String = "\"\"";
return(true);
}
}
var match = regexCtor.Match(arg.String);
if (match.Success)
{
if (ctor != null)
{
var templateSpecializationType = type as TemplateSpecializationType;
var typePrinter = new CSharpTypePrinter(Driver);
typePrinterResult = typePrinterResult ?? (templateSpecializationType != null
? typePrinter.VisitTemplateSpecializationType(templateSpecializationType, qualifiers)
: typePrinter.VisitClassDecl((Class)ctor.Namespace)).Type;
arg.String = string.Format("new {0}{1}", typePrinterResult, match.Groups[2].Value);
if (ctor.Parameters.Count > 0 && ctor.Parameters[0].Type.IsAddress())
{
arg.String = arg.String.Replace("(0)", "()");
}
}
else
{
arg.String = string.Format("new {0}", arg.String);
}
}
else
{
if (ctor != null && ctor.Parameters.Count > 0)
{
var finalPointee = ctor.Parameters[0].Type.SkipPointerRefs().Desugar();
Enumeration @enum;
if (finalPointee.TryGetEnum(out @enum))
{
TranslateEnumExpression(arg, finalPointee, arg.String);
}
}
}
return(decl.IsValueType ? true : (bool?)null);
}
public CSharpGenerator(Driver driver)
: base(driver)
{
typePrinter = new CSharpTypePrinter(driver.TypeDatabase, driver.ASTContext);
CppSharp.AST.Type.TypePrinterDelegate += type => type.Visit(typePrinter).Type;
}
private bool?CheckForDefaultConstruct(Type desugared, Statement statement,
ref string result)
{
var type = desugared.GetFinalPointee() ?? desugared;
Class decl;
if (!type.TryGetClass(out decl))
{
return(false);
}
var ctor = statement as CXXConstructExpr;
TypeMap typeMap;
var typePrinter = new CSharpTypePrinter(Driver);
typePrinter.PushContext(CSharpTypePrinterContextKind.DefaultExpression);
var typePrinterResult = type.Visit(typePrinter).Type;
if (Driver.TypeDatabase.FindTypeMap(decl, type, out typeMap))
{
var typeInSignature = typeMap.CSharpSignatureType(
typePrinter.Context).SkipPointerRefs().Desugar();
Enumeration @enum;
if (typeInSignature.TryGetEnum(out @enum))
{
if (ctor != null &&
(ctor.Arguments.Count == 0 ||
HasSingleZeroArgExpression((Function)ctor.Declaration)))
{
result = "0";
return(true);
}
return(false);
}
if (ctor != null && typePrinterResult == "string" && ctor.Arguments.Count == 0)
{
result = "\"\"";
return(true);
}
}
if (ctor == null)
{
return(decl.IsValueType ? (bool?)false : null);
}
var method = (Method)statement.Declaration;
var expressionSupported = decl.IsValueType && method.Parameters.Count == 0;
if (statement.String.Contains('('))
{
var argsBuilder = new StringBuilder("new ");
argsBuilder.Append(typePrinterResult);
argsBuilder.Append('(');
for (var i = 0; i < ctor.Arguments.Count; i++)
{
var argument = ctor.Arguments[i];
var argResult = argument.String;
expressionSupported &= PrintExpression(method.Parameters[i].Type.Desugar(),
argument, ref argResult) ?? false;
argsBuilder.Append(argResult);
if (i < ctor.Arguments.Count - 1)
{
argsBuilder.Append(", ");
}
}
argsBuilder.Append(')');
result = argsBuilder.ToString();
}
else
{
if (method.Parameters.Count > 0)
{
var paramType = method.Parameters[0].Type.SkipPointerRefs().Desugar();
Enumeration @enum;
if (paramType.TryGetEnum(out @enum))
{
result = TranslateEnumExpression(method, paramType, statement.String);
}
}
}
return(expressionSupported ? true : (bool?)null);
}
public CSharpGenerator(Driver driver) : base(driver)
{
typePrinter = new CSharpTypePrinter(driver);
expressionPrinter = new CSharpExpressionPrinter(typePrinter);
}
private bool?CheckForDefaultConstruct(Type desugared, Expression expression,
ref string result)
{
var type = desugared.GetFinalPointee() ?? desugared;
Class decl;
if (!type.TryGetClass(out decl))
{
return(false);
}
var ctor = expression as CXXConstructExpr;
var typePrinter = new CSharpTypePrinter(Context);
typePrinter.PushMarshalKind(MarshalKind.DefaultExpression);
var typePrinterResult = type.Visit(typePrinter).Type;
TypeMap typeMap;
if (TypeMaps.FindTypeMap(decl, type, out typeMap))
{
var typePrinterContext = new TypePrinterContext()
{
Kind = typePrinter.Kind,
MarshalKind = typePrinter.MarshalKind,
Type = type
};
var typeInSignature = typeMap.CSharpSignatureType(typePrinterContext)
.SkipPointerRefs().Desugar();
Enumeration @enum;
if (typeInSignature.TryGetEnum(out @enum))
{
if (ctor != null &&
(ctor.Arguments.Count == 0 ||
HasSingleZeroArgExpression((Function)ctor.Declaration)))
{
result = "0";
return(true);
}
return(false);
}
if (ctor != null && typePrinterResult == "string" && ctor.Arguments.Count == 0)
{
result = "\"\"";
return(true);
}
}
if (ctor == null)
{
CheckForSimpleExpressions(expression, ref result, desugared);
return(decl.IsValueType ? (bool?)false : null);
}
var method = (Method)expression.Declaration;
var expressionSupported = decl.IsValueType && method.Parameters.Count == 0;
if (expression.String.Contains('('))
{
var argsBuilder = new StringBuilder("new ");
argsBuilder.Append(typePrinterResult);
argsBuilder.Append('(');
for (var i = 0; i < ctor.Arguments.Count; i++)
{
var argument = ctor.Arguments[i];
var argResult = argument.String;
expressionSupported &= PrintExpression(method,
method.Parameters[i].Type.Desugar(), argument, ref argResult) ?? false;
argsBuilder.Append(argResult);
if (i < ctor.Arguments.Count - 1)
{
argsBuilder.Append(", ");
}
}
argsBuilder.Append(')');
result = argsBuilder.ToString();
}
return(expressionSupported ? true : (bool?)null);
}
private string GenerateDelegateSignature(IEnumerable<Parameter> @params, QualifiedType returnType)
{
var typePrinter = new CSharpTypePrinter(Driver);
typePrinter.PushContext(CSharpTypePrinterContextKind.Native);
var typesBuilder = new StringBuilder();
if (!returnType.Type.IsPrimitiveType(PrimitiveType.Void))
{
typesBuilder.Insert(0, returnType.Type.CSharpType(typePrinter));
typesBuilder.Append('_');
}
foreach (var parameter in @params)
{
typesBuilder.Append(parameter.CSharpType(typePrinter));
typesBuilder.Append('_');
}
if (typesBuilder.Length > 0)
typesBuilder.Remove(typesBuilder.Length - 1, 1);
var delegateName = typesBuilder.Replace("global::System.", string.Empty).Replace(
"*", "Ptr").Replace('.', '_').ToString();
if (returnType.Type.IsPrimitiveType(PrimitiveType.Void))
delegateName = "Action_" + delegateName;
else
delegateName = "Func_" + delegateName;
typePrinter.PopContext();
return delegateName;
}
private bool? CheckForDefaultConstruct(Type desugared, Statement arg,
TypeQualifiers qualifiers)
{
// Unwrapping the underlying type behind a possible pointer/reference
Type type = desugared.GetFinalPointee() ?? desugared;
Class decl;
if (!type.TryGetClass(out decl))
return false;
var ctor = arg.Declaration as Method;
TypeMap typeMap;
var typePrinterContext = new CSharpTypePrinterContext
{
CSharpKind = CSharpTypePrinterContextKind.DefaultExpression,
Type = type
};
string typePrinterResult = null;
if (Driver.TypeDatabase.FindTypeMap(decl, type, out typeMap))
{
var typeInSignature = typeMap.CSharpSignatureType(
typePrinterContext).SkipPointerRefs().Desugar();
Enumeration @enum;
if (typeInSignature.TryGetEnum(out @enum))
return false;
if (ctor == null || !ctor.IsConstructor)
return false;
typePrinterResult = typeMap.CSharpSignature(typePrinterContext);
if (typePrinterResult == "string" && ctor.Parameters.Count == 0)
{
arg.String = "\"\"";
return true;
}
}
var match = regexCtor.Match(arg.String);
if (match.Success)
{
if (ctor != null)
{
var templateSpecializationType = type as TemplateSpecializationType;
var typePrinter = new CSharpTypePrinter(Driver);
typePrinterResult = typePrinterResult ?? (templateSpecializationType != null
? typePrinter.VisitTemplateSpecializationType(
templateSpecializationType, qualifiers)
: typePrinter.VisitClassDecl((Class) ctor.Namespace)).Type;
arg.String = string.Format("new {0}{1}", typePrinterResult,
match.Groups[2].Value);
if (ctor.Parameters.Count > 0 && ctor.Parameters[0].Type.IsAddress())
arg.String = arg.String.Replace("(0)", "()");
}
else
arg.String = string.Format("new {0}", arg.String);
}
else
{
if (ctor != null && ctor.Parameters.Count > 0)
{
var finalPointee = ctor.Parameters[0].Type.SkipPointerRefs().Desugar();
Enumeration @enum;
if (finalPointee.TryGetEnum(out @enum))
TranslateEnumExpression(ctor, arg, finalPointee, arg.String);
}
}
return decl.IsValueType ? true : (bool?) null;
}
public override void CSharpMarshalToManaged(CSharpMarshalContext ctx)
{
var type = ctx.ReturnType.Type;
ClassTemplateSpecialization basicString = GetBasicString(type);
Declaration c_str = basicString.Methods.FirstOrDefault(m => m.OriginalName == "c_str");
if (!c_str.IsGenerated)
c_str = basicString.Properties.First(p => p.OriginalName == "c_str");
var typePrinter = new CSharpTypePrinter(ctx.Context);
if (type.IsPointer() || ctx.Declaration is Field)
{
ctx.Return.Write("{0}.{1}({2}).{3}{4}",
basicString.Visit(typePrinter), Helpers.CreateInstanceIdentifier,
ctx.ReturnVarName, c_str.Name, c_str is Method ? "()" : string.Empty);
}
else
{
const string varBasicString = "__basicStringRet";
ctx.SupportBefore.WriteLine("using (var {0} = {1}.{2}({3}))",
varBasicString, basicString.Visit(typePrinter),
Helpers.CreateInstanceIdentifier, ctx.ReturnVarName);
ctx.SupportBefore.WriteStartBraceIndent();
ctx.Return.Write("{0}.{1}{2}", varBasicString, c_str.Name,
c_str is Method ? "()" : string.Empty);
ctx.HasCodeBlock = true;
}
}
private bool? CheckForDefaultConstruct(Type desugared, Expression expression,
ref string result)
{
var type = desugared.GetFinalPointee() ?? desugared;
Class decl;
if (!type.TryGetClass(out decl))
return false;
var ctor = expression as CXXConstructExpr;
TypeMap typeMap;
var typePrinter = new CSharpTypePrinter(Context);
typePrinter.PushMarshalKind(CSharpMarshalKind.DefaultExpression);
var typePrinterResult = type.Visit(typePrinter).Type;
if (TypeMaps.FindTypeMap(decl, type, out typeMap))
{
var typeInSignature = typeMap.CSharpSignatureType(
typePrinter.TypePrinterContext).SkipPointerRefs().Desugar();
Enumeration @enum;
if (typeInSignature.TryGetEnum(out @enum))
{
if (ctor != null &&
(ctor.Arguments.Count == 0 ||
HasSingleZeroArgExpression((Function) ctor.Declaration)))
{
result = "0";
return true;
}
return false;
}
if (ctor != null && typePrinterResult == "string" && ctor.Arguments.Count == 0)
{
result = "\"\"";
return true;
}
}
if (ctor == null)
{
CheckForSimpleExpressions(expression, ref result, desugared);
return decl.IsValueType ? (bool?) false : null;
}
var method = (Method) expression.Declaration;
var expressionSupported = decl.IsValueType && method.Parameters.Count == 0;
if (expression.String.Contains('('))
{
var argsBuilder = new StringBuilder("new ");
argsBuilder.Append(typePrinterResult);
argsBuilder.Append('(');
for (var i = 0; i < ctor.Arguments.Count; i++)
{
var argument = ctor.Arguments[i];
var argResult = argument.String;
expressionSupported &= PrintExpression(method.Parameters[i].Type.Desugar(),
argument, ref argResult) ?? false;
argsBuilder.Append(argResult);
if (i < ctor.Arguments.Count - 1)
argsBuilder.Append(", ");
}
argsBuilder.Append(')');
result = argsBuilder.ToString();
}
else
{
if (method.Parameters.Count > 0)
{
var paramType = method.Parameters[0].Type.SkipPointerRefs().Desugar();
Enumeration @enum;
if (paramType.TryGetEnum(out @enum))
result = TranslateEnumExpression(method, paramType, expression.String);
}
}
return expressionSupported ? true : (bool?) null;
}