void
_PyModule_ClearDict(PyObject *d)
{
/* To make the execution order of destructors for global
objects a bit more predictable, we first zap all objects
whose name starts with a single underscore, before we clear
the entire dictionary. We zap them by replacing them with
None, rather than deleting them from the dictionary, to
avoid rehashing the dictionary (to some extent). */
Py_ssize_t pos;
PyObject *key, *value;
/* First, clear only names starting with a single underscore */
pos = 0;
while (PyDict_Next(d, &pos, &key, &value)) {
if (value != Py_None && PyUnicode_Check(key)) {
if (PyUnicode_READ_CHAR(key, 0) == '_' &&
PyUnicode_READ_CHAR(key, 1) != '_') {
if (Py_VerboseFlag > 1) {
const char *s = _PyUnicode_AsString(key);
if (s != NULL)
PySys_WriteStderr("# clear[1] %s\n", s);
else
PyErr_Clear();
}
if (PyDict_SetItem(d, key, Py_None) != 0)
PyErr_Clear();
}
}
}
/* Next, clear all names except for __builtins__ */
pos = 0;
while (PyDict_Next(d, &pos, &key, &value)) {
if (value != Py_None && PyUnicode_Check(key)) {
if (PyUnicode_READ_CHAR(key, 0) != '_' ||
PyUnicode_CompareWithASCIIString(key, "__builtins__") != 0)
{
if (Py_VerboseFlag > 1) {
const char *s = _PyUnicode_AsString(key);
if (s != NULL)
PySys_WriteStderr("# clear[2] %s\n", s);
else
PyErr_Clear();
}
if (PyDict_SetItem(d, key, Py_None) != 0)
PyErr_Clear();
}
}
}
/* Note: we leave __builtins__ in place, so that destructors
of non-global objects defined in this module can still use
builtins, in particularly 'None'. */
}
static int
PxImageView_setattro(PxImageViewObject* self, PyObject* pyAttributeName, PyObject *pyValue)
{
if (PyUnicode_Check(pyAttributeName)) {
if (PyUnicode_CompareWithASCIIString(pyAttributeName, "data") == 0) {
if (!PxImageView_SetData(self, pyValue))
return -1;
return 0;
}
}
return Py_TYPE(self)->tp_base->tp_setattro((PyObject*)self, pyAttributeName, pyValue);
}
static PyObject*
PxImageView_getattro(PxImageViewObject* self, PyObject* pyAttributeName)
{
PyObject* pyResult;
pyResult = PyObject_GenericGetAttr((PyObject *)self, pyAttributeName);
if (pyResult == NULL && PyErr_ExceptionMatches(PyExc_AttributeError) && PyUnicode_Check(pyAttributeName)) {
if (PyUnicode_CompareWithASCIIString(pyAttributeName, "data") == 0) {
PyErr_Clear();
return self->pyData;
}
}
return Py_TYPE(self)->tp_base->tp_getattro((PyObject*)self, pyAttributeName);
}
// --------------------------------------------------
//
int setattro(PyObject *self, PyObject *nameobj, PyObject *srcobj)
{
PyObj *o = (PyObj *)self;
/* Set attribute 'name' to value 'v'. v==NULL means delete */
if (srcobj == NULL) {
PyErr_SetString(PyExc_RuntimeError, "Cannot delete attribute");
return -1;
}
//
// Check properties we know
//
if (PyUnicode_CompareWithASCIIString(nameobj, "name") == 0)
{
o->p->SetName( PySTRING_AsString(*srcobj) ); //http://stackoverflow.com/questions/8229597/embedding-python
return 0;
}
if(PyUnicode_CompareWithASCIIString(nameobj, "dataType") == 0)
{
o->p->SetDataType((bk3dlib::DataType)PyLong_AsLong(srcobj));
return 0;
}
if(PyUnicode_CompareWithASCIIString(nameobj, "slot") == 0)
{
o->p->SetSlot((bk3dlib::DataType)PyLong_AsLong(srcobj));
return 0;
}
if(PyUnicode_CompareWithASCIIString(nameobj, "components") == 0)
{
o->p->SetNumComps((bk3dlib::DataType)PyLong_AsLong(srcobj));
return 0;
}
//
// Default Generic Attr
//
return PyObject_GenericSetAttr(self, nameobj, srcobj);
}
PyObject *
dbus_py_variant_level_getattro(PyObject *obj, PyObject *name)
{
PyObject *key, *value;
#ifdef PY3
if (PyUnicode_CompareWithASCIIString(name, "variant_level"))
return PyObject_GenericGetAttr(obj, name);
#else
if (PyBytes_Check(name)) {
Py_INCREF(name);
}
else if (PyUnicode_Check(name)) {
name = PyUnicode_AsEncodedString(name, NULL, NULL);
if (!name) {
return NULL;
}
}
else {
PyErr_SetString(PyExc_TypeError, "attribute name must be string");
return NULL;
}
if (strcmp(PyBytes_AS_STRING(name), "variant_level")) {
value = PyObject_GenericGetAttr(obj, name);
Py_CLEAR(name);
return value;
}
Py_CLEAR(name);
#endif /* PY3 */
key = PyLong_FromVoidPtr(obj);
if (!key) {
return NULL;
}
value = PyDict_GetItem(_dbus_py_variant_levels, key);
Py_CLEAR(key);
if (!value)
return NATIVEINT_FROMLONG(0);
Py_INCREF(value);
return value;
}
int _LDAP_initialization(LDAP **ld, PyObject *url, int tls_option) {
int rc;
int portnum;
char *hoststr = NULL;
const int version = LDAP_VERSION3;
const int tls_settings = SCH_CRED_MANUAL_CRED_VALIDATION | SCH_CRED_NO_SERVERNAME_CHECK;
PyObject *scheme = PyObject_GetAttrString(url, "scheme");
PyObject *host = PyObject_GetAttrString(url, "host");
PyObject *port = PyObject_GetAttrString(url, "port");
if (scheme == NULL || host == NULL || port == NULL) return -1;
hoststr = PyObject2char(host);
portnum = PyLong_AsLong(port);
Py_DECREF(host);
Py_DECREF(port);
if (hoststr == NULL) return -1;
if (PyUnicode_CompareWithASCIIString(scheme, "ldaps") == 0) {
*ld = ldap_sslinit(hoststr, portnum, 1);
} else {
*ld = ldap_init(hoststr, portnum);
}
Py_DECREF(scheme);
if (ld == NULL) return -1;
ldap_set_option(*ld, LDAP_OPT_PROTOCOL_VERSION, &version);
switch (tls_option) {
case -1:
/* Cert policy is not set, nothing to do.*/
break;
case 2:
case 4:
/* Cert policy is demand or try, then standard procedure. */
break;
case 0:
case 3:
/* Cert policy is never or allow, then set TLS settings. */
ldap_set_option(*ld, 0x43, &tls_settings);
ldap_set_option(*ld, LDAP_OPT_SERVER_CERTIFICATE, &noverify);
break;
}
rc = ldap_connect(*ld, NULL);
return rc;
}
int compare(PyObject* val1, const char* val2)
{
if (PyUnicode_Check(val1))
#ifdef IS_PY3K
return PyUnicode_CompareWithASCIIString(val1, val2);
#else
{
PyObject* uVal2 = PyUnicode_FromString(val2);
bool result = PyUnicode_Compare(val1, uVal2);
Py_XDECREF(uVal2);
return result;
}
if (PyString_Check(val1))
return strcmp(PyString_AS_STRING(val1), val2);
#endif
return 0;
}
static PyObject *
thunk_getattro(PyObject *self, PyObject *name)
{
PyObject *arg;
PyObject *ret;
if (!PyUnicode_CompareWithASCIIString(name, "__class__")) {
if (!(arg = _strict_eval_borrowed(self))) {
return NULL;
}
return PyObject_GetAttr(arg, name);
}
if (!(arg = PyTuple_Pack(2, self, name))) {
return NULL;
}
ret = _thunk_new_no_check(Py_TYPE(self), LzBinary_getattr, arg, NULL);
Py_DECREF(arg);
return ret;
}
/* Returns 0 on error (no new refs), 1 on success */
static int
setup_context(Py_ssize_t stack_level, PyObject **filename, int *lineno,
PyObject **module, PyObject **registry)
{
PyObject *globals;
/* Setup globals and lineno. */
PyFrameObject *f = PyThreadState_GET()->frame;
// Stack level comparisons to Python code is off by one as there is no
// warnings-related stack level to avoid.
if (stack_level <= 0 || is_internal_frame(f)) {
while (--stack_level > 0 && f != NULL) {
f = f->f_back;
}
}
else {
while (--stack_level > 0 && f != NULL) {
f = next_external_frame(f);
}
}
if (f == NULL) {
globals = PyThreadState_Get()->interp->sysdict;
*lineno = 1;
}
else {
globals = f->f_globals;
*lineno = PyFrame_GetLineNumber(f);
}
*module = NULL;
/* Setup registry. */
assert(globals != NULL);
assert(PyDict_Check(globals));
*registry = PyDict_GetItemString(globals, "__warningregistry__");
if (*registry == NULL) {
int rc;
*registry = PyDict_New();
if (*registry == NULL)
return 0;
rc = PyDict_SetItemString(globals, "__warningregistry__", *registry);
if (rc < 0)
goto handle_error;
}
else
Py_INCREF(*registry);
/* Setup module. */
*module = PyDict_GetItemString(globals, "__name__");
if (*module == NULL) {
*module = PyUnicode_FromString("<string>");
if (*module == NULL)
goto handle_error;
}
else
Py_INCREF(*module);
/* Setup filename. */
*filename = PyDict_GetItemString(globals, "__file__");
if (*filename != NULL && PyUnicode_Check(*filename)) {
Py_ssize_t len;
int kind;
void *data;
if (PyUnicode_READY(*filename))
goto handle_error;
len = PyUnicode_GetLength(*filename);
kind = PyUnicode_KIND(*filename);
data = PyUnicode_DATA(*filename);
#define ascii_lower(c) ((c <= 127) ? Py_TOLOWER(c) : 0)
/* if filename.lower().endswith(".pyc"): */
if (len >= 4 &&
PyUnicode_READ(kind, data, len-4) == '.' &&
ascii_lower(PyUnicode_READ(kind, data, len-3)) == 'p' &&
ascii_lower(PyUnicode_READ(kind, data, len-2)) == 'y' &&
ascii_lower(PyUnicode_READ(kind, data, len-1)) == 'c')
{
*filename = PyUnicode_Substring(*filename, 0,
PyUnicode_GET_LENGTH(*filename)-1);
if (*filename == NULL)
goto handle_error;
}
else
Py_INCREF(*filename);
}
else {
*filename = NULL;
if (*module != Py_None && PyUnicode_CompareWithASCIIString(*module, "__main__") == 0) {
PyObject *argv = _PySys_GetObjectId(&PyId_argv);
/* PyList_Check() is needed because sys.argv is set to None during
Python finalization */
if (argv != NULL && PyList_Check(argv) && PyList_Size(argv) > 0) {
int is_true;
*filename = PyList_GetItem(argv, 0);
Py_INCREF(*filename);
/* If sys.argv[0] is false, then use '__main__'. */
is_true = PyObject_IsTrue(*filename);
if (is_true < 0) {
Py_DECREF(*filename);
goto handle_error;
}
else if (!is_true) {
Py_XSETREF(*filename, PyUnicode_FromString("__main__"));
if (*filename == NULL)
goto handle_error;
}
}
else {
/* embedded interpreters don't have sys.argv, see bug #839151 */
*filename = PyUnicode_FromString("__main__");
if (*filename == NULL)
goto handle_error;
}
}
if (*filename == NULL) {
*filename = *module;
Py_INCREF(*filename);
}
}
return 1;
handle_error:
/* filename not XDECREF'ed here as there is no way to jump here with a
dangling reference. */
Py_XDECREF(*registry);
Py_XDECREF(*module);
return 0;
}
static PyObject *
warn_explicit(PyObject *category, PyObject *message,
PyObject *filename, int lineno,
PyObject *module, PyObject *registry, PyObject *sourceline,
PyObject *source)
{
PyObject *key = NULL, *text = NULL, *result = NULL, *lineno_obj = NULL;
PyObject *item = NULL;
PyObject *action;
int rc;
/* module can be None if a warning is emitted late during Python shutdown.
In this case, the Python warnings module was probably unloaded, filters
are no more available to choose as action. It is safer to ignore the
warning and do nothing. */
if (module == Py_None)
Py_RETURN_NONE;
if (registry && !PyDict_Check(registry) && (registry != Py_None)) {
PyErr_SetString(PyExc_TypeError, "'registry' must be a dict");
return NULL;
}
/* Normalize module. */
if (module == NULL) {
module = normalize_module(filename);
if (module == NULL)
return NULL;
}
else
Py_INCREF(module);
/* Normalize message. */
Py_INCREF(message); /* DECREF'ed in cleanup. */
rc = PyObject_IsInstance(message, PyExc_Warning);
if (rc == -1) {
goto cleanup;
}
if (rc == 1) {
text = PyObject_Str(message);
if (text == NULL)
goto cleanup;
category = (PyObject*)message->ob_type;
}
else {
text = message;
message = PyObject_CallFunction(category, "O", message);
if (message == NULL)
goto cleanup;
}
lineno_obj = PyLong_FromLong(lineno);
if (lineno_obj == NULL)
goto cleanup;
/* Create key. */
key = PyTuple_Pack(3, text, category, lineno_obj);
if (key == NULL)
goto cleanup;
if ((registry != NULL) && (registry != Py_None)) {
rc = already_warned(registry, key, 0);
if (rc == -1)
goto cleanup;
else if (rc == 1)
goto return_none;
/* Else this warning hasn't been generated before. */
}
action = get_filter(category, text, lineno, module, &item);
if (action == NULL)
goto cleanup;
if (PyUnicode_CompareWithASCIIString(action, "error") == 0) {
PyErr_SetObject(category, message);
goto cleanup;
}
/* Store in the registry that we've been here, *except* when the action
is "always". */
rc = 0;
if (PyUnicode_CompareWithASCIIString(action, "always") != 0) {
if (registry != NULL && registry != Py_None &&
PyDict_SetItem(registry, key, Py_True) < 0)
goto cleanup;
else if (PyUnicode_CompareWithASCIIString(action, "ignore") == 0)
goto return_none;
else if (PyUnicode_CompareWithASCIIString(action, "once") == 0) {
if (registry == NULL || registry == Py_None) {
registry = get_once_registry();
if (registry == NULL)
goto cleanup;
}
/* _once_registry[(text, category)] = 1 */
rc = update_registry(registry, text, category, 0);
}
else if (PyUnicode_CompareWithASCIIString(action, "module") == 0) {
/* registry[(text, category, 0)] = 1 */
if (registry != NULL && registry != Py_None)
rc = update_registry(registry, text, category, 0);
}
else if (PyUnicode_CompareWithASCIIString(action, "default") != 0) {
PyErr_Format(PyExc_RuntimeError,
"Unrecognized action (%R) in warnings.filters:\n %R",
action, item);
goto cleanup;
}
}
if (rc == 1) /* Already warned for this module. */
goto return_none;
if (rc == 0) {
if (call_show_warning(category, text, message, filename, lineno,
lineno_obj, sourceline, source) < 0)
goto cleanup;
}
else /* if (rc == -1) */
goto cleanup;
return_none:
result = Py_None;
Py_INCREF(result);
cleanup:
Py_XDECREF(item);
Py_XDECREF(key);
Py_XDECREF(text);
Py_XDECREF(lineno_obj);
Py_DECREF(module);
Py_XDECREF(message);
return result; /* Py_None or NULL. */
}
// The type init slot.
static int pyqtSignal_init(PyObject *self, PyObject *args, PyObject *kwd_args)
{
qpycore_pyqtSignal *ps = (qpycore_pyqtSignal *)self;
// Get the keyword arguments.
PyObject *name_obj = 0;
const char *name = 0;
if (kwd_args)
{
SIP_SSIZE_T pos = 0;
PyObject *key, *value;
while (PyDict_Next(kwd_args, &pos, &key, &value))
{
#if PY_MAJOR_VERSION >= 3
if (PyUnicode_CompareWithASCIIString(key, "name") != 0)
{
PyErr_Format(PyExc_TypeError,
"pyqtSignal() got an unexpected keyword argument '%U'",
key);
Py_XDECREF(name_obj);
return -1;
}
#else
Q_ASSERT(PyString_Check(key));
if (qstrcmp(PyString_AS_STRING(key), "name") != 0)
{
PyErr_Format(PyExc_TypeError,
"pyqtSignal() got an unexpected keyword argument '%s'",
PyString_AS_STRING(key));
Py_XDECREF(name_obj);
return -1;
}
#endif
name_obj = value;
name = sipString_AsASCIIString(&name_obj);
if (!name)
return -1;
}
}
// If there is at least one argument and it is a sequence then assume all
// arguments are sequences. Unfortunately a string is also a sequence so
// check for tuples and lists explicitly.
if (PyTuple_GET_SIZE(args) > 0 && (PyTuple_Check(PyTuple_GET_ITEM(args, 0)) || PyList_Check(PyTuple_GET_ITEM(args, 0))))
{
for (SIP_SSIZE_T i = 0; i < PyTuple_GET_SIZE(args); ++i)
{
PyObject *types = PySequence_Tuple(PyTuple_GET_ITEM(args, i));
if (!types)
{
PyErr_SetString(PyExc_TypeError,
"pyqtSignal() argument expected to be sequence of types");
if (name)
{
Py_DECREF(name_obj);
}
return -1;
}
int rc = add_overload(ps, name, types);
Py_DECREF(types);
if (rc < 0)
{
if (name)
{
Py_DECREF(name_obj);
}
return -1;
}
}
}
else if (add_overload(ps, name, args) < 0)
{
if (name)
{
Py_DECREF(name_obj);
}
return -1;
}
if (name)
{
Py_DECREF(name_obj);
}
return 0;
}
static PyObject *
normalizeUserObj(PyObject *obj)
{
PyCFunctionObject *fn;
if (!PyCFunction_Check(obj)) {
Py_INCREF(obj);
return obj;
}
/* Replace built-in function objects with a descriptive string
because of built-in methods -- keeping a reference to
__self__ is probably not a good idea. */
fn = (PyCFunctionObject *)obj;
if (fn->m_self == NULL) {
/* built-in function: look up the module name */
PyObject *mod = fn->m_module;
PyObject *modname = NULL;
if (mod != NULL) {
if (PyUnicode_Check(mod)) {
modname = mod;
Py_INCREF(modname);
}
else if (PyModule_Check(mod)) {
modname = PyModule_GetNameObject(mod);
if (modname == NULL)
PyErr_Clear();
}
}
if (modname != NULL) {
if (PyUnicode_CompareWithASCIIString(modname, "builtins") != 0) {
PyObject *result;
result = PyUnicode_FromFormat("<%U.%s>", modname,
fn->m_ml->ml_name);
Py_DECREF(modname);
return result;
}
Py_DECREF(modname);
}
return PyUnicode_FromFormat("<%s>", fn->m_ml->ml_name);
}
else {
/* built-in method: try to return
repr(getattr(type(__self__), __name__))
*/
PyObject *self = fn->m_self;
PyObject *name = PyUnicode_FromString(fn->m_ml->ml_name);
PyObject *modname = fn->m_module;
if (name != NULL) {
PyObject *mo = _PyType_Lookup(Py_TYPE(self), name);
Py_XINCREF(mo);
Py_DECREF(name);
if (mo != NULL) {
PyObject *res = PyObject_Repr(mo);
Py_DECREF(mo);
if (res != NULL)
return res;
}
}
/* Otherwise, use __module__ */
PyErr_Clear();
if (modname != NULL && PyUnicode_Check(modname))
return PyUnicode_FromFormat("<built-in method %S.%s>",
modname, fn->m_ml->ml_name);
else
return PyUnicode_FromFormat("<built-in method %s>",
fn->m_ml->ml_name);
}
}
CounterLEObject_getattr(PyObject *s, char *name)
#endif
{
PCT_CounterObject *self = (PCT_CounterObject *)s;
#ifdef IS_PY3K
if (!PyUnicode_Check(attr))
goto generic;
if (PyUnicode_CompareWithASCIIString(attr, "carry") == 0) {
#else
if (strcmp(name, "carry") == 0) {
#endif
return PyLong_FromLong((long)self->carry);
#ifdef IS_PY3K
} else if (!self->shortcut_disabled && PyUnicode_CompareWithASCIIString(attr, "__PCT_CTR_SHORTCUT__") == 0) {
#else
} else if (!self->shortcut_disabled && strcmp(name, "__PCT_CTR_SHORTCUT__") == 0) {
#endif
/* Shortcut hack - See block_template.c */
Py_INCREF(Py_True);
return Py_True;
}
#ifdef IS_PY3K
generic:
return PyObject_GenericGetAttr(s, attr);
#else
return Py_FindMethod(CounterLEObject_methods, (PyObject *)self, name);
#endif
}
static PyObject *
#ifdef IS_PY3K
CounterBEObject_getattro(PyObject *s, PyObject *attr)
#else
CounterBEObject_getattr(PyObject *s, char *name)
#endif
{
PCT_CounterObject *self = (PCT_CounterObject *)s;
#ifdef IS_PY3K
if (!PyUnicode_Check(attr))
goto generic;
if (PyUnicode_CompareWithASCIIString(attr, "carry") == 0) {
#else
if (strcmp(name, "carry") == 0) {
#endif
return PyLong_FromLong((long)self->carry);
#ifdef IS_PY3K
} else if (!self->shortcut_disabled && PyUnicode_CompareWithASCIIString(attr, "__PCT_CTR_SHORTCUT__") == 0) {
#else
} else if (!self->shortcut_disabled && strcmp(name, "__PCT_CTR_SHORTCUT__") == 0) {
#endif
/* Shortcut hack - See block_template.c */
Py_INCREF(Py_True);
return Py_True;
}
#ifdef IS_PY3K
generic:
return PyObject_GenericGetAttr(s, attr);
#else
return Py_FindMethod(CounterBEObject_methods, (PyObject *)self, name);
#endif
}
static PyTypeObject
my_CounterLEType = {
#ifdef IS_PY3K
PyVarObject_HEAD_INIT(NULL, 0) /* deferred type init for compilation on Windows, type will be filled in at runtime */
#else
PyObject_HEAD_INIT(NULL)
0, /* ob_size */
#endif
"_counter.CounterLE", /* tp_name */
sizeof(PCT_CounterObject), /* tp_basicsize */
0, /* tp_itemsize */
/* methods */
(destructor)CounterObject_dealloc, /* tp_dealloc */
0, /* tp_print */
#ifdef IS_PY3K
0, /* tp_getattr */
#else
CounterLEObject_getattr, /* tp_getattr */
#endif
0, /* tp_setattr */
0, /* tp_compare */
0, /* tp_repr */
0, /* tp_as_number */
0, /* tp_as_sequence */
0, /* tp_as_mapping */
0, /* tp_hash */
(ternaryfunc)CounterObject_call, /* tp_call */
0, /* tp_str */
#ifdef IS_PY3K
CounterLEObject_getattro, /* tp_getattro */
#else
0, /* tp_getattro */
#endif
0, /* tp_setattro */
0, /* tp_as_buffer */
Py_TPFLAGS_DEFAULT, /* tp_flags */
"Counter (little endian)", /* tp_doc */
#ifdef IS_PY3K
0, /*tp_traverse*/
0, /*tp_clear*/
0, /*tp_richcompare*/
0, /*tp_weaklistoffset*/
0, /*tp_iter*/
0, /*tp_iternext*/
CounterLEObject_methods, /*tp_methods*/
#endif
};
static PyTypeObject
my_CounterBEType = {
#ifdef IS_PY3K
PyVarObject_HEAD_INIT(NULL, 0) /* deferred type init for compilation on Windows, type will be filled in at runtime */
#else
PyObject_HEAD_INIT(NULL)
0, /* ob_size */
#endif
"_counter.CounterBE", /* tp_name */
sizeof(PCT_CounterObject), /* tp_basicsize */
0, /* tp_itemsize */
(destructor)CounterObject_dealloc, /* tp_dealloc */
0, /* tp_print */
#ifdef IS_PY3K
0, /* tp_getattr */
#else
CounterBEObject_getattr, /* tp_getattr */
#endif
0, /* tp_setattr */
0, /* tp_compare */
0, /* tp_repr */
0, /* tp_as_number */
0, /* tp_as_sequence */
0, /* tp_as_mapping */
0, /* tp_hash */
(ternaryfunc)CounterObject_call, /* tp_call */
0, /* tp_str */
#ifdef IS_PY3K
CounterBEObject_getattro, /* tp_getattro */
#else
0, /* tp_getattro */
#endif
0, /* tp_setattro */
0, /* tp_as_buffer */
Py_TPFLAGS_DEFAULT, /* tp_flags */
"Counter (big endian)", /* tp_doc */
#ifdef IS_PY3K
0, /*tp_traverse*/
0, /*tp_clear*/
0, /*tp_richcompare*/
0, /*tp_weaklistoffset*/
0, /*tp_iter*/
0, /*tp_iternext*/
CounterBEObject_methods, /*tp_methods*/
#endif
};
/*
* Python 2.1 doesn't seem to allow a C equivalent of the __init__ method, so
* we use the module-level functions newLE and newBE here.
*/
static PyObject *
CounterLE_new(PyObject *self, PyObject *args, PyObject *kwargs)
{
PCT_CounterObject *obj = NULL;
/* Create the new object */
obj = PyObject_New(PCT_CounterObject, &my_CounterLEType);
if (obj == NULL) {
return NULL;
}
/* Zero the custom portion of the structure */
memset(&obj->prefix, 0, sizeof(PCT_CounterObject) - offsetof(PCT_CounterObject, prefix));
/* Call the object's initializer. Delete the object if this fails. */
if (CounterObject_init(obj, args, kwargs) != 0) {
return NULL;
}
/* Set the inc_func pointer */
obj->inc_func = (void (*)(void *))CounterLEObject_increment;
/* Return the object */
return (PyObject *)obj;
}
// The type init slot.
static int pyqtSignal_init(PyObject *self, PyObject *args, PyObject *kwd_args)
{
qpycore_pyqtSignal *ps = (qpycore_pyqtSignal *)self;
// Get the keyword arguments.
PyObject *name_obj = 0;
const char *name = 0;
int revision = 0;
QList<QByteArray> *parameter_names = 0;
if (kwd_args)
{
Py_ssize_t pos = 0;
PyObject *key, *value;
while (PyDict_Next(kwd_args, &pos, &key, &value))
{
#if PY_MAJOR_VERSION >= 3
if (PyUnicode_CompareWithASCIIString(key, "name") == 0)
#else
Q_ASSERT(PyString_Check(key));
if (qstrcmp(PyString_AsString(key), "name") == 0)
#endif
{
name_obj = value;
name = sipString_AsASCIIString(&name_obj);
if (!name)
{
PyErr_Format(PyExc_TypeError,
"signal 'name' must be a str, not %s",
sipPyTypeName(Py_TYPE(value)));
return -1;
}
}
#if PY_MAJOR_VERSION >= 3
else if (PyUnicode_CompareWithASCIIString(key, "revision") == 0)
#else
else if (qstrcmp(PyString_AsString(key), "revision") == 0)
#endif
{
revision = sipLong_AsInt(value);
if (PyErr_Occurred())
{
if (PyErr_ExceptionMatches(PyExc_TypeError))
PyErr_Format(PyExc_TypeError,
"signal 'revision' must be an int, not %s",
sipPyTypeName(Py_TYPE(value)));
Py_XDECREF(name_obj);
return -1;
}
}
#if PY_MAJOR_VERSION >= 3
else if (PyUnicode_CompareWithASCIIString(key, "arguments") == 0)
#else
else if (qstrcmp(PyString_AsString(key), "arguments") == 0)
#endif
{
bool ok = true;
if (PySequence_Check(value))
{
Py_ssize_t len = PySequence_Size(value);
parameter_names = new QList<QByteArray>;
for (Py_ssize_t i = 0; i < len; ++i)
{
PyObject *py_attr = PySequence_GetItem(value, i);
if (!py_attr)
{
ok = false;
break;
}
PyObject *py_ascii_attr = py_attr;
const char *attr = sipString_AsASCIIString(
&py_ascii_attr);
Py_DECREF(py_attr);
if (!attr)
{
ok = false;
break;
}
parameter_names->append(QByteArray(attr));
Py_DECREF(py_ascii_attr);
}
}
else
{
ok = false;
}
if (!ok)
{
PyErr_Format(PyExc_TypeError,
"signal 'attribute_names' must be a sequence of str, not %s",
sipPyTypeName(Py_TYPE(value)));
if (parameter_names)
delete parameter_names;
Py_XDECREF(name_obj);
return -1;
}
}
else
{
#if PY_MAJOR_VERSION >= 3
PyErr_Format(PyExc_TypeError,
"pyqtSignal() got an unexpected keyword argument '%U'",
key);
#else
PyErr_Format(PyExc_TypeError,
"pyqtSignal() got an unexpected keyword argument '%s'",
PyString_AsString(key));
#endif
Py_XDECREF(name_obj);
return -1;
}
}
}
// If there is at least one argument and it is a sequence then assume all
// arguments are sequences. Unfortunately a string is also a sequence so
// check for tuples and lists explicitly.
if (PyTuple_Size(args) > 0 && (PyTuple_Check(PyTuple_GetItem(args, 0)) || PyList_Check(PyTuple_GetItem(args, 0))))
{
for (Py_ssize_t i = 0; i < PyTuple_Size(args); ++i)
{
PyObject *types = PySequence_Tuple(PyTuple_GetItem(args, i));
if (!types)
{
PyErr_SetString(PyExc_TypeError,
"pyqtSignal() argument expected to be sequence of types");
if (name)
{
Py_DECREF(name_obj);
}
return -1;
}
int rc;
if (i == 0)
{
// The first is the default.
rc = init_signal_from_types(ps, name, parameter_names,
revision, types);
}
else
{
qpycore_pyqtSignal *overload = (qpycore_pyqtSignal *)PyType_GenericNew(qpycore_pyqtSignal_TypeObject, 0, 0);
if (!overload)
{
rc = -1;
}
else if ((rc = init_signal_from_types(overload, name, 0, revision, types)) < 0)
{
Py_DECREF((PyObject *)overload);
}
else
{
overload->default_signal = ps;
append_overload(overload);
}
}
Py_DECREF(types);
if (rc < 0)
{
if (name)
{
Py_DECREF(name_obj);
}
return -1;
}
}
}
else if (init_signal_from_types(ps, name, parameter_names, revision, args) < 0)
{
if (name)
{
Py_DECREF(name_obj);
}
return -1;
}
if (name)
{
Py_DECREF(name_obj);
}
return 0;
}
static int
future_parse(PyFutureFeatures *ff, mod_ty mod, PyObject *filename)
{
int i, done = 0, prev_line = 0;
stmt_ty first;
if (!(mod->kind == Module_kind || mod->kind == Interactive_kind))
return 1;
if (asdl_seq_LEN(mod->v.Module.body) == 0)
return 1;
/* A subsequent pass will detect future imports that don't
appear at the beginning of the file. There's one case,
however, that is easier to handle here: A series of imports
joined by semi-colons, where the first import is a future
statement but some subsequent import has the future form
but is preceded by a regular import.
*/
i = 0;
first = (stmt_ty)asdl_seq_GET(mod->v.Module.body, i);
if (first->kind == Expr_kind && first->v.Expr.value->kind == Str_kind)
i++;
for (; i < asdl_seq_LEN(mod->v.Module.body); i++) {
stmt_ty s = (stmt_ty)asdl_seq_GET(mod->v.Module.body, i);
if (done && s->lineno > prev_line)
return 1;
prev_line = s->lineno;
/* The tests below will return from this function unless it is
still possible to find a future statement. The only things
that can precede a future statement are another future
statement and a doc string.
*/
if (s->kind == ImportFrom_kind) {
identifier modname = s->v.ImportFrom.module;
if (modname &&
!PyUnicode_CompareWithASCIIString(modname, "__future__")) {
if (done) {
PyErr_SetString(PyExc_SyntaxError,
ERR_LATE_FUTURE);
PyErr_SyntaxLocationObject(filename, s->lineno, s->col_offset);
return 0;
}
if (!future_check_features(ff, s, filename))
return 0;
ff->ff_lineno = s->lineno;
}
else {
done = 1;
}
}
else {
done = 1;
}
}
return 1;
}
