Modules/operator.c

   1 static char operator_doc[] = "\
   2 Operator interface.\n\
   3 \n\
   4 This module exports a set of functions implemented in C corresponding\n\
   5 to the intrinsic operators of Python.  For example, operator.add(x, y)\n\
   6 is equivalent to the expression x+y.  The function names are those\n\
   7 used for special class methods; variants without leading and trailing\n\
   8 '__' are also provided for convenience.\n\
   9 ";
  10
  11 /*
  12
  13      Copyright
  14
  15        Copyright 1996 Digital Creations, L.C., 910 Princess Anne
  16        Street, Suite 300, Fredericksburg, Virginia 22401 U.S.A. All
  17        rights reserved.  Copyright in this software is owned by DCLC,
  18        unless otherwise indicated. Permission to use, copy and
  19        distribute this software is hereby granted, provided that the
  20        above copyright notice appear in all copies and that both that
  21        copyright notice and this permission notice appear. Note that
  22        any product, process or technology described in this software
  23        may be the subject of other Intellectual Property rights
  24        reserved by Digital Creations, L.C. and are not licensed
  25        hereunder.
  26
  27      Trademarks
  28
  29        Digital Creations & DCLC, are trademarks of Digital Creations, L.C..
  30        All other trademarks are owned by their respective companies.
  31
  32      No Warranty
  33
  34        The software is provided "as is" without warranty of any kind,
  35        either express or implied, including, but not limited to, the
  36        implied warranties of merchantability, fitness for a particular
  37        purpose, or non-infringement. This software could include
  38        technical inaccuracies or typographical errors. Changes are
  39        periodically made to the software; these changes will be
  40        incorporated in new editions of the software. DCLC may make
  41        improvements and/or changes in this software at any time
  42        without notice.
  43
  44      Limitation Of Liability
  45
  46        In no event will DCLC be liable for direct, indirect, special,
  47        incidental, economic, cover, or consequential damages arising
  48        out of the use of or inability to use this software even if
  49        advised of the possibility of such damages. Some states do not
  50        allow the exclusion or limitation of implied warranties or
  51        limitation of liability for incidental or consequential
  52        damages, so the above limitation or exclusion may not apply to
  53        you.
  54
  55
  56     If you have questions regarding this software,
  57     contact:
  58
  59       Jim Fulton, jim@digicool.com
  60       Digital Creations L.C.
  61
  62       (540) 371-6909
  63
  64     Modifications
  65
  66       Renamed and slightly rearranged by Guido van Rossum
  67
  68 */
  69
  70 #include "Python.h"
  71
  72 #define spam1(OP,AOP) static PyObject *OP(PyObject *s, PyObject *a) { \
  73   PyObject *a1; \
  74   if(! PyArg_ParseTuple(a,"O",&a1)) return NULL; \
  75   return AOP(a1); }
  76
  77 #define spam2(OP,AOP) static PyObject *OP(PyObject *s, PyObject *a) { \
  78   PyObject *a1, *a2; \
  79   if(! PyArg_ParseTuple(a,"OO",&a1,&a2)) return NULL; \
  80   return AOP(a1,a2); }
  81
  82 #define spamoi(OP,AOP) static PyObject *OP(PyObject *s, PyObject *a) { \
  83   PyObject *a1; int a2; \
  84   if(! PyArg_ParseTuple(a,"Oi",&a1,&a2)) return NULL; \
  85   return AOP(a1,a2); }
  86
  87 #define spam2n(OP,AOP) static PyObject *OP(PyObject *s, PyObject *a) { \
  88   PyObject *a1, *a2; \
  89   if(! PyArg_ParseTuple(a,"OO",&a1,&a2)) return NULL; \
  90   if(-1 == AOP(a1,a2)) return NULL; \
  91   Py_INCREF(Py_None); \
  92   return Py_None; }
  93
  94 #define spam3n(OP,AOP) static PyObject *OP(PyObject *s, PyObject *a) { \
  95   PyObject *a1, *a2, *a3; \
  96   if(! PyArg_ParseTuple(a,"OOO",&a1,&a2,&a3)) return NULL; \
  97   if(-1 == AOP(a1,a2,a3)) return NULL; \
  98   Py_INCREF(Py_None); \
  99   return Py_None; }
 100
 101 #define spami(OP,AOP) static PyObject *OP(PyObject *s, PyObject *a) { \
 102   PyObject *a1; long r; \
 103   if(! PyArg_ParseTuple(a,"O",&a1)) return NULL; \
 104   if(-1 == (r=AOP(a1))) return NULL; \
 105   return PyInt_FromLong(r); }
 106
 107 #define spami2(OP,AOP) static PyObject *OP(PyObject *s, PyObject *a) { \
 108   PyObject *a1, *a2; long r; \
 109   if(! PyArg_ParseTuple(a,"OO",&a1,&a2)) return NULL; \
 110   if(-1 == (r=AOP(a1,a2))) return NULL; \
 111   return PyInt_FromLong(r); }
 112
 113 spami(isCallable       , PyCallable_Check)
 114 spami(isNumberType     , PyNumber_Check)
 115 spami(truth            , PyObject_IsTrue)
 116 spam2(op_add           , PyNumber_Add)
 117 spam2(op_sub           , PyNumber_Subtract)
 118 spam2(op_mul           , PyNumber_Multiply)
 119 spam2(op_div           , PyNumber_Divide)
 120 spam2(op_mod           , PyNumber_Remainder)
 121 spam1(op_neg           , PyNumber_Negative)
 122 spam1(op_pos           , PyNumber_Positive)
 123 spam1(op_abs           , PyNumber_Absolute)
 124 spam1(op_inv           , PyNumber_Invert)
 125 spam2(op_lshift        , PyNumber_Lshift)
 126 spam2(op_rshift        , PyNumber_Rshift)
 127 spami(op_not_          , PyObject_Not)
 128 spam2(op_and_          , PyNumber_And)
 129 spam2(op_xor           , PyNumber_Xor)
 130 spam2(op_or_           , PyNumber_Or)
 131 spami(isSequenceType   , PySequence_Check)
 132 spam2(op_concat        , PySequence_Concat)
 133 spamoi(op_repeat       , PySequence_Repeat)
 134 spami2(op_contains     , PySequence_Contains)
 135 spami2(indexOf         , PySequence_Index)
 136 spami2(countOf         , PySequence_Count)
 137 spami(isMappingType    , PyMapping_Check)
 138 spam2(op_getitem       , PyObject_GetItem)
 139 spam2n(op_delitem       , PyObject_DelItem)
 140 spam3n(op_setitem      , PyObject_SetItem)
 141
 142 static PyObject*
 143 op_getslice(PyObject *s, PyObject *a)
 144 {
 145         PyObject *a1;
 146         int a2,a3;
 147
 148         if (!PyArg_ParseTuple(a,"Oii",&a1,&a2,&a3))
 149                 return NULL;
 150         return PySequence_GetSlice(a1,a2,a3);
 151 }
 152
 153 static PyObject*
 154 op_setslice(PyObject *s, PyObject *a)
 155 {
 156         PyObject *a1, *a4;
 157         int a2,a3;
 158
 159         if (!PyArg_ParseTuple(a,"OiiO",&a1,&a2,&a3,&a4))
 160                 return NULL;
 161
 162         if (-1 == PySequence_SetSlice(a1,a2,a3,a4))
 163                 return NULL;
 164
 165         Py_INCREF(Py_None);
 166         return Py_None;
 167 }
 168
 169 static PyObject*
 170 op_delslice(PyObject *s, PyObject *a)
 171 {
 172         PyObject *a1;
 173         int a2,a3;
 174
 175         if(! PyArg_ParseTuple(a,"Oii",&a1,&a2,&a3))
 176                 return NULL;
 177
 178         if (-1 == PySequence_DelSlice(a1,a2,a3))
 179                 return NULL;
 180
 181         Py_INCREF(Py_None);
 182         return Py_None;
 183 }
 184
 185 #undef spam1
 186 #undef spam2
 187 #define spam1(OP,DOC) {#OP, OP, METH_VARARGS, DOC},
 188 #define spam2(OP,ALTOP,DOC) {#OP, op_##OP, METH_VARARGS, DOC}, \
 189                            {#ALTOP, op_##OP, METH_VARARGS, DOC},
 190
 191 static struct PyMethodDef operator_methods[] = {
 192
 193 spam1(isCallable,
 194  "isCallable(a) -- Same as callable(a).")
 195 spam1(isNumberType,
 196  "isNumberType(a) -- Return 1 if a has a numeric type, and zero otherwise.")
 197 spam1(isSequenceType,
 198  "isSequenceType(a) -- Return 1 if a has a sequence type, and zero otherwise.")
 199 spam1(truth,
 200  "truth(a) -- Return 1 if a is true, and 0 otherwise.")
 201 spam2(contains,sequenceIncludes,
 202  "contains(a, b) -- Same as b in a (note reversed operands).")
 203 spam1(indexOf,
 204  "indexOf(a, b) -- Return the first index of b in a.")
 205 spam1(countOf,
 206  "countOf(a, b) -- Return the number of times b occurs in a.")
 207 spam1(isMappingType,
 208  "isMappingType(a) -- Return 1 if a has a mapping type, and zero otherwise.")
 209
 210 spam2(add,__add__, "add(a, b) -- Same as a + b.")
 211 spam2(sub,__sub__, "sub(a, b) -- Same as a - b.")
 212 spam2(mul,__mul__, "mul(a, b) -- Same as a * b.")
 213 spam2(div,__div__, "div(a, b) -- Same as a / b.")
 214 spam2(mod,__mod__, "mod(a, b) -- Same as a % b.")
 215 spam2(neg,__neg__, "neg(a) -- Same as -a.")
 216 spam2(pos,__pos__, "pos(a) -- Same as +a.")
 217 spam2(abs,__abs__, "abs(a) -- Same as abs(a).")
 218 spam2(inv,__inv__, "inv(a) -- Same as ~a.")
 219 spam2(lshift,__lshift__, "lshift(a, b) -- Same as a << b.")
 220 spam2(rshift,__rshift__, "rshift(a, b) -- Same as a >> b.")
 221 spam2(not_,__not__, "not_(a) -- Same as not a.")
 222 spam2(and_,__and__, "and_(a, b) -- Same as a & b.")
 223 spam2(xor,__xor__, "xor(a, b) -- Same as a ^ b.")
 224 spam2(or_,__or__, "or_(a, b) -- Same as a | b.")
 225 spam2(concat,__concat__,
 226  "concat(a, b) -- Same as a + b, for a and b sequences.")
 227 spam2(repeat,__repeat__,
 228  "repeat(a, b) -- Return a * b, where a is a sequence, and b is an integer.")
 229 spam2(getitem,__getitem__,
 230  "getitem(a, b) -- Same as a[b].")
 231 spam2(setitem,__setitem__,
 232  "setitem(a, b, c) -- Same as a[b] = c.")
 233 spam2(delitem,__delitem__,
 234  "delitem(a, b) -- Same as del a[b].")
 235 spam2(getslice,__getslice__,
 236  "getslice(a, b, c) -- Same as a[b:c].")
 237 spam2(setslice,__setslice__,
 238 "setslice(a, b, c, d) -- Same as a[b:c] = d.")
 239 spam2(delslice,__delslice__,
 240 "delslice(a, b, c) -- Same as del a[b:c].")
 241
 242         {NULL,          NULL}           /* sentinel */
 243
 244 };
 245
 246
 247 /* Initialization function for the module (*must* be called initoperator) */
 248
 249 DL_EXPORT(void)
 250 initoperator(void)
 251 {
 252         /* Create the module and add the functions */
 253         Py_InitModule4("operator", operator_methods, operator_doc,
 254                        (PyObject*)NULL, PYTHON_API_VERSION);
 255 }