parser.c

   1 #include <malloc.h>
   2 #include <math.h>
   3 #include <stdio.h>
   4 #include <stdlib.h>
   5 #include <string.h>
   6
   7 #include "debug.h"
   8
   9 #include "parser.h"
  10
  11 /* global variables */
  12
  13 double answer = 0;
  14
  15 #define DEFAULT_STORAGE_SIZE 10
  16 int storage_size = -1;
  17
  18 double *storage = NULL;
  19
  20 #define DEFAULT_FORMAT "=> %.6g\n"
  21 char *format = NULL;
  22 char *minform = NULL;
  23
  24 workspace_t *programs = NULL;
  25 int nb_programs = 0;
  26
  27 /* compare codes */
  28
  29 int codecmp (char *ref, char *str)
  30 {
  31     int sig;
  32
  33     while (*ref != '\0') {
  34         if (*ref == '\t') {
  35              sig = (*str == '.') ? -1 : ((*str >= '0') && (*str <= '9'));
  36         } else {
  37             sig = *str - *ref;
  38         }
  39         if (sig != 0) {
  40             return (sig > 0) ? 1 : -1;
  41         }
  42         str++;
  43         ref++;
  44     }
  45
  46     return 0;
  47 }
  48
  49 /* calloc or die function */
  50
  51 void *callocordie (size_t count, size_t size)
  52 {
  53     if (count * size == 0) {
  54         return NULL;
  55     }
  56     void *new = calloc (count, size);
  57     if (new == NULL) {
  58         VERBOSE (ERROR, fprintf (stderr, "can't allocate memory\n"));
  59         exit (1);
  60     }
  61     return new;
  62 }
  63
  64 /* allocate new element */
  65
  66 element_t *newelement (func_t function, int nbops, int prio)
  67 {
  68     element_t *new = (element_t *) callocordie (1, sizeof (element_t));
  69     if (nbops) {
  70         new->ops = (element_t **) callocordie (nbops, sizeof (element_t *));
  71     }
  72     new->func = function;
  73     new->nbops = nbops;
  74     new->prio = prio;
  75
  76     return new;
  77 }
  78
  79 /* desallocate element */
  80
  81 void delelement (element_t *root)
  82 {
  83     if ((root != NULL) && (root != ERROR_OP)) {
  84         int i;
  85         for (i = 0; i < root->nbops; i++) {
  86             if ((root->ops[i] != NULL) && (root->ops[i] != ERROR_OP)) {
  87                 delelement (root->ops[i]);
  88             }
  89         }
  90         if (root->nbops) {
  91             free (root->ops);
  92         }
  93         free (root);
  94     }
  95 }
  96
  97 /* duplicate element */
  98
  99 element_t *dupelement (element_t *root)
 100 {
 101     element_t *tmp = NULL;
 102     int i;
 103
 104     if ((root == NULL) || (root == ERROR_OP)) {
 105         return root;
 106     }
 107     tmp = newelement (root->func, root->nbops, root->prio);
 108     tmp->value = root->value;
 109     for (i = 0; i < root->nbops; i++) {
 110         tmp->ops[i] = dupelement (root->ops[i]);
 111     }
 112     return tmp;
 113 }
 114
 115 /* functions */
 116
 117 #define NB_OPERATORS 14
 118 keyword_t operators[NB_OPERATORS] = {
 119     { "+\t", Add, 2, 1, 1},
 120     { "-\t", Sub, 2, 1, 1},
 121     { "*",   Mul, 2, 1, 2},
 122     { "/",   Div, 2, 1, 2},
 123     { "%",   Mod, 2, 1, 3},
 124     { "^",   Pow, 2, 1, 4},
 125     { "==",  Equal, 2, 2, -1},
 126     { "!=",  Diff, 2, 2, -1},
 127     { ">=",  Ge, 2, 2, -1},
 128     { "<=",  Le, 2, 2, -1},
 129     { ">",   Gt, 2, 1, -1},
 130     { "<",   Lt, 2, 1, -1},
 131     { "&",   And, 2, 1, -2},
 132     { "|",   Or, 2, 1, -2}
 133 };
 134
 135 #define NB_FUNCTIONS 31
 136 keyword_t functions[NB_FUNCTIONS] = {
 137     { "sqrt", Sqr, 1, 4, 5},
 138     { "pow",  Pow, 2, 3, 5},
 139     { "cos",  Cos, 1, 3, 5},
 140     { "sin",  Sin, 1, 3, 5},
 141     { "tan",  Tan, 1, 3, 5},
 142     { "acos", Acos, 1, 4, 5},
 143     { "asin", Asin, 1, 4, 5},
 144     { "atan", Atan, 1, 4, 5},
 145     { "log",  Log, 1, 3, 5},
 146     { "exp",  Exp, 1, 3, 5},
 147     { "abs",  Abs, 1, 3, 5},
 148     { "floor", Floor, 1, 5, 5},
 149     { "ceil", Ceil, 1, 4, 5},
 150     { "sto",  Store, 2, 3, 5},
 151     { "rcl",  Recall, 1, 3, 5},
 152     { "inc",  Inc, 1, 3, 5},
 153     { "dec",  Dec, 1, 3, 5},
 154     { "disp", Disp, 0, 4, 9},
 155     { "mem",  Mem, 1, 3, 9},
 156     { "clr",  Clear, 0, 3, 9},
 157     { "quit", Quit, 0, 4, 9},
 158     { "help", Help, 0, 4, 9},
 159     { "!",    Not, 1, 1, 6},
 160     { "cond", Cond, 3, 4, 5},
 161     { "while", While, 2, 5, 5},
 162     { "print", Print, 1, 5, 5},
 163     { "prog", Prog, 3, 4, 9},
 164     { "call", Call, 10, 4, 5},
 165     { "ls",   List, 0, 2, 9},
 166     { "edit", Edit, 1, 4, 9},
 167     { "del",  Del, 1, 3, 9}
 168 };
 169
 170 #define NB_CONSTANTS 3
 171 keyword_t constants[NB_CONSTANTS] = {
 172     { "ans", Ans, 0, 3, 5},
 173     { "e",   E, 0, 1, 5},
 174     { "pi",  Pi, 0, 2, 5}
 175 };
 176
 177 #define NB_SYMBOLS 4
 178 char *symbols[NB_SYMBOLS] = {
 179     "(", ")", "{", "}"
 180 };
 181
 182 /* subparser function */
 183
 184 element_t *subparser (element_t **proot, char **pstr, func_t func, int nbops, int prio)
 185 {
 186     element_t *new = newelement (func, nbops, prio);
 187     new->ops[0] = *proot;
 188     new->ops[1] = parser (*pstr, pstr, new->prio);
 189     if ((new->ops[1] == NULL) || ((new->ops[1] != ERROR_OP) && (new->ops[1]->prio == 9))) {
 190         delelement (new->ops[1]);
 191         new->ops[1] = ERROR_OP;
 192     }
 193     if (new->ops[1] == ERROR_OP) {
 194         delelement (new);
 195         *proot = NULL;
 196         return ERROR_OP;
 197     }
 198     *proot = newelement (Val, 1, 5);
 199     (*proot)->ops[0] = new;
 200
 201     return *proot;
 202 }
 203
 204 /* parser function */
 205
 206 element_t *parser (char *str, char **next, int prio)
 207 {
 208     element_t *root = NULL;
 209     int i;
 210
 211     VERBOSE (DEBUG, fprintf (stdout, "Starting parsing\n"));
 212
 213     /* main loop */
 214     while (*str != '\0') {
 215         int found = 0;
 216         element_t *new = NULL;
 217         VERBOSE (INFO, fprintf (stdout, "Processing: %s\n", str));
 218
 219         /* end without printing */
 220
 221         if (*str == ';') {
 222             if (root) {
 223                 root->hidden = 1;
 224             }
 225             break;
 226         }
 227
 228         /* skip spaces and tabs */
 229
 230         if ((*str == ' ') || (*str == '\t')) {
 231             str++;
 232             continue;
 233         }
 234
 235         /* check for open brace */
 236
 237         if (*str == '{') {
 238             VERBOSE (DEBUG, fprintf (stdout, "start processing brace\n"));
 239             if (root != NULL) {
 240                 delelement (root);
 241                 return ERROR_OP;
 242             }
 243             element_t **prog = NULL;
 244             new = newelement (Code, 0, 5);
 245             root = new;
 246             prog = &root;
 247
 248             do {
 249                 new = parser (str + 1, &str, 0);
 250                 if ((new == NULL) || ((new != ERROR_OP) && (new->prio == 9))) {
 251                     delelement (new);
 252                     new = ERROR_OP;
 253                 }
 254                 if (new == ERROR_OP) {
 255                     delelement (root);
 256                     return ERROR_OP;
 257                 }
 258                 element_t *newprog = newelement (Code, (*prog)->nbops + 1, 5);
 259                 for (i = 0; i < (*prog)->nbops; i++) {
 260                     newprog->ops[i] = (*prog)->ops[i];
 261                     (*prog)->ops[i] = NULL;
 262                 }
 263                 newprog->ops[(*prog)->nbops] = new;
 264                 delelement (*prog);
 265                 (*prog) = newprog;
 266             } while (*str == ',');
 267
 268             if (*str != '}') {
 269                 delelement (root);
 270                 return ERROR_OP;
 271             }
 272             str++;
 273             VERBOSE (DEBUG, fprintf (stdout, "stop processing brace\n"));
 274             continue;
 275         }
 276
 277         /* check for open bracket */
 278
 279         if (*str == '(') {
 280             VERBOSE (DEBUG, fprintf (stdout, "start processing bracket\n"));
 281             if (root) {
 282                 do {
 283                     found = 0;
 284                     new = parser (str + 1, &str, 0);
 285                     if ((new == NULL) || ((new != ERROR_OP) && (new->prio == 9))) {
 286                         delelement (new);
 287                         new = ERROR_OP;
 288                     }
 289                     if ((new == NULL) || (new == ERROR_OP)) {
 290                         delelement (root);
 291                         return ERROR_OP;
 292                     }
 293                     for (i = 0; i < root->nbops; i++) {
 294                         if (root->ops[i] == NULL) {
 295                             root->ops[i] = new;
 296                             found = 1;
 297                             break;
 298                         }
 299                     }
 300                     if (!found) {
 301                         delelement (new);
 302                         delelement (root);
 303                         return ERROR_OP;
 304                     }
 305                 } while (*str == ',');
 306             } else {
 307                 root = newelement (Val, 1, 5);
 308                 new = parser (str + 1, &str, 0);
 309                 if ((new == NULL) || ((new != ERROR_OP) && (new->prio == 9))) {
 310                     delelement (new);
 311                     new = ERROR_OP;
 312                 }
 313                 if ((new == NULL) || (new == ERROR_OP) || (*str == ',')) {
 314                     delelement (new);
 315                     delelement (root);
 316                     return ERROR_OP;
 317                 }
 318                 root->ops[0] = new;
 319             }
 320             if (*str != ')') {
 321                 delelement (root);
 322                 return ERROR_OP;
 323             }
 324             str++;
 325             VERBOSE (DEBUG, fprintf (stdout, "stop processing bracket\n"));
 326             continue;
 327         }
 328
 329         /* check for closing bracket, closing brace or koma */
 330
 331         if ((*str == ')') || (*str == '}') || (*str == ',')) {
 332             if (prio == -9) {
 333                 delelement (root);
 334                 return ERROR_OP;
 335             }
 336             if (next != NULL) {
 337                 *next = str;
 338             }
 339             return root;
 340         }
 341
 342         /* look for operators */
 343
 344         for (i = 0; i < NB_OPERATORS; i++) {
 345             keyword_t *operator = operators + i;
 346             if (codecmp (operator->keyword, str) == 0) {
 347                 VERBOSE (DEBUG, fprintf (stdout, "start processing operator\n"));
 348                 if (root) {
 349                     if ((prio) && (prio > operator->prio)) {
 350                         VERBOSE (DEBUG, fprintf (stdout, "stop because operator priority\n"));
 351                         *next = str;
 352                         return root;
 353                     }
 354                     str += operator->offset;
 355                     VERBOSE (INFO, fprintf (stdout, "Oper: %d\n", operator->func));
 356                     if (subparser (&root, &str, operator->func, operator->nbops, operator->prio) == ERROR_OP) {
 357                         delelement (root);
 358                         return ERROR_OP;
 359                     }
 360                 } else if (*str == '-') {
 361                     root = newelement (Sig, 1, 9);
 362                 } else {
 363                     return ERROR_OP;
 364                 }
 365                 found = 1;
 366                 VERBOSE (DEBUG, fprintf (stdout, "stop processing operator\n"));
 367                 break;
 368             }
 369         }
 370         if (found) {
 371             continue;
 372         }
 373
 374         /* look for functions */
 375
 376         for (i = 0; i < NB_FUNCTIONS; i++) {
 377             keyword_t *function = functions + i;
 378             if (codecmp (function->keyword, str) == 0) {
 379                 VERBOSE (DEBUG, fprintf (stdout, "start processing function\n"));
 380                 if (root == NULL) {
 381                     VERBOSE (INFO, fprintf (stdout, "Func: %d\n", function->func));
 382                     root = newelement (function->func, function->nbops, function->prio);
 383                 } else {
 384                     delelement (root);
 385                     return ERROR_OP;
 386                 }
 387                 str += function->offset;
 388                 found = 1;
 389                 VERBOSE (DEBUG, fprintf (stdout, "stop processing function\n"));
 390                 break;
 391             }
 392         }
 393         if (found) {
 394             continue;
 395         }
 396
 397         /* look for constant */
 398
 399         for (i = 0; i < NB_CONSTANTS; i++) {
 400             keyword_t *constant = constants + i;
 401             if (codecmp (constant->keyword, str) == 0) {
 402                 VERBOSE (DEBUG, fprintf (stdout, "start processing constant\n"));
 403                 if (root == NULL) {
 404                     VERBOSE (INFO, fprintf (stdout, "Const: %d\n", constant->func));
 405                     root = newelement (constant->func, constant->nbops, constant->prio);
 406                 } else {
 407                     delelement (root);
 408                     return ERROR_OP;
 409                 }
 410                 str += constant->offset;
 411                 found = 1;
 412                 VERBOSE (DEBUG, fprintf (stdout, "stop processing constant\n"));
 413                 break;
 414             }
 415         }
 416         if (found) {
 417             continue;
 418         }
 419
 420         /* look for number */
 421
 422         if (((*str >= '0') && (*str <= '9')) ||
 423             (*str == '.') || (*str == '+') || (*str == '-')) {
 424             VERBOSE (DEBUG, fprintf (stdout, "start processing value\n"));
 425             char *pt;
 426             double value = strtod (str, &pt);
 427             VERBOSE (INFO, fprintf (stdout, "Value: %f\n", value));
 428             if (str != pt) {
 429                 if ((root == NULL) || (root->prio == 6)) {
 430                     new = newelement (Val, 1, 5);
 431                     new->value = value;
 432                     if (root == NULL) {
 433                         root = new;
 434                     } else {
 435                         for (i = 0; i < root->nbops; i++) {
 436                             if (root->ops[i] == NULL) {
 437                                 root->ops[i] = new;
 438                                 found = 1;
 439                                 break;
 440                             }
 441                         }
 442                         if (!found) {
 443                             delelement (new);
 444                             delelement (root);
 445                             return ERROR_OP;
 446                         }
 447                     }
 448                     str = pt;
 449                 } else if ((*str == '+') || (*str == '-')) {
 450                     if ((prio) && (prio > 1)) {
 451                         VERBOSE (DEBUG, fprintf (stdout, "stop because operator priority\n"));
 452                         *next = str;
 453                         return root;
 454                     }
 455                     if (subparser (&root, &str, Add, 2, 1) == ERROR_OP) {
 456                         delelement (root);
 457                         return ERROR_OP;
 458                     }
 459                 } else {
 460                     delelement (root);
 461                     return ERROR_OP;
 462                 }
 463                 found = 1;
 464             }
 465             VERBOSE (DEBUG, fprintf (stdout, "stop processing value\n"));
 466         }
 467
 468         /* error */
 469
 470         if (!found) {
 471             delelement (root);
 472             return ERROR_OP;
 473         }
 474
 475     }
 476
 477     if (next != NULL) {
 478         *next = str;
 479     }
 480
 481     return root;
 482 }
 483
 484 /* print element tree */
 485
 486 void print_element (element_t *root, int level)
 487 {
 488     char *func = NULL;
 489     int i;
 490
 491     if ((root == NULL) || (root == ERROR_OP)) {
 492         return;
 493     }
 494
 495     for (i = 0; i < level; i++) {
 496         fprintf (stdout, " ");
 497     }
 498
 499     switch (root->func) {
 500     case Val: func = "Value"; break;
 501     case Sig: func = "Sign"; break;
 502     case Add: func = "Addition"; break;
 503     case Sub: func = "Subtraction"; break;
 504     case Mul: func = "Multiplication"; break;
 505     case Div: func = "Division"; break;
 506     case Mod: func = "Modulo"; break;
 507     case Pow: func = "Power"; break;
 508     case Sqr: func = "Square Root"; break;
 509     case Cos: func = "Cosine"; break;
 510     case Sin: func = "Sine"; break;
 511     case Tan: func = "Tangent"; break;
 512     case Acos: func = "Arc Cosine"; break;
 513     case Asin: func = "Arc Sine"; break;
 514     case Atan: func = "Arc Tangent"; break;
 515     case Log: func = "Logarithm"; break;
 516     case Exp: func = "Exponantial"; break;
 517     case Abs: func = "Absolute value"; break;
 518     case Ceil: func = "Ceil value"; break;
 519     case Floor: func = "Floor value"; break;
 520     case Store: func = "Store"; break;
 521     case Recall: func = "Recall"; break;
 522     case Inc: func = "Increase"; break;
 523     case Dec: func = "Decrease"; break;
 524     case Disp: func = "Display"; break;
 525     case Mem: func = "Memory"; break;
 526     case Clear: func = "Clear"; break;
 527     case Quit: func = "Quit"; break;
 528     case Help: func = "Help"; break;
 529     case Ans: func = "Ans"; break;
 530     case Pi: func = "Pi"; break;
 531     case E: func = "E"; break;
 532     case Equal: func = "Equal"; break;
 533     case Diff: func = "Different"; break;
 534     case Ge: func = "Greater or equal"; break;
 535     case Le: func = "Lesser or equal"; break;
 536     case Gt: func = "Greater"; break;
 537     case Lt: func = "Lesser"; break;
 538     case And: func = "And"; break;
 539     case Or: func = "Or"; break;
 540     case Not: func = "Not"; break;
 541     case Cond: func = "Condition"; break;
 542     case While: func = "While"; break;
 543     case Code: func = "Code"; break;
 544     case Print: func = "Print"; break;
 545     case Prog: func = "Program"; break;
 546     case Call: func = "Call"; break;
 547     case List: func = "List"; break;
 548     case Edit: func = "Edit"; break;
 549     case Del: func = "Del"; break;
 550     }
 551
 552     fprintf (stdout, "Function: %s\n", func);
 553
 554     if ((root->func == Val) && (root->ops[0] == NULL)) {
 555         for (i = 0; i < level; i++) {
 556             fprintf (stdout, " ");
 557         }
 558         fprintf (stdout, "value: %f\n", root->value);
 559     } else {
 560         for (i = 0; i < root->nbops; i++) {
 561             print_element (root->ops[i], level + 1);
 562         }
 563     }
 564 }
 565
 566 /* storage functions */
 567
 568 void memory (int nb)
 569 {
 570     int i, l;
 571     double *tmp = NULL;
 572     if (nb != storage_size) {
 573         l = (nb < storage_size) ? nb : storage_size;
 574         tmp = (double *) callocordie (nb, sizeof (double));
 575         for (i = 0; i < l; i++) {
 576             tmp[i] = storage[i];
 577         }
 578         if (storage != NULL) {
 579             free (storage);
 580         }
 581         storage = tmp;
 582         storage_size = nb;
 583     }
 584 }
 585
 586 double store (int index, double value)
 587 {
 588     if (storage_size == -1) {
 589         memory (DEFAULT_STORAGE_SIZE);
 590     }
 591     if ((index > 0) && (index <= storage_size)) {
 592         storage[index - 1] = value;
 593     } else {
 594         VERBOSE (WARNING, fprintf (stdout, "invalid index (%d) [%d, %d]\n", index, (storage_size) ? 1 : 0, storage_size));
 595     }
 596     return value;
 597 }
 598
 599 double recall (int index)
 600 {
 601     if (storage_size == -1) {
 602         memory (DEFAULT_STORAGE_SIZE);
 603     }
 604     if ((index > 0) && (index <= storage_size)) {
 605         return storage[index - 1];
 606     } else {
 607         VERBOSE (WARNING, fprintf (stdout, "invalid index (%d) [%d, %d]\n", index, (storage_size) ? 1 : 0, storage_size));
 608     }
 609     return 0;
 610 }
 611
 612 double increase (int index)
 613 {
 614     if (storage_size == -1) {
 615         memory (DEFAULT_STORAGE_SIZE);
 616     }
 617     if ((index > 0) && (index <= storage_size)) {
 618         return storage[index - 1]++;
 619     } else {
 620         VERBOSE (WARNING, fprintf (stdout, "invalid index (%d) [%d, %d]\n", index, (storage_size) ? 1 : 0, storage_size));
 621     }
 622     return 0;
 623 }
 624
 625 double decrease (int index)
 626 {
 627     if (storage_size == -1) {
 628         memory (DEFAULT_STORAGE_SIZE);
 629     }
 630     if ((index > 0) && (index <= storage_size)) {
 631         return storage[index - 1]--;
 632     } else {
 633         VERBOSE (WARNING, fprintf (stdout, "invalid index (%d) [%d, %d]\n", index, (storage_size) ? 1 : 0, storage_size));
 634     }
 635     return 0;
 636 }
 637
 638 void display (void)
 639 {
 640     int i;
 641     if (storage_size == -1) {
 642         memory (DEFAULT_STORAGE_SIZE);
 643     }
 644     fprintf (stdout, "storage:");
 645     for (i = 0; i < storage_size; i++) {
 646         fprintf (stdout, " ");
 647         fprintf (stdout, minform, storage[i]);
 648     }
 649     fprintf (stdout, "\n");
 650 }
 651
 652 void clear ()
 653 {
 654     int i;
 655     for (i = 0; i < storage_size; i++) {
 656         storage[i] = 0;
 657     }
 658 }
 659
 660 /* While do function */
 661
 662 double while_do (element_t *cond, element_t *action)
 663 {
 664     double ret = 0;
 665     element_t *temp = NULL;
 666
 667     VERBOSE (DEBUG, fprintf (stdout, "starting while loop\n"));
 668     while (1) {
 669         VERBOSE (DEBUG, fprintf (stdout, "loop...\n"));
 670
 671         temp = dupelement (cond);
 672         if (!evaluate_element (temp, 0)) {
 673             break;
 674         }
 675         if (action) {
 676             temp = dupelement (action);
 677             ret = evaluate_element (temp, 0);
 678         }
 679     }
 680
 681     VERBOSE (DEBUG, fprintf (stdout, "ending while loop\n"));
 682
 683     return ret;
 684 }
 685
 686 /* program function */
 687
 688 double execute_code (element_t **prog, int nbcalls)
 689 {
 690     double ret = 0;
 691     int i;
 692     for (i = 0; i < nbcalls; i++) {
 693         ret = evaluate_element (prog[i], 0);
 694         prog[i] = NULL;
 695     }
 696     return ret;
 697 }
 698
 699 /* print function */
 700
 701 void set_format (char *prompt, int precision)
 702 {
 703     char buffer[128] = {0};
 704     free_format ();
 705     sprintf (buffer, "%s%%.%dg\n", prompt, precision);
 706     format = strdup (buffer);
 707     sprintf (buffer, "%%.%dg", precision);
 708     minform = strdup (buffer);
 709 }
 710
 711 void free_format ()
 712 {
 713     if (format) {
 714         free (format);
 715         format = NULL;
 716     }
 717     if (minform) {
 718         free (minform);
 719         minform = NULL;
 720     }
 721 }
 722
 723 double print (double value)
 724 {
 725     fprintf (stdout, format ? format : DEFAULT_FORMAT, value);
 726     fflush (stdout);
 727     return value;
 728 }
 729
 730 /* quit function */
 731
 732 void quit (void)
 733 {
 734     fprintf (stdout, "bye\n");
 735     exit (0);
 736 }
 737
 738 /* program function */
 739
 740 void prog (int id, int nbmems, element_t *root)
 741 {
 742     int i, n = -1;
 743
 744     if (programs == NULL) {
 745
 746         /* initial memory allocation */
 747         programs = (workspace_t *) callocordie (1, sizeof (workspace_t));
 748         nb_programs = 1;
 749         n = 0;
 750
 751     } else {
 752
 753         /* look for existing program */
 754         for (i = 0; i < nb_programs; i++) {
 755             if ((programs + i)->id == id) {
 756                 n = i;
 757                 break;
 758             }
 759         }
 760         if (n == -1) {
 761
 762             /* new program */
 763             n = nb_programs++;
 764             workspace_t *tmp = (workspace_t *) callocordie (nb_programs, sizeof (workspace_t));
 765             memcpy (tmp, programs, (nb_programs - 1) * sizeof (workspace_t));
 766             free (programs);
 767             programs = tmp;
 768         } else {
 769
 770             /* clean old program */
 771             if ((programs + n)->storage) {
 772                 free ((programs + n)->storage);
 773             }
 774             if ((programs + n)->root) {
 775                 delelement ((programs + n)->root);
 776             }
 777             if ((programs + n)->string) {
 778                 free ((programs + n)->string);
 779             }
 780         }
 781     }
 782
 783     /* set program */
 784     (programs + n)->id = id;
 785     (programs + n)->answer = 0;
 786     (programs + n)->storage = (double *) callocordie (nbmems, sizeof (double));
 787     (programs + n)->storage_size = nbmems;
 788     (programs + n)->root = dupelement (root);
 789 }
 790
 791 double call (int id, int nbops, element_t **ops)
 792 {
 793     workspace_t tmp = {0};
 794     int i, n = -1;
 795     double ret = 0;
 796
 797     if (programs) {
 798
 799         /* look for program */
 800         for (i = 0; i < nb_programs; i++) {
 801             if ((programs + i)->id == id) {
 802                 n = i;
 803                 break;
 804             }
 805         }
 806     }
 807     if (n == -1) {
 808         VERBOSE (WARNING, fprintf (stdout, "error unknown program (%d)\n", id));
 809         return 0;
 810     }
 811
 812     /* store context */
 813     tmp.answer = answer;
 814     tmp.storage = storage;
 815     tmp.storage_size = storage_size;
 816
 817     /* change context */
 818     answer = 0;
 819     storage = (programs + n)->storage;
 820     storage_size = (programs + n)->storage_size;
 821     if (nbops > storage_size) {
 822         double *tmp = (double *) callocordie (nbops, sizeof (double));
 823         memcpy (tmp, storage, storage_size * sizeof (double));
 824         free (storage);
 825         storage = tmp;
 826         storage_size = nbops;
 827     }
 828     for (i = 0; i < nbops; i++) {
 829         double val = evaluate_element (ops[i], 0);
 830         store (i + 1, val);
 831     }
 832
 833     /* evaluate program */
 834     element_t *elements = dupelement ((programs + n)->root);
 835     ret = evaluate_element (elements, 0);
 836
 837     /* restore context */
 838     answer = tmp.answer;
 839     storage = tmp.storage;
 840     storage_size = tmp.storage_size;
 841
 842     return ret;
 843 }
 844
 845 void list ()
 846 {
 847     int i;
 848     fprintf (stdout, "programs:");
 849     for (i = 0; i < nb_programs; i++) {
 850         fprintf (stdout, " %d", (programs + i)->id);
 851     }
 852     fprintf (stdout, "\n");
 853 }
 854
 855 void edit (int id)
 856 {
 857     int i, n = -1;
 858
 859     if (programs) {
 860
 861         /* look for program */
 862         for (i = 0; i < nb_programs; i++) {
 863             if ((programs + i)->id == id) {
 864                 n = i;
 865                 break;
 866             }
 867         }
 868     }
 869     if (n == -1) {
 870         VERBOSE (WARNING, fprintf (stdout, "error unknown program (%d)\n", id));
 871         return;
 872     }
 873
 874     /* set string program */
 875     //rl_insert_text ((programs + n)->string);
 876     VERBOSE (INFO, fprintf (stdout, "edit: %s\n", (programs + n)->string));
 877 }
 878
 879 void save_string (int id, char *string)
 880 {
 881     int i, n = -1;
 882
 883     if (programs) {
 884
 885         /* look for program */
 886         for (i = 0; i < nb_programs; i++) {
 887             if ((programs + i)->id == id) {
 888                 n = i;
 889                 break;
 890             }
 891         }
 892     }
 893     if (n == -1) {
 894         VERBOSE (WARNING, fprintf (stdout, "error unknown program (%d)\n", id));
 895         return;
 896     }
 897
 898     /* save program */
 899     if ((programs + n)->string) {
 900         free ((programs + n)->string);
 901     }
 902     (programs + n)->string = strdup (string);
 903 }
 904
 905 void del (int id)
 906 {
 907     int i, j, n = -1;
 908
 909     if (programs) {
 910
 911         /* look for program */
 912         for (i = 0; i < nb_programs; i++) {
 913             if ((programs + i)->id == id) {
 914                 n = i;
 915                 break;
 916             }
 917         }
 918     }
 919     if (n == -1) {
 920         VERBOSE (WARNING, fprintf (stdout, "error unknown program (%d)\n", id));
 921         return;
 922     }
 923
 924     /* clean program */
 925     if ((programs + n)->storage) {
 926         free ((programs + n)->storage);
 927     }
 928     if ((programs + n)->root) {
 929         delelement ((programs + n)->root);
 930     }
 931     if ((programs + n)->string) {
 932         free ((programs + n)->string);
 933     }
 934
 935     /* remove entry */
 936     workspace_t *tmp = (workspace_t *) callocordie (nb_programs - 1, sizeof (workspace_t));
 937     for (i = 0, j = 0; i < nb_programs; i++) {
 938         if (i != n) {
 939             memcpy (tmp + j, programs + i, sizeof (workspace_t));
 940             j++;
 941         }
 942     }
 943     free (programs);
 944     programs = tmp;
 945     nb_programs--;
 946 }
 947
 948 /* help message */
 949
 950 void help (void)
 951 {
 952     fprintf (stdout, "calc is a simple calculator\n\n");
 953     fprintf (stdout, "supported operators:");
 954     fprintf (stdout, " + - * / %% ^\n");
 955     fprintf (stdout, "camparison operators:");
 956     fprintf (stdout, " == != >= <= > <\n");
 957     fprintf (stdout, "logical operators:");
 958     fprintf (stdout, " & | !\n");
 959     fprintf (stdout, "mathematic functions:");
 960     fprintf (stdout, " pow sqrt log exp\n");
 961     fprintf (stdout, "trig. func.:");
 962     fprintf (stdout, " cos sin tan acos asin atan\n");
 963     fprintf (stdout, "supported functions:");
 964     fprintf (stdout, " abs ceil floor\n");
 965     fprintf (stdout, "storage functions:");
 966     fprintf (stdout, " mem sto rcl inc dec disp\n");
 967     fprintf (stdout, "prog. functions:");
 968     fprintf (stdout, " cond while print {} ;\n");
 969     fprintf (stdout, "misc. functions:");
 970     fprintf (stdout, " quit help\n");
 971     fprintf (stdout, "supported constants:");
 972     fprintf (stdout, " e pi\n");
 973 }
 974
 975 /* evaluate element tree */
 976
 977 #define MASK_SUB 0x1
 978 #define MASK_DIV 0x2
 979
 980 double evaluate_element (element_t *root, char mask)
 981 {
 982     double op0 = 0, op1 = 0;
 983     char nextmask = mask;
 984     int i, nb;
 985
 986     if ((root == NULL) || (root == ERROR_OP)) {
 987         VERBOSE (WARNING, fprintf (stdout, "error while evaluating\n"));
 988         return 0;
 989     }
 990
 991     /* mask to manage sub operator sub and div */
 992     switch (root->func) {
 993     case Add:
 994         nextmask &= ~MASK_SUB;
 995         nextmask &= ~MASK_DIV;
 996         break;
 997     case Sub:
 998         nextmask |= MASK_SUB;
 999         nextmask &= ~MASK_DIV;
1000         break;
1001     case Mul:
1002         nextmask &= ~MASK_DIV;
1003         break;
1004     case Div:
1005         nextmask |= MASK_DIV;
1006         break;
1007     default:
1008         nextmask = mask;
1009     }
1010
1011     switch (root->func) {
1012     case Val:
1013     case Sig:
1014         op0 = (root->ops[0]) ? evaluate_element (root->ops[0], nextmask) : root->value;
1015         break;
1016     case Add:
1017     case Sub:
1018     case Mul:
1019     case Div:
1020     case Mod:
1021     case Pow:
1022     case Store:
1023     case Equal:
1024     case Diff:
1025     case Ge:
1026     case Le:
1027     case Gt:
1028     case Lt:
1029     case And:
1030     case Or:
1031     case Prog:
1032         if (root->ops[1]) {
1033             op1 = evaluate_element (root->ops[1], nextmask);
1034         } else if (root->func != Store) {
1035             VERBOSE (WARNING, fprintf (stdout, "error while evaluating (op[1])\n"));
1036             return 0;
1037         }
1038         /* fallthrough */
1039     case Sqr:
1040     case Cos:
1041     case Sin:
1042     case Tan:
1043     case Acos:
1044     case Asin:
1045     case Atan:
1046     case Log:
1047     case Exp:
1048     case Abs:
1049     case Ceil:
1050     case Floor:
1051     case Recall:
1052     case Inc:
1053     case Dec:
1054     case Not:
1055     case Mem:
1056     case Cond:
1057     case Call:
1058     case Edit:
1059     case Del:
1060         if (root->ops[0]) {
1061             op0 = evaluate_element (root->ops[0], 0);
1062         } else {
1063             VERBOSE (WARNING, fprintf (stdout, "error while evaluating (op[0])\n"));
1064             return 0;
1065         }
1066         break;
1067     case Disp:
1068     case Clear:
1069     case Quit:
1070     case Help:
1071     case Ans:
1072     case Pi:
1073     case E:
1074     case Code:
1075     case List:
1076         break;
1077     case While:
1078         if (root->ops[0] == NULL) {
1079             VERBOSE (WARNING, fprintf (stdout, "error while evaluating (op[0])\n"));
1080             return 0;
1081         }
1082         break;
1083     case Print:
1084         op0 = (root->ops[0]) ? evaluate_element (root->ops[0], 0) : answer;
1085         break;
1086     }
1087
1088     switch (root->func) {
1089     case Val: return op0;
1090     case Sig: return -op0;
1091     case Add: return ((mask & MASK_SUB) == 0) ? op0 + op1 : op0 - op1;
1092     case Sub: return ((mask & MASK_SUB) == 0) ? op0 - op1 : op0 + op1;
1093     case Mul: return ((mask & MASK_DIV) == 0) ? op0 * op1 : op0 / op1;
1094     case Div: return ((mask & MASK_DIV) == 0) ? op0 / op1 : op0 * op1;
1095     case Mod: return fmod (op0, op1);
1096     case Pow: return pow (op0, op1);
1097     case Sqr: return sqrt (op0);
1098     case Cos: return cos (op0);
1099     case Sin: return sin (op0);
1100     case Tan: return tan (op0);
1101     case Acos: return acos (op0);
1102     case Asin: return asin (op0);
1103     case Atan: return atan (op0);
1104     case Log: return log (op0);
1105     case Exp: return exp (op0);
1106     case Abs: return fabs (op0);
1107     case Ceil: return ceil (op0);
1108     case Floor: return floor (op0);
1109     case Store: return store ((int)op0, (op1) ? op1 : answer);
1110     case Recall: return recall ((int)op0);
1111     case Inc: return increase ((int)op0);
1112     case Dec: return decrease ((int)op0);
1113     case Disp: display (); break;
1114     case Mem: memory ((int)op0); break;
1115     case Clear: clear (); break;
1116     case Quit: quit (); break;
1117     case Help: help (); break;
1118     case Ans: return answer;
1119     case Pi: return M_PI;
1120     case E: return M_E;
1121     case Equal: return op0 == op1;
1122     case Diff: return op0 != op1;
1123     case Ge: return op0 >= op1;
1124     case Le: return op0 <= op1;
1125     case Gt: return op0 > op1;
1126     case Lt: return op0 < op1;
1127     case And: return (op0 != 0) && (op1 != 0);
1128     case Or: return (op0 != 0) || (op1 != 0);
1129     case Not: return (op0 == 0);
1130     case Cond:
1131         if ((op0) && (root->ops[1])) {
1132             return evaluate_element (root->ops[1], 0);
1133         } else if ((!op0) && (root->ops[2])) {
1134             return evaluate_element (root->ops[2], 0);
1135         } else {
1136             return 0;
1137         }
1138     case While: return while_do (root->ops[0], root->ops[1]);
1139     case Code: return execute_code (root->ops, root->nbops);
1140     case Print: return print (op0);
1141     case Prog: prog ((int)op0, (int)op1, root->ops[2]); break;
1142     case Call:
1143         for (i = 1, nb =0; i < root->nbops; i++) {
1144             if (root->ops[i]) {
1145                 nb++;
1146             }
1147         }
1148         return call ((int)op0, nb, root->ops + 1);
1149     case List: list (); break;
1150     case Edit: edit ((int)op0); break;
1151     case Del: del ((int)op0); break;
1152     }
1153
1154     return 0;
1155 }
1156
1157 char **generate_completion_list ()
1158 {
1159     int i, j, l = 0;
1160     char **list = (char **) callocordie (NB_OPERATORS + NB_FUNCTIONS + NB_CONSTANTS + NB_SYMBOLS + 1, sizeof (char *));
1161
1162     for (i = 0; i < NB_OPERATORS; i++) {
1163         list[l] = strdup ((operators + i)->keyword);
1164         for (j = 0; j < (int)strlen (list[l]); j++) {
1165             if (list[i][j] == '\t') {
1166                 list[i][j] = '\0';
1167             }
1168         }
1169         if (list[l] != NULL) {
1170             l++;
1171         }
1172     }
1173
1174     for (i = 0; i < NB_FUNCTIONS; i++) {
1175         list[l] = strdup ((functions + i)->keyword);
1176         if (list[l] != NULL) {
1177             l++;
1178         }
1179     }
1180
1181     for (i = 0; i < NB_CONSTANTS; i++) {
1182         list[l] = strdup ((constants + i)->keyword);
1183         if (list[l] != NULL) {
1184             l++;
1185         }
1186     }
1187
1188     for (i = 0; i < NB_SYMBOLS; i++) {
1189         list[l] = strdup (symbols[i]);
1190         if (list[l] != NULL) {
1191             l++;
1192         }
1193     }
1194
1195     return (list);
1196 }
1197
1198 void free_completion_list (char **list)
1199 {
1200     int i;
1201
1202     if (list) {
1203         for (i = 0; i < NB_FUNCTIONS + NB_CONSTANTS; i++) {
1204             if (list[i] != NULL) {
1205                 free (list[i]);
1206             }
1207         }
1208         free (list);
1209     }
1210 }
1211
1212
1213 /* vim: set ts=4 sw=4 et: */