protected virtual void AddPublicConstructor(MemberMethodDefinition function) { if (function == null) { AddPublicConstructorOverload(function, 0); } else { int defcount = 0; if (!function.HasAttribute <NoDefaultParamOverloadsAttribute>()) { foreach (ParamDefinition param in function.Parameters) { if (param.DefaultValue != null) { defcount++; } } } bool hideParams = function.HasAttribute <HideParamsWithDefaultValuesAttribute>(); // The overloads (because of default values) for (int dc = 0; dc <= defcount; dc++) { if (dc < defcount && function.HasAttribute <HideParamsWithDefaultValuesAttribute>()) { continue; } AddPublicConstructorOverload(function, function.Parameters.Count - dc); } } }
protected virtual void AddCreator(MemberMethodDefinition f) { if (f == null) { AddCreatorOverload(f, 0); } else { int defcount = 0; if (!f.HasAttribute <NoDefaultParamOverloadsAttribute>()) { foreach (ParamDefinition param in f.Parameters) { if (param.DefaultValue != null) { defcount++; } } } // The overloads (because of default values) for (int dc = 0; dc <= defcount; dc++) { if (dc < defcount && f.HasAttribute <HideParamsWithDefaultValuesAttribute>()) { continue; } AddCreatorOverload(f, f.Parameters.Count - dc); } } }
protected virtual void AddCreator(MemberMethodDefinition f) { if (f == null) { _codeBuilder.AppendLine("static " + _classDefinition.CLRName + " Create();"); } else { int defcount = 0; if (!f.HasAttribute <NoDefaultParamOverloadsAttribute>()) { foreach (ParamDefinition param in f.Parameters) { if (param.DefaultValue != null) { defcount++; } } } // The overloads (because of default values) for (int dc = 0; dc <= defcount; dc++) { if (dc < defcount && f.HasAttribute <HideParamsWithDefaultValuesAttribute>()) { continue; } _codeBuilder.AppendIndent("static " + _classDefinition.CLRName + " Create"); AddMethodParameters(f, f.Parameters.Count - dc); _codeBuilder.Append(";\n"); } } }
protected virtual void AddPublicConstructor(MemberMethodDefinition function) { string className = (_classDefinition.IsInterface) ? _classDefinition.Name : _classDefinition.CLRName; if (function == null) { _codeBuilder.AppendLine(className + "();"); } else { int defcount = 0; if (!function.HasAttribute <NoDefaultParamOverloadsAttribute>()) { foreach (ParamDefinition param in function.Parameters) { if (param.DefaultValue != null) { defcount++; } } } bool hideParams = function.HasAttribute <HideParamsWithDefaultValuesAttribute>(); // The overloads (because of default values) for (int dc = 0; dc <= defcount; dc++) { if (dc < defcount && hideParams) { continue; } _codeBuilder.AppendIndent(className); AddMethodParameters(function, function.Parameters.Count - dc); _codeBuilder.Append(";\n"); } } }
public override bool HasAttribute <T>() { if (base.HasAttribute <T>()) { return(true); } if (BaseMethod != null) { return(BaseMethod.HasAttribute <T>()); } return(false); }
protected override void GenerateCodeMethod(MemberMethodDefinition f) { string def = f.Definition.Replace(f.ContainingClass.FullyQualifiedNativeName, GetClassName()) + "("; if (def.StartsWith("virtual ")) { def = def.Substring("virtual ".Length); } _codeBuilder.AppendIndent(def); for (int i = 0; i < f.Parameters.Count; i++) { ParamDefinition param = f.Parameters[i]; _codeBuilder.Append(" "); AddNativeMethodParam(param); if (i < f.Parameters.Count - 1) { _codeBuilder.Append(","); } } _codeBuilder.Append(" )\n"); _codeBuilder.AppendLine("{"); _codeBuilder.IncreaseIndent(); _codeBuilder.AppendLine("if (doCallFor" + f.CLRName + ")"); _codeBuilder.AppendLine("{"); _codeBuilder.IncreaseIndent(); NativeProxyClassCppProducer.AddNativeProxyMethodBody(f, "_receiver", _codeBuilder); _codeBuilder.DecreaseIndent(); _codeBuilder.AppendLine("}"); if (!f.HasReturnValue) { if (!f.HasAttribute <DefaultReturnValueAttribute>()) { throw new Exception("Default return value not set."); } _codeBuilder.AppendLine("else"); _codeBuilder.AppendLine("\treturn " + f.GetAttribute <DefaultReturnValueAttribute>().Name + ";"); } _codeBuilder.DecreaseIndent(); _codeBuilder.AppendLine("}"); }
/// <summary> /// Checks whether this method is a set accessor for a CLR property. /// </summary> /// <seealso cref="IsPropertyGetAccessor"/> public static bool CheckForSetAccessor(MemberMethodDefinition methodDef) { // // IMPORTANT: Don't use any of the "IsProperty..." properties of MemberMethodDefinition // in this method as those properties use this method to determine their values. // if (methodDef.IsOverriding) { // Check this before checking possible attributes return(methodDef.BaseMethod.IsPropertySetAccessor); } if (methodDef.IsConstructor || methodDef.MemberTypeName != "void" || methodDef.Parameters.Count != 1) { // Check this before checking possible attributes return(false); } if (methodDef.HasAttribute <PropertyAttribute>()) { return(true); } if (methodDef.HasAttribute <MethodAttribute>()) { return(false); } if (methodDef.HasAttribute <CustomIncDeclarationAttribute>() || methodDef.HasAttribute <CustomCppDeclarationAttribute>()) { return(false); } string name = methodDef.GetRenameName(); if (!name.StartsWith("set") || !Char.IsUpper(name[3])) { return(false); } // Check to see if there is a "get" function string propName = name.Substring(3); MemberMethodDefinition method; // TODO by manski: Allow the case that the getter and the setter come from different classes. // Special care must be taken in this case as for example "Property.ContainingClass" can't // be used anymore, since there are two classes involved. This could be solved by returning // the "lowest" subclass (i.e. the class in which both accessors are defined then). // Then the second argument should be changed to "true" here. method = methodDef.ContainingClass.GetMethodByNativeName("get" + propName, false, false); if (method == null) { method = methodDef.ContainingClass.GetMethodByNativeName("is" + propName, false, false); if (method == null) { method = methodDef.ContainingClass.GetMethodByNativeName("has" + propName, false, false); } } // NOTE: Most checks done in "CheckForGetAccessor()" are represented in "method.IsPropertyGetAccessor". return(method != null && method.IsPropertyGetAccessor && method.MemberTypeName == methodDef.Parameters[0].TypeName && (!methodDef.ContainingClass.AllowVirtuals || (method.IsVirtual == methodDef.IsVirtual && method.IsOverriding == methodDef.IsOverriding))); }
/// <summary> /// Checks whether this method is a get accessor for a CLR property. /// </summary> /// <seealso cref="IsPropertyGetAccessor"/> public static bool CheckForGetAccessor(MemberMethodDefinition methodDef) { // // IMPORTANT: Don't use any of the "IsProperty..." properties of MemberMethodDefinition // in this method as those properties use this method to determine their values. // if (methodDef.IsOverriding) { // Check this before checking possible attributes return(methodDef.BaseMethod.IsPropertyGetAccessor); } if (methodDef.IsConstructor || methodDef.MemberTypeName == "void" || methodDef.Parameters.Count != 0) { // Check this before checking possible attributes return(false); } if (methodDef.HasAttribute <PropertyAttribute>()) { return(true); } if (methodDef.HasAttribute <MethodAttribute>()) { return(false); } if (methodDef.HasAttribute <CustomIncDeclarationAttribute>() || methodDef.HasAttribute <CustomCppDeclarationAttribute>()) { return(false); } string name = methodDef.GetRenameName(); if (methodDef.MemberTypeName == "bool" && ((name.StartsWith("is") && Char.IsUpper(name[2]) && methodDef.MetaDef.CodeStyleDef.AllowIsInPropertyName) || (name.StartsWith("has") && Char.IsUpper(name[3]))) && methodDef.Parameters.Count == 0) { return(true); } if (!methodDef.MemberType.IsValueType && (methodDef.MemberType.IsSharedPtr || methodDef.MemberType is DefTemplateOneType || methodDef.MemberType is DefTemplateTwoTypes)) { return(false); } if (methodDef.MemberType.HasAttribute <ReturnOnlyByMethodAttribute>()) { // Invalid type for a property return(false); } string propName; if (name.StartsWith("get") && Char.IsUpper(name[3])) { propName = name.Substring(3); } else if (name.StartsWith("is") && Char.IsUpper(name[2])) { propName = name.Substring(2); } else { // Not a valid getter prefix. return(false); } // Check if the property's name collides with the name of a nested type. In this // case we can't convert the method into a property. AbstractTypeDefinition type = methodDef.ContainingClass.GetNestedType(propName, false); if (type != null) { return(false); } // Check if the property's name collides with the name of a method. In this // case we can't convert the method into a property. MemberMethodDefinition method = methodDef.ContainingClass.GetMethodByCLRName(propName, true, false); // If there is no method == valid property name return(method == null); }
protected override void GenerateCodeMethod(MemberMethodDefinition f) { if (f.HasAttribute <CustomCppDeclarationAttribute>()) { if (f.IsAbstract && AllowSubclassing) { return; } else { string txt = f.GetAttribute <CustomCppDeclarationAttribute>().DeclarationText; txt = ReplaceCustomVariables(txt, f); _codeBuilder.AppendLine(txt); _codeBuilder.AppendEmptyLine(); return; } } int defcount = 0; if (!f.HasAttribute <NoDefaultParamOverloadsAttribute>()) { foreach (ParamDefinition param in f.Parameters) { if (param.DefaultValue != null) { defcount++; } } } bool methodIsVirtual = DeclareAsVirtual(f); for (int dc = 0; dc <= defcount; dc++) { if (dc == 0 && f.IsAbstract && AllowSubclassing) { //It's abstract, no body definition continue; } if (!AllowMethodOverloads && dc > 0) { continue; } if (dc < defcount && f.HasAttribute <HideParamsWithDefaultValuesAttribute>()) { continue; } _codeBuilder.AppendIndent(GetCLRTypeName(f) + " " + GetClassName() + "::" + f.CLRName); AddMethodParameters(f, f.Parameters.Count - dc); _codeBuilder.Append("\n"); _codeBuilder.AppendLine("{"); _codeBuilder.IncreaseIndent(); bool isVirtualOverload = dc > 0 && methodIsVirtual && AllowVirtualMethods; if (isVirtualOverload) { // Overloads (because of default values) // main method is virtual, call it with CLR default values if _isOverriden=true, // else do a normal native call _codeBuilder.AppendLine("if (_isOverriden)"); _codeBuilder.AppendLine("{"); _codeBuilder.IncreaseIndent(); bool hasPostConversions = false; for (int i = f.Parameters.Count - dc; i < f.Parameters.Count; i++) { ParamDefinition p = f.Parameters[i]; if (!String.IsNullOrEmpty(p.CLRDefaultValuePreConversion)) { _codeBuilder.AppendLine(p.CLRDefaultValuePreConversion); } if (!String.IsNullOrEmpty(p.CLRDefaultValuePostConversion)) { hasPostConversions = true; } string n1, n2, n3; AbstractTypeDefinition dependancy; p.Type.ProduceDefaultParamValueConversionCode(p, out n1, out n2, out n3, out dependancy); if (dependancy != null) { AddTypeDependancy(dependancy); } } _codeBuilder.AppendIndent(""); if (!f.HasReturnValue) { if (hasPostConversions) { _codeBuilder.Append(GetCLRTypeName(f) + " mp_return = "); } else { _codeBuilder.Append("return "); } } _codeBuilder.Append(f.CLRName + "("); for (int i = 0; i < f.Parameters.Count; i++) { ParamDefinition p = f.Parameters[i]; _codeBuilder.Append(" "); if (i < f.Parameters.Count - dc) { _codeBuilder.Append(p.Name); } else { _codeBuilder.Append(p.CLRDefaultValue); } if (i < f.Parameters.Count - 1) { _codeBuilder.Append(","); } } _codeBuilder.Append(" );\n"); for (int i = f.Parameters.Count - dc; i < f.Parameters.Count; i++) { ParamDefinition p = f.Parameters[i]; if (!String.IsNullOrEmpty(p.CLRDefaultValuePostConversion)) { _codeBuilder.AppendLine(p.CLRDefaultValuePostConversion); } } if (!f.HasReturnValue && hasPostConversions) { _codeBuilder.AppendLine("return mp_return;"); } _codeBuilder.DecreaseIndent(); _codeBuilder.AppendLine("}"); _codeBuilder.AppendLine("else"); _codeBuilder.AppendLine("{"); _codeBuilder.IncreaseIndent(); } AddMethodBody(f, f.Parameters.Count - dc); if (isVirtualOverload) { _codeBuilder.DecreaseIndent(); _codeBuilder.AppendLine("}"); } _codeBuilder.DecreaseIndent(); _codeBuilder.AppendLine("}"); } }
protected override void GenerateCodeMethod(MemberMethodDefinition f) { if (f.HasAttribute <CustomIncDeclarationAttribute>()) { string txt = f.GetAttribute <CustomIncDeclarationAttribute>().DeclarationText; txt = ReplaceCustomVariables(txt, f); _codeBuilder.AppendLine(txt); _codeBuilder.AppendEmptyLine(); return; } int defcount = 0; if (!f.HasAttribute <NoDefaultParamOverloadsAttribute>()) { foreach (ParamDefinition param in f.Parameters) { if (param.DefaultValue != null) { defcount++; } } } bool methodIsVirtual = DeclareAsVirtual(f); // The main method AddComments(f); if (AllowMethodIndexAttributes && f.IsVirtual && !f.IsAbstract) { AddMethodIndexAttribute(f); } _codeBuilder.AppendIndent(""); if (f.IsStatic) { _codeBuilder.Append("static "); } if (methodIsVirtual) { _codeBuilder.Append("virtual "); } _codeBuilder.Append(GetCLRTypeName(f) + " " + f.CLRName); AddMethodParameters(f, f.Parameters.Count); if (DeclareAsOverride(f)) { _codeBuilder.Append(" override"); } else if (f.IsAbstract && AllowSubclassing) { _codeBuilder.Append(" abstract"); } _codeBuilder.Append(";\n"); if (AllowMethodOverloads) { // The overloads (because of default values) for (int dc = 1; dc <= defcount; dc++) { if (dc < defcount && f.HasAttribute <HideParamsWithDefaultValuesAttribute>()) { continue; } AddComments(f); _codeBuilder.AppendIndent(""); if (f.IsStatic) { _codeBuilder.Append("static "); } _codeBuilder.Append(GetCLRTypeName(f) + " " + f.CLRName); AddMethodParameters(f, f.Parameters.Count - dc); _codeBuilder.Append(";\n"); } } }
protected override void AddOverridableFunction(MemberMethodDefinition f) { _wrapper.CppCheckTypeForDependancy(f.MemberType); foreach (ParamDefinition param in f.Parameters) { _wrapper.CppCheckTypeForDependancy(param.Type); } _codeBuilder.AppendIndent(""); _codeBuilder.Append(f.MemberTypeNativeName + " " + ProxyName + "::" + f.NativeName + "("); AddNativeMethodParams(f); _codeBuilder.Append(" )"); if (f.IsConstMethod) { _codeBuilder.Append(" const"); } _codeBuilder.Append("\n"); _codeBuilder.AppendLine("{"); _codeBuilder.IncreaseIndent(); if (!f.IsAbstract) { _codeBuilder.AppendLine("if (_overriden[ " + _methodIndices[f] + " ])"); _codeBuilder.AppendLine("{"); _codeBuilder.IncreaseIndent(); } if (f.HasAttribute <CustomNativeProxyDeclarationAttribute>()) { string txt = f.GetAttribute <CustomNativeProxyDeclarationAttribute>().DeclarationText; txt = ReplaceCustomVariables(txt, f).Replace("@MANAGED@", "_managed"); _codeBuilder.AppendLine(txt); } else { AddNativeProxyMethodBody(f, "_managed", _codeBuilder); } if (!f.IsAbstract) { _codeBuilder.DecreaseIndent(); _codeBuilder.AppendLine("}"); _codeBuilder.AppendLine("else"); _codeBuilder.AppendIndent("\t"); if (!f.HasReturnValue) { _codeBuilder.Append("return "); } _codeBuilder.Append(f.ContainingClass.Name + "::" + f.NativeName + "("); for (int i = 0; i < f.Parameters.Count; i++) { ParamDefinition param = f.Parameters[i]; _codeBuilder.Append(" " + param.Name); if (i < f.Parameters.Count - 1) { _codeBuilder.Append(","); } } _codeBuilder.Append(" );\n"); } _codeBuilder.DecreaseIndent(); _codeBuilder.AppendLine("}"); }
public static void AddNativeProxyMethodBody(MemberMethodDefinition f, string managedTarget, SourceCodeStringBuilder sb) { string managedCall; string fullPostConv = null; if (f.IsPropertyGetAccessor) { sb.AppendLine(f.MemberTypeCLRName + " mp_return = " + managedTarget + "->" + MemberPropertyDefinition.GetPropertyName(f) + ";"); managedCall = "mp_return"; } else if (f.IsPropertySetAccessor) { ParamDefinition param = f.Parameters[0]; managedCall = managedTarget + "->" + MemberPropertyDefinition.GetPropertyName(f) + " = " + param.Type.ProduceNativeCallConversionCode(param.Name, param); } else { string pre, post, conv; foreach (ParamDefinition param in f.Parameters) { param.Type.ProduceNativeParamConversionCode(param, out pre, out conv, out post); if (!String.IsNullOrEmpty(pre)) { sb.AppendLine(pre); } if (!String.IsNullOrEmpty(post)) { fullPostConv += post + "\n"; } } bool explicitCast = f.HasAttribute <ExplicitCastingForParamsAttribute>(); if (!f.HasReturnValue) { sb.AppendIndent(f.MemberTypeCLRName + " mp_return = " + managedTarget + "->" + f.CLRName + "("); for (int i = 0; i < f.Parameters.Count; i++) { ParamDefinition param = f.Parameters[i]; param.Type.ProduceNativeParamConversionCode(param, out pre, out conv, out post); sb.Append(" "); if (explicitCast) { sb.Append("(" + param.MemberTypeCLRName + ")"); } sb.Append(conv); if (i < f.Parameters.Count - 1) { sb.Append(","); } } sb.Append(" );\n"); managedCall = "mp_return"; if (!String.IsNullOrEmpty(fullPostConv)) { sb.AppendLine(fullPostConv); } } else { managedCall = managedTarget + "->" + f.CLRName + "("; for (int i = 0; i < f.Parameters.Count; i++) { ParamDefinition param = f.Parameters[i]; param.Type.ProduceNativeParamConversionCode(param, out pre, out conv, out post); managedCall += " "; if (explicitCast) { managedCall += "(" + param.MemberTypeCLRName + ")"; } managedCall += conv; if (i < f.Parameters.Count - 1) { managedCall += ","; } } managedCall += " )"; } } if (!f.HasReturnValue) { if (f.MemberType is IDefString) { sb.AppendLine("SET_NATIVE_STRING( Mogre::Implementation::cachedReturnString, " + managedCall + " )"); sb.AppendLine("return Mogre::Implementation::cachedReturnString;"); } else { string returnExpr; string newname, expr, postcall; ParamDefinition param = new ParamDefinition(f.MetaDef, f, managedCall); expr = f.MemberType.ProducePreCallParamConversionCode(param, out newname); postcall = f.MemberType.ProducePostCallParamConversionCleanupCode(param); if (!String.IsNullOrEmpty(expr)) { sb.AppendLine(expr); if (String.IsNullOrEmpty(postcall)) { returnExpr = newname; } else { throw new Exception("Unexpected"); } } else { returnExpr = newname; } if (IsCachedFunction(f)) { sb.AppendLine("STATIC_ASSERT( sizeof(" + f.MemberType.FullyQualifiedNativeName + ") <= CACHED_RETURN_SIZE )"); sb.AppendLine("memcpy( Mogre::Implementation::cachedReturn, &" + returnExpr + ", sizeof(" + f.MemberType.FullyQualifiedNativeName + ") );"); sb.AppendLine("return *reinterpret_cast<" + f.MemberType.FullyQualifiedNativeName + "*>(Mogre::Implementation::cachedReturn);"); } else { sb.AppendLine("return " + returnExpr + ";"); } } } else { sb.AppendLine(managedCall + ";"); if (!String.IsNullOrEmpty(fullPostConv)) { sb.AppendLine(fullPostConv); } } }