void ILSLSyntaxErrorListener.PostfixOperationOnNonVariable(LSLSourceCodeRange location, LSLPostfixOperationType type) { _errorActionQueue.Enqueue(location.StartIndex, () => SyntaxErrorListener.PostfixOperationOnNonVariable(location, type)); }
/// <summary> /// Converts the provided <see cref="LSLPostfixOperationType" /> to its source code string representation. /// </summary> /// <param name="type">The <see cref="LSLPostfixOperationType" /> to convert to a string.</param> /// <exception cref="ArgumentException"> /// Thrown if the <see cref="LSLPostfixOperationType" /> provided was equal to /// <see cref="LSLPostfixOperationType.Error" />. /// </exception> /// <returns>The source code string representation of the <see cref="LSLPostfixOperationType" />.</returns> public static string ToOperatorString(this LSLPostfixOperationType type) { switch (type) { case LSLPostfixOperationType.Decrement: return("--"); case LSLPostfixOperationType.Increment: return("++"); } throw new ArgumentException( string.Format("Could not convert LSLPostfixOperationType.{0} enum value to operator string", type), "type"); }
/// <summary> /// Construct an <see cref="LSLPostfixOperationNode" /> from a given <see cref="ILSLExprNode" /> and /// <see cref="LSLPostfixOperationType" />. /// </summary> /// <param name="resultType">The return type of the postfix operation on the given expression.</param> /// <param name="leftExpression">The expression the postfix operation occurs on.</param> /// <param name="operationType">The postfix operation type.</param> /// <exception cref="ArgumentNullException"><paramref name="leftExpression" /> is <c>null</c>.</exception> /// <exception cref="ArgumentException"><paramref name="operationType" /> is <see cref="LSLPostfixOperationType.Error" />.</exception> public LSLPostfixOperationNode(LSLType resultType, ILSLExprNode leftExpression, LSLPostfixOperationType operationType) { if (leftExpression == null) { throw new ArgumentNullException("leftExpression"); } if (operationType == LSLPostfixOperationType.Error) { throw new ArgumentException("operationType cannot be LSLPostfixOperationType.Error."); } Type = resultType; LeftExpression = leftExpression; LeftExpression.Parent = this; Operation = operationType; OperationString = Operation.ToOperatorString(); }
/// <summary> /// Validates and returns the type resulting from a postfix operation. /// </summary> /// <param name="left">The expression to preform the postfix operation on.</param> /// <param name="operation">The postfix operation preformed.</param> /// <returns>An <see cref="LSLExpressionValidatorResult" /> object</returns> /// <exception cref="ArgumentNullException"><paramref name="left"/> is <c>null</c>.</exception> public LSLExpressionValidatorResult ValidatePostfixOperation(ILSLReadOnlyExprNode left, LSLPostfixOperationType operation) { if (left == null) { throw new ArgumentNullException("left"); } if (left.HasErrors) { return(LSLExpressionValidatorResult.Error); } LSLType t; if (_operations.TryGetValue(left.Type + operation.ToOperatorString(), out t)) { return(new LSLExpressionValidatorResult(t, true)); } return(LSLExpressionValidatorResult.Error); }
/// <summary> /// Determines whether the given postfix operation is a modifying operation. /// Both <see cref="LSLPostfixOperationType.Decrement" /> and <see cref="LSLPostfixOperationType.Increment" /> are /// modifying operations. /// </summary> /// <param name="type">If the postfix operation modifies the expression to its left.</param> /// <returns><c>true</c> if <paramref name="type"/> is <see cref="LSLPrefixOperationType.Decrement" /> or <see cref="LSLPrefixOperationType.Increment" />.</returns> public static bool IsModifying(this LSLPostfixOperationType type) { return(type == LSLPostfixOperationType.Decrement || type == LSLPostfixOperationType.Increment); }
private void AddPostfixOperation(LSLType left, LSLPostfixOperationType operation, LSLType result) { _operations.Add(left + operation.ToOperatorString(), result); }