gzdoom-gles/dumb/src/core/register.c

/*  _______         ____    __         ___    ___
 * \    _  \       \    /  \  /       \   \  /   /       '   '  '
 *  |  | \  \       |  |    ||         |   \/   |         .      .
 *  |  |  |  |      |  |    ||         ||\  /|  |
 *  |  |  |  |      |  |    ||         || \/ |  |         '  '  '
 *  |  |  |  |      |  |    ||         ||    |  |         .      .
 *  |  |_/  /        \  \__//          ||    |  |
 * /_______/ynamic    \____/niversal  /__\  /____\usic   /|  .  . ibliotheque
 *                                                      /  \
 *                                                     / .  \
 * register.c - Signal type registration.             / / \  \
 *                                                   | <  /   \_
 * By entheh.                                        |  \/ /\   /
 *                                                    \_  /  > /
 *                                                      | \ / /
 *                                                      |  ' /
 *                                                       \__/
 */

#include <stdlib.h>

#include "dumb.h"
#include "internal/dumb.h"



static DUH_SIGTYPE_DESC_LINK *sigtype_desc = NULL;
static DUH_SIGTYPE_DESC_LINK **sigtype_desc_tail = &sigtype_desc;



/* destroy_sigtypes(): frees all memory allocated while registering signal
 * types. This function is set up to be called by dumb_exit().
 */
static void destroy_sigtypes(void)
{
	DUH_SIGTYPE_DESC_LINK *desc_link = sigtype_desc, *next;
	sigtype_desc = NULL;
	sigtype_desc_tail = &sigtype_desc;

	while (desc_link) {
		next = desc_link->next;
		free(desc_link);
		desc_link = next;
	}
}



/* dumb_register_sigtype(): registers a new signal type with DUMB. The signal
 * type is identified by a four-character string (e.g. "WAVE"), which you can
 * encode using the the DUMB_ID() macro (e.g. DUMB_ID('W','A','V','E')). The
 * signal's behaviour is defined by four functions, whose pointers you pass
 * here. See the documentation for details.
 *
 * If a DUH tries to use a signal that has not been registered using this
 * function, then the library will fail to load the DUH.
 */
void DUMBEXPORT dumb_register_sigtype(DUH_SIGTYPE_DESC *desc)
{
	DUH_SIGTYPE_DESC_LINK *desc_link = sigtype_desc;

	ASSERT((desc->load_sigdata && desc->unload_sigdata) || (!desc->load_sigdata && !desc->unload_sigdata));
	ASSERT((desc->start_sigrenderer && desc->end_sigrenderer) || (!desc->start_sigrenderer && !desc->end_sigrenderer));
	ASSERT(desc->sigrenderer_generate_samples && desc->sigrenderer_get_current_sample);

	if (desc_link) {
		do {
			if (desc_link->desc->type == desc->type) {
				desc_link->desc = desc;
				return;
			}
			desc_link = desc_link->next;
		} while (desc_link);
	} else
		dumb_atexit(&destroy_sigtypes);

	desc_link = *sigtype_desc_tail = malloc(sizeof(DUH_SIGTYPE_DESC_LINK));

	if (!desc_link)
		return;

	desc_link->next = NULL;
	sigtype_desc_tail = &desc_link->next;

	desc_link->desc = desc;
}



/* _dumb_get_sigtype_desc(): searches the registered functions for a signal
 * type matching the parameter. If such a sigtype is found, it returns a
 * pointer to a sigtype descriptor containing the necessary functions to
 * manage the signal. If none is found, it returns NULL.
 */
DUH_SIGTYPE_DESC *_dumb_get_sigtype_desc(int32 type)
{
	DUH_SIGTYPE_DESC_LINK *desc_link = sigtype_desc;

	while (desc_link && desc_link->desc->type != type)
		desc_link = desc_link->next;

	return desc_link ? desc_link->desc : NULL;
}