Method getConditionalExpression

parser/parser.go:808–841

getConditionalExpression - Return ast.ConditionExpression created from tokens and validate the syntax

(leftSide token.Token, isAnonymitifier bool)

// getConditionalExpression - Return ast.ConditionExpression created from tokens and validate the syntax
func (parser *Parser) getConditionalExpression(leftSide token.Token, isAnonymitifier bool) (bool, *ast.ConditionExpression, error) {
	conditionalExpression := &ast.ConditionExpression{Condition: parser.currentToken}

	if isAnonymitifier {
		conditionalExpression.Left = ast.Anonymitifier{Token: leftSide}
	} else {
		conditionalExpression.Left = ast.Identifier{Token: leftSide}
	}

	// skip EQUAL or NOT
	parser.nextToken()

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

		if !startedWithApostrophe && parser.currentToken.Type == token.IDENT {
			conditionalExpression.Right = ast.Identifier{Token: parser.currentToken}
		} else {
			conditionalExpression.Right = ast.Anonymitifier{Token: parser.currentToken}
		}
		parser.nextToken()

		finishedWithApostrophe := parser.skipIfCurrentTokenIsApostrophe()
		err := validateApostropheWrapping(startedWithApostrophe, finishedWithApostrophe, conditionalExpression.Right.GetToken())
		if err != nil {
			return false, nil, err
		}
	} else {
		return false, conditionalExpression, &SyntaxError{expecting: []string{token.APOSTROPHE, token.IDENT, token.LITERAL, token.NULL}, got: parser.currentToken.Literal}
	}

	return true, conditionalExpression, nil
}

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