Back to index

python3.2  3.2.2
Classes | Defines | Functions | Variables
operator.c File Reference
#include "Python.h"

Go to the source code of this file.

Classes

struct  itemgetterobject
struct  attrgetterobject
struct  methodcallerobject

Defines

#define spam1(OP, AOP)
#define spam2(OP, AOP)
#define spamoi(OP, AOP)
#define spam2n(OP, AOP)
#define spam3n(OP, AOP)
#define spami(OP, AOP)
#define spami2(OP, AOP)
#define spamn2(OP, AOP)
#define spami2b(OP, AOP)
#define spamrc(OP, A)
#define spam1(OP, DOC)   {#OP, OP, METH_VARARGS, PyDoc_STR(DOC)},
#define spam2(OP, ALTOP, DOC)
#define spam1o(OP, DOC)   {#OP, OP, METH_O, PyDoc_STR(DOC)},
#define spam2o(OP, ALTOP, DOC)

Functions

 PyDoc_STRVAR (operator_doc,"Operator interface.\n\ \n\ This module exports a set of functions implemented in C corresponding\n\ to the intrinsic operators of Python. For example, operator.add(x, y)\n\ is equivalent to the expression x+y. The function names are those\n\ used for special methods; variants without leading and trailing\n\ '__' are also provided for convenience.")
 spami (truth, PyObject_IsTrue)
static PyObjectop_ipow (PyObject *s, PyObject *a)
static PyObjectop_index (PyObject *s, PyObject *a)
static PyObjectis_ (PyObject *s, PyObject *a)
static PyObjectis_not (PyObject *s, PyObject *a)
static PyObjectitemgetter_new (PyTypeObject *type, PyObject *args, PyObject *kwds)
static void itemgetter_dealloc (itemgetterobject *ig)
static int itemgetter_traverse (itemgetterobject *ig, visitproc visit, void *arg)
static PyObjectitemgetter_call (itemgetterobject *ig, PyObject *args, PyObject *kw)
 PyDoc_STRVAR (itemgetter_doc,"itemgetter(item, ...) --> itemgetter object\n\ \n\ Return a callable object that fetches the given item(s) from its operand.\n\ After, f=itemgetter(2), the call f(r) returns r[2].\n\ After, g=itemgetter(2,5,3), the call g(r) returns (r[2], r[5], r[3])")
static PyObjectattrgetter_new (PyTypeObject *type, PyObject *args, PyObject *kwds)
static void attrgetter_dealloc (attrgetterobject *ag)
static int attrgetter_traverse (attrgetterobject *ag, visitproc visit, void *arg)
static PyObjectdotted_getattr (PyObject *obj, PyObject *attr)
static PyObjectattrgetter_call (attrgetterobject *ag, PyObject *args, PyObject *kw)
 PyDoc_STRVAR (attrgetter_doc,"attrgetter(attr, ...) --> attrgetter object\n\ \n\ Return a callable object that fetches the given attribute(s) from its operand.\n\ After, f=attrgetter('name'), the call f(r) returns r.name.\n\ After, g=attrgetter('name', 'date'), the call g(r) returns (r.name, r.date).\n\ After, h=attrgetter('name.first', 'name.last'), the call h(r) returns\n\ (r.name.first, r.name.last).")
static PyObjectmethodcaller_new (PyTypeObject *type, PyObject *args, PyObject *kwds)
static void methodcaller_dealloc (methodcallerobject *mc)
static int methodcaller_traverse (methodcallerobject *mc, visitproc visit, void *arg)
static PyObjectmethodcaller_call (methodcallerobject *mc, PyObject *args, PyObject *kw)
 PyDoc_STRVAR (methodcaller_doc,"methodcaller(name, ...) --> methodcaller object\n\ \n\ Return a callable object that calls the given method on its operand.\n\ After, f = methodcaller('name'), the call f(r) returns r.name().\n\ After, g = methodcaller('name', 'date', foo=1), the call g(r) returns\n\ r.name('date', foo=1).")
PyMODINIT_FUNC PyInit_operator (void)

Variables

static struct PyMethodDef []
static PyTypeObject itemgetter_type
static PyTypeObject attrgetter_type
static PyTypeObject methodcaller_type
static struct PyModuleDef

Class Documentation

struct itemgetterobject

Definition at line 236 of file operator.c.

Collaboration diagram for itemgetterobject:
Class Members
PyObject * item
PyObject_HEAD Py_ssize_t nitems
struct attrgetterobject

Definition at line 373 of file operator.c.

Collaboration diagram for attrgetterobject:
Class Members
PyObject * attr
PyObject_HEAD Py_ssize_t nattrs
struct methodcallerobject

Definition at line 622 of file operator.c.

Collaboration diagram for methodcallerobject:
Class Members
PyObject * args
PyObject * kwds
PyObject_HEAD PyObject * name

Define Documentation

#define spam1 (   OP,
  AOP 
)
Value:
static PyObject *OP(PyObject *s, PyObject *a1) { \
  return AOP(a1); }

Definition at line 162 of file operator.c.

#define spam1 (   OP,
  DOC 
)    {#OP, OP, METH_VARARGS, PyDoc_STR(DOC)},

Definition at line 162 of file operator.c.

#define spam1o (   OP,
  DOC 
)    {#OP, OP, METH_O, PyDoc_STR(DOC)},

Definition at line 165 of file operator.c.

#define spam2 (   OP,
  AOP 
)
Value:
static PyObject *OP(PyObject *s, PyObject *a) { \
  PyObject *a1, *a2; \
  if(! PyArg_UnpackTuple(a,#OP,2,2,&a1,&a2)) return NULL; \
  return AOP(a1,a2); }

Definition at line 163 of file operator.c.

#define spam2 (   OP,
  ALTOP,
  DOC 
)
Value:
{#OP, op_##OP, METH_VARARGS, PyDoc_STR(DOC)}, \
                           {#ALTOP, op_##OP, METH_VARARGS, PyDoc_STR(DOC)},

Definition at line 163 of file operator.c.

#define spam2n (   OP,
  AOP 
)
Value:
static PyObject *OP(PyObject *s, PyObject *a) { \
  PyObject *a1, *a2; \
  if(! PyArg_UnpackTuple(a,#OP,2,2,&a1,&a2)) return NULL; \
  if(-1 == AOP(a1,a2)) return NULL; \
  Py_INCREF(Py_None); \
  return Py_None; }

Definition at line 26 of file operator.c.

#define spam2o (   OP,
  ALTOP,
  DOC 
)
Value:
{#OP, op_##OP, METH_O, PyDoc_STR(DOC)}, \
                           {#ALTOP, op_##OP, METH_O, PyDoc_STR(DOC)},

Definition at line 166 of file operator.c.

#define spam3n (   OP,
  AOP 
)
Value:
static PyObject *OP(PyObject *s, PyObject *a) { \
  PyObject *a1, *a2, *a3; \
  if(! PyArg_UnpackTuple(a,#OP,3,3,&a1,&a2,&a3)) return NULL; \
  if(-1 == AOP(a1,a2,a3)) return NULL; \
  Py_INCREF(Py_None); \
  return Py_None; }

Definition at line 33 of file operator.c.

#define spami (   OP,
  AOP 
)
Value:
static PyObject *OP(PyObject *s, PyObject *a1) { \
  long r; \
  if(-1 == (r=AOP(a1))) return NULL; \
  return PyBool_FromLong(r); }

Definition at line 40 of file operator.c.

#define spami2 (   OP,
  AOP 
)
Value:
static PyObject *OP(PyObject *s, PyObject *a) { \
  PyObject *a1, *a2; long r; \
  if(! PyArg_UnpackTuple(a,#OP,2,2,&a1,&a2)) return NULL; \
  if(-1 == (r=AOP(a1,a2))) return NULL; \
  return PyLong_FromLong(r); }

Definition at line 45 of file operator.c.

#define spami2b (   OP,
  AOP 
)
Value:
static PyObject *OP(PyObject *s, PyObject *a) { \
  PyObject *a1, *a2; long r; \
  if(! PyArg_UnpackTuple(a,#OP,2,2,&a1,&a2)) return NULL; \
  if(-1 == (r=AOP(a1,a2))) return NULL; \
  return PyBool_FromLong(r); }

Definition at line 57 of file operator.c.

#define spamn2 (   OP,
  AOP 
)
Value:
static PyObject *OP(PyObject *s, PyObject *a) { \
  PyObject *a1, *a2; Py_ssize_t r; \
  if(! PyArg_UnpackTuple(a,#OP,2,2,&a1,&a2)) return NULL; \
  if(-1 == (r=AOP(a1,a2))) return NULL; \
  return PyLong_FromSsize_t(r); }

Definition at line 51 of file operator.c.

#define spamoi (   OP,
  AOP 
)
Value:
static PyObject *OP(PyObject *s, PyObject *a) { \
  PyObject *a1; int a2; \
  if(! PyArg_ParseTuple(a,"Oi:" #OP,&a1,&a2)) return NULL; \
  return AOP(a1,a2); }

Definition at line 21 of file operator.c.

#define spamrc (   OP,
  A 
)
Value:
static PyObject *OP(PyObject *s, PyObject *a) { \
  PyObject *a1, *a2; \
  if(! PyArg_UnpackTuple(a,#OP,2,2,&a1,&a2)) return NULL; \
  return PyObject_RichCompare(a1,a2,A); }

Definition at line 63 of file operator.c.


Function Documentation

static PyObject* attrgetter_call ( attrgetterobject ag,
PyObject args,
PyObject kw 
) [static]

Definition at line 537 of file operator.c.

{
    PyObject *obj, *result;
    Py_ssize_t i, nattrs=ag->nattrs;

    if (!PyArg_UnpackTuple(args, "attrgetter", 1, 1, &obj))
        return NULL;
    if (ag->nattrs == 1) /* ag->attr is always a tuple */
        return dotted_getattr(obj, PyTuple_GET_ITEM(ag->attr, 0));

    assert(PyTuple_Check(ag->attr));
    assert(PyTuple_GET_SIZE(ag->attr) == nattrs);

    result = PyTuple_New(nattrs);
    if (result == NULL)
        return NULL;

    for (i=0 ; i < nattrs ; i++) {
        PyObject *attr, *val;
        attr = PyTuple_GET_ITEM(ag->attr, i);
        val = dotted_getattr(obj, attr);
        if (val == NULL) {
            Py_DECREF(result);
            return NULL;
        }
        PyTuple_SET_ITEM(result, i, val);
    }
    return result;
}

Here is the call graph for this function:

static void attrgetter_dealloc ( attrgetterobject ag) [static]

Definition at line 489 of file operator.c.

Here is the call graph for this function:

static PyObject* attrgetter_new ( PyTypeObject type,
PyObject args,
PyObject kwds 
) [static]

Definition at line 382 of file operator.c.

{
    attrgetterobject *ag;
    PyObject *attr;
    Py_ssize_t nattrs, idx, char_idx;

    if (!_PyArg_NoKeywords("attrgetter()", kwds))
        return NULL;

    nattrs = PyTuple_GET_SIZE(args);
    if (nattrs <= 1) {
        if (!PyArg_UnpackTuple(args, "attrgetter", 1, 1, &attr))
            return NULL;
    }

    attr = PyTuple_New(nattrs);
    if (attr == NULL)
        return NULL;

    /* prepare attr while checking args */
    for (idx = 0; idx < nattrs; ++idx) {
        PyObject *item = PyTuple_GET_ITEM(args, idx);
        Py_ssize_t item_len;
        Py_UNICODE *item_buffer;
        int dot_count;

        if (!PyUnicode_Check(item)) {
            PyErr_SetString(PyExc_TypeError,
                            "attribute name must be a string");
            Py_DECREF(attr);
            return NULL;
        }
        item_len = PyUnicode_GET_SIZE(item);
        item_buffer = PyUnicode_AS_UNICODE(item);

        /* check whethere the string is dotted */
        dot_count = 0;
        for (char_idx = 0; char_idx < item_len; ++char_idx) {
            if (item_buffer[char_idx] == (Py_UNICODE)'.')
                ++dot_count;
        }

        if (dot_count == 0) {
            Py_INCREF(item);
            PyUnicode_InternInPlace(&item);
            PyTuple_SET_ITEM(attr, idx, item);
        } else { /* make it a tuple of non-dotted attrnames */
            PyObject *attr_chain = PyTuple_New(dot_count + 1);
            PyObject *attr_chain_item;
            Py_ssize_t unibuff_from = 0;
            Py_ssize_t unibuff_till = 0;
            Py_ssize_t attr_chain_idx = 0;

            if (attr_chain == NULL) {
                Py_DECREF(attr);
                return NULL;
            }

            for (; dot_count > 0; --dot_count) {
                while (item_buffer[unibuff_till] != (Py_UNICODE)'.') {
                    ++unibuff_till;
                }
                attr_chain_item = PyUnicode_FromUnicode(
                                      item_buffer + unibuff_from,
                                      unibuff_till - unibuff_from);
                if (attr_chain_item == NULL) {
                    Py_DECREF(attr_chain);
                    Py_DECREF(attr);
                    return NULL;
                }
                PyUnicode_InternInPlace(&attr_chain_item);
                PyTuple_SET_ITEM(attr_chain, attr_chain_idx, attr_chain_item);
                ++attr_chain_idx;
                unibuff_till = unibuff_from = unibuff_till + 1;
            }

            /* now add the last dotless name */
            attr_chain_item = PyUnicode_FromUnicode(
                                  item_buffer + unibuff_from,
                                  item_len - unibuff_from);
            if (attr_chain_item == NULL) {
                Py_DECREF(attr_chain);
                Py_DECREF(attr);
                return NULL;
            }
            PyUnicode_InternInPlace(&attr_chain_item);
            PyTuple_SET_ITEM(attr_chain, attr_chain_idx, attr_chain_item);

            PyTuple_SET_ITEM(attr, idx, attr_chain);
        }
    }

    /* create attrgetterobject structure */
    ag = PyObject_GC_New(attrgetterobject, &attrgetter_type);
    if (ag == NULL) {
        Py_DECREF(attr);
        return NULL;
    }

    ag->attr = attr;
    ag->nattrs = nattrs;

    PyObject_GC_Track(ag);
    return (PyObject *)ag;
}

Here is the call graph for this function:

static int attrgetter_traverse ( attrgetterobject ag,
visitproc  visit,
void arg 
) [static]

Definition at line 497 of file operator.c.

{
    Py_VISIT(ag->attr);
    return 0;
}
static PyObject* dotted_getattr ( PyObject obj,
PyObject attr 
) [static]

Definition at line 504 of file operator.c.

{
    PyObject *newobj;

    /* attr is either a tuple or instance of str.
       Ensured by the setup code of attrgetter_new */
    if (PyTuple_CheckExact(attr)) { /* chained getattr */
        Py_ssize_t name_idx = 0, name_count;
        PyObject *attr_name;

        name_count = PyTuple_GET_SIZE(attr);
        Py_INCREF(obj);
        for (name_idx = 0; name_idx < name_count; ++name_idx) {
            attr_name = PyTuple_GET_ITEM(attr, name_idx);
            newobj = PyObject_GetAttr(obj, attr_name);
            Py_DECREF(obj);
            if (newobj == NULL) {
                return NULL;
            }
            /* here */
            obj = newobj;
        }
    } else { /* single getattr */
        newobj = PyObject_GetAttr(obj, attr);
        if (newobj == NULL)
            return NULL;
        obj = newobj;
    }

    return obj;
}

Here is the call graph for this function:

Here is the caller graph for this function:

static PyObject* is_ ( PyObject s,
PyObject a 
) [static]

Definition at line 137 of file operator.c.

{
    PyObject *a1, *a2, *result = NULL;
    if (PyArg_UnpackTuple(a,"is_", 2, 2, &a1, &a2)) {
        result = (a1 == a2) ? Py_True : Py_False;
        Py_INCREF(result);
    }
    return result;
}

Here is the call graph for this function:

static PyObject* is_not ( PyObject s,
PyObject a 
) [static]

Definition at line 148 of file operator.c.

{
    PyObject *a1, *a2, *result = NULL;
    if (PyArg_UnpackTuple(a,"is_not", 2, 2, &a1, &a2)) {
        result = (a1 != a2) ? Py_True : Py_False;
        Py_INCREF(result);
    }
    return result;
}

Here is the call graph for this function:

static PyObject* itemgetter_call ( itemgetterobject ig,
PyObject args,
PyObject kw 
) [static]

Definition at line 290 of file operator.c.

{
    PyObject *obj, *result;
    Py_ssize_t i, nitems=ig->nitems;

    if (!PyArg_UnpackTuple(args, "itemgetter", 1, 1, &obj))
        return NULL;
    if (nitems == 1)
        return PyObject_GetItem(obj, ig->item);

    assert(PyTuple_Check(ig->item));
    assert(PyTuple_GET_SIZE(ig->item) == nitems);

    result = PyTuple_New(nitems);
    if (result == NULL)
        return NULL;

    for (i=0 ; i < nitems ; i++) {
        PyObject *item, *val;
        item = PyTuple_GET_ITEM(ig->item, i);
        val = PyObject_GetItem(obj, item);
        if (val == NULL) {
            Py_DECREF(result);
            return NULL;
        }
        PyTuple_SET_ITEM(result, i, val);
    }
    return result;
}

Here is the call graph for this function:

static void itemgetter_dealloc ( itemgetterobject ig) [static]

Definition at line 275 of file operator.c.

Here is the call graph for this function:

static PyObject* itemgetter_new ( PyTypeObject type,
PyObject args,
PyObject kwds 
) [static]

Definition at line 245 of file operator.c.

{
    itemgetterobject *ig;
    PyObject *item;
    Py_ssize_t nitems;

    if (!_PyArg_NoKeywords("itemgetter()", kwds))
        return NULL;

    nitems = PyTuple_GET_SIZE(args);
    if (nitems <= 1) {
        if (!PyArg_UnpackTuple(args, "itemgetter", 1, 1, &item))
            return NULL;
    } else
        item = args;

    /* create itemgetterobject structure */
    ig = PyObject_GC_New(itemgetterobject, &itemgetter_type);
    if (ig == NULL)
        return NULL;

    Py_INCREF(item);
    ig->item = item;
    ig->nitems = nitems;

    PyObject_GC_Track(ig);
    return (PyObject *)ig;
}

Here is the call graph for this function:

static int itemgetter_traverse ( itemgetterobject ig,
visitproc  visit,
void arg 
) [static]

Definition at line 283 of file operator.c.

{
    Py_VISIT(ig->item);
    return 0;
}
static PyObject* methodcaller_call ( methodcallerobject mc,
PyObject args,
PyObject kw 
) [static]

Definition at line 685 of file operator.c.

{
    PyObject *method, *obj, *result;

    if (!PyArg_UnpackTuple(args, "methodcaller", 1, 1, &obj))
        return NULL;
    method = PyObject_GetAttr(obj, mc->name);
    if (method == NULL)
        return NULL;
    result = PyObject_Call(method, mc->args, mc->kwds);
    Py_DECREF(method);
    return result;
}

Here is the call graph for this function:

static void methodcaller_dealloc ( methodcallerobject mc) [static]

Definition at line 667 of file operator.c.

Here is the call graph for this function:

static PyObject* methodcaller_new ( PyTypeObject type,
PyObject args,
PyObject kwds 
) [static]

Definition at line 632 of file operator.c.

{
    methodcallerobject *mc;
    PyObject *name, *newargs;

    if (PyTuple_GET_SIZE(args) < 1) {
        PyErr_SetString(PyExc_TypeError, "methodcaller needs at least "
                        "one argument, the method name");
        return NULL;
    }

    /* create methodcallerobject structure */
    mc = PyObject_GC_New(methodcallerobject, &methodcaller_type);
    if (mc == NULL)
        return NULL;

    newargs = PyTuple_GetSlice(args, 1, PyTuple_GET_SIZE(args));
    if (newargs == NULL) {
        Py_DECREF(mc);
        return NULL;
    }
    mc->args = newargs;

    name = PyTuple_GET_ITEM(args, 0);
    Py_INCREF(name);
    mc->name = name;

    Py_XINCREF(kwds);
    mc->kwds = kwds;

    PyObject_GC_Track(mc);
    return (PyObject *)mc;
}

Here is the call graph for this function:

static int methodcaller_traverse ( methodcallerobject mc,
visitproc  visit,
void arg 
) [static]

Definition at line 677 of file operator.c.

{
    Py_VISIT(mc->args);
    Py_VISIT(mc->kwds);
    return 0;
}
static PyObject* op_index ( PyObject s,
PyObject a 
) [static]

Definition at line 131 of file operator.c.

{
    return PyNumber_Index(a);
}

Here is the call graph for this function:

static PyObject* op_ipow ( PyObject s,
PyObject a 
) [static]

Definition at line 122 of file operator.c.

{
    PyObject *a1, *a2;
    if (PyArg_UnpackTuple(a,"ipow", 2, 2, &a1, &a2))
        return PyNumber_InPlacePower(a1, a2, Py_None);
    return NULL;
}

Here is the call graph for this function:

PyDoc_STRVAR ( operator_doc  ,
"Operator interface.\n\\n\This module exports a set of functions implemented in C corresponding\n\to the intrinsic operators of Python. For  example,
operator.add(x, y)\n\is equivalent to the expression x+y.The function names are those\n\used for special methods;variants without leading and trailing\n\'__'are also provided for convenience."   
)
PyDoc_STRVAR ( itemgetter_doc  ,
"itemgetter(item, ...) --> itemgetter object\n\\n\Return a callable object that fetches the given item(s) from its operand.\n\  After,
= itemgetter(2),
the call f(r) returns r.\n\  After[2],
g  = itemgetter(2,5,3),
the call g(r) returns(r[2], r[5], r[3])"   
)
PyDoc_STRVAR ( attrgetter_doc  ,
"attrgetter(attr, ...) --> attrgetter object\n\\n\Return a callable object that fetches the given attribute(s) from its operand.\n\  After,
= attrgetter('name'),
the call f(r) returns r.name.\n\  After,
g  = attrgetter('name', 'date'),
the call g(r) returns(r.name, r.date).\n\  After,
= attrgetter('name.first', 'name.last'),
the call h(r) returns\n\(r.name.first, r.name.last)."   
)
PyDoc_STRVAR ( methodcaller_doc  ,
"methodcaller(name, ...) --> methodcaller object\n\\n\Return a callable object that calls the given method on its operand.\n\  After,
= methodcaller('name'),
the call f(r) returns r.name().\n\  After,
g  = methodcaller('name', 'date', foo=1),
the call g(r) returns\n\r.name('date', foo=1)."   
)

Definition at line 767 of file operator.c.

{
    PyObject *m;

    /* Create the module and add the functions */
    m = PyModule_Create(&operatormodule);
    if (m == NULL)
        return NULL;

    if (PyType_Ready(&itemgetter_type) < 0)
        return NULL;
    Py_INCREF(&itemgetter_type);
    PyModule_AddObject(m, "itemgetter", (PyObject *)&itemgetter_type);

    if (PyType_Ready(&attrgetter_type) < 0)
        return NULL;
    Py_INCREF(&attrgetter_type);
    PyModule_AddObject(m, "attrgetter", (PyObject *)&attrgetter_type);

    if (PyType_Ready(&methodcaller_type) < 0)
        return NULL;
    Py_INCREF(&methodcaller_type);
    PyModule_AddObject(m, "methodcaller", (PyObject *)&methodcaller_type);
    return m;
}

Here is the call graph for this function:

spami ( truth  ,
PyObject_IsTrue   
)

Definition at line 68 of file operator.c.

{
    PyObject *a1, *a2;
    if (PyArg_UnpackTuple(a,"pow", 2, 2, &a1, &a2))
        return PyNumber_Power(a1, a2, Py_None);
    return NULL;
}

Here is the call graph for this function:


Variable Documentation

static PyTypeObject attrgetter_type [static]

Definition at line 379 of file operator.c.

static PyTypeObject itemgetter_type [static]

Definition at line 242 of file operator.c.

Definition at line 629 of file operator.c.

struct PyMethodDef[] [static]

Definition at line 169 of file operator.c.

struct PyModuleDef [static]
Initial value:
 {
    PyModuleDef_HEAD_INIT,
    "operator",
    operator_doc,
    -1,
    operator_methods,
    NULL,
    NULL,
    NULL,
    NULL
}

Definition at line 754 of file operator.c.