add coverage tests

[calc.git] / program.c

#include <malloc.h>
#include <stdio.h>
#include <string.h>

#include "alloc.h"
#include "argument.h"
#include "debug.h"
#include "parser.h"
#include "stack.h"
#include "storage.h"
#include "tabular.h"
#include "workspace.h"

#include "program.h"

/* global variables */

workspace_t **programs = NULL;
int nb_programs = 0;

/* lookfor program id */

int lookfor_program (int id)
{
    int i;
    for (i = 0; (programs) && (i < nb_programs); i++) {
        if (programs[i]->id == id) {
            return i;
        }
    }
    return -1;
}

/* program function */

void prog (int id, element_t *root)
{
    int n = -1;

    if (programs == NULL) {

        /* initial memory allocation */
        programs = (workspace_t **) callocordie (1, sizeof (workspace_t *));
        n = 0;
        nb_programs = 1;
        programs[n] = alloc_ws ();

    } else {

        /* look for existing program */
        n = lookfor_program (id);
        if (n == -1) {

            /* new program */
            n = nb_programs++;
            workspace_t **tmp = (workspace_t **) callocordie (nb_programs, sizeof (workspace_t *));
            memcpy (tmp, programs, (nb_programs - 1) * sizeof (workspace_t *));
            free (programs);
            programs = tmp;
            programs[n] = alloc_ws ();

        } else {

            /* clean old program */
            clean_ws(programs[n]);
        }
    }

    /* set program */
    programs[n]->id = id;
    programs[n]->root = dupelement (root);
}

double call (int id, int nbargs, element_t **args)
{
    double ret = 0;

    /* look for program */
    int n = lookfor_program (id);
    if (n == -1) {
        VERBOSE (WARNING, fprintf (stdout, "error unknown program (%d)\n", id));
        return 0;
    }

    /* backup context */
    workspace_t *tmp = backup_ws (alloc_ws ());
    restore_ws (programs[n]);
    
    /* set arguments */
    free_tab (argument);
    argument = NULL;
    if (nbargs > 0) {
        def (nbargs, args);
    }

    /* evaluate program */
    answer = 0;
    element_t *elements = dupelement (programs[n]->root);
    ret = evaluate_element (elements, 0);
    delelement (elements);

    /* clean arguments */
    if (argument) {
        free_tab (argument);
    }
    argument = NULL;
    if (nbargs > 0) {
        def (nbargs, args);
    }

    /* restore context */
    backup_ws (programs[n]);
    restore_ws (tmp);

    return ret;
}

void list ()
{
    int i;
    fprintf (stdout, "programs:");
    for (i = 0; i < nb_programs; i++) {
        fprintf (stdout, " %d", programs[i]->id);
    }
    fprintf (stdout, "\n");
}

void edit (int id)
{
    int n = lookfor_program (id);
    if (n == -1) {
        VERBOSE (WARNING, fprintf (stdout, "error unknown program (%d)\n", id));
        return;
    }

    /* set string program */
    fprintf (stdout, "edit: %s\n", programs[n]->string);
}

void savestring (int id, char *string)
{
    int n = lookfor_program (id);

    /* unnecesary code */
    //if (n == -1) {
    //    VERBOSE (WARNING, fprintf (stdout, "error unknown program (%d)\n", id));
    //    return;
    //}
    //if (programs[n]->string) {
    //    free (programs[n]->string);
    //}

    if (string) {
        programs[n]->string = strdup (string);
    }
}

void del (int id)
{
    int n = lookfor_program (id);
    if (n == -1) {
        VERBOSE (WARNING, fprintf (stdout, "error unknown program (%d)\n", id));
        return;
    }

    /* clean program */
    free_ws (programs[n]);

    /* remove entry */
    workspace_t **tmp = (workspace_t **) callocordie (nb_programs - 1, sizeof (workspace_t *));
    memcpy (tmp, programs, n * sizeof (workspace_t *));
    memcpy (tmp + n, programs + n + 1, (nb_programs - n - 1) * sizeof (workspace_t *));
    nb_programs--;
    free (programs);
    programs = tmp;
}

/* vim: set ts=4 sw=4 et: */