public static string InvalidUseOfOperator(UnaryNode node, TypeInfo operand)
{
return($"(line: {node.line}, column: {node.column})" +
$" El operador '{node.Symbol}'no se puede aplicar al tipo '{operand.Text}'."
);
}
private void BuildGroups(IList<Token> tokens, NodeContext context)
{
for (int i = 0; i < tokens.Count; i++)
{
var token = tokens[i];
switch (token.Type)
{
case TokenType.Word:
{
var node = new TermNode(token.Text);
context.AddChild(node);
}
break;
case TokenType.BooleanAnd:
{
var node = new BooleanNode(BooleanType.And);
context.AddChild(node);
}
break;
case TokenType.BooleanOr:
{
var node = new BooleanNode(BooleanType.Or);
context.AddChild(node);
}
break;
case TokenType.Operator:
{
var node = new OperatorNode(token.Text);
context.AddChild(node);
}
break;
case TokenType.ParenthesisOpen:
{
var group = new ParenthesisGroupNode();
context.PushParent(group);
}
break;
case TokenType.ParenthesisClose:
{
context.PopParent();
}
break;
case TokenType.Quote:
// Quotes should have been removed by BuildSentences().
throw new Exception();
case TokenType.UnaryNot:
{
var node = new UnaryNode(UnaryType.Not);
context.AddChild(node);
}
break;
default:
throw new NotImplementedException();
}
}
}
public void VisitUnary(UnaryNode node)
{
VisitUnaryHandler(node);
}
/// <summary>
/// Gets the tree.
/// </summary>
/// <param name="expression">The expression.</param>
/// <param name="expressionTree">The tree.</param>
/// <param name="parent">The parent.</param>
/// <returns>
/// The expression tree.
/// </returns>
/// <exception cref="ArgumentNullException">
/// nameof(expression)
/// or
/// nameof(expression)
/// or
/// nameof(expression)
/// or
/// nameof(expression)
/// or
/// nameof(expression)
/// or
/// nameof(expression) is null.
/// </exception>
/// <exception cref="ExpressionObserversException">
/// Expression member is not a PropertyInfo
/// or
/// Method call has no ReturnParameter
/// or
/// Expression body is null
/// or
/// Expression body is not a supportet Expression {expression} type {expression.Type}.
/// </exception>
public static INodeCollection GetTree(
[NotNull] Expression expression,
[NotNull] IRootAware expressionTree,
IExpressionNode?parent)
{
if (expression == null)
{
throw new ArgumentNullException(nameof(expression));
}
if (expressionTree == null)
{
throw new ArgumentNullException(nameof(expressionTree));
}
var nodeCollection = new NodeCollection(expressionTree, parent);
while (true)
{
switch (expression)
{
case MemberExpression {
Member: PropertyInfo propertyInfo
} memberExpression:
{
expression = memberExpression.Expression;
nodeCollection.AddElement(new PropertyNode(memberExpression, propertyInfo));
break;
}
case MemberExpression {
Member: FieldInfo fieldInfo
} memberExpression:
{
expression = memberExpression.Expression;
nodeCollection.AddElement(new FieldNode(memberExpression, fieldInfo));
break;
}
case MemberExpression _:
throw new TreeException("Expression member is not a PropertyInfo");
case ParameterExpression parameterExpression:
{
var element = new ParameterNode(parameterExpression);
var node = nodeCollection.AddElement(element);
nodeCollection.Roots.Add(node);
return(nodeCollection);
}
case MethodCallExpression methodCallExpression
when methodCallExpression.Method.ReturnParameter == null:
throw new TreeException("Method call has no ReturnParameter");
case MethodCallExpression methodCallExpression:
expression = methodCallExpression.Object;
if (expression != null)
{
var element = new MethodNode(methodCallExpression);
element.Object = GetTree(expression, nodeCollection, element);
var arguments = new List <INodeCollection>();
foreach (var argument in methodCallExpression.Arguments)
{
arguments.Add(GetTree(argument, nodeCollection, element));
}
element.Arguments = arguments;
nodeCollection.AddElement(element);
return(nodeCollection);
}
else
{
var element = new FunctionNode(methodCallExpression);
var parameters = new List <INodeCollection>();
foreach (var argument in methodCallExpression.Arguments)
{
parameters.Add(GetTree(argument, nodeCollection, element));
}
element.Parameters = parameters;
nodeCollection.AddElement(element);
return(nodeCollection);
}
case ConstantExpression constantExpression:
{
var element = new ConstantNode(constantExpression);
var node = nodeCollection.AddElement(element);
nodeCollection.Roots.Add(node);
return(nodeCollection);
}
case BinaryExpression binaryExpression:
{
var element = new BinaryNode(binaryExpression);
element.LeftNodes = GetTree(binaryExpression.Left, nodeCollection, element);
element.RightNodes = GetTree(binaryExpression.Right, nodeCollection, element);
nodeCollection.AddElement(element);
return(nodeCollection);
}
case UnaryExpression unaryExpression:
{
var element = new UnaryNode(unaryExpression);
element.Operand = GetTree(unaryExpression.Operand, nodeCollection, element);
nodeCollection.AddElement(element);
return(nodeCollection);
}
case ConditionalExpression conditionalExpression:
{
var element = new ConditionalNode(conditionalExpression);
element.Test = GetTree(conditionalExpression.Test, nodeCollection, element);
element.IfTrue = GetTree(conditionalExpression.IfTrue, nodeCollection, element);
element.IfFalse = GetTree(conditionalExpression.IfFalse, nodeCollection, element);
nodeCollection.AddElement(element);
return(nodeCollection);
}
case NewExpression newExpression:
{
var element = new ConstructorNode(newExpression);
var parameters = new List <INodeCollection>();
foreach (var argument in newExpression.Arguments)
{
parameters.Add(GetTree(argument, nodeCollection, element));
}
element.Parameters = parameters;
nodeCollection.AddElement(element);
return(nodeCollection);
}
case MemberInitExpression memberInitExpression:
{
var element = new MemberInitNode(memberInitExpression);
var parameters = new List <INodeCollection>();
foreach (var argument in memberInitExpression.NewExpression.Arguments)
{
parameters.Add(GetTree(argument, nodeCollection, element));
}
element.Parameters = parameters;
var bindings = memberInitExpression.Bindings;
var bindingtree = CreateBindingTree(nodeCollection, bindings, element);
element.Bindings = bindingtree;
nodeCollection.AddElement(element);
return(nodeCollection);
}
case null:
throw new TreeException("Expression body is null");
default:
throw new TreeException(
$"Expression body is not a supportet Expression {expression} type {expression.Type}");
}
}
}
public void VisitLeave(UnaryNode node)
{
tabs--;
}
public virtual void VisitUnaryNode(UnaryNode unop)
{
unop.Num.Visit(this);
}
public void VisitEnter(UnaryNode node)
{
WriteLine(node, "Unary " + node.Operator.Value);
tabs++;
}
public override Node Mutate(UnaryNode node)
{
return(node);
}
public override void Visit(UnaryNode n)
{
Count++;
base.Visit(n);
}
public UnaryViewNode <T> CreateViewTree(UnaryNode node)
{
var childView = CreateViewTree(node.Child);
return(ViewNodeFactory.CreateUnaryNode(node, childView));
}
internal UnaryViewNode <T> CreateUnaryNode(UnaryNode node, ViewNode <T> child)
{
var nodeView = ViewFactory.GetView(node);
return(new UnaryViewNode <T>(nodeView, child));
}
