PyObject *KX_PythonComponent::py_component_new(PyTypeObject *type, PyObject *args, PyObject *kwds) { KX_PythonComponent *comp = new KX_PythonComponent(type->tp_name); PyObject *proxy = py_base_new(type, PyTuple_Pack(1, comp->GetProxy()), kwds); if (!proxy) { delete comp; return NULL; } return proxy; }
static long umpyew_utime(char *path, struct utimbuf *buf) { PYINSYS(utime, 2); PYARG(0, PyString_FromString(path)); if (buf) PYARG(1, PyTuple_Pack(2, PyInt_FromLong(buf->actime), PyInt_FromLong(buf->modtime))); else PYARG(1, Py_None); PYCALL; PYOUT; return retval; }
static PyObject * create_filter(PyObject *category, _Py_Identifier *id) { PyObject *action_str = _PyUnicode_FromId(id); if (action_str == NULL) { return NULL; } /* This assumes the line number is zero for now. */ return PyTuple_Pack(5, action_str, Py_None, category, Py_None, _PyLong_Zero); }
static int update_registry(PyObject *registry, PyObject *text, PyObject *category, int add_zero) { PyObject *altkey, *zero = NULL; int rc; if (add_zero) { zero = PyInt_FromLong(0); if (zero == NULL) return -1; altkey = PyTuple_Pack(3, text, category, zero); } else altkey = PyTuple_Pack(2, text, category); rc = already_warned(registry, altkey, 1); Py_XDECREF(zero); Py_XDECREF(altkey); return rc; }
static PyObject * KyotoDB_iteritems(KyotoDB *self) { KyotoCursor *cursor = PyObject_New(KyotoCursor, &yakc_CursorType); APR type(PyInt_FromLong((long)KYOTO_ITEMS)); APR tuple(PyTuple_Pack(2, self, type.get())); int re = Cursor_init(cursor, tuple.get(), NULL); if (re == 0) return (PyObject *)cursor; PyErr_SetString(PyExc_RuntimeError, "Cannot create cursor"); return NULL; }
static PyObject *PyKAdminPrincipal_get_keys(PyKAdminPrincipalObject *self, void *closure) { /* key structure: { kvno: [("enctype", "salt"), ("enctype", "salt")], kvno: ... } */ PyObject *kvno = NULL; PyObject *enctype = NULL; PyObject *salttype = NULL; PyObject *tuple = NULL; PyObject *list = NULL; PyObject *keys = PyDict_New(); ssize_t index = 0; for (; index < self->entry.n_key_data; index++) { krb5_key_data *key_data = &self->entry.key_data[index]; kvno = PyUnifiedLongInt_FromLong(key_data->key_data_kvno); enctype = pykadmin_key_enctype_name(key_data); salttype = pykadmin_key_salttype_name(key_data); tuple = PyTuple_Pack(2, enctype, salttype); if (kvno) { if (PyDict_Contains(keys, kvno)) { list = PyDict_GetItem(keys, kvno); } else { list = PyList_New(0); PyDict_SetItem(keys, kvno, list); } } if (list && tuple) { PyList_Append(list, tuple); } } return keys; }
PyObject* objToJSONFile(PyObject* self, PyObject *args) { PyObject *data; PyObject *file; PyObject *string; PyObject *write; PyObject *argtuple; if (!PyArg_ParseTuple (args, "OO", &data, &file)) { return NULL; } if (!PyObject_HasAttrString (file, "write")) { PyErr_Format (PyExc_TypeError, "expected file"); return NULL; } write = PyObject_GetAttrString (file, "write"); if (!PyCallable_Check (write)) { Py_XDECREF(write); PyErr_Format (PyExc_TypeError, "expected file"); return NULL; } string = objToJSON (self, data); if (string == NULL) { Py_XDECREF(write); return NULL; } argtuple = PyTuple_Pack (1, string); if (argtuple == NULL) { Py_XDECREF(write); return NULL; } if (PyObject_CallObject (write, argtuple) == NULL) { Py_XDECREF(write); Py_XDECREF(argtuple); return NULL; } Py_XDECREF(write); Py_XDECREF(argtuple); Py_XDECREF(string); Py_RETURN_NONE; }
int prop_descr_set(PyObject *self, PyObject *obj, PyObject *value) { int res; if (value != NULL) { PyObject *result = PyTuple_Pack(2, self, value); res = PyObject_SetAttrString(obj, "y", result); Py_DECREF(result); } else { res = PyObject_SetAttrString(obj, "z", self); } return res; }
static PyObject* set_reduce(BoxedSet* so) noexcept { PyObject* keys = NULL, * args = NULL, * result = NULL, * dict = NULL; keys = PySequence_List((PyObject*)so); if (keys == NULL) goto done; args = PyTuple_Pack(1, keys); if (args == NULL) goto done; dict = PyObject_GetAttrString((PyObject*)so, "__dict__"); if (dict == NULL) { PyErr_Clear(); dict = Py_None; Py_INCREF(dict); } result = PyTuple_Pack(3, Py_TYPE(so), args, dict); done: Py_XDECREF(args); Py_XDECREF(keys); Py_XDECREF(dict); return result; }
PyObject* __pycomps_dict_pair_out(COMPS_HSListItem *hsit) { PyObject *key, *val, *tuple; char *x; key = PyUnicode_FromString((char*) ((COMPS_ObjRTreePair*)hsit->data)->key); x = comps_object_tostr(((COMPS_ObjRTreePair*)hsit->data)->data); val = PyUnicode_FromString(x); free(x); tuple = PyTuple_Pack(2, key, val); Py_DECREF(key); Py_DECREF(val); return tuple; }
static PyObject *t_descriptor_isValueRequired(t_descriptor *self, t_item *item) { t_attribute *attr = self->attr; if (!PyObject_TypeCheck(item, CItem)) { PyErr_SetObject(PyExc_TypeError, (PyObject *) item); return NULL; } if (attr) { int flags = attr->flags; t_values *attrDict = get_attrdict(item, flags); return PyTuple_Pack(2, attrDict ? (PyObject *) attrDict : Py_None, attrDict && flags & A_REQUIRED ? Py_True : Py_False); } else return PyTuple_Pack(2, Py_None, Py_False); }
static PyObject * math_log(PyObject *self, PyObject *args) { PyObject *arg; PyObject *base = NULL; PyObject *num, *den; PyObject *ans; PyObject *newargs; if (!PyArg_UnpackTuple(args, "log", 1, 2, &arg, &base)) return NULL; if (base == NULL) return loghelper(args, log, "d:log", arg); newargs = PyTuple_Pack(1, arg); if (newargs == NULL) return NULL; num = loghelper(newargs, log, "d:log", arg); Py_DECREF(newargs); if (num == NULL) return NULL; newargs = PyTuple_Pack(1, base); if (newargs == NULL) { Py_DECREF(num); return NULL; } den = loghelper(newargs, log, "d:log", base); Py_DECREF(newargs); if (den == NULL) { Py_DECREF(num); return NULL; } ans = PyNumber_Divide(num, den); Py_DECREF(num); Py_DECREF(den); return ans; }
static bool HasOwnership(PyObject* obj) { PyObject* addr = GetPointer(obj); PyObject* name = GetName(obj); auto_pyobject nameaddr = PyTuple_Pack(2, name, addr); Py_DECREF(name); Py_DECREF(addr); PyObject* dtor = PyDict_GetItem(GetAddrDtorDict(), *nameaddr); if (!dtor || dtor == Py_None) { return false; } else { return true; } }
static PyObject * KyotoDB_array(KyotoDB *self, int type) { PyObject *result = PyList_New(self->m_db->count()); Py_ssize_t i = 0; kyotocabinet::BasicDB::Cursor *cursor = self->m_db->cursor(); cursor->jump(); std::string key; std::string value; while (cursor->get(&key, &value, true)) { switch (type) { case 0: { PyObject *pkey = KyotoDB_load(key, self->use_pickle); if (pkey == NULL) goto onerror; PyList_SetItem(result, i++, pkey); break; } case 1: { PyObject *pvalue = KyotoDB_load(value, self->use_pickle); if (pvalue == NULL) goto onerror; PyList_SetItem(result, i++, pvalue); break; } case 2: { APR pkey(KyotoDB_load(key, self->use_pickle)); if (pkey == NULL) goto onerror; APR pvalue(KyotoDB_load(value, self->use_pickle)); if (pvalue == NULL) goto onerror; PyList_SetItem(result, i++, PyTuple_Pack(2, (PyObject *)pkey, (PyObject *)pvalue)); break; } } } delete cursor; return result; onerror: for (Py_ssize_t j = 0; j < i; j++) { PyObject *obj = PyList_GetItem(result, j); Py_DECREF(obj); } delete cursor; return NULL; }
static PyObject * range_index(rangeobject *r, PyObject *ob) { PyObject *idx, *tmp; int contains; PyObject *format_tuple, *err_string; static PyObject *err_format = NULL; if (!PyLong_CheckExact(ob) && !PyBool_Check(ob)) { Py_ssize_t index; index = _PySequence_IterSearch((PyObject*)r, ob, PY_ITERSEARCH_INDEX); if (index == -1) return NULL; return PyLong_FromSsize_t(index); } contains = range_contains_long(r, ob); if (contains == -1) return NULL; if (!contains) goto value_error; tmp = PyNumber_Subtract(ob, r->start); if (tmp == NULL) return NULL; /* idx = (ob - r.start) // r.step */ idx = PyNumber_FloorDivide(tmp, r->step); Py_DECREF(tmp); return idx; value_error: /* object is not in the range */ if (err_format == NULL) { err_format = PyUnicode_FromString("%r is not in range"); if (err_format == NULL) return NULL; } format_tuple = PyTuple_Pack(1, ob); if (format_tuple == NULL) return NULL; err_string = PyUnicode_Format(err_format, format_tuple); Py_DECREF(format_tuple); if (err_string == NULL) return NULL; PyErr_SetObject(PyExc_ValueError, err_string); Py_DECREF(err_string); return NULL; }
static PyObject * pyrapidjson_dump(PyObject *self, PyObject *args, PyObject *kwargs) { // TODO: not support kwargs like json.dump() (encoding, etc...) static char *kwlist[] = {(char *)"obj", (char *)"fp", NULL}; PyObject *py_file, *py_json, *py_string, *write_method, *write_arg, *write_ret; rapidjson::Document doc; /* Parse arguments */ if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO", kwlist, &py_json, &py_file)) return NULL; if (!PyObject_HasAttrString(py_file, "write")) { PyErr_Format(PyExc_TypeError, "expected file object. has not write() method."); return NULL; } write_method = PyObject_GetAttrString(py_file, "write"); if (!PyCallable_Check(write_method)) { Py_XDECREF(write_method); PyErr_Format(PyExc_TypeError, "expected file object. write() method is not callable."); return NULL; } py_string = pyobj2pystring(py_json); if (py_string == NULL) { Py_XDECREF(write_method); PyErr_SetString(PyExc_RuntimeError, "pyobj2pystring() error."); return NULL; } write_arg = PyTuple_Pack(1, py_string); if (write_arg == NULL) { Py_XDECREF(write_method); return NULL; } write_ret = PyObject_CallObject(write_method, write_arg); if (write_ret == NULL) { Py_XDECREF(write_method); Py_XDECREF(write_arg); Py_XDECREF(py_string); return NULL; } Py_XDECREF(write_method); Py_XDECREF(write_arg); Py_XDECREF(write_ret); Py_XDECREF(py_string); Py_RETURN_NONE; }
PyMODINIT_FUNC init_pyjava(void) { PyObject *mod; mod = Py_InitModule("_pyjava", methods); if(mod == NULL) return ; Err_Base = PyErr_NewException("pyjava.Error", NULL, NULL); Py_INCREF(Err_Base); PyModule_AddObject(mod, "Error", Err_Base); Err_ClassNotFound = PyErr_NewException( "pyjava.ClassNotFound", Err_Base, NULL); Py_INCREF(Err_ClassNotFound); PyModule_AddObject(mod, "ClassNotFound", Err_ClassNotFound); { PyObject *bases = PyTuple_Pack(2, Err_Base, PyExc_TypeError); Err_NoMatchingOverload = PyErr_NewException( "pyjava.NoMatchingOverload", bases, NULL); Py_INCREF(Err_NoMatchingOverload); PyModule_AddObject(mod, "NoMatchingOverload", Err_NoMatchingOverload); Py_DECREF(bases); } { PyObject *bases = PyTuple_Pack(3, Err_Base, PyExc_TypeError, PyExc_AttributeError); Err_FieldTypeError = PyErr_NewException( "pyjava.NoMatchingOverload", bases, NULL); Py_INCREF(Err_FieldTypeError); PyModule_AddObject(mod, "FieldTypeError", Err_FieldTypeError); Py_DECREF(bases); } javawrapper_init(mod); }
NPY_NO_EXPORT void dot_alignment_error(PyArrayObject *a, int i, PyArrayObject *b, int j) { PyObject *errmsg = NULL, *format = NULL, *fmt_args = NULL, *i_obj = NULL, *j_obj = NULL, *shape1 = NULL, *shape2 = NULL, *shape1_i = NULL, *shape2_j = NULL; format = PyUString_FromString("shapes %s and %s not aligned:" " %d (dim %d) != %d (dim %d)"); shape1 = convert_shape_to_string(PyArray_NDIM(a), PyArray_DIMS(a), ""); shape2 = convert_shape_to_string(PyArray_NDIM(b), PyArray_DIMS(b), ""); i_obj = PyLong_FromLong(i); j_obj = PyLong_FromLong(j); shape1_i = PyLong_FromSsize_t(PyArray_DIM(a, i)); shape2_j = PyLong_FromSsize_t(PyArray_DIM(b, j)); if (!format || !shape1 || !shape2 || !i_obj || !j_obj || !shape1_i || !shape2_j) { goto end; } fmt_args = PyTuple_Pack(6, shape1, shape2, shape1_i, i_obj, shape2_j, j_obj); if (fmt_args == NULL) { goto end; } errmsg = PyUString_Format(format, fmt_args); if (errmsg != NULL) { PyErr_SetObject(PyExc_ValueError, errmsg); } else { PyErr_SetString(PyExc_ValueError, "shapes are not aligned"); } end: Py_XDECREF(errmsg); Py_XDECREF(fmt_args); Py_XDECREF(format); Py_XDECREF(i_obj); Py_XDECREF(j_obj); Py_XDECREF(shape1); Py_XDECREF(shape2); Py_XDECREF(shape1_i); Py_XDECREF(shape2_j); }
static PyObject * forms_do_or_check_forms(PyObject *dummy, FL_OBJECT *(*func)(void)) { FL_OBJECT *generic; genericobject *g; PyObject *arg, *res; for (;;) { Py_BEGIN_ALLOW_THREADS generic = (*func)(); Py_END_ALLOW_THREADS if (generic == NULL) { Py_INCREF(Py_None); return Py_None; } if (generic == FL_EVENT) { int dev; short val; if (my_event_callback == NULL) return PyInt_FromLong(-1L); dev = fl_qread(&val); arg = Py_BuildValue("(ih)", dev, val); if (arg == NULL) return NULL; res = PyEval_CallObject(my_event_callback, arg); Py_XDECREF(res); Py_DECREF(arg); if (res == NULL) return NULL; /* Callback raised exception */ continue; } g = findgeneric(generic); if (g == NULL) { /* Object not known to us (some dialogs cause this) */ continue; /* Ignore it */ } if (g->ob_callback == NULL) { Py_INCREF(g); return ((PyObject *) g); } arg = PyTuple_Pack(2, (PyObject *)g, g->ob_callback_arg); if (arg == NULL) return NULL; res = PyEval_CallObject(g->ob_callback, arg); Py_XDECREF(res); Py_DECREF(arg); if (res == NULL) return NULL; /* Callback raised exception */ } }
static PyObject* Snmp_oid2string(PyObject *resultvalue) { PyObject *dot, *tmp, *tmp2, *list; int i; if ((list = PyTuple_New(PyTuple_Size(resultvalue))) == NULL) return NULL; for (i = 0; i < PyTuple_Size(resultvalue); i++) { if ((tmp = PyTuple_GetItem(resultvalue, i)) == NULL) { Py_DECREF(list); return NULL; } if ((tmp2 = PyObject_Str(tmp)) == NULL) { Py_DECREF(list); return NULL; } PyTuple_SetItem(list, i, tmp2); if (PyErr_Occurred()) { Py_DECREF(tmp2); Py_DECREF(list); return NULL; } } Py_DECREF(resultvalue); resultvalue = list; if ((dot = PyString_FromString(".")) == NULL) return NULL; if ((tmp = PyObject_CallMethod(dot, "join", "(O)", resultvalue)) == NULL) { Py_DECREF(dot); return NULL; } Py_DECREF(resultvalue); Py_DECREF(dot); resultvalue = tmp; if ((tmp = PyTuple_Pack(1, resultvalue)) == NULL) return NULL; Py_DECREF(resultvalue); resultvalue = tmp; if ((tmp2 = PyString_FromString(".%s")) == NULL) return NULL; if ((tmp = PyString_Format(tmp2, resultvalue)) == NULL) { Py_DECREF(tmp2); return NULL; } Py_DECREF(tmp2); Py_DECREF(resultvalue); return tmp; }
PyObject * PyErr_NewException(const char *name, PyObject *base, PyObject *dict) { const char *dot; PyObject *modulename = NULL; PyObject *classname = NULL; PyObject *mydict = NULL; PyObject *bases = NULL; PyObject *result = NULL; dot = strrchr(name, '.'); if (dot == NULL) { PyErr_SetString(PyExc_SystemError, "PyErr_NewException: name must be module.class"); return NULL; } if (base == NULL) base = PyExc_Exception; if (dict == NULL) { dict = mydict = PyDict_New(); if (dict == NULL) goto failure; } if (PyDict_GetItemString(dict, "__module__") == NULL) { modulename = PyUnicode_FromStringAndSize(name, (Py_ssize_t)(dot-name)); if (modulename == NULL) goto failure; if (PyDict_SetItemString(dict, "__module__", modulename) != 0) goto failure; } if (PyTuple_Check(base)) { bases = base; /* INCREF as we create a new ref in the else branch */ Py_INCREF(bases); } else { bases = PyTuple_Pack(1, base); if (bases == NULL) goto failure; } /* Create a real class. */ result = PyObject_CallFunction((PyObject *)&PyType_Type, "sOO", dot+1, bases, dict); failure: Py_XDECREF(bases); Py_XDECREF(mydict); Py_XDECREF(classname); Py_XDECREF(modulename); return result; }
static PyObject *__Pyx_PyDict_GetItem(PyObject *d, PyObject* key) { PyObject *value; value = PyDict_GetItemWithError(d, key); if (unlikely(!value)) { if (!PyErr_Occurred()) { PyObject* args = PyTuple_Pack(1, key); if (likely(args)) PyErr_SetObject(PyExc_KeyError, args); Py_XDECREF(args); } return NULL; } Py_INCREF(value); return value; }
static PyObject* factorize(PyObject* self, PyObject* args){ Py_ssize_t n = 0; if (!PyArg_ParseTuple(args, "n:factorize", &n)) return NULL; PyObject* prime_factorization = PyList_New(0); if (n < 2) return prime_factorization; size_t i = 0; while (!(n & 1)){ n /= 2; i++; } if (i > 0){ PyObject* tuple = PyTuple_Pack(2, PyInt_FromLong(2), PyInt_FromSize_t(i)); PyList_Append(prime_factorization, tuple); Py_DECREF(tuple); } Py_ssize_t p = 3; while (p*p <= n){ i = 0; while (n % p == 0){ n /= p; i++; } if (i > 0){ PyObject* tuple = PyTuple_Pack(2, PyInt_FromSsize_t(p), PyInt_FromSize_t(i)); PyList_Append(prime_factorization, tuple); Py_DECREF(tuple); } p += 2; } if (n > 1){ PyObject* tuple = PyTuple_Pack(2, PyInt_FromSsize_t(n), PyInt_FromLong(1)); PyList_Append(prime_factorization, tuple); Py_DECREF(tuple); } return prime_factorization; }
int microprotocols_add(PyTypeObject *type, PyObject *proto, PyObject *cast) { PyObject *key; if (proto == NULL) proto = (PyObject*)&isqlquoteType; Dprintf("microprotocols_add: cast %p for (%s, ?)", cast, type->tp_name); key = PyTuple_Pack(2, (PyObject*)type, proto); PyDict_SetItem(psyco_adapters, key, cast); Py_DECREF(key); return 0; }
CValue *KX_PythonComponent::GetReplica() { KX_PythonComponent *replica = new KX_PythonComponent(*this); replica->ProcessReplica(); // Subclass the python component. PyTypeObject *type = Py_TYPE(GetProxy()); if (!py_base_new(type, PyTuple_Pack(1, replica->GetProxy()), NULL)) { CM_Error("failed replicate component: \"" << m_name << "\""); delete replica; return NULL; } return replica; }
static PyObject * snakeoil_iflatten_instance_new(PyTypeObject *type, PyObject *args, PyObject *kwargs) { snakeoil_iflatten_instance *self; PyObject *l=NULL, *skip_flattening=(PyObject*)&PyBaseString_Type; int res; if (kwargs && PyDict_Size(kwargs)) { PyErr_SetString(PyExc_TypeError, "iflatten_instance takes no keyword arguments"); return NULL; } if (!PyArg_UnpackTuple(args, "iflatten_instance", 1, 2, &l, &skip_flattening)) { return NULL; } /* Check if we got a single argument that should be skipped. */ res = PyObject_IsInstance(l, skip_flattening); if (res == -1) { return NULL; } else if (res) { PyObject *tuple = PyTuple_Pack(1, l); if (!tuple) { return NULL; } PyObject *iter = PyObject_GetIter(tuple); Py_DECREF(tuple); return iter; } self = (snakeoil_iflatten_instance *)type->tp_alloc(type, 0); if (!self) return NULL; self->in_iternext = 0; if (!(self->iterables = build_initial_iterables(l))) { Py_DECREF(self); return NULL; } Py_INCREF(skip_flattening); self->skip_flattening = skip_flattening; return (PyObject *)self; }
PyObject* JSONFileToObj(PyObject* self, PyObject *args, PyObject *kwargs) { PyObject *read; PyObject *string; PyObject *result; PyObject *file = NULL; PyObject *argtuple; if (!PyArg_ParseTuple (args, "O", &file)) { return NULL; } if (!PyObject_HasAttrString (file, "read")) { PyErr_Format (PyExc_TypeError, "expected file"); return NULL; } read = PyObject_GetAttrString (file, "read"); if (!PyCallable_Check (read)) { Py_XDECREF(read); PyErr_Format (PyExc_TypeError, "expected file"); return NULL; } string = PyObject_CallObject (read, NULL); Py_XDECREF(read); if (string == NULL) { return NULL; } argtuple = PyTuple_Pack(1, string); result = JSONToObj (self, argtuple, kwargs); Py_XDECREF(argtuple); Py_XDECREF(string); if (result == NULL) { return NULL; } return result; }
static PyObject *ffi_list_types(FFIObject *self, PyObject *noargs) { Py_ssize_t i, n1 = self->types_builder.ctx.num_typenames; Py_ssize_t n23 = self->types_builder.ctx.num_struct_unions; PyObject *o, *lst[3] = {NULL, NULL, NULL}, *result = NULL; lst[0] = PyList_New(n1); if (lst[0] == NULL) goto error; lst[1] = PyList_New(0); if (lst[1] == NULL) goto error; lst[2] = PyList_New(0); if (lst[2] == NULL) goto error; for (i = 0; i < n1; i++) { o = PyText_FromString(self->types_builder.ctx.typenames[i].name); if (o == NULL) goto error; PyList_SET_ITEM(lst[0], i, o); } for (i = 0; i < n23; i++) { const struct _cffi_struct_union_s *s; int err, index; s = &self->types_builder.ctx.struct_unions[i]; if (s->name[0] == '$') continue; o = PyText_FromString(s->name); if (o == NULL) goto error; index = (s->flags & _CFFI_F_UNION) ? 2 : 1; err = PyList_Append(lst[index], o); Py_DECREF(o); if (err < 0) goto error; } result = PyTuple_Pack(3, lst[0], lst[1], lst[2]); /* fall-through */ error: Py_XDECREF(lst[2]); Py_XDECREF(lst[1]); Py_XDECREF(lst[0]); return result; }
static PyObject * create_filter(PyObject *category, const char *action) { static PyObject *ignore_str = NULL; static PyObject *error_str = NULL; static PyObject *default_str = NULL; static PyObject *always_str = NULL; PyObject *action_obj = NULL; if (!strcmp(action, "ignore")) { if (ignore_str == NULL) { ignore_str = PyUnicode_InternFromString("ignore"); if (ignore_str == NULL) return NULL; } action_obj = ignore_str; } else if (!strcmp(action, "error")) { if (error_str == NULL) { error_str = PyUnicode_InternFromString("error"); if (error_str == NULL) return NULL; } action_obj = error_str; } else if (!strcmp(action, "default")) { if (default_str == NULL) { default_str = PyUnicode_InternFromString("default"); if (default_str == NULL) return NULL; } action_obj = default_str; } else if (!strcmp(action, "always")) { if (always_str == NULL) { always_str = PyUnicode_InternFromString("always"); if (always_str == NULL) return NULL; } action_obj = always_str; } else { Py_FatalError("unknown action"); } /* This assumes the line number is zero for now. */ return PyTuple_Pack(5, action_obj, Py_None, category, Py_None, _PyLong_Zero); }
// keep this simple so that print(x) and str(x) are concise if x is NA static PyObject * NA_repr(SlopNAObject *self) { PyObject* type_repr = PyObject_Repr(self->exc_type); PyObject* repr = PyTuple_Pack(1, type_repr); PyObject* fmt = PyString_FromString("<NA %s>"); PyObject* ret = PyString_Format(fmt, repr); Py_DECREF(fmt); Py_DECREF(repr); Py_DECREF(type_repr); return ret; }