public ParameterSyntax GenerateManagedParameter(CsParameter csElement)
{
var param = Parameter(Identifier(csElement.Name));
TypeSyntax type;
if (csElement.IsOut && csElement.IsFast)
{
type = ParseTypeName(csElement.PublicType.GetNativeImplementationQualifiedName());
}
else
{
type = ParseTypeName(csElement.PublicType.QualifiedName);
if (csElement.IsOut)
{
param = param.AddModifiers(Token(SyntaxKind.OutKeyword));
}
else if (csElement.IsRef || csElement.IsRefIn)
{
param = param.AddModifiers(Token(SyntaxKind.RefKeyword));
}
}
return(param.WithType(type));
}
public ParameterSyntax GenerateManagedParameter(CsParameter csElement)
{
var param = Parameter(Identifier(csElement.Name));
if (csElement.IsFastOut)
{
var iface = (CsInterface)csElement.PublicType;
param = param.WithType(ParseTypeName(iface.GetNativeImplementationOrThis().QualifiedName));
}
else
{
param = param.WithType(ParseTypeName(csElement.PublicType.QualifiedName));
if (csElement.IsOut)
{
param = param.AddModifiers(Token(SyntaxKind.OutKeyword));
}
else if (csElement.IsRef || csElement.IsRefIn)
{
param = param.AddModifiers(Token(SyntaxKind.RefKeyword));
}
}
return(param);
}
public FixedStatementSyntax GeneratePin(CsParameter csElement)
{
if (csElement.IsFixed && !csElement.IsUsedAsReturnType)
{
return(FixedStatement(
VariableDeclaration(
VoidPtrType,
SingletonSeparatedList(
VariableDeclarator(
GetMarshalStorageLocationIdentifier(csElement),
null,
EqualsValueClause(
PrefixUnaryExpression(
SyntaxKind.AddressOfExpression, IdentifierName(csElement.Name)
)
)
)
)
),
EmptyStatement()
));
}
return(null);
}
public override IEnumerable <MemberDeclarationSyntax> GenerateCode(CsCallable csElement)
{
// method signature
var parameters = csElement.PublicParameters.Select(
param => GetMarshaller(param)
.GenerateManagedParameter(param)
.WithDefault(
param.DefaultValue == null
? default
: EqualsValueClause(ParseExpression(param.DefaultValue))
)
);
var methodDeclaration = AddDocumentationTrivia(
MethodDeclaration(
ParseTypeName(csElement.PublicReturnTypeQualifiedName),
csElement.Name
)
.WithModifiers(csElement.VisibilityTokenList.Add(Token(SyntaxKind.UnsafeKeyword)))
.WithParameterList(ParameterList(SeparatedList(parameters))),
csElement
);
if (csElement.SignatureOnly)
{
yield return(methodDeclaration
.WithSemicolonToken(Token(SyntaxKind.SemicolonToken))
.WithModifiers(TokenList()));
yield break;
}
StatementSyntaxList statements = new(Generators.Marshalling);
foreach (var param in csElement.Parameters)
{
var relations = param.Relations;
if (relations.Count != 0 || param.UsedAsReturn)
{
statements.Add(GenerateManagedHiddenMarshallableProlog(param));
}
foreach (var relation in relations)
{
if (!ValidRelationInScenario(relation))
{
Logger.Error(
LoggingCodes.InvalidRelationInScenario,
$"The relation \"{relation}\" is invalid in a method/function."
);
continue;
}
CsParameter relatedParameter = null;
if (relation is LengthRelation {
Identifier: { Length: > 0 } relatedMarshallableName
})
public FixedStatementSyntax GeneratePin(CsParameter csElement)
{
return(FixedStatement(VariableDeclaration(PointerType(PredefinedType(Token(SyntaxKind.VoidKeyword))),
SingletonSeparatedList(
VariableDeclarator(Identifier(csElement.IntermediateMarshalName)).WithInitializer(EqualsValueClause(
GetMarshalStorageLocation(csElement)
)))), EmptyStatement()));
}
private (InteropType type, bool isLocal) GetInteropTypeForParameter(CsParameter param)
{
InteropType interopType;
var isLocal = false;
var publicName = param.PublicType.QualifiedName;
if (publicName == globalNamespace.GetTypeName(WellKnownName.PointerSize))
{
interopType = typeof(void *);
}
else if (param.HasPointer)
{
interopType = typeof(void *);
}
else if (param.MarshalType is CsFundamentalType marshalFundamental)
{
var type = marshalFundamental.Type;
if (type == typeof(IntPtr))
{
type = typeof(void *);
}
interopType = type;
}
else if (param.PublicType is CsFundamentalType publicFundamental)
{
var type = publicFundamental.Type;
if (type == typeof(IntPtr))
{
type = typeof(void *);
}
interopType = type;
}
else if (param.PublicType is CsStruct csStruct)
{
// If parameter is a struct, then a LocalInterop is needed
if (csStruct.HasMarshalType)
{
interopType = $"{csStruct.QualifiedName}.__Native";
}
else
{
interopType = csStruct.QualifiedName;
}
isLocal = true;
}
else if (param.PublicType is CsEnum csEnum)
{
interopType = csEnum.UnderlyingType.Type;
}
else
{
interopType = null;
}
return(interopType, isLocal);
}
public ArgumentSyntax GenerateManagedArgument(CsParameter csElement)
{
var arg = Argument(IdentifierName(csElement.Name));
if (csElement.IsOut)
{
arg = arg.WithRefOrOutKeyword(Token(SyntaxKind.RefKeyword));
}
return(arg);
}
public FixedStatementSyntax GeneratePin(CsParameter csElement) => FixedStatement(
VariableDeclaration(
GetMarshalTypeSyntax(csElement),
SingletonSeparatedList(
VariableDeclarator(GetMarshalStorageLocationIdentifier(csElement)).WithInitializer(
EqualsValueClause(IdentifierName(csElement.Name))
)
)
),
EmptyStatement()
);
public ParameterSyntax GenerateManagedParameter(CsParameter csElement)
{
var param = Parameter(Identifier(csElement.Name))
.WithType(StringType);
if (csElement.IsOut)
{
param = param.AddModifiers(Token(SyntaxKind.OutKeyword));
}
return(param);
}
protected ParameterSyntax GenerateManagedArrayParameter(CsParameter csElement)
{
var param = Parameter(Identifier(csElement.Name))
.WithType(ArrayType(ParseTypeName(csElement.PublicType.QualifiedName), SingletonList(ArrayRankSpecifier())));
if (csElement.HasParams)
{
param = param.AddModifiers(Token(SyntaxKind.ParamsKeyword));
}
return(param);
}
public FixedStatementSyntax GeneratePin(CsParameter csElement)
{
if (csElement.IsFixed && !csElement.IsUsedAsReturnType)
{
return(FixedStatement(VariableDeclaration(PointerType(PredefinedType(Token(SyntaxKind.VoidKeyword))),
SingletonSeparatedList(
VariableDeclarator(GetMarshalStorageLocationIdentifier(csElement)).WithInitializer(EqualsValueClause(
PrefixUnaryExpression(SyntaxKind.AddressOfExpression,
IdentifierName(csElement.Name))
)))), EmptyStatement()));
}
return(null);
}
public FixedStatementSyntax GeneratePin(CsParameter csElement) => FixedStatement(
VariableDeclaration(
VoidPtrType,
SingletonSeparatedList(
VariableDeclarator(
Identifier(csElement.IntermediateMarshalName),
null,
EqualsValueClause(GetMarshalStorageLocation(csElement))
)
)
),
EmptyStatement()
);
protected ArgumentSyntax GenerateManagedValueTypeArgument(CsParameter csElement)
{
var arg = Argument(IdentifierName(csElement.Name));
if (csElement.IsOut)
{
return(arg.WithRefOrOutKeyword(Token(SyntaxKind.OutKeyword)));
}
else if (csElement.PassedByManagedReference)
{
return(arg.WithRefOrOutKeyword(Token(SyntaxKind.RefKeyword)));
}
return(arg);
}
private InteropType GetInteropTypeForParameter(CsParameter param)
{
if (param.HasPointer)
{
return(TypeRegistry.VoidPtr);
}
if (param.PublicType.IsWellKnownType(Provider, WellKnownName.PointerSize))
{
return(TypeRegistry.VoidPtr);
}
if (param.MarshalType is CsFundamentalType marshalFundamental)
{
return marshalFundamental switch
{
{ IsIntPtr : true } => TypeRegistry.VoidPtr,
public FixedStatementSyntax GeneratePin(CsParameter csElement)
{
if (csElement.IsWideChar)
{
return(FixedStatement(
VariableDeclaration(
PointerType(PredefinedType(Token(SyntaxKind.CharKeyword))),
SingletonSeparatedList(
VariableDeclarator(
GetMarshalStorageLocationIdentifier(csElement),
null,
EqualsValueClause(IdentifierName(csElement.Name))
)
)
),
EmptyStatement()
));
}
return(null);
}
protected ParameterSyntax GenerateManagedValueTypeParameter(CsParameter csElement)
{
var param = Parameter(Identifier(csElement.Name));
if (csElement.IsOut)
{
param = param.AddModifiers(Token(SyntaxKind.OutKeyword));
}
else if (csElement.PassedByManagedReference)
{
param = param.AddModifiers(Token(SyntaxKind.RefKeyword));
}
var type = ParseTypeName(csElement.PublicType.QualifiedName);
if (csElement.IsNullableStruct)
{
type = NullableType(type);
}
return(param.WithType(type));
}
public ParameterSyntax GenerateManagedParameter(CsParameter csElement) => GenerateManagedArrayParameter(csElement);
public ArgumentSyntax GenerateManagedArgument(CsParameter csElement) => Argument(IdentifierName(csElement.Name));
public FixedStatementSyntax GeneratePin(CsParameter csElement)
{
throw new InvalidOperationException();
}
public ParameterSyntax GenerateManagedParameter(CsParameter csElement)
{
return(GenerateManagedArrayParameter(csElement));
}
public FixedStatementSyntax GeneratePin(CsParameter csElement)
{
return(null);
}
public ParameterSyntax GenerateManagedParameter(CsParameter csElement)
{
return(GenerateManagedValueTypeParameter(csElement));
}
public ArgumentSyntax GenerateManagedArgument(CsParameter csElement)
{
return(GenerateManagedValueTypeArgument(csElement));
}
public FixedStatementSyntax GeneratePin(CsParameter csElement) => null;
public ParameterSyntax GenerateManagedParameter(CsParameter csElement) => GenerateManagedValueTypeParameter(csElement);
public ArgumentSyntax GenerateManagedArgument(CsParameter csElement) => GenerateManagedValueTypeArgument(csElement);
public ParameterSyntax GenerateManagedParameter(CsParameter csElement) => Parameter(Identifier(csElement.Name)) .WithType(ParseTypeName(csElement.PublicType.QualifiedName));
public ParameterSyntax GenerateManagedParameter(CsParameter csElement) => throw new NotSupportedException();
public ArgumentSyntax GenerateManagedArgument(CsParameter csElement) => throw new NotSupportedException();
public FixedStatementSyntax GeneratePin(CsParameter csElement) => throw new NotSupportedException();