protected override Value Invoke() { Value exprV = expression.Evaluate(); if (exprV.Type != ValType.Boolean) { throw new CompilerException(Line, 217, "condition", "IF", "Boolean", exprV.TypeString); } while (expression.Evaluate().BoolValue) { Value returnValue = block.Evaluate(); if (returnValue != Value.VOID) { if (returnValue == Value.BREAK) { return(Value.VOID); } else if (returnValue.Type == ValType.Return) { // return early from this block if value is a return statement return(returnValue.ReturnValue); } } } return(Value.VOID); }
public Boolean RunTest() { try { GlobalMemory.Clear(); var sStream = new ANTLRStringStream(input); var lexer = new SGLLexer(sStream); var tStream = new CommonTokenStream(lexer); // Parsing var parser = new SGLParser(tStream); var t = (CommonTree)parser.main().Tree; // Printing tree Console.WriteLine("; " + t.ToStringTree()); // TreeWalking var treeStream = new CommonTreeNodeStream(t); var tw = new SGLTreeWalker(treeStream, true); AbstractNode returned = tw.main(); returned.Evaluate(); if (debug) { realOutput = GlobalMemory.Instance.DebugString; } else { realOutput = GlobalMemory.Instance.StoryboardCode.ToString(); } // comparison realOutput = realOutput.Trim(); output.Trim(); if (output.Equals(realOutput)) { return(true); } else { return(false); } } catch (CompilerException ce) { Console.WriteLine(ce.GetExceptionAsString()); return(false); } catch (Exception ex) { Console.WriteLine("Es ist ein Fehler aufgetreten."); Console.WriteLine(ex.Message); Console.WriteLine(ex.StackTrace); return(false); } }
private NodeStates EvaluateFromIndex(int startingIndex) { for (int i = startingIndex; i < nodes.Length; i++) { AbstractNode node = nodes[i]; switch (node.Evaluate()) { //if a node returns running set currentRunningNodeIndex to that nodes index in the child list case NodeStates.RUNNING: currentRunningNodeIndex = i; NodeState = NodeStates.RUNNING; return(NodeState); //if a node returns success reset currentRunningNodeIndex case NodeStates.SUCCESS: currentRunningNodeIndex = -1; NodeState = NodeStates.SUCCESS; return(NodeState); case NodeStates.FAILURE: break; } } //if all nodes returns failure reset currentRunningNodeIndex currentRunningNodeIndex = -1; NodeState = NodeStates.FAILURE; return(NodeState); }
protected override Value Invoke() { Value value = expression.Evaluate(); var indexValues = new List <Value>(); foreach (AbstractNode indexNode in indexes) { indexValues.Add(indexNode.Evaluate()); } foreach (Value index in indexValues) { if (!index.TypeEquals(ValType.Integer)) { throw new CompilerException(Line, 214, index.TypeString); } else if (value.Type != ValType.List /* || value.IsString()*/) { throw new CompilerException(Line, 215, value.TypeString); } int idx = index.IntValue; value = value.ListValue[idx]; } return(value); }
protected override Value Invoke() { Value value1 = node1.Evaluate(); Value value2 = node2.Evaluate(); Value value3 = node3.Evaluate(); ValType type1 = value1.Type; ValType type2 = value2.Type; ValType type3 = value3.Type; if (CheckArguments(type1, type2, type3)) { try { return(Operate(value1, value2, value3, type1, type2, type3)); } catch (CompilerException sce) { // Catch all CompilerExceptions and add the line number. sce.Line = Line; throw; } } else { throw new CompilerException(Line, 203, Name, value1.TypeString, value2.TypeString, value3.TypeString); } }
protected override Value Invoke() { Value exprV = expression == null ? Value.NULL : expression.Evaluate(); if (indexes.Count < 1) { // a simple assignment //scope.SetSpriteGenerators(SpriteGenerators); scope.Assign(name, exprV); } else { // a possible list-lookup and reassignment Value list = scope.Resolve(name); // iterate up to `foo[x][y]` in case of `foo[x][y][z] = 42;` for (int i = 0; i < indexes.Count - 1 && list != null; i++) { Value index = indexes[i].Evaluate(); if (!index.TypeEquals(ValType.Integer)) { throw new CompilerException(line, 212, (i + 1).ToString(), name, index.TypeString); } else if (list.Type != ValType.List) { throw new CompilerException(line, 213, name, (i).ToString(), list.TypeString); } int position = index.IntValue; list = list.ListValue[position]; } // list is now pointing to `foo[x][y]` in case of `foo[x][y][z] = 42;` // get the value `z`: the last index, in `foo[x][y][z] = 42;` Value idx = indexes[indexes.Count - 1].Evaluate(); if (!idx.TypeEquals(ValType.Integer)) { throw new CompilerException(line, 212, (indexes.Count).ToString(), name, idx.TypeString); } else if (list.Type != ValType.List) { throw new CompilerException(line, 213, name, (indexes.Count - 1).ToString(), list.TypeString); } // re-assign `foo[x][y][z]` List <Value> existing = list.ListValue; // add elements if the index is out of range while (idx.IntValue >= existing.Count) { existing.Add(Value.NULL); } existing[idx.IntValue] = exprV; } return(Value.VOID); }
protected override Value Invoke() { Value value = node.Evaluate(); return(Operate(value)); //throw new CompilerException(Line, 201, Name, value.TypeString); }
//public abstract bool CheckArguments(ValType type1, ValType type2); protected override Value Invoke() { Value value1 = node1.Evaluate(); Value value2 = node2.Evaluate(); return(Operate(value1, value2)); //throw new CompilerException(Line, 202, Name, value1.TypeString, value2.TypeString); }
protected override Value Invoke() { Value condValue = conditionNode.Evaluate(); if (condValue.Type != ValType.Boolean) { throw new CompilerException(Line, 206, condValue.TypeString); } return(condValue.BoolValue ? ifNode.Evaluate() : elseNode.Evaluate()); }
protected override Value Invoke() { Value exprV = expression.Evaluate(); if (exprV.TypeEquals(ValType.Integer)) { ((BlockNode)block).AddOffset(exprV.IntValue); // Execute the block return(block.Evaluate()); } else { throw new CompilerException(Line, 217, "offset", "AT", "Integer/Double", exprV.TypeString); } }
protected override Value Invoke() { /* * Console.WriteLine("init: " + init.Evaluate()); * Console.WriteLine("cond: " + condition.Evaluate()); * Console.WriteLine("iteration: " + iteration.Evaluate()); */ //Console.WriteLine("--------------------------------------"); for (EvaluateInit(); condition.Evaluate().BoolValue; iteration.Evaluate()) { block.Evaluate(); } return(Value.VOID); }
public override NodeStates Evaluate() { if (_constructed) { CalculatePlanValue(); CalculateRiskValue(); CalculateTimeInterval(); if (currentlyRunningNode != null) { switch (currentlyRunningNode.Evaluate()) { case NodeStates.RUNNING: NodeState = NodeStates.RUNNING; break; //if a node returns success reset currentlyRunningNode case NodeStates.SUCCESS: currentlyRunningNode = null; NodeState = NodeStates.SUCCESS; break; //if a node returns failure reset currentlyRunningNode case NodeStates.FAILURE: currentlyRunningNode = null; NodeState = NodeStates.FAILURE; break; } return(NodeState); } else { CalculateProbabilities(); float random = UnityEngine.Random.Range(0f, 1f); for (int i = 0; i < nodeProbabilities.Length; i++) { if (random < nodeProbabilities[i]) { NodeState = nodes[i].Evaluate(); if (NodeState == NodeStates.RUNNING) { currentlyRunningNode = nodes[i]; } break; } else { random -= nodeProbabilities[i]; } } return(NodeState); } } else { Debug.LogError("Node not constructed!"); return(NodeStates.FAILURE); } }
protected override Value Invoke() { Value exprVal = expression.Evaluate(); return(new Value(exprVal, ValType.Return)); }