protected override BoundStatement RewriteForStatement(BoundForStatement node) { /* * { * let upperBound = <UpperBound> * <variable> = <lowerBound> * while <variable> < <UpperBound> * { * <statement> * <variable> = <variable> + 1 * } * } */ var upperBoundSymbol = new VariableSymbol("upperBound", true, node.UpperBound.Type, true); var upperBoundDeclaration = new BoundVariableDeclaration(upperBoundSymbol, node.UpperBound); var upperBoundExpression = new BoundVariableExpression(upperBoundSymbol); var variableDeclaration = new BoundVariableDeclaration(node.Variable, node.LowerBound); // LowerBound shouldn't be rewriten? var variableExpression = new BoundVariableExpression(node.Variable); var conditionOperator = BoundBinaryOperator.Bind(SyntaxKind.LessToken, TypeSymbol.Int, TypeSymbol.Int); var condition = new BoundBinaryExpression(variableExpression, conditionOperator, upperBoundExpression); // UpperBound shouldn't be rewriten? var incrementOperator = BoundBinaryOperator.Bind(SyntaxKind.PlusToken, node.Variable.Type, TypeSymbol.Int); var increment = new BoundBinaryExpression(variableExpression, incrementOperator, new BoundLiteralExpression(1)); var incrementAssignment = new BoundAssignmentExpression(node.Variable, increment); var incrementStatement = new BoundExpressionStatement(incrementAssignment); var whileBlockStatement = new BoundBlockStatement(ImmutableArray.Create <BoundStatement>(node.Statement, incrementStatement)); var whileStatement = new BoundWhileStatement(condition, whileBlockStatement); var result = new BoundBlockStatement(ImmutableArray.Create <BoundStatement>(upperBoundDeclaration, variableDeclaration, whileStatement)); return(RewriteStatement(result)); }
private object EvaluateBoundAssignmentExpression(BoundAssignmentExpression a) { var value = EvaluateExpression(a.Expression); _variables[a.Variable] = value; return(value); }
protected object EvaluateAssignmentExpression(BoundAssignmentExpression a) { var value = EvaluateExpression(a.Expression); _varialbes[a.Variable] = value; return(value); }
private object EvaluateAssignmentExpression(BoundAssignmentExpression a) { var value = EvaluateExpression(a.Expression); Assign(a.Variable, value); return(value); }
private object EvaluateAssignmentExpression(BoundAssignmentExpression assignment) { var value = EvaluateExpression(assignment.Expression); variables[assignment.Variable] = value; return(value); }
private void EmitAssignmentExpression(ILProcessor ilProcessor, BoundAssignmentExpression node) { var variableDefinition = _locals[node.Variable]; EmitExpression(ilProcessor, node.Expression); ilProcessor.Emit(OpCodes.Dup); ilProcessor.Emit(OpCodes.Stloc, variableDefinition); }
private object EvaluateAssignmentExpression(BoundAssignmentExpression expression) { var value = EvaluateExpression(expression.Expression); _variables[expression.Variable] = value; return(value); }
private void OutputAssignmentExpression(BoundAssignmentExpression node, string prefix) { builder.AddFragment(new OutputFragment(prefix, DefaultColour)); builder.AddFragment(new OutputFragment(node.Identifier.Name, VariableColour)); builder.AddFragment(new OutputFragment(DelimeterString, DefaultColour)); builder.AddFragment(new OutputFragment(node.Identifier.ValueType.Name, TypeColour)); builder.AddFragment(new OutputFragment(" = ", StatementColour)); Output(node.Expression, string.Empty); }
protected virtual BoundExpression RewriteAssignmentExpression(BoundAssignmentExpression assignment) { var expression = RewriteExpression(assignment.Expression); if (expression == assignment.Expression) { return(assignment); } return(new BoundAssignmentExpression(assignment.Identifier, expression)); }
protected override BoundExpression RewriteAssignmentExpression(BoundAssignmentExpression assignment) { BoundExpression expression = RewriteExpression(assignment.Expression); if (expression.ValueType != assignment.Identifier.ValueType && TypeConversionSymbol.TryFind(expression.ValueType, assignment.Identifier.ValueType, out var symbol)) { expression = new BoundInternalTypeConversion(symbol, expression); } if (expression == assignment.Expression) { return(assignment); } return(new BoundAssignmentExpression(assignment.Identifier, expression)); }
protected override object EvaluateExpression(BoundExpression node) { try { BoundLiteralExpression boundLiteralExpression = (BoundLiteralExpression)node; return(EvaluateLiteralExpression(boundLiteralExpression)); } catch { try { BoundVariableExpression boundVariableExpression = (BoundVariableExpression)node; return(EvaluateVariableExpression(boundVariableExpression)); } catch { try { BoundAssignmentExpression boundAssignmentExpression = (BoundAssignmentExpression)node; return(EvaluateAssignmentExpression(boundAssignmentExpression)); } catch { try { BoundUnaryExpression boundUnaryExpression = (BoundUnaryExpression)node; return(EvaluateUnaryExpression(boundUnaryExpression)); } catch { try { BoundBinaryExpression boundBinaryExpression = (BoundBinaryExpression)node; return(EvaluateBinaryExpression(boundBinaryExpression)); } catch { return(null); } } } } } }
protected override BoundExpression RewriteAssignmentExpression( BoundAssignmentExpression node ) { if (node.Left is BoundIndexExpression indexExpression) { return(new BoundCallExpression( node.Syntax, indexExpression.Setter !, RewriteExpression(indexExpression.Expression), ImmutableArray.Create( RewriteExpression(indexExpression.Index), RewriteExpression(node.Right) ) )); } return(node); }
private object EvaluateAssignmentExpression(BoundAssignmentExpression assignment) { object expression; if (assignment.Expression.Type == NodeType.FunctionPointer) { expression = EvaluateFunctionPointer((BoundFunctionPointer)assignment.Expression, assignment.Identifier.Name); } else { expression = EvaluateExpression(assignment.Expression); } if (expression == null) { return(null); } Assign(assignment.Identifier, expression); return(expression); }
private static void WriteBoundAssignmentExpression(this IndentedTextWriter writer, BoundAssignmentExpression node) { writer.WriteVariable(node.Variable !.Name); writer.WriteSpace(); writer.ColorWrite("="); writer.WriteSpace(); writer.WriteBoundNode(node.Expression); }
protected virtual void VisitAssignmentExpression(BoundAssignmentExpression node) { VisitExpression(node.Left); VisitExpression(node.Right); }
public virtual void VisitAssignmentExpression(BoundAssignmentExpression node) => this.DefaultVisit(node);
protected override BoundExpression RewriteAssignmentExpression(BoundAssignmentExpression node) { RewriteStatement(new BoundAssignmentStatement(node.Syntax, node.Left, node.Right)); return(new BoundUnitExpression(node.Syntax)); }
public override void VisitAssignmentExpression(BoundAssignmentExpression node) { node.Left.Accept(this); _writer.WritePunctuation(" = "); node.Right.Accept(this); }