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 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);
if (Inputs.Count == 1)
{
ExpressionSyntax initializer;
if (ObjectBuilder.Operation == MyObjectBuilder_LogicGateScriptNode.LogicOperation.NOT)
{
// Initializer for NOT
initializer = SyntaxFactory.PrefixUnaryExpression(
SyntaxKind.LogicalNotExpression,
SyntaxFactory.IdentifierName(
Inputs[0].VariableSyntaxName(m_inputsToVariableNames[Inputs[0]])
)
);
}
else
{
// Initilizer for case when someone just didn't connect anything to second input
initializer = SyntaxFactory.IdentifierName(
Inputs[0].VariableSyntaxName(m_inputsToVariableNames[Inputs[0]])
);
}
// Local variable without binary expression
var localVariable = MySyntaxFactory.LocalVariable(
typeof(bool).Signature(),
VariableSyntaxName(),
initializer
);
expressions.Add(localVariable);
}
else if (Inputs.Count > 1)
{
// Initial expression
ExpressionSyntax initiliazer = SyntaxFactory.BinaryExpression(
OperationKind,
SyntaxFactory.IdentifierName(Inputs[0].VariableSyntaxName(m_inputsToVariableNames[Inputs[0]])),
SyntaxFactory.IdentifierName(Inputs[1].VariableSyntaxName(m_inputsToVariableNames[Inputs[1]]))
);
// Add rest of the binary expression
for (var index = 2; index < Inputs.Count; index++)
{
var inputNode = Inputs[index];
initiliazer = SyntaxFactory.BinaryExpression(
OperationKind,
initiliazer,
SyntaxFactory.IdentifierName(
inputNode.VariableSyntaxName(
m_inputsToVariableNames[inputNode]
)
)
);
}
if (ObjectBuilder.Operation == MyObjectBuilder_LogicGateScriptNode.LogicOperation.NAND ||
ObjectBuilder.Operation == MyObjectBuilder_LogicGateScriptNode.LogicOperation.NOR)
{
// For these also add parenthesis and negation
initiliazer = SyntaxFactory.PrefixUnaryExpression(
SyntaxKind.LogicalNotExpression,
SyntaxFactory.ParenthesizedExpression(
initiliazer
)
);
}
// Local variable syntax
var localVariable = MySyntaxFactory.LocalVariable(typeof(bool).Signature(), VariableSyntaxName(), initiliazer);
expressions.Add(localVariable);
}
}
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 CollectInputExpressions(List <StatementSyntax> expressions)
{
// Insert expressions from connected nodes
base.CollectInputExpressions(expressions);
// Create container variables for output parameters.
// Assign correct identifiers to method call.
var args = new List <SyntaxNodeOrToken>();
var parameters = m_methodInfo.GetParameters();
var index = 0;
// Skip the first parameter for extension methods.
if (m_methodInfo.IsDefined(typeof(ExtensionAttribute), false))
{
index++;
}
for (; index < parameters.Length; index++)
{
var parameter = parameters[index];
// Create container variables for output parameters.
if (parameter.IsOut)
{
// Output parameters
var localOutputVariableName = VariableSyntaxName(parameter.Name);
// add variable creation expression
expressions.Add(MySyntaxFactory.LocalVariable(parameter.ParameterType.GetElementType().Signature(), localOutputVariableName));
// add variable name to parameters
args.Add(SyntaxFactory.Argument(
SyntaxFactory.IdentifierName(localOutputVariableName)
).WithNameColon(SyntaxFactory.NameColon(parameter.Name))
.WithRefOrOutKeyword(SyntaxFactory.Token(SyntaxKind.OutKeyword)
)
);
}
// Get the names of the variables supplying the values to the method call
else
{
// Find the value input node
MyTuple <MyVisualSyntaxNode, MyVariableIdentifier> inputData;
if (m_parametersToInputs.TryGetValue(parameter, out inputData))
{
// FOUND!
// add variable name to arguments
var variableName = inputData.Item1.VariableSyntaxName(inputData.Item2.VariableName);
Debug.Assert(variableName != null);
args.Add(SyntaxFactory.Argument(
SyntaxFactory.IdentifierName(
variableName
)
).WithNameColon(SyntaxFactory.NameColon(parameter.Name))
);
}
else
{
// Not FOUND! will be probably an constant argument
var paramValue =
ObjectBuilder.InputParameterValues.Find(value => value.ParameterName == parameter.Name);
if (paramValue == null)
{
// Dont panic, there could be still the default value.
if (!parameter.HasDefaultValue)
{
// Add null / some default value
args.Add(
MySyntaxFactory.ConstantDefaultArgument(parameter.ParameterType)
.WithNameColon(SyntaxFactory.NameColon(parameter.Name))
);
}
else
{
// default value will take care of this
continue; // no comma for you args
}
}
else
{
// Add constant value to arguments
args.Add(MySyntaxFactory.ConstantArgument(
parameter.ParameterType.Signature(), paramValue.Value
).WithNameColon(SyntaxFactory.NameColon(parameter.Name))
);
}
}
}
// add comma
args.Add(SyntaxFactory.Token(SyntaxKind.CommaToken));
}
// remove last comma
if (args.Count > 0)
{
args.RemoveAt(args.Count - 1);
}
// Create the invocation syntax
InvocationExpressionSyntax methodInvocation = null;
if (m_methodInfo.IsStatic && !m_methodInfo.IsDefined(typeof(ExtensionAttribute)))
{
// Static call
methodInvocation = MySyntaxFactory.MethodInvocationExpressionSyntax(
SyntaxFactory.IdentifierName(m_methodInfo.DeclaringType.FullName + "." + m_methodInfo.Name),
SyntaxFactory.ArgumentList(SyntaxFactory.SeparatedList <ArgumentSyntax>(args))
);
}
else
{
var declaringType = m_methodInfo.DeclaringType;
// Non static local method invocation
if (declaringType == m_scriptBaseType)
{
methodInvocation = MySyntaxFactory.MethodInvocationExpressionSyntax(
SyntaxFactory.IdentifierName(m_methodInfo.Name),
SyntaxFactory.ArgumentList(SyntaxFactory.SeparatedList <ArgumentSyntax>(args))
);
}
// Non static instance method invocation or extension method
else
{
if (m_instance == null)
{
throw new Exception("FunctionNode: " + ObjectBuilder.ID +
" Is missing mandatory instance input.");
}
var instanceVariableName = m_instance.VariableSyntaxName(ObjectBuilder.InstanceInputID.VariableName);
methodInvocation = MySyntaxFactory.MethodInvocationExpressionSyntax(
SyntaxFactory.IdentifierName(m_methodInfo.Name),
SyntaxFactory.ArgumentList(SyntaxFactory.SeparatedList <ArgumentSyntax>(args)),
SyntaxFactory.IdentifierName(instanceVariableName)
);
}
}
// Finalize the syntax
if (m_methodInfo.ReturnType == typeof(void))
{
// just add invocation
expressions.Add(
SyntaxFactory.ExpressionStatement(methodInvocation)
);
}
else
{
// Create variable for return value
expressions.Add(
MySyntaxFactory.LocalVariable(
string.Empty,
VariableSyntaxName("Return"),
methodInvocation
)
);
}
}
internal override void CollectInputExpressions(List <StatementSyntax> expressions)
{
base.CollectInputExpressions(expressions);
// Add local output variable declarations
expressions.AddRange(ObjectBuilder.Outputs.Select(outputData => MySyntaxFactory.LocalVariable(outputData.Type, outputData.Name)));
}
