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