struct.c

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

   while(st!=NULL){
   for(i=0;i<st->numMembers;i++){
       printf("\t%s    %s       %d        %d\n", st->name, st->memberName[i], st->member[i], st->sizeOfMember[i]);
   }
   st=st->next;
   }
      
   
return 0;
}


void convertParseTree(symnode *t, int x) /* ,int x, int y */
/*type: 0 be sibling,1 be next*/
{
   if (t==NULL) return;
   if(x>max_X) max_X=x;
  // if(y>max_Y) max_Y=y;
  TreeMatrix[x][max_Y]=t; 

   //printf("\nTree:%s\n",TreeMatrix[x][y]);
   convertParseTree(t->sibling, x+1);
   if(t->name!=NULL) 
     max_Y++;
   
   convertParseTree(t->next, x);

   return;
}

void initializeMatrix()
{
 int x, y;
 for(x=0;x<TREE_X;x++)
     for(y=0;y<TREE_Y;y++)
         TreeMatrix[x][y]=NULL;
}

void printParseTree(symnode *t)
{
   int x=0, y=0;
   int rowchanged=0;
   int rowflag[TREE_X];
   for(x=0;x<TREE_X;x++)
        rowflag[x]=0;
	
   initializeMatrix();  
   //printf("\n\n OK, converting ParseTree.....\n");
   max_Y=0;
   convertParseTree(t, 0);  
   for(y=0;y<=max_Y;y++){
      for(x=0;x<=max_X;x++){
          if(TreeMatrix[x][y]!=NULL){
	     rowchanged=1;
	     if(x!=0){
	        if(rowflag[x]==0) printf("--  ");
	        else printf("    ");
	     }
             printf("%-10s",TreeMatrix[x][y]->name);  
/*	
	     if( strcmp(TreeMatrix[x][y]->name, "ID")==0){
	        if(TreeMatrix[x][y]->symTab ==NULL)
		  printf("\n NULL \n"); 
	     	printf(": %s", TreeMatrix[x][y]->symTab->name);
		}
	     if( strcmp(TreeMatrix[x][y]->name, "STR")==0)
	     	printf(": %s", literals[TreeMatrix[x][y]->strIndex]);
	     
	     if(strcmp(TreeMatrix[x][y]->name,"INT_V")==0){
             printf(" -- %s\n",TreeMatrix[x][y]->value);
             }*/
     
	     if(TreeMatrix[x][y]->next!=NULL) rowflag[x]=1; 
	     else rowflag[x]=0;
	  }else{
	     if(rowflag[x]!=0) printf("       |      ");
	     else printf("              ");
	  }

      }
      printf("\n");
      if(rowchanged==1){
          for(x=0;x<max_X;x++){
	        if(rowflag[x]!=0)
	             printf("       |      ");  
	        else
	             printf("              "); 
          }
	  printf("\n");
	  }
     rowchanged=0;
   }
}


void initGlobalVal()
{
    //numError = 0;
    currLine = 1;
     idType=-1;  //char 0, int 1, float 2
    funcType = 0;
    strcpy(scope,"Global");
    strCount=0;
     numArgs=0;
     arraySize=1;
     numTypes=0;
     numMembers=-1;
     symTableError=0;
     typeErrs=0;
     symTable=NULL;
     symRoot=NULL;
     symStruct=NULL;
}

int getMemberType(symtype *str, const char *member)
{
    int i;
    for(i=0; i<str->numMembers;i++){
         if(strcmp(str->memberName[i], member)==0) 
	 break;
    }
    if(i==str->numMembers) return -1;
    return str->member[i];
}

int getMemberSize(symtype *str, const char *member)
{
    int i;
    for(i=0; i<str->numMembers;i++){
         if(strcmp(str->memberName[i], member)==0) 
	 break;
    }
    return str->sizeOfMember[i];
}

symtype * getStruct(const char * struct_name, const char * scope)
{
  symtype *ptr;
  for (ptr = symStruct; ptr != (symtype *) 0;
              ptr = (symtype *)ptr->next){
      if (strcmp (ptr->scope,scope) == 0 || strcmp (ptr->scope,"Global") == 0 ){
           if(strcmp(ptr->name,struct_name)== 0) 
	       return ptr;
      }          
  }
  return NULL;   
}

symtype *putStruct(const char * struct_name, const char * scope)
{
 symtype *ptr;

  ptr = (symtype *) malloc (sizeof (symtype));  
  strcpy(ptr->name, struct_name);
  strcpy(ptr->scope, scope);
  ptr->numMembers=0;
  ptr->next=symStruct;
  symStruct=ptr;
  numTypes++;
  return symStruct;
}

symtype *newStruct(const char * struct_name, const char * scope)
{
   if(getStruct(struct_name, scope)==NULL){
       return putStruct(struct_name, scope);
   }
   return NULL;
}
int checkFunc(symnode *func, symnode *tree, int argOrder)
{
	if(tree==NULL) return argOrder;

	//printf("func: %s, node: %s, order %d\n", func->symTab->name, tree->name, argOrder);
	if(argOrder<0){
		printf("ERROR: arguments mismatch\n");
		printf("-parsing messege@(%d,%d): need %d argument(s), but found more\n", tree->line,tree->col, func->symTab->numArgs);
		argOrder--;
		return argOrder;
	}
	
	if(strcmp(tree->name, "ASSIGN")==0 || strcmp(tree->name, "OP")==0 || strcmp(tree->name, "cast")==0){
		int type;
		if(strcmp(tree->name, "cast")!=0){
			typeCheck(tree);
			type=pop();
		}else{
			if(strcmp(tree->value, "char")==0)
				type=0;
			else if(strcmp(tree->value, "int")==0)
					type=1;
				else if(strcmp(tree->value, "float")==0)
						type=2;
					else{
						printf("ERROR: cast error\n");
						printf("-parsing messege@(%d,%d): type \"%s\" dose not exist\n",tree->line,tree->col, tree->value);
						typeErrs++;
					}
		}
		if(type==0){
			if(func->symTab->argsType[argOrder]==2){
				printf("ERROR: type mismatch\n");
				printf("-parsing messege@(%d,%d): need a float type, but found char here\n", tree->line, tree->col);
				typeErrs++;  
			}
			//return ++argOrder;
		}
		if(type==2){
			if(func->symTab->argsType[argOrder]==0){
				printf("ERROR: type mismatch\n");
				printf("-parsing messege@(%d,%d): need a char type, but found float here\n", tree->line,tree->col);
				typeErrs++;  
			}
			//return ++argOrder;
		}
		return --argOrder;
	}
	if(strcmp(tree->name, "ID")==0 ){
		symrec * id;
		id=getsym(tree->symTab->name, tree->symTab->scope);
		if(id==NULL) {
		        typeErrs++;
			printf("-parsing messege@(%d,%d): identifier \"%s\" not declared but first used here\n", tree->line, tree->col,tree->symTab->name);
			push(1.0);        // if id not existed, set it as integer in case type checking broken
			return --argOrder;
		}	
		if(tree->symTab->nameType==1)
			checkFunc(tree, tree->sibling, tree->symTab->numArgs-1);
		//if(func->symTab->isArray
		if(tree->symTab->type != func->symTab->argsType[argOrder]){
			symrec *idnode;
			idnode=getValNode(func->symTab->name, 1, argOrder);
			if(idnode->isArray==1 && tree->symTab->isArray==1){
				printf("ERROR: type mismatch\n");
				printf("-parsing messege@(%d,%d): pass a different type array into function\n", tree->line, tree->col);
				typeErrs++;
				return --argOrder;
			}
			if(idnode->isArray==0 && tree->symTab->isArray==1){
				printf("ERROR: type mismatch\n");
				printf("-parsing messege@(%d,%d): pass an array into function\n", tree->line, tree->col);
				typeErrs++;
				return --argOrder;
			}
			if(idnode->isArray==1 && tree->symTab->isArray==0){
				printf("ERROR: type mismatch\n");
				printf("-parsing messege@(%d,%d): function need array argument\n", tree->line, tree->col);
				typeErrs++;
				return --argOrder;
			}
			if(func->symTab->argsType[argOrder]==2){
				if(tree->symTab->type==0){
					printf("ERROR: type mismatch\n");
					printf("-parsing messege@(%d,%d): identifier \"%s\" is char type,but need float here\n", tree->line, tree->col,tree->symTab->name);
					typeErrs++;
					return --argOrder;
				}
				
				symnode *tmp;
				tmp=newLeaf("ID");
				copyNode(tree, tmp);
				strcpy(tree->name, "cast");
				strcpy(tree->value, "float");
				tree->sibling=tmp;
				return --argOrder;
			}
			if(func->symTab->argsType[argOrder]==0 && tree->symTab->type==2){
				printf("ERROR: type mismatch\n");
				printf("-parsing messege(%d,%d): identifier \"%s\" is float type,but need char here\n", tree->line,tree->col, tree->symTab->name);
				typeErrs++;
				return --argOrder;
			}
			
			if( func->symTab->argsType[argOrder]==1 &&
					tree->symTab->type==2 ){
				symnode *tmp;
				tmp=newLeaf("ID");
				copyNode(tree, tmp);
				strcpy(tree->name, "cast");
				strcpy(tree->value, "int");
				tree->sibling=tmp;
				return --argOrder;
			}
			if(func->symTab->argsType[argOrder]==5){
				
				printf("ERROR: type mismatch\n");
				printf("-parsing messege(%d,%d): \"%s\" is not a structure, need a structure type here\n", tree->line,tree->col,tree->symTab->name);
				typeErrs++;
				return --argOrder;
			}
			//return ++argOrder;
		}else{
			symrec *idnode;
			idnode=getValNode(func->symTab->name, 1, argOrder);
			if(func->symTab->argsType[argOrder]==5){

				if(strcmp(idnode->structtype->name, tree->symTab->structtype->name)!=0){
					printf("WARNING: type mismatch\n");
					printf("-parsing messege(%d,%d): \"%s\" is a different structure type, need structure type \"%s\" here\n", tree->line,tree->col,tree->symTab->name,idnode->structtype->name );
					//typeErrs++;
					return --argOrder;
				}
			}
			if(tree->symTab->isArray==1){
				if(idnode->isArray!=1){
					printf("ERROR: type mismatch\n");
					printf("-parsing messege(%d,%d): \"%s\" is an array identifier\n", tree->line,tree->col,tree->symTab->name);
					typeErrs++;
					return --argOrder;
				}
			}
			if(idnode->isArray==1){
				if(tree->symTab->isArray!=1){
					printf("ERROR: type mismatch\n");
					printf("-parsing messege(%d,%d): \"%s\" is not an array identifier\n", tree->line,tree->col,tree->symTab->name);
					typeErrs++;
					return --argOrder;
				}
			}
		}
		return --argOrder;
	}
	
	if(strcmp(tree->name, "CHAR_V")==0){
		if(func->symTab->argsType[argOrder]==2){
			printf("ERROR: type mismatch\n");
			printf("-parsing messege@(%d,%d): \'%c\' is a char, but need float here\n", tree->line, tree->col,atoi(tree->value));
			typeErrs++;
		}
		return --argOrder;
	}
	if(strcmp(tree->name, "INT_V")==0){
		if(func->symTab->argsType[argOrder]==2){
		        //char fltbuf[80];
			float f;
			strcpy(tree->name, "FLT_V");
			f=atoi(tree->value);
			//printf("v: %s\n",tree->value);
			//printf("f: %f\n",f);
			sprintf(tree->value,"%d",*((unsigned int *)(&f)));
			//strcpy(
		}
		return --argOrder;
	}
	if(strcmp(tree->name, "FLT_V")==0){
		if(func->symTab->argsType[argOrder]==0){
			printf("ERROR: type mismatch\n");
			printf("-parsing messege@(%d,%d): %s is float number, but need char here\n", tree->line, tree->col,tree->value);
			typeErrs++;
		}
		int i;
		if(func->symTab->argsType[argOrder]==1){
			for(i=0; i<strlen(tree->value);i++){
				if(tree->value[i]=='.'){
					tree->value[i]='\0';
					strcpy(tree->name, "INT_V");
					break;
				}
			}
		}
		return --argOrder;
	}
	
	argOrder=checkFunc(func, tree->next, argOrder);
	//printf("order: %d\n", argOrder);
	argOrder=checkFunc(func, tree->sibling, argOrder);
	
		
	return argOrder;
}
symnode *copyNode(symnode *src, symnode *dest)
{
     strcpy(dest->name,  src->name);
     strcpy(dest->value,  src->value);
     dest->symTab=src->symTab;
     dest->strIndex = src->strIndex;
     dest->line = src ->line;
     dest->sibling = src ->sibling;
     dest->next = src -> next;
     return dest;
}
symnode *funcIDNode(symnode *tree)
{
	symnode *tmp;
	if(tree==NULL) return NULL;
		
	if(strcmp(tree->name,"ID")==0){
		 //printf("found: %s\n",tree->symTab->name);
		 return tree;
	}

	tmp = funcIDNode(tree->next);
	if(tmp!=NULL) return tmp;
	else {
		return funcIDNode(tree->sibling);
	}
}
void typeCheck(symnode *tree)
{
	if(tree==NULL) return;
	//if(strcmp(tree->name, "println")==0) return;
	
	if(strcmp(tree->name, "func")!=0 && strcmp(tree->name, "cast")!=0 && 
		strcmp(tree->name, "println")!=0  && strcmp(tree->name, "return")!=0 &&
			strcmp(tree->name, "doWhile")!=0 && strcmp(tree->name, "while")!=0 &&
				strcmp(tree->name, "for")!=0 && strcmp(tree->name, "goto")!=0 &&
					strcmp(tree->name, "exp")!=0 && strcmp(tree->name, "switch")!=0 &&
						strcmp(tree->name, "case")!=0 && strcmp(tree->name, "stmt")!=0 &&
							strcmp(tree->name, "ID")!=0 && strcmp(tree->name, "continue")!=0 &&
								strcmp(tree->name, "struct")!=0){
		
		if(tree->value[0]=='\0' && 
		        ((tree->next!=NULL && tree->sibling==NULL) || (tree->next==NULL && tree->sibling!=NULL))){
			symnode *tmp;
			
			if(tree->next!=NULL) tmp=tree->next;
			if(tree->sibling!=NULL) tmp=tree->sibling;
			copyNode(tmp, tree);
			free(tmp);
		}
	
	}
	
	if(strcmp(tree->name, "struct")==0){
		return;
	}
	if(strcmp(tree->name, "func")==0){
		//symnode *fid;
		//printf("get it\n");
		fid=funcIDNode(tree->sibling);
		//printf("func name: %s\n",fid->symTab->name);
		funcType=fid->symTab->type;
		foundFunc=1;
	}

	if(foundFunc==1 && fid != tree && strcmp(tree->name, "ID")==0 && tree->symTab->nameType==1) {      // if  is function
		//printf("fun<<c: %s\n", tree->symTab->name);	
		if(getsym(tree->symTab->name, tree->symTab->scope)==NULL){
			printf("ERROR: function not defined\n");
			printf("-parsing messege@(%d,%d): function must be declared before using it\n",tree->line,tree->col);
			typeErrs++;
			push(1.0);
			return;
		}
		int  order;
		order=checkFunc(tree, tree->sibling, tree->symTab->numArgs-1);
		if(order>-1){
			typeErrs++;
			printf("ERROR: arguments mismatch\n");
			printf("-parsing messege@(%d,%d): need %d argument(s), too few argments here\n", tree->line,tree->col, tree->symTab->numArgs);
			//argOrder--;
			return ;
		}		
		push(tree->symTab->type);