public virtual T Visit(WhileExpression expression) { expression.Condition.Accept(this); expression.Block.Accept(this); return(default(T)); }
public void GetAndEvaluateWhileExpression() { WhileExpression expression = WhileExpression.Instance; Assert.IsNotNull(expression); Machine machine = new Machine(); List <Expression> listcond = new List <Expression>(); listcond.Add(DupExpression.Instance); listcond.Add(new IntegerExpression(0)); listcond.Add(EqualsExpression.Instance); listcond.Add(NotExpression.Instance); List <Expression> listblock = new List <Expression>(); listblock.Add(IntegerDecrementOperation.Instance); CompositeExpression cond = new CompositeExpression(listcond); CompositeExpression block = new CompositeExpression(listblock); machine.Push(10); machine.Push(block); machine.Push(cond); expression.Evaluate(machine); Assert.AreEqual(1, machine.StackCount); Assert.IsInstanceOfType(machine.Top(), typeof(int)); Assert.AreEqual(0, machine.Pop()); }
public void ShouldRespectWhile() { ParameterExpression nbr = Expression.Variable(typeof(int), nameof(nbr)); ParameterExpression output = Expression.Parameter(typeof(List <int>), "output"); List <int> addedItems = new List <int>(); WhileExpression loop = X.While( Expression.LessThan(Expression.PostIncrementAssign(nbr), Expression.Constant(10)), Expression.Call(output, nameof(List <int> .Add), null, nbr) ); Expression .Lambda <Action <List <int> > >(Expression.Block(new[] { nbr }, loop), output) .Compile()(addedItems); addedItems.Count.ShouldBe(10); int index = 0; while (index++ < 10) { addedItems[index - 1].ShouldBe(index); } }
protected internal virtual Expression VisitWhileExpression(WhileExpression node) { return node.Update( Visit(node.Test), Visit(node.Body), node.BreakTarget, node.ContinueTarget); }
private CodeStatementCollection GenerateImperativeStatement(WhileExpression node) { var whileStmt = CodeHelper.While( GenerateImperativeExpression(node.Condition, isCondition: true), GenerateImperativeStatements(node.Body).OfType <CodeStatement>().ToArray()); return(new CodeStatementCollection(new[] { whileStmt })); }
protected override Expression VisitWhileExpression(WhileExpression expression) { this.Write("while ("); this.Visit(expression.Test); this.WriteLine(")"); this.Visit(expression.Body); return(expression); }
public int Visit(WhileExpression expression) { _writer.Write("while ("); expression.Condition.Accept(this); _writer.WriteLine(")"); expression.Block.Accept(this); return(0); }
Expression getWhile(Token token, Queue <Token> tokens) { var conditional = getCond(token, tokens.Peek(), tokens); var loop = new WhileExpression(conditional as ConditionalExpression); loop.data.parent = data; container.lines.Add(loop); containers.Push(loop); return(null); }
protected override void EmitWhileExpression(WhileExpression expression, bool isStatement = false) { Append("while ("); Emit(expression.Condition); Append(") {\r\n"); Indent(); Emit(expression.Body); Unindent(); Append("{0}}}\r\n", GetTabs()); }
public virtual Expression Visit(WhileExpression expression) { return(new WhileExpression( expression.Token, expression.Condition.Accept(this), (ScopeExpression)expression.Block.Accept(this)) { EndToken = expression.EndToken }); }
public static Result Run(WhileExpression block, Scope scope) { Result overall_result = Result.NULL; int i = 0; while (true) { bool condition_is_true; if (block.IsDoWhile && i == 0) { condition_is_true = true; } else { // Log.Debug (block.Condition); Result condition_result = Interpreters.Execute(block.Condition, scope); condition_is_true = condition_result.IsTrue(); } if (condition_is_true) { try { Result body_result = Interpreters.Execute(block.Body, scope); overall_result = body_result; } catch (BreakException ex) { // Log.Debug (ex); if (ex.CountOfLoops > 1) { throw new BreakException(ex.CountOfLoops - 1); } break; } catch (ContinueException ex) { // Log.Debug (ex); if (ex.CountOfLoops > 1) { throw new ContinueException(ex.CountOfLoops - 1); } } } else { break; } i++; } return(overall_result); }
public void Equals() { WhileExpression cmd1 = new WhileExpression(new ConstantExpression(1), new AssignExpression("one", new ConstantExpression(1))); WhileExpression cmd2 = new WhileExpression(new ConstantExpression(2), new AssignExpression("one", new ConstantExpression(1))); WhileExpression cmd3 = new WhileExpression(new ConstantExpression(1), new AssignExpression("one", new ConstantExpression(2))); WhileExpression cmd4 = new WhileExpression(new ConstantExpression(1), new AssignExpression("one", new ConstantExpression(1))); Assert.IsTrue(cmd1.Equals(cmd4)); Assert.IsTrue(cmd4.Equals(cmd1)); Assert.AreEqual(cmd1.GetHashCode(), cmd4.GetHashCode()); Assert.IsFalse(cmd1.Equals(null)); Assert.IsFalse(cmd1.Equals(123)); Assert.IsFalse(cmd1.Equals(cmd2)); Assert.IsFalse(cmd1.Equals(cmd3)); }
ExpressionType TranslateExpression(WhileExpression e) { ExpressionType eTest = TranslateExpression(e.Test); CheckInteger(e.Test.Pos, eTest); Env.LoopEnvironment.EnterLoop(); ExpressionType body = TranslateExpression(e.Body); if (body.Type != Types.Type._void) { Error.Report(e.Body.Pos, "While expression should return void"); } Exp eWhile = Translate.TranslateWhileExp(eTest.Exp, body.Exp, Env.LoopEnvironment.Done()); Env.LoopEnvironment.ExitLoop(); return(new ExpressionType(eWhile, Types.Type._void)); }
public void ExecuteSimpleWhileWhenConditionIsTrue() { Parser cmdparser = new Parser("a = a + 1"); IExpression body = cmdparser.ParseCommand(); Parser exprparser = new Parser("a < 6"); IExpression expr = exprparser.ParseExpression(); Context context = new Context(); context.SetLocalValue("a", 1); WhileExpression cmd = new WhileExpression(expr, body); Assert.IsNull(cmd.Evaluate(context)); Assert.AreEqual(6, context.GetValue("a")); }
public void ParseWhileCommandWithDo() { Parser cmdparser = new Parser("a = a + 1"); IExpression body = cmdparser.ParseCommand(); Parser exprparser = new Parser("a < 6"); IExpression expr = exprparser.ParseExpression(); Parser parser = new Parser("while a<6 do a=a+1; end"); IExpression expected = new WhileExpression(expr, body); var result = parser.ParseCommand(); Assert.IsNotNull(result); Assert.AreEqual(expected, result); Assert.IsNull(parser.ParseCommand()); }
public WhileExpression Visit(WhileExpression @while) { codeWriter.Write("while (", currentIndent); insideExpressionCount++; Visit(@while.Test); insideExpressionCount--; codeWriter.Write(") {"); codeWriter.NewLine(); currentIndent++; Visit(@while.Body); currentIndent--; codeWriter.Write("}", currentIndent); codeWriter.NewLine(); return(null); }
public string Visit(WhileExpression @while) { var codeWriter = new XzaarCodeWriter(); codeWriter.Write("while (", currentIndent); insideExpressionCount++; codeWriter.Write(Visit(@while.Test)); insideExpressionCount--; codeWriter.Write(") {"); codeWriter.NewLine(); currentIndent++; codeWriter.Write(Visit(@while.Body)); currentIndent--; codeWriter.Write("}", currentIndent); codeWriter.NewLine(); return(codeWriter.ToString()); }
public static WhileExpression Create( AphidExpressionContext context_aphidExpressionContext, AphidExpression condition_aphidExpression, List <AphidExpression> body_list, int value_i, int value_i1 ) { WhileExpression whileExpression = new WhileExpression (context_aphidExpressionContext, condition_aphidExpression, body_list); ((AphidExpression)whileExpression).Index = value_i; ((AphidExpression)whileExpression).Length = value_i1; return(whileExpression); // TODO: Edit factory method of WhileExpression // This method should be able to configure the object in all possible ways. // Add as many parameters as needed, // and assign their values to each field by using the API. }
[DebuggerStepThrough] protected virtual void EmitWhileExpression(WhileExpression expression, bool isStatement = false) { throw new NotImplementedException(); }
void PrintExpression(WhileExpression e, int d) { SayLn("WhileExpression("); PrintExpression(e.Test, d + 1); SayLn(","); PrintExpression(e.Body, d + 1); SayLn(")"); }
protected virtual Expression VisitWhile(WhileExpression node) { Visit(node.Test); Visit(node.Body); return(node); }
public object Visit(WhileExpression @while) { return(null); }
public object Visit(WhileExpression @while) { throw new System.NotImplementedException(); }
protected virtual Expression VisitWhileExpression(WhileExpression expression) { return(expression); }
public void evalExpression(Expression exp) { if (exp == null) { return; } if (exp is InstructionExpression) { evalInstruction((InstructionExpression)exp); return; } else if (exp is SequenceExpression) { SequenceExpression seqExp = (SequenceExpression)exp, seqTmp; Expression expTmp; int index = insertIndex; seqTmp = new SequenceExpression(new List <Expression>(seqExp.exps)); seqs.Add(seqExp); runningSeqs.Add(seqTmp); index = runningSeqs.Count - 1; while (seqTmp.exps.Count > 0) { expTmp = seqTmp.exps.ElementAt(0); evalExpression(expTmp); seqTmp.exps.RemoveAt(0); if (!shouldEvalSeq) { if (seqTmp.exps.Count == 0) { runningSeqs.RemoveAt(index); } return; } } runningSeqs.RemoveAt(runningSeqs.Count - 1); removeDeclaredVariables(seqs.ElementAt(seqs.Count - 1).declaredVariables()); seqs.RemoveAt(seqs.Count - 1); return; } else if (exp is IfExpression) { ifExp = (IfExpression)exp; o1 = evalSimpleExpression(ifExp.condition); if ((bool)o1.value) { evalExpression(ifExp.body); return; } if (ifExp.elseIfList != null) { foreach (ElseIfExpression elseIfExp in ifExp.elseIfList) { o1 = evalSimpleExpression(elseIfExp.condition); if ((bool)o1.value) { evalExpression(elseIfExp.corps); return; } } } if (ifExp.elseBlock != null) { evalExpression(ifExp.elseBlock.body); return; } return; } else if (exp is SwitchExpression) { switchExp = (SwitchExpression)exp; o1 = evalSimpleExpression(switchExp.exp); foreach (SwitchCaseExpression sce in switchExp.cases) { if (sce is CaseExpression) { if (o1.type == ObjectType.stringType && isCatched((string)o1.value, sce, false)) { return; } else if (o1.type == ObjectType.intType && isCatched((int)o1.value, sce, false)) { return; } } else if (sce is DefaultExpression) { evalExpression(((DefaultExpression)sce).body); return; } } return; } else if (exp is WhileExpression) { whileExp = (WhileExpression)exp; while (true) { o1 = evalSimpleExpression(whileExp.condition); if (!(bool)o1.value) { return; } evalExpression(whileExp.body); } } else if (exp is DoWhileExpression) { doWhileExp = (DoWhileExpression)exp; do { evalExpression(doWhileExp.body); o1 = evalSimpleExpression(doWhileExp.condition); if (!(bool)o1.value) { return; } } while (true); } else if (exp is ForExpression) { forExp = (ForExpression)exp; evalExpression(forExp.init); while (true) { o1 = evalSimpleExpression(forExp.condition); if (!(bool)o1.value) { return; } evalExpression(forExp.body); evalExpression(forExp.maj); } } }
protected override void EmitWhileExpression(WhileExpression expression, bool isStatement = false) => EmitWhileExpression(expression.Condition, expression.Body);