event_destroy.c

Go to the documentation of this file.

/*
** Copyright (C) 2005 by Kevin L. Mitchell <klmitch@mit.edu>
**
** This program is free software; you can redistribute it and/or modify
** it under the terms of the GNU General Public License as published by
** the Free Software Foundation; either version 2 of the License, or
** (at your option) any later version.
**
** This program is distributed in the hope that it will be useful,
** but WITHOUT ANY WARRANTY; without even the implied warranty of
** MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
** GNU General Public License for more details.
**
** You should have received a copy of the GNU General Public License
** along with this program; if not, write to the Free Software
** Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
**
** @(#)$Id: event_destroy.c,v 1.11 2005/07/12 15:14:38 klmitch Exp $
*/
#include "engines_int.h"

#include <ltdl.h>

RCSTAG("@(#)$Id: event_destroy.c,v 1.11 2005/07/12 15:14:38 klmitch Exp $");

ev_err_t
event_destroy(ev_ctx_t *ctx)
{
  ev_gens_t *cursor, *next;
  ev_genhdr_t *gen, *lastgen = 0;
  ev_engine_t *eng, *nexteng;
  event_t *ev, *nextev;
  int i;

  ev_init(); /* make sure library is initialized... */

  /* sanity-check the argument... */
  if (!ec_verify(ctx))
    ev_return(EINVAL);
  if (ec_flags(ctx) & EV_CTX_RUNNING)
    ev_return(EBUSY);

  /* release all free events... */
  for (ev = ctx->ec_evs; ev; ev = nextev) {
    nextev = ev->ev_next;
    free(ev); /* release the memory... */
    ctx->ec_evcnt--; /* update the count... */
  }

  ctx->ec_evs = 0; /* zero the event list */
  ev_assert(!ctx->ec_evcnt);

  /* Now go through the list of registered generators and destroy them... */
  for (cursor = ctx->ec_gens; cursor; cursor = next) {
    next = cursor->gs_next;
    _ev_debug(EVAS_LOG, __FILE__, __LINE__, _gca_func,
              "Freeing generators %u-%u(%u); next is %u-%u(%u)",
              cursor->gs_first, cursor->gs_first + cursor->gs_count - 1,
              cursor->gs_count, next ? next->gs_first : 0,
              next ? next->gs_first + next->gs_count - 1 : 0,
              next ? next->gs_count : 0);
    for (i = 0; i < cursor->gs_count; i++) {
      /* release all active generators... */
      while ((gen = cursor->gs_gens[i].gd_active.gl_list)) {
        if (gen == lastgen) /* did we succeed in releasing the generator? */
          ev_return(EV_ERR_NOFREE);
        lastgen = gen; /* remember last generator we looked at... */
        if (cursor->gs_gens[i].gd_release) /* call release function */
          (cursor->gs_gens[i].gd_release)(ctx, (void *)gen);
        else { /* XXX pull this out into a macro or function */
          if (gen->eg_next) /* clip out of current list... */
            gen->eg_next->eg_prev = gen->eg_prev;
          if (gen->eg_prev)
            gen->eg_prev->eg_next = gen->eg_next;
          else
            cursor->gs_gens[i].gd_active.gl_list = gen->eg_next;
          cursor->gs_gens[i].gd_active.gl_count--;
          free(gen); /* now release the generator */
        }
      }

      ev_assert(!cursor->gs_gens[i].gd_active.gl_list);
      ev_assert(!cursor->gs_gens[i].gd_active.gl_count);

      /* now walk the free list (XXX put in macro or function?) */
      for (gen = cursor->gs_gens[i].gd_free.gl_list; gen; gen = lastgen) {
        lastgen = gen->eg_next; /* save pointer to next in list */
        free(gen); /* and release this one */
        cursor->gs_gens[i].gd_free.gl_count--;
      }
      cursor->gs_gens[i].gd_free.gl_list = 0;
      ev_assert(!cursor->gs_gens[i].gd_free.gl_count);
    }
    free(cursor); /* release the memory */
  }

  ctx->ec_maxgen = 0;
  ctx->ec_gens = 0;

  /* destroy the configuration context... */
  tc_destroy(ec_conf(ctx)); /* never mind the error code... */

  /* Walk through the list of engines... */
  for (eng = ctx->ec_engine; eng; eng = nexteng) {
    nexteng = eng->eng_list.el_next;
    if (eng->eng_fini && (eng->eng_runfl & EV_ENGINE_RUNNING))
      eng_fini(ctx, eng); /* call finalization function */

    /* no need to clip it from the list thanks to the nexteng pointer */

    if (eng->eng_handle) /* it was dynamically loaded; close it */
      lt_dlclose((lt_dlhandle)eng->eng_handle);
  }

  ctx->ec_engine = 0; /* zero out engine pointers */
  ctx->ec_socket.el_first = ctx->ec_socket.el_last = 0;
  ctx->ec_signal.el_first = ctx->ec_signal.el_last = 0;
  ctx->ec_timer.el_first = ctx->ec_timer.el_last = 0;

  /* If we initialized libltdl, we now need to clean it up... */
  if (ctx->ec_flags & EV_CTX_LTDLINIT)
    lt_dlexit();

  /* Finally, clear the flags and the magic number */
  ctx->ec_flags = 0;
  ctx->ec_magic = 0;

  ev_return(0); /* All done! */
}

---