check parenthesis

[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)
{
    int i;
    double ret = 0;

    VERBOSE (DEBUG, fprintf (stdout, "new call (%d)\n", id));

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

    /* display debug information */
    VERBOSE (DEBUG, fprintf (stdout, "nbargs: %d\n", nbargs));
    for (i = 0; i < nbargs; i++) {
        VERBOSE (DEBUG, fprintf (stdout, "argument %d\n", i + 1); print_element (args[i], 0));
    }
    VERBOSE (DEBUG, fprintf (stdout, "program\n"); print_element (programs[n]->root, 0));

    /* backup context */
    workspace_t *tmp = backup_ws (alloc_ws ());
    restore_ws (programs[n]);

    /* set arguments */
    VERBOSE (DEBUG, fprintf (stdout, "argument before evaluation (%d)\n", size_tab (argument)));
    for (i = 0; i < size_tab (argument); i++) {
        VERBOSE (DEBUG, fprintf (stdout, "arg %d value: %g\n", i + 1, get_tab (argument, i + 1)));
    }
    VERBOSE (DEBUG, fprintf (stdout, "evaluate %d args\n", nbargs));
    tab_t *new_argument = def (nbargs, args);
    tab_t *old_argument = argument;
    argument = new_argument;
    VERBOSE (DEBUG, fprintf (stdout, "argument after evaluation (%d)\n", size_tab (argument)));
    for (i = 0; i < size_tab (argument); i++) {
        VERBOSE (DEBUG, fprintf (stdout, "arg %d value: %g\n", i + 1, get_tab (argument, i + 1)));
    }

    /* evaluate program */
    answer = 0;
    element_t *elements = dupelement (programs[n]->root);
    ret = evaluate_element (elements, 0);
    VERBOSE (DEBUG, fprintf (stdout, "ret; %g\n", ret));
    delelement (elements);

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

    /* clean arguments */
    free_tab (argument);
    argument = old_argument;

    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: */