private IExpression CompileBinaryOperator(IExpressionNodeFactory factory, ParseNode opNode) { if (opNode.Nodes.Count == 0) { return(null); } if (opNode.Nodes.Count == 1) { return(CompileExpressionNode(factory, opNode.Nodes[0])); } if (opNode.Nodes.Count >= 3) { int curIndex = 1; IExpression curLeft = CompileExpressionNode(factory, opNode.Nodes[0]); while (curIndex < opNode.Nodes.Count) { string token = opNode.Nodes[curIndex].Token.Text; IExpression right = CompileExpressionNode(factory, opNode.Nodes[curIndex + 1]); curLeft = factory.CreateBinaryOperator(token, curLeft, right); curIndex += 2; } return(curLeft); } throw new Exception(opNode.Text + " has two children. Operators must have three or more children."); }
public ExpressionParser( IExpressionNodeFactory expressionNodeFactory, IExpressionVisitorFactory expressionVisitorFactory) { ExpressionNodeFactory = expressionNodeFactory; ExpressionVisitorFactory = expressionVisitorFactory; }
private IExpression CompileQualifiedName(IExpressionNodeFactory factory, IExpression curContext, IList <ParseNode> identifiers, int startIndex) { if (startIndex >= identifiers.Count) { return(curContext); } int curIndex = startIndex; ParseNode curNode = identifiers[curIndex].Nodes[0]; var nameParts = new List <string>(); while (curNode != null && curNode.Token.Type == TokenType.IDENTIFIER) { nameParts.Add(curNode.Token.Text); curIndex += 1; curNode = (curIndex < identifiers.Count) ? identifiers[curIndex].Nodes[0] : null; } if (curNode != null) { if (curNode.Token.Type == TokenType.Array) { nameParts.Add(curNode.Nodes[0].Token.Text); IExpression arrayContext = new QualifiedName(curContext, nameParts.ToArray()); var arrayFunc = new ItemAtIndex(); IExpression index = CompileExpressionNode(factory, curNode.Nodes[2]); arrayFunc.AcceptArguments(arrayContext, index); return(CompileQualifiedName(factory, arrayFunc, identifiers, curIndex + 1)); } if (curNode.Token.Type == TokenType.Method) { var methodContext = nameParts.Count > 0 ? new QualifiedName(curContext, nameParts.ToArray()) : curContext; string methodName = curNode.Nodes[0].Token.Text; IList <ParseNode> argNodes = Select(curNode.Nodes[2].Nodes, TokenType.BooleanExpr); var args = new List <IExpression>(); if (methodContext != null) { args.Add(methodContext); } foreach (ParseNode argNode in argNodes) { args.Add(CompileExpressionNode(factory, argNode)); } return(CompileQualifiedName(factory, factory.CreateFunction(methodName, args.ToArray()), identifiers, curIndex + 1)); } } if (curContext == null && nameParts.Count == 1) { return(factory.CreateVariable(nameParts[0])); } return(new QualifiedName(curContext, nameParts.ToArray())); }
public ExpressionFactory( IExpressionNodeFactory expressionNodeFactory, IExpressionTokenizer expressionTokenizer, IInfixToPostfixConverter infixToPostfixConverter) { this.expressionNodeFactory = expressionNodeFactory; this.expressionTokenizer = expressionTokenizer; this.infixToPostfixConverter = infixToPostfixConverter; }
public MappingExpressionAnalyzer(IExpressionsSerializer expressionSerializer, IExpressionNodeFactory expressionNodeFactory) { if (expressionSerializer == null) throw new ArgumentNullException("expressionSerializer"); if (expressionNodeFactory == null) throw new ArgumentNullException("expressionNodeFactory"); _expressionSerializer = expressionSerializer; _expressionNodeFactory = expressionNodeFactory; }
public ConvertNode(IExpressionNodeFactory nodeFactory, UnaryExpression unaryExpression) : base(unaryExpression) { Operand = nodeFactory.Build(unaryExpression.Operand); }
public GreaterThanOrEqualNode(IExpressionNodeFactory nodeFactory, BinaryExpression greaterThanOrEqualExpression) : base(nodeFactory, greaterThanOrEqualExpression) { }
protected virtual IExpression CompileExpressionNode(IExpressionNodeFactory factory, ParseTreeNode astNode) { switch (astNode.Term.Name) { case "Number": var num = TypeNormalizer.EnsureType <double>(astNode.Token.Value); return(factory.CreateLiteral(num)); case "String": var str = TypeNormalizer.EnsureType <string>(astNode.Token.Value); return(factory.CreateLiteral(str)); case "Boolean": var bln = TypeNormalizer.EnsureType <bool>(astNode.Token.Value); return(factory.CreateLiteral(bln)); case "Identifier": var variable = astNode.Token.Value; if (variable != null) { return(factory.CreateVariable(variable.ToString())); } break; case "Expr": if (astNode.ChildNodes.Count == 3 && astNode.ChildNodes[1].Term is SymbolTerminal) { IExpression left = CompileExpressionNode(factory, astNode.ChildNodes[0]); IExpression right = CompileExpressionNode(factory, astNode.ChildNodes[2]); return(factory.CreateBinaryOperator(astNode.ChildNodes[1].Term.Name, left, right)); } if (astNode.ChildNodes.Count == 2 && astNode.ChildNodes[0].Term is SymbolTerminal) { IExpression arg = CompileExpressionNode(factory, astNode.ChildNodes[1]); return(factory.CreateUnaryOperator(astNode.ChildNodes[0].Term.Name, arg)); } if (astNode.ChildNodes.Count == 2 && astNode.ChildNodes[1].Term is SymbolTerminal) { IExpression arg = CompileExpressionNode(factory, astNode.ChildNodes[0]); return(factory.CreateUnaryOperator(astNode.ChildNodes[1].Term.Name, arg)); } break; case "QualifiedName": var parts = new List <string>(); if (astNode.ChildNodes.Count == 2) { return(new QualifiedName(new[] { astNode.ChildNodes[1].Token.ValueString })); } //Condition ought to be impossible if (astNode.ChildNodes.Count != 3) { throw new Exception("Malformed QualifiedName - should have 3 child nodes"); } ExtractQualifiedName(astNode, parts); return(new QualifiedName(parts.ToArray())); case "FunctionExpression": string functionName = (astNode.ChildNodes[0].Token.ValueString); var args = new IExpression[astNode.ChildNodes[1].ChildNodes.Count]; for (int i = 0; i < astNode.ChildNodes[1].ChildNodes.Count; i++) { args[i] = CompileExpressionNode(factory, astNode.ChildNodes[1].ChildNodes[i]); } return(factory.CreateFunction(functionName, args)); case "IfThen": IExpression condition = CompileExpressionNode(factory, astNode.ChildNodes[1]); IExpression trueExpr = CompileExpressionNode(factory, astNode.ChildNodes[3]); IExpression falseExpr = null; if (astNode.ChildNodes.Count == 6) { falseExpr = CompileExpressionNode(factory, astNode.ChildNodes[5]); } var func = new IfThen(); if (falseExpr != null) { func.AcceptArguments(condition, trueExpr, falseExpr); } else { func.AcceptArguments(condition, trueExpr); } return(func); case "ArrayExpression": IExpression context = CompileExpressionNode(factory, astNode.ChildNodes[0]); IExpression index = CompileExpressionNode(factory, astNode.ChildNodes[1]); var indexer = new ItemAtIndex(); indexer.AcceptArguments(context, index); return(indexer); } return(null); }
// don't call base protected override IExpression CompileExpressionNode(IExpressionNodeFactory factory, ParseTreeNode astNode) { switch (astNode.Term.Name) { case "Number": var num = TypeNormalizer.EnsureType <double>(astNode.Token.Value); return(factory.CreateLiteral(num)); case "String": var str = TypeNormalizer.EnsureType <string>(astNode.Token.Value); return(factory.CreateLiteral(str)); case "Boolean": var bln = TypeNormalizer.EnsureType <bool>(astNode.Token.Value); return(factory.CreateLiteral(bln)); case "Identifier": var variable = astNode.Token.Value; if (variable != null) { return(factory.CreateVariable(variable.ToString())); } break; case "Symbol": var str_1 = TypeNormalizer.EnsureType <string>(astNode.Token.Value); return(factory.CreateLiteral(str_1)); case "UserSectionStmt": return(factory.CreateFunction(astNode.ChildNodes[2].Token.Text, null)); case "GlobalSectionStmt": return(factory.CreateLiteral(this.SinglePage.EvaluatePropertyPath(astNode.ChildNodes[2].Token.Text))); case "ParameterSectionStmt": return(CompileExpressionNode(factory, astNode.ChildNodes[2])); case "FieldsSectionStmt": //return CompileExpressionNode (factory,astNode.ChildNodes[2]); IExpression l = CompileExpressionNode(factory, astNode.ChildNodes[2]); return(factory.CreateFunction(astNode.ChildNodes[0].Token.Text, l)); case "ParExpr": return(CompileExpressionNode(factory, astNode.ChildNodes[0])); case "BinExpr": if (astNode.ChildNodes.Count == 3 && astNode.ChildNodes[1].Term is SymbolTerminal) { IExpression left = CompileExpressionNode(factory, astNode.ChildNodes[0]); IExpression right = CompileExpressionNode(factory, astNode.ChildNodes[2]); return(factory.CreateBinaryOperator(astNode.ChildNodes[1].Term.Name, left, right)); } if (astNode.ChildNodes.Count == 2 && astNode.ChildNodes[0].Term is SymbolTerminal) { IExpression arg = CompileExpressionNode(factory, astNode.ChildNodes[1]); return(factory.CreateUnaryOperator(astNode.ChildNodes[0].Term.Name, arg)); } if (astNode.ChildNodes.Count == 2 && astNode.ChildNodes[1].Term is SymbolTerminal) { IExpression arg = CompileExpressionNode(factory, astNode.ChildNodes[0]); return(factory.CreateUnaryOperator(astNode.ChildNodes[1].Term.Name, arg)); } break; case "QualifiedName": var parts = new List <string>(); if (astNode.ChildNodes.Count == 2) { return(new QualifiedName(new[] { astNode.ChildNodes[1].Token.ValueString })); } /* * //Condition ought to be impossible * if (astNode.ChildNodes.Count != 3 ) * throw new Exception("Malformed QualifiedName - should have 3 child nodes"); */ if (astNode.ChildNodes.Count == 1) { return(CompileExpressionNode(factory, astNode.ChildNodes[0])); } SimpleExpressionLanguageCompiler.ExtractQualifiedName(astNode, parts); return(new QualifiedName(parts.ToArray())); case "FunctionExpression": IExpression [] args = null; string functionName = (astNode.ChildNodes[0].ChildNodes[0].Token.ValueString); if (astNode.ChildNodes.Count == 1) { args = new IExpression[astNode.ChildNodes[0].ChildNodes[0].ChildNodes.Count]; } else { args = new IExpression[astNode.ChildNodes[1].ChildNodes.Count]; for (int i = 0; i < astNode.ChildNodes[1].ChildNodes.Count; i++) { args[i] = CompileExpressionNode(factory, astNode.ChildNodes[1].ChildNodes[i]); } } return(factory.CreateFunction(functionName, args)); case "IfThen": IExpression condition = CompileExpressionNode(factory, astNode.ChildNodes[1].ChildNodes[0]); IExpression trueExpr = CompileExpressionNode(factory, astNode.ChildNodes[3]); // IExpression falseExpr = CompileExpressionNode(factory, astNode.ChildNodes[3]); IExpression falseExpr = null; if (astNode.ChildNodes.Count == 6) { falseExpr = CompileExpressionNode(factory, astNode.ChildNodes[5]); } var func = new IfThen(); if (falseExpr != null) { func.AcceptArguments(condition, trueExpr, falseExpr); } else { func.AcceptArguments(condition, trueExpr); } return(func); /* * case "ArrayExpression": * IExpression context = CompileExpressionNode(factory, astNode.ChildNodes[0]); * IExpression index = CompileExpressionNode(factory, astNode.ChildNodes[1]); * var indexer = new ItemAtIndex(); * indexer.AcceptArguments(context, index); * return indexer; * */ } return(null); }
public MemberAccessNode(IExpressionNodeFactory nodeFactory, MemberExpression memberExpression) : base(memberExpression) { Expression = nodeFactory.Build(memberExpression.Expression); }
public LessThanNode(IExpressionNodeFactory nodeFactory, BinaryExpression lessThanExpression) : base(nodeFactory, lessThanExpression) { }
public EqualNode(IExpressionNodeFactory nodeFactory, BinaryExpression binaryExpression) : base(nodeFactory, binaryExpression) { }
public LambdaNode(IExpressionNodeFactory nodeFactory, LambdaExpression lambdaExpression) : base(lambdaExpression) { Body = nodeFactory.Build(SourceExpression.Body); }
protected virtual IExpression CompileExpressionNode(IExpressionNodeFactory factory, ParseNode astNode) { switch (astNode.Token.Type) { case TokenType.Atom: if (astNode.Nodes[0].Token.Type == TokenType.BROPEN) { return(CompileExpressionNode(factory, astNode.Nodes[1])); } return(CompileExpressionNode(factory, astNode.Nodes[0])); case TokenType.NUMBER: case TokenType.INTEGER: var num = TypeNormalizer.EnsureType <double>(astNode.Token.Text); return(factory.CreateLiteral(num)); case TokenType.STRING: var str = TypeNormalizer.EnsureType <string>(astNode.Token.Text.Replace("\"", String.Empty)); return(factory.CreateLiteral(str)); case TokenType.TRUE: case TokenType.FALSE: var bln = TypeNormalizer.EnsureType <bool>(astNode.Token.Text); return(factory.CreateLiteral(bln)); case TokenType.NULL: return(null); case TokenType.BooleanExpr: case TokenType.CompareExpr: case TokenType.AddExpr: case TokenType.MultExpr: case TokenType.PowerExpr: return(CompileBinaryOperator(factory, astNode)); case TokenType.QualifiedName: return(CompileQualifiedName(factory, null, Select(astNode.Nodes, TokenType.Identifier), 0)); case TokenType.Conditional: var pieces = Select(astNode.Nodes, TokenType.BooleanExpr); IExpression condition = CompileExpressionNode(factory, pieces[0]); IExpression trueExpr = CompileExpressionNode(factory, pieces[1]); IExpression falseExpr = (pieces.Count == 3) ? CompileExpressionNode(factory, pieces[2]) : null; var func = new IfThen(); if (falseExpr != null) { func.AcceptArguments(condition, trueExpr, falseExpr); } else { func.AcceptArguments(condition, trueExpr); } return(func); case TokenType.UnaryExpr: string token = astNode.Nodes[0].Token.Text; IExpression left = CompileBinaryOperator(factory, astNode.Nodes[1]); return(factory.CreateUnaryOperator(token, left)); } return(null); }
public ConnectionValidator(IDiagramViewModel diagram, IMappingExpressionValidator expressionValidator, IExpressionNodeFactory expressionNodeFactory) { if (diagram == null) throw new ArgumentNullException("diagram"); if (expressionValidator == null) throw new ArgumentNullException("expressionValidator"); if (expressionNodeFactory == null) throw new ArgumentNullException("expressionNodeFactory"); _diagram = diagram; _expressionValidator = expressionValidator; _expressionNodeFactory = expressionNodeFactory; }
public ModuloNode(IExpressionNodeFactory nodeFactory, BinaryExpression moduloExpression) : base(nodeFactory, moduloExpression) { }
public BaseBinaryExpressionNode(IExpressionNodeFactory nodeFactory, BinaryExpression binaryExpression) : base(binaryExpression) { Left = nodeFactory.Build(binaryExpression.Left); Right = nodeFactory.Build(binaryExpression.Right); }