public void GenerateClassMethods(Class @class)
{
PushIndent();
var staticMethods = new List <Method>();
foreach (var method in @class.Methods)
{
if (ASTUtils.CheckIgnoreMethod(method))
{
continue;
}
if (method.IsConstructor)
{
continue;
}
if (method.IsStatic)
{
staticMethods.Add(method);
continue;
}
GenerateMethod(method);
}
foreach (var method in staticMethods)
{
GenerateMethod(method);
}
PopIndent();
}
private void GenerateClassMethods(Class @class, Class realOwner)
{
if (@class.IsValueType)
{
foreach (var @base in @class.Bases.Where(b => b.IsClass && !b.Class.Ignore))
{
GenerateClassMethods(@base.Class, realOwner);
}
}
foreach (var method in @class.Methods)
{
if (ASTUtils.CheckIgnoreMethod(method, this.Options))
{
continue;
}
// C++/CLI does not allow special member funtions for value types.
if (@class.IsValueType && method.IsCopyConstructor)
{
continue;
}
GenerateMethod(method, realOwner);
}
}
public void GenerateClassConstructors(Class @class, string nativeType)
{
PushIndent();
// Output a default constructor that takes the native pointer.
WriteLine("{0}({1} native);", SafeIdentifier(@class.Name), nativeType);
WriteLine("{0}({1} native);", SafeIdentifier(@class.Name), "System::IntPtr");
foreach (var ctor in @class.Constructors)
{
if (ASTUtils.CheckIgnoreMethod(ctor))
{
continue;
}
GenerateMethod(ctor);
}
if (@class.IsRefType)
{
GenerateClassDestructor(@class);
GenerateClassFinalizer(@class);
}
PopIndent();
}
private void GenerateClassMethods(Class @class, Class realOwner)
{
if (@class.IsValueType)
{
foreach (var @base in @class.Bases.Where(b => b.IsClass && !b.Class.Ignore))
{
GenerateClassMethods(@base.Class, realOwner);
}
}
foreach (var method in @class.Methods.Where(m => @class == realOwner || !m.IsOperator))
{
if (ASTUtils.CheckIgnoreMethod(method) || CLIHeaders.FunctionIgnored(method))
{
continue;
}
// C++/CLI does not allow special member funtions for value types.
if (@class.IsValueType && method.IsCopyConstructor)
{
continue;
}
// Do not generate constructors or destructors from base classes.
var declaringClass = method.Namespace as Class;
if (declaringClass != realOwner && (method.IsConstructor || method.IsDestructor))
{
continue;
}
GenerateMethod(method, realOwner);
}
}
public virtual void VisitClassConstructors(Class @class)
{
foreach (var ctor in @class.Constructors.Where(c => !ASTUtils.CheckIgnoreMethod(c)))
{
ctor.Visit(this);
}
}
public override bool VisitMethodDecl(Method method)
{
if (!VisitDeclaration(method))
{
return(false);
}
if (ASTUtils.CheckIgnoreMethod(method, Driver.Options))
{
return(false);
}
var @class = method.Namespace as Class;
if (@class == null || @class.IsIncomplete)
{
return(false);
}
if (method.IsConstructor)
{
return(false);
}
if (IsGetter(method))
{
var name = method.Name.Substring("get".Length);
var prop = GetOrCreateProperty(@class, name, method.ReturnType);
prop.GetMethod = method;
prop.Access = method.Access;
// Do not generate the original method now that we know it is a getter.
method.IsGenerated = false;
Driver.Diagnostics.Debug("Getter created: {0}::{1}", @class.Name, name);
return(false);
}
if (IsSetter(method) && IsValidSetter(method))
{
var name = method.Name.Substring("set".Length);
var type = method.Parameters[0].QualifiedType;
var prop = GetOrCreateProperty(@class, name, type);
prop.SetMethod = method;
prop.Access = method.Access;
// Ignore the original method now that we know it is a setter.
method.IsGenerated = false;
Driver.Diagnostics.Debug("Setter created: {0}::{1}", @class.Name, name);
return(false);
}
return(false);
}
public void GenerateMethod(Method method)
{
if (ASTUtils.CheckIgnoreMethod(method, Options))
{
return;
}
PushBlock(CLIBlockKind.Method, method);
GenerateDeclarationCommon(method);
if ((method.IsVirtual || method.IsOverride) && !method.IsOperator)
{
Write("virtual ");
}
var isBuiltinOperator = method.IsOperator &&
Operators.IsBuiltinOperator(method.OperatorKind);
if (method.IsStatic || isBuiltinOperator)
{
Write("static ");
}
if (method.OperatorKind == CXXOperatorKind.ExplicitConversion)
{
Write("explicit ");
}
if (method.IsConstructor || method.IsDestructor ||
method.OperatorKind == CXXOperatorKind.Conversion ||
method.OperatorKind == CXXOperatorKind.ExplicitConversion)
{
Write("{0}(", GetMethodName(method));
}
else
{
Write("{0} {1}(", method.ReturnType, method.Name);
}
GenerateMethodParameters(method);
Write(")");
if (method.IsOverride)
{
Write(" override");
}
WriteLine(";");
if (method.OperatorKind == CXXOperatorKind.EqualEqual)
{
GenerateEquals(method, (Class)method.Namespace);
}
PopBlock(NewLineKind.BeforeNextBlock);
}
public void GenerateClassMethods(List <Method> methods)
{
if (methods.Count == 0)
{
return;
}
Indent();
var @class = (Class)methods[0].Namespace;
if (@class.IsValueType)
{
foreach (var @base in @class.Bases.Where(b => b.IsClass && !b.Class.Ignore))
{
GenerateClassMethods(@base.Class.Methods.Where(m => !m.IsOperator).ToList());
}
}
var staticMethods = new List <Method>();
foreach (var method in methods)
{
if (ASTUtils.CheckIgnoreMethod(method) || FunctionIgnored(method))
{
continue;
}
if (method.IsConstructor)
{
continue;
}
if (method.IsOperator)
{
continue;
}
if (method.IsStatic)
{
staticMethods.Add(method);
continue;
}
method.Visit(this);
}
foreach (var method in staticMethods)
{
method.Visit(this);
}
Unindent();
}
public virtual void VisitClassMethods(Class @class)
{
foreach (var method in @class.Methods.Where(c => !ASTUtils.CheckIgnoreMethod(c)))
{
if (method.IsConstructor)
{
continue;
}
method.Visit(this);
}
}
public void GenerateClassConstructors(Class @class, string nativeType)
{
if (@class.IsStatic)
{
return;
}
PushIndent();
// Output a default constructor that takes the native pointer.
WriteLine("{0}({1} native);", @class.Name, nativeType);
WriteLine("static {0}^ {1}(::System::IntPtr native);",
@class.Name, Helpers.CreateInstanceIdentifier);
if (@class.IsRefType)
{
WriteLine("static {0}^ {1}(::System::IntPtr native, bool {2});",
@class.Name, Helpers.CreateInstanceIdentifier, Helpers.OwnsNativeInstanceIdentifier);
}
foreach (var ctor in @class.Constructors)
{
if (ASTUtils.CheckIgnoreMethod(ctor, Options))
{
continue;
}
// C++/CLI does not allow special member funtions for value types.
if (@class.IsValueType && ctor.IsCopyConstructor)
{
continue;
}
GenerateMethod(ctor);
}
if (@class.IsRefType)
{
var destructor = @class.Destructors
.FirstOrDefault(d => d.Parameters.Count == 0 && d.Access == AccessSpecifier.Public);
if (destructor != null)
{
GenerateClassDestructor(@class);
if (Options.GenerateFinalizers)
{
GenerateClassFinalizer(@class);
}
}
}
PopIndent();
}
public override bool VisitMethodDecl(Method decl)
{
if (ASTUtils.CheckIgnoreMethod(decl))
{
return(false);
}
if (!AlreadyVisited(decl))
{
CheckDuplicate(decl);
}
return(false);
}
public void GenerateMethod(Method method)
{
if (ASTUtils.CheckIgnoreMethod(method, Options))
{
return;
}
PushBlock(BlockKind.Method, method);
GenerateDeclarationCommon(method);
GenerateMethodSpecifier(method, method.Namespace as Class);
WriteLine(";");
PopBlock(NewLineKind.BeforeNextBlock);
}
public override bool VisitMethodDecl(Method method)
{
if (ASTUtils.CheckIgnoreMethod(method) || FunctionIgnored(method))
{
return(false);
}
PushBlock(BlockKind.Method, method);
GenerateDeclarationCommon(method);
GenerateMethodSpecifier(method, method.Namespace as Class);
WriteLine(";");
PopBlock(NewLineKind.BeforeNextBlock);
return(true);
}
public void GenerateMethod(Method method)
{
if (ASTUtils.CheckIgnoreMethod(method))
{
return;
}
PushBlock(CLIBlockKind.Method, method);
GenerateDeclarationCommon(method);
if (method.IsVirtual || method.IsOverride)
{
Write("virtual ");
}
var isBuiltinOperator = method.IsOperator &&
Operators.IsBuiltinOperator(method.OperatorKind);
if (method.IsStatic || isBuiltinOperator)
{
Write("static ");
}
if (method.Kind == CXXMethodKind.Constructor || method.Kind == CXXMethodKind.Destructor)
{
Write("{0}(", SafeIdentifier(method.Name));
}
else
{
Write("{0} {1}(", method.ReturnType, SafeIdentifier(method.Name));
}
GenerateMethodParameters(method);
Write(")");
if (method.IsOverride)
{
Write(" override");
}
WriteLine(";");
PopBlock(NewLineKind.Always);
}
public void GenerateClassConstructors(Class @class, string nativeType)
{
if (@class.IsStatic)
{
return;
}
Indent();
var classNativeName = @class.Visit(CTypePrinter);
CTypePrinter.PushContext(TypePrinterContextKind.Native);
var classManagedName = @class.Visit(CTypePrinter);
CTypePrinter.PopContext();
WriteLine($"{@class.Name}({classManagedName}* native);");
NewLine();
foreach (var ctor in @class.Constructors)
{
if (ASTUtils.CheckIgnoreMethod(ctor) || FunctionIgnored(ctor))
{
continue;
}
ctor.Visit(this);
}
if (@class.IsRefType)
{
var destructor = @class.Destructors
.FirstOrDefault(d => d.Parameters.Count == 0 && d.Access == AccessSpecifier.Public);
if (destructor != null)
{
GenerateClassDestructor(@class);
if (Options.GenerateFinalizers)
{
GenerateClassFinalizer(@class);
}
}
}
Unindent();
}
public void GenerateClassConstructors(Class @class)
{
if (@class.IsStatic)
{
return;
}
foreach (var ctor in @class.Constructors)
{
if (ASTUtils.CheckIgnoreMethod(ctor, Options))
{
continue;
}
GenerateMethod(ctor);
}
}
public override bool VisitMethodDecl(Method decl)
{
if (!VisitDeclaration(decl))
{
return(false);
}
if (ASTUtils.CheckIgnoreMethod(decl))
{
return(false);
}
if (decl.ExplicitInterfaceImpl == null)
{
CheckDuplicate(decl);
}
return(false);
}
public void GenerateClassMethods(Class @class)
{
PushIndent();
if (@class.IsValueType)
{
foreach (var @base in @class.Bases.Where(b => b.IsClass && !b.Class.Ignore))
{
GenerateClassMethods(@base.Class);
}
}
var staticMethods = new List <Method>();
foreach (var method in @class.Methods)
{
if (ASTUtils.CheckIgnoreMethod(method, Options))
{
continue;
}
if (method.IsConstructor)
{
continue;
}
if (method.IsStatic)
{
staticMethods.Add(method);
continue;
}
GenerateMethod(method);
}
foreach (var method in staticMethods)
{
GenerateMethod(method);
}
PopIndent();
}
public void GenerateMethod(Method method)
{
if (ASTUtils.CheckIgnoreMethod(method) || FunctionIgnored(method))
{
return;
}
PushBlock(BlockKind.Method, method);
GenerateDeclarationCommon(method);
GenerateMethodSpecifier(method, method.Namespace as Class);
WriteLine(";");
if (method.OperatorKind == CXXOperatorKind.EqualEqual)
{
GenerateEquals(method, (Class)method.Namespace);
}
PopBlock(NewLineKind.BeforeNextBlock);
}
public virtual void GenerateClassMethods(Class @class)
{
foreach (var method in @class.Methods.Where(m => !m.IsOperator))
{
if (ASTUtils.CheckIgnoreMethod(method) || CppHeaders.FunctionIgnored(method))
{
continue;
}
// Do not generate property getter/setter methods as they will be generated
// as part of properties generation.
var field = (method?.AssociatedDeclaration as Property)?.Field;
if (field != null)
{
continue;
}
method.Visit(this);
}
}
public void GenerateClassConstructors(Class @class)
{
if (@class.IsStatic)
{
return;
}
Indent();
var classNativeName = @class.Visit(CTypePrinter);
foreach (var ctor in @class.Constructors)
{
if (ASTUtils.CheckIgnoreMethod(ctor) || FunctionIgnored(ctor))
{
continue;
}
ctor.Visit(this);
}
Unindent();
}
public void GenerateClassConstructors(Class @class, string nativeType)
{
if (@class.IsStatic)
{
return;
}
PushIndent();
// Output a default constructor that takes the native pointer.
WriteLine("{0}({1} native);", @class.Name, nativeType);
WriteLine("{0}({1} native);", @class.Name, "System::IntPtr");
foreach (var ctor in @class.Constructors)
{
if (ASTUtils.CheckIgnoreMethod(ctor, Options))
{
continue;
}
// C++/CLI does not allow special member funtions for value types.
if (@class.IsValueType && ctor.IsCopyConstructor)
{
continue;
}
GenerateMethod(ctor);
}
if (@class.IsRefType)
{
GenerateClassDestructor(@class);
GenerateClassFinalizer(@class);
}
PopIndent();
}
public void GenerateClass(Class @class)
{
PushBlock(CLIBlockKind.Class);
// Output a default constructor that takes the native pointer.
GenerateClassConstructor(@class, isIntPtr: false);
GenerateClassConstructor(@class, isIntPtr: true);
foreach (var method in @class.Methods)
{
if (ASTUtils.CheckIgnoreMethod(method))
{
continue;
}
GenerateMethod(method, @class);
}
if (@class.IsRefType)
{
if (!CLIHeadersTemplate.HasRefBase(@class))
{
PushBlock(CLIBlockKind.Method);
WriteLine("System::IntPtr {0}::Instance::get()",
QualifiedIdentifier(@class));
WriteStartBraceIndent();
WriteLine("return System::IntPtr(NativePtr);");
WriteCloseBraceIndent();
PopBlock(NewLineKind.BeforeNextBlock);
PushBlock(CLIBlockKind.Method);
WriteLine("void {0}::Instance::set(System::IntPtr object)",
QualifiedIdentifier(@class));
WriteStartBraceIndent();
var nativeType = string.Format("::{0}*", @class.QualifiedOriginalName);
WriteLine("NativePtr = ({0})object.ToPointer();", nativeType);
WriteCloseBraceIndent();
PopBlock(NewLineKind.BeforeNextBlock);
}
}
foreach (var property in @class.Properties)
{
GenerateProperty(property);
}
foreach (var @event in @class.Events)
{
if (@event.Ignore)
{
continue;
}
GenerateDeclarationCommon(@event);
GenerateEvent(@event, @class);
}
if (Options.GenerateFunctionTemplates)
{
foreach (var template in @class.Templates)
{
if (template.Ignore)
{
continue;
}
var functionTemplate = template as FunctionTemplate;
if (functionTemplate == null)
{
continue;
}
GenerateDeclarationCommon(template);
GenerateFunctionTemplate(functionTemplate, @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);
// 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();
}
