public void CreateMainMethod() { mainMethod = new Method("Main") { Class = cls, Modifiers = MethodModifiers.Static }; MethodSpecifier stringLengthSpecifier = new MethodSpecifier("StringLength", new Named <BaseType> [0], new List <TypeSpecifier>() { TypeSpecifier.FromType <int>() }, MethodModifiers.Public, TypeSpecifier.FromType <string>(), Array.Empty <BaseType>()); //MethodSpecifier writeConsoleSpecifier = typeof(Console).GetMethods().Single(m => m.Name == "WriteLine" && m.GetParameters().Length == 1 && m.GetParameters()[0].ParameterType == typeof(string)); TypeSpecifier stringType = TypeSpecifier.FromType <string>(); MethodSpecifier writeConsoleSpecifier = new MethodSpecifier("WriteLine", new Named <BaseType>[] { new Named <BaseType>("argName", stringType) }, new BaseType[0], MethodModifiers.Public, TypeSpecifier.FromType(typeof(Console)), new BaseType[0]); // Create nodes LiteralNode stringLiteralNode = LiteralNode.WithValue(mainMethod, "Hello World"); VariableSetterNode setStringNode = new VariableSetterNode(mainMethod, cls.Type, new Variable("testVariable", TypeSpecifier.FromType <string>())); CallMethodNode getStringLengthNode = new CallMethodNode(mainMethod, stringLengthSpecifier); CallMethodNode writeConsoleNode = new CallMethodNode(mainMethod, writeConsoleSpecifier); // Connect node execs GraphUtil.ConnectExecPins(mainMethod.EntryNode.InitialExecutionPin, setStringNode.InputExecPins[0]); GraphUtil.ConnectExecPins(setStringNode.OutputExecPins[0], getStringLengthNode.InputExecPins[0]); GraphUtil.ConnectExecPins(getStringLengthNode.OutputExecPins[0], writeConsoleNode.InputExecPins[0]); GraphUtil.ConnectExecPins(writeConsoleNode.OutputExecPins[0], mainMethod.ReturnNodes.First().InputExecPins[0]); // Connect node data GraphUtil.ConnectDataPins(stringLiteralNode.ValuePin, setStringNode.NewValuePin); GraphUtil.ConnectDataPins(getStringLengthNode.OutputDataPins[0], writeConsoleNode.ArgumentPins[0]); }
public void Visit(CallMethodNode node) { var paren = node.GetPrecedence() < node.GetObject().GetPrecedence(); if (paren) { source.Append("("); } if (node.GetObject() is IdentifierStringNode) { source.Append((node.GetObject() as IdentifierStringNode).GetIdentifier()); } else { node.GetObject().Visit(this); } if (paren) { source.Append(")"); } source.Append("." + node.GetMethod().Identifier + "("); node.GetParameters().Visit(this); source.Append(")"); }
public void Visit(CallMethodNode node) { visitor.OnVisit((n, v) => { var r = n as CallMethodNode; if (r != null && r.GetMethod() == node.GetMethod()) { Result = IsSameChildren(r, node); } }); reference.Visit(visitor); }
private VarType Parsing(CallMethodNode node, string methodName) { if (Context.IsContainsMethod(node.MethodName)) { return Context.GetTypeMethod(node.MethodName); } else { Console.WriteLine("{0} не существует в текущем контексте. Строка {1}", node.MethodName, node.Line); } return VarType.Undefined; }
private void Parsing(CallMethodNode node, StringBuilder sb, ref int lineNum) { PrintCommand(sb, String.Format("call void Program::{0}() ", node.MethodName), ref lineNum); }
public void TranslateCallMethodNode(CallMethodNode node) { // Wrap in try / catch if (node.HandlesExceptions) { builder.AppendLine("try"); builder.AppendLine("{"); } string temporaryReturnName = null; if (!node.IsPure) { // Translate all the pure nodes this node depends on in // the correct order TranslateDependentPureNodes(node); } // Write assignment of return values if (node.ReturnValuePins.Count == 1) { string returnName = GetOrCreatePinName(node.ReturnValuePins[0]); builder.Append($"{returnName} = "); } else if (node.OutputDataPins.Count > 1) { temporaryReturnName = TranslatorUtil.GetTemporaryVariableName(random); var returnTypeNames = string.Join(", ", node.OutputDataPins.Select(pin => pin.PinType.Value.FullCodeName)); builder.Append($"{typeof(Tuple).FullName}<{returnTypeNames}> {temporaryReturnName} = "); } // Get arguments for method call var argumentNames = GetPinIncomingValues(node.ArgumentPins); // Check whether the method is an operator and we need to translate its name // into operator symbols. Otherwise just call the method normally. if (OperatorUtil.TryGetOperatorInfo(node.MethodSpecifier, out OperatorInfo operatorInfo)) { if (operatorInfo.Unary) { if (argumentNames.Count() != 1) { throw new Exception($"Unary operator was found but did not have one argument: {node.MethodName}"); } if (operatorInfo.UnaryRightPosition) { builder.AppendLine($"{argumentNames.ElementAt(0)}{operatorInfo.Symbol};"); } else { builder.AppendLine($"{operatorInfo.Symbol}{argumentNames.ElementAt(0)};"); } } else { if (argumentNames.Count() != 2) { throw new Exception($"Binary operator was found but did not have two arguments: {node.MethodName}"); } builder.AppendLine($"{argumentNames.ElementAt(0)}{operatorInfo.Symbol}{argumentNames.ElementAt(1)};"); } } else { // Static: Write class name / target, default to own class name // Instance: Write target, default to this if (node.IsStatic) { builder.Append($"{node.DeclaringType.FullCodeName}."); } else { if (node.TargetPin.IncomingPin != null) { string targetName = GetOrCreatePinName(node.TargetPin.IncomingPin); builder.Append($"{targetName}."); } else { // Default to this builder.Append("this."); } } // Prefix with "out" / "ref" / "in" string[] argNameArray = argumentNames.ToArray(); Debug.Assert(argNameArray.Length == node.MethodSpecifier.Parameters.Count); for (int i = 0; i < node.MethodSpecifier.Parameters.Count; i++) { MethodParameterPassType passType = node.MethodSpecifier.Parameters[i].PassType; switch (passType) { case MethodParameterPassType.Out: argNameArray[i] = "out " + argNameArray[i]; break; case MethodParameterPassType.Reference: argNameArray[i] = "ref " + argNameArray[i]; break; case MethodParameterPassType.In: // Don't pass with in as it could break implicit casts. // argNameArray[i] = "in " + argNameArray[i]; break; default: break; } } // Write the method call builder.AppendLine($"{node.BoundMethodName}({string.Join(", ", argNameArray)});"); } // Assign the real variables from the temporary tuple if (node.ReturnValuePins.Count > 1) { var returnNames = GetOrCreatePinNames(node.ReturnValuePins); for (int i = 0; i < returnNames.Count(); i++) { builder.AppendLine($"{returnNames.ElementAt(i)} = {temporaryReturnName}.Item{i+1};"); } } // Set the exception to null on success if catch pin is connected if (node.HandlesExceptions) { builder.AppendLine($"{GetOrCreatePinName(node.ExceptionPin)} = null;"); } // Go to the next state if (!node.IsPure) { WriteGotoOutputPinIfNecessary(node.OutputExecPins[0], node.InputExecPins[0]); } // Catch exceptions if catch pin is connected if (node.HandlesExceptions) { string exceptionVarName = TranslatorUtil.GetTemporaryVariableName(random); builder.AppendLine("}"); builder.AppendLine($"catch (System.Exception {exceptionVarName})"); builder.AppendLine("{"); builder.AppendLine($"{GetOrCreatePinName(node.ExceptionPin)} = {exceptionVarName};"); // Set all return values to default on exception foreach (var returnValuePin in node.ReturnValuePins) { string returnName = GetOrCreatePinName(returnValuePin); builder.AppendLine($"{returnName} = default({returnValuePin.PinType.Value.FullCodeName});"); } if (!node.IsPure) { WriteGotoOutputPinIfNecessary(node.CatchPin, node.InputExecPins[0]); } builder.AppendLine("}"); } }
public void TranslateCallMethodNode(CallMethodNode node) { string temporaryReturnName = null; // Translate all the pure nodes this node depends on in // the correct order TranslateDependentPureNodes(node); // Write assignment of return values if (node.OutputDataPins.Count == 1) { string returnName = GetOrCreatePinName(node.OutputDataPins[0]); builder.Append($"{returnName} = "); } else if (node.OutputDataPins.Count > 1) { temporaryReturnName = TranslatorUtil.GetTemporaryVariableName(); var returnTypeNames = string.Join(", ", node.OutputDataPins.Select(pin => pin.PinType)); builder.Append($"{typeof(Tuple).FullName}<{returnTypeNames}> {temporaryReturnName} = "); } // Static: Write class name / target, default to own class name // Instance: Write target, default to this if (node.IsStatic) { builder.Append($"{node.DeclaringType}."); } else { if (node.TargetPin.IncomingPin != null) { string targetName = GetOrCreatePinName(node.TargetPin.IncomingPin); builder.Append($"{targetName}."); } else { // Default to thise builder.Append("this."); } } // Write function call with arguments var argumentNames = GetPinIncomingValues(node.ArgumentPins); builder.AppendLine($"{node.MethodName}({string.Join(", ", argumentNames)});"); // Assign the real variables from the temporary tuple if (node.OutputDataPins.Count > 1) { var returnNames = GetOrCreatePinNames(node.OutputDataPins); for (int i = 0; i < returnNames.Count(); i++) { builder.AppendLine($"{returnNames.ElementAt(i)} = {temporaryReturnName}.Item{i+1};"); } } // Go to the next state WriteGotoOutputPin(node.OutputExecPins[0]); }
public void TranslateCallMethodNode(CallMethodNode node) { // Wrap in try/catch if we have a catch handler if (node.CatchPin.OutgoingPin != null) { builder.AppendLine("try"); builder.AppendLine("{"); } string temporaryReturnName = null; // Translate all the pure nodes this node depends on in // the correct order TranslateDependentPureNodes(node); // Write assignment of return values if (node.ReturnValuePins.Count == 1) { string returnName = GetOrCreatePinName(node.ReturnValuePins[0]); builder.Append($"{returnName} = "); } else if (node.OutputDataPins.Count > 1) { temporaryReturnName = TranslatorUtil.GetTemporaryVariableName(); var returnTypeNames = string.Join(", ", node.OutputDataPins.Select(pin => pin.PinType)); builder.Append($"{typeof(Tuple).FullName}<{returnTypeNames}> {temporaryReturnName} = "); } // Get arguments for method call var argumentNames = GetPinIncomingValues(node.ArgumentPins); // Check whether the method is an operator and we need to translate its name // into operator symbols. Otherwise just call the method normally. if (OperatorUtil.TryGetOperatorInfo(node.MethodSpecifier, out OperatorInfo operatorInfo)) { if (operatorInfo.Unary) { if (argumentNames.Count() != 1) { throw new Exception($"Unary operator was found but did not have one argument: {node.MethodName}"); } if (operatorInfo.UnaryRightPosition) { builder.AppendLine($"{argumentNames.ElementAt(0)}{operatorInfo.Symbol};"); } else { builder.AppendLine($"{operatorInfo.Symbol}{argumentNames.ElementAt(0)};"); } } else { if (argumentNames.Count() != 2) { throw new Exception($"Binary operator was found but did not have two arguments: {node.MethodName}"); } builder.AppendLine($"{argumentNames.ElementAt(0)}{operatorInfo.Symbol}{argumentNames.ElementAt(1)};"); } } else { // Static: Write class name / target, default to own class name // Instance: Write target, default to this if (node.IsStatic) { builder.Append($"{node.DeclaringType.FullCodeName}."); } else { if (node.TargetPin.IncomingPin != null) { string targetName = GetOrCreatePinName(node.TargetPin.IncomingPin); builder.Append($"{targetName}."); } else { // Default to this builder.Append("this."); } } // Write the method call builder.AppendLine($"{node.MethodName}({string.Join(", ", argumentNames)});"); } // Assign the real variables from the temporary tuple if (node.ReturnValuePins.Count > 1) { var returnNames = GetOrCreatePinNames(node.ReturnValuePins); for (int i = 0; i < returnNames.Count(); i++) { builder.AppendLine($"{returnNames.ElementAt(i)} = {temporaryReturnName}.Item{i+1};"); } } // Go to the next state WriteGotoOutputPin(node.OutputExecPins[0]); // Catch exceptions and execute catch pin if (node.CatchPin.OutgoingPin != null) { string exceptionVarName = TranslatorUtil.GetTemporaryVariableName(); builder.AppendLine("}"); builder.AppendLine($"catch (System.Exception {exceptionVarName})"); builder.AppendLine("{"); builder.AppendLine($"{GetOrCreatePinName(node.ExceptionPin)} = {exceptionVarName};"); WriteGotoOutputPin(node.CatchPin); builder.AppendLine("}"); } }