struct.c

一个编译器的例子,基于c语言,在linux下开发 现在了简单的c语言例子

#include<stdio.h>
#include"struct.h"
#include"stack.h"
int max_X=0, max_Y=0;
//symrec *array=NULL;
int arrayType=-1;
int returnType = -1;
int funcType= -1;
int foundFunc=0;
symnode *fid;

symnode * TreeMatrix[TREE_X][TREE_Y];

int numGlobals()
{
  symrec *tmp=symTable;
  int i=0;
   while(tmp!=NULL){
   if( (strcmp(tmp->scope,"Global")==0) &&    /* scope is Global */
          (tmp->nameType==0)) {                   /* and is a variable */
        i++;
	}
   tmp=tmp->next;
   }
   return i;
}

int numVals(const char *scope)
{
  symrec *tmp=symTable;
  int i=0;
   while(tmp!=NULL){
      if( (strcmp(tmp->scope,scope)==0)&& (tmp->isFuncArg==0)) {                   /* and is a variable */
        i++;
      }
      tmp=tmp->next;
   }
   return i;   
}

int maxValOrder(const char * scope)
{
   symrec *tmp=symTable;
   int order = -1;
   while(tmp!=NULL){
      if(strcmp(tmp->scope, scope)==0){     /*  in same scope */
         if((tmp->nameType==0) && (tmp->isFuncArg==0)){                  /* and is a variable and not a parameter*/
	     if(tmp->order > order)
	        order = tmp->order;
         }
      } 
      tmp = tmp->next;  
  }
  return order;
}

int maxArgOrder(const char *name, const char *scope)
{
    symrec *tmp=symTable;
   int order = -1;
   //printf("\nscope \"%s\" finding...\n", scope);
   while(tmp!=NULL){
      if(strcmp(tmp->scope, scope)==0){     /*  in same scope */
         if((tmp->nameType==0) && (tmp->isFuncArg==1)){                  /* and is a variable and is a parameter*/
	    if( strcmp(tmp->name, name)==0 && tmp->argOrder != -1){
	       //if (tmp->argOrder == -1)
	       return tmp->argOrder;  
	       //printf("\nscope \"%s\" found %d\n", scope,tmp->order);
	    }
	     //else
	        if(tmp->argOrder > order)
	           order = tmp->argOrder;
         }
      } 
      tmp = tmp->next;  
  }
  return order+1;
}

symrec *getFuncNode(const char *funcName)
{
    symrec *tmp=symTable;
   while(tmp!=NULL){
      if(strcmp(tmp->scope, "Global")==0){     /*  in same scope */
         if((tmp->nameType==1) && (strcmp(tmp->name,funcName)==0)){       /* if it is the func as named funcName */
           break;
         }
      } 
      tmp = tmp->next;  
  }
  return tmp;   
}

symrec *getValNode( const char *scope, int isPara,int index)
{
    symrec *tmp=symTable;
    int order;

        
    while(tmp!=NULL){
       if(strcmp(tmp->scope, scope)==0){         /* if it is in the function scope */
          if(isPara==0) order = tmp->order;  // it's variable
	  else
	      order=tmp->argOrder;            //  function arguments
          if((tmp->nameType==0) &&(order == index) &&
	               (tmp->isFuncArg==isPara))
	    break;
       }
       tmp=tmp->next;
    }
    return tmp;     
}

int sizeOfVals(const char * scope)
{
    symrec *tmp=symTable;
    int size;
    int totalsize=0;
    while(tmp!=NULL){
        if((strcmp(tmp->scope, scope)==0) && (tmp->nameType==0) && (tmp->isFuncArg ==0)){
	   //printf("val: %s  scope:%s\n", tmp->name, scope);
	    if(tmp->isArray==1)
	          size = tmp->numArray;
	    else
	           size = 1;
	    switch(tmp->type){
	    case 0: totalsize+=CHAR_SIZE*size;break;
	    case 1: totalsize+=INT_SIZE*size; break;
	    case 2: totalsize+=FLOAT_SIZE*size; break;
	    case 3: totalsize+=VOID_SIZE*size; break;
	    case 4: totalsize+=DOUBLE_SIZE*size; break;
	    case 5: totalsize+=sizeOfStruct(tmp->structtype)*size; break;
	    }
	}
	tmp=tmp->next;
    }
    //printf("size: %d\n", totalsize);
    return totalsize;
}

int sizeOfStruct(symtype *node)
{
   int i, size;
   size = 0;
   for(i=0;i<node->numMembers;i++){
        //printf("struct:\\t%d.  type:%d  size:%d \n", i, node->member[i], node->sizeOfMember[i]);;
        switch(node->member[i]){
	case 0:
	            size+=CHAR_SIZE*node->sizeOfMember[i];break;
	case 1:
	            size+=INT_SIZE*node->sizeOfMember[i];break;
	case 2:
	            size+=FLOAT_SIZE*node->sizeOfMember[i];break;
	case 3:
	            size+=VOID_SIZE*node->sizeOfMember[i];break;
	case 4:
	            size+=DOUBLE_SIZE*node->sizeOfMember[i];break;
	}
   }
     // printf("structsize: %d\n", size); 
   return size;
}

int offsetAtID(const char *scope, int index)
{
    symrec *tmp;
    int offset=0;
    int size=0;
    int i;
    //tmp=getValNode(scope, 0, i);    
    
    for(i=0;i<=index;i++){
        tmp=getValNode(scope, 0, i);
	if(tmp->isArray==1)
	     size = tmp->numArray;
	else
	     size = 1;
	switch(tmp->type){
	    case 0: offset+=CHAR_SIZE*size;break;
	    case 1: offset+=INT_SIZE*size; break;
	    case 2: offset+=FLOAT_SIZE*size; break;
	    case 3: offset+=VOID_SIZE*size; break;
	    case 4: offset+=DOUBLE_SIZE*size; break;
	    case 5: offset+=sizeOfStruct(tmp->structtype)*size; break;	             
	}
    }
    return offset;
}

int offsetOfPara(const char *scope, int index)
{
    symrec *tmp;
    int offset=0;
    int i;

    for(i=0;i<index;i++){
        tmp=getValNode(scope, 1, i);
	if(tmp->isArray==1){
	     offset+= 4;
	     continue;
	}
	switch(tmp->type){
	    case 0: offset+=CHAR_SIZE;break;
	    case 1: offset+=INT_SIZE; break;
	    case 2: offset+=FLOAT_SIZE; break;
	    case 3: offset+=VOID_SIZE; break;
	    case 4: offset+=DOUBLE_SIZE; break;
	    case 5: offset+=4; break;	             
	}
    }
    return offset+8;
}

int sizeOfID(symnode *id)
{
    symrec *tmp;
    int size;
    int totalsize=0;
    if(id->symTab==NULL) return 0;;
    tmp=id->symTab;
    if(tmp->isArray==1)
        size = tmp->numArray;
    else
        size = 1;
    switch(tmp->type){
      case 0:
                totalsize+=CHAR_SIZE*size;break;
      case 1:
                totalsize+=INT_SIZE*size;break;
      case 2:
                totalsize+=FLOAT_SIZE*size;break;
      case 3:
                totalsize+=VOID_SIZE*size;break;
      case 4:
                totalsize+=DOUBLE_SIZE*size;break;
      case 5:
                totalsize+=sizeOfStruct(tmp->structtype)*size;break;
    }
    return totalsize;
}

int sizeAtMember(symtype *st, const char* member)
{
   int index=0;
   int i, size=0;
   int totalOffset=0;
   if(st==NULL)
      return -1;
   
   for(i=0;i<st->numMembers;i++){
      	if(strcmp(st->memberName[i], member)==0)
          	break;
	size = st->sizeOfMember[i];
	switch(st->member[i]){
	case 0:
			totalOffset+=CHAR_SIZE*size;break;
	case 1:
			totalOffset+=INT_SIZE*size;break;
	case 2:
			totalOffset+=FLOAT_SIZE*size;break;
	case 3:
			totalOffset+=VOID_SIZE*size;break;
	case 4:
			totalOffset+=DOUBLE_SIZE*size;break;
	case 5:
			totalOffset+=sizeOfStruct(st)*size;break;
	}      
   }
   return totalOffset;
}

int sizeAtIndex(symnode *id, int index)
{
  	symrec *array;
  	int size=0;
   	if(id==NULL || id->symTab==NULL || id->symTab->isArray==0)
      		return -1;
		
	array=id->symTab;

	switch(array->type){
	case 0:
			size=CHAR_SIZE*index;break;
	case 1:
			size=INT_SIZE*index;break;
	case 2:
			size=FLOAT_SIZE*index;break;
	case 3:
			size=VOID_SIZE*index;break;
	case 4:
			size=DOUBLE_SIZE*index;break;
	case 5:
			size=sizeOfStruct(array->structtype)*index;break;
	}       
        return size;
}
 
char *getOffset(symnode *id)
{
   char addr[255];
   
}

symrec *putsym (const char *sym_name, int sym_type, int func, const char *idScope)
{
  symrec *ptr;
  int i;
  ptr = (symrec *) malloc (sizeof (symrec));
  ptr->nameType = func;                                 //function or variable
 
  ptr->name = (char *) malloc (strlen (sym_name) + 1);
  strcpy (ptr->name,sym_name);
  ptr->scope = (char *) malloc (strlen (idScope) + 1);
  strcpy (ptr->scope,idScope);
  ptr->type = sym_type;                            // int, char or float   for type of varibales or functions
  ptr->value[0]= '\0';
  ptr->value[1]= '\0'; 
  ptr->numArgs=0;
  ptr->isArray = 0;
  ptr->numArray=0;
  for (i=0; i<20;i++){
     ptr->argsType[i]=-1;
  }
  ptr->isFuncArg = 0;                    // not a functioin parameter  as default
  if( func == 0)
      ptr->order = maxValOrder(idScope) + 1;
  else
      ptr->order = -1;
  ptr->argOrder = -1;
  if(sym_type==5)
     ptr->structtype=curStrNode;
  else
     ptr->structtype=NULL;
  ptr->next = symTable;
  symTable = ptr;
  return ptr;
}

symrec *getsym (const char *sym_name, const char *idScope)
{
  symrec *ptr;
  for (ptr = symTable; ptr != (symrec *) 0;
              ptr = (symrec *)ptr->next){
      if (strcmp (ptr->name,sym_name) == 0){
           if(ptr->nameType == 1) return ptr;
	   if(strcmp(ptr->scope, "Global")==0) return ptr;
      	   if(strcmp(ptr->scope,idScope)==0)
                 return ptr;
      }
          
  }
  return NULL;
}

symrec *add2Table(const char *id, int ftype, const char *idScope)
{
    symrec *ptr;
    //printf("\n %s :  %i : %s \n",id, ftype, idScope);
    if (idType!=-1){
         if((ptr=getsym(id,idScope))==NULL){
            return   putsym(id, idType, ftype, idScope);       		
    }
  }
  
  return ptr;
}

symnode *newLeaf(char *s)
{
  symnode *ptr;
  ptr = (symnode *) malloc (sizeof(symnode));
  ptr->name = (char*)malloc(strlen(s)+1);
  strcpy(ptr->name, s);
  //strcpy(ptr->value,"");
  ptr->value[0]='\0';
  ptr->name[strlen(s)]='\0';
  ptr->strIndex = -1;
  ptr->symTab = NULL;
  ptr->line=currLine;
  ptr->col=column;
  ptr->next = NULL;
  ptr->sibling = NULL;  
  return ptr;
}

symnode *setStrIndex(symnode *node, int i)
{
    node->strIndex = i;
    return node;
}

symnode *addNext (symnode *f, symnode *s )
{
 f->next = s;
 return f;
}

symnode *addSibling (symnode *f, symnode *s )
{
  f->sibling = s;
  return f;
}

int printSymbolTable()
{
   char type[20],nameType[20];
   int i=0;
   symrec *tmp = symTable;
   printf("\n                    Symbol Table\n");
   printf("\n ============================================== \n");
   printf(" type   | func/var |    name            |    scope \n");
   printf(" -------------------------------------------------\n");
   while(tmp!=NULL){
     switch(tmp->type){
     case 0: strcpy(type,"char");break;
     case 1: strcpy(type,"int");break;
     case 2: strcpy(type,"float");break;
     case 3: strcpy(type,"void");break;
     case 4: strcpy(type,"double");break;
     case 5: strcpy(type,"struct");break;
     }
     
     switch(tmp->nameType){
     case 0: strcpy(nameType,"VAR");break;
     case 1: strcpy(nameType,"FUNC");break;
     }
     printf("  %-10s%-10s%-20s%s\t%d\tisArg: %d  ArgOrder: %d\tisArray::%d  arraySize:%d\n",
                             type,nameType,tmp->name,tmp->scope, tmp->order,tmp->isFuncArg, tmp->argOrder,tmp->isArray, tmp->numArray);
/*     if(tmp->type == 5){
       printf("\tstruct: %s  scope: %s  numOfMembers: %d\n", tmp->structtype->name, tmp->structtype->scope,tmp->structtype->numMembers);
       for(i=0;i<tmp->structtype->numMembers;i++){
          printf("\t   name: %s  type: %d nums: %d\n", tmp->structtype->memberName[i], tmp->structtype->member[i], tmp->structtype->sizeOfMember[i]);
	  }
      }*/
  /*   if (tmp->nameType==1){
          for (i = 0; i<tmp->numArgs;i++){
		switch(tmp->argsType[i]){
		case 0: strcpy(type,"char");break;
		case 1: strcpy(type,"int");break;
		case 2: strcpy(type,"float");break;
		}	  
	   printf("\targ: %d: %s",i, type);
	   }
     printf(" \n");
     }*/

     tmp=tmp->next;
   }
   printf(" ------------------------\n");
   printf("\n\n             structure list\n");
   printf(" ==========================================\n");
   printf("\tname    member   type      size  \n");
   symtype *st;
   st = symStruct;