register_functions.c

Go to the documentation of this file.

#ifndef _REGISTER_FUNCTIONS_
#define _REGISTER_FUNCTIONS_


#include "register_functions.h"


static int
fpw_function_sort
(
        const void *va,
        const void *vb
)
{
        fpw_function_t *a = (fpw_function_t *) va;
        fpw_function_t *b = (fpw_function_t *) vb;
        return strcmp (a->name, b->name);
}


fpw_function_t *
fpw_find_function
(
        const char *name
)
{
        fpw_function_node_t *gf;
        int i, n, lower, upper;

        if (name == NULL)
                return 0;
        if (all_functions == 0)
        {
                n = 0;
                all_functions = malloc (n_functions * sizeof (fpw_function_t));
                for (gf = fpw_function_nodes; gf; gf = gf->next)
                        for (i = 0; i < gf->n; i++)
                                all_functions[n++] = gf->functions[i];
                qsort (all_functions, n_functions, sizeof (fpw_function_t), fpw_function_sort);
        }
        lower = -1;
        upper = n_functions;
        /* printf("search function %s\n", name); */
        while (lower < upper - 1)
        {
                i = (lower + upper) / 2;
                n = strcmp (all_functions[i].name, name);
                /* printf("try [%d].%s, cmp %d\n", i, all_functions[i].name, n); */
                if (n == 0)
                        return all_functions + i;
                if (n > 0)
                        upper = i;
                else
                        lower = i;
        }
        for (i = 0; i < n_functions; i++)
                if (strcasecmp (all_functions[i].name, name) == 0)
                        return all_functions + i;
        g_log ("", G_LOG_LEVEL_WARNING,
                _("unknown function `%s'\n"), name);
        return 0;
}


int
fpw_functionv
(
        const char *name,
        int argc,
        char **argv
)
{
        int x = 0;
        int y = 0;
        int i;
        fpw_function_t *a;

        if (verbose && name)
        {
                fprintf (stderr, "Function: \033[34m%s(", name);
                for (i = 0; i < argc; i++)
                        fprintf (stderr, "%s%s", i ? "," : "", argv[i]);
                fprintf (stderr, ")\033[0m\n");
        }
        a = fpw_find_function (name);
        if (!a)
                return 1;
        return a->trigger_cb (argc, argv, x, y);
}


int
fpw_function
(
        const char *name
)
{
        return fpw_functionv (name, 0, 0);
}


void
fpw_register_functions
(
        fpw_function_t * a,
        int n
)
{
        fpw_function_node_t *gf;

        if (verbose)
        {
                fprintf(stderr, "%d functions registered.\n", n);
        }
        gf = (fpw_function_node_t *) malloc (sizeof (fpw_function_node_t));
        gf->next = fpw_function_nodes;
        fpw_function_nodes = gf;
        gf->functions = a;
        gf->n = n;
        n_functions += n;
        if (all_functions)
        {
                free (all_functions);
                all_functions = 0;
        }
}


#endif /* _REGISTER_FUNCTIONS_ guard. */


/* EOF */