public void ScheduleAttributeAccessor(Smoke *smoke, Smoke.Method *meth)
{
string name = ByteArrayManager.GetString(smoke->methodNames[meth->name]);
bool isSetMethod = false;
if (name.StartsWith("set"))
{
name = name.Remove(0, 3);
isSetMethod = true;
}
else
{
// capitalize the first letter
StringBuilder builder = new StringBuilder(name);
builder[0] = char.ToUpper(builder[0]);
name = builder.ToString();
}
// If the new name clashes with a name of a type declaration, keep the lower-case name.
var typesWithSameName = from member in data.GetAccessibleMembers(smoke->classes + meth->classId)
where (member.Type == MemberTypes.NestedType ||
member.Type == MemberTypes.Method) &&
member.Name == name
select member;
if (typesWithSameName.Any())
{
string className = ByteArrayManager.GetString(smoke->classes[meth->classId].className);
Debug.Print(" |--Conflicting names: property/type: {0} in class {1} - keeping original property name", name,
className);
name = char.ToLower(name[0]) + name.Substring(1);
}
Attribute attr;
if (!attributes.TryGetValue(name, out attr))
{
attr = new Attribute();
attr.Smoke = smoke;
attributes.Add(name, attr);
}
if (isSetMethod)
{
attr.SetMethod = meth;
}
else
{
attr.GetMethod = meth;
}
}
public CodeMemberMethod GenerateBasicMethodDefinition(Smoke *smoke, Smoke.Method *method, string cppSignature,
CodeTypeReference iface)
{
// do we actually want that method?
string className = ByteArrayManager.GetString(smokeClass->className);
string completeSignature = className + "::" + cppSignature;
if (translator.ExcludedMethods.Any(regex => regex.IsMatch(completeSignature)))
{
return(null);
}
CodeParameterDeclarationExpressionCollection args = new CodeParameterDeclarationExpressionCollection();
int count = 1;
bool isRef;
// make instance operators static and bring the arguments in the correct order
string methName = ByteArrayManager.GetString(smoke->methodNames[method->name]);
bool isOperator = false;
string explicitConversionType = null;
if (methName.StartsWith("operator"))
{
string op = methName.Substring(8);
if (unsupportedOperators.Contains(op))
{
// not supported
Debug.Print(" |--Won't wrap method {0}::{1}", className, cppSignature);
return(null);
}
if (op == "<<")
{
methName = "Write";
}
else if (op == ">>")
{
methName = "Read";
}
// binary/unary operator
if (binaryOperators.Contains(op) || unaryOperators.Contains(op))
{
// instance operator
if (smoke->classes[method->classId].size > 0)
{
if (op == "*" && method->numArgs == 0 || (op == "++" || op == "--") && method->numArgs == 1)
{
// dereference operator and postfix in-/decrement operator are not supported
Debug.Print(" |--Won't wrap method {0}::{1}", className, cppSignature);
return(null);
}
try
{
CodeParameterDeclarationExpression exp =
new CodeParameterDeclarationExpression(translator.CppToCSharp(className, out isRef), "arg" + count++);
args.Add(exp);
}
catch (NotSupportedException)
{
Debug.Print(" |--Won't wrap method {0}::{1}", className, cppSignature);
return(null);
}
}
else
{
// global operator
if (op == "*" && method->numArgs == 0 || (op == "++" || op == "--") && method->numArgs == 2)
{
// dereference operator and postfix in-/decrement operator are not supported
Debug.Print(" |--Won't wrap method {0}::{1}", className, cppSignature);
return(null);
}
}
isOperator = true;
}
else if (op[0] == ' ')
{
// conversion operator
explicitConversionType = op.Substring(1);
if (explicitConversionType.Contains("QVariant"))
{
return(null);
}
try
{
explicitConversionType = translator.CppToCSharp(explicitConversionType, out isRef).GetStringRepresentation();
if (smoke->classes[method->classId].size > 0)
{
CodeParameterDeclarationExpression exp =
new CodeParameterDeclarationExpression(translator.CppToCSharp(className, out isRef), "arg" + count++);
args.Add(exp);
}
}
catch (NotSupportedException)
{
Debug.Print(" |--Won't wrap method {0}::{1}", className, cppSignature);
return(null);
}
isOperator = true;
}
}
// translate arguments
string[] methodArgs = isOperator ? null : GetMethodArgs(smoke, method);
for (short *typeIndex = smoke->argumentList + method->args; *typeIndex > 0; typeIndex++)
{
try
{
args.Add(this.GetArgument(smoke, typeIndex, methodArgs, args, ref count));
}
catch (NotSupportedException)
{
Debug.Print(" |--Won't wrap method {0}::{1}", className, cppSignature);
return(null);
}
}
this.RemovePreviousOverload(args, char.ToUpper(methName[0]) + methName.Substring(1));
// translate return type
CodeTypeReference returnType;
try
{
returnType = translator.CppToCSharp(smoke->types + method->ret, out isRef);
}
catch (NotSupportedException)
{
Debug.Print(" |--Won't wrap method {0}::{1}", className, cppSignature);
return(null);
}
CodeMemberMethod cmm;
if ((method->flags & (uint)Smoke.MethodFlags.mf_ctor) > 0)
{
cmm = new CodeConstructor();
cmm.Attributes = 0; // initialize to 0 so we can do |=
((CodeConstructor)cmm).ChainedConstructorArgs.Add(new CodeSnippetExpression("(System.Type) null"));
}
else
{
cmm = new CodeMemberMethod();
cmm.Attributes = 0; // initialize to 0 so we can do |=
string csName = methName;
if (!isOperator && methName != "finalize" && !qMethodExp.IsMatch(methName))
{
// capitalize the first letter
StringBuilder builder = new StringBuilder(csName);
builder[0] = char.ToUpper(builder[0]);
string tmp = builder.ToString();
// If the new name clashes with a name of a type declaration, keep the lower-case name.
var typesWithSameName = from member in data.GetAccessibleMembers(smokeClass)
where member.Type == MemberTypes.NestedType && member.Name == tmp
select member;
var propertiesWithSameName = (from member in data.GetAccessibleMembers(smokeClass)
where member.Type == MemberTypes.Property && member.Name == tmp
select member).ToList();
if (iface != null && propertiesWithSameName.Count() == 1 &&
(method->flags & (uint)Smoke.MethodFlags.mf_protected) == 0)
{
cmm.PrivateImplementationType = iface;
csName = tmp;
}
else
{
if (propertiesWithSameName.Any())
{
if ((method->flags & (uint)Smoke.MethodFlags.mf_virtual) == 0)
{
Debug.Print(
" |--Conflicting names: method/(type or property): {0} in class {1} - keeping original method name", tmp,
className);
}
else
{
csName = tmp;
}
}
else if (typesWithSameName.Any())
{
Debug.Print(" |--Conflicting names: method/classname: {0} in class {1} - keeping original method name", tmp,
className);
}
else
{
csName = tmp;
}
}
}
if (explicitConversionType != null)
{
cmm.Name = "explicit operator " + explicitConversionType;
cmm.ReturnType = new CodeTypeReference(" ");
}
else
{
cmm.Name = csName;
cmm.ReturnType = returnType;
}
}
// for destructors we already have this stuff set
if ((method->flags & (uint)Smoke.MethodFlags.mf_dtor) == 0)
{
// set access
if ((method->flags & (uint)Smoke.MethodFlags.mf_protected) > 0)
{
cmm.Attributes |= MemberAttributes.Family;
}
else
{
cmm.Attributes |= MemberAttributes.Public;
}
if (isOperator)
{
cmm.Attributes |= MemberAttributes.Final | MemberAttributes.Static;
}
else if (cmm.Name == "ToString" && args.Count == 0 && cmm.ReturnType.BaseType == "System.String")
{
cmm.Attributes = MemberAttributes.Public | MemberAttributes.Override;
}
else
{
if ((method->flags & (uint)Smoke.MethodFlags.mf_static) > 0)
{
cmm.Attributes |= MemberAttributes.Static;
}
else
{
// virtual/final
MemberAttributes access;
bool foundInInterface;
bool isOverride = MethodOverrides(smoke, method, out access, out foundInInterface);
// methods that have to be implemented from interfaces can't override anything
if (iface == null && (isOverride = MethodOverrides(smoke, method, out access, out foundInInterface)))
{
cmm.Attributes = access | MemberAttributes.Override;
}
else if (foundInInterface)
{
cmm.Attributes = access;
}
if ((method->flags & (uint)Smoke.MethodFlags.mf_purevirtual) > 0)
{
if (!m_internalImplementation)
{
cmm.Attributes = (cmm.Attributes & ~MemberAttributes.ScopeMask) | MemberAttributes.Abstract;
// The code generator doesn't like MemberAttributes.Abstract | MemberAttributes.Override being set.
if (isOverride && !type.IsInterface)
{
cmm.ReturnType.BaseType = "override " + cmm.ReturnType.BaseType == "System.Void"
? "void"
: cmm.ReturnType.BaseType;
}
}
else
{
cmm.Attributes |= MemberAttributes.Override;
}
}
if ((method->flags & (uint)Smoke.MethodFlags.mf_virtual) == 0 &&
(method->flags & (uint)Smoke.MethodFlags.mf_purevirtual) == 0 &&
!isOverride)
{
cmm.Attributes |= MemberAttributes.Final | MemberAttributes.New;
}
}
}
}
else
{
// hack, so we don't have to use CodeSnippetTypeMember to generator the destructor
cmm.ReturnType = new CodeTypeReference(" ");
}
// add the parameters
foreach (CodeParameterDeclarationExpression exp in args)
{
cmm.Parameters.Add(exp);
}
this.DistributeMethod(cmm);
return(cmm);
}
public void Run()
{
for (short classId = 1; classId <= data.Smoke->numClasses; classId++)
{
Smoke.Class *klass = data.Smoke->classes + classId;
if (klass->external)
{
continue;
}
List <Property> props = new List <Property>();
if (!GetProperties(data.Smoke, classId,
(name, originalType, typeName, writable, isEnum) =>
props.Add(new Property(name, originalType, typeName, writable, isEnum))))
{
continue;
}
CodeTypeDeclaration type = data.SmokeTypeMap[(IntPtr)klass];
string className = ByteArrayManager.GetString(klass->className);
foreach (Property prop in props)
{
CodeMemberProperty cmp = new CodeMemberProperty();
try
{
bool isRef;
short id = data.Smoke->IDType(prop.Type);
if (id > 0)
{
cmp.Type = translator.CppToCSharp(data.Smoke->types + id, out isRef);
}
else
{
if (!prop.Type.Contains("::"))
{
id = data.Smoke->IDType(className + "::" + prop.Type);
if (id > 0)
{
cmp.Type = translator.CppToCSharp(data.Smoke->types + id, out isRef);
}
else
{
cmp.Type = translator.CppToCSharp(prop.Type, out isRef);
}
}
cmp.Type = translator.CppToCSharp(prop.Type, out isRef);
}
}
catch (NotSupportedException)
{
Debug.Print(" |--Won't wrap Property {0}::{1}", className, prop.Name);
continue;
}
if (documentation.ContainsKey(type))
{
IList <string> docs = documentation[type];
for (int i = 0; i < docs.Count; i++)
{
Match match = Regex.Match(docs[i],
prop.Name + " : (const )?" + prop.OriginalType +
@"\n(?<docs>This.*?)\nAccess functions:", RegexOptions.Singleline);
if (match.Success)
{
Util.FormatComment(match.Groups["docs"].Value, cmp, i > 0);
break;
}
}
}
cmp.Name = prop.Name;
// capitalize the first letter
StringBuilder builder = new StringBuilder(cmp.Name);
builder[0] = char.ToUpper(builder[0]);
string capitalized = builder.ToString();
// If the new name clashes with a name of a type declaration, keep the lower-case name (or even make the name lower-case).
var typesWithSameName = from member in data.GetAccessibleMembers(data.Smoke->classes + classId)
where (member.Type == MemberTypes.NestedType ||
member.Type == MemberTypes.Method) &&
member.Name == capitalized
select member;
if (typesWithSameName.Any())
{
Debug.Print(
" |--Conflicting names: property/(type or method): {0} in class {1} - keeping original property name",
capitalized, className);
if (capitalized == cmp.Name)
{
builder[0] = char.ToLower(builder[0]);
cmp.Name = builder.ToString(); // lower case the property if necessary
}
}
else
{
cmp.Name = capitalized;
}
cmp.HasGet = true;
cmp.HasSet = prop.IsWritable;
cmp.Attributes = MemberAttributes.Public | MemberAttributes.New | MemberAttributes.Final;
cmp.CustomAttributes.Add(new CodeAttributeDeclaration("Q_PROPERTY",
new CodeAttributeArgument(
new CodePrimitiveExpression(prop.OriginalType)),
new CodeAttributeArgument(
new CodePrimitiveExpression(prop.Name))));
// ===== get-method =====
short getterMapId = FindQPropertyGetAccessorMethodMapId(classId, prop, capitalized);
if (getterMapId == 0)
{
Debug.Print(" |--Missing 'get' method for property {0}::{1} - using QObject.Property()", className, prop.Name);
cmp.GetStatements.Add(new CodeMethodReturnStatement(new CodeCastExpression(cmp.Type,
new CodeMethodInvokeExpression(
new CodeThisReferenceExpression(),
"Property",
new CodePrimitiveExpression(prop.Name)))));
}
else
{
Smoke.MethodMap *map = data.Smoke->methodMaps + getterMapId;
short getterId = map->method;
if (getterId < 0)
{
// simply choose the first (i.e. non-const) version if there are alternatives
getterId = data.Smoke->ambiguousMethodList[-getterId];
}
Smoke.Method *getter = data.Smoke->methods + getterId;
if (getter->classId != classId)
{
// The actual get method is defined in a parent class - don't create a property for it.
continue;
}
if ((getter->flags & (uint)Smoke.MethodFlags.mf_virtual) == 0 &&
(getter->flags & (uint)Smoke.MethodFlags.mf_purevirtual) == 0)
{
cmp.GetStatements.Add(new CodeMethodReturnStatement(new CodeCastExpression(cmp.Type,
new CodeMethodInvokeExpression(
SmokeSupport.interceptor_Invoke,
new CodePrimitiveExpression(
ByteArrayManager.GetString(
data.Smoke->methodNames[getter->name
])),
new CodePrimitiveExpression(
data.Smoke->GetMethodSignature(getter)),
new CodeTypeOfExpression(cmp.Type),
new CodePrimitiveExpression(false)))));
}
else
{
cmp.HasGet = false;
if (!cmp.HasSet)
{
// the get accessor is virtual and there's no set accessor => continue
continue;
}
}
}
// ===== set-method =====
if (!prop.IsWritable)
{
// not writable? => continue
type.Members.Add(cmp);
continue;
}
char mungedSuffix;
short setterMethId = FindQPropertySetAccessorMethodId(classId, prop, capitalized, out mungedSuffix);
if (setterMethId == 0)
{
Debug.Print(" |--Missing 'set' method for property {0}::{1} - using QObject.SetProperty()", className, prop.Name);
cmp.SetStatements.Add(new CodeExpressionStatement(
new CodeMethodInvokeExpression(new CodeThisReferenceExpression(), "SetProperty",
new CodePrimitiveExpression(prop.Name),
new CodeArgumentReferenceExpression("value"))));
}
else
{
Smoke.Method *setter = data.Smoke->methods + setterMethId;
if (setter->classId != classId)
{
// defined in parent class, continue
type.Members.Add(cmp);
continue;
}
string setterName = ByteArrayManager.GetString(data.Smoke->methodNames[setter->name]);
if (!cmp.HasGet)
{
// so the 'get' method is virtual - generating a property for only the 'set' method is a bad idea
MethodsGenerator mg = new MethodsGenerator(data, translator, type, klass);
mg.GenerateMethod(setterMethId, setterName + mungedSuffix);
continue;
}
cmp.SetStatements.Add(new CodeExpressionStatement(
new CodeMethodInvokeExpression(SmokeSupport.interceptor_Invoke,
new CodePrimitiveExpression(setterName + mungedSuffix),
new CodePrimitiveExpression(
this.data.Smoke->GetMethodSignature(setterMethId)),
new CodeTypeOfExpression(typeof(void)),
new CodePrimitiveExpression(false),
new CodeTypeOfExpression(cmp.Type),
new CodeArgumentReferenceExpression("value"))));
}
type.Members.Add(cmp);
}
}
}
