readfuncs.h File Reference

#include "nodes/nodes.h"

Include dependency graph for readfuncs.h:

This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Functions
const char *	pg_strtok (int *length)
char *	debackslash (const char *token, int length)
void *	nodeRead (const char *token, int tok_len)
Node *	parseNodeString (void)

Function Documentation

debackslash()

char * debackslash ( const char *  token, int  length  )

extern

Definition at line 214 of file read.c.

{
    char       *result = palloc(length + 1);
    char       *ptr = result;
 
    while (length > 0)
    {
        if (*token == '\\' && length > 1)
            token++, length--;
        *ptr++ = *token++;
        length--;
    }
    *ptr = '\0';
    return result;
}

References palloc().

Referenced by nodeRead(), and nullable_string().

nodeRead()

void * nodeRead ( const char *  token, int  tok_len  )

extern

Definition at line 320 of file read.c.

{
    Node       *result;
    NodeTag     type;
 
    if (token == NULL)          /* need to read a token? */
    {
        token = pg_strtok(&tok_len);
 
        if (token == NULL)      /* end of input */
            return NULL;
    }
 
    type = nodeTokenType(token, tok_len);
 
    switch ((int) type)
    {
        case LEFT_BRACE:
            result = parseNodeString();
            token = pg_strtok(&tok_len);
            if (token == NULL || token[0] != '}')
                elog(ERROR, "did not find '}' at end of input node");
            break;
        case LEFT_PAREN:
            {
                List       *l = NIL;
 
                /*----------
                 * Could be an integer list:    (i int int ...)
                 * or an OID list:              (o int int ...)
                 * or an XID list:              (x int int ...)
                 * or a bitmapset:              (b int int ...)
                 * or a list of nodes/values:   (node node ...)
                 *----------
                 */
                token = pg_strtok(&tok_len);
                if (token == NULL)
                    elog(ERROR, "unterminated List structure");
                if (tok_len == 1 && token[0] == 'i')
                {
                    /* List of integers */
                    for (;;)
                    {
                        int         val;
                        char       *endptr;
 
                        token = pg_strtok(&tok_len);
                        if (token == NULL)
                            elog(ERROR, "unterminated List structure");
                        if (token[0] == ')')
                            break;
                        val = (int) strtol(token, &endptr, 10);
                        if (endptr != token + tok_len)
                            elog(ERROR, "unrecognized integer: \"%.*s\"",
                                 tok_len, token);
                        l = lappend_int(l, val);
                    }
                    result = (Node *) l;
                }
                else if (tok_len == 1 && token[0] == 'o')
                {
                    /* List of OIDs */
                    for (;;)
                    {
                        Oid         val;
                        char       *endptr;
 
                        token = pg_strtok(&tok_len);
                        if (token == NULL)
                            elog(ERROR, "unterminated List structure");
                        if (token[0] == ')')
                            break;
                        val = (Oid) strtoul(token, &endptr, 10);
                        if (endptr != token + tok_len)
                            elog(ERROR, "unrecognized OID: \"%.*s\"",
                                 tok_len, token);
                        l = lappend_oid(l, val);
                    }
                    result = (Node *) l;
                }
                else if (tok_len == 1 && token[0] == 'x')
                {
                    /* List of TransactionIds */
                    for (;;)
                    {
                        TransactionId val;
                        char       *endptr;
 
                        token = pg_strtok(&tok_len);
                        if (token == NULL)
                            elog(ERROR, "unterminated List structure");
                        if (token[0] == ')')
                            break;
                        val = (TransactionId) strtoul(token, &endptr, 10);
                        if (endptr != token + tok_len)
                            elog(ERROR, "unrecognized Xid: \"%.*s\"",
                                 tok_len, token);
                        l = lappend_xid(l, val);
                    }
                    result = (Node *) l;
                }
                else if (tok_len == 1 && token[0] == 'b')
                {
                    /* Bitmapset -- see also _readBitmapset() */
                    Bitmapset  *bms = NULL;
 
                    for (;;)
                    {
                        int         val;
                        char       *endptr;
 
                        token = pg_strtok(&tok_len);
                        if (token == NULL)
                            elog(ERROR, "unterminated Bitmapset structure");
                        if (tok_len == 1 && token[0] == ')')
                            break;
                        val = (int) strtol(token, &endptr, 10);
                        if (endptr != token + tok_len)
                            elog(ERROR, "unrecognized integer: \"%.*s\"",
                                 tok_len, token);
                        bms = bms_add_member(bms, val);
                    }
                    result = (Node *) bms;
                }
                else
                {
                    /* List of other node types */
                    for (;;)
                    {
                        /* We have already scanned next token... */
                        if (token[0] == ')')
                            break;
                        l = lappend(l, nodeRead(token, tok_len));
                        token = pg_strtok(&tok_len);
                        if (token == NULL)
                            elog(ERROR, "unterminated List structure");
                    }
                    result = (Node *) l;
                }
                break;
            }
        case RIGHT_PAREN:
            elog(ERROR, "unexpected right parenthesis");
            result = NULL;      /* keep compiler happy */
            break;
        case OTHER_TOKEN:
            if (tok_len == 0)
            {
                /* must be "<>" --- represents a null pointer */
                result = NULL;
            }
            else
            {
                elog(ERROR, "unrecognized token: \"%.*s\"", tok_len, token);
                result = NULL;  /* keep compiler happy */
            }
            break;
        case T_Integer:
 
            /*
             * we know that the token terminates on a char atoi will stop at
             */
            result = (Node *) makeInteger(atoi(token));
            break;
        case T_Float:
            {
                char       *fval = (char *) palloc(tok_len + 1);
 
                memcpy(fval, token, tok_len);
                fval[tok_len] = '\0';
                result = (Node *) makeFloat(fval);
            }
            break;
        case T_Boolean:
            result = (Node *) makeBoolean(token[0] == 't');
            break;
        case T_String:
            /* need to remove leading and trailing quotes, and backslashes */
            result = (Node *) makeString(debackslash(token + 1, tok_len - 2));
            break;
        case T_BitString:
            /* need to remove backslashes, but there are no quotes */
            result = (Node *) makeBitString(debackslash(token, tok_len));
            break;
        default:
            elog(ERROR, "unrecognized node type: %d", (int) type);
            result = NULL;      /* keep compiler happy */
            break;
    }
 
    return result;
}

References bms_add_member(), debackslash(), elog, ERROR, fb(), lappend(), lappend_int(), lappend_oid(), lappend_xid(), LEFT_BRACE, LEFT_PAREN, makeBitString(), makeBoolean(), makeFloat(), makeInteger(), makeString(), NIL, nodeRead(), nodeTokenType(), OTHER_TOKEN, palloc(), parseNodeString(), pg_strtok(), RIGHT_PAREN, type, and val.

Referenced by _readA_Const(), _readA_Expr(), nodeRead(), and stringToNodeInternal().

parseNodeString()

Node * parseNodeString ( void  )

extern

Definition at line 571 of file readfuncs.c.

{
    READ_TEMP_LOCALS();
 
    /* Guard against stack overflow due to overly complex expressions */
    check_stack_depth();
 
    token = pg_strtok(&length);
 
#define MATCH(tokname, namelen) \
    (length == namelen && memcmp(token, tokname, namelen) == 0)
 
#include "readfuncs.switch.c"
 
    elog(ERROR, "badly formatted node string \"%.32s\"...", token);
    return NULL;                /* keep compiler quiet */
}

References check_stack_depth(), elog, ERROR, fb(), pg_strtok(), and READ_TEMP_LOCALS.

Referenced by nodeRead().

pg_strtok()

const char * pg_strtok ( int *  length )

extern

Definition at line 153 of file read.c.

{
    const char *local_str;      /* working pointer to string */
    const char *ret_str;        /* start of token to return */
 
    local_str = pg_strtok_ptr;
 
    while (*local_str == ' ' || *local_str == '\n' || *local_str == '\t')
        local_str++;
 
    if (*local_str == '\0')
    {
        *length = 0;
        pg_strtok_ptr = local_str;
        return NULL;            /* no more tokens */
    }
 
    /*
     * Now pointing at start of next token.
     */
    ret_str = local_str;
 
    if (*local_str == '(' || *local_str == ')' ||
        *local_str == '{' || *local_str == '}')
    {
        /* special 1-character token */
        local_str++;
    }
    else
    {
        /* Normal token, possibly containing backslashes */
        while (*local_str != '\0' &&
               *local_str != ' ' && *local_str != '\n' &&
               *local_str != '\t' &&
               *local_str != '(' && *local_str != ')' &&
               *local_str != '{' && *local_str != '}')
        {
            if (*local_str == '\\' && local_str[1] != '\0')
                local_str += 2;
            else
                local_str++;
        }
    }
 
    *length = local_str - ret_str;
 
    /* Recognize special case for "empty" token */
    if (*length == 2 && ret_str[0] == '<' && ret_str[1] == '>')
        *length = 0;
 
    pg_strtok_ptr = local_str;
 
    return ret_str;
}

References fb(), and pg_strtok_ptr.

Referenced by _readA_Const(), _readA_Expr(), _readBitmapset(), _readBoolExpr(), _readConst(), _readExtensibleNode(), nodeRead(), parseNodeString(), and readDatum().