public bool Apply(IFunctionSpecificationAnalyser aNativeFunction, IFunctionAssembler aAssembler)
{
var matcher = Matcher.CType(
new TupleCType(aNativeFunction.CurrentParameterType, aNativeFunction.NextParameterType));
if (!matcher.Match(new TupleCType(
new PointerCType(new NamedCType("char")),
new NamedCType("int")
)))
{
return false;
}
if (aNativeFunction.CurrentParameter.Name != "buffer") return false;
if (aNativeFunction.NextParameter.Name != "buffer_size") return false;
string parameterName = aNativeFunction.CurrentParameter.Name;
string utf8StringName = "utf8_"+parameterName;
aAssembler.AddPInvokeParameter(new CSharpType("IntPtr"), aNativeFunction.CurrentParameter.Name, utf8StringName + ".IntPtr");
aAssembler.AddPInvokeParameter(new CSharpType("int"), aNativeFunction.NextParameter.Name, utf8StringName + ".BufferLength");
aAssembler.SetManagedReturn(new CSharpType("string"));
aAssembler.InsertAtTop( "string returnValue;");
aAssembler.InsertBeforeCall("using (Utf8String " + utf8StringName + " = SpotifyMarshalling.AllocBuffer(256))");
aAssembler.InsertBeforeCall("{");
aAssembler.IncreaseIndent();
aAssembler.InsertAfterCall("returnValue = " + utf8StringName + ".Value;");
aAssembler.DecreaseIndent();
aAssembler.InsertAfterCall("}");
aAssembler.InsertAtEnd("return returnValue;");
aNativeFunction.ConsumeArgument();
aNativeFunction.ConsumeArgument();
return true;
}
public bool Apply(IFunctionSpecificationAnalyser aNativeFunction, IFunctionAssembler aAssembler)
{
var firstArgType = aNativeFunction.CurrentParameterType;
var secondArgType = aNativeFunction.NextParameterType;
bool secondArgIsInt = secondArgType.MatchToPattern(new NamedCType("int")).IsMatch;
if (!secondArgIsInt) { return false; }
bool firstArgIsPointer = firstArgType is PointerCType;
if (!firstArgIsPointer) { return false; }
var derefOnceType = firstArgType.ChildType;
bool firstArgIsPointerToPointer = derefOnceType is PointerCType;
if (!firstArgIsPointerToPointer) { return false; }
var derefTwiceType = derefOnceType.ChildType;
bool firstArgIsPointerToPointerToNamedType = derefTwiceType is NamedCType;
if (!firstArgIsPointerToPointerToNamedType) { return false; }
var elementType = (NamedCType)derefTwiceType;
bool arrayIsMutable = !derefOnceType.Qualifiers.Contains("const");
string arg1name = aNativeFunction.CurrentParameter.Name;
string arg2name = aNativeFunction.NextParameter.Name;
if (arg2name != "num_" + arg1name) { return false; }
string className;
if (!iHandlesToClassNames.TryGetValue(elementType.Name, out className)) { return false; }
// Finally, we are sure that this is an array of handles.
// Now we need to marshal the cursed thing!
string paramName = aNativeFunction.CurrentParameter.Name;
aAssembler.AddPInvokeParameter(
new CSharpType("IntPtr"),
paramName,
"array_" + paramName + ".IntPtr");
aAssembler.AddPInvokeParameter(
new CSharpType("int"),
"num_" + paramName,
"array_" + paramName + ".Length");
aAssembler.AddManagedParameter(
paramName,
new CSharpType(className + "[]"));
aAssembler.InsertBeforeCall("using (var array_" + paramName + " = SpotifyMarshalling.ArrayToNativeArray(" + paramName + ", x=>x._handle))");
aAssembler.InsertBeforeCall("{");
aAssembler.IncreaseIndent();
if (arrayIsMutable)
{
// Unless we pass in a 'handle * const *', the function might have changed
// the content of the array, so copy it back.
aAssembler.InsertAfterCall("array_" + paramName + ".CopyTo(" + paramName + ", ptr => ptr == IntPtr.Zero ? null : new " + className + "(ptr));");
}
aAssembler.DecreaseIndent();
aAssembler.InsertAfterCall( "}");
aNativeFunction.ConsumeArgument();
aNativeFunction.ConsumeArgument();
return true;
}
public bool Apply(IFunctionSpecificationAnalyser aNativeFunction, IFunctionAssembler aAssembler)
{
var matcher = Matcher.CType(new TupleCType(
aNativeFunction.CurrentParameterType,
aNativeFunction.NextParameterType));
if (!matcher.Match(new TupleCType(
new PointerCType(new VariableCType("element-type")),
new NamedCType("int"))))
{
return false;
}
var elementType = matcher.BoundVariables["element-type"] as NamedCType;
if (elementType == null) { return false; }
string arg1name = aNativeFunction.CurrentParameter.Name;
string arg2name = aNativeFunction.NextParameter.Name;
if (arg2name != "num_" + arg1name) { return false; }
string managedType;
switch (elementType.Name)
{
case "int":
managedType = "int";
break;
default:
return false;
}
// Finally, we are sure that this is an array of handles.
// Now we need to marshal the cursed thing!
string paramName = aNativeFunction.CurrentParameter.Name;
aAssembler.AddPInvokeParameter(
new CSharpType("IntPtr"),
paramName,
"array_" + paramName + ".IntPtr");
aAssembler.AddPInvokeParameter(
new CSharpType("int"),
"num_" + paramName,
"array_" + paramName + ".Length");
aAssembler.AddManagedParameter(
paramName,
new CSharpType(managedType + "[]"));
aAssembler.InsertBeforeCall("using (var array_" + paramName + " = SpotifyMarshalling.ArrayToNativeArray(" + paramName + "))");
aAssembler.InsertBeforeCall("{");
aAssembler.IncreaseIndent();
aAssembler.InsertAfterCall( "Array.Copy(array_"+paramName+".Value(), "+paramName+", "+paramName+".Length);");
aAssembler.DecreaseIndent();
aAssembler.InsertAfterCall("}");
aNativeFunction.ConsumeArgument();
aNativeFunction.ConsumeArgument();
return true;
}
public bool Apply(IFunctionSpecificationAnalyser aNativeFunction, IFunctionAssembler aAssembler)
{
if (!aNativeFunction.CurrentParameterType.MatchToPattern(
new PointerCType(new NamedCType("char"))).IsMatch)
{
return(false);
}
if (-1 != Matcher.CType(aNativeFunction.CurrentParameterType).FirstMatch(
new NamedCType("size_t"),
new NamedCType("int")
))
{
return(false);
}
if (!aNativeFunction.ReturnType.MatchToPattern(
new NamedCType("int")).IsMatch)
{
return(false);
}
if (aNativeFunction.CurrentParameterIndex != aNativeFunction.ParameterCount - 2)
{
return(false);
}
string lengthNativeType = ((NamedCType)aNativeFunction.NextParameterType).Name;
string lengthManagedType = lengthNativeType == "size_t" ? "UIntPtr" : "int";
string parameterName = aNativeFunction.CurrentParameter.Name;
string utf8StringName = "utf8_" + parameterName;
aAssembler.AddPInvokeParameter(new CSharpType("IntPtr"), aNativeFunction.CurrentParameter.Name, utf8StringName + ".IntPtr");
aAssembler.AddPInvokeParameter(new CSharpType(lengthManagedType), aNativeFunction.NextParameter.Name, "(" + lengthManagedType + ")(" + utf8StringName + ".BufferLength)");
aAssembler.SetPInvokeReturn(new CSharpType("int"), "stringLength_" + parameterName);
aAssembler.SetManagedReturn(new CSharpType("string"));
aAssembler.InsertAtTop("string returnValue;");
aAssembler.InsertAtTop("int stringLength_" + parameterName + " = 256;");
aAssembler.InsertBeforeCall("using (Utf8String " + utf8StringName + " = SpotifyMarshalling.AllocBuffer(stringLength_" + parameterName + "))");
aAssembler.InsertBeforeCall("{");
aAssembler.IncreaseIndent();
aAssembler.InsertPreCall("stringLength_" + parameterName);
aAssembler.InsertBeforeCall(utf8StringName + ".ReallocIfSmaller(stringLength_" + parameterName + " + 1);");
aAssembler.InsertAfterCall("returnValue = " + utf8StringName + ".GetString(stringLength_" + parameterName + ");");
aAssembler.DecreaseIndent();
aAssembler.InsertAfterCall("}");
aAssembler.InsertAtEnd("return returnValue;");
aNativeFunction.ConsumeArgument();
aNativeFunction.ConsumeArgument();
aNativeFunction.ConsumeReturn();
return(true);
}
public bool Apply(IFunctionSpecificationAnalyser aNativeFunction, IFunctionAssembler aAssembler)
{
if (!aNativeFunction.CurrentParameterType.MatchToPattern(
new PointerCType(new NamedCType("char"))).IsMatch)
{
return false;
}
if (-1 != Matcher.CType(aNativeFunction.CurrentParameterType).FirstMatch(
new NamedCType("size_t"),
new NamedCType("int")
))
{
return false;
}
if (!aNativeFunction.ReturnType.MatchToPattern(
new NamedCType("int")).IsMatch)
{
return false;
}
if (aNativeFunction.CurrentParameterIndex != aNativeFunction.ParameterCount - 2)
{
return false;
}
string lengthNativeType = ((NamedCType)aNativeFunction.NextParameterType).Name;
string lengthManagedType = lengthNativeType == "size_t" ? "UIntPtr" : "int";
string parameterName = aNativeFunction.CurrentParameter.Name;
string utf8StringName = "utf8_"+parameterName;
aAssembler.AddPInvokeParameter(new CSharpType("IntPtr"), aNativeFunction.CurrentParameter.Name, utf8StringName + ".IntPtr");
aAssembler.AddPInvokeParameter(new CSharpType(lengthManagedType), aNativeFunction.NextParameter.Name, "(" + lengthManagedType + ")(" + utf8StringName + ".BufferLength)");
aAssembler.SetPInvokeReturn(new CSharpType("int"), "stringLength_"+parameterName);
aAssembler.SetManagedReturn(new CSharpType("string"));
aAssembler.InsertAtTop( "string returnValue;");
aAssembler.InsertAtTop("int stringLength_" + parameterName + " = 256;");
aAssembler.InsertBeforeCall("using (Utf8String " + utf8StringName + " = SpotifyMarshalling.AllocBuffer(stringLength_" + parameterName + "))");
aAssembler.InsertBeforeCall("{");
aAssembler.IncreaseIndent();
aAssembler.InsertPreCall("stringLength_" + parameterName);
aAssembler.InsertBeforeCall(utf8StringName + ".ReallocIfSmaller(stringLength_" + parameterName + " + 1);");
aAssembler.InsertAfterCall("returnValue = " + utf8StringName + ".GetString(stringLength_" + parameterName + ");");
aAssembler.DecreaseIndent();
aAssembler.InsertAfterCall("}");
aAssembler.InsertAtEnd("return returnValue;");
aNativeFunction.ConsumeArgument();
aNativeFunction.ConsumeArgument();
aNativeFunction.ConsumeReturn();
return true;
}
public bool Apply(IFunctionSpecificationAnalyser aNativeFunction, IFunctionAssembler aAssembler)
{
var matcher = Matcher.CType(aNativeFunction.CurrentParameterType);
if (!matcher.Match(new PointerCType(new NamedCType("char") { Qualifiers = { "const" } })))
{
return false;
}
string utf8StringName = "utf8_" + aNativeFunction.CurrentParameter.Name;
aAssembler.AddPInvokeParameter(new CSharpType("IntPtr"), aNativeFunction.CurrentParameter.Name, utf8StringName + ".IntPtr");
aAssembler.AddManagedParameter(aNativeFunction.CurrentParameter.Name, new CSharpType("string"));
aAssembler.InsertBeforeCall("using (Utf8String " + utf8StringName + " = SpotifyMarshalling.StringToUtf8(" + aNativeFunction.CurrentParameter.Name + "))");
aAssembler.InsertBeforeCall("{");
aAssembler.IncreaseIndent();
aAssembler.DecreaseIndent();
aAssembler.InsertAfterCall("}");
aNativeFunction.ConsumeArgument();
return true;
}
public bool Apply(IFunctionSpecificationAnalyser aNativeFunction, IFunctionAssembler aAssembler)
{
var matcher = Matcher.CType(
new TupleCType(aNativeFunction.CurrentParameterType, aNativeFunction.NextParameterType));
if (!matcher.Match(new TupleCType(
new PointerCType(new NamedCType("char")),
new NamedCType("int")
)))
{
return(false);
}
if (aNativeFunction.CurrentParameter.Name != "buffer")
{
return(false);
}
if (aNativeFunction.NextParameter.Name != "buffer_size")
{
return(false);
}
string parameterName = aNativeFunction.CurrentParameter.Name;
string utf8StringName = "utf8_" + parameterName;
aAssembler.AddPInvokeParameter(new CSharpType("IntPtr"), aNativeFunction.CurrentParameter.Name, utf8StringName + ".IntPtr");
aAssembler.AddPInvokeParameter(new CSharpType("int"), aNativeFunction.NextParameter.Name, utf8StringName + ".BufferLength");
aAssembler.SetManagedReturn(new CSharpType("string"));
aAssembler.InsertAtTop("string returnValue;");
aAssembler.InsertBeforeCall("using (Utf8String " + utf8StringName + " = SpotifyMarshalling.AllocBuffer(256))");
aAssembler.InsertBeforeCall("{");
aAssembler.IncreaseIndent();
aAssembler.InsertAfterCall("returnValue = " + utf8StringName + ".Value;");
aAssembler.DecreaseIndent();
aAssembler.InsertAfterCall("}");
aAssembler.InsertAtEnd("return returnValue;");
aNativeFunction.ConsumeArgument();
aNativeFunction.ConsumeArgument();
return(true);
}
public bool Apply(IFunctionSpecificationAnalyser aNativeFunction, IFunctionAssembler aAssembler)
{
var matcher = Matcher.CType(aNativeFunction.CurrentParameterType);
if (!matcher.Match(new PointerCType(new NamedCType("char")
{
Qualifiers = { "const" }
})))
{
return(false);
}
string utf8StringName = "utf8_" + aNativeFunction.CurrentParameter.Name;
aAssembler.AddPInvokeParameter(new CSharpType("IntPtr"), aNativeFunction.CurrentParameter.Name, utf8StringName + ".IntPtr");
aAssembler.AddManagedParameter(aNativeFunction.CurrentParameter.Name, new CSharpType("string"));
aAssembler.InsertBeforeCall("using (Utf8String " + utf8StringName + " = SpotifyMarshalling.StringToUtf8(" + aNativeFunction.CurrentParameter.Name + "))");
aAssembler.InsertBeforeCall("{");
aAssembler.IncreaseIndent();
aAssembler.DecreaseIndent();
aAssembler.InsertAfterCall("}");
aNativeFunction.ConsumeArgument();
return(true);
}
public bool Apply(IFunctionSpecificationAnalyser aNativeFunction, IFunctionAssembler aAssembler)
{
var firstArgType = aNativeFunction.CurrentParameterType;
var secondArgType = aNativeFunction.NextParameterType;
bool secondArgIsInt = secondArgType.MatchToPattern(new NamedCType("int")).IsMatch;
if (!secondArgIsInt)
{
return(false);
}
bool firstArgIsPointer = firstArgType is PointerCType;
if (!firstArgIsPointer)
{
return(false);
}
var derefOnceType = firstArgType.ChildType;
bool firstArgIsPointerToPointer = derefOnceType is PointerCType;
if (!firstArgIsPointerToPointer)
{
return(false);
}
var derefTwiceType = derefOnceType.ChildType;
bool firstArgIsPointerToPointerToNamedType = derefTwiceType is NamedCType;
if (!firstArgIsPointerToPointerToNamedType)
{
return(false);
}
var elementType = (NamedCType)derefTwiceType;
bool arrayIsMutable = !derefOnceType.Qualifiers.Contains("const");
string arg1name = aNativeFunction.CurrentParameter.Name;
string arg2name = aNativeFunction.NextParameter.Name;
if (arg2name != "num_" + arg1name)
{
return(false);
}
string className;
if (!iHandlesToClassNames.TryGetValue(elementType.Name, out className))
{
return(false);
}
// Finally, we are sure that this is an array of handles.
// Now we need to marshal the cursed thing!
string paramName = aNativeFunction.CurrentParameter.Name;
aAssembler.AddPInvokeParameter(
new CSharpType("IntPtr"),
paramName,
"array_" + paramName + ".IntPtr");
aAssembler.AddPInvokeParameter(
new CSharpType("int"),
"num_" + paramName,
"array_" + paramName + ".Length");
aAssembler.AddManagedParameter(
paramName,
new CSharpType(className + "[]"));
aAssembler.InsertBeforeCall("using (var array_" + paramName + " = SpotifyMarshalling.ArrayToNativeArray(" + paramName + ", x=>x._handle))");
aAssembler.InsertBeforeCall("{");
aAssembler.IncreaseIndent();
if (arrayIsMutable)
{
// Unless we pass in a 'handle * const *', the function might have changed
// the content of the array, so copy it back.
aAssembler.InsertAfterCall("array_" + paramName + ".CopyTo(" + paramName + ", ptr => ptr == IntPtr.Zero ? null : new " + className + "(ptr));");
}
aAssembler.DecreaseIndent();
aAssembler.InsertAfterCall("}");
aNativeFunction.ConsumeArgument();
aNativeFunction.ConsumeArgument();
return(true);
}
public bool Apply(IFunctionSpecificationAnalyser aNativeFunction, IFunctionAssembler aAssembler)
{
var matcher = Matcher.CType(new TupleCType(
aNativeFunction.CurrentParameterType,
aNativeFunction.NextParameterType));
if (!matcher.Match(new TupleCType(
new PointerCType(new VariableCType("element-type")),
new NamedCType("int"))))
{
return(false);
}
var elementType = matcher.BoundVariables["element-type"] as NamedCType;
if (elementType == null)
{
return(false);
}
string arg1name = aNativeFunction.CurrentParameter.Name;
string arg2name = aNativeFunction.NextParameter.Name;
if (arg2name != "num_" + arg1name)
{
return(false);
}
string managedType;
switch (elementType.Name)
{
case "int":
managedType = "int";
break;
default:
return(false);
}
// Finally, we are sure that this is an array of handles.
// Now we need to marshal the cursed thing!
string paramName = aNativeFunction.CurrentParameter.Name;
aAssembler.AddPInvokeParameter(
new CSharpType("IntPtr"),
paramName,
"array_" + paramName + ".IntPtr");
aAssembler.AddPInvokeParameter(
new CSharpType("int"),
"num_" + paramName,
"array_" + paramName + ".Length");
aAssembler.AddManagedParameter(
paramName,
new CSharpType(managedType + "[]"));
aAssembler.InsertBeforeCall("using (var array_" + paramName + " = SpotifyMarshalling.ArrayToNativeArray(" + paramName + "))");
aAssembler.InsertBeforeCall("{");
aAssembler.IncreaseIndent();
aAssembler.InsertAfterCall("Array.Copy(array_" + paramName + ".Value(), " + paramName + ", " + paramName + ".Length);");
aAssembler.DecreaseIndent();
aAssembler.InsertAfterCall("}");
aNativeFunction.ConsumeArgument();
aNativeFunction.ConsumeArgument();
return(true);
}
