Lines Matching refs:self
51 lock_traverse(lockobject *self, visitproc visit, void *arg)
53 Py_VISIT(Py_TYPE(self));
58 lock_dealloc(lockobject *self)
60 PyObject_GC_UnTrack(self);
61 if (self->in_weakreflist != NULL) {
62 PyObject_ClearWeakRefs((PyObject *) self);
64 if (self->lock_lock != NULL) {
66 if (self->locked)
67 PyThread_release_lock(self->lock_lock);
68 PyThread_free_lock(self->lock_lock);
70 PyTypeObject *tp = Py_TYPE(self);
71 tp->tp_free((PyObject*)self);
173 lock_PyThread_acquire_lock(lockobject *self, PyObject *args, PyObject *kwds)
179 PyLockStatus r = acquire_timed(self->lock_lock, timeout);
185 self->locked = 1;
201 lock_PyThread_release_lock(lockobject *self, PyObject *Py_UNUSED(ignored))
204 if (!self->locked) {
209 PyThread_release_lock(self->lock_lock);
210 self->locked = 0;
223 lock_locked_lock(lockobject *self, PyObject *Py_UNUSED(ignored))
225 return PyBool_FromLong((long)self->locked);
235 lock_repr(lockobject *self)
238 self->locked ? "locked" : "unlocked", Py_TYPE(self)->tp_name, self);
243 lock__at_fork_reinit(lockobject *self, PyObject *Py_UNUSED(args))
245 if (_PyThread_at_fork_reinit(&self->lock_lock) < 0) {
250 self->locked = 0;
327 rlock_traverse(rlockobject *self, visitproc visit, void *arg)
329 Py_VISIT(Py_TYPE(self));
335 rlock_dealloc(rlockobject *self)
337 PyObject_GC_UnTrack(self);
338 if (self->in_weakreflist != NULL)
339 PyObject_ClearWeakRefs((PyObject *) self);
340 /* self->rlock_lock can be NULL if PyThread_allocate_lock() failed
342 if (self->rlock_lock != NULL) {
344 if (self->rlock_count > 0)
345 PyThread_release_lock(self->rlock_lock);
347 PyThread_free_lock(self->rlock_lock);
349 PyTypeObject *tp = Py_TYPE(self);
350 tp->tp_free(self);
355 rlock_acquire(rlockobject *self, PyObject *args, PyObject *kwds)
365 if (self->rlock_count > 0 && tid == self->rlock_owner) {
366 unsigned long count = self->rlock_count + 1;
367 if (count <= self->rlock_count) {
372 self->rlock_count = count;
375 r = acquire_timed(self->rlock_lock, timeout);
377 assert(self->rlock_count == 0);
378 self->rlock_owner = tid;
379 self->rlock_count = 1;
405 rlock_release(rlockobject *self, PyObject *Py_UNUSED(ignored))
409 if (self->rlock_count == 0 || self->rlock_owner != tid) {
414 if (--self->rlock_count == 0) {
415 self->rlock_owner = 0;
416 PyThread_release_lock(self->rlock_lock);
434 rlock_acquire_restore(rlockobject *self, PyObject *args)
443 if (!PyThread_acquire_lock(self->rlock_lock, 0)) {
445 r = PyThread_acquire_lock(self->rlock_lock, 1);
452 assert(self->rlock_count == 0);
453 self->rlock_owner = owner;
454 self->rlock_count = count;
464 rlock_release_save(rlockobject *self, PyObject *Py_UNUSED(ignored))
469 if (self->rlock_count == 0) {
475 owner = self->rlock_owner;
476 count = self->rlock_count;
477 self->rlock_count = 0;
478 self->rlock_owner = 0;
479 PyThread_release_lock(self->rlock_lock);
490 rlock_is_owned(rlockobject *self, PyObject *Py_UNUSED(ignored))
494 if (self->rlock_count > 0 && self->rlock_owner == tid) {
508 rlockobject *self = (rlockobject *) type->tp_alloc(type, 0);
509 if (self == NULL) {
512 self->in_weakreflist = NULL;
513 self->rlock_owner = 0;
514 self->rlock_count = 0;
516 self->rlock_lock = PyThread_allocate_lock();
517 if (self->rlock_lock == NULL) {
518 Py_DECREF(self);
522 return (PyObject *) self;
526 rlock_repr(rlockobject *self)
529 self->rlock_count ? "locked" : "unlocked",
530 Py_TYPE(self)->tp_name, self->rlock_owner,
531 self->rlock_count, self);
537 rlock__at_fork_reinit(rlockobject *self, PyObject *Py_UNUSED(args))
539 if (_PyThread_at_fork_reinit(&self->rlock_lock) < 0) {
544 self->rlock_owner = 0;
545 self->rlock_count = 0;
605 lockobject *self = (lockobject *)type->tp_alloc(type, 0);
606 if (self == NULL) {
610 self->lock_lock = PyThread_allocate_lock();
611 self->locked = 0;
612 self->in_weakreflist = NULL;
614 if (self->lock_lock == NULL) {
615 Py_DECREF(self);
619 return self;
666 PyObject *weakreflist; /* List of weak references to self */
670 localdummy_dealloc(localdummyobject *self)
672 if (self->weakreflist != NULL)
673 PyObject_ClearWeakRefs((PyObject *) self);
674 PyTypeObject *tp = Py_TYPE(self);
675 tp->tp_free((PyObject*)self);
705 PyObject *weakreflist; /* List of weak references to self */
713 static PyObject *_ldict(localobject *self, thread_module_state *state);
719 _local_create_dummy(localobject *self, thread_module_state *state)
741 wr = PyWeakref_NewRef((PyObject *) dummy, self->wr_callback);
748 int r = PyDict_SetItem(self->dummies, wr, ldict);
753 r = PyDict_SetItem(tdict, self->key, (PyObject *) dummy);
794 localobject *self = (localobject *)type->tp_alloc(type, 0);
795 if (self == NULL) {
799 self->args = Py_XNewRef(args);
800 self->kw = Py_XNewRef(kw);
801 self->key = PyUnicode_FromFormat("thread.local.%p", self);
802 if (self->key == NULL) {
806 self->dummies = PyDict_New();
807 if (self->dummies == NULL) {
811 /* We use a weak reference to self in the callback closure
813 PyObject *wr = PyWeakref_NewRef((PyObject *) self, NULL);
817 self->wr_callback = PyCFunction_NewEx(&wr_callback_def, wr, NULL);
819 if (self->wr_callback == NULL) {
822 if (_local_create_dummy(self, state) == NULL) {
825 return (PyObject *)self;
828 Py_DECREF(self);
833 local_traverse(localobject *self, visitproc visit, void *arg)
835 Py_VISIT(Py_TYPE(self));
836 Py_VISIT(self->args);
837 Py_VISIT(self->kw);
838 Py_VISIT(self->dummies);
848 local_clear(localobject *self)
850 Py_CLEAR(self->args);
851 Py_CLEAR(self->kw);
852 Py_CLEAR(self->dummies);
853 Py_CLEAR(self->wr_callback);
855 if (self->key) {
863 PyObject *v = _PyDict_Pop(tstate->dict, self->key, Py_None);
880 local_dealloc(localobject *self)
883 from code called below, which is very dangerous since Py_REFCNT(self) == 0 */
884 if (self->weakreflist != NULL) {
885 PyObject_ClearWeakRefs((PyObject *) self);
888 PyObject_GC_UnTrack(self);
890 local_clear(self);
891 Py_XDECREF(self->key);
893 PyTypeObject *tp = Py_TYPE(self);
894 tp->tp_free((PyObject*)self);
900 _ldict(localobject *self, thread_module_state *state)
910 PyObject *dummy = PyDict_GetItemWithError(tdict, self->key);
915 ldict = _local_create_dummy(self, state);
919 if (Py_TYPE(self)->tp_init != PyBaseObject_Type.tp_init &&
920 Py_TYPE(self)->tp_init((PyObject*)self,
921 self->args, self->kw) < 0) {
925 PyDict_DelItem(tdict, self->key);
938 local_setattro(localobject *self, PyObject *name, PyObject *v)
940 PyObject *module = PyType_GetModuleByDef(Py_TYPE(self), &thread_module);
943 PyObject *ldict = _ldict(self, state);
955 Py_TYPE(self)->tp_name, name);
959 return _PyObject_GenericSetAttrWithDict((PyObject *)self, name, v, ldict);
990 local_getattro(localobject *self, PyObject *name)
992 PyObject *module = PyType_GetModuleByDef(Py_TYPE(self), &thread_module);
995 PyObject *ldict = _ldict(self, state);
1007 if (!Py_IS_TYPE(self, state->local_type)) {
1009 return _PyObject_GenericGetAttrWithDict((PyObject *)self, name,
1024 (PyObject *)self, name, ldict, 0);
1039 localobject *self = (localobject *)Py_NewRef(obj);
1040 if (self->dummies != NULL) {
1042 ldict = PyDict_GetItemWithError(self->dummies, dummyweakref);
1044 PyDict_DelItem(self->dummies, dummyweakref);
1116 thread_PyThread_start_new_thread(PyObject *self, PyObject *fargs)
1184 thread_PyThread_exit_thread(PyObject *self, PyObject *Py_UNUSED(ignored))
1198 thread_PyThread_interrupt_main(PyObject *self, PyObject *args)
1239 thread_get_ident(PyObject *self, PyObject *Py_UNUSED(ignored))
1262 thread_get_native_id(PyObject *self, PyObject *Py_UNUSED(ignored))
1277 thread__count(PyObject *self, PyObject *Py_UNUSED(ignored))
1356 thread_stack_size(PyObject *self, PyObject *args)