private void WriteMethodSignature(MethodDeclaration member, ICallSignature signature = null)
{
_Writer.WriteAccessibility(member.Accessibility);
WriteIsStatic(member.IsStatic);
WriteIsAsync(member.IsAsync);
WriteIsAbstract(member.IsAbstract);
_Writer.Write(member.MethodName);
WriteCallSignature(signature ?? member);
}
public static string GetComCompatibleName(this ICallSignature sig)
{
if (sig.OverloadOrdinal == 0)
{
return(sig.Name);
}
else
{
return(sig.Name + "_" + sig.OverloadOrdinal.ToString());
}
}
public static IEnumerable <IVariable> GetABIParametersCs(this ICallSignature sig, bool explicitContext = false)
{
foreach (var v in GetABIParametersCpp(sig, explicitContext))
{
if (v.IsArray && v.IsWriteable())
{
yield return(v.Morph(null, null, BasicTypes.IntPtr, false));
}
else
{
yield return(v);
}
}
}
private void WriteFunctionSignature(FunctionDeclaration member, ICallSignature signature = null)
{
WriteIsDeclare(member.IsDeclare);
WriteIsExport(member.IsExport);
WriteIsDefault(member.IsDefault);
WriteIsAsync(member.IsAsync);
_Writer.Write("function ");
if (member.FunctionName != null)
{
_Writer.Write(' ');
_Writer.Write(member.FunctionName);
}
WriteCallSignature(signature ?? member);
}
public static void WriteCallSignature(this TextWriter writer, ICallSignature signature)
{
writer.WriteTypeParameters(signature.TypeParameters);
if (signature.HasParameter)
{
writer.WriteParameters(signature.Parameters);
}
else
{
writer.Write("()");
}
if (signature.ReturnType != null)
{
writer.Write(": ");
signature.ReturnType.WriteTypeReference(writer);
}
}
public static bool SignatureEquals(this ICallSignature a, ICallSignature b)
{
if (!a.Return.Equals(b.Return) || a.Parameters.Count != b.Parameters.Count)
{
return(false);
}
for (int i = 0; i < a.Parameters.Count; i++)
{
if (!a.Parameters[i].Equals(b.Parameters[i]))
{
return(false);
}
}
return(true);
}
private void WriteCallSignature(ICallSignature signature)
{
_Writer.WriteTypeParameters(signature.TypeParameters);
if (signature.HasParameter)
{
WriteParameters(signature.Parameters);
}
else
{
_Writer.Write("()");
}
if (signature.ReturnType != null)
{
_Writer.Write(": ");
signature.ReturnType.WriteTypeReference(_Writer);
}
}
public static ICallSignature Rename(this ICallSignature c, string name)
{
var m = new Method()
{
Access = Access.Public,
Name = name,
Return = c.Return,
Nature = MemberNature.Abstract,
IsConst = c.IsConst
};
foreach (var arg in c.Parameters)
{
m.Parameters.Add(arg);
}
return(m);
}
public static IEnumerable <IVariable> GetABIParametersCpp(this ICallSignature sig, bool explicitContext = false)
{
if (explicitContext)
{
yield return(new Parameter(BasicTypes.IObject, "__i_", VariableContext.In, false));
}
foreach (var arg in sig.Parameters.GetABIParametersCpp())
{
yield return(arg);
}
if (sig.Return != null && !sig.Return.IsVoid)
{
foreach (var arg in sig.Return.Morph("___ret", VariableContext.Out).GetABIParametersCpp())
{
yield return(arg);
}
}
}
public override bool Equals(ICallSignature <CallingConventionSig> other) => Equals(other as MethodBaseSig);
private void WriteConstructorSignature(ConstructorDeclaration member, ICallSignature signature = null)
{
_Writer.WriteAccessibility(member.Accessibility);
_Writer.Write("constructor ");
WriteCallSignature(signature ?? member);
}
