private IList <Node> evaluateAggregate(Node node, ActivationFrame frame, Interpreter callback)
{
SummationType summationType = (SummationType)node.Instructions[0];
IList <Node> list = node.Instructions;
int size = list.Count;
int sum = 0;
IList <VariableNode> listOfVariableNodes = new List <VariableNode>();
for (int i = 1; i < size; i++)
{
if (node.Instructions[i] is VariableNode)
{
listOfVariableNodes.Add((VariableNode)node.Instructions[i]);
}
else
{
string value = ((FinalNode)list[i].Instructions[0]).dataString();
sum += Convert.ToInt32(value);
}
}
if (listOfVariableNodes.Count > 0)
{
sum += aggregateVariable(listOfVariableNodes, frame);
}
FinalNode returnNode = new FinalNode();
returnNode.DataString = sum;
frame.pushReturnNode(returnNode);
return(new List <>());
}
public virtual void evaluateExpressionStack()
{
Node @operator = null;
if (operatorStack.Count == 0)
{
throw new Exception("not operators on stack");
}
@operator = operatorStack.Pop();
//TODO ensure the type is accurate.
//assert false : "this needs to fail until i fix it";
if (@operator.Type.Equals(NodeType.EqualEqualType) && operandStack.Count >= 2)
{
NodeImpl r = (NodeImpl)operandStack.Pop();
NodeImpl l = (NodeImpl)operandStack.Pop();
ActivationFrame frame = activationFrameStack.peek();
object rReal = r.getRealValue(frame);
object lreal = l.getRealValue(frame);
bool equalEqualEval = rReal.Equals(lreal);
BooleanNode booleanNode = new BooleanNode();
FinalNode finalNode = new FinalNode();
finalNode.DataString = equalEqualEval;
booleanNode.addInst(finalNode);
operandStack.Push(booleanNode);
}
}
public virtual void pushOperatorStack(Node node)
{
if (operatorStack.Count == 0)
{
operatorStack.Push(node);
}
else
{
FinalNode currentOperand = (FinalNode)operatorStack.Peek();
int currentNodePrecedence = getOperatorPrecedenceValue(currentOperand);
int newNodePrecedence = getOperatorPrecedenceValue((FinalNode)node);
SrEval eval = operatorPrecedenceTable.shiftReduceOperationTable[currentNodePrecedence][newNodePrecedence];
if (eval == SrEval.Shift)
{
operatorStack.Push(node);
return;
}
if (eval == SrEval.Reduce)
{
if (operandStack.Count >= 2)
{
Node rValue = operandStack.Pop();
Node lValue = operandStack.Pop();
Node operation = operatorStack.Pop();
evalBooleanOperation(operation, lValue, rValue);
// Need to Evaluate the operation.
// Create a new node?
}
}
}
}
private int aggregateVariable(IList <VariableNode> variableNodeList, ActivationFrame frame)
{
int sum = 0;
for (int i = 0; i < variableNodeList.Count; i++)
{
Node v = frame.variableSet[variableNodeList[i].variableName];
FinalNode finalNode = null;
if (v is FinalNode && v.Instructions.Count == 0)
{
finalNode = (FinalNode)v;
}
if (v is PrimitiveNode)
{
PrimitiveNode primitiveNode = (PrimitiveNode)v;
finalNode = (FinalNode)primitiveNode.Instructions[0];
}
if (finalNode != null)
{
sum += Convert.ToInt32(finalNode.dataString());
}
}
return(sum);
}
public override Node visitEndLine(JuliarParser.EndLineContext ctx)
{
FinalNode finalNode = new FinalNode();
new IterateOverContext(this, ctx, this, finalNode);
return(finalNode);
}
public virtual bool canLiteralBeAssigned <T>(KeywordNode keyword, T t) where T : NodeImpl
{
if (keyword.Instructions[0] is FinalNode)
{
FinalNode finalNode = (FinalNode)keyword.Instructions[0];
string dataType = finalNode.dataString();
string rvalueDataString = ((FinalNode)t.Instructions.get(0)).dataString();
switch (finalNode.IntegralType)
{
case jinteger:
{
try
{
Convert.ToInt32(rvalueDataString);
}
catch (NumberFormatException)
{
throw new Exception("invalid r-Value");
}
return(true);
}
}
}
return(false);
}
internal PropertyPathWalker(string path, bool isDatacontextBound)
{
_path = path;
_isDataContextBound = isDatacontextBound;
if (_isDataContextBound)
{
_firstNode = new DependencyPropertyNode(FrameworkElement.DataContextProperty);
}
ParsePath(_path, out IPropertyPathNode head, out IPropertyPathNode tail);
if (_firstNode == null)
{
_firstNode = head ?? new StandardPropertyPathNode();
}
else
{
_firstNode.Next = head;
}
FinalNode = tail ?? _firstNode;
FinalNode.Listen(this);
}
public static string sysExec(Node argumentNode)
{
if (argumentNode is FinalNode)
{
FinalNode finalNode = (FinalNode)argumentNode;
return(com.juliar.pal.Primitives.sysExec(finalNode.dataString()));
}
return("");
}
private static string fileOpen(Node argumentNode)
{
if (argumentNode is FinalNode)
{
FinalNode finalNode = (FinalNode)argumentNode;
return(sysFileOpen(finalNode.dataString()));
}
return("");
}
public static bool canPrimitiveValueBeAssignedToVar(VariableDeclarationNode lvalue, PrimitiveNode rvalue)
{
FinalNode rvalueTerminal = (FinalNode)rvalue.Instructions[0];
VariableNode variableNode;
if (juserDefined == lvalue.IntegralType)
{
variableNode = lvalue.UserDefinedNode.VariableNode;
}
else
{
variableNode = (VariableNode)lvalue.Instructions[1];
}
string data = rvalueTerminal.dataString();
try
{
switch (variableNode.IntegralType)
{
case jinteger:
return(true);
case jdouble:
return(true);
case jfloat:
return(true);
case jlong:
return(true);
case jstring:
return(true);
case jobject:
return(false);
case jboolean:
return(Convert.ToBoolean(data));
case juserDefined:
return(true);
default:
return(false);
}
}
catch (NumberFormatException)
{
return(false);
}
}
private IList <Node> evalIfStatement(Node node, ActivationFrame frame, Interpreter callback)
{
IList <Node> instructionList = node.Instructions;
int size = instructionList.Count;
IList <Node> trueExpressions = new List <Node>();
BooleanNode booleanNode = getBooleanExpressionNode(instructionList, size, trueExpressions);
if (booleanNode != null && booleanNode.Instructions.Count == 1)
{
FinalNode finalNode = (FinalNode)booleanNode.Instructions[0];
if (finalNode.IntegralType == IntegralType.jboolean)
{
bool? @bool = Convert.ToBoolean(finalNode.dataString());
if (@bool)
{
return(trueExpressions);
}
}
}
else if (booleanNode != null && booleanNode.Instructions.Count > 0)
{
Node currentValue = frame.popNode();
frame.pushReturnNode(null);
bool?booleanResult = false;
evalBooleanNode(booleanNode, frame, callback);
if (frame.peekReturnNode() != null && frame.peekReturnNode() is BooleanNode)
{
Node booleanEvalReturnNode = frame.popNode();
FinalNode result = getFinalNodeFromAnyNode(booleanEvalReturnNode);
booleanResult = Convert.ToBoolean(result.dataString());
}
// TODO - FINISH THIS
if (booleanResult && frame.peekReturnNode() != null)
{
Node returnNode = frame.popNode();
if (returnNode is BreakExprNode)
{
IList <Node> returnList = new List <Node>();
returnList.Add(returnNode);
return(new List <>());
}
}
frame.pushReturnNode(currentValue);
}
return(new List <>());
}
public FinalNode RecreateChildrenAsFinal()
{
ActiveChild curr = this.LastChild;
FinalNode newCurr = null;
while (curr != null)
{
newCurr = new FinalNode(curr.Info, curr.Child, newCurr);
curr = curr.PrevChild;
}
return(newCurr);
}
public static IList <Node> evalPrimitives(Node n, ActivationFrame activationFrame, Interpreter calback)
{
string functionName = ((FinalNode)n.Instructions[0]).dataString();
FinalNode finalNode = new FinalNode();
switch (functionName)
{
case "print":
printLine(activationFrame, functionName, n.Instructions[2]);
break;
case "__getByteFromString":
getByteFromString(activationFrame, n.Instructions[1], n.Instructions[2]);
break;
case "printLine":
printLine(activationFrame, functionName, n.Instructions[1]);
break;
case "fileOpen":
string data = fileOpen(n.Instructions[2]);
finalNode.DataString = data;
finalNode.VariableTypeByIntegralType = IntegralType.jstring;
activationFrame.pushReturnNode(finalNode);
//activationFrame.returnNode = finalNode;
break;
case "sysExec":
string ex = sysExec(n.Instructions[2]);
finalNode.DataString = ex;
finalNode.VariableTypeByIntegralType = IntegralType.jstring;
activationFrame.pushReturnNode(finalNode);
//activationFrame.returnNode = finalNode;
break;
case "availableMemory":
long value = availableMemory();
finalNode.DataString = value;
finalNode.VariableTypeByIntegralType = IntegralType.jlong;
activationFrame.pushReturnNode(finalNode);
//activationFrame.returnNode = finalNode;
break;
default:
JuliarLogger.log("function " + functionName + " does not exist");
break;
}
return(new List <>());
}
public static void commandInstance(CommandNode commandNode, ActivationFrame activationFrame, VariableDeclarationNode variableToAssignTo)
{
IList <Node> slotList = new List <Node>();
slotList.Add(commandNode);
interpreterCallback.execute(slotList);
FinalNode variableNameTerminalNode = (FinalNode)variableToAssignTo.Instructions[1].Instructions[0];
string variableName = variableNameTerminalNode.dataString();
if (activationFrame.variableSet.ContainsKey(variableName))
{
activationFrame.variableSet.Remove(variableName);
}
activationFrame.variableSet[variableName] = activationFrame.peekReturnNode();
//activationFrame.returnNode = null;
}
protected void Teardown()
{
// Only dispose the dispatcher if it was created here.
if (_hasLocalDispatcher)
{
// We are here because the FinalNode's ExitBehavior is running on the Dispatcher.
// Attempting to dispose of the Dispatcher from the final executable using the Dispatcher's
// own thread will cause the Dispatcher to kill (abort) it's thread.
// That thread abort can be avoided by giving the Dispatcher cleanup to a different thread,
// which allows the currently executing ExitBehavior to finish cleanly first.
Task.Factory.StartNew(() =>
{
LogService.Log(LogType, LogMessageType.Debug, GetType().Name, "Waiting for local dispatcher '" + Name + "' to be empty.");
_dispatcher.WaitUntilDone();
LogService.Log(LogType, LogMessageType.Debug, GetType().Name, "'" + Name + "' is disposing.");
// We are now completely done with the dispatcher.
_dispatcher.Dispose();
_dispatcher = null;
});
}
try
{
_finishedEvent.Dispose();
}
catch (ObjectDisposedException)
{
// reset event was disposed
}
//Dispose the UML nodes
DisposeNodes(InitialNode);
if (FinalNode != null)
{
// THIS MAY BE A PROBLEM if SimpleDispatcher is made to dispose IExecutables after executing them.
FinalNode.Dispose();
}
Dispose();
}
private int getOperatorPrecedenceValue(FinalNode node)
{
int precedence = -1;
string dataString = node.dataString();
switch (dataString)
{
case "*":
case "/":
case "%":
precedence = 7;
break;
case "+":
case "-":
precedence = 0;
break;
case "(":
precedence = 9;
break;
case ")":
precedence = 10;
break;
case "==":
precedence = 13;
break;
case "&&":
precedence = 14;
break;
case "||":
precedence = 15;
break;
}
return(precedence);
}
private static void getByteFromString(ActivationFrame activationFrame, Node argumentNode, Node index)
{
string variableName = ((VariableNode)argumentNode).variableName;
object variable = activationFrame.variableSet[variableName];
if (variable is FinalNode)
{
char[] array = sysGetByteFromString(((FinalNode)variable).dataString());
FinalNode finalNode = new FinalNode();
string argTwoVariableName = ((VariableNode)index).variableName;
object argTwo = activationFrame.variableSet[argTwoVariableName];
FinalNode argumentTwo = null;
if (argTwo is PrimitiveNode)
{
argumentTwo = (FinalNode)activationFrame.variableSet[argTwoVariableName].Instructions[0];
}
else if (argTwo is FinalNode)
{
argumentTwo = (FinalNode)activationFrame.variableSet[argTwoVariableName];
}
assert(argumentTwo != null ? argumentTwo.dataString() : null) != null;
int parsedIndex = Convert.ToInt32(argumentTwo.dataString());
if (parsedIndex > array.Length)
{
throw new Exception("\r\nJuliar runtime exception - Index out of bounds accessing variable - '" + variableName + "'");
}
if (parsedIndex < array.Length)
{
finalNode.DataString = array[parsedIndex];
activationFrame.pushReturnNode(finalNode);
//activationFrame.returnNode = finalNode;
}
}
}
public static void primitiveInstance(PrimitiveNode primitiveNode, ActivationFrame activationFrame, VariableDeclarationNode variableToAssignTo)
{
if (canPrimitiveValueBeAssignedToVar(variableToAssignTo, primitiveNode))
{
string variableName;
if (variableToAssignTo.IntegralType == juserDefined)
{
variableName = variableToAssignTo.UserDefinedNode.FullyQualifiedVariableName;
}
else
{
FinalNode variableNameTerminalNode = (FinalNode)variableToAssignTo.Instructions[1].Instructions[0];
variableName = variableNameTerminalNode.dataString();
}
if (activationFrame.variableSet.ContainsKey(variableName))
{
activationFrame.variableSet.Remove(variableName);
}
activationFrame.variableSet[variableName] = primitiveNode;
}
}
private IList <Node> evalBooleanNode(Node node, ActivationFrame frame, Interpreter callback)
{
Node variableType = node.Instructions[0];
if (node is BooleanOperatorNode)
{
// ((BooleanOperatorNode)node).evaluateExpression( frame , this);
}
try
{
Node lvalue = null;
if (variableType is VariableNode)
{
string variableName = ((VariableNode)node.Instructions[0]).variableName;
lvalue = frame.variableSet[variableName];
}
else
{
lvalue = variableType;
}
bool isEqualEqual;
Node rvalue = null;
// This is ugly code. Need to find a better way to
// handle these cases.
// Multiple ifs will only cause confusion.
FinalNode updatedLvalue = null;
/*
* if (node.getInstructions().size() == 1) {
* //lvalue must be a single boolean expression
* if (lvalue instanceof FinalNode) {
* BooleanNode booleanNode = new BooleanNode();
* booleanNode.addInst(lvalue);
* frame.pushReturnNode( booleanNode );
* return new ArrayList<>();
* }
*
* if (lvalue instanceof PrimitiveNode) {
* updatedLvalue = (FinalNode) lvalue.getInstructions().get(0);
* }
*
* } else if (node.getInstructions().size() > 1) {
* //if (booleanOperatorNode.getInstructions().get(0) instanceof EqualEqualSignNode) {
* //isEqualEqual;
* //}
* rvalue = node.getInstructions().get(2);
* FinalNode updatedRvalue = null;
* if (rvalue != null && rvalue instanceof PrimitiveNode) {
* updatedRvalue = (FinalNode) rvalue.getInstructions().get(0);
* }
*
* if (updatedLvalue != null) {
* lvalue = updatedLvalue;
* }
*
* if (updatedRvalue != null) {
* rvalue = updatedRvalue;
* }
*
* isEqualEqual = getFinalNodeFromAnyNode( lvalue) .dataString().equals( getFinalNodeFromAnyNode(rvalue).dataString());
* //else if (booleanOperatorNode.getInstructions().get(0) instanceof )
* FinalNode finalNode = new FinalNode();
* finalNode.setDataString(isEqualEqual);
*
* BooleanNode booleanNode = new BooleanNode();
* booleanNode.addInst(finalNode);
*
* frame.pushReturnNode( booleanNode );
* return new ArrayList<>();
* }
*/
}
catch (Exception ex)
{
JuliarLogger.log(ex.Message);
}
return(new List <>());
}
public ActiveChild(T info, FinalNode child, ActiveChild prevChild)
: base(info)
{
this.Child = child;
this.PrevChild = prevChild;
}
public FinalNode(T info, FinalNode child, FinalNode nextChild)
: base(info)
{
this.Child = child;
this.NextChild = nextChild;
}
private static void printLine(ActivationFrame activationFrame, string functionName, Node argumentNode)
{
FinalNode finalNode = null;
if (argumentNode == null)
{
if (activationFrame.peekReturnNode() != null)
{
//argumentNode = activationFrame.returnNode;
argumentNode = activationFrame.popNode();
}
}
switch (argumentNode.Type)
{
case LiteralType:
finalNode = (FinalNode)argumentNode.Instructions[0];
break;
case VariableType:
string variableName = ((VariableNode)argumentNode).variableName;
Node tempVariableNode = activationFrame.variableSet[variableName];
if (tempVariableNode == null)
{
// a variable has been declared and not initazlized
finalNode = new FinalNode();
break;
}
if (tempVariableNode is VariableNode)
{
string name = ((VariableNode)tempVariableNode).variableName;
if (activationFrame.variableSet.ContainsKey(name))
{
finalNode = (FinalNode)activationFrame.variableSet[name].Instructions[0];
}
}
else
{
printLine(activationFrame, functionName, tempVariableNode);
return;
}
break;
case FinalType:
finalNode = (FinalNode)argumentNode;
break;
}
if (finalNode == null)
{
dumpFrameVariables(activationFrame);
Debug.Assert(finalNode != null, "the final node cannot be null");
}
string stringToPrint = finalNode.dataString();
if (functionName.Equals("printLine"))
{
sysPrintLine(stringToPrint);
return;
}
if (functionName.Equals("print"))
{
sysPrint(stringToPrint);
return;
}
}
/// <summary/>
public Material()
{
Nodes = new MaterialNodeCollection();
FinalNode = new FinalNode();
}
/// <summary>
/// Распарсить XMI файл и создать объекты соответствующих классов
/// </summary>
/// <param name="diagram">Исходная диаграмма</param>
/// <param name="hasJoinOrFork">Имеется ли join\fork</param>
/// <returns></returns>
public bool Parse(Diagram diagram, ref bool hasJoinOrFork)
{
xmlFile = diagram.doc;
XmlNodeList xPackagedList;
try {
xPackagedList = xmlFile.GetElementsByTagName("packagedElement");
} catch (NullReferenceException) {
//Console.WriteLine("[x] Тег packagedElement не найден");
return(false);
}
// получим корневой элемент
XmlNode xRoot = FindActivePackageEl(xPackagedList);
if (xRoot == null)
{
//Console.WriteLine("[x] Вид диаграммы не AD");
return(false);
}
var attr = xRoot.Attributes["xsi:type"];
if (attr == null)
{
//Console.WriteLine("[x] Не удалось распарсить xmi файл");
return(false);
}
if (!attr.Value.Equals("uml:Activity"))
{
//Console.WriteLine("[x] Вид диаграммы не AD");
return(false);
}
// пройтись по всем тегам и создать объекты
foreach (XmlNode node in xRoot.ChildNodes)
{
var elAttr = node.Attributes["xsi:type"];
if (elAttr == null)
{
continue;
}
if (elAttr.Value == "uml:OpaqueAction" || elAttr.Value == "uml:InitialNode" || elAttr.Value == "uml:ActivityFinalNode" ||
elAttr.Value == "uml:FlowFinalNode" || elAttr.Value == "uml:DecisionNode" || elAttr.Value == "uml:MergeNode" ||
elAttr.Value == "uml:ForkNode" || elAttr.Value == "uml:JoinNode")
{
DiagramElement nodeFromXMI = null;
switch (elAttr.Value)
{
// активность
case "uml:OpaqueAction":
nodeFromXMI = new ActivityNode(node.Attributes["xmi:id"].Value,
AttrAdapter(node.Attributes["inPartition"]), AttrAdapter(node.Attributes["name"]));
nodeFromXMI.setType(ElementType.ACTIVITY);
adNodesList.addLast(nodeFromXMI);
break;
// узел инициализации
case "uml:InitialNode":
nodeFromXMI = new InitialNode(node.Attributes["xmi:id"].Value, AttrAdapter(node.Attributes["inPartition"]));
nodeFromXMI.setType(ElementType.INITIAL_NODE);
adNodesList.addLast(nodeFromXMI);
break;
// конечное состояние
case "uml:ActivityFinalNode":
case "uml:FlowFinalNode":
nodeFromXMI = new FinalNode(node.Attributes["xmi:id"].Value, AttrAdapter(node.Attributes["inPartition"]));
nodeFromXMI.setType(ElementType.FINAL_NODE);
adNodesList.addLast(nodeFromXMI);
break;
// условный переход
case "uml:DecisionNode":
nodeFromXMI = new DecisionNode(node.Attributes["xmi:id"].Value, AttrAdapter(node.Attributes["inPartition"]), AttrAdapter(node.Attributes["question"]));
nodeFromXMI.setType(ElementType.DECISION);
adNodesList.addLast(nodeFromXMI);
break;
// узел слияния
case "uml:MergeNode":
nodeFromXMI = new MergeNode(node.Attributes["xmi:id"].Value, AttrAdapter(node.Attributes["inPartition"]));
nodeFromXMI.setType(ElementType.MERGE);
adNodesList.addLast(nodeFromXMI);
break;
// разветвитель
case "uml:ForkNode":
nodeFromXMI = new ForkNode(node.Attributes["xmi:id"].Value, AttrAdapter(node.Attributes["inPartition"]));
nodeFromXMI.setType(ElementType.FORK);
adNodesList.addLast(nodeFromXMI);
hasJoinOrFork = true;
break;
// синхронизатор
case "uml:JoinNode":
nodeFromXMI = new JoinNode(node.Attributes["xmi:id"].Value, AttrAdapter(node.Attributes["inPartition"]));
nodeFromXMI.setType(ElementType.JOIN);
adNodesList.addLast(nodeFromXMI);
hasJoinOrFork = true;
break;
}
// добавляем ид входящих и выходящих переходов
if (nodeFromXMI != null)
{
string idsIn = node.Attributes["incoming"]?.Value;
string idsOut = node.Attributes["outgoing"]?.Value;
nodeFromXMI.addIn(idsIn ?? "");
nodeFromXMI.addOut(idsOut ?? "");
}
}
// создаем переход
else if (node.Attributes["xsi:type"].Value.Equals("uml:ControlFlow"))
{
// находим подпись перехода
var markNode = node.ChildNodes[1];
string mark = markNode.Attributes["value"].Value.Trim(); // если подпись является "yes", значит это подпись по умолчанию
ControlFlow temp = new ControlFlow(node.Attributes["xmi:id"].Value, mark.Equals("true") ? "" : mark);
temp.setType(ElementType.FLOW);
temp.setSrc(AttrAdapter(node.Attributes["source"]));
temp.setTarget(AttrAdapter(node.Attributes["target"]));
adNodesList.addLast(temp);
}
// создаем дорожку
else if (node.Attributes["xsi:type"].Value.Equals("uml:ActivityPartition"))
{
Swimlane temp = new Swimlane(node.Attributes["xmi:id"].Value, AttrAdapter(node.Attributes["name"]))
{
ChildCount = node.Attributes["node"] == null ? 0 : node.Attributes["node"].Value.Split().Length
};
temp.setType(ElementType.SWIMLANE);
if (temp.Name != "")
{
diagram.Actors.Add(temp);
}
adNodesList.addLast(temp);
}
// неизвестный элемент
else
{
var unknownNode = new UnknownNode(node.Attributes["xmi:id"].Value);
unknownNode.setType(ElementType.UNKNOWN);
unknownNodes.Add(unknownNode);
}
}
XmlNode coordRoot = null;
try {
coordRoot = xmlFile.GetElementsByTagName("plane")[0];
} catch (NullReferenceException) {
//Console.WriteLine("[x] Тег packagedElement не найден");
}
if (coordRoot != null)
{
FindCoordinates(coordRoot, diagram);
}
for (int i = 0; i < adNodesList.size(); i++)
{
var node = adNodesList.get(i);
if (node is DiagramElement)
{
var nodeFromXMI = (DiagramElement)node;
switch (nodeFromXMI.getType())
{
case ElementType.FINAL_NODE:
if (nodeFromXMI.inSize() == 0)
{
// ошибка
ADMistakeFactory.createMistake(MistakesSeriousness.mistakes[MISTAKES.NO_IN], MistakeAdapter.toString(MISTAKES.NO_IN), new ADNodesList.ADNode(nodeFromXMI), ALL_MISTAKES.NO_IN);
}
break;
case ElementType.INITIAL_NODE:
if (nodeFromXMI.outSize() == 0)
{
// ошибка
ADMistakeFactory.createMistake(MistakesSeriousness.mistakes[MISTAKES.NO_OUT], MistakeAdapter.toString(MISTAKES.NO_OUT), new ADNodesList.ADNode(nodeFromXMI), ALL_MISTAKES.NO_OUT);
}
break;
default:
if (nodeFromXMI.inSize() == 0 || nodeFromXMI.outSize() == 0)
{
// ошибка
if (nodeFromXMI.inSize() == 0)
{
ADMistakeFactory.createMistake(MistakesSeriousness.mistakes[MISTAKES.NO_IN], MistakeAdapter.toString(MISTAKES.NO_IN), new ADNodesList.ADNode(nodeFromXMI), ALL_MISTAKES.NO_IN);
}
if (nodeFromXMI.outSize() == 0)
{
ADMistakeFactory.createMistake(MistakesSeriousness.mistakes[MISTAKES.NO_OUT], MistakeAdapter.toString(MISTAKES.NO_OUT), new ADNodesList.ADNode(nodeFromXMI), ALL_MISTAKES.NO_OUT);
}
}
break;
}
}
}
// ошибка - тип элемента не принадлежит AD
foreach (var node in unknownNodes)
{
ADMistakeFactory.createMistake(MistakesSeriousness.mistakes[MISTAKES.FORBIDDEN_ELEMENT], MistakeAdapter.toString(MISTAKES.FORBIDDEN_ELEMENT), node, ALL_MISTAKES.FORBIDDEN_ELEMENT);
}
return(true);
}
public IntegralTypeNode(FinalNode terminalNode, string name)
{
objectData = terminalNode;
integralName = name;
}
public static IList <Node> evalFunctionCall(Node node, ActivationFrameStack activationFrame, string mainFunctionName, IDictionary <string, Node> functionNodeMap, Interpreter callback)
{
FunctionCallNode functionCallNode = (FunctionCallNode)node;
string functionToCall = functionCallNode.functionName();
//ActivationFrame evalFrame = activationFrameStack.pop();
bool isPrimitive = EvaluatePrimitives.evalIfPrimitive(node, activationFrame.peek(), callback);
//activationFrameStack.push( evalFrame );
if (isPrimitive)
{
return(new List <>());
}
// main should only be called from the compliationUnit
if (functionCallNode.Equals(mainFunctionName))
{
return(new List <>());
}
FunctionDeclNode functionDeclNode = (FunctionDeclNode)functionNodeMap[functionToCall];
if (functionDeclNode != null)
{
ActivationFrame frame = new ActivationFrame();
frame.frameName = functionToCall;
IList <VariableNode> sourceVariables = new List <VariableNode>();
IList <VariableDeclarationNode> targetVariables = new List <VariableDeclarationNode>();
foreach (Node v in node.Instructions)
{
if (v is VariableNode)
{
sourceVariables.Add((VariableNode)v);
}
}
foreach (Node v in functionDeclNode.Instructions)
{
if (v is VariableDeclarationNode)
{
targetVariables.Add((VariableDeclarationNode)v);
}
}
if (sourceVariables.Count != targetVariables.Count)
{
throw new Exception("Source and target variable count do not match");
}
// since the function that is getting called can reference the variable using the
// formal parameters of the function this code will match the calling functions data
// with the target calling functions variable name.
for (int i = 0; i < sourceVariables.Count; i++)
{
VariableNode variableNode = (VariableNode)targetVariables[0].Instructions[1];
if (variableNode.integralTypeNode == sourceVariables[i].integralTypeNode)
{
frame.variableSet[variableNode.variableName] = activationFrame.peek().variableSet[sourceVariables[i].variableName];
}
else
{
throw new Exception("data types are not the same");
}
}
activationFrame.push(frame);
IList <Node> statements = getFunctionStatements(functionDeclNode.Instructions);
callback.execute(statements);
activationFrame.pop();
//activationFrame.push(frame);
//execute(functionDeclNode.getInstructions());
return(new List <Node>());
}
else
{
FinalNode primitiveArg = new FinalNode();
primitiveArg.DataString = functionToCall;
PrimitiveNode primitiveNode = new PrimitiveNode();
primitiveNode.addInst(primitiveArg);
foreach (Node primArgs in node.Instructions)
{
if (primArgs is VariableNode || primArgs is IntegralTypeNode)
{
primitiveNode.addInst(primArgs);
}
}
return(EvaluatePrimitives.evalPrimitives(primitiveNode, activationFrame.peek(), callback));
}
}
