Advertisement
Guest User

Untitled

a guest
Jun 2nd, 2017
50
0
Never
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
  1. #include <string.h>
  2. #include <stdlib.h>
  3. #include <stdio.h>
  4. #include "symbol_table.h"
  5.  
  6. struct symbol_t *new_table(void) {
  7.     return (struct symbol_t *)NULL;
  8. }
  9.  
  10. struct symbol_t *clone_table(struct symbol_t *table) {
  11.     struct symbol_t *element;
  12.     struct symbol_t *new_tablex;
  13.  
  14.     element=table;
  15.     new_tablex=new_table();
  16.     while((struct symbol_t *)NULL!=element) {
  17.         /* check return value */
  18.         new_tablex=table_add_symbol(new_tablex,element->identifier,element->type,0);
  19.         element=element->next;
  20.     }
  21.  
  22.     return new_tablex;
  23. }
  24.  
  25. struct symbol_t *table_add_symbol(struct symbol_t *table, char *identifier, short type, short check) {
  26.     struct symbol_t *element;
  27.     struct symbol_t *new_element;
  28.  
  29.     if(table_lookup(table,identifier,type)!=(struct symbol_t *)NULL) {
  30.         if(check) {
  31.             fprintf(stderr,"Duplicate field %s.\n",identifier);
  32.             exit(3);
  33.         }
  34.        
  35.         table=table_remove_symbol(table,identifier);
  36.     }
  37.    
  38.     new_element=(struct symbol_t *)malloc(sizeof(struct symbol_t));
  39.     new_element->next=(struct symbol_t *)NULL;
  40.     new_element->identifier=strdup(identifier);
  41.     new_element->type=type;
  42.  
  43.     if((struct symbol_t *)NULL==table) {
  44.         return new_element;
  45.     }
  46.     element=table;
  47.  
  48.     while((struct symbol_t *)NULL!=element->next) {
  49.         element=element->next;
  50.     }
  51.  
  52.     element->next=new_element;
  53.    
  54.     return table;
  55. }
  56.  
  57. struct symbol_t *table_lookup(struct symbol_t *table, char *identifier,short sType) {
  58.     struct symbol_t *element;
  59.  
  60.     element=table;
  61.  
  62.     if((struct symbol_t *)NULL==table) {
  63.         return (struct symbol_t *)NULL;
  64.     }
  65.    
  66.     if(strcmp(element->identifier,identifier)==0 && element->type == sType) {
  67.         return element;
  68.     }
  69.    
  70.     while((struct symbol_t *)NULL!=element->next) {
  71.         element=element->next;
  72.         if(strcmp(element->identifier,identifier)==0 && element->type == sType ) {
  73.             return element;
  74.         }
  75.     }
  76.  
  77.     return (struct symbol_t *)NULL;
  78. }
  79.  
  80. struct symbol_t *table_merge(struct symbol_t *table, struct symbol_t *to_add, short check) {
  81.     struct symbol_t *element;
  82.     struct symbol_t *new_table=clone_table(table);
  83.    
  84.     element=to_add;
  85.     while(element!=(struct symbol_t *)NULL) {
  86.         new_table=table_add_symbol(new_table,element->identifier,element->type,check);
  87.         element=element->next;
  88.     }
  89.  
  90.     return new_table;
  91. }
  92.  
  93. struct symbol_t *table_remove_symbol(struct symbol_t *table, char *identifier) {
  94.     struct symbol_t *element;
  95.     struct symbol_t *previous_element;
  96.     struct symbol_t *new_element;
  97.  
  98.     if((struct symbol_t *)NULL==table) {
  99.         return table;
  100.     }
  101.  
  102.     previous_element=(struct symbol_t *)NULL;
  103.     element=table;
  104.  
  105.     while((struct symbol_t *)NULL!=element) {
  106.         if(strcmp(element->identifier,identifier)==0) {
  107.             if((struct symbol_t *)NULL==previous_element) {
  108.                 new_element=element->next;
  109.             }
  110.             else {
  111.                 previous_element->next=element->next;
  112.                 new_element=table;
  113.             }
  114.             (void)free(element->identifier);
  115.             (void)free(element);
  116.             return new_element;
  117.         }
  118.         previous_element=element;
  119.         element=element->next;
  120.     }
  121.  
  122.     return table;
  123. }
  124.  
  125. void check_variable(struct symbol_t *table, char *identifier) {
  126.     struct symbol_t *element=table_lookup(table,identifier,SYMBOL_TYPE_VAR);
  127.     if(element!=(struct symbol_t *)NULL) {
  128.         if(element->type!=SYMBOL_TYPE_VAR) {
  129.             fprintf(stderr,"Identifier %s not a variable.\n",identifier);
  130.             exit(3);
  131.         }
  132.     }
  133.     else {
  134.         if( table_lookup( table,identifier, SYMBOL_TYPE_FIELD ) == ( struct symbol_t *)0 ){
  135.         fprintf(stderr,"Unknown identifier (variable) %s.\n",identifier);
  136.         exit(3);
  137.         }
  138.     }
  139. }
  140.  
  141. void check_field(struct symbol_t *table, char *identifier) {
  142.     struct symbol_t *element=table_lookup(table,identifier,SYMBOL_TYPE_FIELD);
  143.     if(element!=(struct symbol_t *)NULL) {
  144.         if(element->type!=SYMBOL_TYPE_FIELD) {
  145.             fprintf(stderr,"Identifier %s not a field.\n",identifier);
  146.             exit(3);
  147.         }
  148.     }
  149.     else {
  150.         fprintf(stderr,"Unknown identifier (field) %s.\n",identifier);
  151.         exit(3);
  152.     }
  153. }
Advertisement
Add Comment
Please, Sign In to add comment
Advertisement