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(); }