symbol.c

guide and some example with visualC++

/* symbol.c
 *
 *	(C) Copyright Apr 15 1995, Edmond J. Breen.
 *		   ALL RIGHTS RESERVED.
 * This code may be copied for personal, non-profit use only.
 *
 */

#include <stdio.h>
#include <stdlib.h>
#include <string.h>

#include "typemod.h"
#include "MachSet.h"
#include  "global.h"
#include "lexer.h"
#include "xalloc.h"
#include "preproc.h"
#include "symbol.h"
#include "parser.h"



int EiC_iskeyword(keyword_t *keywords,char*id,int n)
{
    int i;
    for(i=0;i<n;i++)
	if(strcmp(keywords[i].id,id) == 0)
	    return keywords[i].token;
    return 0;
}

#define MoD 2
void EiC_eicpush(eicstack_t *s, val_t v)
{
    if(!(s->n%MoD)) {
	if(!s->n)
	    s->val = (val_t*)xcalloc(sizeof(val_t),MoD);
	else
	    s->val = (val_t*)xrealloc(s->val,(s->n+MoD)*sizeof(val_t));
    }
    s->val[s->n] = v;
    s->n++;
}

int EiC_eicpop(eicstack_t *s, val_t *pop)
{
    if(s->n == 0)
	return 0;
    s->n--;
    *pop = s->val[s->n];
    if(!(s->n%MoD)) {		
	if(!s->n)
	    xfree(s->val);
	else
	    s->val = (val_t*)xrealloc(s->val,s->n*sizeof(val_t));
    }
    return 1;
}


/* LOOK UP TABLE ROUTINES
   --------------------------*/

static size_t _EnTrY_No = 0;
int hashsmc(char * s,int mod);
symentry_t *EiC_HTAB[HSIZE];


/* code for generating tempories */
unsigned int NumTemps=0, CurTemp =0;

symentry_t * EiC_nxtTemp(int obj, int level)
{
    symentry_t *sym;
    char tmpName[50];
    sprintf(tmpName,"%s%d","__TeMp",NumTemps);

    /* There should be no need to watch out for change of level !!!!
     * It will be assumed that the compound statement routine will
     * handle it.
     */


    sym = EiC_insertLUT(EiC_work_tab,tmpName,obj);
    NumTemps++;

    CurTemp++;

    if(sym->val.ival == -1) /* needs a home */ 
	EiC_stackit(sym,level);

    /* Setting up the token information is left
     * to the caller of this routine.
     */

    sym->level = level;
    return sym;
}    



size_t EiC_lut_NextEntryNum(void)
{
    return _EnTrY_No;
}
                             /*CUT EiChashFunc*/
int hashsmc(char * s,int mod)
{
    register unsigned int h, c;
    h = 0;
    while(  (c = (int) *s++) > 0)
	h =   (h << 1) + c;
    return ( h % mod);
}
                           /*END CUT*/

                            /*CUT lutLookUp*/
int Pclash;

char *EiC_getClashedfname(char nspace,char *id)
{
    symentry_t *sym;
    for(sym = EiC_HTAB[hashsmc(id,HSIZE)]; sym != NULL; sym = sym->next)
	if(sym->nspace == nspace && strcmp(id,sym->id) == 0)
	    if((sym->sclass & c_private) &&
	       sym->fname != CurrentFileName()) {
		return sym->fname;
	    }
    return NULL;
}

symentry_t * EiC_lookup(char nspace, char *id)
{
    symentry_t *sym;
    Pclash = 0;
    for(sym = EiC_HTAB[hashsmc(id,HSIZE)]; sym != NULL; sym = sym->next)
	if(sym->nspace == nspace && strcmp(id,sym->id) == 0) {
	    if((sym->sclass & c_private) &&
	       sym->fname != CurrentFileName()) {
		Pclash = 1;
		continue;
	    }
	    else
		break;
	}

    return(sym);
}
                             /*END CUT*/

                           /*CUT lutInsert*/
symentry_t * EiC_insertLUT(char nspace,char *id,int type)
{
    symentry_t *sym;
    auto int  hashval;

    sym = (symentry_t *) xcalloc(1,sizeof(symentry_t));
    if(sym == NULL)
	return(NULL);
    if( (sym->id = EiC_strsave(id)) == NULL) {
	xfree(sym);
	return(NULL);
    }
    sym->entry = _EnTrY_No++;
    hashval = hashsmc(sym->id,HSIZE);
    sym->next = EiC_HTAB[hashval];
    EiC_HTAB[hashval] = sym;
    sym->nspace = nspace;
    sym->val.ival = -1;		/* indicates  unused */
    sym->type = EiC_addtype(type,NULL);
    sym->fname =  CurrentFileName();
    return(sym);
}
                           /*END CUT*/

void delete(symentry_t *sym)
{
    auto symentry_t * this;
    auto int idx;
    
    idx = hashsmc(sym->id,HSIZE);
    this = EiC_HTAB[idx];
    if(this == sym)
	EiC_HTAB[idx] = sym->next;
    else {			/* find and unlink  */
	while(this && this->next != sym)
	    this = this->next;
	this->next = sym->next;
    }
}

void EiC_UpdateSymPos(symentry_t * sym)
{

    if(sym->next && sym->next->level > sym->level) {
	symentry_t * p = EiC_HTAB[hashsmc(sym->id,HSIZE)];
	delete(sym);
	while(p->next != sym)
	    if(p->next) {
		if(p->next->level > sym->level)
		    p=p->next;
		else {
		    sym->next = p->next;
		    p->next = sym;
		}
	    } else {
		p->next = sym;
		sym->next = NULL;
	    }
    }
}

void EiC_remsym(symentry_t *sym)
{

  delete(sym);
  free_sym(sym);

}
/*END CUT*/

#if 1
void remBuiltin(symentry_t *sym)
{
    /* removes the prototype of the builtin function only */
    EiC_freetype(sym->type);
    sym->type = EiC_addtype(t_builtin,NULL);
    sym->fname = "::EiC::";
}
#endif


/*CUT lutRemLevel*/
void EiC_remlevel(int level)
{
  int i;
  symentry_t * sym, *symh;

  for(i=0;i<HSIZE;i++) {
    sym = EiC_HTAB[i];
    while(sym && sym->level >= level) {
      symh = sym->next;
      free_sym(sym);
      sym = symh;
    }
    EiC_HTAB[i] = sym;
  }
}
/*END CUT*/
/*CUT lutRemTempories*/
void EiC_remTempories(void)
{
  int i;
  symentry_t * sym, *symh;

  for(i=0;i<HSIZE;i++) {
    sym = EiC_HTAB[i];
    while(sym && IsTemp(sym->type)) {
      symh = sym->next;
      free_sym(sym);
      sym = symh;
    }
    EiC_HTAB[i] = sym;
  }
}
/*END CUT*/



int  EiC_lutClearFileEntries(char *FileName)
{

    int i;
    symentry_t * sym, *p, *t;

    for(i=0;i<HSIZE;i++) {
	t = sym = EiC_HTAB[i];
	p = NULL;
	while(sym){
	    if(strcmp(sym->fname,FileName) == 0) {
		if(p)
		    p->next = sym->next;
		else
		    t = sym->next;
		free_sym(sym);
		if(!p) {
		    sym = t;
		    continue;
		}
	    } else
		p = sym;
	    sym=p->next;
	}
	EiC_HTAB[i] = t;
    }
    return 1;

}
                    /*END CUT*/
                     /*CUT lutCleanUp*/

void EiC_lut_CleanUp(size_t bot)
{

    int i;
    symentry_t * sym, *p, *t;
    for(i=0;i<HSIZE;i++) {
	t = sym = EiC_HTAB[i];
	p = NULL;
	while(sym){
	    if(sym->entry >= bot) {
		if(EiC_gettype(sym->type) == t_builtin) {
		    remBuiltin(sym);
		    p = sym;
		} else {
		    if(p)
			p->next = sym->next;
		    else
			t = sym->next;
		    free_sym(sym);
		    if(!p) {
			sym = t;
			continue;
		    }
		}
	    } else
		p = sym;
	    sym=p->next;
	}
	EiC_HTAB[i] = t;
    }

}
                     /*END CUT*/
                     /*CUT lutFreeSym*/

#define freeAg(X)   do {\
			    symentry_t *x = X; \
			    if(!isconst(x->type)) \
			         xfree(EiC_ENV->AR[x->val.ival].v.p.p);\
			    else xfree(x->val.p.p);\
		    } while (0)


#define freeAg1(X)  xfree(EiC_ENV->AR[X->val.ival].v.p.p)


static void free_sym(symentry_t *sym)
{

#if 0    
      printf("Freeing [%s] %d  %d [%d]\n",
  	sym->id, sym->entry, sym->val.ival,EiC_gettype(sym->type));
    
#endif    
    
    if(EiC_gettype(sym->type) == t_func) {
	EiC_killcode(sym);
    } else if(sym->level == 1)  { /* global value */
	int t;
	if((t=EiC_gettype(sym->type)) == t_array && sym->val.ival >=0) 
	    freeAg(sym);
	else if ((t== t_union || t == t_struct) && sym->val.ival >=0 ) 
	    freeAg(sym);
		
    }


    /*
     * the conditions for pushing  onto the ARgar stack
     * must be the same as those for stacking as found in
     * function establish_id
     * Except for ParseError
     */
    if( sym->val.ival >=0
       && sym->level == 1
       && EiC_gettype(sym->type) != t_builtin ) {
	if(! isconst(sym->type)
	   && sym->nspace == stand_tab
	   && sym->sclass != c_typedef) {
	    EiC_eicpush(&EiC_ENV->ARgar,sym->val);
	}
    }
    EiC_freetype(sym->type);
    xfree(sym->id);
    xfree(sym);
}
                        /*END CUT*/

void EiC_UpdateEntry(symentry_t *sym)
{
    int t = EiC_gettype(sym->type);
    if(CurrentFileName() != sym->fname &&
       t != t_func &&
       t != t_funcdec &&
       t != t_builtin)
	return;
    sym->entry =  _EnTrY_No++;
    sym->pname = sym->fname;
    sym->fname = CurrentFileName();
}

void EiC_addoffsettolevel(char nspace,int level,int off)
{
    int i;
    symentry_t * sym;

    for(i=0;i<HSIZE;i++) {
	sym = EiC_HTAB[i];
	while(sym && sym->level == level && sym->nspace == nspace) {
	    sym->val.ival = -(sym->val.ival + off);
	    sym = sym->next;
	}
    }
}

void EiC_marktype(type_expr *type, char mark)
{
    int i;
    struct_t *s;
    void EiC_markFunc(type_expr *t,int mark);
    
    while(type) {
	xmark(type,mark);
	switch(EiC_gettype(type)) {
	  case t_builtin:
	    if(EiC_getInf(type) == NULL)
		break;
	  case t_funcdec:
	  case t_func:
	    EiC_markFunc(type,mark);
	    break;
	  case t_union: