Method getContainExpression

parser/parser.go:844–903

getContainExpression - Return ast.ContainExpression created from tokens and validate the syntax

(leftSide token.Token, isAnonymitifier bool)

// getContainExpression - Return ast.ContainExpression created from tokens and validate the syntax
func (parser *Parser) getContainExpression(leftSide token.Token, isAnonymitifier bool) (bool, *ast.ContainExpression, error) {
	containExpression := &ast.ContainExpression{}

	if isAnonymitifier {
		return false, nil, &SyntaxError{expecting: []string{token.IDENT}, got: "'" + leftSide.Literal + "'"}
	}

	containExpression.Left = ast.Identifier{Token: leftSide}

	if parser.currentToken.Type == token.IN {
		containExpression.Contains = true
	} else {
		containExpression.Contains = false
	}

	// skip IN or NOTIN
	parser.nextToken()

	err := validateTokenAndSkip(parser, []token.Type{token.LPAREN})
	if err != nil {
		return false, nil, err
	}

	for parser.currentToken.Type == token.IDENT || parser.currentToken.Type == token.LITERAL || parser.currentToken.Type == token.NULL || parser.currentToken.Type == token.APOSTROPHE {
		startedWithApostrophe := parser.skipIfCurrentTokenIsApostrophe()

		err = validateToken(parser.currentToken.Type, []token.Type{token.IDENT, token.LITERAL, token.NULL})
		if err != nil {
			return false, nil, err
		}
		currentAnonymitifier := ast.Anonymitifier{Token: parser.currentToken}
		containExpression.Right = append(containExpression.Right, currentAnonymitifier)
		// Ignore token.IDENT, token.LITERAL or token.NULL
		parser.nextToken()

		finishedWithApostrophe := parser.skipIfCurrentTokenIsApostrophe()

		err = validateApostropheWrapping(startedWithApostrophe, finishedWithApostrophe, currentAnonymitifier.GetToken())
		if err != nil {
			return false, nil, err
		}

		if parser.currentToken.Type != token.COMMA {
			if parser.currentToken.Type != token.RPAREN {
				return false, nil, &SyntaxError{expecting: []string{token.COMMA, token.RPAREN}, got: string(parser.currentToken.Type)}
			}
			break
		}

		// Ignore token.COMMA
		parser.nextToken()
	}

	err = validateTokenAndSkip(parser, []token.Type{token.RPAREN})
	if err != nil {
		return false, nil, err
	}