private bool UpdateName(Function function)
{
if (function.TranslationUnit.Module != null)
Generator.CurrentOutputNamespace = function.TranslationUnit.Module.OutputNamespace;
var @params = function.Parameters.Where(p => p.Kind != ParameterKind.IndirectReturnType)
.Select(p => p.QualifiedType.ToString());
// Include the conversion type in case of conversion operators
var method = function as Method;
if (method != null &&
method.IsOperator &&
(method.OperatorKind == CXXOperatorKind.Conversion ||
method.OperatorKind == CXXOperatorKind.ExplicitConversion))
@params = @params.Concat(new[] { method.ConversionType.ToString() });
var signature = string.Format("{0}({1})", function.Name, string.Join( ", ", @params));
signature = FixSignatureForConversions(function, signature);
if (Count == 0)
Count++;
if (!methodSignatures.ContainsKey(signature))
{
methodSignatures.Add(signature, 0);
return false;
}
var methodCount = ++methodSignatures[signature];
if (Count < methodCount + 1)
Count = methodCount + 1;
if (function.IsOperator)
{
// TODO: turn into a method; append the original type (say, "signed long")
// of the last parameter to the type so that the user knows which overload is called
diagnostics.Warning("Duplicate operator {0} ignored", function.Name);
function.ExplicitlyIgnore();
}
else if (method != null && method.IsConstructor)
{
diagnostics.Warning("Duplicate constructor {0} ignored", function.Name);
function.ExplicitlyIgnore();
}
else
function.Name += methodCount.ToString(CultureInfo.InvariantCulture);
return true;
}
public override bool VisitFunctionDecl(Function function)
{
if (function.GenerationKind == GenerationKind.None)
return false;
if (function.Parameters.Any(param => IsStdType(param.QualifiedType)))
{
function.ExplicitlyIgnore();
return false;
}
return true;
}
static bool CheckDefaultParameters(Function function, Function overload)
{
var commonParameters = Math.Min(function.Parameters.Count, overload.Parameters.Count);
var i = 0;
for (; i < commonParameters; ++i)
{
var funcParam = function.Parameters[i];
var overloadParam = overload.Parameters[i];
if (!funcParam.QualifiedType.Equals(overloadParam.QualifiedType))
return false;
}
for (; i < function.Parameters.Count; ++i)
{
var funcParam = function.Parameters[i];
if (!funcParam.HasDefaultValue)
return false;
}
for (; i < overload.Parameters.Count; ++i)
{
var overloadParam = overload.Parameters[i];
if (!overloadParam.HasDefaultValue)
return false;
}
if (function.Parameters.Count > overload.Parameters.Count)
overload.ExplicitlyIgnore();
else
function.ExplicitlyIgnore();
return true;
}
public override bool VisitFunctionDecl(Function function)
{
if (!VisitDeclaration(function))
return false;
var ret = function.ReturnType;
string msg;
if (HasInvalidType(ret.Type, out msg))
{
function.ExplicitlyIgnore();
Log.Debug("Function '{0}' was ignored due to {1} return decl",
function.Name, msg);
return false;
}
foreach (var param in function.Parameters)
{
if (HasInvalidDecl(param, out msg))
{
function.ExplicitlyIgnore();
Log.Debug("Function '{0}' was ignored due to {1} param",
function.Name, msg);
return false;
}
if (HasInvalidType(param.Type, out msg))
{
function.ExplicitlyIgnore();
Log.Debug("Function '{0}' was ignored due to {1} param",
function.Name, msg);
return false;
}
var decayedType = param.Type.Desugar() as DecayedType;
if (decayedType != null)
{
function.ExplicitlyIgnore();
Log.Debug("Function '{0}' was ignored due to unsupported decayed type param",
function.Name);
return false;
}
if (param.Kind == ParameterKind.IndirectReturnType)
{
Class retClass;
param.Type.Desugar().TryGetClass(out retClass);
if (retClass == null)
{
function.ExplicitlyIgnore();
Log.Debug(
"Function '{0}' was ignored due to an indirect return param not of a tag type",
function.Name);
return false;
}
}
}
return true;
}
private static bool CheckSingleParameterPointerConstnessForAmbiguity(
Function function, Function overload)
{
var functionParams = function.Parameters.Where(
p => p.Kind == ParameterKind.Regular).ToList();
// It's difficult to handle this case for more than one parameter
// For example, if we have:
// void f(float&, const int&);
// void f(const float&, int&);
// what should we do? Generate both? Generate the first one encountered?
// Generate the one with the least amount of "complex" parameters?
// So let's just start with the simplest case for the time being
if (functionParams.Count != 1)
return false;
var overloadParams = overload.Parameters.Where(
p => p.Kind == ParameterKind.Regular).ToList();
if (overloadParams.Count != 1)
return false;
var parameterFunction = functionParams[0];
var parameterOverload = overloadParams[0];
var pointerParamFunction = parameterFunction.Type.Desugar() as PointerType;
var pointerParamOverload = parameterOverload.Type.Desugar() as PointerType;
if (pointerParamFunction == null || pointerParamOverload == null)
return false;
if (!pointerParamFunction.GetPointee().Equals(pointerParamOverload.GetPointee()))
return false;
if (parameterFunction.IsConst && !parameterOverload.IsConst)
{
function.ExplicitlyIgnore();
return true;
}
if (parameterOverload.IsConst && !parameterFunction.IsConst)
{
overload.ExplicitlyIgnore();
return true;
}
if (pointerParamFunction.Modifier == PointerType.TypeModifier.RVReference &&
pointerParamOverload.Modifier != PointerType.TypeModifier.RVReference)
{
function.ExplicitlyIgnore();
return true;
}
if (pointerParamFunction.Modifier != PointerType.TypeModifier.RVReference &&
pointerParamOverload.Modifier == PointerType.TypeModifier.RVReference)
{
overload.ExplicitlyIgnore();
return true;
}
return false;
}
