private void VerifyFuncPtr(ParseResult result, int index, string str)
{
Assert.NotNull(result);
Assert.True(index < result.NativeDefinedTypes.Count, "Invalid index");
NativeFunctionPointer fptr = (NativeFunctionPointer)result.NativeDefinedTypes[index];
Assert.Equal(str, fptr.DisplayName);
}
public void SaveAndLoad6()
{
NativeFunctionPointer fptr = new NativeFunctionPointer("f1");
Assert.Equal(NativeCallingConvention.WinApi, fptr.CallingConvention);
fptr.CallingConvention = NativeCallingConvention.Pascal;
fptr.Signature.ReturnType = new NativeBuiltinType(BuiltinType.NativeChar);
NativeProcedure proc = new NativeProcedure("p1");
Assert.Equal(NativeCallingConvention.WinApi, proc.CallingConvention);
proc.CallingConvention = NativeCallingConvention.CDeclaration;
proc.Signature.ReturnType = new NativeBuiltinType(BuiltinType.NativeChar);
var ns = new BasicSymbolStorage();
ns.AddProcedure(proc);
ns.AddDefinedType(fptr);
NativeDefinedType temp = null;
NativeFunctionPointer retPtr = null;
Assert.True(ns.TryGetGlobalSymbol(fptr.Name, out temp));
retPtr = (NativeFunctionPointer)temp;
Assert.Equal(NativeCallingConvention.Pascal, retPtr.CallingConvention);
NativeProcedure retProc = null;
Assert.True(ns.TryGetGlobalSymbol(proc.Name, out retProc));
Assert.Equal(NativeCallingConvention.CDeclaration, retProc.CallingConvention);
}
private void WriteFunctionPointer(NativeFunctionPointer ptr)
{
_writer.WriteNameKind(NativeNameKind.FunctionPointer);
_writer.WriteString(ptr.Name);
_writer.WriteInt32((int)ptr.CallingConvention);
WriteSignature(ptr.Signature);
}
/// <summary>
/// Generate a delegate in code
/// </summary>
/// <param name="ntFuncPtr"></param>
/// <returns></returns>
/// <remarks></remarks>
public CodeTypeDelegate GenerateDelegate(NativeFunctionPointer ntFuncPtr)
{
if (ntFuncPtr == null)
{
throw new ArgumentNullException("ntFuncPtr");
}
string comment = "Return Type: ";
CodeTypeDelegate del = new CodeTypeDelegate();
del.Name = ntFuncPtr.Name;
del.Attributes = MemberAttributes.Public;
del.ReturnType = GenerateTypeReferenceImpl(ntFuncPtr.Signature.ReturnType, ref comment);
del.Parameters.AddRange(GenerateParameters(ntFuncPtr.Signature, ref comment));
// If there is a non-default calling convention we need to generate the attribute
if (ntFuncPtr.CallingConvention == NativeCallingConvention.CDeclaration || ntFuncPtr.CallingConvention == NativeCallingConvention.Standard)
{
del.CustomAttributes.Add(MarshalAttributeFactory.CreateUnmanagedFunctionPointerAttribute(ntFuncPtr.CallingConvention));
}
del.UserData[TransformConstants.DefinedType] = ntFuncPtr;
del.UserData[TransformConstants.ReturnType] = ntFuncPtr.Signature.ReturnType;
del.UserData[TransformConstants.ReturnTypeSal] = ntFuncPtr.Signature.ReturnTypeSalAttribute;
del.Comments.Add(new CodeCommentStatement(comment, true));
return(del);
}
private NativeGlobalSymbol ImportFunctionPointer()
{
var ptr = new NativeFunctionPointer(_reader.ReadString());
ptr.CallingConvention = (NativeCallingConvention)_reader.ReadInt32();
ptr.Signature = ImportSignature();
return(new NativeGlobalSymbol(ptr));
}
public void FunctionPointerSimple()
{
var p = new NativeFunctionPointer("ptr");
p.CallingConvention = NativeCallingConvention.CDeclaration;
p.Signature = new NativeSignature();
p.Signature.ReturnType = new NativeBuiltinType(BuiltinType.NativeInt32);
TestRoundTrip(p);
}
public void FunctionPointerReturnSal()
{
var p = new NativeFunctionPointer("ptr");
p.CallingConvention = NativeCallingConvention.CDeclaration;
p.Signature = new NativeSignature();
p.Signature.ReturnTypeSalAttribute = new NativeSalAttribute();
p.Signature.ReturnTypeSalAttribute.SalEntryList.Add(new NativeSalEntry(SalEntryType.NotNull));
p.Signature.ReturnType = new NativeBuiltinType(BuiltinType.NativeInt32);
TestRoundTrip(p);
}
public void FuncPtr1()
{
NativeFunctionPointer fptr = new NativeFunctionPointer("f1");
fptr.Signature.ReturnType = new NativeBuiltinType(BuiltinType.NativeChar);
fptr.Signature.Parameters.Add(new NativeParameter("f", new NativeBuiltinType(BuiltinType.NativeFloat)));
var ns = new BasicSymbolStorage();
ns.AddDefinedType(fptr);
NativeDefinedType retFptr = null;
Assert.True(ns.TryGetGlobalSymbol(fptr.Name, out retFptr));
Assert.Equal("char (*f1)(float f)", ((NativeFunctionPointer)retFptr).DisplayName);
}
public void Pre()
{
NativeFunctionPointer ptr = new NativeFunctionPointer("foo");
Assert.NotNull(ptr.Signature);
}
internal DelegateDeclarationSyntax GenerateFunctionPointer(NativeFunctionPointer nativeFuncPointer)
{
throw new NotSupportedException();
}
