home *** CD-ROM | disk | FTP | other *** search
/ ftp.parl.clemson.edu / 2015-02-07.ftp.parl.clemson.edu.tar / ftp.parl.clemson.edu / pub / coven / coven-utils-1.1.tgz / coven-utils-1.1.tar / utils / coven-module-parser / symbol.c < prev    next >
C/C++ Source or Header  |  2003-01-28  |  5KB  |  257 lines
  1. /*
  2.  * (C) 2001 Clemson University
  3.  *
  4.  * See COPYING in top-level directory.
  5.  */
  6.  
  7.  
  8. #ifndef lint
  9. static char symbol_c_rcsid[] = "$Header: /projects/cvsroot/coven-module-parser/symbol.c,v 1.3 2003/01/28 14:53:35 ndebard Exp $";
  10. #endif
  11.  
  12. /*
  13. *    symbol --- symbol table and mapping routines
  14. */
  15.  
  16. #include <stdio.h>
  17. #include "symbol.h"
  18. #include "stringtbl.h"
  19. #include "y.tab.h"
  20. extern int line;
  21.  
  22. /*
  23.  *    MAXHASH --- determines the hash table width.
  24.  *    symtab --- the symbol table structure
  25.  */
  26.  
  27. #define MAXHASH    311
  28.  
  29. static sym_ent_p symtab[MAXHASH];
  30.  
  31. /*
  32.  *    external routine declarations
  33.  */
  34.  
  35. int strcmp();
  36.  
  37. /*
  38.  *    hash --- scramble a name (hopefully) uniformly to fit in a table
  39.  */
  40. static unsigned int hash(char *name)
  41. {
  42.     register unsigned int h = 0;
  43.     while (*name)
  44.     {
  45.         h <<= 4;
  46.         h ^= *name++;
  47.     }
  48.     return(h % MAXHASH);
  49. }
  50.  
  51. /*
  52.  *    symenter --- enter a name into the symbol table
  53.  */
  54. sym_ent_p symenter(char *name, sym_ent_p context, int type)
  55. {
  56.     register sym_ent_p p;
  57.     unsigned int h;
  58.  
  59.     /* first check for conflicts */
  60.     p = symlook(name, context, type);
  61.     if(p != NULL) {
  62.         yyerror("Symbol name conflict when adding name to symbol table.");
  63.         exit(1);
  64.     }
  65.  
  66.     if(type == TYPE_TYPE || 
  67.        type == TYPE_VARIABLE || 
  68.        (context == NULL && type == TYPE_MODULE)
  69.       ) 
  70.     {
  71.         /* create an entry and insert it at the front of the table */
  72.         h = hash(name);
  73.         p = (sym_ent_p)emalloc(sizeof(sym_ent));
  74.         p->name = name;
  75.         p->next = symtab[h];
  76.         p->type = type;
  77.         switch(type) {
  78.           case TYPE_MODULE:
  79.             p->value.mod = (module_ent_p)emalloc(sizeof(module_ent));
  80.             p->value.mod->args = NULL;
  81.         break;
  82.           case TYPE_VARIABLE:
  83.         p->value.var = (variable_ent_p)emalloc(sizeof(variable_ent));
  84.         break;
  85.           case TYPE_TYPE:
  86.         /* we don't do anything here, yet */
  87.         break;
  88.         }
  89.         symtab[h] = p;
  90.     }
  91.     else {
  92.         p = (sym_ent_p)emalloc(sizeof(sym_ent));
  93.         p->name = name;
  94.         p->next = NULL;
  95.         p->type = type;
  96.     }
  97.  
  98.     return(p);
  99. }
  100.  
  101. /*
  102.  *    symlook --- lookup a symbol in the symbol table
  103.  *
  104.  *        symlook scans the symbol table and returns a pointer to
  105.  *        the symbol table entry
  106.  */
  107. sym_ent_p symlook(char *name, sym_ent_p context, int type)
  108. {
  109.     register sym_ent_p p;
  110.     unsigned int h;
  111.     
  112.     if(context == NULL) {
  113.         h = hash(name);
  114.         for (p = symtab[h]; p != 0; p = p->next)
  115.         if(strcmp(p->name, name) == 0)
  116.             break;
  117.     }
  118.     else {
  119.         if(type == TYPE_MODULE)
  120.             p = context->value.mod->args;
  121.         else
  122.                p = context;
  123.         while(p != NULL) {
  124.             if(strcmp(p->name, name) == 0)
  125.             break;
  126.             p = p->next;
  127.         }
  128.     }
  129.  
  130.     return(p);
  131. }
  132.  
  133. sym_ent_p lookup_type(char *name)
  134. {
  135.     sym_ent_p p;
  136.     p = symlook(name, NULL, TYPE_TYPE);
  137.     if(p != NULL && p->type == TYPE_TYPE) return p;
  138.     return NULL;
  139. }
  140.  
  141. void init_symbol_table()
  142. {
  143.     bzero(symtab, MAXHASH * sizeof(sym_ent_p));
  144. }
  145.  
  146. void sym_print (sym_ent_p sym, char *prepend)
  147. {
  148. #if 0
  149.       printf(prepend);
  150.     printf("SYMBOL [%s]\n", sym->name);
  151.     switch(sym->type) {
  152.       case TYPE_MODULE:
  153.            printf(prepend);
  154.         printf("\ttype: MODULE\n");
  155.            printf(prepend);
  156.         printf("\tmodule path: %s\n", sym->value.mod->path);
  157.         {
  158.             sym_ent_p cur = sym->value.mod->args;
  159.         while(cur != NULL) {
  160.             sym_print(cur, "\t");
  161.             cur = cur->next;
  162.         }
  163.         }
  164.         break;
  165.       case TYPE_VARIABLE:
  166.            printf(prepend);
  167.         printf("\ttype: VARIABLE\n");
  168.         switch(sym->value.var->vclass) {
  169.           case BUFFER:
  170.                printf(prepend);
  171.         printf("\tclass: BUFFER\n");
  172.         break;
  173.           case PARAMETER:
  174.                printf(prepend);
  175.         printf("\tclass: PARAMETER\n");
  176.         break;
  177.           case -1:
  178.         printf(prepend);
  179.         printf("\tclass: NONE DEFINED\n");
  180.         break;
  181.           default:
  182.                printf(prepend);
  183.         printf("\tclass: * UNDEFINED * ERROR!\n");
  184.         break;
  185.         }
  186.         printf(prepend);
  187.         printf("\ttype: %s\n", sym->value.var->type->name);
  188.         break;
  189.       case TYPE_TYPE:
  190.         printf(prepend);
  191.         printf("\ttype: TYPE\n");
  192.         break;
  193.       case TYPE_ARGUMENT:
  194.            printf(prepend);
  195.         printf("\ttype: ARGUMENT\n");
  196.         switch(sym->value.arg->direction) {
  197.           case INPUT:
  198.                printf(prepend);
  199.           printf("\tdirection: INPUT\n");
  200.         break;
  201.           case OUTPUT:
  202.                printf(prepend);
  203.         printf("\tdirection: OUTPUT\n");
  204.         break;
  205.           case INOUT:
  206.                printf(prepend);
  207.         printf("\tdirection: INOUT\n");
  208.         break;
  209.           case STATIC:
  210.                printf(prepend);
  211.         printf("\tdirection: STATIC\n");
  212.         break;
  213.           default:
  214.                printf(prepend);
  215.         printf("\tdirection: * UNDEFINED * ERROR!\n");
  216.         break;
  217.         }
  218.         switch(sym->value.arg->mclass) {
  219.           case BUFFER:
  220.                printf(prepend);
  221.         printf("\tclass: BUFFER\n");
  222.         break;
  223.           case PARAMETER:
  224.                printf(prepend);
  225.         printf("\tclass: PARAMETER\n");
  226.         break;
  227.           default:
  228.                printf(prepend);
  229.         printf("\tclass: * UNDEFINED * ERROR!\n");
  230.         break;
  231.         }
  232.            printf(prepend);
  233.         printf("\ttype: %s\n", sym->value.arg->type->name);
  234.         break;
  235.       default:
  236.            printf(prepend);
  237.         printf("\ttype: * UNDEFINED * ERROR!\n");
  238.         break;
  239.     }
  240. #endif
  241. }
  242.  
  243. void symtab_print(void)
  244. {
  245.     int i;
  246.        for(i=0; i<MAXHASH; i++) {
  247.         sym_ent_p cur = symtab[i];
  248.         if(cur != NULL)
  249.             printf("*** [ HASH VALUE ] *** %d\n", i);
  250.         while(cur != NULL) {
  251.            sym_print(cur, "");
  252.            cur = cur->next;
  253.         }
  254.     }
  255. }
  256.  
  257.