(n Node, depth int)
| 389 | } |
| 390 | |
| 391 | func (t *tree) cInner(n Node, depth int) Node { |
| 392 | for { |
| 393 | debugf(depth, "cInner: tok: cur=%v peek=%v n=%v", t.Cur(), t.Peek(), n) |
| 394 | switch cur := t.Cur(); cur.T { |
| 395 | case lex.TokenEqual, lex.TokenEqualEqual, lex.TokenNE, lex.TokenGT, lex.TokenGE, |
| 396 | lex.TokenLE, lex.TokenLT, lex.TokenLike, lex.TokenContains: |
| 397 | t.Next() |
| 398 | n = NewBinaryNode(cur, n, t.P(depth+1)) |
| 399 | case lex.TokenBetween: |
| 400 | // weird syntax: BETWEEN x AND y AND is ignored essentially |
| 401 | t.Next() |
| 402 | n2 := t.P(depth) |
| 403 | t.expect(lex.TokenLogicAnd, "input") |
| 404 | t.Next() |
| 405 | n = NewTriNode(cur, n, n2, t.P(depth+1)) |
| 406 | case lex.TokenIN: |
| 407 | t.Next() |
| 408 | switch t.Cur().T { |
| 409 | case lex.TokenIdentity: |
| 410 | ident := t.Next() |
| 411 | return NewBinaryNode(cur, n, NewIdentityNode(&ident)) |
| 412 | case lex.TokenLeftBracket: |
| 413 | // Right side is an array of values |
| 414 | t.Next() |
| 415 | val, err := ValueArray(depth, t.TokenPager) |
| 416 | if err != nil { |
| 417 | t.errorf("Could not build an array: %v", err) |
| 418 | } |
| 419 | return NewBinaryNode(cur, n, NewValueNode(val)) |
| 420 | case lex.TokenLeftParenthesis: |
| 421 | // This is a special type of Binary? its 2nd argument is a array node |
| 422 | return NewBinaryNode(cur, n, t.ArrayNode(depth)) |
| 423 | case lex.TokenUdfExpr: |
| 424 | fn := t.Next() // consume Function Name |
| 425 | return NewBinaryNode(cur, n, t.Func(depth, fn)) |
| 426 | case lex.TokenValue, lex.TokenString: |
| 427 | v := t.Next() |
| 428 | return NewBinaryNode(cur, n, NewStringNode(v.V)) |
| 429 | case lex.TokenValueEscaped: |
| 430 | v := t.Next() |
| 431 | return NewBinaryNode(cur, n, NewStringNeedsEscape(v)) |
| 432 | default: |
| 433 | t.unexpected(t.Cur(), "Right side of IN expected (identity|array|func|value) but got") |
| 434 | } |
| 435 | case lex.TokenIntersects: |
| 436 | t.Next() // Consume "INTERSECTS" |
| 437 | switch t.Cur().T { |
| 438 | case lex.TokenIdentity: |
| 439 | // x INTERSECTS field where field MUST be an array |
| 440 | ident := t.Next() |
| 441 | in := NewIdentityNode(&ident) |
| 442 | if in.IsBooleanIdentity() { |
| 443 | t.unexpected(t.Cur(), "expected array on right side of INTERSECTS") |
| 444 | } |
| 445 | return NewBinaryNode(cur, n, in) |
| 446 | case lex.TokenLeftParenthesis, lex.TokenLeftBracket: |
| 447 | // The 2nd argument is an array node |
| 448 | return NewBinaryNode(cur, n, t.ArrayNode(depth)) |
no test coverage detected