exfunction.cpp

这是一个能够自动生成文档的程序

		list.AddTail(pToken);
	}
	
	PARAMETER* pParam =  ParseOneParameter(list);
	if(pParam != NULL)
		oFunc.AddParameter(pParam);
}

PARAMETER* CExFunction::ParseOneParameter(CTokenList& iList)
{
	if(iList.IsEmpty()) return NULL;

	//保存到oFuc,并由其删除
	PARAMETER* pParam = new PARAMETER;

	//首先解析缺省值
    POSITION pos = iList.GetHeadPosition();
	while(pos != NULL)
	{
		POSITION currPos = pos;
		CToken* pToken = iList.GetNext(pos);
		ASSERT(pToken != NULL);

		//有缺省值
		if(pToken->GetType() == TT_ASSIGN)
		{
			iList.RemoveAt(currPos);
			while(pos != NULL)
			{
				POSITION currPos = pos;
				pToken = iList.GetNext(pos);
                pToken->CatContentTo(pParam->defVal);
				iList.RemoveAt(currPos);
			}
		}
	}

	//是否为数组
    pos = iList.GetHeadPosition();
	while(pos != NULL)
	{
		POSITION currPos = pos;
		CToken* pToken = iList.GetNext(pos);
		ASSERT(pToken != NULL);

		// [
		if(pToken->GetType() == TT_LBRACE)
		{
			pToken->CatContentTo(pParam->array);
			iList.RemoveAt(currPos);
			while(pos != NULL)
			{
				POSITION currPos = pos;
				pToken = iList.GetNext(pos);
                pToken->CatContentTo(pParam->array);
				iList.RemoveAt(currPos);
			}
		}
	}
	
	//注意，有可能无参数名
	//最后一个token，如果前面的token有实质类型，并且此token是一个标识符，
	//则此token是参数名，否则为缺少参数名
	CToken* pTailToken = iList.GetTail();
	ASSERT(pTailToken != NULL);
	iList.RemoveTail();

    BOOL pureType = FALSE; //是否找到实质类型
	pos = iList.GetHeadPosition();
	while(pos != NULL)
	{
		CToken* pToken = iList.GetNext(pos);
		ASSERT(pToken != NULL);
		if(pToken->GetType() == TT_WORD)
		{
			CIdenItem* pIdenItem = gIdens.Search(pToken->GetContent());
			if(pIdenItem != NULL)
			{
				if(pIdenItem->IsDataType())
					pureType = TRUE;
			}
			else //其他不明标识符视为类型名
			{
				pureType = TRUE;
			}
		}

		CIdentifier::CatDataType(pParam->type, *pToken);
	}

	if(!pureType || pTailToken->GetType() != TT_WORD)
		CIdentifier::CatDataType(pParam->type, *pTailToken);
	else
		pParam->name = pTailToken->GetContent();
	
	return pParam;
}

PARAMETER* CExFunction::ParseOneParameter2(CTokenList& iList)
{
	if(iList.IsEmpty()) return NULL;

	//保存到oFuc,并由其删除
	PARAMETER* pParam = new PARAMETER;

	//首先解析缺省值
	ParseOneParameter2DefaultValue(iList, *pParam);

	//解析参数类型中的数组
	ParseOneParameter2Array(iList, *pParam);

	//由于类型与参数名不能简单分辩，所以一起解析
	ParseOneParameter2TypeAndName(iList, *pParam);

	return pParam;
}

void CExFunction::ParseOneParameter2DefaultValue(CTokenList& iList, PARAMETER& oParam)
{
    POSITION pos = iList.GetHeadPosition();
	while(pos != NULL)
	{
		POSITION currPos = pos;
		CToken* pToken = iList.GetNext(pos);
		ASSERT(pToken != NULL);

		//有缺省值
		if(pToken->GetType() == TT_ASSIGN)
		{
			iList.RemoveAt(currPos);
			while(pos != NULL)
			{
				POSITION currPos = pos;
				pToken = iList.GetNext(pos);
                pToken->CatContentTo(oParam.defVal);
				//将缺省值token从列表中删除
				iList.RemoveAt(currPos);
			}
		}
	}
}

void CExFunction::ParseOneParameter2Array(CTokenList& iList, PARAMETER& oParam)
{
    POSITION pos = iList.GetHeadPosition();
	while(pos != NULL)
	{
		POSITION currPos = pos;
		CToken* pToken = iList.GetNext(pos);
		ASSERT(pToken != NULL);

		//参数类型中包括数组
		if(pToken->GetType() == TT_LBRACE)
		{
			pToken->CatContentTo(oParam.array);
			iList.RemoveAt(currPos);
			while(pos != NULL)
			{
				POSITION currPos = pos;
				pToken = iList.GetNext(pos);
                pToken->CatContentTo(oParam.array);
				//将数组token从列表中删除
				iList.RemoveAt(currPos);
			}
		}
	}
}

void CExFunction::ParseOneParameter2TypeAndName(CTokenList& iList, PARAMETER& oParam)
{
	//注意，有可能没有参数名
	//最后一个token，如果前面的token有实质类型，并且此token是一个标识符，
	//则此token是参数名，否则为缺少参数名
	if(iList.IsEmpty()) return;
	CToken* pTailToken = iList.GetTail();
	ASSERT(pTailToken != NULL);
	iList.RemoveTail();

    BOOL pureType = FALSE; //是否找到实质类型
	POSITION pos = iList.GetHeadPosition();
	while(pos != NULL)
	{
		CToken* pToken = iList.GetNext(pos);
		ASSERT(pToken != NULL);
		if(pToken->GetType() == TT_WORD)
		{
			CIdenItem* pIdenItem = gIdens.Search(pToken->GetContent());
			if(pIdenItem != NULL)
			{
				if(pIdenItem->IsDataType())
					pureType = TRUE;
			}
			else //其他不明标识符视为类型名
			{
				pureType = TRUE;
			}
		}

		CIdentifier::CatDataType(oParam.type, *pToken);
	}

	if(!pureType || pTailToken->GetType() != TT_WORD)
		CIdentifier::CatDataType(oParam.type, *pTailToken);
	else
		oParam.name = pTailToken->GetContent();
}

BOOL CExFunction::IsParamEqual(LPCTSTR iParamType, int iIndex)
{
	if(iIndex >= 0 && iIndex < mParameterList.GetCount())
	{
		 POSITION pos = mParameterList.FindIndex(iIndex);
		 ASSERT(pos != NULL);
		 PARAMETER* pParam = mParameterList.GetAt(pos);
		 ASSERT(pParam != NULL);
		 if(pParam->type == iParamType)
			 return TRUE;
	}

	return FALSE;
}


BOOL CExFunction::operator == (CExFunction& oOther)
{
	if(mName != oOther.GetName())
		return FALSE;

	if(mParameterList.GetCount() != oOther.GetParameterCount())
		return FALSE;

	POSITION pos = mParameterList.GetHeadPosition();
	int index = 0;
	while(pos != NULL)
	{
		PARAMETER* pParam = mParameterList.GetNext(pos);
		ASSERT(pParam != NULL);
		if(!oOther.IsParamEqual(pParam->type, index++))
            return FALSE;
	}

	return TRUE;
}

void CExFunction::UniteFunction(CExFunction* ipOther)
{
	ASSERT(mName == ipOther->GetName());
	//暂不处理重定义之类的错误

	//参数表相同，同一函数
	if(*this == *ipOther)
	{
		if(ipOther->IsDefined() && !this->IsDefined())
		{
			this->SetDefined(TRUE);
		}

		delete ipOther;
		return;
	}
    else
	{
		POSITION pos = mRewriteFuncList.GetHeadPosition();
		while(pos != NULL)
		{
			CExFunction* pFunc = mRewriteFuncList.GetNext(pos);
			ASSERT(pFunc != NULL);
			if(*pFunc == *ipOther)
			{
				if(ipOther->IsDefined() && !pFunc->IsDefined())
				{
					pFunc->SetDefined(TRUE);
				}

				delete ipOther;
				return;
			}
		}

		//新的重载函数
        mRewriteFuncList.AddTail(ipOther);
	}
}

void CExFunction::GetPrototype(CString& oPrototype)
{
	CString head;
	if(ISTRIM(mTrim, VIRTUAL)) head += "virtual ";
	if(ISTRIM(mTrim, STATIC))  head += "static ";

	CString param;
	POSITION pos = mParameterList.GetHeadPosition();
	while(pos != NULL)
	{
		if(!param.IsEmpty()) param += ",";
		PARAMETER* pParam = mParameterList.GetNext(pos);
		ASSERT(pParam != NULL);
		param += pParam->type;
		if(!pParam->name.IsEmpty())
			param += " " + pParam->name;
		if(!pParam->array.IsEmpty())
            param += pParam->array;
		if(!pParam->defVal.IsEmpty())
			param += "=" + pParam->defVal;
	}

	CString tail;
	if(ISTRIM(mTrim, CONST)) tail += " const";
	if(ISTRIM(mTrim, PUREVIRTUAL))  tail += "=0";

	CString type(mReturnType);
	if(!type.IsEmpty()) type += ' ';
	oPrototype.Format("%s%s%s(%s)%s;", head, type, mName, param, tail);
}

void CExFunction::OutputSymbols(CXml& oXml, LPCTSTR iPath)
{
 	CString path, tag;
	tag.Format("<function name=\"%s\">", mName);
	oXml.AddNode(tag, iPath, NULL, "</function>");   

	path = iPath + tag;
    CString prototype;
	GetPrototype(prototype);
	int index = 1;
	tag.Format("<prototype index=\"%d\">", index++);
    oXml.AddNode(tag, path, prototype, "</prototype>");
	
	const UINT DESC_LEN = 50;
	CString desc;
    CIdentifier::GetStringLeft(desc, mComment, DESC_LEN);
	oXml.AddNode("<desc>", path, desc, "</desc>");
	oXml.AddNode("<explain>", path, mComment, "</explain>");


    POSITION pos = mRewriteFuncList.GetHeadPosition();
	while(pos != NULL)
	{
		CExFunction* pFunc = mRewriteFuncList.GetNext(pos);
		ASSERT(pFunc != NULL);
        pFunc->GetPrototype(prototype);
	    tag.Format("<prototype index=\"%d\">", index++);
        oXml.AddNode(tag, path, prototype, "</prototype>");
	}
}