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))); }