public static GetterSetter GetPropertyInfo(CXXMethodDecl decl) { GetterSetter gs; if (allPropertyMethods.TryGetValue(decl, out gs)) { return(gs); } return(null); }
public static IEnumerable <string> GetMethodComments(CXXMethodDecl decl) { return(ExtractTextComments(decl.DumpToString())); }
public override void VisitCXXMethodDecl(CXXMethodDecl decl, VisitKind visitKind) { if (visitKind != VisitKind.Enter) { return; } var isConstructor = decl is CXXConstructorDecl; if (decl is CXXDestructorDecl || isConstructor) { return; } if (decl.IsCopyAssignmentOperator || decl.IsMoveAssignmentOperator) { return; } if (decl.Parent == null) { return; } if (!decl.Parent.QualifiedName.StartsWith("Urho3D::")) { return; } // Only get methods prefixed with Get with no parameters // and Set methods that return void and take a single parameter var name = decl.Name; // Handle Get methods that are not really getters // This is a get method that does not get anything QualType type; if (name.StartsWith("Get") || name.StartsWith("Is")) { if (decl.Parameters.Count() != 0) { return; } if (decl.ReturnQualType.ToString() == "void") { return; } if (name == "IsElementEventSender" || name == "IsOpen" || name == "IsPressed") { return; } type = decl.ReturnQualType; } else if (name.StartsWith("Set")) { if (decl.Parameters.Count() != 1) { return; } if (!(decl.ReturnQualType.Bind() is Sharpie.Bind.Types.VoidType)) { return; } if ((name == "SetTypeName" || name == "SetType") && decl.Parent.Name == "UnknownComponent") { return; } if (decl.Access != AccessSpecifier.Public) { return; } type = decl.Parameters.FirstOrDefault().QualType; } else { return; } Dictionary <string, Dictionary <QualType, GetterSetter> > typeProperties; if (!allProperties.TryGetValue(decl.Parent.Name, out typeProperties)) { typeProperties = new Dictionary <string, Dictionary <QualType, GetterSetter> >(); allProperties[decl.Parent.Name] = typeProperties; } var propName = name.Substring(name.StartsWith("Is") ? 2 : 3); Dictionary <QualType, GetterSetter> property; if (!typeProperties.TryGetValue(propName, out property)) { property = new Dictionary <QualType, GetterSetter>(); typeProperties[propName] = property; } GetterSetter gs; if (!property.TryGetValue(type, out gs)) { gs = new GetterSetter() { Name = propName }; } if (name.StartsWith("Get") || name.StartsWith("Is")) { Console.WriteLine($"Getter exists for {name}"); if (propName != decl.Parent.Name || propName == "Text") { // do not generate Getter if propertyName equals to typename (Text type already has a workaround for this case) gs.Getter = decl; } } else { if (gs.Setter != null) { Console.WriteLine($"Setter exists for {name}"); } gs.Setter = decl; } property[type] = gs; }
public override void VisitCXXMethodDecl(CXXMethodDecl decl, VisitKind visitKind) { if (!MethodIsBindable (decl, visitKind)) return; var cmethodBuilder = new StringBuilder(); AstType pinvokeReturn, methodReturn; WrapKind returnIsWrapped; ICSharpCode.NRefactory.CSharp.ParameterModifier pinvokeMod, methodMod; LookupMarshalTypes(decl.ReturnQualType, out pinvokeReturn, out pinvokeMod, out methodReturn, out methodMod, out returnIsWrapped, isReturn: true); var methodReturn2 = methodReturn.Clone(); var propertyInfo = ScanBaseTypes.GetPropertyInfo(decl); if (propertyInfo != null) { propertyInfo.HostType = currentType; if (decl.Name.StartsWith("Get") || decl.Name.StartsWith("Is")) propertyInfo.MethodReturn = methodReturn.Clone(); } var methodName = decl.Name; if (currentTypeNames.Contains(methodName)) methodName += (uniqueMethodName++).ToString(); currentTypeNames.Add(methodName); // // PInvoke declaration + C counterpart declaration // string pinvoke_name = currentType.Name + "_" + methodName; var isConstructor = decl is CXXConstructorDecl; if (isConstructor) { pinvokeReturn = new SimpleType ("IntPtr"); // Do not bind a default constructor for Skeleton if (currentType.Name == "Skeleton") return; } var pinvoke = new MethodDeclaration { Name = pinvoke_name, ReturnType = pinvokeReturn, Modifiers = Modifiers.Extern | Modifiers.Static | Modifiers.Internal }; if (!decl.IsStatic && !isConstructor) pinvoke.Parameters.Add(new ParameterDeclaration(new SimpleType("IntPtr"), "handle")); var dllImport = new Attribute { Type = new SimpleType("DllImport") }; dllImport.Arguments.Add (new PrimitiveExpression ("mono-urho")); dllImport.Arguments.Add (new AssignmentExpression (new IdentifierExpression ("CallingConvention"), csParser.ParseExpression ("CallingConvention.Cdecl"))); pinvoke.Attributes.Add(new AttributeSection(dllImport)); // The C counterpart var cinvoke = new StringBuilder(); string marshalReturn = "{0}"; string creturnType = CleanTypeCplusplus(decl.ReturnQualType); switch (creturnType) { case "bool": creturnType = "int"; break; case "Urho3D::StringHash": creturnType = "int"; marshalReturn = "({0}).Value ()"; break; case "Urho3D::String": case "const Urho3D::String &": case "const class Urho3D::String &": creturnType = "const char *"; marshalReturn = "strdup(({0}).CString ())"; break; case "const struct Urho3D::TileMapInfo2D &": creturnType = "Urho3D::TileMapInfo2D"; break; case "const struct Urho3D::CrowdObstacleAvoidanceParams &": creturnType = "Urho3D::CrowdObstacleAvoidanceParams"; break; case "const class Urho3D::Vector3 &": case "const class Urho3D::Vector2 &": case "const class Urho3D::Vector4 &": case "const class Urho3D::IntVector2 &": case "const class Urho3D::Quaternion &": case "const class Urho3D::Plane &": case "const class Urho3D::BoundingBox &": case "const class Urho3D::Color &": case "Urho3D::Vector3": case "Urho3D::Vector2": case "Urho3D::Vector4": case "Urho3D::IntVector2": case "Urho3D::Quaternion": case "Urho3D::Plane": case "Urho3D::BoundingBox": case "Urho3D::Color": var nsIndex = creturnType.IndexOf ("Urho3D::") + "Urho3D".Length; creturnType = "Interop" + creturnType.Remove (0, nsIndex).Trim ('&', ' ') + " "; marshalReturn = "*((" + creturnType + " *) &({0}))"; break; } if (creturnType.StartsWith("SharedPtr<")) { creturnType = creturnType.ExtractGenericParameter().DropClassOrStructPrefix() + " *"; marshalReturn = "auto copy = {0};\n" + "\tauto plain = copy.Get();\n" + "\tcopy.Detach();\n" + "\tdelete copy;\n" + "\treturn plain;"; } const string methodNameSuffix = "%MethodSuffix%"; const string variantConverterMask = "%VariantConvertor%"; if (isConstructor) cmethodBuilder.Append($"DllExport void *\n{pinvoke_name}{methodNameSuffix} ("); else cmethodBuilder.Append($"DllExport {creturnType}\n{pinvoke_name}{methodNameSuffix} ("); if (decl.IsStatic) { cinvoke.Append($"{decl.Parent.Name}::{decl.Name} ("); } else if (isConstructor) { cinvoke.Append($"new {decl.Name}("); } else { cmethodBuilder.Append($"Urho3D::{decl.Parent.Name} *_target"); if (decl.Parameters.Any()) cmethodBuilder.Append(", "); cinvoke.Append($"_target->{decl.Name} ("); } // // Method declaration // MethodDeclaration method = null; ConstructorDeclaration constructor = null; if (isConstructor) { constructor = new ConstructorDeclaration { Name = RemapMemberName(decl.Parent.Name, decl.Name), Modifiers = (decl.IsStatic ? Modifiers.Static : 0) | (propertyInfo != null ? Modifiers.Private : Modifiers.Public) | (decl.Name == "ToString" ? Modifiers.Override : 0) }; constructor.Body = new BlockStatement(); } else { method = new MethodDeclaration { Name = RemapMemberName(decl.Parent.Name, decl.Name), ReturnType = methodReturn, Modifiers = (decl.IsStatic ? Modifiers.Static : 0) | (propertyInfo != null ? Modifiers.Private : Modifiers.Public) }; method.Body = new BlockStatement(); } // // Marshal from C# to C and the C support to call into C++ // var invoke = new InvocationExpression(new IdentifierExpression(pinvoke_name)); if (!decl.IsStatic && !isConstructor) invoke.Arguments.Add(new IdentifierExpression("handle")); bool first = true; int anonymousParameterNameCount = 1; int currentParamCount = -1; foreach (var param in decl.Parameters) { currentParamCount++; AstType pinvokeParameter, parameter; WrapKind wrapKind; if (!first) { cinvoke.Append(", "); cmethodBuilder.Append(", "); } else first = false; LookupMarshalTypes(param.QualType, out pinvokeParameter, out pinvokeMod, out parameter, out methodMod, out wrapKind); string paramName = param.Name; if (string.IsNullOrEmpty(paramName)) paramName = "param" + (anonymousParameterNameCount++); Expression parameterReference = new IdentifierExpression (paramName); switch (currentType.Name) { case "Input": switch (decl.Name) { case "GetMouseButtonDown": case "GetMouseButtonPress": parameter = new SimpleType ("MouseButton"); parameterReference = new CastExpression (new PrimitiveType ("int"), parameterReference); break; case "GetKeyPress": case "GetKeyDown": case "GetScancodeFromKey": case "GetKeyName": if (currentParamCount == 0 && paramName == "key") { parameter = new SimpleType ("Key"); parameterReference = new CastExpression (new PrimitiveType ("int"), parameterReference); } break; } break; case "VertexBuffer": switch (decl.Name) { case "SetSize": if (currentParamCount == 1 && paramName == "elementMask") { parameter = new SimpleType ("ElementMask"); parameterReference = new CastExpression (new PrimitiveType ("uint"), parameterReference); } break; case "GetVertexSize": if (currentParamCount == 0 && paramName == "elementMask") { parameter = new SimpleType ("ElementMask"); parameterReference = new CastExpression (new PrimitiveType ("uint"), parameterReference); } break; case "GetElementOffset": if (currentParamCount == 0 && paramName == "elementMask") { parameter = new SimpleType ("ElementMask"); parameterReference = new CastExpression (new PrimitiveType ("uint"), parameterReference); } break; } break; case "Log": switch (decl.Name) { case "Write": if (currentParamCount == 0 && paramName == "level") { parameter = new SimpleType ("LogLevel"); parameterReference = new CastExpression (new PrimitiveType ("int"), parameterReference); } break; } break; } if (constructor == null) method.Parameters.Add(new ParameterDeclaration(parameter, paramName, methodMod)); else constructor.Parameters.Add(new ParameterDeclaration(parameter, paramName, methodMod)); pinvoke.Parameters.Add(new ParameterDeclaration(pinvokeParameter, paramName, pinvokeMod)); switch (wrapKind) { case WrapKind.None: invoke.Arguments.Add(parameterReference); break; case WrapKind.HandleMember: case WrapKind.UrhoObject: var cond = new ConditionalExpression (new BinaryOperatorExpression (new CastExpression (new PrimitiveType ("object"), parameterReference), BinaryOperatorType.Equality, new PrimitiveExpression (null)), csParser.ParseExpression ("IntPtr.Zero"), csParser.ParseExpression (paramName + ".Handle")); invoke.Arguments.Add (cond); break; case WrapKind.EventHandler: invoke.Arguments.Add(parameterReference); break; case WrapKind.StringHash: invoke.Arguments.Add (csParser.ParseExpression (paramName + ".Code")); break; case WrapKind.RefBlittable: invoke.Arguments.Add (new DirectionExpression (FieldDirection.Ref, parameterReference)); break; case WrapKind.VectorSharedPtr: throw new NotImplementedException ("Vector marshaling not supported for parameters yet"); } var ctype = CleanTypeCplusplus (param.QualType); string paramInvoke = paramName; switch (ctype) { case "bool": ctype = "int"; break; case "Urho3D::Deserializer &": case "Urho3D::Serializer &": ctype = "File *"; paramInvoke = $"*{paramInvoke}"; break; case "const class Urho3D::String &": ctype = "const char *"; paramInvoke = $"Urho3D::String({paramInvoke})"; break; case "Urho3D::StringHash": ctype = "int"; paramInvoke = $"Urho3D::StringHash({paramInvoke})"; break; case "const class Urho3D::Variant &": paramInvoke = $"{variantConverterMask}({paramInvoke})"; break; } cmethodBuilder.Append($"{ctype} {paramName}"); cinvoke.Append($"{paramInvoke}"); } cinvoke.Append(")"); cmethodBuilder.Append(")\n{\n\t"); // if the type has a ctor accepting Context - add a parameterless one that will use "this(Application.CurrentContext)" if (isConstructor && decl.Parameters.Count() == 1 && decl.Parameters.ElementAt(0).QualType.ToString() == "class Urho3D::Context *") { var ctor = new ConstructorDeclaration { Modifiers = Modifiers.Public, Body = new BlockStatement(), Initializer = new ConstructorInitializer { ConstructorInitializerType = ConstructorInitializerType.This } }; ctor.Initializer.Arguments.Add(csParser.ParseExpression("Application.CurrentContext")); currentType.Members.Add(ctor); } if (method != null && methodReturn is Sharpie.Bind.Types.VoidType) { method.Body.Add(invoke); // pn ($"fprintf (stderr,\"DEBUG {creturnType} {pinvoke_name} (...)\\n\");"); cmethodBuilder.AppendLine($"{cinvoke.ToString()};"); } else { ReturnStatement ret = null; Expression returnExpression; if (!isConstructor) ret = new ReturnStatement(); switch (returnIsWrapped) { case WrapKind.HandleMember: returnExpression = new InvocationExpression (new MemberReferenceExpression (new IdentifierExpression ("Runtime"), "LookupRefCounted", methodReturn2), invoke); break; case WrapKind.UrhoObject: returnExpression = new InvocationExpression (new MemberReferenceExpression (new IdentifierExpression ("Runtime"), "LookupObject", methodReturn2), invoke); break; case WrapKind.EventHandler: returnExpression = invoke; break; case WrapKind.StringHash: returnExpression = new ObjectCreateExpression (new SimpleType ("StringHash"), invoke); break; case WrapKind.MarshalPtrToString: returnExpression = new InvocationExpression(new MemberReferenceExpression(new IdentifierExpression("Marshal"), "PtrToStringAnsi"), invoke); break; case WrapKind.MarshalPtrToStruct: returnExpression = new InvocationExpression(new MemberReferenceExpression(new IdentifierExpression("Marshal"), "PtrToStructure"), invoke, new TypeOfExpression(methodReturn2)); returnExpression = new CastExpression(methodReturn2.Clone(), returnExpression); break; case WrapKind.VectorSharedPtr: var cacheName = "_" + method.Name + "_cache"; var f = new FieldDeclaration () { ReturnType = method.ReturnType.Clone (), Modifiers = Modifiers.Private | (method.Modifiers & Modifiers.Static) }; f.Variables.Add (new VariableInitializer (cacheName, null)); currentType.Members.Add (f); var sharedPtrType = (methodReturn as SimpleType).TypeArguments.First ().Clone (); //TODO: check if UrhoObject var create = (sharedPtrType.ToString() == "AnimationState") ? "CreateVectorSharedPtrRefcountedProxy" : "CreateVectorSharedPtrProxy"; returnExpression = new ConditionalExpression ( new BinaryOperatorExpression (new IdentifierExpression (cacheName), BinaryOperatorType.InEquality, new PrimitiveExpression (null)), new IdentifierExpression (cacheName), new AssignmentExpression ( new IdentifierExpression (cacheName), new InvocationExpression ( new MemberReferenceExpression ( new IdentifierExpression ("Runtime"), create, sharedPtrType), invoke))); break; default: returnExpression = invoke; break; } if (ret != null) { ret.Expression = returnExpression; method.Body.Add(ret); } else { if (currentType.ClassType == ClassType.Class){ //usually, the Context is the first object user creates so let's add additional check if engine is inited if (currentType.Name == "Context") { constructor.Body.Add (new InvocationExpression (new IdentifierExpression ("CheckEngine"), null)); } bool hasBaseTypes = currentType.BaseTypes.Count != 0; if (hasBaseTypes) { constructor.Initializer = new ConstructorInitializer { ConstructorInitializerType = ConstructorInitializerType.Base, }; constructor.Initializer.Arguments.Add(csParser.ParseExpression("UrhoObjectFlag.Empty")); } var ctorAssign = new AssignmentExpression(new IdentifierExpression("handle"), returnExpression); constructor.Body.Add(new ExpressionStatement(ctorAssign)); if (hasBaseTypes) { constructor.Body.Add (new InvocationExpression (new MemberReferenceExpression (new IdentifierExpression ("Runtime"), "RegisterObject"), new ThisReferenceExpression ())); } } } var rstr = String.Format(marshalReturn, cinvoke.ToString()); CXXRecordDecl returnType; //Wrap with WeakPtr all RefCounted subclasses constructors if (isConstructor) { if (ScanBaseTypes.nameToDecl.TryGetValue(decl.Parent.QualifiedName, out returnType) && returnType.IsDerivedFrom(ScanBaseTypes.UrhoRefCounted)) rstr = $"WeakPtr<{decl.Name}>({rstr})"; } cmethodBuilder.AppendLine(!rstr.Contains("\treturn ") ? $"return {rstr};" : rstr); } cmethodBuilder.AppendLine("}\n"); var code = cmethodBuilder.ToString(); const string variantArgDef = "const class Urho3D::Variant &"; //if methods contains Variant argument -- replace it with overloads if (code.Contains(variantArgDef)) { var variantSupportedTypes = new Dictionary<string, string> { //C++ - C# types map {"const class Urho3D::Vector3 &", "Vector3"}, {"const class Urho3D::IntRect &", "IntRect"}, {"const class Urho3D::Color &", "Color"}, {"const class Urho3D::Vector2 &", "Vector2"}, {"const class Urho3D::Vector4 &", "Vector4"}, {"const class Urho3D::IntVector2 &", "IntVector2"}, {"const class Urho3D::Quaternion &", "Quaternion"}, {"int", "int"}, {"float", "float"}, {"const char *", "string"}, //TODO: Matrix, StringHash? }; var primitiveTypes = new[] { "int", "float", "string" }; pn("// Urho3D::Variant overloads begin:"); int index = 0; foreach (var item in variantSupportedTypes) { //C: p(code .Replace(variantArgDef, item.Key) .Replace(methodNameSuffix, index.ToString()) .Replace(variantConverterMask, item.Key == "const char *" ? "Urho3D::String" : string.Empty)); //methodNameSuffix to avoid error: // error C2733: second C linkage of overloaded function 'function name' not allowed. //C#: var isPrimitive = primitiveTypes.Contains(item.Value); AstType argumentType; var argumentModifier = ICSharpCode.NRefactory.CSharp.ParameterModifier.None; if (!isPrimitive) { argumentType = new SimpleType(item.Value); argumentModifier = ICSharpCode.NRefactory.CSharp.ParameterModifier.Ref; } else { argumentType = new PrimitiveType(item.Value); } var dllImportItem = (MethodDeclaration)pinvoke.Clone(); var originalEntryPointName = dllImportItem.Name; dllImportItem.Name += index; var variantParam = dllImportItem.Parameters.First(p => p.ToString().Contains(variantArgDef)); variantParam.Type = argumentType.Clone(); variantParam.ParameterModifier = argumentModifier; currentType.Members.Add(dllImportItem); var clonedMethod = (MethodDeclaration)method.Clone(); variantParam = clonedMethod.Parameters.First(p => p.ToString().Contains(variantArgDef)); variantParam.Type = argumentType.Clone(); //add 'index' to all EntryPoint invocations inside the method (no mater how complex method body is): //and 'ref' keyword for the argument clonedMethod.Body.Descendants .OfType<InvocationExpression>() .Where(ie => ie.Target is IdentifierExpression && ((IdentifierExpression)ie.Target).Identifier == originalEntryPointName) .ToList() .ForEach(ie => { if (!isPrimitive) { //non-primitive types should be marked with 'ref' keyword var argument = ie.Arguments.OfType<IdentifierExpression>().First(arg => arg.Identifier == variantParam.Name); ie.Arguments.Remove(argument); ie.Arguments.Add(new DirectionExpression(FieldDirection.Ref, argument)); } var exp = (IdentifierExpression)ie.Target; exp.Identifier += index; }); currentType.Members.Add(clonedMethod); InsertSummaryComments(clonedMethod, StringUtil.GetMethodComments(decl)); index++; } pn("// Urho3D::Variant overloads end."); } //method does not have "Variant" arguments else { //C: pn(code .Replace(methodNameSuffix, string.Empty) .Replace(variantConverterMask, string.Empty)); //C#: currentType.Members.Add(pinvoke); if (method == null) currentType.Members.Add(constructor); else { currentType.Members.Add(method); InsertSummaryComments(method, StringUtil.GetMethodComments(decl)); } } }
// // Determines if we should bind a method that the C++ API scanner found // bool MethodIsBindable (CXXMethodDecl decl, VisitKind visitKind) { // We only care about enter visits, not leave if (visitKind != VisitKind.Enter) return false; // Global definitions, not inside a class, skip if (currentType == null) return false; // Do not bother with constructors in abstract classes var isConstructor = decl is CXXConstructorDecl; if (isConstructor && decl.Parent.IsAbstract) return false; // Do not wrap constructors if (decl is CXXDestructorDecl) return false; // Not supported in C# if (decl.IsCopyAssignmentOperator || decl.IsMoveAssignmentOperator) return false; // TODO: temporary, do not handle opreators if (!isConstructor && decl.Name.StartsWith ("operator", StringComparison.Ordinal)) return false; // Sanity check if (RemapTypeName (decl.Parent.Name) != currentType.Name) { //Console.WriteLine("For some reason we go t amethod that does not belong here {0}.{1} on {2}", decl.Parent.Name, decl.Name, currentType.Name); return false; } // We only bind the public API if (decl.Access != AccessSpecifier.Public) return false; // Skip blacklisted methods if (SkipMethod (decl)) return false; // Temporary: while we add support for other things, just to debug things // remove types we do not support int variantArgumentsCount = 0; foreach (var p in decl.Parameters) { bool isVariantArgument = IsVariantType(p.QualType); if (isVariantArgument) variantArgumentsCount++; if (IsUnsupportedType(p.QualType, returnType: false) && !isVariantArgument) { //Console.WriteLine($"Bailing out on {p.QualType} from {decl.QualifiedName}"); return false; } } if (variantArgumentsCount > 1) return false; //it won't be easy to handle if it has more than one Variant argument if (IsUnsupportedType(decl.ReturnQualType, returnType: true)) {//variant return type is not support yet //Console.WriteLine($"RETURN Bailing out on {decl.ReturnQualType} from {decl.QualifiedName}"); return false; } return true; }
// Avoid generating methods that conflict in their signatures after we turn Urho::String into string bool SkipMethod (CXXMethodDecl decl) { //DEBUG specific method /*if (currentType.Name == "WorkQueue" && decl.Name == "GetFreeItem") return false; return true;*/ switch (currentType.Name) { case "Graphics": if (decl.Name == "GetShader") return decl.Parameters.Skip (1).First ().QualType.ToString () == "const char *"; if (decl.Name == "SetShaderParameter") //strange method. it has overloads for all basic types and an overload with "Variant"... (it shouldn't have Variant or should have ONLY Variant) return decl.Parameters.Any (p => p.QualType.ToString ().Contains ("const class Urho3D::Variant &")); break; case "DebugHud": if (decl.Name == "SetAppStats") //it has overloads with String and Variant (that also can handle String) return decl.Parameters.Any (p => p.QualType.ToString ().Contains ("const class Urho3D::Variant &")); break; case "Node": if (decl.Name == "GetChild") return decl.Parameters.First ().QualType.ToString () == "const char *"; break; case "Shader": if (decl.Name == "GetVariation") return decl.Parameters.Skip (1).First ().QualType.ToString () == "const char *"; break; case "Scene": // The following look like internal methods that should not really be surfaced // to the user. If we ever find that we have to surface, then we should rename them // in the other method, as they will conflict with the events. // // These names are bad choices, because they are called internally when something // has been done, and they complete the process. For example "NodeRemoved" should // really be "RemoveNode", and "NodeAdded" should really be "AddNode", but that has // a different method and implementation on the Scene class (that is, there is // already a AddNode method, which is a high-level method) switch (decl.Name) { case "NodeAdded": case "NodeRemoved": case "ComponentAdded": case "ComponentRemoved": return true; } break; case "Application": switch (decl.Name) { case "Application": return decl.Parameters.First ().QualType.ToString ().Contains ("Urho3D::Context"); case "Setup": case "Start": case "Stop": return true; } break; case "Skeleton": switch (decl.Name) { case "GetBone": if (decl.Parameters.First ().QualType.ToString ().Contains ("String &")) return true; return false; } break; } switch (decl.Name) { case "OnDragMove": case "OnDragEnd": case "OnDragDropTest": case "OnDragDropFinish": case "OnDragCancel": case "OnDragBegin": return true; } return false; }
public static IEnumerable<string> GetMethodComments(CXXMethodDecl decl) { return ExtractTextComments(decl.DumpToString()); }
public override void VisitCXXMethodDecl(CXXMethodDecl decl, VisitKind visitKind) { if (visitKind != VisitKind.Enter) return; var isConstructor = decl is CXXConstructorDecl; if (decl is CXXDestructorDecl || isConstructor) return; if (decl.IsCopyAssignmentOperator || decl.IsMoveAssignmentOperator) return; if (decl.Parent == null) return; if (!decl.Parent.QualifiedName.StartsWith("Urho3D::")) return; // Only get methods prefixed with Get with no parameters // and Set methods that return void and take a single parameter var name = decl.Name; // Handle Get methods that are not really getters // This is a get method that does not get anything QualType type; if (name.StartsWith("Get") || name.StartsWith("Is")) { if (decl.Parameters.Count() != 0) return; if (decl.ReturnQualType.ToString() == "void") return; if (name == "IsElementEventSender" || name == "IsOpen" || name == "IsPressed") return; type = decl.ReturnQualType; } else if (name.StartsWith("Set")) { if (decl.Parameters.Count() != 1) return; if (!(decl.ReturnQualType.Bind() is Sharpie.Bind.Types.VoidType)) return; if ((name == "SetTypeName" || name == "SetType") && decl.Parent.Name == "UnknownComponent") return; if (decl.Access != AccessSpecifier.Public) return; type = decl.Parameters.FirstOrDefault().QualType; } else return; Dictionary<string, Dictionary<QualType, GetterSetter>> typeProperties; if (!allProperties.TryGetValue(decl.Parent.Name, out typeProperties)) { typeProperties = new Dictionary<string, Dictionary<QualType, GetterSetter>>(); allProperties[decl.Parent.Name] = typeProperties; } var propName = name.Substring(name.StartsWith("Is") ? 2 : 3); Dictionary<QualType, GetterSetter> property; if (!typeProperties.TryGetValue(propName, out property)) { property = new Dictionary<QualType, GetterSetter>(); typeProperties[propName] = property; } GetterSetter gs; if (!property.TryGetValue(type, out gs)) { gs = new GetterSetter() { Name = propName }; } if (name.StartsWith("Get") || name.StartsWith("Is")) { Console.WriteLine($"Getter exists for {name}"); gs.Getter = decl; } else { if (gs.Setter != null) { Console.WriteLine($"Setter exists for {name}"); } gs.Setter = decl; } property[type] = gs; }
public static GetterSetter GetPropertyInfo(CXXMethodDecl decl) { GetterSetter gs; if (allPropertyMethods.TryGetValue(decl, out gs)) return gs; return null; }