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