fish/icalc/symbol.c

   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(Symbol *tree,short type, void (*visit)(Symbol *))  /* inorder traversal of tree */
  83 {
  84         if (tree)
  85         {
  86                 traverse(tree->left, type, visit);
  87                 if (tree->type == type)
  88                         (*visit)(tree);
  89                 traverse(tree->right, type, visit);
  90         }
  91 }
  92
  93 static void printval(item)
  94         Symbol *item;
  95 {
  96         fprintf(stdout, "\t%s\t= ", item->name);
  97         cprin(stdout, NULL, "\n", item->u.val);
  98 }
  99
 100 static void printname(item)
 101         Symbol *item;
 102 {
 103         fprintf(stdout,"\t%s\n", item->name);
 104 }
 105
 106 void printlist(type)            /* print names of symbols with given type */
 107         int type;               /* simple-minded at moment */
 108 {
 109         if (type == CONST || type == VAR)
 110                 traverse(symtree, type, printval);
 111         else
 112                 traverse(symtree, type, printname);
 113 }