public IEnumerable <StatementSyntax> GenerateManagedToNativeProlog(CsMarshalCallableBase csElement)
{
yield return(LocalDeclarationStatement(
VariableDeclaration(ParseTypeName(csElement.MarshalType.QualifiedName),
SingletonSeparatedList(
VariableDeclarator(GetMarshalStorageLocationIdentifier(csElement))))));
}
public override ArgumentSyntax GenerateNativeArgument(CsMarshalCallableBase csElement) => Argument(
csElement.PassedByNativeReference
? csElement.IsFixed && !csElement.UsedAsReturn
? GetMarshalStorageLocation(csElement)
: PrefixUnaryExpression(SyntaxKind.AddressOfExpression, IdentifierName(csElement.Name))
: IdentifierName(csElement.Name)
);
public ArgumentSyntax GenerateNativeArgument(CsMarshalCallableBase csElement)
{
var csEnum = (CsEnum)csElement.PublicType;
if (csElement.PassedByNativeReference)
{
if (csElement.IsFixed && !csElement.UsedAsReturn)
{
return(Argument(GetMarshalStorageLocation(csElement)));
}
else
{
return(Argument(PrefixUnaryExpression(SyntaxKind.AddressOfExpression,
IdentifierName(csElement.Name))));
}
}
else
{
return(Argument(
CheckedExpression(
SyntaxKind.UncheckedExpression,
CastExpression(
ParseTypeName(csEnum.UnderlyingType?.Type.FullName ?? "int"),
IdentifierName(csElement.Name)))));
}
}
private IEnumerable <StatementSyntax> GenerateNativeByRefProlog(CsMarshalCallableBase publicElement, ExpressionSyntax nativeParameter)
{
var marshaller = generators.Marshalling.GetMarshaller(publicElement);
var localByRef = publicElement.IsRef || publicElement.IsOut;
ExpressionSyntax refToNativeExpression = InvocationExpression(
MemberAccessExpression(
SyntaxKind.SimpleMemberAccessExpression,
globalNamespace.GetTypeNameSyntax(BuiltinType.Unsafe),
GenericName(Identifier("AsRef"))
.WithTypeArgumentList(
TypeArgumentList(
SingletonSeparatedList(
marshaller.GetMarshalTypeSyntax(publicElement))))))
.WithArgumentList(
ArgumentList(
SingletonSeparatedList(
Argument(
nativeParameter))));
var publicType = ParseTypeName(publicElement.PublicType.QualifiedName);
if (localByRef)
{
if (!marshaller.GeneratesMarshalVariable(publicElement))
{
publicType = RefType(publicType);
}
refToNativeExpression = RefExpression(refToNativeExpression);
}
if (marshaller.GeneratesMarshalVariable(publicElement))
{
yield return(LocalDeclarationStatement(
VariableDeclaration(
RefType(marshaller.GetMarshalTypeSyntax(publicElement)))
.WithVariables(
SingletonSeparatedList(
VariableDeclarator(
generators.Marshalling.GetMarshalStorageLocationIdentifier(publicElement))
.WithInitializer(
EqualsValueClause(
refToNativeExpression))))));
yield return(LocalDeclarationStatement(
VariableDeclaration(publicType)
.WithVariables(
SingletonSeparatedList(
VariableDeclarator(
Identifier(publicElement.Name))))));
}
else
{
yield return(LocalDeclarationStatement(
VariableDeclaration(publicType)
.AddVariables(
VariableDeclarator(Identifier(publicElement.Name))
.WithInitializer(EqualsValueClause(refToNativeExpression)))));
}
}
private IEnumerable <StatementSyntax> GenerateNativeByRefProlog(CsMarshalCallableBase publicElement,
ExpressionSyntax nativeParameter,
TypeSyntax nativeParameterType)
{
var marshaller = GetMarshaller(publicElement);
var marshalTypeSyntax = marshaller.GetMarshalTypeSyntax(publicElement);
var publicType = ParseTypeName(publicElement.PublicType.QualifiedName);
var generatesMarshalVariable = marshaller.GeneratesMarshalVariable(publicElement);
ExpressionSyntax publicDefaultValue = publicElement.UsedAsReturn ? default : DefaultLiteral;
var refToNativeClause = GenerateAsRefInitializer(publicElement, nativeParameter, marshalTypeSyntax);
TypeSyntax publicVariableType, marshalVariableType;
ExpressionSyntax publicVariableInitializer, marshalVariableInitializer;
if (publicElement is CsParameter {
IsOptional: true, IsLocalManagedReference : true
} parameter)
{
Debug.Assert(marshaller is RefWrapperMarshaller);
var refVariableDeclaration = LocalDeclarationStatement(
VariableDeclaration(
RefType(marshalTypeSyntax),
SingletonSeparatedList(
VariableDeclarator(
MarshallerBase.GetRefLocationIdentifier(publicElement),
public ArgumentSyntax GenerateNativeArgument(CsMarshalCallableBase csElement) => Argument(
MemberAccessExpression(
SyntaxKind.SimpleMemberAccessExpression,
IdentifierName(csElement.Name),
IdentifierName("NativePointer")
)
);
public IEnumerable <StatementSyntax> GenerateManagedToNativeProlog(CsMarshalCallableBase csElement)
{
var defaultSyntax = LiteralExpression(SyntaxKind.DefaultLiteralExpression, Token(SyntaxKind.DefaultKeyword));
yield return(LocalDeclarationStatement(
VariableDeclaration(
GetMarshalTypeSyntax(csElement),
SingletonSeparatedList(
VariableDeclarator(GetMarshalStorageLocationIdentifier(csElement))
.WithInitializer(
EqualsValueClause(defaultSyntax))
)
)
));
if (csElement.IsOut)
{
yield return(ExpressionStatement(
AssignmentExpression(
SyntaxKind.SimpleAssignmentExpression,
IdentifierName(csElement.Name),
defaultSyntax
)
));
}
}
private StatementSyntax GenerateManagedReturnProlog(CsMarshalCallableBase csElement)
{
return(LocalDeclarationStatement(
VariableDeclaration(
csElement.IsArray ? ArrayType(ParseTypeName(csElement.PublicType.QualifiedName), SingletonList(ArrayRankSpecifier())) : ParseTypeName(csElement.PublicType.QualifiedName),
SingletonSeparatedList(
VariableDeclarator(csElement.Name)))));
}
public ArgumentSyntax GenerateNativeArgument(CsMarshalCallableBase csElement)
{
if (csElement.PassedByNativeReference)
{
return(Argument(PrefixUnaryExpression(SyntaxKind.AddressOfExpression, GetMarshalStorageLocation(csElement))));
}
return(Argument(GetMarshalStorageLocation(csElement)));
}
internal static TypeSyntax GetPublicType(CsMarshalCallableBase publicElement)
{
var publicType = ParseTypeName(publicElement.PublicType.QualifiedName);
return(publicElement.IsArray
? ArrayType(publicType, SingletonList(ArrayRankSpecifier()))
: publicType);
}
public IEnumerable <StatementSyntax> GenerateManagedToNativeProlog(CsMarshalCallableBase csElement)
{
yield return(LocalDeclarationStatement(
VariableDeclaration(
IntPtrType,
SingletonSeparatedList(
VariableDeclarator(
GetMarshalStorageLocationIdentifier(csElement),
public ArgumentSyntax GenerateNativeArgument(CsMarshalCallableBase csElement)
{
return(Argument(GenerateNullCheckIfNeeded(csElement,
PrefixUnaryExpression(SyntaxKind.AddressOfExpression,
GetMarshalStorageLocation(csElement)),
CastExpression(
PointerType(PredefinedType(Token(SyntaxKind.VoidKeyword))),
LiteralExpression(SyntaxKind.NumericLiteralExpression, Literal(0))))));
}
public ArgumentSyntax GenerateNativeArgument(CsMarshalCallableBase csElement) => Argument(
GenerateNullCheckIfNeeded(
csElement,
PrefixUnaryExpression(SyntaxKind.AddressOfExpression, GetMarshalStorageLocation(csElement)),
CastExpression(
VoidPtrType,
LiteralExpression(SyntaxKind.NumericLiteralExpression, Literal(0))
)
)
);
public IEnumerable <StatementSyntax> GenerateManagedToNativeProlog(CsMarshalCallableBase csElement)
{
yield return(LocalDeclarationStatement(
VariableDeclaration(
PointerType(
QualifiedName(
IdentifierName("System"),
IdentifierName("IntPtr"))),
SingletonSeparatedList(
VariableDeclarator(GetMarshalStorageLocationIdentifier(csElement))))));
yield return(ExpressionStatement(
AssignmentExpression(
SyntaxKind.SimpleAssignmentExpression,
IdentifierName(GetMarshalStorageLocationIdentifier(csElement)),
CastExpression(
PointerType(
QualifiedName(
IdentifierName("System"),
IdentifierName("IntPtr"))),
LiteralExpression(
SyntaxKind.NumericLiteralExpression,
Literal(0))))));
yield return(GenerateNullCheckIfNeeded(csElement,
Block(
LocalDeclarationStatement(
VariableDeclaration(
PointerType(
QualifiedName(
IdentifierName("System"),
IdentifierName("IntPtr"))),
SingletonSeparatedList(
VariableDeclarator(
Identifier(csElement.IntermediateMarshalName))
.WithInitializer(
EqualsValueClause(
StackAllocArrayCreationExpression(
ArrayType(
QualifiedName(
IdentifierName("System"),
IdentifierName("IntPtr")),
SingletonList(
ArrayRankSpecifier(
SingletonSeparatedList <ExpressionSyntax>(
MemberAccessExpression(
SyntaxKind.SimpleMemberAccessExpression,
IdentifierName(csElement.Name),
IdentifierName("Length")))))))))))),
ExpressionStatement(
AssignmentExpression(
SyntaxKind.SimpleAssignmentExpression,
IdentifierName(GetMarshalStorageLocationIdentifier(csElement)),
IdentifierName(csElement.IntermediateMarshalName))))));
}
public ArgumentSyntax GenerateNativeArgument(CsMarshalCallableBase csElement)
{
if (csElement.IsOut)
{
return(Argument(PrefixUnaryExpression(SyntaxKind.AddressOfExpression, GetMarshalStorageLocation(csElement))));
}
return(Argument(CastExpression(
PointerType(PredefinedType(Token(SyntaxKind.VoidKeyword))),
GetMarshalStorageLocation(csElement))));
}
public override IEnumerable <StatementSyntax> GenerateManagedToNativeProlog(CsMarshalCallableBase csElement)
{
if (csElement.IsOut && !csElement.IsPrimitive && !csElement.UsedAsReturn)
{
yield return(ExpressionStatement(
AssignmentExpression(
SyntaxKind.SimpleAssignmentExpression, IdentifierName(csElement.Name), DefaultLiteral
)
));
}
}
public ArgumentSyntax GenerateNativeArgument(CsMarshalCallableBase csElement) => Argument(
GeneratorHelpers.CastExpression(
VoidPtrType,
BinaryExpression(
SyntaxKind.CoalesceExpression,
ConditionalAccessExpression(
IdentifierName(csElement.Name),
MemberBindingExpression(IdentifierName("NativePointer"))
),
IntPtrZero
)
)
);
public ArgumentSyntax GenerateNativeArgument(CsMarshalCallableBase csElement) => Argument(
csElement.PassedByNativeReference
? csElement.IsFixed && !csElement.UsedAsReturn
? GetMarshalStorageLocation(csElement)
: PrefixUnaryExpression(SyntaxKind.AddressOfExpression, IdentifierName(csElement.Name))
: CheckedExpression(
SyntaxKind.UncheckedExpression,
CastExpression(
ParseTypeName(((CsEnum)csElement.PublicType).UnderlyingType.Name),
IdentifierName(csElement.Name)
)
)
);
private IEnumerable <StatementSyntax> GenerateProlog(CsMarshalCallableBase publicElement,
ExpressionSyntax nativeParameter,
TypeSyntax nativeParameterType)
{
ExpressionSyntax CastToPublicType(TypeSyntax targetType, ExpressionSyntax expression) =>
targetType.IsEquivalentTo(nativeParameterType)
? expression
: GeneratorHelpers.CastExpression(targetType, expression);
var marshaller = GetMarshaller(publicElement);
var publicType = GetPublicType(publicElement);
var generatesMarshalVariable = marshaller.GeneratesMarshalVariable(publicElement);
var publicTypeVariableValue = nativeParameter != null && !generatesMarshalVariable
? CastToPublicType(publicType, nativeParameter)
: DefaultLiteral;
yield return(LocalDeclarationStatement(
VariableDeclaration(
publicType,
SingletonSeparatedList(
VariableDeclarator(Identifier(publicElement.Name))
.WithInitializer(EqualsValueClause(publicTypeVariableValue))
)
)
));
if (generatesMarshalVariable)
{
var marshalTypeSyntax = marshaller.GetMarshalTypeSyntax(publicElement);
var initializerExpression = nativeParameter != null
? CastToPublicType(marshalTypeSyntax, nativeParameter)
: DefaultLiteral;
yield return(LocalDeclarationStatement(
VariableDeclaration(
marshalTypeSyntax,
SingletonSeparatedList(
VariableDeclarator(
MarshallerBase.GetMarshalStorageLocationIdentifier(publicElement),
null,
EqualsValueClause(initializerExpression)
)
)
)
));
}
}
public IEnumerable <StatementSyntax> GenerateManagedToNativeProlog(CsMarshalCallableBase csElement)
{
yield return(LocalDeclarationStatement(
VariableDeclaration(
QualifiedName(
IdentifierName("System"),
IdentifierName("IntPtr")),
SingletonSeparatedList(
VariableDeclarator(GetMarshalStorageLocationIdentifier(csElement))
.WithInitializer(
EqualsValueClause(
MemberAccessExpression(SyntaxKind.SimpleMemberAccessExpression,
MemberAccessExpression(SyntaxKind.SimpleMemberAccessExpression,
IdentifierName("System"),
IdentifierName("IntPtr")),
IdentifierName("Zero"))))))));
}
public IEnumerable <StatementSyntax> GenerateManagedToNativeProlog(CsMarshalCallableBase csElement)
{
yield return(LocalDeclarationStatement(
VariableDeclaration(
ArrayType(ParseTypeName($"{csElement.PublicType.QualifiedName}.__Native"), SingletonList(ArrayRankSpecifier())),
SingletonSeparatedList(
VariableDeclarator(GetMarshalStorageLocationIdentifier(csElement))
.WithInitializer(EqualsValueClause(
GenerateNullCheckIfNeeded(csElement,
ObjectCreationExpression(
ArrayType(ParseTypeName($"{csElement.PublicType.QualifiedName}.__Native"),
SingletonList(ArrayRankSpecifier(
SingletonSeparatedList <ExpressionSyntax>(
MemberAccessExpression(SyntaxKind.SimpleMemberAccessExpression,
IdentifierName(csElement.Name),
IdentifierName("Length"))))))),
LiteralExpression(SyntaxKind.NullLiteralExpression))))))));
}
protected StatementSyntax GenerateArrayNativeToManagedExtendedProlog(CsMarshalCallableBase csElement)
{
var callable = (CsCallable)csElement.Parent;
var lengthParam = callable.Parameters
.FirstOrDefault(param
=> param.Relation is LengthRelation relation &&
relation.RelatedMarshallableName == csElement.CppElementName);
if (lengthParam != null)
{
var marshaller = new LengthRelationMarshaller(globalNamespace);
return(marshaller.GenerateNativeToManaged(csElement, lengthParam));
}
else
{
return(NotSupported("Cannot marshal a native array to a managed array when length is not specified"));
}
}
public ArgumentSyntax GenerateNativeArgument(CsMarshalCallableBase csElement)
{
if (csElement.PassedByNativeReference)
{
if (csElement.IsFixed && !csElement.UsedAsReturn)
{
return(Argument(GetMarshalStorageLocation(csElement)));
}
else
{
return(Argument(PrefixUnaryExpression(SyntaxKind.AddressOfExpression,
IdentifierName(csElement.Name))));
}
}
else
{
return(Argument(IdentifierName(csElement.Name)));
}
}
public IEnumerable <StatementSyntax> GenerateManagedToNativeProlog(CsMarshalCallableBase csElement)
{
yield return(LocalDeclarationStatement(
VariableDeclaration(ParseTypeName($"{csElement.PublicType.QualifiedName}.__Native"),
SingletonSeparatedList(
VariableDeclarator(GetMarshalStorageLocationIdentifier(csElement))
.WithInitializer(
EqualsValueClause(
DefaultExpression(ParseTypeName($"{csElement.PublicType.QualifiedName}.__Native"))))))));
if (csElement.IsOut)
{
yield return(ExpressionStatement(
AssignmentExpression(SyntaxKind.SimpleAssignmentExpression,
IdentifierName(csElement.Name),
DefaultExpression(ParseTypeName(csElement.PublicType.QualifiedName))
)));
}
}
private IEnumerable <StatementSyntax> GenerateProlog(
CsMarshalCallableBase publicElement,
ExpressionSyntax nativeParameter)
{
var marshaller = generators.Marshalling.GetMarshaller(publicElement);
yield return(LocalDeclarationStatement(
VariableDeclaration(ParseTypeName(publicElement.PublicType.QualifiedName))
.AddVariables(
VariableDeclarator(Identifier(publicElement.Name))
.WithInitializer(
EqualsValueClause(
DefaultExpression(ParseTypeName(publicElement.PublicType.QualifiedName)))))));
if (marshaller.GeneratesMarshalVariable(publicElement))
{
yield return(LocalDeclarationStatement(
VariableDeclaration(marshaller.GetMarshalTypeSyntax(publicElement))
.AddVariables(
VariableDeclarator(generators.Marshalling.GetMarshalStorageLocationIdentifier(publicElement))
.WithInitializer(
nativeParameter != null
? EqualsValueClause(
CastExpression(
marshaller.GetMarshalTypeSyntax(publicElement),
nativeParameter))
: null))));
}
else
{
if (nativeParameter != null)
{
yield return(ExpressionStatement(
AssignmentExpression(SyntaxKind.SimpleAssignmentExpression,
IdentifierName(publicElement.Name),
CastExpression(
ParseTypeName(publicElement.PublicType.QualifiedName),
nativeParameter)
)));
}
}
}
public IEnumerable <StatementSyntax> GenerateManagedToNativeProlog(CsMarshalCallableBase csElement)
{
var identifier = GetMarshalStorageLocationIdentifier(csElement);
var elementType = GetMarshalElementTypeSyntax(csElement);
var spanTypeName = GlobalNamespace.GetGenericTypeNameSyntax(
BuiltinType.Span,
TypeArgumentList(SingletonSeparatedList(elementType))
);
ArrayTypeSyntax GetArrayType(ExpressionSyntax length) => ArrayType(
elementType,
SingletonList(ArrayRankSpecifier(SingletonSeparatedList(length)))
);
yield return(LocalDeclarationStatement(
VariableDeclaration(
spanTypeName,
SingletonSeparatedList(
VariableDeclarator(
identifier, default,
public ArgumentSyntax GenerateNativeArgument(CsMarshalCallableBase csElement)
{
return(Argument(CastExpression(
PointerType(
PredefinedType(
Token(SyntaxKind.VoidKeyword))),
ParenthesizedExpression(
BinaryExpression(
SyntaxKind.CoalesceExpression,
ConditionalAccessExpression(
IdentifierName(csElement.Name),
MemberBindingExpression(
IdentifierName("NativePointer"))),
MemberAccessExpression(SyntaxKind.SimpleMemberAccessExpression,
MemberAccessExpression(
SyntaxKind.SimpleMemberAccessExpression,
IdentifierName("System"),
IdentifierName("IntPtr")),
IdentifierName("Zero")))))));
}
protected StatementSyntax GenerateArrayNativeToManagedExtendedProlog(CsMarshalCallableBase csElement)
{
// e.g. Function(int[] buffer, int length)
// callable is Function
// csElement is buffer
// lengthParam is length
var callable = (CsCallable)csElement.Parent;
bool MatchPredicate(CsParameter param)
{
var relations = param.Relations;
if (relations is null)
{
return(false);
}
return(relations.OfType <LengthRelation>()
.Any(relation => relation.Identifier == csElement.CppElementName));
}
var lengthParam = callable.Parameters
.Where(MatchPredicate)
.ToArray();
if (lengthParam.Length == 0)
{
return(NotSupported("Cannot marshal a native array to a managed array when length is not specified"));
}
if (lengthParam.Length > 1)
{
return(NotSupported("Cannot marshal a native array to a managed array when length is specified multiple times"));
}
var marshaller = new LengthRelationMarshaller(globalNamespace);
return(marshaller.GenerateNativeToManaged(csElement, lengthParam[0]));
}
public IEnumerable <StatementSyntax> GenerateNativeToManagedExtendedProlog(CsMarshalCallableBase csElement)
{
yield return(NotImplemented("Array of structs with native type"));
}
public ArgumentSyntax GenerateNativeArgument(CsMarshalCallableBase csElement)
{
return(Argument(IdentifierName(csElement.IntermediateMarshalName)));
}
