mirror of
https://github.com/AssetRipper/ILSpy.git
synced 2026-11-13 20:05:48 -10:00
257 lines
8.5 KiB
C#
257 lines
8.5 KiB
C#
//
|
|
// UnaryOperatorExpression.cs
|
|
//
|
|
// Author:
|
|
// Mike Krüger <[email protected]>
|
|
//
|
|
// Copyright (c) 2009 Novell, Inc (http://www.novell.com)
|
|
//
|
|
// Permission is hereby granted, free of charge, to any person obtaining a copy
|
|
// of this software and associated documentation files (the "Software"), to deal
|
|
// in the Software without restriction, including without limitation the rights
|
|
// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
|
|
// copies of the Software, and to permit persons to whom the Software is
|
|
// furnished to do so, subject to the following conditions:
|
|
//
|
|
// The above copyright notice and this permission notice shall be included in
|
|
// all copies or substantial portions of the Software.
|
|
//
|
|
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
|
|
// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
|
|
// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
|
|
// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
|
|
// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
|
|
// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
|
|
// THE SOFTWARE.
|
|
|
|
using System;
|
|
using System.Linq.Expressions;
|
|
|
|
namespace ICSharpCode.Decompiler.CSharp.Syntax
|
|
{
|
|
/// <summary>
|
|
/// Operator Expression
|
|
/// </summary>
|
|
public class UnaryOperatorExpression : Expression
|
|
{
|
|
public readonly static TokenRole NotRole = new TokenRole("!");
|
|
public readonly static TokenRole BitNotRole = new TokenRole("~");
|
|
public readonly static TokenRole MinusRole = new TokenRole("-");
|
|
public readonly static TokenRole PlusRole = new TokenRole("+");
|
|
public readonly static TokenRole IncrementRole = new TokenRole("++");
|
|
public readonly static TokenRole DecrementRole = new TokenRole("--");
|
|
public readonly static TokenRole DereferenceRole = new TokenRole("*");
|
|
public readonly static TokenRole AddressOfRole = new TokenRole("&");
|
|
public readonly static TokenRole AwaitRole = new TokenRole("await");
|
|
public readonly static TokenRole NullConditionalRole = new TokenRole("?");
|
|
public readonly static TokenRole SuppressNullableWarningRole = new TokenRole("!");
|
|
public readonly static TokenRole IndexFromEndRole = new TokenRole("^");
|
|
public readonly static TokenRole PatternNotRole = new TokenRole("not");
|
|
|
|
public UnaryOperatorExpression()
|
|
{
|
|
}
|
|
|
|
public UnaryOperatorExpression(UnaryOperatorType op, Expression expression)
|
|
{
|
|
this.Operator = op;
|
|
this.Expression = expression;
|
|
}
|
|
|
|
public UnaryOperatorType Operator {
|
|
get;
|
|
set;
|
|
}
|
|
|
|
public CSharpTokenNode OperatorToken {
|
|
get { return GetChildByRole(GetOperatorRole(Operator)); }
|
|
}
|
|
|
|
public Expression Expression {
|
|
get { return GetChildByRole(Roles.Expression); }
|
|
set { SetChildByRole(Roles.Expression, value); }
|
|
}
|
|
|
|
public override void AcceptVisitor(IAstVisitor visitor)
|
|
{
|
|
visitor.VisitUnaryOperatorExpression(this);
|
|
}
|
|
|
|
public override T AcceptVisitor<T>(IAstVisitor<T> visitor)
|
|
{
|
|
return visitor.VisitUnaryOperatorExpression(this);
|
|
}
|
|
|
|
public override S AcceptVisitor<T, S>(IAstVisitor<T, S> visitor, T data)
|
|
{
|
|
return visitor.VisitUnaryOperatorExpression(this, data);
|
|
}
|
|
|
|
protected internal override bool DoMatch(AstNode other, PatternMatching.Match match)
|
|
{
|
|
UnaryOperatorExpression o = other as UnaryOperatorExpression;
|
|
return o != null && (this.Operator == UnaryOperatorType.Any || this.Operator == o.Operator)
|
|
&& this.Expression.DoMatch(o.Expression, match);
|
|
}
|
|
|
|
public static TokenRole GetOperatorRole(UnaryOperatorType op)
|
|
{
|
|
switch (op)
|
|
{
|
|
case UnaryOperatorType.Not:
|
|
return NotRole;
|
|
case UnaryOperatorType.BitNot:
|
|
return BitNotRole;
|
|
case UnaryOperatorType.Minus:
|
|
return MinusRole;
|
|
case UnaryOperatorType.Plus:
|
|
return PlusRole;
|
|
case UnaryOperatorType.Increment:
|
|
case UnaryOperatorType.PostIncrement:
|
|
return IncrementRole;
|
|
case UnaryOperatorType.PostDecrement:
|
|
case UnaryOperatorType.Decrement:
|
|
return DecrementRole;
|
|
case UnaryOperatorType.Dereference:
|
|
return DereferenceRole;
|
|
case UnaryOperatorType.AddressOf:
|
|
return AddressOfRole;
|
|
case UnaryOperatorType.Await:
|
|
return AwaitRole;
|
|
case UnaryOperatorType.NullConditional:
|
|
return NullConditionalRole;
|
|
case UnaryOperatorType.NullConditionalRewrap:
|
|
case UnaryOperatorType.IsTrue:
|
|
return null; // no syntax
|
|
case UnaryOperatorType.SuppressNullableWarning:
|
|
return SuppressNullableWarningRole;
|
|
case UnaryOperatorType.IndexFromEnd:
|
|
return IndexFromEndRole;
|
|
case UnaryOperatorType.PatternNot:
|
|
return PatternNotRole;
|
|
case UnaryOperatorType.PatternRelationalLessThan:
|
|
return BinaryOperatorExpression.LessThanRole;
|
|
case UnaryOperatorType.PatternRelationalLessThanOrEqual:
|
|
return BinaryOperatorExpression.LessThanOrEqualRole;
|
|
case UnaryOperatorType.PatternRelationalGreaterThan:
|
|
return BinaryOperatorExpression.GreaterThanRole;
|
|
case UnaryOperatorType.PatternRelationalGreaterThanOrEqual:
|
|
return BinaryOperatorExpression.GreaterThanOrEqualRole;
|
|
default:
|
|
throw new NotSupportedException("Invalid value for UnaryOperatorType");
|
|
}
|
|
}
|
|
|
|
public static ExpressionType GetLinqNodeType(UnaryOperatorType op, bool checkForOverflow)
|
|
{
|
|
switch (op)
|
|
{
|
|
case UnaryOperatorType.Not:
|
|
return ExpressionType.Not;
|
|
case UnaryOperatorType.BitNot:
|
|
return ExpressionType.OnesComplement;
|
|
case UnaryOperatorType.Minus:
|
|
return checkForOverflow ? ExpressionType.NegateChecked : ExpressionType.Negate;
|
|
case UnaryOperatorType.Plus:
|
|
return ExpressionType.UnaryPlus;
|
|
case UnaryOperatorType.Increment:
|
|
return ExpressionType.PreIncrementAssign;
|
|
case UnaryOperatorType.Decrement:
|
|
return ExpressionType.PreDecrementAssign;
|
|
case UnaryOperatorType.PostIncrement:
|
|
return ExpressionType.PostIncrementAssign;
|
|
case UnaryOperatorType.PostDecrement:
|
|
return ExpressionType.PostDecrementAssign;
|
|
case UnaryOperatorType.Dereference:
|
|
case UnaryOperatorType.AddressOf:
|
|
case UnaryOperatorType.Await:
|
|
case UnaryOperatorType.SuppressNullableWarning:
|
|
case UnaryOperatorType.IndexFromEnd:
|
|
case UnaryOperatorType.PatternNot:
|
|
case UnaryOperatorType.PatternRelationalLessThan:
|
|
case UnaryOperatorType.PatternRelationalLessThanOrEqual:
|
|
case UnaryOperatorType.PatternRelationalGreaterThan:
|
|
case UnaryOperatorType.PatternRelationalGreaterThanOrEqual:
|
|
return ExpressionType.Extension;
|
|
default:
|
|
throw new NotSupportedException("Invalid value for UnaryOperatorType");
|
|
}
|
|
}
|
|
}
|
|
|
|
public enum UnaryOperatorType
|
|
{
|
|
/// <summary>
|
|
/// Any unary operator (used in pattern matching)
|
|
/// </summary>
|
|
Any,
|
|
|
|
/// <summary>Logical not (!a)</summary>
|
|
Not,
|
|
/// <summary>Bitwise not (~a)</summary>
|
|
BitNot,
|
|
/// <summary>Unary minus (-a)</summary>
|
|
Minus,
|
|
/// <summary>Unary plus (+a)</summary>
|
|
Plus,
|
|
/// <summary>Pre increment (++a)</summary>
|
|
Increment,
|
|
/// <summary>Pre decrement (--a)</summary>
|
|
Decrement,
|
|
/// <summary>Post increment (a++)</summary>
|
|
PostIncrement,
|
|
/// <summary>Post decrement (a--)</summary>
|
|
PostDecrement,
|
|
/// <summary>Dereferencing (*a)</summary>
|
|
Dereference,
|
|
/// <summary>Get address (&a)</summary>
|
|
AddressOf,
|
|
/// <summary>C# 5.0 await</summary>
|
|
Await,
|
|
/// <summary>C# 6 null-conditional operator.
|
|
/// Occurs as target of member reference or indexer expressions
|
|
/// to indicate <c>?.</c> or <c>?[]</c>.
|
|
/// Corresponds to <c>nullable.unwrap</c> in ILAst.
|
|
/// </summary>
|
|
NullConditional,
|
|
/// <summary>
|
|
/// Wrapper around a primary expression containing a null conditional operator.
|
|
/// Corresponds to <c>nullable.rewrap</c> in ILAst.
|
|
/// This has no syntax in C#, but the node is used to ensure parentheses are inserted where necessary.
|
|
/// </summary>
|
|
NullConditionalRewrap,
|
|
/// <summary>
|
|
/// Implicit call of "operator true".
|
|
/// </summary>
|
|
IsTrue,
|
|
/// <summary>
|
|
/// C# 8 postfix ! operator (dammit operator)
|
|
/// </summary>
|
|
SuppressNullableWarning,
|
|
/// <summary>
|
|
/// C# 8 prefix ^ operator
|
|
/// </summary>
|
|
IndexFromEnd,
|
|
/// <summary>
|
|
/// C# 9 not pattern
|
|
/// </summary>
|
|
PatternNot,
|
|
/// <summary>
|
|
/// C# 9 relational pattern
|
|
/// </summary>
|
|
PatternRelationalLessThan,
|
|
/// <summary>
|
|
/// C# 9 relational pattern
|
|
/// </summary>
|
|
PatternRelationalLessThanOrEqual,
|
|
/// <summary>
|
|
/// C# 9 relational pattern
|
|
/// </summary>
|
|
PatternRelationalGreaterThan,
|
|
/// <summary>
|
|
/// C# 9 relational pattern
|
|
/// </summary>
|
|
PatternRelationalGreaterThanOrEqual,
|
|
}
|
|
}
|