public static UnknownToken ( Tokens tokExpected, Tokens tokCurr, int position ) : Exception | ||
tokExpected | Tokens | |
tokCurr | Tokens | |
position | int | |
리턴 | Exception |
internal void CheckToken(Tokens token) { if (_token != token) { throw ExprException.UnknownToken(token, _token, _pos); } }
internal Tokens Scan() { char ch; char[] text = _text; _token = Tokens.None; while (true) { loop: _start = _pos; _op = Operators.Noop; ch = text[_pos++]; switch (ch) { case (char)0: _token = Tokens.EOS; goto end_loop; case ' ': case '\t': case '\n': case '\r': ScanWhite(); goto loop; case '(': _token = Tokens.LeftParen; goto end_loop; case ')': _token = Tokens.RightParen; goto end_loop; case '#': ScanDate(); CheckToken(Tokens.Date); goto end_loop; case '\'': ScanString('\''); CheckToken(Tokens.StringConst); goto end_loop; case '=': _token = Tokens.BinaryOp; _op = Operators.EqualTo; goto end_loop; case '>': _token = Tokens.BinaryOp; ScanWhite(); if (text[_pos] == '=') { _pos++; _op = Operators.GreaterOrEqual; } else { _op = Operators.GreaterThen; } goto end_loop; case '<': _token = Tokens.BinaryOp; ScanWhite(); if (text[_pos] == '=') { _pos++; _op = Operators.LessOrEqual; } else if (text[_pos] == '>') { _pos++; _op = Operators.NotEqual; } else { _op = Operators.LessThen; } goto end_loop; case '+': _token = Tokens.BinaryOp; _op = Operators.Plus; goto end_loop; case '-': _token = Tokens.BinaryOp; _op = Operators.Minus; goto end_loop; case '*': _token = Tokens.BinaryOp; _op = Operators.Multiply; goto end_loop; case '/': _token = Tokens.BinaryOp; _op = Operators.Divide; goto end_loop; case '%': _token = Tokens.BinaryOp; _op = Operators.Modulo; goto end_loop; /* Beginning of bitwise operators */ case '&': _token = Tokens.BinaryOp; _op = Operators.BitwiseAnd; goto end_loop; case '|': _token = Tokens.BinaryOp; _op = Operators.BitwiseOr; goto end_loop; case '^': _token = Tokens.BinaryOp; _op = Operators.BitwiseXor; goto end_loop; case '~': _token = Tokens.BinaryOp; _op = Operators.BitwiseNot; goto end_loop; /* we have bracketed identifier */ case '[': // BUG: special case ScanName(']', _escape, "]\\"); CheckToken(Tokens.Name); goto end_loop; case '`': ScanName('`', '`', "`"); CheckToken(Tokens.Name); goto end_loop; default: /* Check for list separator */ if (ch == _listSeparator) { _token = Tokens.ListSeparator; goto end_loop; } if (ch == '.') { if (_prevOperand == Empty) { ScanNumeric(); } else { _token = Tokens.Dot; } goto end_loop; } /* Check for binary constant */ if (ch == '0' && (text[_pos] == 'x' || text[_pos] == 'X')) { _token = Tokens.BinaryConst; goto end_loop; } /* Check for number: digit is always good; . or - only if osNil. */ if (IsDigit(ch)) { ScanNumeric(); goto end_loop; } /* Check for reserved word */ ScanReserved(); if (_token != Tokens.None) { goto end_loop; } /* Alpha means identifier */ if (IsAlphaNumeric(ch)) { ScanName(); if (_token != Tokens.None) { CheckToken(Tokens.Name); goto end_loop; } } /* Don't understand that banter at all. */ _token = Tokens.Unknown; throw ExprException.UnknownToken(new string(text, _start, _pos - _start), _start + 1); } } end_loop: return(_token); }
internal Tokens Scan() { char[] text = this.text; this.token = Tokens.None; Label_000E: this.start = this.pos; this.op = 0; char ch = text[this.pos++]; switch (ch) { case '\t': case '\n': case '\r': case ' ': this.ScanWhite(); goto Label_000E; case '\0': this.token = Tokens.EOS; break; case '#': this.ScanDate(); this.CheckToken(Tokens.Date); break; case '%': this.token = Tokens.BinaryOp; this.op = 20; break; case '&': this.token = Tokens.BinaryOp; this.op = 0x16; break; case '\'': this.ScanString('\''); this.CheckToken(Tokens.StringConst); break; case '(': this.token = Tokens.LeftParen; break; case ')': this.token = Tokens.RightParen; break; case '*': this.token = Tokens.BinaryOp; this.op = 0x11; break; case '+': this.token = Tokens.BinaryOp; this.op = 15; break; case '-': this.token = Tokens.BinaryOp; this.op = 0x10; break; case '/': this.token = Tokens.BinaryOp; this.op = 0x12; break; case '<': this.token = Tokens.BinaryOp; this.ScanWhite(); if (text[this.pos] != '=') { if (text[this.pos] == '>') { this.pos++; this.op = 12; } else { this.op = 9; } } else { this.pos++; this.op = 11; } break; case '=': this.token = Tokens.BinaryOp; this.op = 7; break; case '>': this.token = Tokens.BinaryOp; this.ScanWhite(); if (text[this.pos] != '=') { this.op = 8; } else { this.pos++; this.op = 10; } break; case '[': this.ScanName(']', this.Escape, @"]\"); this.CheckToken(Tokens.Name); break; case '^': this.token = Tokens.BinaryOp; this.op = 0x18; break; case '`': this.ScanName('`', '`', "`"); this.CheckToken(Tokens.Name); break; case '|': this.token = Tokens.BinaryOp; this.op = 0x17; break; case '~': this.token = Tokens.BinaryOp; this.op = 0x19; break; default: if (ch == this.ListSeparator) { this.token = Tokens.ListSeparator; } else if (ch == '.') { if (this.prevOperand == 0) { this.ScanNumeric(); } else { this.token = Tokens.Dot; } } else if ((ch == '0') && ((text[this.pos] == 'x') || (text[this.pos] == 'X'))) { this.ScanBinaryConstant(); this.token = Tokens.BinaryConst; } else if (this.IsDigit(ch)) { this.ScanNumeric(); } else { this.ScanReserved(); if (this.token == Tokens.None) { if (this.IsAlphaNumeric(ch)) { this.ScanName(); if (this.token != Tokens.None) { this.CheckToken(Tokens.Name); break; } } this.token = Tokens.Unknown; throw ExprException.UnknownToken(new string(text, this.start, this.pos - this.start), this.start + 1); } } break; } return(this.token); }
// CONSIDER: configure the scanner : local info internal ExpressionNode Parse() { // free all nodes _expression = null; StartScan(); int cParens = 0; OperatorInfo opInfo; while (_token != Tokens.EOS) { loop: Scan(); switch (_token) { case Tokens.EOS: // End of string: must be operand; force out expression; // check for bomb; check nothing left on stack. if (_prevOperand == Empty) { if (_topNode == 0) { // we have an empty expression break; } // set error missing operator // read the last operator info opInfo = _ops[_topOperator - 1]; throw ExprException.MissingOperand(opInfo); } // collect all nodes BuildExpression(Operators.priLow); if (_topOperator != 1) { throw ExprException.MissingRightParen(); } break; case Tokens.Name: case Tokens.Parent: case Tokens.Numeric: case Tokens.Decimal: case Tokens.Float: case Tokens.StringConst: case Tokens.Date: ExpressionNode node = null; string str = null; /* Constants and identifiers: create leaf node */ if (_prevOperand != Empty) { // set error missing operator throw ExprException.MissingOperator(new string(_text, _start, _pos - _start)); } if (_topOperator > 0) { // special check for IN without parentheses opInfo = _ops[_topOperator - 1]; if (opInfo._type == Nodes.Binop && opInfo._op == Operators.In && _token != Tokens.Parent) { throw ExprException.InWithoutParentheses(); } } _prevOperand = Scalar; switch (_token) { case Tokens.Parent: string relname; string colname; // parsing Parent[(relation_name)].column_name) try { // expecting an '(' or '.' Scan(); if (_token == Tokens.LeftParen) { //read the relation name ScanToken(Tokens.Name); relname = NameNode.ParseName(_text, _start, _pos); ScanToken(Tokens.RightParen); ScanToken(Tokens.Dot); } else { relname = null; CheckToken(Tokens.Dot); } } catch (Exception e) when(Common.ADP.IsCatchableExceptionType(e)) { throw ExprException.LookupArgument(); } ScanToken(Tokens.Name); colname = NameNode.ParseName(_text, _start, _pos); opInfo = _ops[_topOperator - 1]; node = new LookupNode(_table, colname, relname); break; case Tokens.Name: /* Qualify name now for nice error checking */ opInfo = _ops[_topOperator - 1]; /* Create tree element - */ // CONSIDER: Check for reserved proc names here node = new NameNode(_table, _text, _start, _pos); break; case Tokens.Numeric: str = new string(_text, _start, _pos - _start); node = new ConstNode(_table, ValueType.Numeric, str); break; case Tokens.Decimal: str = new string(_text, _start, _pos - _start); node = new ConstNode(_table, ValueType.Decimal, str); break; case Tokens.Float: str = new string(_text, _start, _pos - _start); node = new ConstNode(_table, ValueType.Float, str); break; case Tokens.StringConst: Debug.Assert(_text[_start] == '\'' && _text[_pos - 1] == '\'', "The expression contains an invalid string constant"); Debug.Assert(_pos - _start > 1, "The expression contains an invalid string constant"); // Store string without quotes.. str = new string(_text, _start + 1, _pos - _start - 2); node = new ConstNode(_table, ValueType.Str, str); break; case Tokens.Date: Debug.Assert(_text[_start] == '#' && _text[_pos - 1] == '#', "The expression contains invalid date constant."); Debug.Assert(_pos - _start > 2, "The expression contains invalid date constant '{0}'."); // Store date without delimiters(#s).. str = new string(_text, _start + 1, _pos - _start - 2); node = new ConstNode(_table, ValueType.Date, str); break; default: Debug.Fail("unhandled token"); break; } NodePush(node); goto loop; case Tokens.LeftParen: cParens++; if (_prevOperand == Empty) { // Check for ( following IN/IFF. if not, we have a normal (. // Peek: take a look at the operators stack Debug.Assert(_topOperator > 0, "Empty operator stack!!"); opInfo = _ops[_topOperator - 1]; if (opInfo._type == Nodes.Binop && opInfo._op == Operators.In) { /* IN - handle as procedure call */ node = new FunctionNode(_table, "In"); NodePush(node); /* Push operator decriptor */ _ops[_topOperator++] = new OperatorInfo(Nodes.Call, Operators.Noop, Operators.priParen); } else { /* Normal ( */ /* Push operator decriptor */ _ops[_topOperator++] = new OperatorInfo(Nodes.Paren, Operators.Noop, Operators.priParen); } } else { // This is a procedure call or () qualification // Force out any dot qualifiers; check for bomb BuildExpression(Operators.priProc); _prevOperand = Empty; ExpressionNode nodebefore = NodePeek(); if (nodebefore == null || nodebefore.GetType() != typeof(NameNode)) { // this is more like an assert, so we not care about "nice" exception text.. throw ExprException.SyntaxError(); } /* Get the proc name */ NameNode name = (NameNode)NodePop(); // Make sure that we can bind the name as a Function // then get the argument count and types, and parse arguments.. node = new FunctionNode(_table, name._name); // check to see if this is an aggregate function Aggregate agg = (Aggregate)(int)((FunctionNode)node).Aggregate; if (agg != Aggregate.None) { node = ParseAggregateArgument((FunctionId)(int)agg); NodePush(node); _prevOperand = Expr; goto loop; } NodePush(node); _ops[_topOperator++] = new OperatorInfo(Nodes.Call, Operators.Noop, Operators.priParen); } goto loop; case Tokens.RightParen: { /* Right parentheses: Build expression if we have an operand. */ if (_prevOperand != Empty) { BuildExpression(Operators.priLow); } /* We must have Tokens.LeftParen on stack. If no operand, must be procedure call. */ if (_topOperator <= 1) { // set error, syntax: too many right parens.. throw ExprException.TooManyRightParentheses(); } Debug.Assert(_topOperator > 1, "melformed operator stack."); _topOperator--; opInfo = _ops[_topOperator]; if (_prevOperand == Empty && opInfo._type != Nodes.Call) { // set error, syntax: missing operand. throw ExprException.MissingOperand(opInfo); } Debug.Assert(opInfo._priority == Operators.priParen, "melformed operator stack."); if (opInfo._type == Nodes.Call) { /* add argument to the function call. */ if (_prevOperand != Empty) { // read last function argument ExpressionNode argument = NodePop(); /* Get the procedure name and append argument */ Debug.Assert(_topNode > 0 && NodePeek().GetType() == typeof(FunctionNode), "The function node should be created on '('"); FunctionNode func = (FunctionNode)NodePop(); func.AddArgument(argument); func.Check(); NodePush(func); } } else { /* Normal parentheses: create tree node */ // Construct & Put the Nodes.Paren node on node stack node = NodePop(); node = new UnaryNode(_table, Operators.Noop, node); NodePush(node); } _prevOperand = Expr; cParens--; goto loop; } case Tokens.ListSeparator: { /* Comma encountered: Must be operand; force out subexpression */ if (_prevOperand == Empty) { throw ExprException.MissingOperandBefore(","); } /* We are be in a procedure call */ /* build next argument */ BuildExpression(Operators.priLow); opInfo = _ops[_topOperator - 1]; if (opInfo._type != Nodes.Call) { throw ExprException.SyntaxError(); } ExpressionNode argument2 = NodePop(); /* Get the procedure name */ FunctionNode func = (FunctionNode)NodePop(); func.AddArgument(argument2); NodePush(func); _prevOperand = Empty; goto loop; } case Tokens.BinaryOp: if (_prevOperand == Empty) { /* Check for unary plus/minus */ if (_op == Operators.Plus) { _op = Operators.UnaryPlus; // fall through to UnaryOperator; } else if (_op == Operators.Minus) { /* Unary minus */ _op = Operators.Negative; // fall through to UnaryOperator; } else { // Error missing operand: throw ExprException.MissingOperandBefore(Operators.ToString(_op)); } } else { _prevOperand = Empty; /* CNSIDER: If we are going to support BETWEEN Translate AND to special BetweenAnd if it is. */ /* Force out to appropriate precedence; push operator. */ BuildExpression(Operators.Priority(_op)); // PushOperator descriptor _ops[_topOperator++] = new OperatorInfo(Nodes.Binop, _op, Operators.Priority(_op)); goto loop; } goto case Tokens.UnaryOp; // fall through to UnaryOperator; case Tokens.UnaryOp: /* Must be no operand. Push it. */ _ops[_topOperator++] = new OperatorInfo(Nodes.Unop, _op, Operators.Priority(_op)); goto loop; case Tokens.ZeroOp: // check the we have operator on the stack if (_prevOperand != Empty) { // set error missing operator throw ExprException.MissingOperator(new string(_text, _start, _pos - _start)); } // PushOperator descriptor _ops[_topOperator++] = new OperatorInfo(Nodes.Zop, _op, Operators.priMax); _prevOperand = Expr; goto loop; case Tokens.Dot: //if there is a name on the stack append it. ExpressionNode before = NodePeek(); if (before != null && before.GetType() == typeof(NameNode)) { Scan(); if (_token == Tokens.Name) { NameNode nameBefore = (NameNode)NodePop(); string newName = nameBefore._name + "." + NameNode.ParseName(_text, _start, _pos); NodePush(new NameNode(_table, newName)); goto loop; } } // fall through to default goto default; default: throw ExprException.UnknownToken(new string(_text, _start, _pos - _start), _start + 1); } } goto end_loop; end_loop: Debug.Assert(_topNode == 1 || _topNode == 0, "Invalid Node Stack"); _expression = _nodeStack[0]; return(_expression); }
internal ExpressionNode Parse() { ExpressionNode node; OperatorInfo info; this.expression = null; this.StartScan(); int num = 0; goto Label_078F; Label_0014: this.Scan(); switch (this.token) { case Tokens.Name: case Tokens.Numeric: case Tokens.Decimal: case Tokens.Float: case Tokens.StringConst: case Tokens.Date: case Tokens.Parent: { node = null; string constant = null; if (this.prevOperand != 0) { throw ExprException.MissingOperator(new string(this.text, this.start, this.pos - this.start)); } if (this.topOperator > 0) { info = this.ops[this.topOperator - 1]; if (((info.type == Nodes.Binop) && (info.op == 5)) && (this.token != Tokens.Parent)) { throw ExprException.InWithoutParentheses(); } } this.prevOperand = 1; switch (this.token) { case Tokens.Name: info = this.ops[this.topOperator - 1]; node = new NameNode(this._table, this.text, this.start, this.pos); goto Label_0338; case Tokens.Numeric: constant = new string(this.text, this.start, this.pos - this.start); node = new ConstNode(this._table, System.Data.ValueType.Numeric, constant); goto Label_0338; case Tokens.Decimal: constant = new string(this.text, this.start, this.pos - this.start); node = new ConstNode(this._table, System.Data.ValueType.Decimal, constant); goto Label_0338; case Tokens.Float: constant = new string(this.text, this.start, this.pos - this.start); node = new ConstNode(this._table, System.Data.ValueType.Float, constant); goto Label_0338; case Tokens.StringConst: constant = new string(this.text, this.start + 1, (this.pos - this.start) - 2); node = new ConstNode(this._table, System.Data.ValueType.Str, constant); goto Label_0338; case Tokens.Date: constant = new string(this.text, this.start + 1, (this.pos - this.start) - 2); node = new ConstNode(this._table, System.Data.ValueType.Date, constant); goto Label_0338; case Tokens.Parent: { string str2; try { this.Scan(); if (this.token == Tokens.LeftParen) { this.ScanToken(Tokens.Name); str2 = NameNode.ParseName(this.text, this.start, this.pos); this.ScanToken(Tokens.RightParen); this.ScanToken(Tokens.Dot); } else { str2 = null; this.CheckToken(Tokens.Dot); } } catch (Exception exception) { if (!ADP.IsCatchableExceptionType(exception)) { throw; } throw ExprException.LookupArgument(); } this.ScanToken(Tokens.Name); string columnName = NameNode.ParseName(this.text, this.start, this.pos); info = this.ops[this.topOperator - 1]; node = new LookupNode(this._table, columnName, str2); goto Label_0338; } } break; } case Tokens.ListSeparator: { if (this.prevOperand == 0) { throw ExprException.MissingOperandBefore(","); } this.BuildExpression(3); info = this.ops[this.topOperator - 1]; if (info.type != Nodes.Call) { throw ExprException.SyntaxError(); } ExpressionNode argument = this.NodePop(); FunctionNode node4 = (FunctionNode)this.NodePop(); node4.AddArgument(argument); this.NodePush(node4); this.prevOperand = 0; goto Label_0014; } case Tokens.LeftParen: num++; if (this.prevOperand != 0) { this.BuildExpression(0x16); this.prevOperand = 0; ExpressionNode node5 = this.NodePeek(); if ((node5 == null) || (node5.GetType() != typeof(NameNode))) { throw ExprException.SyntaxError(); } NameNode node9 = (NameNode)this.NodePop(); node = new FunctionNode(this._table, node9.name); Aggregate aggregate = (Aggregate)((FunctionNode)node).Aggregate; if (aggregate != Aggregate.None) { node = this.ParseAggregateArgument((FunctionId)aggregate); this.NodePush(node); this.prevOperand = 2; } else { this.NodePush(node); this.ops[this.topOperator++] = new OperatorInfo(Nodes.Call, 0, 2); } } else { info = this.ops[this.topOperator - 1]; if ((info.type != Nodes.Binop) || (info.op != 5)) { this.ops[this.topOperator++] = new OperatorInfo(Nodes.Paren, 0, 2); } else { node = new FunctionNode(this._table, "In"); this.NodePush(node); this.ops[this.topOperator++] = new OperatorInfo(Nodes.Call, 0, 2); } } goto Label_0014; case Tokens.RightParen: if (this.prevOperand != 0) { this.BuildExpression(3); } if (this.topOperator <= 1) { throw ExprException.TooManyRightParentheses(); } this.topOperator--; info = this.ops[this.topOperator]; if ((this.prevOperand == 0) && (info.type != Nodes.Call)) { throw ExprException.MissingOperand(info); } if (info.type == Nodes.Call) { if (this.prevOperand != 0) { ExpressionNode node8 = this.NodePop(); FunctionNode node2 = (FunctionNode)this.NodePop(); node2.AddArgument(node8); node2.Check(); this.NodePush(node2); } } else { node = this.NodePop(); node = new UnaryNode(this._table, 0, node); this.NodePush(node); } this.prevOperand = 2; num--; goto Label_0014; case Tokens.ZeroOp: if (this.prevOperand != 0) { throw ExprException.MissingOperator(new string(this.text, this.start, this.pos - this.start)); } this.ops[this.topOperator++] = new OperatorInfo(Nodes.Zop, this.op, 0x18); this.prevOperand = 2; goto Label_0014; case Tokens.UnaryOp: goto Label_0647; case Tokens.BinaryOp: if (this.prevOperand != 0) { this.prevOperand = 0; this.BuildExpression(Operators.Priority(this.op)); this.ops[this.topOperator++] = new OperatorInfo(Nodes.Binop, this.op, Operators.Priority(this.op)); goto Label_0014; } if (this.op != 15) { if (this.op != 0x10) { throw ExprException.MissingOperandBefore(Operators.ToString(this.op)); } this.op = 1; } else { this.op = 2; } goto Label_0647; case Tokens.Dot: { ExpressionNode node3 = this.NodePeek(); if ((node3 == null) || !(node3.GetType() == typeof(NameNode))) { goto Label_0763; } this.Scan(); if (this.token != Tokens.Name) { goto Label_0763; } NameNode node6 = (NameNode)this.NodePop(); string name = node6.name + "." + NameNode.ParseName(this.text, this.start, this.pos); this.NodePush(new NameNode(this._table, name)); goto Label_0014; } case Tokens.EOS: if (this.prevOperand != 0) { this.BuildExpression(3); if (this.topOperator != 1) { throw ExprException.MissingRightParen(); } } else if (this.topNode != 0) { info = this.ops[this.topOperator - 1]; throw ExprException.MissingOperand(info); } goto Label_078F; default: goto Label_0763; } Label_0338: this.NodePush(node); goto Label_0014; Label_0647: this.ops[this.topOperator++] = new OperatorInfo(Nodes.Unop, this.op, Operators.Priority(this.op)); goto Label_0014; Label_0763: throw ExprException.UnknownToken(new string(this.text, this.start, this.pos - this.start), this.start + 1); Label_078F: if (this.token != Tokens.EOS) { goto Label_0014; } this.expression = this.NodeStack[0]; return(this.expression); }