void *obj_deref_debug(void *object, const char *file, int line)
{
object_t *o = object;
fprintf(stderr,"%s:%i obj_deref(%p <%s>)\n",file,line,object,obj_type(object)->name);
o->refcount -= 2;
if (o->refcount <= 1)
{
if (o->refcount >= 0)
{
o->type->nr_freed++;
if (o->type->kill)
o->type->kill(object);
fprintf(stderr,"obj_deref(): freeing object of type %s\n",obj_type(object)->name);
unregister_object(object);
free(object);
}
else
{
fprintf(stderr,"obj_deref(): Orphan or dying object dereferenced (refcount var = %i)\n",
o->refcount);
BUG("Error: Orphan or dying object dereferenced, have to quit.");
}
}
else
{
fprintf(stderr,"obj_deref(): Refcount of %s object down to %i.\n",obj_type(object)->name,o->refcount/2);
}
return 0;
}
void
unregister_elem_class(void *ptr)
{
if (ptr) {
st_delete(seqblock_klass_table, (st_data_t*)&ptr, NULL);
unregister_object(ptr);
}
}
/* Please see header for specification */
Anvil::GLSLShaderToSPIRVGenerator::~GLSLShaderToSPIRVGenerator()
{
auto object_tracker_ptr = Anvil::ObjectTracker::get();
object_tracker_ptr->unregister_object(Anvil::ObjectType::ANVIL_GLSL_SHADER_TO_SPIRV_GENERATOR,
this);
m_spirv_blob.clear();
}
~shooting()
{
unregister_resource(holder.get());
unregister_object(&dialog);
for(auto &enemy: enemies){
delete enemy;
}
for(auto &bullet: enemy_bullets){
delete bullet;
}
}
/*
* Delete mark symbol from hash table, then free memory.
*/
void
free_object(void *ptr)
{
if (ptr) {
unregister_object(ptr);
try {
cvFree(&ptr);
}
catch (cv::Exception& e) {
raise_cverror(e);
}
}
}
/*
* Release IplConvKernel object from memory and delete from hashtable.
*/
void
release_iplconvkernel_object(void *ptr)
{
if (ptr) {
unregister_object(ptr);
try {
cvReleaseStructuringElement((IplConvKernel**)(&ptr));
}
catch (cv::Exception& e) {
raise_cverror(e);
}
}
}
~configurator()
{
unregister_object(&title);
unregister_object(&text[0]);
unregister_object(&text[1]);
unregister_object(&js_name);
unregister_object(&back);
for(auto &a: assignors){
unregister_object(&a);
}
}
void *obj_deref(void *object)
{
/* Note: 'o' is static so that I can set a watchpoint on it:
* break obj_deref
* -> Breakpoint 1
* cont
* [...]
* del 1
* next
* watch (o->type == &(biplane.object_type))
* cont
* [...]
* print *o
* print *o.type
* Note that this breaks only when the value of the given expression
* changes, not when it's true...
*/
static object_t *o;
o = object;
o->refcount -= 2;
if (o->refcount <= 1)
{
if (o->refcount >= 0)
{
o->type->nr_freed++;
unregister_object(object);
if (o->type->kill)
o->type->kill(object);
free(object);
}
else
{
/* This point is reached if we manage to keep a reference
and deref it even when refcount is 0, or if we deref an
object which was never referenced. In principle this can
never happen in a correct program. */
BUG("Error: Orphan or dying object dereferenced, have to quit.");
}
}
return 0;
}
static void unregister_rule(struct pa_policy_context_rule *rule,
enum pa_policy_object_type type,
const char *name,
void *ptr,
unsigned long index)
{
union pa_policy_context_action *actn;
struct pa_policy_set_property *setprop;
struct pa_policy_del_property *delprop;
struct pa_policy_object *object;
int lineno;
for (actn = rule->actions; actn != NULL; actn = actn->any.next) {
switch (actn->any.type) {
case pa_policy_set_property:
setprop = &actn->setprop;
lineno = setprop->lineno;
object = &setprop->object;
break;
case pa_policy_delete_property:
delprop = &actn->delprop;
lineno = delprop->lineno;
object = &delprop->object;
break;
default:
continue;
} /* switch */
unregister_object(object, type, name, ptr, index, lineno);
} /* for actn */
}
~key_assignor()
{
unregister_object(&button);
unregister_object(&key);
}
~title()
{
for(auto &b: buttons){
unregister_object(&b);
}
}
