home *** CD-ROM | disk | FTP | other *** search
/ Gold Fish 1 / GoldFishApril1994_CD2.img / d4xx / d472 / icalc / src / tree.c < prev   
C/C++ Source or Header  |  1991-04-17  |  3KB  |  154 lines
  1. /*
  2. *    tree creation, deletion and evaluation routines for complex-number
  3. *    parser.
  4. *
  5. *    MWS, March 20, 1991.
  6. */
  7.  
  8. #include <string.h>
  9. #include <stdlib.h>
  10. #include <math.h>
  11. #include "memory.h"
  12. #include "complex.h"
  13. #include "complex.tab.h"
  14.  
  15. #define    allocnode()    rem_malloc(sizeof(Node))
  16.  
  17. Node *n_asgn(sym, arg)            /* node for assignment operator */
  18.     Symbol *sym;
  19.     Node *arg;
  20. {
  21.     Node *n = allocnode();
  22.  
  23.     n->type = '=';
  24.     n->contents.sym = sym;
  25.     n->left = arg;
  26.     n->right = NULL;
  27.  
  28.     return n;
  29. }
  30.  
  31. Node *n_binop(op, left, right)        /* node for binary operator */
  32.     int op;
  33.     Node *left, *right;
  34. {
  35.     Node *n = allocnode();
  36.  
  37.     n->type = op;
  38.     n->left = left;
  39.     n->right = right;
  40.  
  41.     return n;
  42. }
  43.  
  44. Node *n_unop(op, arg)            /* node for unary operator */
  45.     int op;
  46.     Node *arg;
  47. {
  48.     Node *n = allocnode();
  49.  
  50.     n->type = op;
  51.     n->left = arg;
  52.     n->right = NULL;
  53.  
  54.     return n;
  55. }
  56.  
  57. Node *n_func(type, sym, arg)        /* node for function */
  58.     int type;
  59.     Symbol *sym;
  60.     Node *arg;
  61. {
  62.     Node *n = allocnode();
  63.  
  64.     n->type = type;
  65.     n->contents.sym = sym;
  66.     n->left = arg;
  67.     n->right = NULL;
  68.  
  69.     return n;
  70. }
  71.  
  72. Node *n_symbol(type, sym)        /* node for symbol - VAR or CONST */
  73.     int type;
  74.     Symbol *sym;
  75. {
  76.     Node *n = allocnode();
  77.  
  78.     n->type = type;
  79.     n->contents.sym = sym;
  80.     n->left = NULL;
  81.     n->right = NULL;
  82.  
  83.     return n;
  84. }
  85.  
  86. Node *n_number(real, imag)    /* node for number */
  87.     double real, imag;
  88. {
  89.     Node *n = allocnode();
  90.  
  91.     n->type = NUMBER;
  92.     n->contents.val.real = real;
  93.     n->contents.val.imag = imag;
  94.     n->left = NULL;
  95.     n->right = NULL;
  96.  
  97.     return n;
  98. }
  99.  
  100. Complex eval_tree(n)        /* evaluate the complex value of a tree */
  101.     Node *n;
  102. {
  103.     switch (n->type)
  104.     {
  105.     case NUMBER:    return n->contents.val;
  106.  
  107.     case C_BLTIN:    return (*(n->contents.sym->u.cptr))(eval_tree(n->left));
  108.  
  109.     case R_BLTIN: {    Complex rv;
  110.             rv.real = (*(n->contents.sym->u.rptr))(eval_tree(n->left));
  111.             rv.imag = 0.0;
  112.             return rv;
  113.               }
  114.  
  115.     case UFUNC:   { UserFunc *uf = &n->contents.sym->u.ufunc;
  116.             uf->param->u.val = eval_tree(n->left);
  117.             return eval_tree(uf->tree);
  118.               }
  119.  
  120.     case VAR:
  121.     case PARAMETER:
  122.     case CONST:    return n->contents.sym->u.val;
  123.  
  124.     case '+':    return cadd(eval_tree(n->left), eval_tree(n->right));
  125.     case '-':    return csub(eval_tree(n->left), eval_tree(n->right));
  126.     case '*':    return cmul(eval_tree(n->left), eval_tree(n->right));
  127.     case '/':    return cdiv(eval_tree(n->left), eval_tree(n->right));
  128.     case '^':    return cpow(eval_tree(n->left), eval_tree(n->right));
  129.  
  130.     case '(':    return eval_tree(n->left);
  131.     case UMINUS:    return cneg(eval_tree(n->left));
  132.     case '\'':    return conj(eval_tree(n->left));
  133.  
  134.     case '=':    return n->contents.sym->u.val = eval_tree(n->left);
  135.  
  136.     default:    /* should NEVER see this... */
  137.             execerror("internal - unknown node-type", NULL);
  138.     }
  139. }
  140.  
  141. /* delete all nodes of a tree */
  142. /* not used in current implementation */
  143. /********
  144. void delete_tree(n)
  145.     Node *n;
  146. {
  147.     if (n)
  148.     {
  149.         delete_tree(n->left);
  150.         delete_tree(n->right);
  151.         free(n);
  152.     }
  153. }
  154. ********/