program.c

   1 #include <malloc.h>
   2 #include <stdio.h>
   3 #include <string.h>
   4
   5 #include "alloc.h"
   6 #include "argument.h"
   7 #include "debug.h"
   8 #include "parser.h"
   9 #include "stack.h"
  10 #include "storage.h"
  11 #include "tabular.h"
  12 #include "workspace.h"
  13
  14 #include "program.h"
  15
  16 /* global variables */
  17
  18 workspace_t **programs = NULL;
  19 int nb_programs = 0;
  20
  21 /* lookfor program id */
  22
  23 int lookfor_program (int id)
  24 {
  25     int i;
  26     for (i = 0; (programs) && (i < nb_programs); i++) {
  27         if (programs[i]->id == id) {
  28             return i;
  29         }
  30     }
  31     return -1;
  32 }
  33
  34 /* program function */
  35
  36 void prog (int id, element_t *root)
  37 {
  38     int n = -1;
  39
  40     if (programs == NULL) {
  41
  42         /* initial memory allocation */
  43         programs = (workspace_t **) callocordie (1, sizeof (workspace_t *));
  44         n = 0;
  45         nb_programs = 1;
  46         programs[n] = alloc_ws ();
  47
  48     } else {
  49
  50         /* look for existing program */
  51         n = lookfor_program (id);
  52         if (n == -1) {
  53
  54             /* new program */
  55             n = nb_programs++;
  56             workspace_t **tmp = (workspace_t **) callocordie (nb_programs, sizeof (workspace_t *));
  57             memcpy (tmp, programs, (nb_programs - 1) * sizeof (workspace_t *));
  58             free (programs);
  59             programs = tmp;
  60             programs[n] = alloc_ws ();
  61
  62         } else {
  63
  64             /* clean old program */
  65             clean_ws(programs[n]);
  66         }
  67     }
  68
  69     /* set program */
  70     programs[n]->id = id;
  71     programs[n]->root = dupelement (root);
  72 }
  73
  74 double call (int id, int nbargs, element_t **args)
  75 {
  76     int i;
  77     double ret = 0;
  78
  79     VERBOSE (DEBUG, fprintf (stdout, "new call (%d)\n", id));
  80
  81     /* look for program */
  82     int n = lookfor_program (id);
  83     if (n == -1) {
  84         VERBOSE (WARNING, fprintf (stdout, "error unknown program (%d)\n", id));
  85         return 0;
  86     }
  87
  88     /* display debug information */
  89     VERBOSE (DEBUG, fprintf (stdout, "nbargs: %d\n", nbargs));
  90     for (i = 0; i < nbargs; i++) {
  91         VERBOSE (DEBUG, fprintf (stdout, "argument %d\n", i + 1); print_element (args[i], 0));
  92     }
  93     VERBOSE (DEBUG, fprintf (stdout, "program\n"); print_element (programs[n]->root, 0));
  94
  95     /* backup context */
  96     workspace_t *tmp = backup_ws (alloc_ws ());
  97     restore_ws (programs[n]);
  98
  99     /* set arguments */
 100     VERBOSE (DEBUG, fprintf (stdout, "argument before evaluation (%d)\n", size_tab (argument)));
 101     for (i = 0; i < size_tab (argument); i++) {
 102         VERBOSE (DEBUG, fprintf (stdout, "arg %d value: %g\n", i + 1, get_tab (argument, i + 1)));
 103     }
 104     VERBOSE (DEBUG, fprintf (stdout, "evaluate %d args\n", nbargs));
 105     tab_t *new_argument = def (nbargs, args);
 106     tab_t *old_argument = argument;
 107     argument = new_argument;
 108     VERBOSE (DEBUG, fprintf (stdout, "argument after evaluation (%d)\n", size_tab (argument)));
 109     for (i = 0; i < size_tab (argument); i++) {
 110         VERBOSE (DEBUG, fprintf (stdout, "arg %d value: %g\n", i + 1, get_tab (argument, i + 1)));
 111     }
 112
 113     /* evaluate program */
 114     answer = 0;
 115     element_t *elements = dupelement (programs[n]->root);
 116     ret = evaluate_element (elements, 0);
 117     VERBOSE (DEBUG, fprintf (stdout, "ret; %g\n", ret));
 118     delelement (elements);
 119
 120     /* restore context */
 121     backup_ws (programs[n]);
 122     restore_ws (tmp);
 123     free_ws (tmp);
 124
 125     /* clean arguments */
 126     free_tab (argument);
 127     argument = old_argument;
 128
 129     return ret;
 130 }
 131
 132 void list ()
 133 {
 134     int i;
 135     printf ("programs:");
 136     for (i = 0; i < nb_programs; i++) {
 137         printf (" %d", programs[i]->id);
 138     }
 139     printf ("\n");
 140 }
 141
 142 void edit (int id)
 143 {
 144     extern char *edit_line;
 145     int n = lookfor_program (id);
 146     if (n == -1) {
 147         VERBOSE (WARNING, fprintf (stdout, "error unknown program (%d)\n", id));
 148         return;
 149     }
 150
 151     /* set string program */
 152     if (edit_line) {
 153         free (edit_line);
 154     }
 155     edit_line = strdup (programs[n]->string);
 156     //printf ("edit: %s\n", programs[n]->string);
 157 }
 158
 159 void savestring (int id, char *string)
 160 {
 161     int n = lookfor_program (id);
 162
 163     /* unnecesary code */
 164     //if (n == -1) {
 165     //    VERBOSE (WARNING, fprintf (stdout, "error unknown program (%d)\n", id));
 166     //    return;
 167     //}
 168     //if (programs[n]->string) {
 169     //    free (programs[n]->string);
 170     //}
 171
 172     if (string) {
 173         programs[n]->string = strdup (string);
 174     }
 175 }
 176
 177 void del (int id)
 178 {
 179     int n = lookfor_program (id);
 180     if (n == -1) {
 181         VERBOSE (WARNING, fprintf (stdout, "error unknown program (%d)\n", id));
 182         return;
 183     }
 184
 185     /* clean program */
 186     free_ws (programs[n]);
 187
 188     /* remove entry */
 189     workspace_t **tmp = (workspace_t **) callocordie (nb_programs - 1, sizeof (workspace_t *));
 190     memcpy (tmp, programs, n * sizeof (workspace_t *));
 191     memcpy (tmp + n, programs + n + 1, (nb_programs - n - 1) * sizeof (workspace_t *));
 192     nb_programs--;
 193     free (programs);
 194     programs = tmp;
 195 }
 196
 197 /* vim: set ts=4 sw=4 et: */