static void hbhmat_finalizer(SEXP ptr) {
ext_matrix *e;
hbhankel_matrix *h;
if (TYPEOF(ptr) != EXTPTRSXP)
return;
e = R_ExternalPtrAddr(ptr);
if (!e)
return;
if (strcmp(e->type, "hbhankel matrix"))
return;
h = e->matrix;
free_area(h->col_ind);
free_area(h->row_ind);
Free(h->weights);
free_circulant(h);
Free(h);
Free(e);
R_ClearExternalPtr(ptr);
}
void cleanup_taskbar()
{
Panel *panel;
Taskbar *tskbar;
int i, j, k;
cleanup_taskbarname();
if (win_to_task_table) g_hash_table_foreach(win_to_task_table, taskbar_remove_task, 0);
for (i=0 ; i < nb_panel ; i++) {
panel = &panel1[i];
for (j=0 ; j < panel->nb_desktop ; j++) {
tskbar = &panel->taskbar[j];
for (k=0; k<TASKBAR_STATE_COUNT; ++k) {
if (tskbar->state_pix[k]) XFreePixmap(server.dsp, tskbar->state_pix[k]);
}
free_area (&tskbar->area);
// remove taskbar from the panel
panel->area.list = g_slist_remove(panel->area.list, tskbar);
}
if (panel->taskbar) {
free(panel->taskbar);
panel->taskbar = 0;
}
}
if (win_to_task_table) {
g_hash_table_destroy(win_to_task_table);
win_to_task_table = 0;
}
}
static void elemstyle_free(elemstyle_t *elemstyle) {
elemstyle_condition_t *cond;
for (cond = elemstyle->condition; cond;) {
if(cond->key) xmlFree(cond->key);
if(cond->value) xmlFree(cond->value);
elemstyle_condition_t *prevcond = cond;
cond = cond->next;
g_free(prevcond);
}
switch(elemstyle->type) {
case ES_TYPE_NONE:
break;
case ES_TYPE_LINE:
free_line(elemstyle->line);
break;
case ES_TYPE_AREA:
free_area(elemstyle->area);
break;
case ES_TYPE_LINE_MOD:
free_line_mod(elemstyle->line_mod);
break;
}
if(elemstyle->icon) free_icon(elemstyle->icon);
g_free(elemstyle);
}
void free_area(Area *a)
{
if (!a)
return;
for (GList *l = a->children; l; l = l->next)
free_area(l->data);
if (a->children) {
g_list_free(a->children);
a->children = NULL;
}
for (int i = 0; i < MOUSE_STATE_COUNT; i++) {
XFreePixmap(server.display, a->pix_by_state[i]);
if (a->pix == a->pix_by_state[i]) {
a->pix = None;
}
a->pix_by_state[i] = None;
}
if (a->pix) {
XFreePixmap(server.display, a->pix);
a->pix = None;
}
if (mouse_over_area == a) {
mouse_over_area = NULL;
}
}
void destroy_separator(void *obj)
{
Separator *separator = (Separator *)obj;
remove_area(&separator->area);
free_area(&separator->area);
free_and_null(separator);
}
void cleanup_panel()
{
if (!panels)
return;
cleanup_taskbar();
for (int i = 0; i < num_panels; i++) {
Panel *p = &panels[i];
free_area(&p->area);
if (p->temp_pmap)
XFreePixmap(server.display, p->temp_pmap);
p->temp_pmap = 0;
if (p->hidden_pixmap)
XFreePixmap(server.display, p->hidden_pixmap);
p->hidden_pixmap = 0;
if (p->main_win)
XDestroyWindow(server.display, p->main_win);
p->main_win = 0;
stop_timeout(p->autohide_timeout);
cleanup_freespace(p);
}
free(panel_items_order);
panel_items_order = NULL;
free(panel_window_name);
panel_window_name = NULL;
free(panels);
panels = NULL;
free_area(&panel_config.area);
if (backgrounds)
g_array_free(backgrounds, TRUE);
backgrounds = NULL;
if (gradients) {
for (guint i = 0; i < gradients->len; i++)
cleanup_gradient(&g_array_index(gradients, GradientClass, i));
g_array_free(gradients, TRUE);
}
gradients = NULL;
pango_font_description_free(panel_config.g_task.font_desc);
panel_config.g_task.font_desc = NULL;
pango_font_description_free(panel_config.taskbarname_font_desc);
panel_config.taskbarname_font_desc = NULL;
}
static void free_area (area_t * area)
{
if (!area)
return;
switch (area->ty)
{
case AREA_UNION:
free_area (area->a.a_union[0]);
free_area (area->a.a_union[1]);
break;
default:
break;
}
free (area);
}
static
void free_area(dumb_ptr<area_t> area)
{
if (!area)
return;
switch (area->ty)
{
case AREA::UNION:
free_area(area->a.a_union[0]);
free_area(area->a.a_union[1]);
break;
default:
break;
}
area.delete_();
}
static void persistent_destroy(struct exception_store *store)
{
struct pstore *ps = get_info(store);
dm_io_put(sectors_to_pages(ps->chunk_size));
vfree(ps->callbacks);
free_area(ps);
kfree(ps);
}
void *gw_check_realloc(void *p, size_t size, const char *filename,
long lineno, const char *function)
{
struct area *area;
if (p == NULL)
return gw_check_malloc(size, filename, lineno, function);
gw_assert(initialized);
gw_assert(size > 0);
lock();
area = find_area(p);
if (!area) {
unlock();
panic(0, "Realloc called on non-allocated area");
}
if (size == area->area_size) {
/* No changes */
} else if (size <= area->max_size) {
change_total_size(size - area->area_size);
area->area_size = size;
endmark(p, size);
} else if (size > area->max_size) {
/* The current block is not large enough for the reallocation.
* We will allocate a new block, copy the data over, and free
* the old block. We round the size up to a power of two,
* to prevent frequent reallocations. */
struct area *new_area;
size_t new_size;
unsigned char *new_p;
new_size = round_pow2(size + 2 * MARKER_SIZE);
new_p = malloc(new_size);
new_size -= 2 * MARKER_SIZE;
new_p += MARKER_SIZE;
memcpy(new_p, p, area->area_size);
fill(new_p + area->area_size, size - area->area_size,
NEW_AREA_PATTERN);
new_area = record_allocation(new_p, size,
area->allocator.filename,
area->allocator.lineno,
area->allocator.function);
new_area->max_size = new_size;
free_area(area);
p = new_p;
area = new_area;
}
area->reallocator.filename = filename;
area->reallocator.lineno = lineno;
area->reallocator.function = function;
unlock();
return p;
}
static void make_location (val_t * v)
{
if (v->ty == TY_AREA && v->v.v_area->ty == AREA_LOCATION)
{
location_t location = v->v.v_area->a.a_loc;
free_area (v->v.v_area);
v->ty = TY_LOCATION;
v->v.v_location = location;
}
}
void destroy_execp(void *obj)
{
Execp *execp = (Execp *)obj;
if (execp->frontend) {
// This is a frontend element
execp->backend->instances = g_list_remove_all(execp->backend->instances, execp);
free_and_null(execp->frontend);
remove_area(&execp->area);
free_area(&execp->area);
free_and_null(execp);
} else {
// This is a backend element
stop_timeout(execp->backend->timer);
execp->backend->timer = NULL;
if (execp->backend->icon) {
imlib_context_set_image(execp->backend->icon);
imlib_free_image();
execp->backend->icon = NULL;
}
free_and_null(execp->backend->buf_output);
free_and_null(execp->backend->text);
free_and_null(execp->backend->icon_path);
if (execp->backend->child) {
kill(-execp->backend->child, SIGHUP);
execp->backend->child = 0;
}
if (execp->backend->child_pipe >= 0) {
close(execp->backend->child_pipe);
execp->backend->child_pipe = -1;
}
if (execp->backend->cmd_pids) {
g_tree_destroy(execp->backend->cmd_pids);
execp->backend->cmd_pids = NULL;
}
execp->backend->bg = NULL;
pango_font_description_free(execp->backend->font_desc);
execp->backend->font_desc = NULL;
free_and_null(execp->backend->command);
free_and_null(execp->backend->tooltip);
free_and_null(execp->backend->lclick_command);
free_and_null(execp->backend->mclick_command);
free_and_null(execp->backend->rclick_command);
free_and_null(execp->backend->dwheel_command);
free_and_null(execp->backend->uwheel_command);
if (execp->backend->instances) {
fprintf(stderr, "Error: Attempt to destroy backend while there are still frontend instances!\n");
exit(-1);
}
free(execp->backend);
free(execp);
}
}
void cleanup_systray()
{
stop_net();
systray_enabled = 0;
systray_max_icon_size = 0;
systray_monitor = 0;
systray.area.on_screen = FALSE;
free_area(&systray.area);
if (render_background) {
XFreePixmap(server.display, render_background);
render_background = 0;
}
}
void magic_clear_var(val_t *v)
{
switch (v->ty)
{
case TYPE::STRING:
v->v.v_string.delete_();
break;
case TYPE::AREA:
free_area(v->v.v_area);
break;
default:
break;
}
}
void magic_clear_var (val_t * v)
{
switch (v->ty)
{
case TY_STRING:
free (v->v.v_string);
break;
case TY_AREA:
free_area (v->v.v_area);
break;
default:
break;
}
}
void free_area (Area *a)
{
GSList *l0;
for (l0 = a->list; l0 ; l0 = l0->next)
free_area (l0->data);
if (a->list) {
g_slist_free(a->list);
a->list = 0;
}
if (a->pix) {
XFreePixmap (server.dsp, a->pix);
a->pix = 0;
}
}
void cleanup_taskbarname() {
int i, k;
Panel* panel;
Taskbar* tskbar;
for (i = 0; i < nb_panel; i++) {
panel = &panel1[i];
for (uint8_t j = 0; j < panel->desktop_count; ++j) {
tskbar = &panel->taskbar[j];
if (tskbar->bar_name.name) g_free(tskbar->bar_name.name);
free_area(&tskbar->bar_name.area);
for (k = 0; k < TASKBAR_STATE_COUNT; ++k) {
if (tskbar->bar_name.state_pix[k])
XFreePixmap(server.dsp, tskbar->bar_name.state_pix[k]);
}
tskbar->area.list = g_slist_remove(tskbar->area.list, &tskbar->bar_name);
}
}
}
void gw_check_free(void *p, const char *filename, long lineno,
const char *function)
{
struct area *area;
gw_assert(initialized);
if (p == NULL)
return;
lock();
area = find_area(p);
if (!area) {
unlock();
panic(0, "Free called on non-allocated area");
}
free_area(area);
unlock();
}
void s48_free_area(Area* area) {
unsigned long size = BYTES_TO_PAGES(area->end - area->start);
s48_address start = area->start;
unsigned long i;
s48_free_pagesB(start, size);
/* This is not really needed, I think. It's only a waste of time */
for (i = 0; i < size; i++) {
/* Safe because I is less than SIZE, which cannot cause an
overflow here. */
s48_memory_map_setB(ADD_PAGES_I_KNOW_THIS_CAN_OVERFLOW(start, i), NULL);
}
#ifndef NDEBUG
/* Blank it out, to find errors more easily */
memset(area->start, 0, area->end - area->start);
#endif
free_area(area);
}
void cleanup_taskbar()
{
Panel *panel;
Taskbar *tskbar;
int i, j, k;
cleanup_taskbarname();
if (win_to_task_table) {
while (g_hash_table_size(win_to_task_table)) {
GHashTableIter iter;
gpointer key, value;
g_hash_table_iter_init (&iter, win_to_task_table);
if (g_hash_table_iter_next (&iter, &key, &value)) {
taskbar_remove_task(key, 0, 0);
}
}
}
for (i=0 ; i < nb_panel ; i++) {
panel = &panel1[i];
for (j=0 ; j < panel->nb_desktop ; j++) {
tskbar = &panel->taskbar[j];
for (k=0; k<TASKBAR_STATE_COUNT; ++k) {
if (tskbar->state_pix[k]) XFreePixmap(server.dsp, tskbar->state_pix[k]);
}
free_area (&tskbar->area);
// remove taskbar from the panel
panel->area.list = g_slist_remove(panel->area.list, tskbar);
}
if (panel->taskbar) {
free(panel->taskbar);
panel->taskbar = 0;
}
}
if (win_to_task_table) {
g_hash_table_destroy(win_to_task_table);
win_to_task_table = 0;
}
}
void cleanup_launcher_theme(Launcher *launcher)
{
free_area(&launcher->area);
GSList *l;
for (l = launcher->list_icons; l ; l = l->next) {
LauncherIcon *launcherIcon = (LauncherIcon*)l->data;
if (launcherIcon) {
free_icon(launcherIcon->icon_scaled);
free_icon(launcherIcon->icon_original);
free(launcherIcon->icon_name);
free(launcherIcon->icon_path);
free(launcherIcon->cmd);
free(launcherIcon->icon_tooltip);
}
free(launcherIcon);
}
g_slist_free(launcher->list_icons);
launcher->list_icons = NULL;
free_themes(launcher->list_themes);
launcher->list_themes = NULL;
}
void cleanup_panel()
{
if (!panel1) return;
cleanup_taskbar();
int i;
Panel *p;
for (i=0 ; i < nb_panel ; i++) {
p = &panel1[i];
free_area(&p->area);
if (p->temp_pmap) XFreePixmap(server.dsp, p->temp_pmap);
if (p->hidden_pixmap) XFreePixmap(server.dsp, p->hidden_pixmap);
if (p->main_win) XDestroyWindow(server.dsp, p->main_win);
}
if (panel1) free(panel1);
if (backgrounds)
g_array_free(backgrounds, 1);
if (panel_config.g_task.font_desc) pango_font_description_free(panel_config.g_task.font_desc);
}
void cleanup_panel()
{
if (!panel1)
return;
cleanup_taskbar();
int i;
Panel *p;
for (i = 0; i < nb_panel; i++) {
p = &panel1[i];
free_area(&p->area);
if (p->temp_pmap)
XFreePixmap(server.dsp, p->temp_pmap);
p->temp_pmap = 0;
if (p->hidden_pixmap)
XFreePixmap(server.dsp, p->hidden_pixmap);
p->hidden_pixmap = 0;
if (p->main_win)
XDestroyWindow(server.dsp, p->main_win);
p->main_win = 0;
stop_timeout(p->autohide_timeout);
}
free(panel_items_order);
panel_items_order = NULL;
free(panel_window_name);
panel_window_name = NULL;
free(panel1);
panel1 = NULL;
if (backgrounds)
g_array_free(backgrounds, 1);
backgrounds = NULL;
pango_font_description_free(panel_config.g_task.font_desc);
panel_config.g_task.font_desc = NULL;
}
static
void stringify(val_t *v, int within_op)
{
static earray<ZString, DIR, DIR::COUNT> dirs //=
{{
{"south"}, {"south-west"},
{"west"}, {"north-west"},
{"north"}, {"north-east"},
{"east"}, {"south-east"},
}};
FString buf;
switch (v->ty)
{
case TYPE::UNDEF:
buf = "UNDEF";
break;
case TYPE::INT:
buf = STRPRINTF("%i", v->v.v_int);
break;
case TYPE::STRING:
return;
case TYPE::DIR:
buf = dirs[v->v.v_dir];
break;
case TYPE::ENTITY:
buf = show_entity(v->v.v_entity);
break;
case TYPE::LOCATION:
buf = STRPRINTF("<\"%s\", %d, %d>",
v->v.v_location.m->name_,
v->v.v_location.x,
v->v.v_location.y);
break;
case TYPE::AREA:
buf = "%area";
free_area(v->v.v_area);
break;
case TYPE::SPELL:
buf = v->v.v_spell->name;
break;
case TYPE::INVOCATION:
{
dumb_ptr<invocation> invocation_ = within_op
? v->v.v_invocation
: map_id2bl(v->v.v_int)->as_spell();
buf = invocation_->spell->name;
}
break;
default:
FPRINTF(stderr, "[magic] INTERNAL ERROR: Cannot stringify %d\n",
v->ty);
return;
}
v->v.v_string = dumb_string::copys(buf);
v->ty = TYPE::STRING;
}
static void stringify (val_t * v, int within_op)
{
static char *dirs[8] =
{ "south", "south-west", "west", "north-west", "north", "north-east",
"east", "south-east"
};
char *buf;
switch (v->ty)
{
case TY_UNDEF:
buf = strdup ("UNDEF");
break;
case TY_INT:
buf = malloc (32);
sprintf (buf, "%i", v->v.v_int);
break;
case TY_STRING:
return;
case TY_DIR:
buf = strdup (dirs[v->v.v_int]);
break;
case TY_ENTITY:
buf = strdup (show_entity (v->v.v_entity));
break;
case TY_LOCATION:
buf = malloc (128);
sprintf (buf, "<\"%s\", %d, %d>", map[v->v.v_location.m].name,
v->v.v_location.x, v->v.v_location.y);
break;
case TY_AREA:
buf = strdup ("%area");
free_area (v->v.v_area);
break;
case TY_SPELL:
buf = strdup (v->v.v_spell->name);
break;
case TY_INVOCATION:
{
invocation_t *invocation = within_op
? v->v.v_invocation : (invocation_t *) map_id2bl (v->v.v_int);
buf = strdup (invocation->spell->name);
}
break;
default:
fprintf (stderr, "[magic] INTERNAL ERROR: Cannot stringify %d\n",
v->ty);
return;
}
v->v.v_string = buf;
v->ty = TY_STRING;
}
