static PyObject * Util_func_cpu_info(PyObject *obj) { int i, count; uv_cpu_info_t* cpus; int err; PyObject *result, *item, *times, *exc_data; UNUSED_ARG(obj); err = uv_cpu_info(&cpus, &count); if (err == 0) { result = PyList_New(count); if (!result) { uv_free_cpu_info(cpus, count); return NULL; } for (i = 0; i < count; i++) { item = PyStructSequence_New(&CPUInfoResultType); times = PyStructSequence_New(&CPUInfoTimesResultType); if (!item || !times) { Py_XDECREF(item); Py_XDECREF(times); Py_DECREF(result); uv_free_cpu_info(cpus, count); return NULL; } PyStructSequence_SET_ITEM(item, 0, Py_BuildValue("s", cpus[i].model)); PyStructSequence_SET_ITEM(item, 1, PyInt_FromLong((long)cpus[i].speed)); PyStructSequence_SET_ITEM(item, 2, times); PyList_SET_ITEM(result, i, item); PyStructSequence_SET_ITEM(times, 0, PyLong_FromUnsignedLongLong((unsigned PY_LONG_LONG)cpus[i].cpu_times.sys)); PyStructSequence_SET_ITEM(times, 1, PyLong_FromUnsignedLongLong((unsigned PY_LONG_LONG)cpus[i].cpu_times.user)); PyStructSequence_SET_ITEM(times, 2, PyLong_FromUnsignedLongLong((unsigned PY_LONG_LONG)cpus[i].cpu_times.idle)); PyStructSequence_SET_ITEM(times, 3, PyLong_FromUnsignedLongLong((unsigned PY_LONG_LONG)cpus[i].cpu_times.irq)); PyStructSequence_SET_ITEM(times, 4, PyLong_FromUnsignedLongLong((unsigned PY_LONG_LONG)cpus[i].cpu_times.nice)); } uv_free_cpu_info(cpus, count); return result; } else { exc_data = Py_BuildValue("(is)", err, uv_strerror(err)); if (exc_data != NULL) { PyErr_SetObject(PyExc_UVError, exc_data); Py_DECREF(exc_data); } return NULL; } }
static PyObject *app_translations_contexts_make(void) { PyObject *translations_contexts; BLT_i18n_contexts_descriptor *ctxt; int pos = 0; translations_contexts = PyStructSequence_New(&BlenderAppTranslationsContextsType); if (translations_contexts == NULL) { return NULL; } #define SetObjString(item) PyStructSequence_SET_ITEM(translations_contexts, pos++, PyUnicode_FromString((item))) #define SetObjNone() PyStructSequence_SET_ITEM(translations_contexts, pos++, Py_INCREF_RET(Py_None)) for (ctxt = _contexts; ctxt->c_id; ctxt++) { if (ctxt->value) { SetObjString(ctxt->value); } else { SetObjNone(); } } #undef SetObjString #undef SetObjNone return translations_contexts; }
static PyObject * tmtotuple(struct tm *p) { PyObject *v = PyStructSequence_New(&StructTimeType); if (v == NULL) return NULL; #define SET(i,val) PyStructSequence_SET_ITEM(v, i, PyLong_FromLong((long) val)) SET(0, p->tm_year + 1900); SET(1, p->tm_mon + 1); /* Want January == 1 */ SET(2, p->tm_mday); SET(3, p->tm_hour); SET(4, p->tm_min); SET(5, p->tm_sec); SET(6, (p->tm_wday + 6) % 7); /* Want Monday == 0 */ SET(7, p->tm_yday + 1); /* Want January, 1 == 1 */ SET(8, p->tm_isdst); #ifdef HAVE_STRUCT_TM_TM_ZONE PyStructSequence_SET_ITEM(v, 9, PyUnicode_DecodeLocale(p->tm_zone, "surrogateescape")); SET(10, p->tm_gmtoff); #endif /* HAVE_STRUCT_TM_TM_ZONE */ #undef SET if (PyErr_Occurred()) { Py_XDECREF(v); return NULL; } return v; }
static PyObject* Locale_localeconv(Locale* self) { struct lconv* lc = localeconv_l(self->locale); int i = 0; PyObject* result = PyStructSequence_New(&LconvType); _seq_set_string(result, self->locale, i++, lc->decimal_point); _seq_set_string(result, self->locale, i++, lc->thousands_sep); _seq_set_grouping(result, self->locale, i++, lc->grouping); _seq_set_string(result, self->locale, i++, lc->int_curr_symbol); _seq_set_string(result, self->locale, i++, lc->currency_symbol); _seq_set_string(result, self->locale, i++, lc->mon_decimal_point); _seq_set_string(result, self->locale, i++, lc->mon_thousands_sep); _seq_set_grouping(result, self->locale, i++, lc->mon_grouping); _seq_set_string(result, self->locale, i++, lc->positive_sign); _seq_set_string(result, self->locale, i++, lc->negative_sign); _seq_set_int(result, self->locale, i++, lc->int_frac_digits); _seq_set_int(result, self->locale, i++, lc->frac_digits); _seq_set_bool(result, self->locale, i++, lc->p_cs_precedes); _seq_set_bool(result, self->locale, i++, lc->p_sep_by_space); _seq_set_int(result, self->locale, i++, lc->n_cs_precedes); _seq_set_int(result, self->locale, i++, lc->n_sep_by_space); _seq_set_int(result, self->locale, i++, lc->p_sign_posn); _seq_set_int(result, self->locale, i++, lc->n_sign_posn); _seq_set_bool(result, self->locale, i++, lc->int_p_cs_precedes); _seq_set_bool(result, self->locale, i++, lc->int_n_cs_precedes); _seq_set_bool(result, self->locale, i++, lc->int_p_sep_by_space); _seq_set_bool(result, self->locale, i++, lc->int_n_sep_by_space); _seq_set_int(result, self->locale, i++, lc->int_p_sign_posn); _seq_set_int(result, self->locale, i++, lc->int_n_sign_posn); assert(i==lconv_desc.n_in_sequence); return result; }
static PyObject * mkpwent(struct passwd *p) { int setIndex = 0; PyObject *v = PyStructSequence_New(&StructPwdType); if (v == NULL) return NULL; #define SETI(i,val) PyStructSequence_SET_ITEM(v, i, PyInt_FromLong((long) val)) #define SETS(i,val) sets(v, i, val) SETS(setIndex++, p->pw_name); #ifdef __VMS SETS(setIndex++, ""); #else SETS(setIndex++, p->pw_passwd); #endif SETI(setIndex++, p->pw_uid); SETI(setIndex++, p->pw_gid); SETS(setIndex++, p->pw_dir); SETS(setIndex++, p->pw_shell); #undef SETS #undef SETI if (PyErr_Occurred()) { Py_XDECREF(v); return NULL; } return v; }
/** * Simple utility function to initialize #PyStructSequence_Desc */ static PyObject *py_structseq_from_strings( PyTypeObject *py_type, PyStructSequence_Desc *py_sseq_desc, const char **str_items) { PyObject *py_struct_seq; int pos = 0; const char **str_iter; PyStructSequence_Field *desc; /* initialize array */ /* We really populate the contexts' fields here! */ for (str_iter = str_items, desc = py_sseq_desc->fields; *str_iter; str_iter++, desc++) { desc->name = (char *)*str_iter; desc->doc = NULL; } /* end sentinel */ desc->name = desc->doc = NULL; PyStructSequence_InitType(py_type, py_sseq_desc); /* initialize pytype */ py_struct_seq = PyStructSequence_New(py_type); BLI_assert(py_struct_seq != NULL); for (str_iter = str_items; *str_iter; str_iter++) { PyStructSequence_SET_ITEM(py_struct_seq, pos++, PyUnicode_FromString((*str_iter))); } return py_struct_seq; }
static PyObject *make_app_cb_info(void) { PyObject *app_cb_info; int pos; app_cb_info = PyStructSequence_New(&BlenderAppCbType); if (app_cb_info == NULL) { return NULL; } for (pos = 0; pos < BLI_CB_EVT_TOT; pos++) { if (app_cb_info_fields[pos].name == NULL) { Py_FatalError("invalid callback slots 1"); } PyStructSequence_SET_ITEM(app_cb_info, pos, (py_cb_array[pos] = PyList_New(0))); } if (app_cb_info_fields[pos + APP_CB_OTHER_FIELDS].name != NULL) { Py_FatalError("invalid callback slots 2"); } /* custom function */ PyStructSequence_SET_ITEM(app_cb_info, pos++, (PyObject *)&BPyPersistent_Type); return app_cb_info; }
static PyObject *mkspent(struct spwd *p) { int setIndex = 0; PyObject *v = PyStructSequence_New(&StructSpwdType); if (v == NULL) return NULL; #define SETI(i,val) PyStructSequence_SET_ITEM(v, i, PyInt_FromLong((long) val)) #define SETS(i,val) sets(v, i, val) SETS(setIndex++, p->sp_namp); SETS(setIndex++, p->sp_pwdp); #ifndef __HAIKU__ SETI(setIndex++, p->sp_lstchg); #endif SETI(setIndex++, p->sp_min); SETI(setIndex++, p->sp_max); SETI(setIndex++, p->sp_warn); SETI(setIndex++, p->sp_inact); SETI(setIndex++, p->sp_expire); SETI(setIndex++, p->sp_flag); #undef SETS #undef SETI if (PyErr_Occurred()) { Py_DECREF(v); return NULL; } return v; }
PyObject* PyFloat_GetInfo(void) { PyObject* floatinfo; int pos = 0; floatinfo = PyStructSequence_New(&FloatInfoType); if (floatinfo == NULL) { return NULL; } #define SetIntFlag(flag) PyStructSequence_SET_ITEM(floatinfo, pos++, PyInt_FromLong(flag)) #define SetDblFlag(flag) PyStructSequence_SET_ITEM(floatinfo, pos++, PyFloat_FromDouble(flag)) SetDblFlag(DBL_MAX); SetIntFlag(DBL_MAX_EXP); SetIntFlag(DBL_MAX_10_EXP); SetDblFlag(DBL_MIN); SetIntFlag(DBL_MIN_EXP); SetIntFlag(DBL_MIN_10_EXP); SetIntFlag(DBL_DIG); SetIntFlag(DBL_MANT_DIG); SetDblFlag(DBL_EPSILON); SetIntFlag(FLT_RADIX); SetIntFlag(FLT_ROUNDS); #undef SetIntFlag #undef SetDblFlag if (PyErr_Occurred()) { Py_CLEAR(floatinfo); return NULL; } return floatinfo; }
static PyObject * tmtotuple(struct tm *p) { PyObject *v = PyStructSequence_New(&StructTimeType); if (v == NULL) return NULL; #define SET(i,val) PyStructSequence_SET_ITEM(v, i, PyInt_FromLong((long) val)) SET(0, p->tm_year + 1900); SET(1, p->tm_mon + 1); /* Want January == 1 */ SET(2, p->tm_mday); SET(3, p->tm_hour); SET(4, p->tm_min); SET(5, p->tm_sec); SET(6, (p->tm_wday + 6) % 7); /* Want Monday == 0 */ SET(7, p->tm_yday + 1); /* Want January, 1 == 1 */ SET(8, p->tm_isdst); #undef SET if (PyErr_Occurred()) { Py_XDECREF(v); return NULL; } return v; }
static void nameinfo_cb(void *arg, int status, int timeouts, char *node, char *service) { PyGILState_STATE gstate = PyGILState_Ensure(); PyObject *callback, *errorno, *dns_node, *dns_service, *dns_result, *result; callback = (PyObject *)arg; ASSERT(callback); if (status != ARES_SUCCESS) { errorno = PyInt_FromLong((long)status); dns_result = Py_None; Py_INCREF(Py_None); goto callback; } dns_result = PyStructSequence_New(&AresNameinfoResultType); if (!dns_result) { PyErr_NoMemory(); PyErr_WriteUnraisable(Py_None); errorno = PyInt_FromLong((long)ARES_ENOMEM); dns_result = Py_None; Py_INCREF(Py_None); goto callback; } dns_node = Py_BuildValue("s", node); if (service) { dns_service = Py_BuildValue("s", service); } else { dns_service = Py_None; Py_INCREF(Py_None); } PyStructSequence_SET_ITEM(dns_result, 0, dns_node); PyStructSequence_SET_ITEM(dns_result, 1, dns_service); errorno = Py_None; Py_INCREF(Py_None); callback: result = PyObject_CallFunctionObjArgs(callback, dns_result, errorno, NULL); if (result == NULL) { PyErr_WriteUnraisable(callback); } Py_XDECREF(result); Py_DECREF(dns_result); Py_DECREF(errorno); Py_DECREF(callback); PyGILState_Release(gstate); }
static PyObject * resource_getrusage(PyObject *self, PyObject *args) { int who; struct rusage ru; PyObject *result; if (!PyArg_ParseTuple(args, "i:getrusage", &who)) return NULL; if (getrusage(who, &ru) == -1) { if (errno == EINVAL) { PyErr_SetString(PyExc_ValueError, "invalid who parameter"); return NULL; } PyErr_SetFromErrno(ResourceError); return NULL; } result = PyStructSequence_New(&StructRUsageType); if (!result) return NULL; PyStructSequence_SET_ITEM(result, 0, PyFloat_FromDouble(doubletime(ru.ru_utime))); PyStructSequence_SET_ITEM(result, 1, PyFloat_FromDouble(doubletime(ru.ru_stime))); PyStructSequence_SET_ITEM(result, 2, PyLong_FromLong(ru.ru_maxrss)); PyStructSequence_SET_ITEM(result, 3, PyLong_FromLong(ru.ru_ixrss)); PyStructSequence_SET_ITEM(result, 4, PyLong_FromLong(ru.ru_idrss)); PyStructSequence_SET_ITEM(result, 5, PyLong_FromLong(ru.ru_isrss)); PyStructSequence_SET_ITEM(result, 6, PyLong_FromLong(ru.ru_minflt)); PyStructSequence_SET_ITEM(result, 7, PyLong_FromLong(ru.ru_majflt)); PyStructSequence_SET_ITEM(result, 8, PyLong_FromLong(ru.ru_nswap)); PyStructSequence_SET_ITEM(result, 9, PyLong_FromLong(ru.ru_inblock)); PyStructSequence_SET_ITEM(result, 10, PyLong_FromLong(ru.ru_oublock)); PyStructSequence_SET_ITEM(result, 11, PyLong_FromLong(ru.ru_msgsnd)); PyStructSequence_SET_ITEM(result, 12, PyLong_FromLong(ru.ru_msgrcv)); PyStructSequence_SET_ITEM(result, 13, PyLong_FromLong(ru.ru_nsignals)); PyStructSequence_SET_ITEM(result, 14, PyLong_FromLong(ru.ru_nvcsw)); PyStructSequence_SET_ITEM(result, 15, PyLong_FromLong(ru.ru_nivcsw)); if (PyErr_Occurred()) { Py_DECREF(result); return NULL; } return result; }
static PyObject * mkgrent(struct group *p) { int setIndex = 0; PyObject *v = PyStructSequence_New(&StructGrpType), *w; char **member; if (v == NULL) return NULL; if ((w = PyList_New(0)) == NULL) { Py_DECREF(v); return NULL; } for (member = p->gr_mem; *member != NULL; member++) { PyObject *x = PyString_FromString(*member); if (x == NULL || PyList_Append(w, x) != 0) { Py_XDECREF(x); Py_DECREF(w); Py_DECREF(v); return NULL; } Py_DECREF(x); } #define SET(i,val) PyStructSequence_SET_ITEM(v, i, val) SET(setIndex++, PyString_FromString(p->gr_name)); #if defined(__VMS) || defined(PLAN9APE) SET(setIndex++, Py_None); Py_INCREF(Py_None); #else if (p->gr_passwd) SET(setIndex++, PyString_FromString(p->gr_passwd)); else { SET(setIndex++, Py_None); Py_INCREF(Py_None); } #endif SET(setIndex++, PyInt_FromLong((long) p->gr_gid)); SET(setIndex++, w); #undef SET if (PyErr_Occurred()) { Py_DECREF(v); Py_DECREF(w); return NULL; } return v; }
static PyObject * Util_func_interface_addresses(PyObject *obj) { int i, count; char ip[INET6_ADDRSTRLEN]; uv_interface_address_t* interfaces; uv_err_t err; PyObject *result, *item, *exc_data; UNUSED_ARG(obj); err = uv_interface_addresses(&interfaces, &count); if (err.code == UV_OK) { result = PyList_New(count); if (!result) { uv_free_interface_addresses(interfaces, count); return NULL; } for (i = 0; i < count; i++) { item = PyStructSequence_New(&InterfaceAddressesResultType); if (!item) { Py_DECREF(result); uv_free_interface_addresses(interfaces, count); return NULL; } PyStructSequence_SET_ITEM(item, 0, Py_BuildValue("s", interfaces[i].name)); PyStructSequence_SET_ITEM(item, 1, PyBool_FromLong((long)interfaces[i].is_internal)); if (interfaces[i].address.address4.sin_family == AF_INET) { uv_ip4_name(&interfaces[i].address.address4, ip, INET_ADDRSTRLEN); } else if (interfaces[i].address.address4.sin_family == AF_INET6) { uv_ip6_name(&interfaces[i].address.address6, ip, INET6_ADDRSTRLEN); } PyStructSequence_SET_ITEM(item, 2, Py_BuildValue("s", ip)); PyList_SET_ITEM(result, i, item); } uv_free_interface_addresses(interfaces, count); return result; } else { exc_data = Py_BuildValue("(is)", err.code, uv_strerror(err)); if (exc_data != NULL) { PyErr_SetObject(PyExc_UVError, exc_data); Py_DECREF(exc_data); } return NULL; } }
static PyObject *make_oiio_info(void) { PyObject *oiio_info; int pos = 0; #ifdef WITH_OPENIMAGEIO int curversion; #endif oiio_info = PyStructSequence_New(&BlenderAppOIIOType); if (oiio_info == NULL) { return NULL; } #ifndef WITH_OPENIMAGEIO #define SetStrItem(str) \ PyStructSequence_SET_ITEM(oiio_info, pos++, PyUnicode_FromString(str)) #endif #define SetObjItem(obj) \ PyStructSequence_SET_ITEM(oiio_info, pos++, obj) #ifdef WITH_OPENIMAGEIO curversion = OIIO_getVersionHex(); SetObjItem(PyBool_FromLong(1)); SetObjItem(Py_BuildValue("(iii)", curversion / 10000, (curversion / 100) % 100, curversion % 100)); SetObjItem(PyUnicode_FromFormat("%2d, %2d, %2d", curversion / 10000, (curversion / 100) % 100, curversion % 100)); #else SetObjItem(PyBool_FromLong(0)); SetObjItem(Py_BuildValue("(iii)", 0, 0, 0)); SetStrItem("Unknown"); #endif if (PyErr_Occurred()) { Py_CLEAR(oiio_info); return NULL; } #undef SetStrItem #undef SetObjItem return oiio_info; }
static PyObject * Util_func_getrusage(PyObject *obj) { int err; uv_rusage_t ru; PyObject *result; UNUSED_ARG(obj); err = uv_getrusage(&ru); if (err < 0) { RAISE_UV_EXCEPTION(err, PyExc_UVError); return NULL; } result = PyStructSequence_New(&RusageResultType); if (!result) return NULL; #define pyuv__doubletime(TV) ((double)(TV).tv_sec + 1e-6*(TV).tv_usec) PyStructSequence_SET_ITEM(result, 0, PyFloat_FromDouble(pyuv__doubletime(ru.ru_utime))); PyStructSequence_SET_ITEM(result, 1, PyFloat_FromDouble(pyuv__doubletime(ru.ru_stime))); PyStructSequence_SET_ITEM(result, 2, PyLong_FromLong(ru.ru_maxrss)); PyStructSequence_SET_ITEM(result, 3, PyLong_FromLong(ru.ru_ixrss)); PyStructSequence_SET_ITEM(result, 4, PyLong_FromLong(ru.ru_idrss)); PyStructSequence_SET_ITEM(result, 5, PyLong_FromLong(ru.ru_isrss)); PyStructSequence_SET_ITEM(result, 6, PyLong_FromLong(ru.ru_minflt)); PyStructSequence_SET_ITEM(result, 7, PyLong_FromLong(ru.ru_majflt)); PyStructSequence_SET_ITEM(result, 8, PyLong_FromLong(ru.ru_nswap)); PyStructSequence_SET_ITEM(result, 9, PyLong_FromLong(ru.ru_inblock)); PyStructSequence_SET_ITEM(result, 10, PyLong_FromLong(ru.ru_oublock)); PyStructSequence_SET_ITEM(result, 11, PyLong_FromLong(ru.ru_msgsnd)); PyStructSequence_SET_ITEM(result, 12, PyLong_FromLong(ru.ru_msgrcv)); PyStructSequence_SET_ITEM(result, 13, PyLong_FromLong(ru.ru_nsignals)); PyStructSequence_SET_ITEM(result, 14, PyLong_FromLong(ru.ru_nvcsw)); PyStructSequence_SET_ITEM(result, 15, PyLong_FromLong(ru.ru_nivcsw)); #undef pyuv__doubletime if (PyErr_Occurred()) { Py_DECREF(result); return NULL; } return result; }
static PyObject * mkgrent(struct group *p) { int setIndex = 0; PyObject *v = PyStructSequence_New(&StructGrpType), *w; char **member; if (v == NULL) return NULL; if ((w = PyList_New(0)) == NULL) { Py_DECREF(v); return NULL; } for (member = p->gr_mem; *member != NULL; member++) { PyObject *x = PyUnicode_DecodeFSDefault(*member); if (x == NULL || PyList_Append(w, x) != 0) { Py_XDECREF(x); Py_DECREF(w); Py_DECREF(v); return NULL; } Py_DECREF(x); } #define SET(i,val) PyStructSequence_SET_ITEM(v, i, val) SET(setIndex++, PyUnicode_DecodeFSDefault(p->gr_name)); if (p->gr_passwd) SET(setIndex++, PyUnicode_DecodeFSDefault(p->gr_passwd)); else { SET(setIndex++, Py_None); Py_INCREF(Py_None); } SET(setIndex++, _PyLong_FromGid(p->gr_gid)); SET(setIndex++, w); #undef SET if (PyErr_Occurred()) { Py_DECREF(v); return NULL; } return v; }
PyObject * test(PyObject *self, PyObject *args) { /* FWIW, this assumes that we called: PyStructSequence_InitType(&CoordType, &coord_desc); when initializing the module: */ PyObject *obj = PyStructSequence_New(&CoordType); if (!obj) { return NULL; } /* These PyInt_ calls can't fail; the SET_ITEM macros steal the new ref they give us, so this is correct: */ PyStructSequence_SET_ITEM(obj, 0, PyInt_FromLong(0)); PyStructSequence_SET_ITEM(obj, 1, PyInt_FromLong(0)); return obj; }
static PyObject* make_version_info(void) noexcept { PyObject* version_info; const char* s; int pos = 0; version_info = PyStructSequence_New(&VersionInfoType); if (version_info == NULL) { return NULL; } /* * These release level checks are mutually exclusive and cover * the field, so don't get too fancy with the pre-processor! */ #if PY_RELEASE_LEVEL == PY_RELEASE_LEVEL_ALPHA s = "alpha"; #elif PY_RELEASE_LEVEL == PY_RELEASE_LEVEL_BETA s = "beta"; #elif PY_RELEASE_LEVEL == PY_RELEASE_LEVEL_GAMMA s = "candidate"; #elif PY_RELEASE_LEVEL == PY_RELEASE_LEVEL_FINAL s = "final"; #endif #define SetIntItem(flag) PyStructSequence_SET_ITEM(version_info, pos++, PyInt_FromLong(flag)) #define SetStrItem(flag) PyStructSequence_SET_ITEM(version_info, pos++, PyString_FromString(flag)) SetIntItem(PY_MAJOR_VERSION); SetIntItem(PY_MINOR_VERSION); SetIntItem(PY_MICRO_VERSION); SetStrItem(s); SetIntItem(PY_RELEASE_SERIAL); #undef SetIntItem #undef SetStrItem if (PyErr_Occurred()) { Py_CLEAR(version_info); return NULL; } return version_info; }
static PyObject* make_flags(void) { int pos = 0; PyObject* seq; seq = PyStructSequence_New(&FlagsType); if (seq == NULL) return NULL; #define SetFlag(flag) PyStructSequence_SET_ITEM(seq, pos++, PyInt_FromLong(flag)) SetFlag(Py_DebugFlag); SetFlag(Py_Py3kWarningFlag); SetFlag(Py_DivisionWarningFlag); SetFlag(_Py_QnewFlag); SetFlag(Py_InspectFlag); SetFlag(Py_InteractiveFlag); SetFlag(Py_OptimizeFlag); SetFlag(Py_DontWriteBytecodeFlag); SetFlag(Py_NoUserSiteDirectory); SetFlag(Py_NoSiteFlag); SetFlag(Py_IgnoreEnvironmentFlag); SetFlag(Py_TabcheckFlag); SetFlag(Py_VerboseFlag); #ifdef RISCOS SetFlag(Py_RISCOSWimpFlag); #endif /* SetFlag(saw_unbuffered_flag); */ SetFlag(Py_UnicodeFlag); /* SetFlag(skipfirstline); */ SetFlag(Py_BytesWarningFlag); SetFlag(Py_HashRandomizationFlag); #undef SetFlag if (PyErr_Occurred()) { Py_DECREF(seq); return NULL; } return seq; }
static PyObject *make_app_cb_info(void) { PyObject *app_cb_info; int pos= 0; app_cb_info= PyStructSequence_New(&BlenderAppCbType); if (app_cb_info == NULL) { return NULL; } for(pos= 0; pos < BLI_CB_EVT_TOT; pos++) { if(app_cb_info_fields[pos].name == NULL) { Py_FatalError("invalid callback slots 1"); } PyStructSequence_SET_ITEM(app_cb_info, pos, (py_cb_array[pos]= PyList_New(0))); } if(app_cb_info_fields[pos].name != NULL) { Py_FatalError("invalid callback slots 2"); } return app_cb_info; }
static PyObject * mkpwent(struct passwd *p) { int setIndex = 0; PyObject *v = PyStructSequence_New(&StructPwdType); if (v == NULL) return NULL; #define SETI(i,val) PyStructSequence_SET_ITEM(v, i, PyLong_FromLong((long) val)) #define SETS(i,val) sets(v, i, val) SETS(setIndex++, p->pw_name); #if defined(HAVE_STRUCT_PASSWD_PW_PASSWD) && !defined(__ANDROID__) SETS(setIndex++, p->pw_passwd); #else SETS(setIndex++, ""); #endif PyStructSequence_SET_ITEM(v, setIndex++, _PyLong_FromUid(p->pw_uid)); PyStructSequence_SET_ITEM(v, setIndex++, _PyLong_FromGid(p->pw_gid)); #if defined(HAVE_STRUCT_PASSWD_PW_GECOS) SETS(setIndex++, p->pw_gecos); #else SETS(setIndex++, ""); #endif SETS(setIndex++, p->pw_dir); SETS(setIndex++, p->pw_shell); #undef SETS #undef SETI if (PyErr_Occurred()) { Py_XDECREF(v); return NULL; } return v; }
static PyObject *make_ffmpeg_info(void) { PyObject *ffmpeg_info; int pos = 0; #ifdef WITH_FFMPEG int curversion; #endif ffmpeg_info = PyStructSequence_New(&BlenderAppFFmpegType); if (ffmpeg_info == NULL) { return NULL; } #if 0 // UNUSED #define SetIntItem(flag) \ PyStructSequence_SET_ITEM(ffmpeg_info, pos++, PyLong_FromLong(flag)) #endif #ifndef WITH_FFMPEG #define SetStrItem(str) \ PyStructSequence_SET_ITEM(ffmpeg_info, pos++, PyUnicode_FromString(str)) #endif #define SetObjItem(obj) \ PyStructSequence_SET_ITEM(ffmpeg_info, pos++, obj) #ifdef WITH_FFMPEG # define FFMPEG_LIB_VERSION(lib) { \ curversion = lib ## _version(); \ SetObjItem(PyC_Tuple_Pack_I32(curversion >> 16, (curversion >> 8) % 256, curversion % 256)); \ SetObjItem(PyUnicode_FromFormat("%2d, %2d, %2d", \ curversion >> 16, (curversion >> 8) % 256, curversion % 256)); \ } (void)0 #else # define FFMPEG_LIB_VERSION(lib) { \ SetStrItem("Unknown"); \ SetStrItem("Unknown"); \ } (void)0 #endif #ifdef WITH_FFMPEG SetObjItem(PyBool_FromLong(1)); #else SetObjItem(PyBool_FromLong(0)); #endif FFMPEG_LIB_VERSION(avcodec); FFMPEG_LIB_VERSION(avdevice); FFMPEG_LIB_VERSION(avformat); FFMPEG_LIB_VERSION(avutil); FFMPEG_LIB_VERSION(swscale); #undef FFMPEG_LIB_VERSION if (PyErr_Occurred()) { Py_CLEAR(ffmpeg_info); return NULL; } // #undef SetIntItem #undef SetStrItem #undef SetObjItem return ffmpeg_info; }
static PyObject * Util_func_interface_addresses(PyObject *obj) { static char buf[INET6_ADDRSTRLEN+1]; int i, count; uv_interface_address_t* interfaces; int err; PyObject *result, *item, *exc_data; UNUSED_ARG(obj); err = uv_interface_addresses(&interfaces, &count); if (err < 0) { exc_data = Py_BuildValue("(is)", err, uv_strerror(err)); if (exc_data != NULL) { PyErr_SetObject(PyExc_UVError, exc_data); Py_DECREF(exc_data); } return NULL; } result = PyList_New(count); if (!result) { uv_free_interface_addresses(interfaces, count); return NULL; } for (i = 0; i < count; i++) { item = PyStructSequence_New(&InterfaceAddressesResultType); if (!item) { Py_DECREF(result); uv_free_interface_addresses(interfaces, count); return NULL; } PyStructSequence_SET_ITEM(item, 0, Py_BuildValue("s", interfaces[i].name)); PyStructSequence_SET_ITEM(item, 1, PyBool_FromLong((long)interfaces[i].is_internal)); if (interfaces[i].address.address4.sin_family == AF_INET) { uv_ip4_name(&interfaces[i].address.address4, buf, sizeof(buf)); } else if (interfaces[i].address.address4.sin_family == AF_INET6) { uv_ip6_name(&interfaces[i].address.address6, buf, sizeof(buf)); } PyStructSequence_SET_ITEM(item, 2, Py_BuildValue("s", buf)); if (interfaces[i].netmask.netmask4.sin_family == AF_INET) { uv_ip4_name(&interfaces[i].netmask.netmask4, buf, sizeof(buf)); } else if (interfaces[i].netmask.netmask4.sin_family == AF_INET6) { uv_ip6_name(&interfaces[i].netmask.netmask6, buf, sizeof(buf)); } PyStructSequence_SET_ITEM(item, 3, Py_BuildValue("s", buf)); PyOS_snprintf(buf, sizeof(buf), "%02x:%02x:%02x:%02x:%02x:%02x", (unsigned char)interfaces[i].phys_addr[0], (unsigned char)interfaces[i].phys_addr[1], (unsigned char)interfaces[i].phys_addr[2], (unsigned char)interfaces[i].phys_addr[3], (unsigned char)interfaces[i].phys_addr[4], (unsigned char)interfaces[i].phys_addr[5]); PyStructSequence_SET_ITEM(item, 4, Py_BuildValue("s", buf)); PyList_SET_ITEM(result, i, item); } uv_free_interface_addresses(interfaces, count); return result; }
static PyObject * structseq_new(PyTypeObject *type, PyObject *args, PyObject *kwds) { PyObject *arg = NULL; PyObject *dict = NULL; PyObject *ob; PyStructSequence *res = NULL; Py_ssize_t len, min_len, max_len, i, n_unnamed_fields; static char *kwlist[] = {"sequence", "dict", 0}; if (!PyArg_ParseTupleAndKeywords(args, kwds, "O|O:structseq", kwlist, &arg, &dict)) return NULL; arg = PySequence_Fast(arg, "constructor requires a sequence"); if (!arg) { return NULL; } if (dict && !PyDict_Check(dict)) { PyErr_Format(PyExc_TypeError, "%.500s() takes a dict as second arg, if any", type->tp_name); Py_DECREF(arg); return NULL; } len = PySequence_Fast_GET_SIZE(arg); min_len = VISIBLE_SIZE_TP(type); max_len = REAL_SIZE_TP(type); n_unnamed_fields = UNNAMED_FIELDS_TP(type); if (min_len != max_len) { if (len < min_len) { PyErr_Format(PyExc_TypeError, "%.500s() takes an at least %zd-sequence (%zd-sequence given)", type->tp_name, min_len, len); Py_DECREF(arg); return NULL; } if (len > max_len) { PyErr_Format(PyExc_TypeError, "%.500s() takes an at most %zd-sequence (%zd-sequence given)", type->tp_name, max_len, len); Py_DECREF(arg); return NULL; } } else { if (len != min_len) { PyErr_Format(PyExc_TypeError, "%.500s() takes a %zd-sequence (%zd-sequence given)", type->tp_name, min_len, len); Py_DECREF(arg); return NULL; } } res = (PyStructSequence*) PyStructSequence_New(type); if (res == NULL) { return NULL; } for (i = 0; i < len; ++i) { PyObject *v = PySequence_Fast_GET_ITEM(arg, i); Py_INCREF(v); res->ob_item[i] = v; } for (; i < max_len; ++i) { if (dict && (ob = PyDict_GetItemString( dict, type->tp_members[i-n_unnamed_fields].name))) { } else { ob = Py_None; } Py_INCREF(ob); res->ob_item[i] = ob; } Py_DECREF(arg); return (PyObject*) res; }
static PyObject *make_app_info(void) { extern char bprogname[]; /* argv[0] from creator.c */ PyObject *app_info; int pos= 0; app_info= PyStructSequence_New(&BlenderAppType); if (app_info == NULL) { return NULL; } #define SetIntItem(flag) \ PyStructSequence_SET_ITEM(app_info, pos++, PyLong_FromLong(flag)) #define SetStrItem(str) \ PyStructSequence_SET_ITEM(app_info, pos++, PyUnicode_FromString(str)) #define SetObjItem(obj) \ PyStructSequence_SET_ITEM(app_info, pos++, obj) SetObjItem(Py_BuildValue("(iii)", BLENDER_VERSION/100, BLENDER_VERSION%100, BLENDER_SUBVERSION)); SetObjItem(PyUnicode_FromFormat("%d.%02d (sub %d)", BLENDER_VERSION/100, BLENDER_VERSION%100, BLENDER_SUBVERSION)); #if defined(BLENDER_VERSION_CHAR) && EXPAND(BLENDER_VERSION_CHAR) != 1 SetStrItem(STRINGIFY(BLENDER_VERSION_CHAR)); #else SetStrItem(""); #endif SetStrItem(STRINGIFY(BLENDER_VERSION_CYCLE)); SetStrItem(bprogname); SetObjItem(PyBool_FromLong(G.background)); /* build info */ #ifdef BUILD_DATE SetStrItem(build_date); SetStrItem(build_time); SetStrItem(build_rev); SetStrItem(build_platform); SetStrItem(build_type); SetStrItem(build_cflags); SetStrItem(build_cxxflags); SetStrItem(build_linkflags); SetStrItem(build_system); #else SetStrItem("Unknown"); SetStrItem("Unknown"); SetStrItem("Unknown"); SetStrItem("Unknown"); SetStrItem("Unknown"); SetStrItem("Unknown"); SetStrItem("Unknown"); SetStrItem("Unknown"); SetStrItem("Unknown"); #endif SetObjItem(BPY_app_handlers_struct()); #undef SetIntItem #undef SetStrItem #undef SetObjItem if (PyErr_Occurred()) { Py_CLEAR(app_info); return NULL; } return app_info; }
static void host_cb(void *arg, int status, int timeouts, struct hostent *hostent) { PyGILState_STATE gstate = PyGILState_Ensure(); char ip[INET6_ADDRSTRLEN]; char **ptr; PyObject *callback, *dns_name, *errorno, *dns_aliases, *dns_addrlist, *dns_result, *tmp, *result; callback = (PyObject *)arg; ASSERT(callback); if (status != ARES_SUCCESS) { errorno = PyInt_FromLong((long)status); dns_result = Py_None; Py_INCREF(Py_None); goto callback; } dns_aliases = PyList_New(0); dns_addrlist = PyList_New(0); dns_result = PyStructSequence_New(&AresHostResultType); if (!(dns_aliases && dns_addrlist && dns_result)) { PyErr_NoMemory(); PyErr_WriteUnraisable(Py_None); Py_XDECREF(dns_aliases); Py_XDECREF(dns_addrlist); Py_XDECREF(dns_result); errorno = PyInt_FromLong((long)ARES_ENOMEM); dns_result = Py_None; Py_INCREF(Py_None); goto callback; } for (ptr = hostent->h_aliases; *ptr != NULL; ptr++) { if (*ptr != hostent->h_name && strcmp(*ptr, hostent->h_name)) { tmp = Py_BuildValue("s", *ptr); if (tmp == NULL) { break; } PyList_Append(dns_aliases, tmp); Py_DECREF(tmp); } } for (ptr = hostent->h_addr_list; *ptr != NULL; ptr++) { if (hostent->h_addrtype == AF_INET) { ares_inet_ntop(AF_INET, *ptr, ip, INET_ADDRSTRLEN); tmp = Py_BuildValue("s", ip); } else if (hostent->h_addrtype == AF_INET6) { ares_inet_ntop(AF_INET6, *ptr, ip, INET6_ADDRSTRLEN); tmp = Py_BuildValue("s", ip); } else { continue; } if (tmp == NULL) { break; } PyList_Append(dns_addrlist, tmp); Py_DECREF(tmp); } dns_name = Py_BuildValue("s", hostent->h_name); PyStructSequence_SET_ITEM(dns_result, 0, dns_name); PyStructSequence_SET_ITEM(dns_result, 1, dns_aliases); PyStructSequence_SET_ITEM(dns_result, 2, dns_addrlist); errorno = Py_None; Py_INCREF(Py_None); callback: result = PyObject_CallFunctionObjArgs(callback, dns_result, errorno, NULL); if (result == NULL) { PyErr_WriteUnraisable(callback); } Py_XDECREF(result); Py_DECREF(dns_result); Py_DECREF(errorno); Py_DECREF(callback); PyGILState_Release(gstate); }
static void query_naptr_cb(void *arg, int status,int timeouts, unsigned char *answer_buf, int answer_len) { PyGILState_STATE gstate = PyGILState_Ensure(); int parse_status; struct ares_naptr_reply *naptr_reply, *naptr_ptr; PyObject *dns_result, *errorno, *tmp, *result, *callback; naptr_reply = NULL; callback = (PyObject *)arg; ASSERT(callback); if (status != ARES_SUCCESS) { errorno = PyInt_FromLong((long)status); dns_result = Py_None; Py_INCREF(Py_None); goto callback; } parse_status = ares_parse_naptr_reply(answer_buf, answer_len, &naptr_reply); if (parse_status != ARES_SUCCESS) { errorno = PyInt_FromLong((long)parse_status); dns_result = Py_None; Py_INCREF(Py_None); goto callback; } dns_result = PyList_New(0); if (!dns_result) { PyErr_NoMemory(); PyErr_WriteUnraisable(Py_None); errorno = PyInt_FromLong((long)ARES_ENOMEM); dns_result = Py_None; Py_INCREF(Py_None); goto callback; } for (naptr_ptr = naptr_reply; naptr_ptr != NULL; naptr_ptr = naptr_ptr->next) { tmp = PyStructSequence_New(&AresQueryNAPTRResultType); if (tmp == NULL) { break; } PyStructSequence_SET_ITEM(tmp, 0, PyInt_FromLong((long)naptr_ptr->order)); PyStructSequence_SET_ITEM(tmp, 1, PyInt_FromLong((long)naptr_ptr->preference)); PyStructSequence_SET_ITEM(tmp, 2, Py_BuildValue("s", (char *)naptr_ptr->flags)); PyStructSequence_SET_ITEM(tmp, 3, Py_BuildValue("s", (char *)naptr_ptr->service)); PyStructSequence_SET_ITEM(tmp, 4, Py_BuildValue("s", (char *)naptr_ptr->regexp)); PyStructSequence_SET_ITEM(tmp, 5, Py_BuildValue("s", naptr_ptr->replacement)); PyList_Append(dns_result, tmp); Py_DECREF(tmp); } errorno = Py_None; Py_INCREF(Py_None); callback: result = PyObject_CallFunctionObjArgs(callback, dns_result, errorno, NULL); if (result == NULL) { PyErr_WriteUnraisable(callback); } Py_XDECREF(result); Py_DECREF(dns_result); Py_DECREF(errorno); if (naptr_reply) { ares_free_data(naptr_reply); } Py_DECREF(callback); PyGILState_Release(gstate); }
static void query_srv_cb(void *arg, int status,int timeouts, unsigned char *answer_buf, int answer_len) { PyGILState_STATE gstate = PyGILState_Ensure(); int parse_status; struct ares_srv_reply *srv_reply, *srv_ptr; PyObject *dns_result, *errorno, *tmp, *result, *callback; srv_reply = NULL; callback = (PyObject *)arg; ASSERT(callback); if (status != ARES_SUCCESS) { errorno = PyInt_FromLong((long)status); dns_result = Py_None; Py_INCREF(Py_None); goto callback; } parse_status = ares_parse_srv_reply(answer_buf, answer_len, &srv_reply); if (parse_status != ARES_SUCCESS) { errorno = PyInt_FromLong((long)parse_status); dns_result = Py_None; Py_INCREF(Py_None); goto callback; } dns_result = PyList_New(0); if (!dns_result) { PyErr_NoMemory(); PyErr_WriteUnraisable(Py_None); errorno = PyInt_FromLong((long)ARES_ENOMEM); dns_result = Py_None; Py_INCREF(Py_None); goto callback; } for (srv_ptr = srv_reply; srv_ptr != NULL; srv_ptr = srv_ptr->next) { tmp = PyStructSequence_New(&AresQuerySRVResultType); if (tmp == NULL) { break; } PyStructSequence_SET_ITEM(tmp, 0, Py_BuildValue("s", srv_ptr->host)); PyStructSequence_SET_ITEM(tmp, 1, PyInt_FromLong((long)srv_ptr->port)); PyStructSequence_SET_ITEM(tmp, 2, PyInt_FromLong((long)srv_ptr->priority)); PyStructSequence_SET_ITEM(tmp, 3, PyInt_FromLong((long)srv_ptr->weight)); PyList_Append(dns_result, tmp); Py_DECREF(tmp); } errorno = Py_None; Py_INCREF(Py_None); callback: result = PyObject_CallFunctionObjArgs(callback, dns_result, errorno, NULL); if (result == NULL) { PyErr_WriteUnraisable(callback); } Py_XDECREF(result); Py_DECREF(dns_result); Py_DECREF(errorno); if (srv_reply) { ares_free_data(srv_reply); } Py_DECREF(callback); PyGILState_Release(gstate); }
static void query_soa_cb(void *arg, int status,int timeouts, unsigned char *answer_buf, int answer_len) { PyGILState_STATE gstate = PyGILState_Ensure(); int parse_status; struct ares_soa_reply *soa_reply = NULL; PyObject *dns_result, *errorno, *result, *callback; callback = (PyObject *)arg; ASSERT(callback); if (status != ARES_SUCCESS) { errorno = PyInt_FromLong((long)status); dns_result = Py_None; Py_INCREF(Py_None); goto callback; } parse_status = ares_parse_soa_reply(answer_buf, answer_len, &soa_reply); if (parse_status != ARES_SUCCESS) { errorno = PyInt_FromLong((long)parse_status); dns_result = Py_None; Py_INCREF(Py_None); goto callback; } dns_result = PyStructSequence_New(&AresQuerySOAResultType); if (!dns_result) { PyErr_NoMemory(); PyErr_WriteUnraisable(Py_None); errorno = PyInt_FromLong((long)ARES_ENOMEM); dns_result = Py_None; Py_INCREF(Py_None); goto callback; } PyStructSequence_SET_ITEM(dns_result, 0, Py_BuildValue("s", soa_reply->nsname)); PyStructSequence_SET_ITEM(dns_result, 1, Py_BuildValue("s", soa_reply->hostmaster)); PyStructSequence_SET_ITEM(dns_result, 2, PyInt_FromLong((long)soa_reply->serial)); PyStructSequence_SET_ITEM(dns_result, 3, PyInt_FromLong((long)soa_reply->refresh)); PyStructSequence_SET_ITEM(dns_result, 4, PyInt_FromLong((long)soa_reply->retry)); PyStructSequence_SET_ITEM(dns_result, 5, PyInt_FromLong((long)soa_reply->expire)); PyStructSequence_SET_ITEM(dns_result, 6, PyInt_FromLong((long)soa_reply->minttl)); errorno = Py_None; Py_INCREF(Py_None); callback: result = PyObject_CallFunctionObjArgs(callback, dns_result, errorno, NULL); if (result == NULL) { PyErr_WriteUnraisable(callback); } Py_XDECREF(result); Py_DECREF(dns_result); Py_DECREF(errorno); if (soa_reply) { ares_free_data(soa_reply); } Py_DECREF(callback); PyGILState_Release(gstate); }