public override List<Template> Generate(TranslationUnit unit)
{
var outputs = new List<Template>();
var template = new CSharpTextTemplate(Driver, unit, typePrinter, expressionPrinter);
outputs.Add(template);
return outputs;
}
public override List <Template> Generate(IEnumerable <TranslationUnit> units)
{
var outputs = new List <Template>();
var template = new CSharpTextTemplate(Driver, units, typePrinter, expressionPrinter);
outputs.Add(template);
return(outputs);
}
public override List <Template> Generate(TranslationUnit unit)
{
var outputs = new List <Template>();
var template = new CSharpTextTemplate(Driver, unit, typePrinter);
outputs.Add(template);
return(outputs);
}
public void GenerateClass(Class @class)
{
if (@class.Ignore || @class.IsIncomplete)
{
return;
}
GenerateDeclarationCommon(@class);
if (GenerateClassProlog(@class))
{
return;
}
// Process the nested types.
PushIndent();
GenerateDeclContext(@class);
PopIndent();
var nativeType = string.Format("::{0}*", @class.QualifiedOriginalName);
if (CSharpTextTemplate.ShouldGenerateClassNativeField(@class))
{
GenerateClassNativeField(@class, nativeType);
}
GenerateClassConstructors(@class, nativeType);
GenerateClassProperties(@class);
GenerateClassEvents(@class);
GenerateClassMethods(@class);
if (Options.GenerateFunctionTemplates)
{
GenerateClassGenericMethods(@class);
}
GenerateClassVariables(@class);
if (@class.Fields.Any())
{
PushBlock(CLIBlockKind.AccessSpecifier);
WriteLine("private:");
PopBlock(NewLineKind.IfNotEmpty);
PushBlock(CLIBlockKind.Fields);
GenerateClassFields(@class);
PopBlock();
}
WriteLine("};");
}
public bool GenerateClassProlog(Class @class)
{
if (@class.IsUnion)
{
WriteLine("[System::Runtime::InteropServices::StructLayout({0})]",
"System::Runtime::InteropServices::LayoutKind::Explicit");
}
// Nested types cannot have visibility modifiers in C++/CLI.
var isTopLevel = @class.Namespace is TranslationUnit ||
@class.Namespace is Namespace;
if (isTopLevel)
{
Write("public ");
}
Write(@class.IsValueType ? "value struct " : "ref class ");
Write("{0}", @class.Name);
if (@class.IsStatic)
{
Write(" abstract sealed");
}
if (@class.IsOpaque)
{
WriteLine(";");
return(true);
}
if ([email protected])
{
if (CSharpTextTemplate.HasRefBase(@class))
{
Write(" : {0}", QualifiedIdentifier(@class.Bases[0].Class));
}
else if (@class.IsRefType)
{
Write(" : ICppInstance");
}
}
NewLine();
WriteLine("{");
WriteLine("public:");
NewLine();
return(false);
}
private void GenerateClassFinalizer(Class @class)
{
PushBlock(CLIBlockKind.Finalizer);
WriteLine("{0}::!{1}()", QualifiedIdentifier(@class), @class.Name);
WriteStartBraceIndent();
if (CSharpTextTemplate.ShouldGenerateClassNativeField(@class))
{
WriteLine("delete NativePtr;");
}
WriteCloseBraceIndent();
PopBlock(NewLineKind.BeforeNextBlock);
}
public void GenerateClass(Class @class)
{
PushBlock(CLIBlockKind.Class);
GenerateDeclContext(@class);
// Output a default constructor that takes the native pointer.
GenerateClassConstructor(@class, isIntPtr: false);
GenerateClassConstructor(@class, isIntPtr: true);
if (@class.IsRefType)
{
GenerateClassDestructor(@class);
GenerateClassFinalizer(@class);
}
foreach (var method in @class.Methods)
{
if (ASTUtils.CheckIgnoreMethod(method))
{
continue;
}
GenerateMethod(method, @class);
}
if (CSharpTextTemplate.ShouldGenerateClassNativeField(@class))
{
PushBlock(CLIBlockKind.Method);
WriteLine("System::IntPtr {0}::{1}::get()",
QualifiedIdentifier(@class), Helpers.InstanceIdentifier);
WriteStartBraceIndent();
WriteLine("return System::IntPtr(NativePtr);");
WriteCloseBraceIndent();
PopBlock(NewLineKind.BeforeNextBlock);
PushBlock(CLIBlockKind.Method);
WriteLine("void {0}::{1}::set(System::IntPtr object)",
QualifiedIdentifier(@class), Helpers.InstanceIdentifier);
WriteStartBraceIndent();
var nativeType = string.Format("::{0}*", @class.QualifiedOriginalName);
WriteLine("NativePtr = ({0})object.ToPointer();", nativeType);
WriteCloseBraceIndent();
PopBlock(NewLineKind.BeforeNextBlock);
}
GenerateClassProperties(@class, @class);
foreach (var @event in @class.Events)
{
if (@event.Ignore)
{
continue;
}
GenerateDeclarationCommon(@event);
GenerateEvent(@event, @class);
}
foreach (var variable in @class.Variables)
{
if (variable.Ignore)
{
continue;
}
if (variable.Access != AccessSpecifier.Public)
{
continue;
}
GenerateDeclarationCommon(variable);
GenerateVariable(variable, @class);
}
PopBlock();
}
public void GenerateClass(Class @class)
{
PushBlock(CLIBlockKind.Class);
GenerateDeclContext(@class);
GenerateClassConstructors(@class);
foreach (var method in @class.Methods)
{
if (ASTUtils.CheckIgnoreMethod(method, Options))
{
continue;
}
// C++/CLI does not allow special member funtions for value types.
if (@class.IsValueType && method.IsCopyConstructor)
{
continue;
}
GenerateMethod(method, @class);
}
if (CSharpTextTemplate.ShouldGenerateClassNativeField(@class))
{
PushBlock(CLIBlockKind.Method);
WriteLine("System::IntPtr {0}::{1}::get()",
QualifiedIdentifier(@class), Helpers.InstanceIdentifier);
WriteStartBraceIndent();
WriteLine("return System::IntPtr(NativePtr);");
WriteCloseBraceIndent();
PopBlock(NewLineKind.BeforeNextBlock);
PushBlock(CLIBlockKind.Method);
WriteLine("void {0}::{1}::set(System::IntPtr object)",
QualifiedIdentifier(@class), Helpers.InstanceIdentifier);
WriteStartBraceIndent();
var nativeType = string.Format("::{0}*", @class.QualifiedOriginalName);
WriteLine("NativePtr = ({0})object.ToPointer();", nativeType);
WriteCloseBraceIndent();
PopBlock(NewLineKind.BeforeNextBlock);
}
GenerateClassProperties(@class, @class);
foreach (var @event in @class.Events)
{
if ([email protected])
{
continue;
}
GenerateDeclarationCommon(@event);
GenerateEvent(@event, @class);
}
foreach (var variable in @class.Variables)
{
if (!variable.IsGenerated)
{
continue;
}
if (variable.Access != AccessSpecifier.Public)
{
continue;
}
GenerateDeclarationCommon(variable);
GenerateVariable(variable, @class);
}
PopBlock();
}
public override bool VisitClassDecl(Class @class)
{
var ctx = Context as CSharpMarshalContext;
string instance = Context.ReturnVarName;
if (@class.IsRefType &&
(Context.ReturnType.Qualifiers.IsConst || !Context.ReturnType.Type.IsAddress()) &&
(!Context.Driver.Options.GenerateAbstractImpls || [email protected]))
{
var instanceName = Generator.GeneratedIdentifier("instance");
if (VarSuffix > 0)
{
instanceName += VarSuffix;
}
if (@class.HasNonTrivialCopyConstructor)
{
// Find a valid copy constructor overload.
var copyCtorMethod = @class.Methods.FirstOrDefault(method =>
method.IsCopyConstructor);
if (copyCtorMethod == null)
{
throw new NotSupportedException("Expected a valid copy constructor");
}
// Call the copy constructor.
TypeMap typeMap;
if (!copyCtorMethod.IsGenerated && FindTypeMap(ctx.Driver.TypeDatabase, @class, out typeMap))
{
typeMap.CSharpMarshalCopyCtorToManaged(Context);
}
else
{
// Allocate memory for a new native object and call the ctor.
Context.SupportBefore.WriteLine("var {0} = Marshal.AllocHGlobal({1});",
instanceName, @class.Layout.Size);
Context.SupportBefore.WriteLine("{0}.Internal.{1}({2}, new global::System.IntPtr(&{3}));",
QualifiedIdentifier(@class),
CSharpTextTemplate.GetFunctionNativeIdentifier(copyCtorMethod),
instanceName, instance);
}
}
else
{
// Allocate memory for a new native object and call the ctor.
Context.SupportBefore.WriteLine("var {0} = Marshal.AllocHGlobal({1});",
instanceName, @class.Layout.Size);
instance = instance.Trim('*');
Context.SupportBefore.WriteLine(
"CppSharp.Runtime.Helpers.memcpy({0}, new IntPtr(&{1}), new UIntPtr({2}));",
instanceName, instance, @class.Layout.Size);
}
instance = instanceName;
}
if (@class.IsRefType)
{
Context.Return.Write("({0} == IntPtr.Zero) ? null : ",
instance);
}
Context.Return.Write("new {0}({1})",
QualifiedIdentifier(@class.OriginalClass ?? @class) +
(Context.Driver.Options.GenerateAbstractImpls && @class.IsAbstract ?
"Internal" : ""),
instance);
return(true);
}
