static void emit_all_code_objects(void) { PyObject *gc_module = NULL, *lst = NULL, *all_codes = NULL; Py_ssize_t i, size; gc_module = PyImport_ImportModuleNoBlock("gc"); if (gc_module == NULL) goto error; lst = PyObject_CallMethod(gc_module, "get_objects", ""); if (lst == NULL || !PyList_Check(lst)) goto error; all_codes = PySet_New(NULL); if (all_codes == NULL) goto error; size = PyList_GET_SIZE(lst); for (i = 0; i < size; i++) { PyObject *o = PyList_GET_ITEM(lst, i); if (o->ob_type->tp_traverse && o->ob_type->tp_traverse(o, _look_for_code_object, (void *)all_codes) < 0) goto error; } error: Py_XDECREF(all_codes); Py_XDECREF(lst); Py_XDECREF(gc_module); }
void PyErr_Display(PyObject *exception, PyObject *value, PyObject *tb) { PyObject *seen; PyObject *f = _PySys_GetObjectId(&PyId_stderr); if (PyExceptionInstance_Check(value) && tb != NULL && PyTraceBack_Check(tb)) { /* Put the traceback on the exception, otherwise it won't get displayed. See issue #18776. */ PyObject *cur_tb = PyException_GetTraceback(value); if (cur_tb == NULL) PyException_SetTraceback(value, tb); else Py_DECREF(cur_tb); } if (f == Py_None) { /* pass */ } else if (f == NULL) { _PyObject_Dump(value); fprintf(stderr, "lost sys.stderr\n"); } else { /* We choose to ignore seen being possibly NULL, and report at least the main exception (it could be a MemoryError). */ seen = PySet_New(NULL); if (seen == NULL) PyErr_Clear(); print_exception_recursive(f, value, seen); Py_XDECREF(seen); } }
/** ctor. */ set(std::initializer_list<obj> l) { _p = PySet_New(NULL); for(auto &x: l){ add(x); } }
static PyObject *pair_set_position(PyObject *self, PyObject *args, PyObject *kwds) { // checked static char *keywords[] = { "postition", "follow", NULL }; PyObject *position = NULL; int follow = 0; if (SibNil_Check(self)) Py_RETURN_NONE; if (! PyArg_ParseTupleAndKeywords(args, kwds, "O|p", keywords, &position, &follow)) return NULL; if (follow) { PyObject *seen = PySet_New(NULL); pwalk_setpos(self, seen, position); Py_DECREF(seen); } else { Py_ASSIGN(((SibPair *) self)->position, position); } Py_RETURN_NONE; }
static PyObject *pair_fill_position(PyObject *self, PyObject *args, PyObject *kwds) { // checked static char *keywords[] = { "position", "follow", NULL }; PyObject *position = NULL; int follow = 0; if (! PyArg_ParseTupleAndKeywords(args, kwds, "O|p", keywords, &position, &follow)) return NULL; if (follow) { PyObject *seen = PySet_New(NULL); pwalk_fillpos(self, seen, position); Py_DECREF(seen); } else { if (! ((SibPair *) self)->position) { Py_INCREF(position); ((SibPair *) self)->position = position; } } Py_RETURN_NONE; }
PyObject *to_python<types::set<T>>::convert(types::set<T> const &v) { PyObject *obj = PySet_New(nullptr); for (auto const &e : v) PySet_Add(obj, ::to_python(e)); return obj; }
long SibPair_IsRecursive(PyObject *self) { // checked if (SibNil_Check(self)) return 0; PyObject *seen = PySet_New(NULL); PyObject *pair_id; long result = 0; for ( ; SibPair_CheckExact(self); self = SibPair_CDR(self)) { pair_id = PyLong_FromVoidPtr(self); if (PySet_Contains(seen, pair_id)) { /* seen it, therefore recursive */ Py_DECREF(pair_id); result = 1; break; } else { PySet_Add(seen, pair_id); Py_DECREF(pair_id); } } Py_DECREF(seen); return result; }
long SibPair_IsProper(PyObject *self) { // checked if (SibNil_Check(self)) return 1; PyObject *seen = PySet_New(NULL); PyObject *pair_id; long result = 0; for ( ; SibPair_CheckExact(self); self = SibPair_CDR(self)) { pair_id = PyLong_FromVoidPtr(self); if (PySet_Contains(seen, pair_id)) { /* seen it, therefore recursive */ Py_DECREF(pair_id); result = 1; break; } else { PySet_Add(seen, pair_id); Py_DECREF(pair_id); } } /* it's either recursive and thus proper, or the last item needs to have been a nil, or it's improper */ Py_DECREF(seen); return result || SibNil_Check(self); }
static PyObject *convertFrom_QSet_0101QAbstractState(void *sipCppV, PyObject *sipTransferObj) { QSet<QAbstractState*> *sipCpp = reinterpret_cast<QSet<QAbstractState*> *>(sipCppV); #line 319 "/home/vikky/Desktop/DVCS/stuff/scrapy/soft/PyQt-x11-gpl-4.11.4/sip/QtCore/qset.sip" // Create the set. PyObject *s; if ((s = PySet_New(NULL)) == NULL) return NULL; // Set the set elements. QSet<QAbstractState *>::const_iterator it = sipCpp->constBegin(); QSet<QAbstractState *>::const_iterator end = sipCpp->constEnd(); while (it != end) { PyObject *tobj; // The explicit (void *) cast allows QAbstractState to be const. if ((tobj = sipConvertFromType((void *)*it, sipType_QAbstractState, sipTransferObj)) == NULL) { Py_DECREF(s); return NULL; } PySet_Add(s, tobj); ++it; } return s; #line 165 "/home/vikky/Desktop/DVCS/stuff/scrapy/soft/PyQt-x11-gpl-4.11.4/QtCore/sipQtCoreQSet0101QAbstractState.cpp" }
static PyObject *pair_length(PyObject *self, PyObject *_noargs) { PyObject *seen; PyObject *tmp; long length = 0; if (SibNil_Check(self)) { return PyLong_FromLong(length); } seen = PySet_New(NULL); for(; SibPair_CheckExact(self); self = SibPair_CDR(self)) { tmp = PyLong_FromVoidPtr(self); if (PySet_Contains(seen, tmp)) { Py_DECREF(tmp); self = NULL; break; } else { PySet_Add(seen, tmp); Py_DECREF(tmp); length++; } } if (self && ! SibNil_Check(self)) length++; Py_DECREF(seen); return PyLong_FromLong(length); }
set& operator=(std::initializer_list<obj> l) { release(); _p = PySet_New(NULL); for(auto &x: l){ add(x); } return *this; }
static int foreach_libblock_id_user_map_callback( void *user_data, ID *self_id, ID **id_p, int UNUSED(cb_flag)) { IDUserMapData *data = user_data; if (*id_p) { if (data->types_bitmap) { if (!id_check_type(*id_p, data->types_bitmap)) { return IDWALK_RET_NOP; } } if ((GS(self_id->name) == ID_OB) && (id_p == (ID **)&((Object *)self_id)->proxy_from)) { /* We skip proxy_from here, since it some internal pointer which is not irrelevant info for py/API level. */ return IDWALK_RET_NOP; } else if ((GS(self_id->name) == ID_KE) && (id_p == (ID **)&((Key *)self_id)->from)) { /* We skip from here, since it some internal pointer which is not irrelevant info for py/API level. */ return IDWALK_RET_NOP; } /* pyrna_struct_hash() uses ptr.data only, * but pyrna_struct_richcmp() uses also ptr.type, * so we need to create a valid PointerRNA here... */ PyObject *key = data->py_id_key_lookup_only; RNA_id_pointer_create(*id_p, &((BPy_StructRNA *)key)->ptr); PyObject *set; if ((set = PyDict_GetItem(data->user_map, key)) == NULL) { /* limit to key's added already */ if (data->is_subset) { return IDWALK_RET_NOP; } /* Cannot use our placeholder key here! */ key = pyrna_id_CreatePyObject(*id_p); set = PySet_New(NULL); PyDict_SetItem(data->user_map, key, set); Py_DECREF(set); Py_DECREF(key); } if (data->py_id_curr == NULL) { data->py_id_curr = pyrna_id_CreatePyObject(data->id_curr); } PySet_Add(set, data->py_id_curr); } return IDWALK_RET_NOP; }
static PyObject* Cache_cached_get(Cache* self) { PyObject* cached_set = PySet_New(NULL); for(int i=0; i<self->sets*self->ways; i++) { // For each cached cacheline expand to all cached addresses: for(int j=0; j<self->cl_size; j++) { // PySys_WriteStdout("%i %i %i %i\n", self->sets, self->ways, i, self->placement[i].cl_id); PyObject* addr = PyLong_FromUnsignedLong(self->placement[i].cl_id*self->cl_size+j); PySet_Add(cached_set, addr); Py_DECREF(addr); } } return cached_set; }
/* * Convert a list of Value nodes containing the column name as a string to a * pyset of python unicode strings. */ PyObject * valuesToPySet(List *targetlist) { PyObject *result = PySet_New(0); ListCell *lc; foreach(lc, targetlist) { Value *value = (Value *) lfirst(lc); PyObject *pyString = PyString_FromString(strVal(value)); PySet_Add(result, pyString); Py_DECREF(pyString); }
static PyObject *pair_unpack(PyObject *self, PyObject *_noargs) { // checked SibPairFollower *i = PyObject_New(SibPairFollower, &SibPairFollowerType); if(! i) return NULL; Py_INCREF(self); i->current = self; i->seen = PySet_New(NULL); i->just_items = 1; return (PyObject *) i; }
static int LockObject_init(LockObject *self, PyObject *args, PyObject *kwargs) { GDEBUG("self:%p", self); self->counter = 1; Py_CLEAR(self->waiters); self->waiters = PySet_New(NULL); if (self->waiters == NULL) { return -1; } DEBUG("self:%p counter:%d waiters:%p", self, self->counter, self->waiters); return 1; }
PyObject *WeakSet_New(void){ WeakSet *self; self = (WeakSet *)WeakSetType.tp_alloc(&WeakSetType, 0); self->set = self->selfref = NULL; self->set = PySet_New(NULL); if (!self->set) goto bail; self->selfref = PyWeakref_NewRef((PyObject *)self->set,NULL); if (!self->selfref) goto bail; return (PyObject *)self; bail: Py_XDECREF(self->set); Py_XDECREF(self->selfref); Py_DECREF(self); return NULL; }
static PyObject *Video_device_get_info(Video_device *self) { ASSERT_OPEN; struct v4l2_capability caps; if(my_ioctl(self->fd, VIDIOC_QUERYCAP, &caps)) { return NULL; } PyObject *set = PySet_New(NULL); if(!set) { return NULL; } struct capability *capability = capabilities; while((void *)capability < (void *)capabilities + sizeof(capabilities)) { if(caps.capabilities & capability->id) { PyObject *s = PyString_FromString(capability->name); if(!s) { Py_DECREF(set); return NULL; } PySet_Add(set, s); } capability++; } return Py_BuildValue("sssO", caps.driver, caps.card, caps.bus_info, set); }
static int SemaphoreObject_init(SemaphoreObject *self, PyObject *args, PyObject *kwargs) { int value = 1; GDEBUG("self:%p", self); static char *keywords[] = {"value", NULL}; if (!PyArg_ParseTupleAndKeywords(args, kwargs, "|i:__init__", keywords, &value)) { return -1; } self->counter = value; Py_CLEAR(self->waiters); self->waiters = PySet_New(NULL); if (self->waiters == NULL) { return -1; } DEBUG("self:%p counter:%d waiters:%p", self, self->counter, self->waiters); return 1; }
static PyObject *pair_clear_position(PyObject *self, PyObject *args, PyObject *kwds) { static char *keywords[] = { "follow", NULL }; int follow = 0; if (SibNil_Check(self)) Py_RETURN_NONE; if (! PyArg_ParseTupleAndKeywords(args, kwds, "|p", keywords, &follow)) return NULL; if (follow) { PyObject *seen = PySet_New(NULL); pwalk_setpos(self, seen, NULL); Py_DECREF(seen); } else { Py_CLEAR(((SibPair *) self)->position); } Py_RETURN_NONE; }
void TestPyOtherSide::testSetToList() { // Test if a Python set is converted to a list PyObject *set = PySet_New(NULL); QVERIFY(set != NULL); PyObject *o = NULL; o = PyLong_FromLong(123); QVERIFY(o != NULL); QVERIFY(PySet_Add(set, o) == 0); o = PyLong_FromLong(321); QVERIFY(o != NULL); QVERIFY(PySet_Add(set, o) == 0); o = PyLong_FromLong(444); QVERIFY(o != NULL); QVERIFY(PySet_Add(set, o) == 0); // This will not be added (no duplicates in a set) o = PyLong_FromLong(123); QVERIFY(o != NULL); QVERIFY(PySet_Add(set, o) == 0); // At this point, we should have 3 items (123, 321 and 444) QVERIFY(PySet_Size(set) == 3); QVariant v = convertPyObjectToQVariant(set); QVERIFY(v.canConvert(QMetaType::QVariantList)); QList<QVariant> l = v.toList(); QVERIFY(l.size() == 3); QVERIFY(l.contains(123)); QVERIFY(l.contains(321)); QVERIFY(l.contains(444)); }
static PyObject *bpy_user_map(PyObject *UNUSED(self), PyObject *args, PyObject *kwds) { #if 0 /* If someone knows how to get a proper 'self' in that case... */ BPy_StructRNA *pyrna = (BPy_StructRNA *)self; Main *bmain = pyrna->ptr.data; #else Main *bmain = G.main; /* XXX Ugly, but should work! */ #endif static const char *kwlist[] = {"subset", "key_types", "value_types", NULL}; PyObject *subset = NULL; PyObject *key_types = NULL; PyObject *val_types = NULL; BLI_bitmap *key_types_bitmap = NULL; BLI_bitmap *val_types_bitmap = NULL; PyObject *ret = NULL; if (!PyArg_ParseTupleAndKeywords( args, kwds, "|O$O!O!:user_map", (char **)kwlist, &subset, &PySet_Type, &key_types, &PySet_Type, &val_types)) { return NULL; } if (key_types) { key_types_bitmap = pyrna_set_to_enum_bitmap( rna_enum_id_type_items, key_types, sizeof(short), true, USHRT_MAX, "key types"); if (key_types_bitmap == NULL) { goto error; } } if (val_types) { val_types_bitmap = pyrna_set_to_enum_bitmap( rna_enum_id_type_items, val_types, sizeof(short), true, USHRT_MAX, "value types"); if (val_types_bitmap == NULL) { goto error; } } IDUserMapData data_cb = {NULL}; if (subset) { PyObject *subset_fast = PySequence_Fast(subset, "user_map"); if (subset_fast == NULL) { goto error; } PyObject **subset_array = PySequence_Fast_ITEMS(subset_fast); Py_ssize_t subset_len = PySequence_Fast_GET_SIZE(subset_fast); data_cb.user_map = _PyDict_NewPresized(subset_len); data_cb.is_subset = true; for (; subset_len; subset_array++, subset_len--) { PyObject *set = PySet_New(NULL); PyDict_SetItem(data_cb.user_map, *subset_array, set); Py_DECREF(set); } Py_DECREF(subset_fast); } else { data_cb.user_map = PyDict_New(); } data_cb.types_bitmap = key_types_bitmap; ListBase *lb_array[MAX_LIBARRAY]; int lb_index; lb_index = set_listbasepointers(bmain, lb_array); while (lb_index--) { if (val_types_bitmap && lb_array[lb_index]->first) { if (!id_check_type(lb_array[lb_index]->first, val_types_bitmap)) { continue; } } for (ID *id = lb_array[lb_index]->first; id; id = id->next) { /* One-time init, ID is just used as placeholder here, we abuse this in iterator callback * to avoid having to rebuild a complete bpyrna object each time for the key searching * (where only ID pointer value is used). */ if (data_cb.py_id_key_lookup_only == NULL) { data_cb.py_id_key_lookup_only = pyrna_id_CreatePyObject(id); } if (!data_cb.is_subset) { PyObject *key = data_cb.py_id_key_lookup_only; PyObject *set; RNA_id_pointer_create(id, &((BPy_StructRNA *)key)->ptr); /* We have to insert the key now, otherwise ID unused would be missing from final dict... */ if ((set = PyDict_GetItem(data_cb.user_map, key)) == NULL) { /* Cannot use our placeholder key here! */ key = pyrna_id_CreatePyObject(id); set = PySet_New(NULL); PyDict_SetItem(data_cb.user_map, key, set); Py_DECREF(set); Py_DECREF(key); } } data_cb.id_curr = id; BKE_library_foreach_ID_link(id, foreach_libblock_id_user_map_callback, &data_cb, IDWALK_NOP); if (data_cb.py_id_curr) { Py_DECREF(data_cb.py_id_curr); data_cb.py_id_curr = NULL; } } } ret = data_cb.user_map; error: Py_XDECREF(data_cb.py_id_key_lookup_only); if (key_types_bitmap) { MEM_freeN(key_types_bitmap); } if (val_types_bitmap) { MEM_freeN(val_types_bitmap); } return ret; }
// Returns a new reference. static PyObject* decode_val(DecodeBuffer* input, TType type, PyObject* typeargs) { switch (type) { case T_BOOL: { int8_t v = readByte(input); if (INT_CONV_ERROR_OCCURRED(v)) { return NULL; } switch (v) { case 0: Py_RETURN_FALSE; case 1: Py_RETURN_TRUE; // Don't laugh. This is a potentially serious issue. default: PyErr_SetString(PyExc_TypeError, "boolean out of range"); return NULL; } break; } case T_I08: { int8_t v = readByte(input); if (INT_CONV_ERROR_OCCURRED(v)) { return NULL; } return PyInt_FromLong(v); } case T_I16: { int16_t v = readI16(input); if (INT_CONV_ERROR_OCCURRED(v)) { return NULL; } return PyInt_FromLong(v); } case T_I32: { int32_t v = readI32(input); if (INT_CONV_ERROR_OCCURRED(v)) { return NULL; } return PyInt_FromLong(v); } case T_I64: { int64_t v = readI64(input); if (INT_CONV_ERROR_OCCURRED(v)) { return NULL; } // TODO(dreiss): Find out if we can take this fastpath always when // sizeof(long) == sizeof(long long). if (CHECK_RANGE(v, LONG_MIN, LONG_MAX)) { return PyInt_FromLong((long) v); } return PyLong_FromLongLong(v); } case T_DOUBLE: { double v = readDouble(input); if (v == -1.0 && PyErr_Occurred()) { return false; } return PyFloat_FromDouble(v); } case T_STRING: { Py_ssize_t len = readI32(input); char* buf; if (!readBytes(input, &buf, len)) { return NULL; } return PyString_FromStringAndSize(buf, len); } case T_LIST: case T_SET: { SetListTypeArgs parsedargs; int32_t len; PyObject* ret = NULL; int i; if (!parse_set_list_args(&parsedargs, typeargs)) { return NULL; } if (!checkTypeByte(input, parsedargs.element_type)) { return NULL; } len = readI32(input); if (!check_ssize_t_32(len)) { return NULL; } ret = PyList_New(len); if (!ret) { return NULL; } for (i = 0; i < len; i++) { PyObject* item = decode_val(input, parsedargs.element_type, parsedargs.typeargs); if (!item) { Py_DECREF(ret); return NULL; } PyList_SET_ITEM(ret, i, item); } // TODO(dreiss): Consider biting the bullet and making two separate cases // for list and set, avoiding this post facto conversion. if (type == T_SET) { PyObject* setret; #if (PY_VERSION_HEX < 0x02050000) // hack needed for older versions setret = PyObject_CallFunctionObjArgs((PyObject*)&PySet_Type, ret, NULL); #else // official version setret = PySet_New(ret); #endif Py_DECREF(ret); return setret; } return ret; } case T_MAP: { int32_t len; int i; MapTypeArgs parsedargs; PyObject* ret = NULL; if (!parse_map_args(&parsedargs, typeargs)) { return NULL; } if (!checkTypeByte(input, parsedargs.ktag)) { return NULL; } if (!checkTypeByte(input, parsedargs.vtag)) { return NULL; } len = readI32(input); if (!check_ssize_t_32(len)) { return false; } ret = PyDict_New(); if (!ret) { goto error; } for (i = 0; i < len; i++) { PyObject* k = NULL; PyObject* v = NULL; k = decode_val(input, parsedargs.ktag, parsedargs.ktypeargs); if (k == NULL) { goto loop_error; } v = decode_val(input, parsedargs.vtag, parsedargs.vtypeargs); if (v == NULL) { goto loop_error; } if (PyDict_SetItem(ret, k, v) == -1) { goto loop_error; } Py_DECREF(k); Py_DECREF(v); continue; // Yuck! Destructors, anyone? loop_error: Py_XDECREF(k); Py_XDECREF(v); goto error; } return ret; error: Py_XDECREF(ret); return NULL; } case T_STRUCT: { StructTypeArgs parsedargs; if (!parse_struct_args(&parsedargs, typeargs)) { return NULL; } PyObject* ret = PyObject_CallObject(parsedargs.klass, NULL); if (!ret) { return NULL; } if (!decode_struct(input, ret, parsedargs.spec)) { Py_DECREF(ret); return NULL; } return ret; } case T_STOP: case T_VOID: case T_UTF16: case T_UTF8: case T_U64: default: PyErr_SetString(PyExc_TypeError, "Unexpected TType"); return NULL; } }
PyObject *WeakSet_test(PyObject *ignored){ int r; WeakSet *set = NULL; PyObject *obj = NULL; PyObject *setref = NULL; PyObject *setbackup = NULL; // It'd be nice if this had line numbers. #define T(x) if (!(x)) {PyErr_SetString(PyExc_AssertionError,"FIXME"); goto bail;} obj = WeakSet_New(); if (!obj) goto bail; set = (WeakSet *)WeakSet_New(); if (!set) goto bail; setref = set->selfref; Py_INCREF(setref); T(setref->ob_refcnt == 2); T(PyObject_Length(set->set) == 0); T(WeakSet_Contains((PyObject *)set,obj) == 0); r = WeakSet_Add((PyObject *)set,obj); if (r) goto bail; T(setref->ob_refcnt == 3); T(PyObject_Length(set->set) == 1); T(WeakSet_Contains((PyObject *)set,obj) == 1); // Simple case, object is deleted while set is still alive. Py_CLEAR(obj); T(setref->ob_refcnt == 2); T(PyObject_Length(set->set) == 0); // Complex, set is deleted, while object is still alive. obj = WeakSet_New(); if (!obj) goto bail; r = WeakSet_Add((PyObject *)set,obj); if (r) goto bail; T(PyObject_Length(set->set) == 1); T(WeakSet_Contains((PyObject *)set,obj) == 1); T(setref->ob_refcnt == 3); // If we simply delete set, the reference created for obj, and hence // setref, will have nothing pointing to it and be garbage collected before // set is actually deleted. So create a backup of the set, forcing the // reference created for obj to persist. setbackup = PySet_New(set->set); if (!setbackup) goto bail; Py_CLEAR(set); // The reference for obj is still holding a reference to setref T(setref->ob_refcnt == 2); Py_CLEAR(obj); // Now only we are holding a reference to setref T(setref->ob_refcnt == 1); Py_XDECREF(set); Py_XDECREF(setbackup); Py_XDECREF(setref); Py_XDECREF(obj); Py_RETURN_TRUE; bail: Py_XDECREF(set); Py_XDECREF(setbackup); Py_XDECREF(setref); Py_XDECREF(obj); return NULL; }
PyObject *to_python<types::empty_set>::convert(types::empty_set) { return PySet_New(nullptr); }
PyObject* Context_new(PyTypeObject* type, PyObject* args, PyObject* kwargs) { Context* self = NULL; Runtime* runtime = NULL; PyObject* global = NULL; PyObject* access = NULL; PyObject* alertlist = NULL; char* keywords[] = {"runtime", "glbl", "access", "alertlist", NULL}; if(!PyArg_ParseTupleAndKeywords( args, kwargs, "O!|OOO", keywords, RuntimeType, &runtime, &global, &access, &alertlist )) goto error; if(global == Py_None) global = NULL; if(access == Py_None) access = NULL; if(alertlist == Py_None) alertlist = NULL; if(global != NULL && !PyMapping_Check(global)) { PyErr_SetString(PyExc_TypeError, "Global handler must provide item access."); goto error; } if(access != NULL && !PyCallable_Check(access)) { PyErr_SetString(PyExc_TypeError, "Access handler must be callable."); goto error; } if(alertlist != NULL && !PyList_Check(alertlist)) { PyErr_SetString(PyExc_TypeError, "Alert list must be a list object."); goto error; } self = (Context*) type->tp_alloc(type, 0); if(self == NULL) goto error; // Tracking what classes we've installed in // the context. self->classes = (PyDictObject*) PyDict_New(); if(self->classes == NULL) goto error; self->objects = (PySetObject*) PySet_New(NULL); if(self->objects == NULL) goto error; self->cx = JS_NewContext(runtime->rt, 8192); if(self->cx == NULL) { PyErr_SetString(PyExc_RuntimeError, "Failed to create JSContext."); goto error; } JS_BeginRequest(self->cx); /* * Notice that we don't add a ref to the Python context for * the copy stored on the JSContext*. I'm pretty sure this * would cause a cyclic dependancy that would prevent * garbage collection from happening on either side of the * bridge. * */ JS_SetContextPrivate(self->cx, self); // Setup the root of the property lookup doodad. self->root = JS_NewObject(self->cx, &js_global_class, NULL, NULL); if(self->root == NULL) { PyErr_SetString(PyExc_RuntimeError, "Error creating root object."); goto error; } if(!JS_InitStandardClasses(self->cx, self->root)) { PyErr_SetString(PyExc_RuntimeError, "Error initializing JS VM."); goto error; } // Don't setup the global handler until after the standard classes // have been initialized. // XXX: Does anyone know if finalize is called if new fails? if(global != NULL) Py_INCREF(global); self->global = global; if(access != NULL) Py_INCREF(access); self->access = access; if(alertlist != NULL) Py_INCREF(alertlist); self->alertlist = alertlist; // Setup counters for resource limits self->branch_count = 0; self->max_time = 0; self->start_time = 0; self->max_heap = 0; JS_SetBranchCallback(self->cx, branch_cb); JS_SetErrorReporter(self->cx, report_error_cb); Py_INCREF(runtime); self->rt = runtime; goto success; error: if(self != NULL && self->cx != NULL) JS_EndRequest(self->cx); Py_XDECREF(self); self = NULL; success: if(self != NULL && self->cx != NULL) JS_EndRequest(self->cx); return (PyObject*) self; }
// Returns a new reference. static PyObject* decode_val(DecodeBuffer* input, TType type, PyObject* typeargs, long string_limit, long container_limit) { switch (type) { case T_BOOL: { int8_t v = readByte(input); if (INT_CONV_ERROR_OCCURRED(v)) { return NULL; } switch (v) { case 0: Py_RETURN_FALSE; case 1: Py_RETURN_TRUE; // Don't laugh. This is a potentially serious issue. default: PyErr_SetString(PyExc_TypeError, "boolean out of range"); return NULL; } break; } case T_I08: { int8_t v = readByte(input); if (INT_CONV_ERROR_OCCURRED(v)) { return NULL; } return PyInt_FromLong(v); } case T_I16: { int16_t v = readI16(input); if (INT_CONV_ERROR_OCCURRED(v)) { return NULL; } return PyInt_FromLong(v); } case T_I32: { int32_t v = readI32(input); if (INT_CONV_ERROR_OCCURRED(v)) { return NULL; } return PyInt_FromLong(v); } case T_I64: { int64_t v = readI64(input); if (INT_CONV_ERROR_OCCURRED(v)) { return NULL; } // TODO(dreiss): Find out if we can take this fastpath always when // sizeof(long) == sizeof(long long). if (CHECK_RANGE(v, LONG_MIN, LONG_MAX)) { return PyInt_FromLong((long) v); } return PyLong_FromLongLong(v); } case T_DOUBLE: { double v = readDouble(input); if (v == -1.0 && PyErr_Occurred()) { return false; } return PyFloat_FromDouble(v); } case T_STRING: { Py_ssize_t len = readI32(input); char* buf; if (!readBytes(input, &buf, len)) { return NULL; } if (!check_length_limit(len, string_limit)) { return NULL; } if (is_utf8(typeargs)) return PyUnicode_DecodeUTF8(buf, len, 0); else return PyString_FromStringAndSize(buf, len); } case T_LIST: case T_SET: { SetListTypeArgs parsedargs; int32_t len; PyObject* ret = NULL; int i; bool use_tuple = false; if (!parse_set_list_args(&parsedargs, typeargs)) { return NULL; } if (!checkTypeByte(input, parsedargs.element_type)) { return NULL; } len = readI32(input); if (!check_length_limit(len, container_limit)) { return NULL; } use_tuple = type == T_LIST && parsedargs.immutable; ret = use_tuple ? PyTuple_New(len) : PyList_New(len); if (!ret) { return NULL; } for (i = 0; i < len; i++) { PyObject* item = decode_val(input, parsedargs.element_type, parsedargs.typeargs, string_limit, container_limit); if (!item) { Py_DECREF(ret); return NULL; } if (use_tuple) { PyTuple_SET_ITEM(ret, i, item); } else { PyList_SET_ITEM(ret, i, item); } } // TODO(dreiss): Consider biting the bullet and making two separate cases // for list and set, avoiding this post facto conversion. if (type == T_SET) { PyObject* setret; setret = parsedargs.immutable ? PyFrozenSet_New(ret) : PySet_New(ret); Py_DECREF(ret); return setret; } return ret; } case T_MAP: { int32_t len; int i; MapTypeArgs parsedargs; PyObject* ret = NULL; if (!parse_map_args(&parsedargs, typeargs)) { return NULL; } if (!checkTypeByte(input, parsedargs.ktag)) { return NULL; } if (!checkTypeByte(input, parsedargs.vtag)) { return NULL; } len = readI32(input); if (!check_length_limit(len, container_limit)) { return NULL; } ret = PyDict_New(); if (!ret) { goto error; } for (i = 0; i < len; i++) { PyObject* k = NULL; PyObject* v = NULL; k = decode_val(input, parsedargs.ktag, parsedargs.ktypeargs, string_limit, container_limit); if (k == NULL) { goto loop_error; } v = decode_val(input, parsedargs.vtag, parsedargs.vtypeargs, string_limit, container_limit); if (v == NULL) { goto loop_error; } if (PyDict_SetItem(ret, k, v) == -1) { goto loop_error; } Py_DECREF(k); Py_DECREF(v); continue; // Yuck! Destructors, anyone? loop_error: Py_XDECREF(k); Py_XDECREF(v); goto error; } if (parsedargs.immutable) { PyObject* thrift = PyImport_ImportModule("thrift.Thrift"); PyObject* cls = NULL; PyObject* arg = NULL; if (!thrift) { goto error; } cls = PyObject_GetAttrString(thrift, "TFrozenDict"); if (!cls) { goto error; } arg = PyTuple_New(1); PyTuple_SET_ITEM(arg, 0, ret); return PyObject_CallObject(cls, arg); } return ret; error: Py_XDECREF(ret); return NULL; } case T_STRUCT: { StructTypeArgs parsedargs; if (!parse_struct_args(&parsedargs, typeargs)) { return NULL; } return decode_struct(input, Py_None, parsedargs.klass, parsedargs.spec, string_limit, container_limit); } case T_STOP: case T_VOID: case T_UTF16: case T_UTF8: case T_U64: default: PyErr_SetString(PyExc_TypeError, "Unexpected TType"); return NULL; } }
static PyObject * plist_fullset (PyObject *self) { return PySet_New(plist_fulllist(self)); }
//============================================================================= // STATIC : SPELLwsWarmStartImpl::setGlobalsFilter() //============================================================================= void SPELLwsWarmStartImpl::setGlobalsFilter( PyObject* filterKeys ) { s_filterKeys = PySet_New( filterKeys ); }