public RedILNode VisitUnaryOperatorExpression(UnaryOperatorExpression unaryOperatorExpression, State data) { var operand = CastUtilities.CastRedILNode <ExpressionNode>(unaryOperatorExpression.Expression.AcceptVisitor(this, data.NewState(unaryOperatorExpression, null))); if (OperatorUtilities.IsIncrement(unaryOperatorExpression.Operator)) { if (data.ParentNode.NodeType != NodeType.Statement) { throw new RedILException($"Incremental operators can only be used within statements"); } BinaryExpressionOperator binaryOp = default; switch (unaryOperatorExpression.Operator) { case UnaryOperatorType.Increment: case UnaryOperatorType.PostIncrement: binaryOp = BinaryExpressionOperator.Add; break; case UnaryOperatorType.Decrement: case UnaryOperatorType.PostDecrement: binaryOp = BinaryExpressionOperator.Subtract; break; } var constantOne = new ConstantValueNode(DataValueType.Integer, 1); return(new AssignNode(operand, VisitBinaryOperatorExpression(operand, constantOne, binaryOp, data.NewState(unaryOperatorExpression, null)))); } var op = OperatorUtilities.UnaryOperator(unaryOperatorExpression.Operator); return(new UnaryExpressionNode(op, operand)); }
private ExpressionNode VisitBinaryOperatorExpression(ExpressionNode left, ExpressionNode right, BinaryExpressionOperator op, State data) { if (OperatorUtilities.IsBoolean(op)) { return(new BinaryExpressionNode(DataValueType.Boolean, op, left, right)); } else if (OperatorUtilities.IsArithmatic(op)) { if (left.DataType == DataValueType.String || right.DataType == DataValueType.String) { return(new BinaryExpressionNode(DataValueType.String, BinaryExpressionOperator.StringConcat, left, right)); } else if (left.DataType == DataValueType.Float || right.DataType == DataValueType.Float) { return(new BinaryExpressionNode(DataValueType.Float, op, left, right)); } else if (left.DataType == DataValueType.Integer && right.DataType == DataValueType.Integer) { return(new BinaryExpressionNode(DataValueType.Integer, op, left, right)); } } else if (op == BinaryExpressionOperator.NullCoalescing) { return(new BinaryExpressionNode(left.DataType, op, left, right)); } throw new RedILException($"Unsupported operator '{op}' with data types '{left.DataType}' and '{right.DataType}'"); }
public RedILNode VisitAssignmentExpression(AssignmentExpression assignmentExpression, State data) { if (data.ParentNode.NodeType != NodeType.Statement) { throw new RedILException("Assigment is only possible within a statement"); } var assignNode = new AssignNode(); var left = CastUtilities.CastRedILNode <ExpressionNode>(assignmentExpression.Left.AcceptVisitor(this, data.NewState(assignmentExpression, assignNode))); var right = CastUtilities.CastRedILNode <ExpressionNode>(assignmentExpression.Right.AcceptVisitor(this, data.NewState(assignmentExpression, assignNode))); if (assignmentExpression.Operator == AssignmentOperatorType.Assign) { assignNode.Left = left; assignNode.Right = right; } else { var op = OperatorUtilities.BinaryOperator(assignmentExpression.Operator); assignNode.Left = left; assignNode.Right = VisitBinaryOperatorExpression(left, right, op, data); } return(assignNode); }
public RedILNode VisitBinaryOperatorExpression(BinaryOperatorExpression binaryOperatorExpression, State data) { //TODO: send parent node var op = OperatorUtilities.BinaryOperator(binaryOperatorExpression.Operator); var left = CastUtilities.CastRedILNode <ExpressionNode>(binaryOperatorExpression.Left.AcceptVisitor(this, data.NewState(binaryOperatorExpression, null))); var right = CastUtilities.CastRedILNode <ExpressionNode>(binaryOperatorExpression.Right.AcceptVisitor(this, data.NewState(binaryOperatorExpression, null))); return(VisitBinaryOperatorExpression(left, right, op, data)); }