Method F

expr/parse.go:495–581

F -> v | "(" O ")" | "!" O | "-" O | "NOT" C | "EXISTS" v | "IS" O | "AND (" O ")" | "OR (" O ")"

(depth int)

// F -> v | "(" O ")" | "!" O | "-" O | "NOT" C | "EXISTS" v | "IS" O | "AND (" O ")" | "OR (" O ")"
func (t *tree) F(depth int) Node {
	debugf(depth, "F: %v", t.Cur())

	// Urnary operations
	switch cur := t.Cur(); cur.T {
	case lex.TokenNegate, lex.TokenMinus:

		t.Next() // consume NOT, !, Minus

		debugf(depth, "start:%v cur: %v   peek:%v", cur, t.Cur(), t.Peek())
		var arg Node

		switch t.Peek().T {
		case lex.TokenIN, lex.TokenLike, lex.TokenContains, lex.TokenBetween,
			lex.TokenIntersects:
			// TODO:  this is a bug.  An old version of generator was saving these
			//  NOT news INTERSECTS ("a")    which is invalid it should be
			//  news NOT INTERSECTS ("a")  OR NOT (news INTERSECTS ("a"))
			//
			// NOT <expr> LIKE <expr>
			// NOT <expr> INTERSECTS <expr>
			// NOT <expr> BETWEEN <expr> AND <expr>
			// NOT <expr> CONTAINS <expr>
			// NOT <expr> IN <expr>
			//
			// NOT identity > 7

			arg = t.C(depth + 1)
		default:

			switch t.Cur().T {
			case lex.TokenUdfExpr:
				arg = t.v(depth + 1)
			default:
				arg = t.C(depth + 1)
			}
		}
		n := NewUnary(cur, arg)
		debugf(depth, "f urnary: %s   arg: %#v", n, arg)
		return n
	case lex.TokenExists:
		// Urnary operations:  require right side value node
		t.Next() // Consume "EXISTS"
		debugf(depth, "F PRE  EXISTS:%v   cur:%v", cur, t.Cur())
		n := NewUnary(cur, t.v(depth+1))
		debugf(depth, "F POST EXISTS: %s  cur:%v", n, t.Cur())
		return n
	case lex.TokenIs:
		nxt := t.Next()
		if nxt.T == lex.TokenNegate {
			return NewUnary(cur, t.F(depth+1))
		}
		return NewUnary(cur, t.F(depth+1))
	case lex.TokenLogicAnd, lex.TokenLogicOr:
		debugf(depth, "found boolean and/or (O)? %v", cur)
		t.Next() // consume AND/OR
		t.discardNewLinesAndComments()
		switch t.Cur().T {