util.cpp

snl编译器 开发环境visual c

		}

    /* 调用函数printSpaces,打印相应的空格,进行缩进 */ 
    printSpaces();	
  
  switch ( tree->nodekind)
  {   case ProK : 
		   fprintf(listing,"%s  ","ProK"); break;
      case PheadK:
		  {fprintf(listing,"%s  ","PheadK");
		   fprintf(listing,"%s  ",tree->name[0]);
		  }
		   break;
	  case DecK:
		{  fprintf(listing,"%s  ","DecK"); 
          if (tree->attr.ProcAttr.paramt==varparamType )
			  fprintf(listing,"%s  ","var param:");
		  if (tree->attr.ProcAttr.paramt==valparamType)
			  fprintf(listing,"%s  ","value param:");
		   switch(tree->kind.dec)
		   { case  ArrayK:
		     { 
			   fprintf(listing,"%s  ","ArrayK");
               fprintf(listing,"%d  ",tree->attr.ArrayAttr.up);
			   fprintf(listing,"%d  ",tree->attr.ArrayAttr.low);
			   if (tree->attr.ArrayAttr.childtype == CharK)
				    fprintf(listing,"%s  ","Chark");
			   else if( tree->attr.ArrayAttr.childtype == IntegerK)
				    fprintf(listing,"%s  ","IntegerK");
			 };break;
		     case  CharK:
			 fprintf(listing,"%s  ","CharK");break;
			 case  IntegerK:
			 fprintf(listing,"%s  ","IntegerK");break;
			 case  RecordK:
			 fprintf(listing,"%s  ","RecordK");break;
			 case  IdK:
			 fprintf(listing,"%s  ","IdK");
			 fprintf(listing,"%s  ",tree->attr.type_name);
			 break;
			 default: 
				 fprintf(listing,"error1!");
				 Error = TRUE;
		   };
         if (tree->idnum !=0)
	       for (int i=0 ; i <= (tree->idnum);i++)
		   {
			   fprintf(listing,"%s  ",tree->name[i]);
				
		   }
		else  
			{
				fprintf(listing,"wrong!no var!\n");
				Error = TRUE;	
			}
		} break;
	  case TypeK:
		   fprintf(listing,"%s  ","TypeK");break;
	  
	  case VarK:
		   fprintf(listing,"%s  ","VarK");
		   if(tree->table[0]!=NULL)
			   fprintf(listing,"%d  %d  ",tree->table[0]->attrIR.More.VarAttr.off,tree->table[0]->attrIR.More.VarAttr.level);
		   break;
	  
	  case ProcDecK: 
			fprintf(listing,"%s  ","ProcDecK");
		    fprintf(listing,"%s  ",tree->name[0]);
			if(tree->table[0]!=NULL)
				fprintf(listing,"%d %d %d  ",tree->table[0]->attrIR.More.ProcAttr.mOff,tree->table[0]->attrIR.More.ProcAttr.nOff,tree->table[0]->attrIR.More.ProcAttr.level);
            break;
	  
	  case StmLK:
		   fprintf(listing,"%s  ","StmLk");break;
	  
	  case StmtK:
		  { fprintf(listing,"%s  ","StmtK");
            switch (tree->kind.stmt)
			{ case IfK:
    		       fprintf(listing,"%s  ","If");break;
			  case WhileK:
		           fprintf(listing,"%s  ","While");break;
			  
			  case AssignK:
		           fprintf(listing,"%s  ","Assign");
				   break;
			  
			  case ReadK:
		           fprintf(listing,"%s  ","Read");
				   fprintf(listing,"%s  " , tree->name[0]);
				   if(tree->table[0]!=NULL)
					   fprintf(listing,"%d   %d  ",tree->table[0]->attrIR.More.VarAttr.off,tree->table[0]->attrIR.More.VarAttr.level);
				   break;
			  
			  case WriteK:
		           fprintf(listing,"%s  ","Write");break;
			  
			  case CallK:
		           fprintf(listing,"%s  ","Call");
				   fprintf(listing,"%s  ", tree->name[0]);
				   break;
			  
			  case ReturnK:
		           fprintf(listing,"%s  ","Return");break;
     
			  default: 
				fprintf(listing,"error2!");
				Error = TRUE;	
			}
          };break;
	  case ExpK: 
		  { fprintf(listing,"%s  ","ExpK");
		    switch (tree->kind.exp)
			{ case OpK:
    		      { fprintf(listing,"%s  ","Op");
			        switch(tree->attr.ExpAttr.op)
					{ case EQ:   fprintf(listing,"%s  " , "="); break;
                      case LT:   fprintf(listing,"%s  " , "<"); break;      
                      case PLUS: fprintf(listing,"%s  " , "+"); break;   
                      case MINUS:fprintf(listing,"%s  " , "-"); break;
					  case TIMES:fprintf(listing,"%s  " , "*"); break;  
                      case OVER: fprintf(listing,"%s  " , "/"); break;  
                      default: 
						  fprintf(listing,"error3!");
						  Error = TRUE;
					}

					if(tree->attr.ExpAttr.varkind==ArrayMembV)
					{
						fprintf(listing,"ArrayMember  ");
						fprintf(listing,"%s  ",tree->name[0]);
					}
                  };break;
			  case ConstK:
				    fprintf(listing,"%s  ","Const");
					switch(tree->attr.ExpAttr.varkind)
					{
						case IdV:
					    fprintf(listing,"Id  ");
						fprintf(listing,"%s  ",tree->name[0]);
						break;
						case FieldMembV:
					    fprintf(listing,"FieldMember  ");
					    fprintf(listing,"%s  ",tree->name[0]);
						break;
						case ArrayMembV:
					    fprintf(listing,"ArrayMember  ");
						fprintf(listing,"%s  ",tree->name[0]);
						break;
						default: 
							fprintf(listing,"var type error!");
							Error = TRUE;
					}
					
					fprintf(listing,"%d  ",tree->attr.ExpAttr.val);
					break;
			  case VariK:
		           fprintf(listing,"%s  ","Vari");
                   switch(tree->attr.ExpAttr.varkind)
				   {
						case IdV:
					    fprintf(listing,"Id  ");
						fprintf(listing,"%s  ",tree->name[0]);
						break;
						case FieldMembV:
					    fprintf(listing,"FieldMember  ");
					    fprintf(listing,"%s  ",tree->name[0]);
						break;
						case ArrayMembV:
					    fprintf(listing,"ArrayMember  ");
						fprintf(listing,"%s  ",tree->name[0]);
						break;
						default: 
							fprintf(listing,"var type error!");
							Error = TRUE;
				   }
				   if(tree->table[0]!=NULL)
					   fprintf(listing,"%d   %d  ",tree->table[0]->attrIR.More.VarAttr.off,tree->table[0]->attrIR.More.VarAttr.level);

				   break;
              default: 
				  fprintf(listing,"error4!");
				  Error = TRUE;
			}
		  };break;
   default: 
	   fprintf(listing,"error5!");
	   Error = TRUE;
   }
   
   fprintf(listing,"\n");
   
    /* 对语法树结点tree的各子结点递归调用printTree过程 *
	 * 缩进写入列表文件listing						   */
    for (i=0;i<MAXCHILDREN;i++)
         printTree(tree->child[i]);

	/* 对语法树结点tree的兄弟节点递归调用printTree过程 *
	 * 缩进写入列表文件listing						   */ 
	tree = tree->sibling;			
  }

  /* 减量缩进宏,每次退出语法树节点时减量缩进 */
  UNINDENT;							
}



/**************************************************/
/****************释放指针空间部分******************/
/**************************************************/

void freeDec(TreeNode * p);

void freeStm(TreeNode * p);

void freeExp(TreeNode * t);
/***********************************************************/
/* 函数名  freeTree                                        */
/* 功  能  通过递归调用释放指针空间                        */
/* 说  明                    		    				   */
/***********************************************************/
void freeTree(TreeNode * t)
{
	TreeNode * p = NULL;

	if(t!=NULL)
		free(t->child[0]);
	
	p = t->child[1];
	
	freeDec(p);
				
	p = t->child[2]->child[0];
	
	freeStm(p);

}
/***********************************************************/
/* 函数名  freeDec                                         */
/* 功  能  通过递归调用释放声明类型指针空间                */
/* 说  明                    		    				   */
/***********************************************************/
void freeDec(TreeNode * p)
{
	TreeNode * p1 = NULL;
	TreeNode * p2 = NULL;
	
	while(p!=NULL)
	{	
		switch(p->nodekind)
		{
			case TypeK:
			case VarK:
				/*p1指向类型声明节点链或者变量声明节点链*/
				p1 = p->child[0];
				while(p1!=NULL)
				{
					p2 = p1->sibling;
					free(p1);
					p1 = p2;
				}
				break;
			case ProcDecK:
				/*p1指向函数声明节点的第一个儿子节点－－形参节点*/
				p1 = p->child[0];
				while(p1!=NULL)
				{
					p2 = p1->sibling;
					free(p1);
					p1 = p2;
				}
				/*p1指向函数声明节点的第二个儿子结点－－声明节点*/
				p1 = p->child[1];
				freeDec(p1);
				/*p1指向函数声明节点的三个儿子节点－－函数体节点*/
				p1 = p->child[2];
				freeStm(p1);
				break;
		}
		p1 = p->sibling;
		free(p);
		p = p1;
	}
}

/***********************************************************/
/* 函数名  freeStm                                         */
/* 功  能  通过递归调用释放语句类型指针空间                */
/* 说  明                    		    				   */
/***********************************************************/
void freeStm(TreeNode * p)
{
	TreeNode * t = p;
	TreeNode * p1 = NULL;
	TreeNode * p2 = NULL;
	while(t!=NULL)
	{
		switch(t->kind.stmt)
		{
			case IfK:
				/*删除条件表达式节点*/
				freeExp(t->child[0]);
				/*删除then语句序列部分*/
				freeStm(t->child[1]);
				/*删除else语句序列部分*/
				freeStm(t->child[2]);
				break;
			case WhileK:
				/*删除条件表达式节点*/
				freeExp(t->child[0]);
				/*删除while语句序列部分*/
				freeStm(t->child[1]);
				break;
			case AssignK:
				/*删除赋值号左侧*/
				p1 = t->child[0];
				freeExp(p1);
				/*删除赋值号右侧*/
				p1 = t->child[1];
				freeExp(p1);
				break;
			case ReadK:
				break;
			case WriteK:
				/*删除儿子节点*/
				freeExp(t->child[0]);
				break;
			case CallK:
				/*删除左儿子(调用函数名)*/
				freeExp(t->child[0]);
				/*删除右儿子节点(实参链)*/
				p1 = t->child[1];
				while(p1 !=NULL)
				{
					p2 = p1->sibling;
					freeExp(p1);
					p1 = p2;
				}
				break;

			case ReturnK:
				break;
		}
		p1 = t->sibling;
		free(t);
		t = p1;
	}
}

/***********************************************************/
/* 函数名  freeExp                                         */
/* 功  能  通过递归调用释放表达式类型指针空间              */
/* 说  明                    		    				   */
/***********************************************************/
void freeExp(TreeNode * t)
{
	TreeNode * p1 = NULL;
	TreeNode * p2 = NULL;

	switch(t->kind.exp)
	{
	case OpK:
		/*删除左操作数*/
		freeExp(t->child[0]);
		/*删除右操作数*/
		freeExp(t->child[1]);
		break;
	case ConstK:
		/*直接删除该节点*/
		free(t);
		break;
	case VariK:
		p1 = t;
		while (p1!=NULL)
		{
			p2 = p1->child[0];
			free(p1);
			p1 = p2;
		}
		break;
	}
}

/***********************************************************/
/* 函数名  freeTable                                       */
/* 功  能  通过递归调用释放符号表空间                      */
/* 说  明                    		    				   */
/***********************************************************/
void freeTable(void)
{
	 SymbTable * p1=NULL;
	 SymbTable * p2=NULL;
	 int i = 0;

	 while(scope[i]!=NULL)
	 {
		 p1 = scope[i];
		 while(p1!=NULL)
		 {
			 p2 = p1->next;
			 free(p1);
			 p1 = p2;
		 }
		 i++;
	 }
}