event_gen_register.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_gen_register.c,v 1.7 2005/12/18 00:15:11 klmitch Exp $
*/
#include "event_int.h"

#include <stdlib.h>
#include <string.h>

RCSTAG("@(#)$Id: event_gen_register.c,v 1.7 2005/12/18 00:15:11 klmitch Exp $");

struct generator {
  unsigned int  gentype;        
  ev_magic_t    genmagic;       
  size_t        gensize;        
  ev_freegen_t  genrel;         
};

#define gd_init(gd, desc)                                                     \
do {                                                                          \
  ev_gendesc_t *_gd = (gd);                                                   \
  struct generator *_desc = (desc);                                           \
  /* initialize generator descriptor */                                       \
  _gd->gd_type = _desc->gentype; /* remember type... */                       \
  _gd->gd_magic = _desc->genmagic; /* ...magic number... */                   \
  _gd->gd_size = _desc->gensize; /* ...generator size... */                   \
  _gd->gd_release = _desc->genrel; /* ...and generator release callback */    \
  /* zero the generator lists... */                                           \
  _gd->gd_active.gl_count = 0;                                                \
  _gd->gd_active.gl_list = 0;                                                 \
  _gd->gd_free.gl_count = 0;                                                  \
  _gd->gd_free.gl_list = 0;                                                   \
} while (0)

#define gens_link(ctx, gens)                                                  \
do {                                                                          \
  ev_ctx_t *_ctx = (ctx);                                                     \
  ev_gens_t *_gens = (gens);                                                  \
  if (_gens->gs_next) /* update next element's prev pointer */                \
    _gens->gs_next->gs_prev = _gens;                                          \
  if (_gens->gs_prev) /* update previous element's next pointer */            \
    _gens->gs_prev->gs_next = _gens;                                          \
  else /* oops, first entry... */                                             \
    _ctx->ec_gens = _gens;                                                    \
} while (0)

static ev_err_t
gens_construct(ev_ctx_t *ctx, ev_gens_t *prev, ev_gens_t *next,
               struct generator *desc)
{
  ev_gens_t *gens;

  ev_trace();

  /* allocate the thing... */
  if (!(gens = (ev_gens_t *)malloc(sizeof(ev_gens_t))))
    ev_return(ENOMEM);

  /* Now initialize it... */
  gens->gs_next = next; /* initialize list pointers... */
  gens->gs_prev = prev;

  gens->gs_first = desc->gentype; /* remember type... */
  gens->gs_count = 1; /* only one generator here... */

  /* initialize generator descriptor */
  gd_init(&gens->gs_gens[0], desc);

  if (desc->gentype > ctx->ec_maxgen) /* keep track of largest generator */
    ctx->ec_maxgen = desc->gentype;

  /* finally, link it into the right place... */
  gens_link(ctx, gens);

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

static ev_err_t
gens_extend(ev_ctx_t *ctx, ev_gens_t *gens, struct generator *desc)
{
  ev_gendesc_t *gd;

  ev_trace();

  ev_assert(gens); /* should never be NULL here... */

  /* resize the gens... */
  if (!(gens = (ev_gens_t *)realloc(gens, sizeof(ev_gens_t) +
                                    sizeof(ev_gendesc_t) * gens->gs_count)))
    ev_return(ENOMEM);

  if (gens->gs_first > desc->gentype) { /* expanding at the beginning */
    memmove(&gens->gs_gens[1], &gens->gs_gens[0], /* shift the array over */
            sizeof(ev_gendesc_t) * gens->gs_count);
    gens->gs_first = desc->gentype; /* shift the first type... */
    gd = &gens->gs_gens[0]; /* put new generator at beginning */
  } else
    gd = &gens->gs_gens[gens->gs_count]; /* put new generator at end */

  gens->gs_count++; /* increment the count of generators... */

  /* initialize generator descriptor */
  gd_init(gd, desc);

  if (desc->gentype > ctx->ec_maxgen) /* keep track of largest generator */
    ctx->ec_maxgen = desc->gentype;

  /* finally, clean up links... */
  gens_link(ctx, gens);

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

static ev_err_t
gens_merge(ev_ctx_t *ctx, ev_gens_t *gens, struct generator *desc)
{
  ev_gens_t *new;

  ev_trace();

  ev_assert(gens); /* there must be an entry... */
  ev_assert(gens->gs_next); /* ...and a next entry */

  /* allocate new gens structure... */
  if (!(new = (ev_gens_t *)malloc(sizeof(ev_gens_t) + sizeof(ev_gendesc_t) *
                                  (gens->gs_count + gens->gs_next->gs_count))))
    ev_return(ENOMEM);

  /* initialize it... */
  new->gs_next = gens->gs_next->gs_next; /* taking out *two* entries */
  new->gs_prev = gens->gs_prev;

  new->gs_first = gens->gs_first; /* remember first type... */
  new->gs_count = gens->gs_count + gens->gs_next->gs_count + 1; /* and count */

  /* now copy old gendescs... */
  memcpy(&new->gs_gens[0], &gens->gs_gens[0], /* copy first entry... */
         sizeof(ev_gendesc_t) * gens->gs_count);

  /* and the last entry... */
  memcpy(&new->gs_gens[gens->gs_count + 1], &gens->gs_next->gs_gens[0],
         sizeof(ev_gendesc_t) * gens->gs_next->gs_count);

  /* next, initialize the newly allocated gendesc */
  gd_init(&new->gs_gens[gens->gs_count], desc);

  /* This should never be the maximum generator... */
  ev_assert(desc->gentype <= ctx->ec_maxgen);

  /* Link it into the right place... */
  gens_link(ctx, new);

  /* and release the memory for the old ones. */
  free(gens->gs_next); /* free the second one first... */
  free(gens); /* so that we don't reference freed memory */

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

ev_err_t
event_gen_register(ev_ctx_t *ctx, unsigned int gentype, ev_magic_t genmagic,
                   size_t gensize, ev_freegen_t genrel)
{
  ev_gens_t *gens, *last = 0;
  struct generator desc;

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

  if (!ec_verify(ctx) || gentype == EGT_NONE || !genmagic ||
      gensize < sizeof(ev_genhdr_t))
    ev_return(EINVAL); /* sanity-check arguments */

  desc.gentype = gentype; /* initialize the generator description */
  desc.genmagic = genmagic;
  desc.gensize = gensize;
  desc.genrel = genrel;

  /* if no entries or if the gentype is at the beginning of the list... */
  if (!ctx->ec_gens || gentype < ctx->ec_gens->gs_first - 1)
    /* just construct the thing... */
    ev_return(gens_construct(ctx, 0, ctx->ec_gens, &desc));

  /* walk through the list and find a place to insert generator */
  for (gens = ctx->ec_gens; gens; last = gens, gens = gens->gs_next) {
    /* duplicate generator? */
    if (gentype >= gens->gs_first && gentype < gens->gs_first + gens->gs_count)
      ev_return(EV_ERR_DUPGEN);

    /* Have we found an insertion point? */
    if (gentype >= gens->gs_first + gens->gs_count && gens->gs_next &&
        gentype < gens->gs_next->gs_first)
      break; /* all done! */
  }

  ev_assert(gens || last); /* one of these must be non-zero */

  /* inserting at end of list... */
  if (!gens && gentype != last->gs_first + last->gs_count)
    ev_return(gens_construct(ctx, last, 0, &desc));
  else if (!gens) /* OK, we're extending the last entry... */
    gens = last;

  /* OK, insertion point is somewhere in the middle... */
  if (gentype == gens->gs_first + gens->gs_count ||
      (gens->gs_next && gentype == gens->gs_next->gs_first - 1)) {
    /* extending or merging...but which? */
    if (gentype == gens->gs_first + gens->gs_count &&
        gens->gs_next && gentype == gens->gs_next->gs_first - 1)
      ev_return(gens_merge(ctx, gens, &desc)); /* merging! */

    /* OK, extending... */
    ev_return(gens_extend(ctx, ((gentype == gens->gs_first + gens->gs_count) ?
                                gens : gens->gs_next), &desc));
  }

  /* OK, construct a new entry */
  ev_return(gens_construct(ctx, gens, gens->gs_next, &desc));
}

---