private void EmitEnum(TransportModelEnum enumModel, ICodeStream output)
{
var outputFile = (CodeFileCSharp)output.CreateCodeFile($"{CsEmitterHelper.GetCSharpModelShortName(enumModel, ModelType.Transport)}.cs");
var unit = CompilationUnit();
unit = unit.AddUsings(
UsingDirective(ParseName(nameof(System))));
var enumDeclaration = EnumDeclaration(CsEmitterHelper.GetCSharpModelShortName(enumModel, ModelType.Transport));
enumDeclaration = enumDeclaration.AddModifiers(Token(SyntaxKind.PublicKeyword));
enumDeclaration = enumDeclaration.WithMembers(SeparatedList <EnumMemberDeclarationSyntax>(enumModel.Members.Values.Select(EmitEnumMember)));
if (enumModel.IsFlags)
{
enumDeclaration = enumDeclaration.WithAttributeLists(
List <AttributeListSyntax>(
new[] { AttributeList(
SingletonSeparatedList <AttributeSyntax>(
Attribute(
IdentifierName(typeof(System.FlagsAttribute).FullName)))) }));
}
var nsContainer = NamespaceDeclaration(ParseName(this.settings.CsTransportModelNamespace));
nsContainer = nsContainer.AddMembers(enumDeclaration);
unit = unit.AddMembers(nsContainer);
outputFile.SyntaxTree = unit.SyntaxTree;
}
protected override List<ICodeStream> CreateOutputs(ICodeStreamFactory codeStreamFactory)
{
List<ICodeStream> result = new List<ICodeStream>();
this.outputStream = codeStreamFactory.CreateCodeStream(Languages.CSharp, OutStreamName);
result.Add(this.outputStream);
return result;
}
private void EmitInterface(TransportModelInterface model, ICodeStream output)
{
var outputFile = (CodeFileCSharp)output.CreateCodeFile($"{CsEmitterHelper.GetCSharpModelShortName(model, ModelType.Transport)}.cs");
var unit = CompilationUnit();
unit = unit.AddUsings(
UsingDirective(ParseName(nameof(System))));
var entityInterface = InterfaceDeclaration(CsEmitterHelper.GetCSharpModelShortName(model, ModelType.Transport));
entityInterface = entityInterface.AddModifiers(Token(SyntaxKind.PublicKeyword));
if (model.GenericParameters.Count > 0)
{
entityInterface = entityInterface.WithTypeParameterList(TypeParameterList(SeparatedList <TypeParameterSyntax>(model.GenericParameters.Select(p => TypeParameter(p.Key)))));
entityInterface = entityInterface.WithConstraintClauses(List <TypeParameterConstraintClauseSyntax>(
model.GenericParameters.Select(p =>
TypeParameterConstraintClause(
IdentifierName(p.Key),
SeparatedList <TypeParameterConstraintSyntax>(new[] { TypeConstraint(ParseTypeName(CsEmitterHelper.GetModelGenericParameterConstraintTypeName(p.Value, ModelType.Transport))) })))));
}
List <string> baseTypes = new List <string>();
foreach (var interfaceModel in model.Interfaces)
{
baseTypes.Add(CsEmitterHelper.GetCSharpModelFullyQualifiedName(interfaceModel, this.settings, ModelType.Transport));
}
if (baseTypes.Count > 0)
{
entityInterface = entityInterface.WithBaseList(BaseList(SeparatedList <BaseTypeSyntax>(baseTypes.Select(t => SimpleBaseType(ParseTypeName(t))))));
}
entityInterface = entityInterface.WithMembers(List <MemberDeclarationSyntax>(model.Members.Select(m =>
PropertyDeclaration(ParseTypeName(CsEmitterHelper.GetPropertyTypeName(m.Value, this.settings, ModelType.Transport)), NameHelper.GetSafeVariableName(m.Value.Name))
.WithAccessorList(
SyntaxFactory.AccessorList(
SyntaxFactory.List <AccessorDeclarationSyntax>(new AccessorDeclarationSyntax[]
{
SyntaxFactory.AccessorDeclaration(SyntaxKind.GetAccessorDeclaration)
.WithSemicolonToken(SyntaxFactory.Token(SyntaxKind.SemicolonToken)),
SyntaxFactory.AccessorDeclaration(SyntaxKind.SetAccessorDeclaration)
.WithSemicolonToken(SyntaxFactory.Token(SyntaxKind.SemicolonToken))
})))
)));
var nsContainer = NamespaceDeclaration(ParseName(this.settings.CsTransportModelNamespace));
nsContainer = nsContainer.AddMembers(entityInterface);
unit = unit.AddMembers(nsContainer);
outputFile.SyntaxTree = unit.SyntaxTree;
}
public void Emit(Parameters parameters, ICodeStream output)
{
foreach (var entityModel in parameters.TransportModel.TransportModelEntities)
{
this.EmitEntity(entityModel.Value, output);
}
foreach (var interfaceModel in parameters.TransportModel.TransportModelInterfaces)
{
this.EmitInterface(interfaceModel.Value, output);
}
}
public void Emit(Parameters parameters, ICodeStream output)
{
var outputFile = (CodeFileCSharp)output.CreateCodeFile($"{ConverterClassName}.cs");
var unit = CompilationUnit();
unit = unit.AddUsings(
UsingDirective(ParseName(nameof(System))));
var converterClass = ClassDeclaration(ConverterClassName);
converterClass = converterClass.AddModifiers(Token(SyntaxKind.PublicKeyword));
var baseNodeEntity = parameters.TransportModel.TransportModelEntities.First(e => e.Key == settings.AstNodeBaseTypeQualified.Split('.').Last());
var baseNodeInterface = parameters.TransportModel.TransportModelInterfaces.First(e => e.Key == settings.AstNodeBaseTypeQualified.Split('.').Last());
var syntaxKindEnum = parameters.TransportModel.TransportModelEnums.First(e => e.Key == "SyntaxKind");
var conversionMethod = MethodDeclaration(ParseTypeName(CsEmitterHelper.GetCSharpModelFullyQualifiedName(baseNodeInterface.Value, this.settings, ModelType.Ast)), this.convertFromNodeMethodName)
.AddModifiers(Token(SyntaxKind.PublicKeyword))
.WithParameterList(ParameterList(SeparatedList <ParameterSyntax>(new[] { Parameter(Identifier(this.nodeParameterName)).WithType(ParseTypeName(CsEmitterHelper.GetCSharpModelFullyQualifiedName(baseNodeInterface.Value, this.settings, ModelType.Transport))) })))
.WithBody(Block());
conversionMethod = conversionMethod.AddBodyStatements(
IfStatement(
BinaryExpression(SyntaxKind.EqualsExpression, IdentifierName(this.nodeParameterName), IdentifierName("null")),
ReturnStatement(IdentifierName("null")))
);
foreach (var entityModel in parameters.TransportModel.TransportModelEntities.Where(e => e.Value.TsDiscriminant is TransportModelEntityTsDiscriminantSyntaxKind))
{
conversionMethod = conversionMethod.AddBodyStatements(this.EmitForEntity(entityModel.Value, syntaxKindEnum.Value));
}
conversionMethod = conversionMethod.AddBodyStatements(
ExpressionStatement(
ThrowExpression(
ObjectCreationExpression(ParseTypeName(typeof(InvalidOperationException).FullName),
ArgumentList(SeparatedList <ArgumentSyntax>(new[] { Argument(LiteralExpression(SyntaxKind.StringLiteralExpression, Literal("Unable to convert node."))) })),
null
))));
converterClass = converterClass.AddMembers(conversionMethod);
converterClass = converterClass.AddMembers(this.EmitCollectionConversionMethod(baseNodeInterface.Value));
var nsContainer = NamespaceDeclaration(ParseName(this.settings.CsAstModelNamespace));
nsContainer = nsContainer.AddMembers(converterClass);
unit = unit.AddMembers(nsContainer);
outputFile.SyntaxTree = unit.SyntaxTree;
}
protected override List <ICodeStream> CreateOutputs(ICodeStreamFactory codeStreamFactory)
{
List <ICodeStream> result = new List <ICodeStream>();
this.csTransportModelsOutputStream = codeStreamFactory.CreateCodeStream(Languages.CSharp, CsTransportModelsOutStreamName);
result.Add(this.csTransportModelsOutputStream);
this.csAstModelsOutputStream = codeStreamFactory.CreateCodeStream(Languages.CSharp, CsAstModelOutStreamName);
result.Add(this.csAstModelsOutputStream);
this.csModelBuildersOutputStream = codeStreamFactory.CreateCodeStream(Languages.CSharp, CsModelBuildersOutStreamName);
result.Add(this.csModelBuildersOutputStream);
this.csTransportToAstConverterOutputStream = codeStreamFactory.CreateCodeStream(Languages.CSharp, CsTransportToAstConverterOutputStreamName);
result.Add(this.csTransportToAstConverterOutputStream);
this.tsModelsOutputStream = codeStreamFactory.CreateCodeStream(Languages.TypeScript, TsModelsOutStreamName);
result.Add(this.tsModelsOutputStream);
return(result);
}
public void Emit(Parameters parameters, ICodeStream output)
{
var singleOutputFile = (CodeFileTs)output.CreateCodeFile($"TransportToAstConverter.ts");
var name = "Converter";
var classDefinition = new StClassDeclaration()
.WithModifier(new StExportKeywordToken())
.WithName(new StIdentifier().WithEscapedText(name));
classDefinition.members.Add(this.EmitNodeConversionFunction(parameters, singleOutputFile));
classDefinition.members.Add(this.EmitNodeCollectionConversionFunction(singleOutputFile));
var importStatement = new StImportDeclaration()
.WithModuleSpecifier(new StStringLiteral().WithText(typescriptModuleName))
.WithImportClause(c =>
c
.WithNamedBindings(new StNamespaceImport().WithName(new StIdentifier().WithEscapedText(typescriptAliasName)))
);
singleOutputFile.Model = new StRoot()
.WithStatement(importStatement)
.WithStatement(classDefinition);
}
private void EmitEntity(TransportModelEntity entityModel, ICodeStream output)
{
var outputFile = (CodeFileCSharp)output.CreateCodeFile($"{CsEmitterHelper.GetCSharpModelShortName(entityModel, ModelType.Transport)}.cs");
var unit = CompilationUnit();
unit = unit.AddUsings(
UsingDirective(ParseName(nameof(System))));
var entityClass = ClassDeclaration(CsEmitterHelper.GetCSharpModelShortName(entityModel, ModelType.Transport));
entityClass = entityClass.AddModifiers(Token(SyntaxKind.PublicKeyword));
if (entityModel.TsDiscriminant is TransportModelEntityTsDiscriminantSyntaxKind kindDiscriminant)
{
entityClass = entityClass.AddMembers(
ConstructorDeclaration(CsEmitterHelper.GetCSharpModelShortName(entityModel, ModelType.Transport))
.AddModifiers(Token(SyntaxKind.PublicKeyword))
.WithBody(Block().AddStatements(
ExpressionStatement(
AssignmentExpression(
SyntaxKind.SimpleAssignmentExpression,
MemberAccessExpression(
SyntaxKind.SimpleMemberAccessExpression,
ThisExpression(),
IdentifierName("kind")),
MemberAccessExpression(
SyntaxKind.SimpleMemberAccessExpression,
IdentifierName($"{this.settings.CsTransportModelNamespace}.SyntaxKind"),
IdentifierName(kindDiscriminant.SyntaxKindValueName)))))));
}
if (entityModel.GenericParameters.Count > 0)
{
entityClass = entityClass.WithTypeParameterList(TypeParameterList(SeparatedList <TypeParameterSyntax>(entityModel.GenericParameters.Select(p => TypeParameter(p.Key)))));
entityClass = entityClass.WithConstraintClauses(List <TypeParameterConstraintClauseSyntax>(
entityModel.GenericParameters.Select(p =>
TypeParameterConstraintClause(
IdentifierName(p.Key),
SeparatedList <TypeParameterConstraintSyntax>(new[] { TypeConstraint(ParseTypeName(CsEmitterHelper.GetModelGenericParameterConstraintTypeName(p.Value, ModelType.Transport))) })))));
}
List <string> baseTypes = new List <string>();
if (entityModel.BaseEntity != null)
{
baseTypes.Add(CsEmitterHelper.GetCSharpModelReferenceName(entityModel.BaseEntity, this.settings, ModelType.Transport));
}
foreach (var interfaceModel in entityModel.Interfaces)
{
baseTypes.Add(CsEmitterHelper.GetCSharpModelFullyQualifiedName(interfaceModel, this.settings, ModelType.Transport));
}
if (baseTypes.Count > 0)
{
entityClass = entityClass.WithBaseList(BaseList(SeparatedList <BaseTypeSyntax>(baseTypes.Select(t => SimpleBaseType(ParseTypeName(t))))));
}
entityClass = entityClass.AddMembers(entityModel.Members.Select(m =>
PropertyDeclaration(ParseTypeName(CsEmitterHelper.GetPropertyTypeName(m.Value, this.settings, ModelType.Transport)), NameHelper.GetSafeVariableName(m.Value.Name))
.WithAccessorList(
SyntaxFactory.AccessorList(
SyntaxFactory.List <AccessorDeclarationSyntax>(new AccessorDeclarationSyntax[]
{
SyntaxFactory.AccessorDeclaration(SyntaxKind.GetAccessorDeclaration)
.WithSemicolonToken(SyntaxFactory.Token(SyntaxKind.SemicolonToken)),
SyntaxFactory.AccessorDeclaration(SyntaxKind.SetAccessorDeclaration)
.WithSemicolonToken(SyntaxFactory.Token(SyntaxKind.SemicolonToken))
})))
.AddModifiers(Token(SyntaxKind.PublicKeyword))
).ToArray <MemberDeclarationSyntax>());
var nsContainer = NamespaceDeclaration(ParseName(this.settings.CsTransportModelNamespace));
nsContainer = nsContainer.AddMembers(entityClass);
unit = unit.AddMembers(nsContainer);
outputFile.SyntaxTree = unit.SyntaxTree;
}
private void EmitEntity(TransportModelEntity entityModel, ICodeStream output)
{
var outputFile = (CodeFileCSharp)output.CreateCodeFile($"{CsEmitterHelper.GetCSharpModelShortName(entityModel, ModelType.Ast)}.cs");
var unit = CompilationUnit();
unit = unit.AddUsings(
UsingDirective(ParseName(nameof(System))));
var entityClass = ClassDeclaration(CsEmitterHelper.GetCSharpModelShortName(entityModel, ModelType.Ast));
entityClass = entityClass.AddModifiers(Token(SyntaxKind.PublicKeyword));
if (entityModel.TsDiscriminant == null || !(entityModel.TsDiscriminant is TransportModelEntityTsDiscriminantSyntaxKind))
{
entityClass = entityClass.AddModifiers(Token(SyntaxKind.AbstractKeyword));
}
List <StatementSyntax> propertyInitializers = null;
List <ArgumentSyntax> baseConstructorArguments = null;
var constructorDeclaration =
ConstructorDeclaration(CsEmitterHelper.GetCSharpModelShortName(entityModel, ModelType.Ast))
.AddModifiers(Token(SyntaxKind.PublicKeyword))
.WithParameterList(ParameterList(SeparatedList <ParameterSyntax>(this.GetConstructorParameters(entityModel, out propertyInitializers, out baseConstructorArguments))));
if (baseConstructorArguments != null && baseConstructorArguments.Count > 0)
{
constructorDeclaration = constructorDeclaration.WithInitializer(
ConstructorInitializer(SyntaxKind.BaseConstructorInitializer)
.AddArgumentListArguments(baseConstructorArguments.ToArray()));
}
var constructorBody = Block();
constructorBody = this.PopulateRequiredConstructorBodyInitializers(constructorBody, entityModel);
if (propertyInitializers != null && propertyInitializers.Count > 0)
{
constructorBody = constructorBody.AddStatements(propertyInitializers.ToArray());
}
constructorDeclaration = constructorDeclaration.WithBody(constructorBody);
entityClass = entityClass.AddMembers(constructorDeclaration);
if (constructorDeclaration.ParameterList.Parameters.Count > 0)
{
var parameterlessConstructorDeclaration =
ConstructorDeclaration(CsEmitterHelper.GetCSharpModelShortName(entityModel, ModelType.Ast))
.AddModifiers(Token(SyntaxKind.PublicKeyword));
var parameterlessConstructorBody = Block();
parameterlessConstructorBody = this.PopulateRequiredConstructorBodyInitializers(parameterlessConstructorBody, entityModel);
parameterlessConstructorDeclaration = parameterlessConstructorDeclaration.WithBody(parameterlessConstructorBody);
entityClass = entityClass.AddMembers(parameterlessConstructorDeclaration);
}
if (entityModel.GenericParameters.Count > 0)
{
entityClass = entityClass.WithTypeParameterList(TypeParameterList(SeparatedList <TypeParameterSyntax>(entityModel.GenericParameters.Select(p => TypeParameter(p.Key)))));
entityClass = entityClass.WithConstraintClauses(List <TypeParameterConstraintClauseSyntax>(
entityModel.GenericParameters.Select(p =>
TypeParameterConstraintClause(
IdentifierName(p.Key),
SeparatedList <TypeParameterConstraintSyntax>(new[] { TypeConstraint(ParseTypeName(CsEmitterHelper.GetModelGenericParameterConstraintTypeName(p.Value, ModelType.Ast))) })))));
}
List <string> baseTypes = new List <string>();
if (entityModel.Name == this.settings.AstNodeBaseTypeQualified.Split('.').Last())
{
baseTypes.Add($"{settings.CsAstModelNamespace}.{baseNodeType}");
}
if (entityModel.BaseEntity != null)
{
baseTypes.Add(CsEmitterHelper.GetCSharpModelReferenceName(entityModel.BaseEntity, this.settings, ModelType.Ast));
}
foreach (var interfaceModel in entityModel.Interfaces)
{
baseTypes.Add(CsEmitterHelper.GetCSharpModelFullyQualifiedName(interfaceModel, this.settings, ModelType.Ast));
}
if (baseTypes.Count > 0)
{
entityClass = entityClass.WithBaseList(BaseList(SeparatedList <BaseTypeSyntax>(baseTypes.Select(t => SimpleBaseType(ParseTypeName(t))))));
}
entityClass = entityClass.AddMembers(
entityModel
.Members
.Where(m => !CsEmitterHelper.IsNodeCollection(m.Value.Type))
.Select(m =>
FieldDeclaration(VariableDeclaration(ParseTypeName(CsEmitterHelper.GetAstModelPropertyTypeName(m.Value, this.settings)), SeparatedList <VariableDeclaratorSyntax>(new[] { VariableDeclarator(this.GetFieldName(m.Key)) })))
).ToArray <MemberDeclarationSyntax>());
entityClass = entityClass.AddMembers(entityModel.Members.Select(m => this.CreatePropertyDeclaration(m.Value)).ToArray <MemberDeclarationSyntax>());
if (entityModel.TsDiscriminant is TransportModelEntityTsDiscriminantSyntaxKind)
{
entityClass = entityClass.AddMembers(this.GenerateConversionMethod(entityModel));
}
var nsContainer = NamespaceDeclaration(ParseName(this.settings.CsAstModelNamespace));
nsContainer = nsContainer.AddMembers(entityClass);
unit = unit.AddMembers(nsContainer);
outputFile.SyntaxTree = unit.SyntaxTree;
}
private static void InternalConvertExceptionFilter(
CodeTextWriter tw,
IExtractContextHost extractContext,
PreparedMethodInformation preparedMethod,
ICodeStream codeStream)
{
tw.WriteLine("//-------------------");
tw.WriteLine("// [3-1] Exception filters:");
tw.SplitLine();
for (var handlerIndex = 0;
handlerIndex < codeStream.ExceptionHandlers.Length;
handlerIndex++)
{
var handler = codeStream.ExceptionHandlers[handlerIndex];
var filterName = string.Format(
"{0}_ExceptionFilter{1}__",
preparedMethod.Method.CLanguageFunctionName,
handlerIndex);
tw.WriteLine(
"static int16_t {0}(System_Exception* ex)",
filterName);
tw.WriteLine("{");
using (var _ = tw.Shift())
{
tw.WriteLine("il2c_assert(ex != NULL);");
for (var catchHandlerIndex = 0;
catchHandlerIndex < handler.CatchHandlers.Length;
catchHandlerIndex++)
{
var catchHandler = handler.CatchHandlers[catchHandlerIndex];
if (catchHandler.CatchHandlerType == ExceptionCatchHandlerTypes.Catch)
{
tw.WriteLine(
"if (il2c_unlikely__(il2c_isinst__(ex, il2c_typeof({0})))) return {1};",
catchHandler.CatchType.MangledUniqueName,
catchHandlerIndex + 1);
}
}
// Write finally block index if contains.
var finallyHandler = handler.CatchHandlers.
Select((catchHandler, index) => new { catchHandler, index }).
FirstOrDefault(entry => entry.catchHandler.CatchHandlerType == ExceptionCatchHandlerTypes.Finally);
if (finallyHandler != null)
{
tw.WriteLine("return IL2C_FILTER_FINALLY; // Not matched (will go to finally)");
}
else
{
tw.WriteLine("return IL2C_FILTER_NOMATCH; // Not matched");
}
}
tw.WriteLine("}");
tw.SplitLine();
}
}
public void Emit(Parameters parameters, ICodeStream output)
{
var singleOutputFile = (CodeFileTs)output.CreateCodeFile($"TransportTypeMarker.ts");
this.EmitTypeMarkerFunction(parameters, singleOutputFile);
}
