public AggregateNode(string name) : base(null, name) { if (null == (this.methodInfo = AggregateNode.LookupFunc(name))) { throw InvalidExpressionException.UndefinedFunction(name); } }
public AggregateNode(string name) : base((ExpressionNode)null, name) { if ((object)(this.methodInfo = AggregateNode.LookupFunc(name)) == null) { throw InvalidExpressionException.UndefinedFunction(name); } }
public static bool IsAggregare(string name) { return(null != (object)AggregateNode.LookupFunc(name)); }
private bool TryParse(bool enableExceptions, out ExpressionNode expressionNode) { expressionNode = null; Token token; int parenCount = 0; this.StartParse(); do { try { token = this.lexer.Read(); } catch (LexicalException e) { if (enableExceptions) { throw e; } return(false); } Debug.WriteLine(Utils.TokenToString(token) + " : " + this.lexer.TokenString); switch (token) { case Token.Name: case Token.Numeric: case Token.Decimal: case Token.Float: case Token.NumericHex: case Token.StringConst: case Token.Date: if (OperandType.None != this.prevOperand) { if (enableExceptions) { throw ParserException.MissingOperator(this.lexer.TokenString); } return(false); } /*if (this.opStack.Count > 0) * { * OperatorInfo info = this.opStack.Peek(); * if (info.Operator == Operator.In) * { * throw ParserException.InWithoutParentheses(); * } * }*/ this.prevOperand = OperandType.Scalar; this.nodeStack.Push(this.CreateScalarNode(token, this.lexer.TokenString)); break; case Token.ListSeparator: { if (this.prevOperand == OperandType.None) { if (enableExceptions) { throw ParserException.MissingOperandBefore(","); } return(false); } this.BuildExpression(3); OperatorInfo info = this.opStack.Peek(); if (info.Type != NodeType.Call) { if (enableExceptions) { throw ParserException.SystaxError(); } return(false); } ExpressionNode arg = this.nodeStack.Pop(); FunctionNode func = (FunctionNode)this.nodeStack.Pop(); func.AddArgument(arg); this.nodeStack.Push(func); this.prevOperand = OperandType.None; } break; case Token.LeftParen: parenCount++; if (OperandType.None != this.prevOperand) { this.BuildExpression(22); this.prevOperand = OperandType.None; ExpressionNode node = this.nodeStack.Peek(); if (!(node is NameNode)) { if (enableExceptions) { throw ParserException.SystaxError(); } return(false); } NameNode node1 = (NameNode)this.nodeStack.Pop(); ExpressionNode func; if (AggregateNode.IsAggregare(node1.Name)) { func = new AggregateNode(node1.Name); } else { func = new FunctionNode(node1.Parent, node1.Name); } this.nodeStack.Push(func); this.opStack.Push(new OperatorInfo(NodeType.Call, Operator.Proc)); } else { OperatorInfo info = this.opStack.Peek(); if (info.Type != NodeType.Binop || info.Operator != Operator.In) { this.opStack.Push(new OperatorInfo(NodeType.Paren, Operator.Proc)); } else { this.nodeStack.Push(new FunctionNode(null, "In")); this.opStack.Push(new OperatorInfo(NodeType.Call, Operator.Proc)); } } break; case Token.RightParen: { if (this.prevOperand != OperandType.None) { this.BuildExpression(3); } if (this.opStack.Count <= 1) { if (enableExceptions) { throw ParserException.TooManyRightParentheses(); } return(false); } OperatorInfo info = this.opStack.Pop(); if (this.prevOperand == OperandType.None && info.Type != NodeType.Call) { if (enableExceptions) { throw ParserException.MissingOperand(info.Operator.ToString()); } return(false); } if (info.Type == NodeType.Call) { if (this.prevOperand != OperandType.None) { ExpressionNode argument = this.nodeStack.Pop(); FunctionNode func = (FunctionNode)this.nodeStack.Pop(); func.AddArgument(argument); func.Check(); this.nodeStack.Push(func); } } else { ExpressionNode node = this.nodeStack.Pop(); node = new UnaryOpNode(Operator.Noop, node); // noop -- return value this.nodeStack.Push(node); } this.prevOperand = OperandType.Expr; parenCount--; } break; case Token.ZeroOp: if (OperandType.None != this.prevOperand) { if (enableExceptions) { throw ParserException.MissingOperator(this.lexer.TokenString); } return(false); } this.opStack.Push(new OperatorInfo(NodeType.Zop, this.lexer.Operator)); this.prevOperand = OperandType.Expr; break; case Token.UnaryOp: this.opStack.Push(new OperatorInfo(NodeType.Unop, this.lexer.Operator)); break; case Token.BinaryOp: if (OperandType.None != this.prevOperand) { this.prevOperand = OperandType.None; Operator op = this.lexer.Operator; NodeType nodeType = NodeType.Binop; if (op == Operator.And) { this.BuildExpression(Operator.BetweenAnd.Priority); // eat all ops higher than BETWEEN AND: the unary +/-; comparison ops, etc. OperatorInfo lastOp = this.opStack.Peek(); if (op == Operator.And && lastOp.Operator == Operator.Between) { op = Operator.BetweenAnd; nodeType = NodeType.TernaryOp2; } } this.BuildExpression(op.Priority); this.opStack.Push(new OperatorInfo(nodeType, op)); } else { if (Operator.Plus == this.lexer.Operator) { this.opStack.Push(new OperatorInfo(NodeType.Unop, Operator.UnaryPlus)); } else if (Operator.Minus == this.lexer.Operator) { this.opStack.Push(new OperatorInfo(NodeType.Unop, Operator.Negative)); } else { if (enableExceptions) { throw ParserException.MissingOperandBefore(this.lexer.Operator.ToString()); } return(false); } } break; case Token.TernaryOp: if (OperandType.None != this.prevOperand) { Operator op = this.lexer.Operator; this.prevOperand = OperandType.None; this.BuildExpression(op.Priority); this.opStack.Push(new OperatorInfo(NodeType.TernaryOp, op)); } break; case Token.Dot: { ExpressionNode node = this.nodeStack.Peek(); if (!(node is NameNode) && !(node is FunctionNode) && !(node is ConstNode)) { if (enableExceptions) { throw ParserException.UnknownToken(this.lexer.TokenString, this.lexer.StartPos); } return(false); } try { token = this.lexer.Read(); } catch (LexicalException e) { if (enableExceptions) { throw e; } return(false); } if (Token.Name != token) { if (enableExceptions) { throw ParserException.UnknownToken(this.lexer.TokenString, this.lexer.StartPos); } return(false); } ExpressionNode node1 = this.nodeStack.Pop(); //NameNode node1 = (NameNode)this.nodeStack.Pop(); //string name = node1.Name + "." + this.lexer.TokenString; this.nodeStack.Push(new NameNode(node1, this.lexer.TokenString)); } break; case Token.EOF: if (OperandType.None != this.prevOperand) { this.BuildExpression(3); if (this.opStack.Count != 1) { if (enableExceptions) { throw ParserException.MissingRightParen(); } return(false); } } else if (this.nodeStack.Count > 0) { if (enableExceptions) { throw ParserException.MissingOperand(this.opStack.Peek().Operator.ToString()); } return(false); } break; case Token.Parameter: try { token = this.lexer.Read(); } catch (LexicalException e) { if (enableExceptions) { throw e; } return(false); } if (Token.Name != token) { if (enableExceptions) { throw ParserException.UnknownToken(this.lexer.TokenString, this.lexer.StartPos); } return(false); } NameNode parametersNode = new NameNode(null, "Parameters"); this.nodeStack.Push(new NameNode(parametersNode, this.lexer.TokenString)); this.prevOperand = OperandType.Scalar; break; default: if (enableExceptions) { throw ParserException.UnknownToken(this.lexer.TokenString, this.lexer.StartPos); } return(false); } } while (Token.EOF != token); //Debug.Assert(1 == this.nodeStack.Count); if (this.nodeStack.Count != 1) { return(false); } expressionNode = this.nodeStack.Peek(); if (expressionNode == null) { return(false); } return(true); }
private bool TryParse(bool enableExceptions, out ExpressionNode expressionNode) { expressionNode = (ExpressionNode)null; int num = 0; this.StartParse(); Token token; do { try { token = this.lexer.Read(); } catch (LexicalException ex) { if (enableExceptions) { throw ex; } return(false); } switch (token) { case Token.Name: case Token.Numeric: case Token.Decimal: case Token.Float: case Token.NumericHex: case Token.StringConst: case Token.Date: if (this.prevOperand != OperandType.None) { if (enableExceptions) { throw ParserException.MissingOperator(this.lexer.TokenString); } return(false); } this.prevOperand = OperandType.Scalar; this.nodeStack.Push(this.CreateScalarNode(token, this.lexer.TokenString)); break; case Token.ListSeparator: if (this.prevOperand == OperandType.None) { if (enableExceptions) { throw ParserException.MissingOperandBefore(","); } return(false); } this.BuildExpression(3); if (this.opStack.Peek().Type != ExpressionParser.NodeType.Call) { if (enableExceptions) { throw ParserException.SystaxError(); } return(false); } ExpressionNode expressionNode1 = this.nodeStack.Pop(); FunctionNode functionNode1 = (FunctionNode)this.nodeStack.Pop(); functionNode1.AddArgument(expressionNode1); this.nodeStack.Push((ExpressionNode)functionNode1); this.prevOperand = OperandType.None; break; case Token.LeftParen: ++num; if (this.prevOperand != OperandType.None) { this.BuildExpression(22); this.prevOperand = OperandType.None; if (!(this.nodeStack.Peek() is NameNode)) { if (enableExceptions) { throw ParserException.SystaxError(); } return(false); } NameNode nameNode = (NameNode)this.nodeStack.Pop(); this.nodeStack.Push(!AggregateNode.IsAggregare(nameNode.Name) ? (ExpressionNode) new FunctionNode(nameNode.Parent, nameNode.Name) : (ExpressionNode) new AggregateNode(nameNode.Name)); this.opStack.Push(new ExpressionParser.OperatorInfo(ExpressionParser.NodeType.Call, Operator.Proc)); break; } ExpressionParser.OperatorInfo operatorInfo1 = this.opStack.Peek(); if (operatorInfo1.Type != ExpressionParser.NodeType.Binop || operatorInfo1.Operator != Operator.In) { this.opStack.Push(new ExpressionParser.OperatorInfo(ExpressionParser.NodeType.Paren, Operator.Proc)); break; } this.nodeStack.Push((ExpressionNode) new FunctionNode((ExpressionNode)null, "In")); this.opStack.Push(new ExpressionParser.OperatorInfo(ExpressionParser.NodeType.Call, Operator.Proc)); break; case Token.RightParen: if (this.prevOperand != OperandType.None) { this.BuildExpression(3); } if (this.opStack.Count <= 1) { if (enableExceptions) { throw ParserException.TooManyRightParentheses(); } return(false); } ExpressionParser.OperatorInfo operatorInfo2 = this.opStack.Pop(); if (this.prevOperand == OperandType.None && operatorInfo2.Type != ExpressionParser.NodeType.Call) { if (enableExceptions) { throw ParserException.MissingOperand(operatorInfo2.Operator.ToString()); } return(false); } if (operatorInfo2.Type == ExpressionParser.NodeType.Call) { if (this.prevOperand != OperandType.None) { ExpressionNode expressionNode2 = this.nodeStack.Pop(); FunctionNode functionNode2 = (FunctionNode)this.nodeStack.Pop(); functionNode2.AddArgument(expressionNode2); functionNode2.Check(); this.nodeStack.Push((ExpressionNode)functionNode2); } } else { ExpressionNode right = this.nodeStack.Pop(); this.nodeStack.Push((ExpressionNode) new UnaryOpNode(Operator.Noop, right)); } this.prevOperand = OperandType.Expr; --num; break; case Token.ZeroOp: if (this.prevOperand != OperandType.None) { if (enableExceptions) { throw ParserException.MissingOperator(this.lexer.TokenString); } return(false); } this.opStack.Push(new ExpressionParser.OperatorInfo(ExpressionParser.NodeType.Zop, this.lexer.Operator)); this.prevOperand = OperandType.Expr; break; case Token.UnaryOp: this.opStack.Push(new ExpressionParser.OperatorInfo(ExpressionParser.NodeType.Unop, this.lexer.Operator)); break; case Token.BinaryOp: if (this.prevOperand != OperandType.None) { this.prevOperand = OperandType.None; Operator betweenAnd = this.lexer.Operator; ExpressionParser.NodeType type = ExpressionParser.NodeType.Binop; if (betweenAnd == Operator.And) { this.BuildExpression(Operator.BetweenAnd.Priority); ExpressionParser.OperatorInfo operatorInfo3 = this.opStack.Peek(); if (betweenAnd == Operator.And && operatorInfo3.Operator == Operator.Between) { betweenAnd = Operator.BetweenAnd; type = ExpressionParser.NodeType.TernaryOp2; } } this.BuildExpression(betweenAnd.Priority); this.opStack.Push(new ExpressionParser.OperatorInfo(type, betweenAnd)); break; } if (Operator.Plus == this.lexer.Operator) { this.opStack.Push(new ExpressionParser.OperatorInfo(ExpressionParser.NodeType.Unop, Operator.UnaryPlus)); break; } if (Operator.Minus == this.lexer.Operator) { this.opStack.Push(new ExpressionParser.OperatorInfo(ExpressionParser.NodeType.Unop, Operator.Negative)); break; } if (enableExceptions) { throw ParserException.MissingOperandBefore(this.lexer.Operator.ToString()); } return(false); case Token.TernaryOp: if (this.prevOperand != OperandType.None) { Operator op = this.lexer.Operator; this.prevOperand = OperandType.None; this.BuildExpression(op.Priority); this.opStack.Push(new ExpressionParser.OperatorInfo(ExpressionParser.NodeType.TernaryOp, op)); break; } break; case Token.Dot: ExpressionNode expressionNode3 = this.nodeStack.Peek(); if (!(expressionNode3 is NameNode)) { if (!(expressionNode3 is FunctionNode)) { if (!(expressionNode3 is ConstNode)) { if (enableExceptions) { throw ParserException.UnknownToken(this.lexer.TokenString, this.lexer.StartPos); } return(false); } } } try { token = this.lexer.Read(); } catch (LexicalException ex) { if (enableExceptions) { throw ex; } return(false); } if (Token.Name != token) { if (enableExceptions) { throw ParserException.UnknownToken(this.lexer.TokenString, this.lexer.StartPos); } return(false); } this.nodeStack.Push((ExpressionNode) new NameNode(this.nodeStack.Pop(), this.lexer.TokenString)); break; case Token.Parameter: try { token = this.lexer.Read(); } catch (LexicalException ex) { if (enableExceptions) { throw ex; } return(false); } if (Token.Name != token) { if (enableExceptions) { throw ParserException.UnknownToken(this.lexer.TokenString, this.lexer.StartPos); } return(false); } this.nodeStack.Push((ExpressionNode) new NameNode((ExpressionNode) new NameNode((ExpressionNode)null, "Parameters"), this.lexer.TokenString)); this.prevOperand = OperandType.Scalar; break; case Token.EOF: if (this.prevOperand != OperandType.None) { this.BuildExpression(3); if (this.opStack.Count != 1) { if (enableExceptions) { throw ParserException.MissingRightParen(); } return(false); } break; } if (this.nodeStack.Count > 0) { if (enableExceptions) { throw ParserException.MissingOperand(this.opStack.Peek().Operator.ToString()); } return(false); } break; default: if (enableExceptions) { throw ParserException.UnknownToken(this.lexer.TokenString, this.lexer.StartPos); } return(false); } }while (Token.EOF != token); if (this.nodeStack.Count != 1) { return(false); } expressionNode = this.nodeStack.Peek(); return(expressionNode != null); }