exfunction.cpp

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

// ExFunction.cpp: implementation of the CExFunction class.
//
//////////////////////////////////////////////////////////////////////

#include "stdafx.h"

#include "ExFunction.h"
#include "IdenItem.h"
#include "Identifiers.h"
#include "CPGlobals.h"

#ifdef _DEBUG
#undef THIS_FILE
static char THIS_FILE[]=__FILE__;
#define new DEBUG_NEW
#endif

//////////////////////////////////////////////////////////////////////
// Construction/Destruction
//////////////////////////////////////////////////////////////////////

BEGIN_TEST_DUMP(PARAMETER)
    TEST_DUMP(type)
    TEST_DUMP(name)
    TEST_DUMP(defVal)
    TEST_DUMP(array)
END_TEST_DUMP()


BEGIN_TEST_DUMP(CExFunction)
    TEST_DUMP_BASE(CIdentifier)
	TEST_DUMP(mReturnType)
END_TEST_DUMP()


CExFunction::CExFunction()
{
}

CExFunction::~CExFunction()
{
    POSITION pos = mParameterList.GetHeadPosition();
	while(pos != NULL)
		delete mParameterList.GetNext(pos);

    pos = mRewriteFuncList.GetHeadPosition();
	while(pos != NULL)
		delete mRewriteFuncList.GetNext(pos);
}

CExFunction* CExFunction::ParseFunction(CTokenList& iList, 
										UINT iAccessTrim/*=TRIM_PUBLIC*/,
										BOOL iDefinition/*=FALSE*/, 
										CTokenList* iopSrcList/*=NULL*/, 
										POSITION* iopPos/*=NULL*/,
										BOOL iIsInType/*=FALSE*/)

{
    CExFunction* pFunc = new CExFunction();

	CToken* pToken = iList.GetHead();
	if(gpCurrPage != NULL && pToken != NULL)
	{
		CString comment;
		gpCurrPage->GetComment(comment, pToken->GetLine());
		pFunc->SetComment(comment);
	}
	
	ParseDeclare(iList, iAccessTrim, *pFunc, iIsInType);
	pFunc->SetCurrScope(gScope.GetCurrScope());

	if(iDefinition)
	{
		pFunc->SetDefined(TRUE);
        UINT square = 1;
		ASSERT(iopSrcList != NULL);
		ASSERT(iopPos != NULL);
		while(*iopPos != NULL)
		{
            CToken* pToken = iopSrcList->GetNext(*iopPos);
			if(pToken->GetType() == TT_LSQUARE)
				square++;
			else if(pToken->GetType() == TT_RSQUARE)
				square--;
			if(square == 0)
				break;

			pFunc->AddImpToken(pToken);
        }
	}

	TEST_TRACE(pFunc);
	return pFunc;
}


void CExFunction::ParseDeclare(CTokenList& iList, 
							   UINT iAccessTrim, 
							   CExFunction& oFunc,
							   BOOL iIsInType/*=FALSE*/)
{
	//将函数声明分解为：返回值、修饰符及域/参数表/尾部
    CTokenList list1, list2, list3;

	CToken* pToken = NULL;
	CToken* pPreToken = NULL;
	CToken* pPrePreToken = NULL;
	POSITION pos = iList.GetHeadPosition();

	//解析函数名
	while(pos != NULL)
    {
		pPrePreToken = pPreToken;
		pPreToken = pToken;
		pToken = iList.GetNext(pos);
		ASSERT(pToken != NULL);
		if(pToken->GetType() == TT_LPARAN) //出现(
		{
			CString funcName;
			if(pPreToken != NULL)
				funcName = pPreToken->GetContent();

			//注意操作符重载及析构函数
			if( pPrePreToken != NULL                                   &&
			  ( strcmp(pPrePreToken->GetContent(), "operator") == 0 || 
				strcmp(pPrePreToken->GetContent(), "~") == 0        )  )
			{
			    funcName.Insert(0, pPrePreToken->GetContent());
                list1.RemoveTail();
			}
				
			oFunc.SetName(funcName);
			break;
		}
		else
		{
			if(pPreToken != NULL)
				list1.AddTail(pPreToken);
		}
	}

	//返回类型
    //TEST_TRACE(list1);
	ParsePrecursor(list1, oFunc, iIsInType);

	//参数表
	BOOL paran = 1;
	while(pos != NULL)
	{
		pToken = iList.GetNext(pos);
		ASSERT(pToken != NULL);

		if(pToken->GetType() == TT_LPARAN) 
			paran++;
		else if(pToken->GetType() == TT_RPARAN)
			paran--;

		if(paran == 0)
			break;

		list2.AddTail(pToken);
	}

	//解析参数表
	//TEST_TRACE(list2);
	ParseParameter(list2, oFunc);

	//剩余部分
	while(pos != NULL)
	{
		pToken = iList.GetNext(pos);
		ASSERT(pToken != NULL);
		list3.AddTail(pToken);
	}

	//解析最后部分，包括是否const和纯虚函数
    //TEST_TRACE(list3);
	ParseTail(list3, oFunc);
}

void CExFunction::ParsePrecursor(CTokenList& iList, 
								 CExFunction& oFunc,
								 BOOL iIsInType/*=FALSE*/)
{
	UINT trim = 0;
	CString returnType;
	POSITION pos = iList.GetTailPosition();
	while(pos != NULL)
	{
		CToken* pToken = iList.GetPrev(pos);
		//域指令
		if(pToken->GetType() == TT_SCOPE) //::
		{
			if(!iIsInType)
			    oFunc.SetScopeReverse(pToken->GetContent());
			iList.RemoveTail();
			if(pos == NULL)
			{
                ASSERT(FALSE);
				break;
			}

			pToken = iList.GetPrev(pos);
			if(pToken != NULL && pToken->IsType(TT_GT)) //模板类 >
			{
				//oFunc.SetScopeReverse(pToken->GetContent());
				while(pos != NULL)
				{
					pToken = iList.GetPrev(pos);
					ASSERT(pToken != NULL);
                    //oFunc.SetScopeReverse(pToken->GetContent());
					iList.RemoveTail();
                    if(pToken->IsType(TT_LT)) // <
					{
						ASSERT(pos != NULL);
						pToken = iList.GetPrev(pos);
						break;
					}
				}
			}

			if(pToken != NULL && !iIsInType)
			{
			    oFunc.SetScopeReverse(pToken->GetContent());
			    iList.RemoveTail();
			}
		}
		else
		{
            break;
		}
    }


	pos = iList.GetHeadPosition();
	while(pos != NULL)
	{
		CToken* pToken = iList.GetNext(pos);
		TEST_TRACE(pToken);
		if(pToken->GetType() == TT_WORD)
		{
			POSITION tempPos = pos;
			CIdenItem* pIdenItem = gIdens.Search(pToken->GetContent());
			if(pIdenItem != NULL)
			{
                KEYWORD key = pIdenItem->keyIndex;
				//模板参数，忽略
				if(key == KEY_TEMPLATE)
				{
					while(pos != NULL)
					{
						tempPos = pos;
						pToken = iList.GetNext(pos);
						if(pToken->GetType() == TT_GT) break;
					}
				}
				else if(key == KEY_INLINE)
				{
					trim |= TRIM_INLINE;
				}
				else if(key == KEY_VIRTUAL)
				{
					trim |= TRIM_VIRTUAL;
				}
				else if(key == KEY_STATIC)
				{
					trim |= TRIM_STATIC;
				}
				else if(key==KEY_CONST || key==KEY_SIGNED || key==KEY_UNSIGNED //类型修饰
					|| pIdenItem->IsDataType() //数据类型
			        || key == KEY_NOT) //其他非关键字
				{
					CIdentifier::CatDataType(returnType, *pToken);
				}
				//忽略其他关键字
			}
			else
			{
				CIdentifier::CatDataType(returnType, *pToken);
			}
		}
		else
		{
			CIdentifier::CatDataType(returnType, *pToken);
		}
	}

	oFunc.SetTrim(trim);
	oFunc.SetReturnType(returnType);

	TEST_TRACE(returnType);
}

void CExFunction::ParseTail(CTokenList& iList, CExFunction& oFunc)
{
	UINT trim = 0;
	POSITION pos = iList.GetHeadPosition();
	while(pos != NULL)
	{
		CToken* pToken = iList.GetNext(pos);
		ASSERT(pToken != NULL);
		if(pToken->IsType(TT_WORD))
		{
			KEYWORD key = gIdens.QueryKeyword(pToken->GetContent());
			if(key == KEY_CONST)
				trim |= TRIM_CONST;
		}
		else if(pToken->IsType(TT_ASSIGN)) // =
		{
			if(pos != NULL)
			{
				pToken = iList.GetNext(pos);
				if(strcmp(pToken->GetContent(), "0") == 0)
					trim |= TRIM_PUREVIRTUAL;
			}
		}
	}

	oFunc.SetTrim(trim);
}

void CExFunction::ParseParameter(CTokenList& iList, CExFunction& oFunc)
{
    POSITION pos = iList.GetHeadPosition();
	UINT paran = 0;
	CTokenList list; //临时保存一个参数的token
	while(pos != NULL)
	{
		CToken* pToken = iList.GetNext(pos);
		ASSERT(pToken != NULL);
		UINT tt = pToken->GetType();
		if(tt == TT_LPARAN || tt == TT_LBRACE || tt == TT_LT) // < [ (
		{
			paran++;
		}
		else if(tt == TT_RPARAN || tt == TT_RBRACE || tt == TT_GT) // > ] )
		{
			paran--;
		}
		//读完一个参数的token
		else if(paran == 0 && tt == TT_COMMA) //,
		{
			PARAMETER* pParam =  ParseOneParameter(list);
			if(pParam != NULL)
				oFunc.AddParameter(pParam);
			list.RemoveAll();
			continue;
		}