home *** CD-ROM | disk | FTP | other *** search
/ Gold Fish 1 / GoldFishApril1994_CD2.img / d4xx / d472 / icalc / src / symbol.c < prev    next >
C/C++ Source or Header  |  1991-04-17  |  2KB  |  117 lines
  1. /*
  2. *    symbol-table management routines for complex-number expression parser.
  3. *    MWS, March 17, 1991.
  4. */
  5. #include <stdio.h>
  6. #include <string.h>
  7. #include <stdlib.h>
  8. #include "memory.h"
  9. #include "complex.h"
  10. #include "complex.tab.h"
  11.  
  12. extern void cprin(FILE *, char *prefix, char *suffix, Complex z);
  13.  
  14. /* Prototypes for static functions defined in symbol.c */
  15. static void insert(Symbol **tree, Symbol *item);
  16. static void traverse(Symbol *tree, short type, void (*visit)(Symbol *));
  17. static void printval(Symbol *item);
  18. static void printname(Symbol *item);
  19.  
  20. static Symbol    *symtree = NULL;    /* symbol table: binary tree */
  21.  
  22. Symbol *lookup(s)            /* find s in symbol table */
  23.     char *s;
  24. {
  25.     Symbol *sp = symtree;
  26.     int cmp;
  27.  
  28.     while (sp)
  29.     {
  30.         cmp = strcmp(s, sp->name);
  31.         if (cmp == 0)
  32.             break;
  33.         else if (cmp < 0)
  34.             sp = sp->left;
  35.         else  /* cmp > 0 */
  36.             sp = sp->right;
  37.     }
  38.  
  39.     return sp;
  40. }
  41.  
  42. static void insert(tree, item)        /* no duplicate names permitted... */
  43.     Symbol **tree, *item;
  44. {
  45.     if (*tree == NULL)
  46.     {
  47.         *tree = item;
  48.         item->left = item->right = NULL;
  49.     }
  50.     else if (strcmp(item->name, (*tree)->name) < 0)
  51.         insert(&(*tree)->left, item);
  52.     else
  53.         insert(&(*tree)->right, item);
  54. }
  55.  
  56. Symbol *allocsym(s, t)            /* allocate a symbol */
  57.     char *s;
  58.     int t;
  59. {
  60.     Symbol *sp;
  61.     
  62.     sp = (Symbol *) emalloc(sizeof(Symbol));
  63.     sp->name = emalloc(strlen(s)+1);
  64.     strcpy(sp->name, s);
  65.     sp->type = t;
  66.  
  67.     return sp;
  68. }
  69.  
  70. Symbol *install(s, t, cval)        /* install s in symbol table */
  71.     char *s;
  72.     int t;
  73.     Complex cval;
  74. {
  75.     Symbol *sp = allocsym(s, t);
  76.     sp->u.val = cval;
  77.  
  78.     insert(&symtree, sp);
  79.     return sp;
  80. }
  81.  
  82. static void traverse(tree, type, visit)    /* inorder traversal of tree */
  83.     Symbol *tree;
  84.     short type;
  85.     void (*visit)(struct Symbol *);
  86. {
  87.     if (tree)
  88.     {
  89.         traverse(tree->left, type, visit);
  90.         if (tree->type == type)
  91.             (*visit)(tree);
  92.         traverse(tree->right, type, visit);
  93.     }
  94. }
  95.  
  96. static void printval(item)
  97.     Symbol *item;
  98. {
  99.     fprintf(stdout, "\t%s\t= ", item->name);
  100.     cprin(stdout, NULL, "\n", item->u.val);
  101. }
  102.  
  103. static void printname(item)
  104.     Symbol *item;
  105. {
  106.     fprintf(stdout,"\t%s\n", item->name);
  107. }
  108.  
  109. void printlist(type)        /* print names of symbols with given type */
  110.     int type;        /* simple-minded at moment */
  111. {
  112.     if (type == CONST || type == VAR)
  113.         traverse(symtree, type, printval);
  114.     else
  115.         traverse(symtree, type, printname);
  116. }
  117.