symbtable.cpp

snl语言是一个简单的具有嵌套过程定义的过程式语言

}


/***********************************************************/
/* 函数名 Compat                                           */
/* 功  能 判断类型是否相容                                 */
/* 说  明 由于TINY语言中只有整数类型、字符类型、数组类型和 */
/*        记录类型，故类型相容等于类型等价，只需判断每个结 */
/*        构类型的内部表示产生的指针值是否相同即可。       */
/***********************************************************/
int   Compat(TypeIR * tp1,TypeIR * tp2)
{
	int  present; 
	if (tp1!=tp2)
		present = FALSE;  /*类型不等*/
	else
		present = TRUE;   /*类型等价*/
	return present;
}

/***********************************************************/
/* 函数名 NewTy	                                           */
/* 功  能 创建当前空类型内部表示                           */
/* 说  明 参数为类型，函数返回该类型的内部表示的地址       */
/***********************************************************/
TypeIR * NewTy(TypeKind  kind)
{
	/* 内存中动态申请分配单元，
	   返回指向该单元的类型内部表示类型指针t */
	TypeIR * table = (TypeIR *) malloc(sizeof(TypeIR));

	/* 类型内部表示类型指针table为NULL,
       未能成功分配内存单元将显示提示错误信息*/
    if (table==NULL)
	{
		fprintf(listing,"Out of memory error !");
		Error = TRUE;
	}
	/* 类型内部表示类型指针table不是NULL,内存单元已经成功分配 */
	else
		switch(kind)
		{
			case intTy:
			case charTy:
			case boolTy:
				table->kind = kind;
				table->size = 1;
				break;
			case arrayTy:
				table->kind = arrayTy;
				table->More.ArrayAttr.indexTy = NULL;
				table->More.ArrayAttr.elemTy = NULL;
				break;
			case recordTy:
				table->kind = recordTy;
				table->More.body = NULL;
				break;
		}
	return table;
}

/***********************************************************/
/* 函数名 NewBody                                          */
/* 功  能 创建当前空记录类型中域的链表                     */
/* 说  明 函数返回该类型的新的链表的单元地址               */
/***********************************************************/
fieldChain * NewBody(void)
{
	fieldChain * Ptr = (fieldChain *) malloc(sizeof(fieldChain));

	if (Ptr==NULL)
	{
		fprintf(listing,"Out of memory error !");
		Error = TRUE;
	}
	else
	{
		Ptr->Next = NULL;
		Ptr->off = 0;
		Ptr->UnitType = NULL;
	}
	return Ptr;
}

/***********************************************************/
/* 函数名 NewParam	                                       */
/* 功  能 创建当前空形参链表                               */
/* 说  明 函数返回新申请的单元地址                         */
/***********************************************************/
ParamTable * NewParam(void)
{
	ParamTable * Ptr = (ParamTable *) malloc(sizeof(ParamTable));

    if (Ptr==NULL)
	{
		fprintf(listing,"Out of memory error !");
		Error = TRUE;
	}
	else
	{
		Ptr->entry = NULL;
		Ptr->next = NULL;
	}
		
	return Ptr;
}

/***********************************************************/
/* 函数名 ErrorPrompt                                      */
/* 功  能 错误提示                                         */
/* 说  明 在输出文件中显示错误提示，并给全局量Error赋值为1 */
/***********************************************************/
void ErrorPrompt(int line,char * name,char * message)
{
	fprintf(listing,">>>Line: %d, %s %s",line,name,message);
	Error = TRUE;
	exit(0);
}


/***********************************************************/
/* 函数名 printTab                                         */
/* 功  能 打印空格                                         */
/* 说  明 在输出文件中打印个数为参数tabnum的空格           */
/***********************************************************/
void printTab(int tabnum)
{
	for(int i=0;i<tabnum;i++)
		fprintf(listing," ");
}


/***********************************************************/
/* 函数名  printTable                                      */
/* 功  能  把符号表在输出文件中显示出来                    */
/* 说  明  分层显示符号表内容，并在下面显示该符号的类型内部*/
/*         表示                                            */
/***********************************************************/
/*void printTable(void)
{
	SymbTable * table = NULL;
	TypeIR * tp = NULL;
	
    //fprintf(listing,"\n symble table:\n\n");
   
	/*while*if (scope[Level]!=NULL)
	{
		fprintf(listing,"\n------  level: %d  ------\n",Level);
		table = scope[Level];
		while (table!=NULL)
		{
			switch(table->attrIR.kind)
			{
			case typeKind:
				fprintf(listing,"typeDec:\n");
				printTab(5);
				fprintf(listing,"name->%s;\n",table->idName);
				printTab(5);
				tp = table->attrIR.idtype;
				if(tp!=NULL)
					printTy(tp);
				else
					fprintf(listing,"type error!\n");
				break;
			case varKind:
				fprintf(listing,"varDec:\n");
				printTab(5);
				printVar(table);
				break;
			case procKind:
				fprintf(listing,"procDec:\n");
				printTab(5);
				printProc(table);
				break;
			}
			table = table->next;
		}
	}
}

*/
/***********************************************************/
/* 函数名  printTy                                         */
/* 功  能  把类型内部表示在输出文件中显示出来              */
/* 说  明  显示其类型名，大小，及其他相关信息              */
/***********************************************************/
/*void printTy(TypeIR * ty)
{
	switch(ty->kind)
	{
	case intTy:
		fprintf(listing,"kind->intTy;\n");
		printTab(5);
		fprintf(listing,"size->%d;\n",ty->size);
		break;
	case charTy:
		fprintf(listing,"kind->charTy;\n");
		printTab(5);
		fprintf(listing,"size->%d;\n",ty->size);
		break;
	case arrayTy:
		fprintf(listing,"kind->arrayTy;\n");
		printTab(5);
		fprintf(listing,"size->%d;\n",ty->size);
		printTab(5);
		
		if(ty->More.ArrayAttr.indexTy->kind==intTy)
		    fprintf(listing,"indextype->intTy;\n");
		else
			fprintf(listing,"indextype->charTy;\n");
		
		printTab(5);
		if(ty->More.ArrayAttr.elemTy->kind==intTy)
		    fprintf(listing,"elemtype->intTy;\n");
		else
			fprintf(listing,"elemtype->charTy;\n");
		break;
	case recordTy:
		fprintf(listing,"kind->recordTy;\n");
		printTab(5);
		fprintf(listing,"size->%d;\n",ty->size);
		
		fieldChain * tyBody = ty->More.body;
		fprintf(listing,"\n");
		printTab(3);
		fprintf(listing,"field:\n");
		
		while(tyBody!=NULL)
		{
			printTab(5);
			fprintf(listing,"id->%s;\n",tyBody->id);
			printTab(5);
			fprintf(listing,"unit");
			printTy(tyBody->UnitType);
			printTab(5);
			fprintf(listing,"off->%d;\n",tyBody->off);
			tyBody = tyBody->Next;
			fprintf(listing,"\n");
		}
		break;
	}
}
*/
/***********************************************************/
/* 函数名  printVar                                        */
/* 功  能  把变量内部表示在输出文件中显示出来              */
/* 说  明  显示其变量名称，偏移，类型名及其他              */
/***********************************************************/
/*void printVar(SymbTable * entry)
{
    fprintf(listing,"name->%s;\n",entry->idName);
				
	AttributeIR  attr = entry->attrIR;
	printTab(5);
	fprintf(listing,"level->%d;\n",attr.More.VarAttr.level);
	printTab(5);
	fprintf(listing,"off->%d;\n",attr.More.VarAttr.off);
	printTab(5);
	if(attr.More.VarAttr.isParam==true)
		fprintf(listing,"param\n");
	else
		fprintf(listing,"not param\n");
	printTab(5);
	if(attr.More.VarAttr.access==dir)
		fprintf(listing,"access->dir;\n");
	else
		fprintf(listing,"access->indir;\n");

	printTab(5);
	fprintf(listing,"\n");
	
	if(entry->attrIR.idtype!=NULL)
    {	
		printTab(5);
		printTy(entry->attrIR.idtype);
    }	
}


*/
/***********************************************************/
/* 函数名  printProc                                       */
/* 功  能  把过程内部表示在输出文件中显示出来              */
/* 说  明  显示过程名，层数                                */
/***********************************************************/
/*void printProc(SymbTable * entry)
{
	
	SymbTable * entry0 = NULL;

	fprintf(listing,"name->%s;\n",entry->idName);
				
	AttributeIR  attr = entry->attrIR;
	printTab(5);
	fprintf(listing,"level->%d;\n",attr.More.ProcAttr.level);
	ParamTable * ptable = attr.More.ProcAttr.param;
	printTab(5);

	fprintf(listing,"noff->%d; \n",entry->attrIR.More.ProcAttr.nOff);
	printTab(5);
	fprintf(listing,"moff->%d; \n",entry->attrIR.More.ProcAttr.mOff);
}

*/		
/********************************************************/
/* 函数名  FindField	  								*/
/* 功  能  查找纪录的域名								*/
/* 说  明  返回值为是否找到标志，变量Entry返回此域名在  */
/*		   纪录的域表中的位置.							*/
/********************************************************/
bool  FindField(char * Id , fieldChain  *head,fieldChain  **Entry )
{ 
	bool  present =false;
   /*记录当前节点*/
	fieldChain *currentItem = head;
   /*从表头开始查找这个标识符，直到找到或到达表尾*/
   while ((currentItem!=NULL)&&( present==false))
   { 
	  if  (strcmp(currentItem->id, Id )==0) 
	  { present= true;
	    if (Entry!=NULL)
	       (*Entry)=currentItem;
      }
      else  currentItem=currentItem->Next;
   }

  return(present);
}