Back to index

python3.2  3.2.2
Defines | Functions
node.c File Reference
#include "Python.h"
#include "node.h"
#include "errcode.h"

Go to the source code of this file.

Defines

#define XXXROUNDUP(n)

Functions

nodePyNode_New (int type)
static int fancy_roundup (int n)
int PyNode_AddChild (register node *n1, int type, char *str, int lineno, int col_offset)
static void freechildren (node *)
void PyNode_Free (node *n)

Define Documentation

#define XXXROUNDUP (   n)
Value:
((n) <= 1 ? (n) :                 \
               (n) <= 128 ? (((n) + 3) & ~3) :          \
               fancy_roundup(n))

Definition at line 73 of file node.c.


Function Documentation

static int fancy_roundup ( int  n) [static]

Definition at line 23 of file node.c.

{
    /* Round up to the closest power of 2 >= n. */
    int result = 256;
    assert(n > 128);
    while (result < n) {
        result <<= 1;
        if (result <= 0)
            return -1;
    }
    return result;
}
static void freechildren ( node n) [static]

Definition at line 129 of file node.c.

{
    int i;
    for (i = NCH(n); --i >= 0; )
        freechildren(CHILD(n, i));
    if (n->n_child != NULL)
        PyObject_FREE(n->n_child);
    if (STR(n) != NULL)
        PyObject_FREE(STR(n));
}

Here is the caller graph for this function:

int PyNode_AddChild ( register node n1,
int  type,
char *  str,
int  lineno,
int  col_offset 
)

Definition at line 79 of file node.c.

{
    const int nch = n1->n_nchildren;
    int current_capacity;
    int required_capacity;
    node *n;

    if (nch == INT_MAX || nch < 0)
        return E_OVERFLOW;

    current_capacity = XXXROUNDUP(nch);
    required_capacity = XXXROUNDUP(nch + 1);
    if (current_capacity < 0 || required_capacity < 0)
        return E_OVERFLOW;
    if (current_capacity < required_capacity) {
        if (required_capacity > PY_SIZE_MAX / sizeof(node)) {
            return E_NOMEM;
        }
        n = n1->n_child;
        n = (node *) PyObject_REALLOC(n,
                                      required_capacity * sizeof(node));
        if (n == NULL)
            return E_NOMEM;
        n1->n_child = n;
    }

    n = &n1->n_child[n1->n_nchildren++];
    n->n_type = type;
    n->n_str = str;
    n->n_lineno = lineno;
    n->n_col_offset = col_offset;
    n->n_nchildren = 0;
    n->n_child = NULL;
    return 0;
}

Here is the caller graph for this function:

void PyNode_Free ( node n)

Definition at line 120 of file node.c.

{
    if (n != NULL) {
        freechildren(n);
        PyObject_FREE(n);
    }
}

Here is the call graph for this function:

Here is the caller graph for this function:

node* PyNode_New ( int  type)

Definition at line 8 of file node.c.

{
    node *n = (node *) PyObject_MALLOC(1 * sizeof(node));
    if (n == NULL)
        return NULL;
    n->n_type = type;
    n->n_str = NULL;
    n->n_lineno = 0;
    n->n_nchildren = 0;
    n->n_child = NULL;
    return n;
}

Here is the caller graph for this function: