public static IEnumerable <MemberDeclarationSyntax> Transpile(this Syntax.FileSyntax fileNode, bool apiOnly = false)
{
_ = fileNode ?? throw new ArgumentNullException(nameof(fileNode));
foreach (var declaration in fileNode.DeclarationList.Transpile())
{
yield return(declaration);
}
foreach (var function in fileNode.FunctionList)
{
if (apiOnly)
{
// Transform function into native function to remove function body.
yield return(function.AsNativeFunction().Transpile());
}
else
{
yield return(function.Transpile());
}
}
foreach (var enumDeclaration in TranspileToEnumHandler.GetEnums())
{
yield return(enumDeclaration);
}
TranspileToEnumHandler.Reset();
}
public static IEnumerable <MemberDeclarationSyntax> Transpile(this Syntax.TypeDefinitionSyntax typeDefinitionNode)
{
_ = typeDefinitionNode ?? throw new ArgumentNullException(nameof(typeDefinitionNode));
var identifier = SyntaxFactory.Identifier(
SyntaxTriviaList.Empty,
SyntaxKind.IdentifierToken,
typeDefinitionNode.NewTypeNameNode.TranspileIdentifier(),
typeDefinitionNode.NewTypeNameNode.ValueText,
SyntaxTriviaList.Empty); // todo: comment?
if (TranspileToEnumHandler.IsTypeEnum(typeDefinitionNode.NewTypeNameNode.ValueText, out _))
{
var enumDeclr = SyntaxFactory.EnumDeclaration(
new SyntaxList <AttributeListSyntax>(SyntaxFactory.AttributeList()),
new SyntaxTokenList(SyntaxFactory.Token(SyntaxKind.PublicKeyword)),
identifier,
null,
default);
TranspileToEnumHandler.AddEnum(enumDeclr);
yield break;
}
var declr = SyntaxFactory.ClassDeclaration(
default(SyntaxList <AttributeListSyntax>),
new SyntaxTokenList(SyntaxFactory.Token(SyntaxKind.PublicKeyword)),
identifier,
null,
null,
default(SyntaxList <TypeParameterConstraintClauseSyntax>),
default(SyntaxList <MemberDeclarationSyntax>))
.AddMembers(SyntaxFactory.ConstructorDeclaration(
public static MemberDeclarationSyntax Transpile(this Syntax.GlobalConstantDeclarationSyntax globalConstantDeclarationNode)
{
_ = globalConstantDeclarationNode ?? throw new ArgumentNullException(nameof(globalConstantDeclarationNode));
var identifier = SyntaxFactory.Identifier(
SyntaxTriviaList.Empty,
SyntaxKind.IdentifierToken,
globalConstantDeclarationNode.IdentifierNameNode.TranspileIdentifier(),
globalConstantDeclarationNode.IdentifierNameNode.ValueText,
SyntaxTriviaList.Empty);
var globalConstantDeclaration = SyntaxFactory.FieldDeclaration(
SyntaxFactory.VariableDeclaration(globalConstantDeclarationNode.TypeNameNode.Transpile())
.AddVariables(
SyntaxFactory.VariableDeclarator(
identifier,
null,
globalConstantDeclarationNode.EqualsValueClause.Transpile(out var isConstantExpression))));
var isAddedToEnum = false;
var expr = globalConstantDeclarationNode.EqualsValueClause.ValueNode.Expression;
if (expr.FunctionCall != null)
{
var convertFunctionName = expr.FunctionCall.IdentifierNameNode.ValueText;
if (TranspileToEnumHandler.IsFunctionEnumConverter(convertFunctionName, out var enumTypeName))
{
var enumMember = SyntaxFactory.EnumMemberDeclaration(
new SyntaxList <AttributeListSyntax>(
SyntaxFactory.AttributeList(
default(SeparatedSyntaxList <AttributeSyntax>).Add(SyntaxFactory.Attribute(
SyntaxFactory.ParseName(nameof(EnumMemberConstantDeclarationAttribute)),
SyntaxFactory.ParseAttributeArgumentList($"(nameof({identifier.Text}))"))))),
identifier,
SyntaxFactory.EqualsValueClause(expr.FunctionCall.ArgumentListNode.FirstArgument.Transpile()));
TranspileToEnumHandler.AddEnumMember(enumMember, convertFunctionName);
isAddedToEnum = true;
}
}
return(isConstantExpression
? globalConstantDeclaration.WithModifiers(
new SyntaxTokenList(
SyntaxFactory.Token(SyntaxKind.PublicKeyword),
SyntaxFactory.Token(SyntaxKind.ConstKeyword)))
: globalConstantDeclaration.WithModifiers(
new SyntaxTokenList(
SyntaxFactory.Token(isAddedToEnum
? TranspileToEnumHandler.EnumMemberDeclarationAccessModifier
: SyntaxKind.PublicKeyword),
SyntaxFactory.Token(SyntaxKind.StaticKeyword),
SyntaxFactory.Token(SyntaxKind.ReadOnlyKeyword))));
}
public static MemberDeclarationSyntax Transpile(this Syntax.NativeFunctionDeclarationSyntax nativeFunctionDeclarationNode)
{
_ = nativeFunctionDeclarationNode ?? throw new ArgumentNullException(nameof(nativeFunctionDeclarationNode));
return(nativeFunctionDeclarationNode.FunctionDeclarationNode.Transpile()
.WithModifiers(
new SyntaxTokenList(
SyntaxFactory.Token(TranspileToEnumHandler.IsFunctionEnumConverter(nativeFunctionDeclarationNode.FunctionDeclarationNode.IdentifierNode.ValueText, out _)
? TranspileToEnumHandler.EnumCastFunctionAccessModifier
: SyntaxKind.PublicKeyword),
SyntaxFactory.Token(SyntaxKind.StaticKeyword),
SyntaxFactory.Token(SyntaxKind.ExternKeyword)))
.WithSemicolonToken(SyntaxFactory.Token(SyntaxKind.SemicolonToken)));
}
public static IEnumerable <MemberDeclarationSyntax> Transpile(this Syntax.FileSyntax fileNode)
{
_ = fileNode ?? throw new ArgumentNullException(nameof(fileNode));
foreach (var declaration in fileNode.DeclarationList.Transpile())
{
yield return(declaration);
}
foreach (var function in fileNode.FunctionList)
{
yield return(function.Transpile());
}
foreach (var enumDeclaration in TranspileToEnumHandler.GetEnums())
{
yield return(enumDeclaration);
}
TranspileToEnumHandler.Reset();
}
