public void visit(WhileCommand that) { Console.Write("while ("); that.Expression.visit(this); Console.WriteLine(")"); that.Command.visit(this); }
// Use this for initialization void Start() { Button btn = leftButton.GetComponent <Button>(); Button btn1 = rightButton.GetComponent <Button>(); Button btn2 = upButton.GetComponent <Button>(); Button btn3 = downButton.GetComponent <Button>(); Button btn4 = whileButton.GetComponent <Button>(); Button btn5 = methodButton.GetComponent <Button>(); // methodContainer = GameObject.Find("methodContainer"); commandList = new List <string>(); whileList = new List <string>(); methodList = new List <string>(); jaggedWhileList = new List <List <string> >(); //whileActive = false; whileInstance = GetComponent <WhileCommand>(); methodInstance = GetComponent <MethodCommand>(); btn.onClick.AddListener(TaskOnClick); btn1.onClick.AddListener(TaskOnClick); btn2.onClick.AddListener(TaskOnClick); btn3.onClick.AddListener(TaskOnClick); btn4.onClick.AddListener(TaskOnClick); btn5.onClick.AddListener(TaskOnClick); }
public void ExecuteWhileCommand() { IExpression incrementX = new ArithmeticBinaryExpression(ArithmeticOperator.Add, new ConstantExpression(1), new VariableExpression("a")); IExpression decrementY = new ArithmeticBinaryExpression(ArithmeticOperator.Subtract, new VariableExpression("b"), new ConstantExpression(1)); ICommand setX = new SetVariableCommand("a", incrementX); ICommand setY = new SetVariableCommand("b", decrementY); List <ICommand> commands = new List <ICommand>(); commands.Add(setX); commands.Add(setY); ICommand command = new CompositeCommand(commands); IExpression yexpr = new VariableExpression("b"); WhileCommand whilecmd = new WhileCommand(yexpr, command); Context context = new Context(); context.SetValue("a", 0); context.SetValue("b", 5); whilecmd.Execute(context); Assert.AreEqual(0, context.GetValue("b")); Assert.AreEqual(5, context.GetValue("a")); }
public Void VisitWhileCommand(WhileCommand ast, Void arg) { System.Console.WriteLine("Visiting WhileCommand"); TypeDenoter expressionType = ast.Expression.Visit(this, null); CheckAndReportError(expressionType.Equals(StandardEnvironment.BooleanType), "expression type must be boolean", ast); return(ast.Command.Visit(this, null)); }
public Void VisitWhileCommand(WhileCommand ast, Void arg) { var expressionType = ast.Expression.Visit(this); CheckAndReportError(expressionType == StandardEnvironment.BooleanType, "Boolean expression expected here", ast.Expression); ast.Command.Visit(this); return(null); }
public void visit(WhileCommand that) { that.Expression.visit(this); that.Command.visit(this); if (that.Expression.Type.Kind != TypeKind.Boolean) { throw new CheckerError(that.Position, "Boolean expression expected in 'while' statement"); } }
public Void VisitWhileCommand(WhileCommand ast, Void arg) { TypeDenoter expressionType = ast.Expression.Visit(this, null); if (expressionType is BoolTypeDenoter == false) { ReportError("\"%\" is not a boolean type", ast); } ast.Command.Visit(this, null); return(null); }
public Void VisitWhileCommand(WhileCommand ast, Frame frame) { var jumpAddr = _emitter.Emit(OpCode.JUMP, Register.CB); var loopAddr = _emitter.NextInstrAddr; ast.Command.Visit(this, frame); _emitter.Patch(jumpAddr); ast.Expression.Visit(this, frame); _emitter.Emit(OpCode.JUMPIF, Machine.TrueValue, Register.CB, loopAddr); return(null); }
public static void Main() { MachineComposite dublin = ExampleMachine.Dublin(); Term sp = new Constant((Machine)dublin.Find("StarPress:1401")); Term ub = new Constant((Machine)dublin.Find("UnloadBuffer:1501")); WhileCommand wc = new WhileCommand( new HasMaterial(sp), new CarryCommand(sp, ub)); wc.Execute(); }
public void ExecuteWhileCommandWithNullCondition() { Context context = new Context(); IExpression cond = new ConstantExpression(null); ICommand cmd = new ExpressionCommand(new AssignExpression("a", new ConstantExpression(42))); WhileCommand wcmd = new WhileCommand(cond, cmd); wcmd.Execute(context); Assert.IsNull(context.GetValue("a")); }
public void CreateWhileCommand() { IExpression cond = new ConstantExpression(1); ICommand cmd = new ExpressionCommand(new ConstantExpression(2)); WhileCommand wcmd = new WhileCommand(cond, cmd); Assert.IsNotNull(wcmd.Condition); Assert.AreSame(cond, wcmd.Condition); Assert.IsNotNull(wcmd.Command); Assert.AreSame(cmd, wcmd.Command); }
public Void VisitWhileCommand(WhileCommand ast, Void arg) { TypeDenoter wHile = ast.Expression.Visit(this, null); if (!(wHile is BoolTypeDenoter)) { ReportError("\"%\" is not a procedure identifier", ast); } ast.Command.Visit(this, null); return(null); }
private ICommand ParseWhileCommand() { IExpression condition = this.ParseExpression(); this.ParseEndOfLine(); ICommand command = this.ParseCommandList("end", "enddo"); WhileCommand whileCommand = new WhileCommand(condition, command); this.lexer.NextToken(); return(whileCommand); }
public void ParseSimpleWhileCommand() { Parser parser = new Parser("while (a) \r\n b = 2;"); var result = parser.ParseCommand(); Assert.IsNotNull(result); Assert.That(result is WhileCommand); WhileCommand command = (WhileCommand)result; Assert.IsNotNull(command.Condition); Assert.IsNotNull(command.Command); }
public void ExecuteWhileCommandWithTrueCondition() { Context context = new Context(); IExpression cond = new NameExpression("a"); ICommand cmd = new ExpressionCommand(new AssignExpression("a", new ConstantExpression(false))); WhileCommand wcmd = new WhileCommand(cond, cmd); context.SetValue("a", true); wcmd.Execute(context); Assert.AreEqual(false, context.GetValue("a")); }
public void ParseSimpleWhileCommand() { Parser parser = new Parser("while (a) \r\n b = 2;"); var result = parser.ParseCommand(); Assert.IsNotNull(result); Assert.IsInstanceOfType(result, typeof(WhileCommand)); WhileCommand command = (WhileCommand)result; Assert.IsNotNull(command.Condition); Assert.IsNotNull(command.Command); }
public void ParseSimpleWhile() { ICommand command = ParseCommand("while (x<10) x=x+1;"); Assert.IsNotNull(command); Assert.IsInstanceOfType(command, typeof(WhileCommand)); WhileCommand whilecmd = (WhileCommand)command; Assert.IsNotNull(whilecmd.Condition); Assert.IsNotNull(whilecmd.Command); Assert.IsInstanceOfType(whilecmd.Command, typeof(SetCommand)); }
//public List<List<string>> jaggedCommandList = new List<List<string>>(); // Use this for initialization void Start() { //confirm = GameObject.Find("confirm").GetComponent<Button>(); //whilePanel = GameObject.Find("WhileField"); whileCommand = GetComponent <WhileCommand>(); btnInstance = GetComponent <ButtonClick>(); methodCommand = GetComponent <MethodCommand>(); whilePanel = whileCommand.whilePanel; confirm = whileCommand.confirm; confirm.onClick.AddListener(TaskOnClick); }
// Use this for initialization void Start() { floormask = LayerMask.GetMask("Floor"); Player = GameObject.FindGameObjectWithTag("Player"); // playerRigidbody = GetComponent<Rigidbody>(); Button btn = playButton.GetComponent <Button>(); btnInstance = GetComponent <ButtonClick>(); whileInstance = GetComponent <WhileCommand>(); btn.onClick.AddListener(TaskOnClick); }
public static void Main() { MachineComposite dublin = ExampleMachine.Dublin(); //Machine starPress = (Machine) dublin.Find("StarPress:1401"); // uncomment to add bins //starPress.Load(new Bin(42));// and see it work //starPress.Load(new Bin(84));// Term sp = new Constant((Machine)dublin.Find("StarPress:1401")); Term ub = new Constant((Machine)dublin.Find("UnloadBuffer:1501")); WhileCommand wc = new WhileCommand( new HasMaterial(sp), new CarryCommand(sp, ub)); wc.Execute(); }
public void CreateAndEvaluateSimpleWhileCommand() { BindingEnvironment environment = new BindingEnvironment(); environment.SetValue("a", 1); IExpression condition = new CompareExpression(ComparisonOperator.Less, new NameExpression("a"), new ConstantExpression(10)); ICommand body = new SetCommand("a", new BinaryOperatorExpression(new NameExpression("a"), new ConstantExpression(1), BinaryOperator.Add)); WhileCommand command = new WhileCommand(condition, body); command.Execute(environment); Assert.AreEqual(condition, command.Condition); Assert.AreEqual(body, command.Command); Assert.AreEqual(10, environment.GetValue("a")); }
public void ParseWhileCommandMultiline() { Parser parser = new Parser("while a \r\n a = b\r\nend"); ICommand command = parser.ParseCommand(); Assert.IsNotNull(command); Assert.IsInstanceOfType(command, typeof(WhileCommand)); WhileCommand whilecommand = (WhileCommand)command; Assert.IsNotNull(whilecommand.Condition); Assert.IsNotNull(whilecommand.Command); Assert.IsInstanceOfType(whilecommand.Condition, typeof(VariableExpression)); Assert.IsNull(parser.ParseCommand()); }
public void EvaluateWhileCommandUsingDecrement() { BindingEnvironment environment = new BindingEnvironment(); environment.SetValue("a", 2); IExpression condition = new VariableExpression("a"); ICommand command = new SetCommand("a", new BinaryArithmeticExpression(new VariableExpression("a"), new ConstantExpression(1), ArithmeticOperator.Subtract)); WhileCommand wcommand = new WhileCommand(condition, command); Assert.AreEqual(command, wcommand.Command); Assert.AreEqual(condition, wcommand.Condition); wcommand.Execute(environment); Assert.AreEqual(0, environment.GetValue("a")); }
// Use this for initialization void Start() { floormask = LayerMask.GetMask("Floor"); Player = GameObject.FindGameObjectWithTag("Player"); // playerRigidbody = GetComponent<Rigidbody>(); //Button btn = playButton.GetComponent<Button>(); btnInstance = GetComponent <UIButtonClick>(); whileInstance = GetComponent <WhileCommand>(); spawn = GetComponent <SpawnInstructions>(); //btn.onClick.AddListener(TaskOnClick); //store original position of player //originalPos = player.transform.position; isRotating = false; targetAngle = Player.transform.eulerAngles.y; targetRotation = Quaternion.AngleAxis(targetAngle, Vector3.up); }
public void WhileWithAddExpression() { var expression = new CompareExpression(ComparisonOperator.Less, new VariableExpression("a"), new ConstantExpression(10)); var inccommand = new SetVariableCommand("k", new ArithmeticBinaryExpression(ArithmeticOperator.Add, new VariableExpression("k"), new ConstantExpression(1))); var addcommand = new SetVariableCommand("a", new ArithmeticBinaryExpression(ArithmeticOperator.Add, new VariableExpression("k"), new VariableExpression("a"))); var command = new CompositeCommand(new ICommand[] { inccommand, addcommand }); var whilecommand = new WhileCommand(expression, command); Context context = new Context(); context.SetValue("a", 0); context.SetValue("k", 0); var result = whilecommand.Execute(context); Assert.IsNull(result); Assert.IsNotNull(whilecommand.Condition); Assert.IsNotNull(whilecommand.Command); Assert.AreEqual(4, context.GetValue("k")); Assert.AreEqual(10, context.GetValue("a")); }
// Use this for initialization void Start() { /*Button btn = leftButton.GetComponent<Button>(); * Button btn1 = rightButton.GetComponent<Button>(); * Button btn2 = upButton.GetComponent<Button>(); * Button btn3 = downButton.GetComponent<Button>();*/ // Button btn4 = whileButton.GetComponent<Button>(); //Button btn5 = methodButton.GetComponent<Button>(); //Mairim //Button submitBtn = submit.GetComponent<Button>(); //submitBtn.onClick.AddListener (SubmitCommands); //Record original position of the player //originalPos = player.transform.position; //Button clearBtn = clear.GetComponent<Button>(); //clearBtn.onClick.AddListener (ClearCommands); // methodContainer = GameObject.Find("methodContainer"); commandList = new List <string>(); whileList = new List <string>(); methodList = new List <string>(); jaggedWhileList = new List <List <string> >(); //whileActive = false; whileInstance = GetComponent <WhileCommand>(); methodInstance = GetComponent <MethodCommand>(); /* * btn.onClick.AddListener(TaskOnClick); * btn1.onClick.AddListener(TaskOnClick); * btn2.onClick.AddListener(TaskOnClick); * btn3.onClick.AddListener(TaskOnClick);*/ // btn4.onClick.AddListener(TaskOnClick); // btn5.onClick.AddListener(TaskOnClick); }
public void ParseAndEvaluateSimpleWhileWithCompositeCommand() { Parser parser = new Parser("while (a) { a = a-1; b=b+1; }"); ICommand command = parser.ParseCommand(); Assert.IsNotNull(command); Assert.IsInstanceOfType(command, typeof(WhileCommand)); WhileCommand whilecmd = (WhileCommand)command; Assert.IsInstanceOfType(whilecmd.Command, typeof(CompositeCommand)); BindingEnvironment environment = new BindingEnvironment(); environment.SetValue("a", 2); environment.SetValue("b", 0); command.Execute(environment); Assert.AreEqual(0, environment.GetValue("a")); Assert.AreEqual(2, environment.GetValue("b")); }
public bool TryGetSimpleCommand(string command, out BaseCommand returnCommand) { returnCommand = null; string[] arguments = null; string methodName = GetMethodSingature(command, ref arguments); CommandsMethods commandEnum = _availableCommands.FirstOrDefault(com => com.ToString() == methodName); if (commandEnum == 0) { return(false); } switch (commandEnum) { case (CommandsMethods.Forward): if (arguments == null || arguments.Length != 1 || arguments[0] != string.Empty) { return(false); } returnCommand = new MoveCommand(_implementator, MoveSides.FORWARD); return(true); case (CommandsMethods.Backward): if (arguments == null || arguments.Length != 1 || arguments[0] != string.Empty) { return(false); } returnCommand = new MoveCommand(_implementator, MoveSides.BACKWARD); return(true); case (CommandsMethods.Turn): { if (arguments == null || arguments.Length == 0) { return(false); } var turnSide = arguments[0].ToLower(); if (turnSide == TurnArguments.Right.ToString().ToLower()) { returnCommand = new RotateCommand(_implementator, TurnArguments.Right); } else if (turnSide == TurnArguments.Left.ToString().ToLower()) { returnCommand = new RotateCommand(_implementator, TurnArguments.Left); } return(true); } case (CommandsMethods.Do): { int count = 0; if (arguments == null || arguments.Length == 0 || !int.TryParse(arguments[0], out count)) { return(false); } returnCommand = new DoCommand(_implementator, count); return(true); } case (CommandsMethods.While): { if (arguments == null || arguments.Length == 0) { return(false); } WhileConditions argument = _allWhileConditions.FirstOrDefault(com => com.ToString() == arguments[0]); if (argument == 0) { return(false); } returnCommand = new WhileCommand(_implementator, argument); return(true); } } return(false); }
public void GenerateCodeForInstruction(CodeLine line) { if (InstructionHelper.IsMoveInstruction(line.instruction)) { var command = new MoveCommand(InstructionHelper.GetInstructionDirection(line.instruction), currentCodeLineNumber + 1); commandToCodeLineMapping.Add(command, line); allCommands.Add(command); } if (InstructionHelper.IsPutInstruction(line.instruction)) { var command = new PutCommand(currentCodeLineNumber + 1); commandToCodeLineMapping.Add(command, line); allCommands.Add(command); } if (InstructionHelper.IsPickInstruction(line.instruction)) { var command = new PickCommand(currentCodeLineNumber + 1); commandToCodeLineMapping.Add(command, line); allCommands.Add(command); } if (InstructionHelper.IsJumpInstruction(line.instruction)) { ICommand command; if (InstructionHelper.IsJumpInstructionLabel(line.instruction)) { command = new JumpCommand(currentCodeLineNumber + 1); allCommands.Add(command); } else { //this is being set in code later - otherwise forward jumps will not work - see RepairJumps for reference. command = new JumpCommand(currentCodeLineNumber + 1); allCommands.Add(command); } commandToCodeLineMapping.Add(command, line); } if (InstructionHelper.IsIfInstruction(line.instruction)) { int trueLineNumber = currentCodeLineNumber + 1; int elseLineNumber = currentCodeLineNumber + line.TotalChildrenCount + 1; var command = new IfCommand(trueLineNumber, elseLineNumber, GetConditions(line), GetLogicalOperators(line)); allCommands.Add(command); commandToCodeLineMapping.Add(command, line); currentCodeLineNumber++; foreach (var child in line.children) { GenerateCodeForInstruction(child); } command.NextCommandId = currentCodeLineNumber; currentCodeLineNumber--; //this may seem wrong but actually it is not } if (InstructionHelper.IsWhileInstruction(line.instruction)) { int trueLineNumber = currentCodeLineNumber + 1; int falseLineNumber = currentCodeLineNumber + line.TotalChildrenCount + 1; var command = new WhileCommand(trueLineNumber, falseLineNumber, GetConditions(line), GetLogicalOperators(line)); allCommands.Add(command); commandToCodeLineMapping.Add(command, line); currentCodeLineNumber++; foreach (var child in line.children) { GenerateCodeForInstruction(child); } var loopJumpCommand = new JumpCommand(trueLineNumber - 1); commandToCodeLineMapping.Add(loopJumpCommand, null); command.NextCommandId = currentCodeLineNumber + 1; allCommands.Add(loopJumpCommand); } if (InstructionHelper.IsRepeatInstruction(line.instruction)) { int trueLineNumber = currentCodeLineNumber + 1; int falseLineNumber = currentCodeLineNumber + line.TotalChildrenCount + 1; var command = new RepeatCommand(trueLineNumber, falseLineNumber, InstructionHelper.GetRepeatTimes(line.instruction)); allCommands.Add(command); commandToCodeLineMapping.Add(command, line); currentCodeLineNumber++; foreach (var child in line.children) { GenerateCodeForInstruction(child); } var loopJumpCommand = new JumpCommand(trueLineNumber - 1); commandToCodeLineMapping.Add(loopJumpCommand, null); command.NextCommandId = currentCodeLineNumber; allCommands.Add(loopJumpCommand); } currentCodeLineNumber++; }