protected override void GenerateCodeProperty(MemberPropertyDefinition p)
{
if (p.IsVirtual)
{
base.GenerateCodeProperty(p);
}
}
protected MemberPropertyDefinition EnhanceProperty(MemberPropertyDefinition property)
{
MemberPropertyDefinition prop = property.Clone();
if (_classDefinition.BaseClass != null)
{
if (!prop.CanWrite)
{
// There's a chance the class overrides only the get function. If the
// property is not declared virtual then it will be read-only, so if
// it's not virtual check if a base class contains the set property
// and if it does, include it.
// If it's virtual and its base function will be declared virtual, this
// function will be declared virtual too, so it's not necessary to add
// the set function.
if (!DeclareAsVirtual(prop.GetterFunction))
{
MemberPropertyDefinition bp = _classDefinition.BaseClass.GetProperty(prop.Name, true);
if (bp != null && bp.CanWrite)
{
prop.SetterFunction = bp.SetterFunction;
}
}
}
if (!prop.CanRead)
{
// There's a chance the class overrides only the set function. If the
// property is not declared virtual then it will be write-only, so if
// it's not virtual check if a base class contains the set property
// and if it does, include it.
// If it's virtual and its base function will be declared virtual, this
// function will be declared virtual too, so it's not necessary to add
// the get function.
if (!DeclareAsVirtual(prop.SetterFunction))
{
MemberPropertyDefinition bp = _classDefinition.BaseClass.GetProperty(prop.Name, true);
if (bp != null && bp.CanRead)
{
prop.GetterFunction = bp.GetterFunction;
}
}
}
}
return(prop);
}
/// <summary>
/// Checks whether the specified property can be added to the generated source code.
/// </summary>
protected virtual bool IsPropertyAllowed(MemberPropertyDefinition p)
{
// If the property is ignored or the property is unhandled
if (p.IsIgnored() || !p.IsTypeHandled())
{
return(false);
}
if (p.ContainingClass.IsSingleton && (p.Name == "Singleton" || p.Name == "SingletonPtr"))
{
return(false);
}
return(true);
}
protected override bool IsPropertyAllowed(MemberPropertyDefinition p)
{
if (base.IsPropertyAllowed(p))
{
if (p.Name == "Singleton" || p.Name == "SingletonPtr")
{
return(false);
}
else
{
return(true);
}
}
else
{
return(false);
}
}
public virtual MemberPropertyDefinition[] GetProperties()
{
if (_properties != null)
{
return(_properties);
}
_properties = MemberPropertyDefinition.GetPropertiesFromMethods(this.Methods);
if (GetInterfaces().Length > 0)
{
foreach (MemberPropertyDefinition prop in _properties)
{
if (!prop.CanWrite)
{
foreach (ClassDefinition iface in GetInterfaces())
{
MemberPropertyDefinition ip = iface.GetProperty(prop.Name, true);
if (ip != null && ip.CanWrite)
{
prop.SetterFunction = ip.SetterFunction;
break;
}
}
}
if (!prop.CanRead)
{
foreach (ClassDefinition iface in GetInterfaces())
{
MemberPropertyDefinition ip = iface.GetProperty(prop.Name, true);
if (ip != null && ip.CanRead)
{
prop.GetterFunction = ip.GetterFunction;
break;
}
}
}
}
}
return(_properties);
}
public virtual MemberPropertyDefinition GetProperty(string name, bool inherit)
{
MemberPropertyDefinition prop = null;
foreach (MemberPropertyDefinition p in this.GetProperties())
{
if (p.Name == name)
{
prop = p;
break;
}
}
if (prop == null && inherit && BaseClass != null)
{
return(BaseClass.GetProperty(name, inherit));
}
else
{
return(prop);
}
}
/// <summary>
/// Converts the specified methods into CLR properties.
/// </summary>
/// <param name="methods">The methods to convert. Methods that are no accesors (<c>IsProperty == false</c>) will be ignored.</param>
public static MemberPropertyDefinition[] GetPropertiesFromMethods(IEnumerable <MemberMethodDefinition> methods)
{
// NOTE: Use a sorted "list" here so that the order (and thereby the position) of thy properties in
// the generated source code doesn't vary each time the sources are generated.
SortedDictionary <string, MemberPropertyDefinition> props = new SortedDictionary <string, MemberPropertyDefinition>();
foreach (MemberMethodDefinition f in methods)
{
if (!f.IsProperty || !f.IsDeclarableFunction)
{
continue;
}
MemberPropertyDefinition p = null;
string propName = GetPropertyName(f);
CodeStyleDefinition codeStyle = f.MetaDef.CodeStyleDef;
if (props.ContainsKey(propName))
{
p = props[propName];
}
else
{
//
// Merge properties with "is" or "has" prefix as this prefix can only be determined
// from the get accessor but not from the set accessor.
//
if (f.IsPropertySetAccessor)
{
// Set accessor - check for existing properties prefixed with "is" or "has".
if (codeStyle.AllowIsInPropertyName && props.ContainsKey(codeStyle.CLRPropertyIsPrefix + propName))
{
propName = codeStyle.CLRPropertyIsPrefix + propName;
p = props[propName];
}
else if (props.ContainsKey(codeStyle.CLRPropertyHasPrefix + propName))
{
propName = codeStyle.CLRPropertyHasPrefix + propName;
p = props[propName];
}
}
else
{
// Get accessor
string oldPropName = null;
if (codeStyle.AllowIsInPropertyName &&
propName.StartsWith(codeStyle.CLRPropertyIsPrefix) &&
props.ContainsKey(propName.Substring(codeStyle.CLRPropertyIsPrefix.Length)))
{
// is prefix
oldPropName = propName.Substring(codeStyle.CLRPropertyIsPrefix.Length);
}
else if (propName.StartsWith(codeStyle.CLRPropertyHasPrefix) &&
props.ContainsKey(propName.Substring(codeStyle.CLRPropertyHasPrefix.Length)))
{
// has prefix
oldPropName = propName.Substring(codeStyle.CLRPropertyHasPrefix.Length);
}
if (oldPropName != null)
{
MemberPropertyDefinition oldProp = props[oldPropName];
// We need to check here whether the set accessor is actually
if (oldProp.MemberTypeName == f.MemberTypeName)
{
props.Remove(oldPropName);
p = new MemberPropertyDefinition(propName);
p.MemberTypeName = oldProp.MemberTypeName;
p.PassedByType = oldProp.PassedByType;
p.SetterFunction = oldProp.SetterFunction;
props.Add(p.Name, p);
}
}
}
if (p == null)
{
// New property found
p = new MemberPropertyDefinition(propName);
if (f.IsPropertyGetAccessor)
{
p.MemberTypeName = f.MemberTypeName;
p.PassedByType = f.PassedByType;
}
else
{
p.MemberTypeName = f.Parameters[0].TypeName;
p.PassedByType = f.Parameters[0].PassedByType;
}
props.Add(p.Name, p);
}
}
if (f.IsPropertyGetAccessor)
{
p.GetterFunction = f;
}
else if (f.IsPropertySetAccessor)
{
p.SetterFunction = f;
}
}
return(props.Values.ToArray());
}
protected override void GenerateCodeProperty(MemberPropertyDefinition p)
{
string ptype = GetCLRTypeName(p);
string pname = GetClassName() + "::" + p.Name;
if (p.CanRead)
{
if (!(p.GetterFunction.IsAbstract && AllowSubclassing))
{
if (AllowProtectedMembers || p.GetterFunction.ProtectionLevel != ProtectionLevel.Protected)
{
string managedType = GetMethodNativeCall(p.GetterFunction, 0);
_codeBuilder.AppendLine(ptype + " " + pname + "::get()");
_codeBuilder.AppendLine("{");
if (_cachedMembers.Contains(p.GetterFunction))
{
string priv = NameToPrivate(p.Name);
_codeBuilder.AppendLine("\treturn ( CLR_NULL == " + priv + " ) ? (" + priv + " = " + managedType + ") : " + priv + ";");
}
else
{
_codeBuilder.AppendLine("\treturn " + managedType + ";");
}
_codeBuilder.AppendLine("}");
}
}
}
if (p.CanWrite)
{
if (!(p.SetterFunction.IsAbstract && AllowSubclassing))
{
if (AllowProtectedMembers || p.SetterFunction.ProtectionLevel != ProtectionLevel.Protected)
{
_codeBuilder.AppendLine("void " + pname + "::set( " + ptype + " " + p.SetterFunction.Parameters[0].Name + " )");
_codeBuilder.AppendLine("{");
_codeBuilder.IncreaseIndent();
string preCall = GetMethodPreNativeCall(p.SetterFunction, 1);
string nativeCall = GetMethodNativeCall(p.SetterFunction, 1);
string postCall = GetMethodPostNativeCall(p.SetterFunction, 1);
if (!String.IsNullOrEmpty(preCall))
{
_codeBuilder.AppendLine(preCall);
}
_codeBuilder.AppendLine(nativeCall + ";");
if (!String.IsNullOrEmpty(postCall))
{
_codeBuilder.AppendLine(postCall);
}
_codeBuilder.DecreaseIndent();
_codeBuilder.AppendLine("}");
}
}
}
}
protected override void GenerateCodeProperty(MemberPropertyDefinition p)
{
//TODO comments for properties
//AddComments(p);
string ptype = GetCLRTypeName(p);
_codeBuilder.AppendFormatIndent("property {0} {1}\n{{\n", ptype, p.Name);
if (p.CanRead)
{
MemberMethodDefinition f = p.GetterFunction;
bool methodIsVirtual = DeclareAsVirtual(f);
if (p.GetterFunction.ProtectionLevel == ProtectionLevel.Public || (AllowProtectedMembers && p.GetterFunction.ProtectionLevel == ProtectionLevel.Protected))
{
_codeBuilder.AppendLine(p.GetterFunction.ProtectionLevel.GetCLRProtectionName() + ":");
if (AllowMethodIndexAttributes && f.IsVirtual && !f.IsAbstract)
{
_codeBuilder.Append("\t");
AddMethodIndexAttribute(f);
}
_codeBuilder.AppendIndent("\t");
if (p.GetterFunction.IsStatic)
{
_codeBuilder.Append("static ");
}
if (methodIsVirtual)
{
_codeBuilder.Append("virtual ");
}
_codeBuilder.Append(ptype + " get()");
if (DeclareAsOverride(p.GetterFunction))
{
_codeBuilder.Append(" override");
}
else if (f.IsAbstract && AllowSubclassing)
{
_codeBuilder.Append(" abstract");
}
_codeBuilder.Append(";\n");
}
}
if (p.CanWrite)
{
MemberMethodDefinition f = p.SetterFunction;
bool methodIsVirtual = DeclareAsVirtual(f);
if (p.SetterFunction.ProtectionLevel == ProtectionLevel.Public || (AllowProtectedMembers && p.SetterFunction.ProtectionLevel == ProtectionLevel.Protected))
{
_codeBuilder.AppendLine(p.SetterFunction.ProtectionLevel.GetCLRProtectionName() + ":");
if (AllowMethodIndexAttributes && f.IsVirtual && !f.IsAbstract)
{
_codeBuilder.Append("\t");
AddMethodIndexAttribute(f);
}
_codeBuilder.AppendIndent("\t");
if (p.SetterFunction.IsStatic)
{
_codeBuilder.Append("static ");
}
if (methodIsVirtual)
{
_codeBuilder.Append("virtual ");
}
_codeBuilder.Append("void set(" + ptype + " " + p.SetterFunction.Parameters[0].Name + ")");
if (DeclareAsOverride(p.SetterFunction))
{
_codeBuilder.Append(" override");
}
else if (f.IsAbstract && AllowSubclassing)
{
_codeBuilder.Append(" abstract");
}
_codeBuilder.Append(";\n");
}
}
_codeBuilder.AppendLine("}");
}
protected virtual void GenerateCodeInterfaceProperty(MemberPropertyDefinition prop)
{
GenerateCodeProperty(prop);
}
protected virtual void Init()
{
if (_initCalled)
{
return;
}
_initCalled = true;
foreach (MemberMethodDefinition f in _classDefinition.PublicMethods)
{
if (f.IsListenerAdder && !f.IsIgnored)
{
_listeners.Add((ClassDefinition)f.Parameters[0].Type);
}
}
foreach (ClassDefinition iface in _classDefinition.GetInterfaces())
{
// Add attributes of interface methods from the interface classes
foreach (MemberMethodDefinition f in iface.Methods)
{
MemberMethodDefinition tf = _classDefinition.GetMethodWithSignature(f.Signature);
if (tf != null)
{
tf.AddAttributes(f.Attributes);
}
}
//Store properties of interface classes. They have precedence over type's properties.
foreach (MemberPropertyDefinition ip in iface.GetProperties())
{
if (IsPropertyAllowed(ip) &&
(ip.ProtectionLevel == ProtectionLevel.Public ||
(AllowProtectedMembers && ip.ProtectionLevel == ProtectionLevel.Protected)))
{
_interfaceProperties.Add(ip);
}
}
}
foreach (MemberFieldDefinition field in _classDefinition.Fields)
{
if (!field.IsIgnored && field.MemberType.IsSTLContainer)
{
if (field.ProtectionLevel == ProtectionLevel.Public ||
((AllowSubclassing || AllowProtectedMembers) && field.ProtectionLevel == ProtectionLevel.Protected))
{
MarkCachedMember(field);
}
}
}
foreach (ClassDefinition iface in _interfaces)
{
if (iface == _classDefinition)
{
continue;
}
foreach (MemberFieldDefinition field in iface.Fields)
{
if (!field.IsIgnored && field.MemberType.IsSTLContainer &&
!field.IsStatic)
{
if (field.ProtectionLevel == ProtectionLevel.Public ||
((AllowSubclassing || AllowProtectedMembers) && field.ProtectionLevel == ProtectionLevel.Protected))
{
MarkCachedMember(field);
}
}
}
}
foreach (MemberMethodDefinition func in _classDefinition.AbstractFunctions)
{
if (func.ProtectionLevel == ProtectionLevel.Public ||
(AllowProtectedMembers && func.ProtectionLevel == ProtectionLevel.Protected))
{
if ((func.ContainingClass.AllowSubClassing || (func.ContainingClass == _classDefinition && AllowSubclassing)) && !func.IsProperty)
{
_isAbstractClass = true;
_abstractFunctions.Add(func);
}
}
}
foreach (MemberPropertyDefinition prop in _classDefinition.AbstractProperties)
{
if (IsPropertyAllowed(prop) && (prop.ContainingClass.AllowSubClassing ||
(prop.ContainingClass == _classDefinition && AllowSubclassing)))
{
if (prop.ProtectionLevel == ProtectionLevel.Public ||
(AllowProtectedMembers && prop.ProtectionLevel == ProtectionLevel.Protected))
{
_isAbstractClass = true;
_abstractProperties.Add(prop);
}
}
}
SearchOverridableFunctions(_classDefinition);
//SearchProtectedFields(_t);
foreach (ClassDefinition iface in _interfaces)
{
SearchOverridableFunctions(iface);
//SearchProtectedFields(iface);
}
_overridableProperties = MemberPropertyDefinition.GetPropertiesFromMethods(_overridableFunctions);
//Find cached members
foreach (MemberDefinitionBase m in _classDefinition.Members)
{
if (m.HasAttribute <CachedGetAccessorAttribute>())
{
MarkCachedMember(m);
}
}
foreach (ClassDefinition iface in _interfaces)
{
if (iface == _classDefinition)
{
continue;
}
foreach (MemberDefinitionBase m in iface.Members)
{
if (m.HasAttribute <CachedGetAccessorAttribute>())
{
MarkCachedMember(m);
}
}
}
}
protected virtual void GenerateCodeProperty(MemberPropertyDefinition prop)
{
}
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);
}
}
}