public void GenerateClassFields(Class @class) { // Handle the case of struct (value-type) inheritance by adding the base // properties to the managed value subtypes. if (@class.IsValueType) { foreach (var @base in @class.Bases.Where(b => b.IsClass && b.Class.IsDeclared)) { GenerateClassFields(@base.Class); } } Indent(); // check for value types because some of the ignored fields may back properties; // not the case for ref types because the NativePtr pattern is used there foreach (var field in @class.Fields.Where(f => !ASTUtils.CheckIgnoreField(f))) { var property = @class.Properties.FirstOrDefault(p => p.Field == field); if (property != null && !property.IsInRefTypeAndBackedByValueClassField()) { field.Visit(this); } } Unindent(); }
public override bool VisitFieldDecl(Field field) { var @class = field.Namespace as Class; if (@class == null) { return(false); } if (@class.IsValueType) { return(false); } if (ASTUtils.CheckIgnoreField(field)) { return(false); } var prop = new Property() { Name = field.Name, Namespace = field.Namespace, QualifiedType = field.QualifiedType, Field = field }; @class.Properties.Add(prop); field.ExplicityIgnored = true; return(false); }
public override bool VisitFieldDecl(Field field) { if (!VisitDeclaration(field)) { return(false); } if (ASTUtils.CheckIgnoreField(field)) { return(false); } var @class = field.Namespace as Class; if (@class == null) { return(false); } // Check if we already have a synthetized property. var existingProp = @class.Properties.FirstOrDefault(property => property.Field == field); if (existingProp != null) { return(false); } field.GenerationKind = GenerationKind.Internal; var prop = new Property { Name = field.Name, Namespace = field.Namespace, QualifiedType = field.QualifiedType, Access = field.Access, Field = field, AssociatedDeclaration = field }; if (Options.GeneratorKind == GeneratorKind.CPlusPlus) { GenerateAcessorMethods(field, prop); } // do not rename value-class fields because they would be // generated as fields later on even though they are wrapped by properties; // that is, in turn, because it's cleaner to write // the struct marshalling logic just for properties if (!prop.IsInRefTypeAndBackedByValueClassField()) { field.Name = Generator.GeneratedIdentifier(field.Name); } @class.Properties.Add(prop); Diagnostics.Debug($"Property created from field: {field.QualifiedName}"); return(false); }
public override bool VisitFieldDecl(Field field) { if (!VisitDeclaration(field)) { return(false); } var @class = field.Namespace as Class; if (@class == null) { return(false); } if (ASTUtils.CheckIgnoreField(field)) { return(false); } // Check if we already have a synthetized property. var existingProp = @class.Properties.FirstOrDefault(property => property.Name == field.Name && property.QualifiedType == field.QualifiedType); if (existingProp != null) { field.ExplicityIgnored = true; return(false); } field.ExplicityIgnored = true; var prop = new Property { Name = field.Name, Namespace = field.Namespace, QualifiedType = field.QualifiedType, Access = field.Access, Field = field }; // do not rename value-class fields because they would be // generated as fields later on even though they are wrapped by properties; // that is, in turn, because it's cleaner to write // the struct marshalling logic just for properties if (!prop.IsInRefTypeAndBackedByValueClassField()) { field.Name = Generator.GeneratedIdentifier(field.Name); } @class.Properties.Add(prop); Log.Debug("Property created from field: {0}::{1}", @class.Name, field.Name); return(false); }
public override bool VisitFieldDecl(Field decl) { if (ASTUtils.CheckIgnoreField(decl)) { return(false); } if (!AlreadyVisited(decl)) { CheckDuplicate(decl); } return(false); }
public override bool VisitFieldDecl(Field decl) { if (!VisitDeclaration(decl)) { return(false); } if (ASTUtils.CheckIgnoreField(decl)) { return(false); } CheckDuplicate(decl); return(false); }
public virtual bool VisitClassDeclContext(Class @class) { if (!VisitDeclContext(@class)) { return(false); } foreach (var field in @class.Fields.Where(f => !ASTUtils.CheckIgnoreField(f))) { field.Visit(this); } foreach (var property in @class.Properties.Where(p => !ASTUtils.CheckIgnoreProperty(p))) { property.Visit(this); } VisitClassConstructors(@class); VisitClassMethods(@class); foreach (var @event in @class.Events) { if ([email protected]) { continue; } @event.Visit(this); } foreach (var variable in @class.Variables) { if (!variable.IsGenerated) { continue; } if (variable.Access != AccessSpecifier.Public) { continue; } variable.Visit(this); } return(true); }
public void GenerateClassFields(Class @class) { if ([email protected]) { return; } // Handle the case of struct (value-type) inheritance by adding the base // fields to the managed value subtypes. foreach (var @base in @class.Bases) { Class baseClass; if ([email protected](out baseClass)) { continue; } if (!baseClass.IsValueType || baseClass.Ignore) { Console.WriteLine("Ignored base class of value type '{0}'", baseClass.Name); continue; } GenerateClassFields(baseClass); } PushIndent(); foreach (var field in @class.Fields) { if (ASTUtils.CheckIgnoreField(field)) { continue; } GenerateDeclarationCommon(field); if (@class.IsUnion) { WriteLine("[FieldOffset({0})]", field.Offset); } WriteLine("{0} {1};", field.Type, SafeIdentifier(field.Name)); } PopIndent(); }
private void GenerateStructMarshaling(Class @class, string nativeVar) { foreach (var @base in @class.Bases) { if ([email protected] || @base.Class.Ignore) { continue; } var baseClass = @base.Class; GenerateStructMarshaling(baseClass, nativeVar); } foreach (var field in @class.Fields) { if (ASTUtils.CheckIgnoreField(field)) { continue; } var nativeField = string.Format("{0}{1}", nativeVar, field.OriginalName); var ctx = new MarshalContext(Driver) { ArgName = field.Name, ReturnVarName = nativeField, ReturnType = field.QualifiedType }; var marshal = new CLIMarshalNativeToManagedPrinter(ctx); field.Visit(marshal); if (!string.IsNullOrWhiteSpace(marshal.Context.SupportBefore)) { Write(marshal.Context.SupportBefore); } WriteLine("{0} = {1};", field.Name, marshal.Context.Return); } }
public virtual bool VisitClassDeclContext(Class @class) { if (!VisitDeclContext(@class)) { return(false); } foreach (var field in @class.Fields.Where(f => !ASTUtils.CheckIgnoreField(f))) { field.Visit(this); } foreach (var property in @class.Properties.Where(p => !ASTUtils.CheckIgnoreProperty(p))) { property.Visit(this); } VisitClassConstructors(@class); VisitClassMethods(@class); return(true); }