parser.c

   1 #include <math.h>
   2 #include <stdio.h>
   3 #include <stdlib.h>
   4 #include <string.h>
   5
   6 #include "alloc.h"
   7 #include "argument.h"
   8 #include "debug.h"
   9 #include "element.h"
  10 #include "format.h"
  11 #include "program.h"
  12 #include "stack.h"
  13 #include "storage.h"
  14
  15 #include "parser.h"
  16
  17 /* global variables */
  18
  19 double answer = 0;
  20
  21 double anglefactor = 1;
  22
  23 /* compare codes */
  24
  25 int codecmp (char *ref, char *str)
  26 {
  27     int sig;
  28
  29     while (*ref != '\0') {
  30         if (*ref == '\t') {
  31              sig = (*str == '.') ? -1 : ((*str >= '0') && (*str <= '9'));
  32         } else {
  33             sig = *str - *ref;
  34         }
  35         if (sig != 0) {
  36             return (sig > 0) ? 1 : -1;
  37         }
  38         str++;
  39         ref++;
  40     }
  41
  42     return 0;
  43 }
  44
  45 /* functions */
  46
  47 #define MAX_ARGS 100
  48
  49 #define NB_OPERATORS 14
  50 keyword_t operators[NB_OPERATORS] = {
  51     { "+\t", Add, 2, 1, 1},
  52     { "-\t", Sub, 2, 1, 1},
  53     { "*",   Mul, 2, 1, 2},
  54     { "/",   Div, 2, 1, 2},
  55     { "%",   Mod, 2, 1, 3},
  56     { "^",   Pow, 2, 1, 4},
  57     { "==",  Equal, 2, 2, -1},
  58     { "!=",  Diff, 2, 2, -1},
  59     { ">=",  Ge, 2, 2, -1},
  60     { "<=",  Le, 2, 2, -1},
  61     { ">",   Gt, 2, 1, -1},
  62     { "<",   Lt, 2, 1, -1},
  63     { "&",   And, 2, 1, -2},
  64     { "|",   Or, 2, 1, -2}
  65 };
  66
  67 #define NB_FUNCTIONS 55
  68 keyword_t functions[NB_FUNCTIONS] = {
  69     { "sqrt", Sqr, 1, 4, 5},
  70     { "pow",  Pow, 2, 3, 5},
  71     { "cos",  Cos, 1, 3, 5},
  72     { "sin",  Sin, 1, 3, 5},
  73     { "tan",  Tan, 1, 3, 5},
  74     { "acos", Acos, 1, 4, 5},
  75     { "asin", Asin, 1, 4, 5},
  76     { "atan", Atan, 1, 4, 5},
  77     { "ln",   Ln, 1, 2, 5},
  78     { "log",  Log, 1, 3, 5},
  79     { "exp",  Exp, 1, 3, 5},
  80     { "erfc", Erfc, 1, 4, 5},
  81     { "erf",  Erf, 1, 3, 5},
  82     { "abs",  Abs, 1, 3, 5},
  83     { "floor", Floor, 1, 5, 5},
  84     { "ceil", Ceil, 1, 4, 5},
  85     { "sto",  Store, 2, 3, 5},
  86     { "rcl",  Recall, 1, 3, 5},
  87     { "inc",  Inc, 1, 3, 5},
  88     { "dec",  Dec, 1, 3, 5},
  89     { "disp", Disp, 0, 4, 9},
  90     { "mem",  Memory, 1, 3, 5},
  91     { "clr",  Clear, 0, 3, 9},
  92     { "quit", Quit, 0, 4, 9},
  93     { "help", Help, 0, 4, 9},
  94     { "!",    Not, 1, 1, 6},
  95     { "cond", Cond, 3, 4, 5},
  96     { "while", While, 2, 5, 5},
  97     { "print", Print, 1, 5, 5},
  98     { "prog", Prog, 2, 4, 9},
  99     { "arg",  Arg, 1, 3, 5},
 100     { "call", Call, MAX_ARGS, 4, 5},
 101     { "ls",   List, 0, 2, 9},
 102     { "edit", Edit, 1, 4, 9},
 103     { "del",  Del, 1, 3, 9},
 104     { "get",  Get, 1, 3, 5},
 105     { "len",  Length, 0, 3, 5},
 106     { "pop",  Pop, 0, 3, 5},
 107     { "push", Push, 1, 4, 5},
 108     { "put",  Put, 2, 3, 5},
 109     { "set",  Set, MAX_ARGS, 3, 5},
 110     { "show", Show, 0, 4, 5},
 111     { "max",  Max, 2, 3, 5},
 112     { "mean", Mean, 2, 4, 5},
 113     { "med",  Median, 0, 3, 5},
 114     { "min",  Min, 2, 3, 5},
 115     { "ord",  Order, 0, 3, 5},
 116     { "prod", Prod, 0, 4, 5},
 117     { "sum",  Sum, 0, 3, 5},
 118     { "var",  Variance, 2, 3, 5},
 119     { "format", Precision, 1, 6, 9},
 120     { "base", Base, 2, 4, 9},
 121     { "deg", Deg, 0, 3, 9},
 122     { "grad", Grad, 0, 4, 9},
 123     { "rad", Rad, 0, 3, 9}
 124 };
 125
 126 #define NB_CONSTANTS 3
 127 keyword_t constants[NB_CONSTANTS] = {
 128     { "ans", Ans, 0, 3, 5},
 129     { "e",   E, 0, 1, 5},
 130     { "pi",  Pi, 0, 2, 5}
 131 };
 132
 133 #define NB_SYMBOLS 4
 134 char *symbols[NB_SYMBOLS] = {
 135     "(", ")", "{", "}"
 136 };
 137
 138 /* subparser function */
 139
 140 element_t *subparser (element_t **proot, char **pstr, func_t func, int nbops, int prio)
 141 {
 142     element_t *new = newelement (func, nbops, prio);
 143     new->ops[0] = *proot;
 144     new->ops[1] = parser (*pstr, pstr, new->prio);
 145     if ((new->ops[1] == NULL) || ((new->ops[1] != ERROR_OP) && (new->ops[1]->prio == 9))) {
 146         delelement (new->ops[1]);
 147         new->ops[1] = ERROR_OP;
 148     }
 149     if (new->ops[1] == ERROR_OP) {
 150         delelement (new);
 151         *proot = NULL;
 152         return ERROR_OP;
 153     }
 154     *proot = newelement (Val, 1, 5);
 155     (*proot)->ops[0] = new;
 156
 157     return *proot;
 158 }
 159
 160 /* parser function */
 161
 162 element_t *parser (char *str, char **next, int prio)
 163 {
 164     element_t *root = NULL;
 165     char *string = str;
 166     int i;
 167
 168     VERBOSE (DEBUG, fprintf (stdout, "Starting parsing\n"));
 169
 170     /* main loop */
 171     while (*str != '\0') {
 172         int found = 0;
 173         element_t *new = NULL;
 174         VERBOSE (INFO, fprintf (stdout, "Processing: %s\n", str));
 175
 176         /* end without printing */
 177
 178         if (*str == ';') {
 179             if (root) {
 180                 root->hidden = 1;
 181             }
 182             break;
 183         }
 184
 185         /* skip spaces and tabs */
 186
 187         if ((*str == ' ') || (*str == '\t')) {
 188             str++;
 189             continue;
 190         }
 191
 192         /* check for open brace */
 193
 194         if (*str == '{') {
 195             VERBOSE (DEBUG, fprintf (stdout, "start processing brace\n"));
 196             if (root != NULL) {
 197                 delelement (root);
 198                 return ERROR_OP;
 199             }
 200             root = newelement (Code, 0, 5);
 201
 202             do {
 203                 new = parser (str + 1, &str, 0);
 204                 if ((new == NULL) || ((new != ERROR_OP) && (new->prio == 9))) {
 205                     delelement (new);
 206                     new = ERROR_OP;
 207                 }
 208                 if (new == ERROR_OP) {
 209                     delelement (root);
 210                     return ERROR_OP;
 211                 }
 212                 element_t *newcode = newelement (Code, root->nbops + 1, 5);
 213                 for (i = 0; i < root->nbops; i++) {
 214                     newcode->ops[i] = root->ops[i];
 215                     root->ops[i] = NULL;
 216                 }
 217                 newcode->ops[root->nbops] = new;
 218                 delelement (root);
 219                 root = newcode;
 220             } while (*str == ',');
 221
 222             if (*str != '}') {
 223                 delelement (root);
 224                 return ERROR_OP;
 225             }
 226             str++;
 227             VERBOSE (DEBUG, fprintf (stdout, "stop processing brace\n"));
 228             continue;
 229         }
 230
 231         /* check for open bracket */
 232
 233         if (*str == '(') {
 234             VERBOSE (DEBUG, fprintf (stdout, "start processing bracket\n"));
 235             if (root) {
 236                 do {
 237                     found = 0;
 238                     new = parser (str + 1, &str, 0);
 239                     if ((new == NULL) || ((new != ERROR_OP) && (new->prio == 9))) {
 240                         delelement (new);
 241                         new = ERROR_OP;
 242                     }
 243                     if ((new == NULL) || (new == ERROR_OP)) {
 244                         delelement (root);
 245                         return ERROR_OP;
 246                     }
 247                     for (i = 0; i < root->nbops; i++) {
 248                         if (root->ops[i] == NULL) {
 249                             root->ops[i] = new;
 250                             found = 1;
 251                             break;
 252                         }
 253                     }
 254                     if (!found) {
 255                         delelement (new);
 256                         delelement (root);
 257                         return ERROR_OP;
 258                     }
 259                 } while (*str == ',');
 260             } else {
 261                 root = newelement (Val, 1, 5);
 262                 new = parser (str + 1, &str, 0);
 263                 if ((new == NULL) || ((new != ERROR_OP) && (new->prio == 9))) {
 264                     delelement (new);
 265                     new = ERROR_OP;
 266                 }
 267                 if ((new == NULL) || (new == ERROR_OP) || (*str == ',')) {
 268                     delelement (new);
 269                     delelement (root);
 270                     return ERROR_OP;
 271                 }
 272                 root->ops[0] = new;
 273             }
 274             if (*str != ')') {
 275                 delelement (root);
 276                 return ERROR_OP;
 277             }
 278             str++;
 279             VERBOSE (DEBUG, fprintf (stdout, "stop processing bracket\n"));
 280             continue;
 281         }
 282
 283         /* check for closing bracket, closing brace or koma */
 284
 285         if ((*str == ')') || (*str == '}') || (*str == ',')) {
 286             if (prio == -9) {
 287                 delelement (root);
 288                 return ERROR_OP;
 289             }
 290             if (next != NULL) {
 291                 *next = str;
 292             }
 293             return root;
 294         }
 295
 296         /* look for operators */
 297
 298         for (i = 0; i < NB_OPERATORS; i++) {
 299             keyword_t *operator = operators + i;
 300             if (codecmp (operator->keyword, str) == 0) {
 301                 VERBOSE (DEBUG, fprintf (stdout, "start processing operator\n"));
 302                 if ((root) && (root->prio == 9)) {
 303                     VERBOSE (DEBUG, fprintf (stdout, "terminal function (%d)\n", root->func));
 304                     delelement (root);
 305                     return ERROR_OP;
 306                 } else if (root) {
 307                     if ((prio) && (prio > operator->prio)) {
 308                         VERBOSE (DEBUG, fprintf (stdout, "stop because operator priority\n"));
 309                         *next = str;
 310                         return root;
 311                     }
 312                     str += operator->offset;
 313                     VERBOSE (INFO, fprintf (stdout, "Oper: %d\n", operator->func));
 314                     if (subparser (&root, &str, operator->func, operator->nbops, operator->prio) == ERROR_OP) {
 315                         delelement (root);
 316                         return ERROR_OP;
 317                     }
 318                 } else if (*str == '-') {
 319                     root = newelement (Sig, 1, 6);
 320                 } else {
 321                     return ERROR_OP;
 322                 }
 323                 found = 1;
 324                 VERBOSE (DEBUG, fprintf (stdout, "stop processing operator\n"));
 325                 break;
 326             }
 327         }
 328         if (found) {
 329             continue;
 330         }
 331
 332         /* look for functions */
 333
 334         for (i = 0; i < NB_FUNCTIONS; i++) {
 335             keyword_t *function = functions + i;
 336             if (codecmp (function->keyword, str) == 0) {
 337                 VERBOSE (DEBUG, fprintf (stdout, "start processing function\n"));
 338                 if (root == NULL) {
 339                     VERBOSE (INFO, fprintf (stdout, "Func: %d\n", function->func));
 340                     root = newelement (function->func, function->nbops, function->prio);
 341                 } else {
 342                     delelement (root);
 343                     return ERROR_OP;
 344                 }
 345                 str += function->offset;
 346                 found = 1;
 347                 VERBOSE (DEBUG, fprintf (stdout, "stop processing function\n"));
 348                 break;
 349             }
 350         }
 351         if (found) {
 352             continue;
 353         }
 354
 355         /* look for constant */
 356
 357         for (i = 0; i < NB_CONSTANTS; i++) {
 358             keyword_t *constant = constants + i;
 359             if (codecmp (constant->keyword, str) == 0) {
 360                 VERBOSE (DEBUG, fprintf (stdout, "start processing constant\n"));
 361                 if (root == NULL) {
 362                     VERBOSE (INFO, fprintf (stdout, "Const: %d\n", constant->func));
 363                     root = newelement (constant->func, constant->nbops, constant->prio);
 364                 } else {
 365                     delelement (root);
 366                     return ERROR_OP;
 367                 }
 368                 str += constant->offset;
 369                 found = 1;
 370                 VERBOSE (DEBUG, fprintf (stdout, "stop processing constant\n"));
 371                 break;
 372             }
 373         }
 374         if (found) {
 375             continue;
 376         }
 377
 378         /* look for number */
 379
 380         VERBOSE (DEBUG, fprintf (stdout, "start processing value\n"));
 381         char *pt;
 382         double value = (get_ibase () == 10) ? strtod (str, &pt) : strtoul (str, &pt, get_ibase ());
 383         VERBOSE (INFO, fprintf (stdout, "Value: %f\n", value));
 384         if (str != pt) {
 385             if ((root == NULL) || (root->prio == 6)) {
 386                 new = newelement (Val, 1, 5);
 387                 new->value = value;
 388                 if (root == NULL) {
 389                     root = new;
 390                 } else {
 391                     for (i = 0; i < root->nbops; i++) {
 392                         if (root->ops[i] == NULL) {
 393                             root->ops[i] = new;
 394                             found = 1;
 395                             break;
 396                         }
 397                     }
 398                     if (!found) {
 399                         delelement (new);
 400                         delelement (root);
 401                         return ERROR_OP;
 402                     }
 403                 }
 404                 str = pt;
 405             } else if ((*str == '+') || (*str == '-')) {
 406                 if ((prio) && (prio > 1)) {
 407                     VERBOSE (DEBUG, fprintf (stdout, "stop because operator priority\n"));
 408                     *next = str;
 409                     return root;
 410                 }
 411                 if (subparser (&root, &str, Add, 2, 1) == ERROR_OP) {
 412                     delelement (root);
 413                     return ERROR_OP;
 414                 }
 415             } else {
 416                 delelement (root);
 417                 return ERROR_OP;
 418             }
 419             found = 1;
 420         }
 421         VERBOSE (DEBUG, fprintf (stdout, "stop processing value\n"));
 422
 423         /* error */
 424
 425         if (!found) {
 426             delelement (root);
 427             return ERROR_OP;
 428         }
 429
 430     }
 431
 432     if (next != NULL) {
 433         *next = str;
 434     }
 435
 436     /* save string */
 437     if (root != NULL) {
 438         root->string = string;
 439     }
 440
 441     return root;
 442 }
 443
 444 /* print element tree */
 445
 446 void print_element (element_t *root, int level)
 447 {
 448     char *func = NULL;
 449     int i;
 450
 451     if ((root == NULL) || (root == ERROR_OP)) {
 452         return;
 453     }
 454
 455     for (i = 0; i < level; i++) {
 456         printf (" ");
 457     }
 458
 459     switch (root->func) {
 460     case Val: func = "Value"; break;
 461     case Sig: func = "Sign"; break;
 462     case Add: func = "Addition"; break;
 463     case Sub: func = "Subtraction"; break;
 464     case Mul: func = "Multiplication"; break;
 465     case Div: func = "Division"; break;
 466     case Mod: func = "Modulo"; break;
 467     case Pow: func = "Power"; break;
 468     case Sqr: func = "Square Root"; break;
 469     case Cos: func = "Cosine"; break;
 470     case Sin: func = "Sine"; break;
 471     case Tan: func = "Tangent"; break;
 472     case Acos: func = "Arc Cosine"; break;
 473     case Asin: func = "Arc Sine"; break;
 474     case Atan: func = "Arc Tangent"; break;
 475     case Ln: func = "Logarithm (natural)"; break;
 476     case Log: func = "Logarithm (10 base)"; break;
 477     case Exp: func = "Exponantial"; break;
 478     case Erfc: func = "Complementary Error Function"; break;
 479     case Erf: func = "Error Function"; break;
 480     case Abs: func = "Absolute value"; break;
 481     case Ceil: func = "Ceil value"; break;
 482     case Floor: func = "Floor value"; break;
 483     case Store: func = "Store"; break;
 484     case Recall: func = "Recall"; break;
 485     case Inc: func = "Increase"; break;
 486     case Dec: func = "Decrease"; break;
 487     case Disp: func = "Display"; break;
 488     case Memory: func = "Memory"; break;
 489     case Clear: func = "Clear"; break;
 490     case Quit: func = "Quit"; break;
 491     case Help: func = "Help"; break;
 492     case Ans: func = "Ans"; break;
 493     case Pi: func = "Pi"; break;
 494     case E: func = "E"; break;
 495     case Equal: func = "Equal"; break;
 496     case Diff: func = "Different"; break;
 497     case Ge: func = "Greater or equal"; break;
 498     case Le: func = "Lesser or equal"; break;
 499     case Gt: func = "Greater"; break;
 500     case Lt: func = "Lesser"; break;
 501     case And: func = "And"; break;
 502     case Or: func = "Or"; break;
 503     case Not: func = "Not"; break;
 504     case Cond: func = "Condition"; break;
 505     case While: func = "While"; break;
 506     case Code: func = "Code"; break;
 507     case Print: func = "Print"; break;
 508     case Prog: func = "Program"; break;
 509     case Arg: func = "Argument"; break;
 510     case Call: func = "Call"; break;
 511     case List: func = "List"; break;
 512     case Edit: func = "Edit"; break;
 513     case Del: func = "Del"; break;
 514     case Get: func = "Get"; break;
 515     case Length: func = "Length"; break;
 516     case Pop: func = "Pop"; break;
 517     case Push: func = "Push"; break;
 518     case Put: func = "Put"; break;
 519     case Set: func = "Set"; break;
 520     case Show: func = "Show"; break;
 521     case Max: func = "Maximum"; break;
 522     case Mean: func = "Mean"; break;
 523     case Median: func = "Median"; break;
 524     case Min: func = "Minimum"; break;
 525     case Order: func = "Order"; break;
 526     case Prod: func = "Product"; break;
 527     case Sum: func = "Sum"; break;
 528     case Variance: func = "Variance"; break;
 529     case Precision: func = "Precision"; break;
 530     case Base: func = "Base"; break;
 531     case Deg: func = "Degree"; break;
 532     case Grad: func = "Gradian"; break;
 533     case Rad: func = "Radian"; break;
 534     }
 535
 536     printf ("Function: %s\n", func);
 537
 538     if ((root->func == Val) && (root->ops[0] == NULL)) {
 539         for (i = 0; i < level; i++) {
 540             printf (" ");
 541         }
 542         printf ("value: %f\n", root->value);
 543     } else {
 544         for (i = 0; i < root->nbops; i++) {
 545             print_element (root->ops[i], level + 1);
 546         }
 547     }
 548 }
 549
 550 /* While do function */
 551
 552 double while_do (element_t *cond, element_t *action)
 553 {
 554     double ret = 0;
 555     element_t *temp = NULL;
 556
 557     VERBOSE (DEBUG, fprintf (stdout, "starting while loop\n"));
 558     while (1) {
 559         VERBOSE (DEBUG, fprintf (stdout, "loop...\n"));
 560
 561         temp = dupelement (cond);
 562         double test = evaluate_element (temp, 0);
 563         delelement (temp);
 564         if (!test) {
 565             break;
 566         }
 567         if (action) {
 568             temp = dupelement (action);
 569             ret = evaluate_element (temp, 0);
 570             delelement (temp);
 571         }
 572     }
 573
 574     VERBOSE (DEBUG, fprintf (stdout, "ending while loop\n"));
 575
 576     return ret;
 577 }
 578
 579 /* program function */
 580
 581 double execute_code (element_t **prog, int nbcalls)
 582 {
 583     double ret = 0;
 584     int i;
 585     for (i = 0; i < nbcalls; i++) {
 586         ret = evaluate_element (prog[i], 0);
 587     }
 588     return ret;
 589 }
 590
 591 /* quit function */
 592
 593 void quit (void)
 594 {
 595     printf ("bye\n");
 596     exit (0);
 597 }
 598
 599 /* help message */
 600
 601 void help (void)
 602 {
 603     printf ("calc is a simple calculator\n\n");
 604     printf ("arithmetic op.:");
 605     printf (" + - * / %% ^\n");
 606     printf ("comparison op.:");
 607     printf (" == != >= <= > <\n");
 608     printf ("logical op.:");
 609     printf (" & | !\n");
 610     printf ("mathematic func.:");
 611     printf (" exp ln log pow sqrt\n");
 612     printf ("trigonometric func.:");
 613     printf (" acos asin atan cos sin tan\n");
 614     printf ("error functions:");
 615     printf (" erf erfc\n");
 616     printf ("miscellaneous func.:");
 617     printf (" abs ceil floor\n");
 618     printf ("storage func.:");
 619     printf (" clear dec disp inc mem rcl sto\n");
 620     printf ("control flow prim.:");
 621     printf (" cond print while {} ;\n");
 622     printf ("program management:");
 623     printf (" arg call del edit ls prog\n");
 624     printf ("stack management:");
 625     printf (" get len pop push put set show\n");
 626     printf ("stack func.:");
 627     printf (" max mean med min ord prod sum var\n");
 628     printf ("control management:");
 629     printf (" base deg format grad help quit rad\n");
 630     printf ("constants:");
 631     printf (" ans e pi\n");
 632 }
 633
 634 /* format function */
 635
 636 int format (int precision)
 637 {
 638     if (precision > 0) {
 639         set_precision (precision);
 640         set_format ();
 641     } else if (precision != -1) {
 642         VERBOSE (WARNING, fprintf (stdout, "error incorrect precision (%d)\n", precision));
 643         return 0;
 644     }
 645     return get_precision ();
 646 }
 647
 648 /* base function */
 649
 650 void base (int in, int out)
 651 {
 652     if ((in > 0) && (in < 37)) {
 653         set_base (in, in);
 654         if ((out > 0) && (out < 37)) {
 655             set_base (in, out);
 656         } else if (out != - 1) {
 657             VERBOSE (WARNING, fprintf (stdout, "error incorrect output base (%d)\n", out));
 658         }
 659     } else if (in != -1 ) {
 660         VERBOSE (WARNING, fprintf (stdout, "error incorrect input base (%d)\n", in));
 661     } else {
 662         printf ("base (I/O): %s\n", show_base ());
 663     }
 664 }
 665
 666 /* evaluate element tree */
 667
 668 #define MASK_SUB 0x1
 669 #define MASK_DIV 0x2
 670
 671 double evaluate_element (element_t *root, char mask)
 672 {
 673     double op0 = 0, op1 = 0;
 674     char nextmask = mask;
 675     int i, nb;
 676
 677     if ((root == NULL) || (root == ERROR_OP)) {
 678         VERBOSE (WARNING, fprintf (stdout, "error while evaluating\n"));
 679         return 0;
 680     }
 681
 682     /* mask to manage sub operator sub and div */
 683     switch (root->func) {
 684     case Add:
 685         nextmask &= ~MASK_SUB;
 686         nextmask &= ~MASK_DIV;
 687         break;
 688     case Sub:
 689         nextmask |= MASK_SUB;
 690         nextmask &= ~MASK_DIV;
 691         break;
 692     case Mul:
 693         nextmask &= ~MASK_DIV;
 694         break;
 695     case Div:
 696         nextmask |= MASK_DIV;
 697         break;
 698     default:
 699         nextmask = mask;
 700     }
 701
 702     switch (root->func) {
 703     case Val:
 704     case Sig:
 705         op0 = (root->ops[0]) ? evaluate_element (root->ops[0], nextmask) : root->value;
 706         break;
 707     case Add:
 708     case Sub:
 709     case Mul:
 710     case Div:
 711     case Mod:
 712     case Pow:
 713     case Equal:
 714     case Diff:
 715     case Ge:
 716     case Le:
 717     case Gt:
 718     case Lt:
 719     case And:
 720     case Or:
 721         if (root->ops[1]) {
 722             op1 = evaluate_element (root->ops[1], nextmask);
 723         } else {
 724             VERBOSE (WARNING, fprintf (stdout, "error while evaluating (op[1])\n"));
 725             return 0;
 726         }
 727         /* fallthrough */
 728     case Sqr:
 729     case Cos:
 730     case Sin:
 731     case Tan:
 732     case Acos:
 733     case Asin:
 734     case Atan:
 735     case Ln:
 736     case Log:
 737     case Exp:
 738     case Erfc:
 739     case Erf:
 740     case Abs:
 741     case Ceil:
 742     case Floor:
 743     case Recall:
 744     case Inc:
 745     case Dec:
 746     case Not:
 747     case Cond:
 748     case Prog:
 749     case Arg:
 750     case Call:
 751     case Edit:
 752     case Del:
 753     case Get:
 754         if (root->ops[0]) {
 755             op0 = evaluate_element (root->ops[0], 0);
 756         } else {
 757             VERBOSE (WARNING, fprintf (stdout, "error while evaluating (op[0])\n"));
 758             return 0;
 759         }
 760         break;
 761     case Disp:
 762     case Clear:
 763     case Quit:
 764     case Help:
 765     case Ans:
 766     case Pi:
 767     case E:
 768     case Code:
 769     case List:
 770     case Length:
 771     case Pop:
 772     case Set:
 773     case Show:
 774     case Median:
 775     case Order:
 776     case Prod:
 777     case Sum:
 778     case Deg:
 779     case Grad:
 780     case Rad:
 781         break;
 782     case While:
 783         if (root->ops[0] == NULL) {
 784             VERBOSE (WARNING, fprintf (stdout, "error while evaluating (op[0])\n"));
 785             return 0;
 786         }
 787         break;
 788     case Memory:
 789         if (root->ops[0] == NULL) {
 790             op0 = -1;
 791         } else {
 792             op0 = (int)evaluate_element (root->ops[0], 0);
 793             if (op0 < 0) {
 794                 VERBOSE (WARNING, fprintf (stdout, "error incorrect memory size (%d)\n", (int)op0));
 795                 return 0;
 796             }
 797         }
 798         break;
 799     case Push:
 800     case Print:
 801         op0 = (root->ops[0]) ? evaluate_element (root->ops[0], 0) : answer;
 802         break;
 803     case Store:
 804     case Put:
 805         if (root->ops[0]) {
 806             op0 = evaluate_element (root->ops[0], 0);
 807         } else {
 808             VERBOSE (WARNING, fprintf (stdout, "error while evaluating (op[0])\n"));
 809             return 0;
 810         }
 811         op1 = (root->ops[1]) ? evaluate_element (root->ops[1], 0) : answer;
 812         break;
 813     case Max:
 814     case Mean:
 815     case Min:
 816     case Variance:
 817         if (root->ops[0]) {
 818             op0 = evaluate_element (root->ops[0], 0);
 819             op1 = (root->ops[1]) ? evaluate_element (root->ops[1], 0) : answer;
 820         }
 821         break;
 822     case Precision:
 823         op0 = (root->ops[0]) ? evaluate_element (root->ops[0], 0) : -1;
 824         break;
 825     case Base:
 826         op0 = (root->ops[0]) ? evaluate_element (root->ops[0], 0) : -1;
 827         op1 = (root->ops[1]) ? evaluate_element (root->ops[1], 0) : -1;
 828         break;
 829     }
 830
 831     switch (root->func) {
 832     case Val: return op0;
 833     case Sig: return -op0;
 834     case Add: return ((mask & MASK_SUB) == 0) ? op0 + op1 : op0 - op1;
 835     case Sub: return ((mask & MASK_SUB) == 0) ? op0 - op1 : op0 + op1;
 836     case Mul: return ((mask & MASK_DIV) == 0) ? op0 * op1 : op0 / op1;
 837     case Div: return ((mask & MASK_DIV) == 0) ? op0 / op1 : op0 * op1;
 838     case Mod: return fmod (op0, op1);
 839     case Pow: return pow (op0, op1);
 840     case Sqr: return sqrt (op0);
 841     case Cos: return cos (op0 / anglefactor);
 842     case Sin: return sin (op0 / anglefactor);
 843     case Tan: return tan (op0 / anglefactor);
 844     case Acos: return acos (op0) * anglefactor;
 845     case Asin: return asin (op0) * anglefactor;
 846     case Atan: return atan (op0) * anglefactor;
 847     case Ln: return log (op0);
 848     case Log: return log10 (op0);
 849     case Exp: return exp (op0);
 850     case Erfc: return erfc (op0);
 851     case Erf: return erf (op0);
 852     case Abs: return fabs (op0);
 853     case Ceil: return ceil (op0);
 854     case Floor: return floor (op0);
 855     case Store: return store ((int)op0, op1);
 856     case Recall: return recall ((int)op0);
 857     case Inc: return increase ((int)op0);
 858     case Dec: return decrease ((int)op0);
 859     case Disp: display (); break;
 860     case Memory: return memory ((root->ops[0]) ? (int)op0 : -1);
 861     case Clear: clear (); break;
 862     case Quit: quit (); break;
 863     case Help: help (); break;
 864     case Ans: return answer;
 865     case Pi: return M_PI;
 866     case E: return M_E;
 867     case Equal: return op0 == op1;
 868     case Diff: return op0 != op1;
 869     case Ge: return op0 >= op1;
 870     case Le: return op0 <= op1;
 871     case Gt: return op0 > op1;
 872     case Lt: return op0 < op1;
 873     case And: return (op0 != 0) && (op1 != 0);
 874     case Or: return (op0 != 0) || (op1 != 0);
 875     case Not: return (op0 == 0);
 876     case Cond:
 877         if ((op0) && (root->ops[1])) {
 878             return evaluate_element (root->ops[1], 0);
 879         } else if ((!op0) && (root->ops[2])) {
 880             return evaluate_element (root->ops[2], 0);
 881         } else {
 882             return 0;
 883         }
 884     case While: return while_do (root->ops[0], root->ops[1]);
 885     case Code: return execute_code (root->ops, root->nbops);
 886     case Print: return print (op0);
 887     case Prog:
 888         prog ((int)op0, root->ops[1]);
 889         savestring ((int)op0, root->string);
 890         break;
 891     case Arg: return arg ((int)op0);
 892     case Call:
 893         for (i = 1, nb = 0; i < root->nbops; i++) {
 894             if (root->ops[i]) {
 895                 nb++;
 896             }
 897         }
 898         return call ((int)op0, nb, root->ops + 1);
 899     case List: list (); break;
 900     case Edit: edit ((int)op0); break;
 901     case Del: del ((int)op0); break;
 902     case Get: return get ((int)op0);
 903     case Length: return length ();
 904     case Pop: return pop ();
 905     case Push: return push (op0);
 906     case Put: return put ((int)op0, op1);
 907     case Set:
 908         for (i = 0, nb =0; i < root->nbops; i++) {
 909             if (root->ops[i]) {
 910                 nb++;
 911             }
 912         }
 913         return set (nb, root->ops);
 914     case Show: show (); break;
 915     case Max:
 916         if (root->ops[0]) {
 917             return op0 > op1 ? op0 : op1;
 918         }
 919         return max ();
 920     case Mean:
 921         if (root->ops[0]) {
 922             return (op0 + op1) / 2;
 923         }
 924         return mean ();
 925     case Median: return median ();
 926     case Min:
 927         if (root->ops[0]) {
 928             return op0 < op1 ? op0 : op1;
 929         }
 930         return min ();
 931     case Order: order (); break;
 932     case Prod: return prod ();
 933     case Sum: return sum ();
 934     case Variance:
 935         if (root->ops[0]) {
 936             double m = (op0 + op1) / 2;
 937             op0 -= m;
 938             op1 -= m;
 939             return op0 * op0 + op1 * op1;
 940         }
 941         return variance ();
 942     case Precision:
 943         return format ((int)op0);
 944     case Base:
 945         base ((int)op0, (int)op1);
 946         break;
 947     case Deg:
 948         anglefactor = 180 / M_PI;
 949         break;
 950     case Grad:
 951         anglefactor = 200 / M_PI;
 952         break;
 953     case Rad:
 954         anglefactor = 1;
 955         break;
 956     }
 957
 958     return 0;
 959 }
 960
 961 char **generate_completion_list ()
 962 {
 963     int i, j, l = 0;
 964     char **list = (char **) callocordie (NB_OPERATORS + NB_FUNCTIONS + NB_CONSTANTS + NB_SYMBOLS + 1, sizeof (char *));
 965
 966     for (i = 0; i < NB_OPERATORS; i++) {
 967         list[l] = strdup ((operators + i)->keyword);
 968         for (j = 0; j < (int)strlen (list[l]); j++) {
 969             if (list[i][j] == '\t') {
 970                 list[i][j] = '\0';
 971             }
 972         }
 973         if (list[l] != NULL) {
 974             l++;
 975         }
 976     }
 977
 978     for (i = 0; i < NB_FUNCTIONS; i++) {
 979         list[l] = strdup ((functions + i)->keyword);
 980         if (list[l] != NULL) {
 981             l++;
 982         }
 983     }
 984
 985     for (i = 0; i < NB_CONSTANTS; i++) {
 986         list[l] = strdup ((constants + i)->keyword);
 987         if (list[l] != NULL) {
 988             l++;
 989         }
 990     }
 991
 992     for (i = 0; i < NB_SYMBOLS; i++) {
 993         list[l] = strdup (symbols[i]);
 994         if (list[l] != NULL) {
 995             l++;
 996         }
 997     }
 998
 999     return (list);
1000 }
1001
1002 void free_completion_list (char **list)
1003 {
1004     int i;
1005
1006     if (list) {
1007         for (i = 0; i < NB_OPERATORS + NB_FUNCTIONS + NB_CONSTANTS + NB_SYMBOLS + 1; i++) {
1008             if (list[i] != NULL) {
1009                 free (list[i]);
1010             }
1011         }
1012         free (list);
1013     }
1014 }
1015
1016 /* vim: set ts=4 sw=4 et: */