// Takes array of key indexs and recursively creates syntax for condition clause.
private ExpressionSyntax CreateAndClauses(int index, List <int> keyIndexes)
{
var literal = MySyntaxFactory.Literal(ObjectBuilder.OuputTypes[keyIndexes[index]], ObjectBuilder.Keys[keyIndexes[index]]);
if (index == 0)
{
return(SyntaxFactory.BinaryExpression(
SyntaxKind.EqualsExpression,
SyntaxFactory.IdentifierName(ObjectBuilder.OutputNames[keyIndexes[index]]),
literal
));
}
var currentExpression = SyntaxFactory.BinaryExpression(
SyntaxKind.EqualsExpression,
SyntaxFactory.IdentifierName(ObjectBuilder.OutputNames[keyIndexes[index]]),
literal
);
return(SyntaxFactory.BinaryExpression(
SyntaxKind.LogicalAndExpression,
CreateAndClauses(--index, keyIndexes),
currentExpression
));
}
internal override void CollectInputExpressions(List <StatementSyntax> expressions)
{
base.CollectInputExpressions(expressions);
var entryType = MyVisualScriptingProxy.GetType(ObjectBuilder.Type);
var listType = typeof(List <>).MakeGenericType(entryType);
var separatedList = new List <SyntaxNodeOrToken>();
// Create source of arguments for array creation syntax
for (var index = 0; index < ObjectBuilder.DefaultEntries.Count; index++)
{
var entry = ObjectBuilder.DefaultEntries[index];
var literal = MySyntaxFactory.Literal(ObjectBuilder.Type, entry);
separatedList.Add(literal);
if (index < ObjectBuilder.DefaultEntries.Count - 1)
{
separatedList.Add(SyntaxFactory.Token(SyntaxKind.CommaToken));
}
}
// Syntax of "new Type[]{arg0, arg1, ...}"
ArrayCreationExpressionSyntax arrayCreationSyntax = null;
if (separatedList.Count > 0)
{
arrayCreationSyntax = SyntaxFactory.ArrayCreationExpression(
SyntaxFactory.ArrayType(
SyntaxFactory.IdentifierName(ObjectBuilder.Type),
SyntaxFactory.SingletonList(
SyntaxFactory.ArrayRankSpecifier(
SyntaxFactory.SingletonSeparatedList <ExpressionSyntax>(
SyntaxFactory.OmittedArraySizeExpression()
)
)
)
),
SyntaxFactory.InitializerExpression(
SyntaxKind.ArrayInitializerExpression,
SyntaxFactory.SeparatedList <ExpressionSyntax>(
separatedList
)
)
);
}
// Syntax of new List<Type>(arrayCreationSyntax);
var listCreationSyntax = MySyntaxFactory.GenericObjectCreation(listType, arrayCreationSyntax == null ? null : new[] { arrayCreationSyntax });
var localVariableSyntax = MySyntaxFactory.LocalVariable(listType, VariableSyntaxName(), listCreationSyntax);
expressions.Add(localVariableSyntax);
}
internal override void CollectSequenceExpressions(List <StatementSyntax> expressions)
{
CollectInputExpressions(expressions);
var valueVariableName = m_valueInput.VariableSyntaxName(ObjectBuilder.ValueInput.VariableName);
var switchSections = new List <SwitchSectionSyntax>();
var syntaxList = new List <StatementSyntax>();
for (int index = 0; index < m_sequenceOutputs.Count; index++)
{
var sequenceOutputNode = m_sequenceOutputs[index];
if (sequenceOutputNode == null)
{
continue;
}
syntaxList.Clear();
// Collect
sequenceOutputNode.CollectSequenceExpressions(syntaxList);
// Add break to the end of the section
syntaxList.Add(SyntaxFactory.BreakStatement());
// New section syntax
var section = SyntaxFactory.SwitchSection().WithLabels(
SyntaxFactory.SingletonList <SwitchLabelSyntax>(
SyntaxFactory.CaseSwitchLabel(
MySyntaxFactory.Literal(ObjectBuilder.NodeType, ObjectBuilder.Options[index].Option)
)
)).WithStatements(SyntaxFactory.List(syntaxList));
switchSections.Add(section);
}
var switchSyntax = SyntaxFactory.SwitchStatement(
SyntaxFactory.IdentifierName(valueVariableName)
)
.WithSections(SyntaxFactory.List(switchSections));
expressions.Add(switchSyntax);
}
internal override void CollectInputExpressions(List <StatementSyntax> expressions)
{
var value = ObjectBuilder.Value ?? string.Empty;
var type = MyVisualScriptingProxy.GetType(ObjectBuilder.Type);
base.CollectInputExpressions(expressions);
// First handle special cases as Color and Enums
if (type == typeof(Color) || type.IsEnum)
{
expressions.Add(
MySyntaxFactory.LocalVariable(
ObjectBuilder.Type,
VariableSyntaxName(),
SyntaxFactory.MemberAccessExpression(
SyntaxKind.SimpleMemberAccessExpression,
SyntaxFactory.IdentifierName(ObjectBuilder.Type),
SyntaxFactory.IdentifierName(ObjectBuilder.Value)
)
)
);
}
else if (type == typeof(Vector3D))
{
expressions.Add(
MySyntaxFactory.LocalVariable(ObjectBuilder.Type, VariableSyntaxName(),
MySyntaxFactory.NewVector3D(ObjectBuilder.Value)
)
);
}
else
{
// Rest is generic
expressions.Add(
MySyntaxFactory.LocalVariable(
ObjectBuilder.Type,
VariableSyntaxName(),
MySyntaxFactory.Literal(ObjectBuilder.Type, value))
);
}
}
internal override void CollectInputExpressions(List <StatementSyntax> expressions)
{
base.CollectInputExpressions(expressions);
// MyLocalization.Static["context", "messageId"];
var localizationAccessExpression = SyntaxFactory.ElementAccessExpression(
SyntaxFactory.MemberAccessExpression(
SyntaxKind.SimpleMemberAccessExpression,
SyntaxFactory.IdentifierName("VRage.Game.Localization.MyLocalization"),
SyntaxFactory.IdentifierName("Static")
)
).WithArgumentList(
SyntaxFactory.BracketedArgumentList(
SyntaxFactory.SeparatedList <ArgumentSyntax>(
new SyntaxNodeOrToken[]
{
SyntaxFactory.Argument(
MySyntaxFactory.Literal(typeof(string).Signature(), ObjectBuilder.Context)),
SyntaxFactory.Token(SyntaxKind.CommaToken),
SyntaxFactory.Argument(
MySyntaxFactory.Literal(typeof(string).Signature(), ObjectBuilder.MessageId))
})
)
);
// ToString() invocation expression
var toStringExpression = SyntaxFactory.InvocationExpression(
SyntaxFactory.MemberAccessExpression(
SyntaxKind.SimpleMemberAccessExpression,
localizationAccessExpression,
SyntaxFactory.IdentifierName("ToString")
)
);
// String tmpVariableName = the above
string tmpVariableName = "localizedText_" + ObjectBuilder.ID;
if (m_inputParameterNodes.Count == 0)
{
tmpVariableName = VariableSyntaxName();
}
var localizedTextVariableSyntax = MySyntaxFactory.LocalVariable(typeof(string).Signature(),
tmpVariableName, toStringExpression);
if (m_inputParameterNodes.Count > 0)
{
// Prepare variable names for creation of string.Format call
var parameterVariableNames = new List <string>();
parameterVariableNames.Add(tmpVariableName);
for (int index = 0; index < m_inputParameterNodes.Count; index++)
{
var node = m_inputParameterNodes[index];
parameterVariableNames.Add(node.VariableSyntaxName(ObjectBuilder.ParameterInputs[index].VariableName));
}
// string.Format(....) call
var stringFormatSyntax = MySyntaxFactory.MethodInvocation("Format", parameterVariableNames, "string");
// node variable syntax creation
var nodeVariableSyntax = MySyntaxFactory.LocalVariable(typeof(string).Signature(), VariableSyntaxName(), stringFormatSyntax);
expressions.Add(localizedTextVariableSyntax);
expressions.Add(nodeVariableSyntax);
}
else
{
expressions.Add(localizedTextVariableSyntax);
}
}
internal override void CollectSequenceExpressions(List <StatementSyntax> expressions)
{
base.CollectInputExpressions(expressions);
// We can ignore the nodes with empty bodies
if (m_bodySequence != null)
{
var bodySyntax = new List <StatementSyntax>();
// Collect body expressions
m_bodySequence.CollectSequenceExpressions(bodySyntax);
// Create syntax for first index of for loop
ExpressionSyntax firstIndexExpression;
if (m_firstInput != null)
{
firstIndexExpression = SyntaxFactory.IdentifierName(
m_firstInput.VariableSyntaxName(ObjectBuilder.FirstIndexValueInput.VariableName)
);
}
else
{
firstIndexExpression = MySyntaxFactory.Literal(
typeof(int).Signature(),
ObjectBuilder.FirstIndexValue
);
}
// Create syntax for last index condition
ExpressionSyntax lastIndexExpression;
if (m_lastInput != null)
{
lastIndexExpression = SyntaxFactory.IdentifierName(
m_lastInput.VariableSyntaxName(ObjectBuilder.LastIndexValueInput.VariableName)
);
}
else
{
lastIndexExpression = MySyntaxFactory.Literal(typeof(int).Signature(), ObjectBuilder.LastIndexValue);
}
// Create syntax for increment
ExpressionSyntax incrementExpression;
if (m_incrementInput != null)
{
incrementExpression = SyntaxFactory.IdentifierName(
m_incrementInput.VariableSyntaxName(ObjectBuilder.IncrementValueInput.VariableName)
);
}
else
{
incrementExpression = MySyntaxFactory.Literal(typeof(int).Signature(), ObjectBuilder.IncrementValue);
}
// Put the for statement syntax together
var forStatement = SyntaxFactory.ForStatement(
SyntaxFactory.Block(bodySyntax)
).WithDeclaration(
SyntaxFactory.VariableDeclaration(
SyntaxFactory.PredefinedType(
SyntaxFactory.Token(SyntaxKind.IntKeyword)))
.WithVariables(
SyntaxFactory.SingletonSeparatedList <VariableDeclaratorSyntax>(
SyntaxFactory.VariableDeclarator(
SyntaxFactory.Identifier(VariableSyntaxName()))
.WithInitializer(
SyntaxFactory.EqualsValueClause(
firstIndexExpression
)
)
)
)
).WithCondition(
SyntaxFactory.BinaryExpression(
SyntaxKind.LessThanOrEqualExpression,
SyntaxFactory.IdentifierName(VariableSyntaxName()),
lastIndexExpression
)
).WithIncrementors(
SyntaxFactory.SingletonSeparatedList <ExpressionSyntax>(
SyntaxFactory.AssignmentExpression(
SyntaxKind.AddAssignmentExpression,
SyntaxFactory.IdentifierName(VariableSyntaxName()),
incrementExpression
)
)
);
expressions.Add(forStatement);
}
// Ignore if not present
if (m_finishSequence != null)
{
m_finishSequence.CollectSequenceExpressions(expressions);
}
}
internal override void CollectSequenceExpressions(List <StatementSyntax> expressions)
{
// Collect input only from these nodes that are inputs for this node.
m_toCollectNodeCache.Clear();
foreach (var subTreeNode in SubTreeNodes)
{
var directConnection = false;
foreach (var outputNode in subTreeNode.Outputs)
{
// Must be an input
if (outputNode == this && !outputNode.Collected)
{
directConnection = true;
break;
}
}
if (directConnection)
{
subTreeNode.CollectInputExpressions(expressions);
}
else
{
// Cache these that are getting the input from this one.
m_toCollectNodeCache.Add(subTreeNode);
}
}
// We can ignore the nodes with empty bodies
if (m_bodySequence != null)
{
var bodySyntax = new List <StatementSyntax>();
// Collect the assigned bodies from
foreach (var node in m_toCollectNodeCache)
{
node.CollectInputExpressions(bodySyntax);
}
// Collect body expressions
m_bodySequence.CollectSequenceExpressions(bodySyntax);
// Create syntax for first index of for loop
ExpressionSyntax firstIndexExpression;
if (m_firstInput != null)
{
firstIndexExpression = SyntaxFactory.IdentifierName(
m_firstInput.VariableSyntaxName(ObjectBuilder.FirstIndexValueInput.VariableName)
);
}
else
{
firstIndexExpression = MySyntaxFactory.Literal(
typeof(int).Signature(),
ObjectBuilder.FirstIndexValue
);
}
// Create syntax for last index condition
ExpressionSyntax lastIndexExpression;
if (m_lastInput != null)
{
lastIndexExpression = SyntaxFactory.IdentifierName(
m_lastInput.VariableSyntaxName(ObjectBuilder.LastIndexValueInput.VariableName)
);
}
else
{
lastIndexExpression = MySyntaxFactory.Literal(typeof(int).Signature(), ObjectBuilder.LastIndexValue);
}
// Create syntax for increment
ExpressionSyntax incrementExpression;
if (m_incrementInput != null)
{
incrementExpression = SyntaxFactory.IdentifierName(
m_incrementInput.VariableSyntaxName(ObjectBuilder.IncrementValueInput.VariableName)
);
}
else
{
incrementExpression = MySyntaxFactory.Literal(typeof(int).Signature(), ObjectBuilder.IncrementValue);
}
// Put the for statement syntax together
var forStatement = SyntaxFactory.ForStatement(
SyntaxFactory.Block(bodySyntax)
).WithDeclaration(
SyntaxFactory.VariableDeclaration(
SyntaxFactory.PredefinedType(
SyntaxFactory.Token(SyntaxKind.IntKeyword)))
.WithVariables(
SyntaxFactory.SingletonSeparatedList <VariableDeclaratorSyntax>(
SyntaxFactory.VariableDeclarator(
SyntaxFactory.Identifier(VariableSyntaxName()))
.WithInitializer(
SyntaxFactory.EqualsValueClause(
firstIndexExpression
)
)
)
)
).WithCondition(
SyntaxFactory.BinaryExpression(
SyntaxKind.LessThanOrEqualExpression,
SyntaxFactory.IdentifierName(VariableSyntaxName()),
lastIndexExpression
)
).WithIncrementors(
SyntaxFactory.SingletonSeparatedList <ExpressionSyntax>(
SyntaxFactory.AssignmentExpression(
SyntaxKind.AddAssignmentExpression,
SyntaxFactory.IdentifierName(VariableSyntaxName()),
incrementExpression
)
)
);
expressions.Add(forStatement);
}
// Ignore if not present
if (m_finishSequence != null)
{
m_finishSequence.CollectSequenceExpressions(expressions);
}
}
