hfiletodoc.cpp

文档生成工具 XML例子

// HFileToDoc.cpp: implementation of the CHFileToDoc class.
//
//////////////////////////////////////////////////////////////////////

#include "stdafx.h"
#include "XMLClassDoc.h"
#include "HFileToDoc.h"
#include "StringDefine.h"


#ifdef _DEBUG
#undef THIS_FILE
static char THIS_FILE[]=__FILE__;
#define new DEBUG_NEW
#endif
#include "atlbase.h"
using namespace MSXML2;
//////////////////////////////////////////////////////////////////////
// Construction/Destruction
//////////////////////////////////////////////////////////////////////

enum VisitType {v_public, v_protected, v_private};

CHFileToDoc::CHFileToDoc()
{
}

CHFileToDoc::~CHFileToDoc()
{

}

int CHFileToDoc::OpenFile(char* pszHFilePath)
{
	if(!ExistFile(pszHFilePath))
	{
		return -1; // -2 源文件不存在
	}
	MoveRemark(pszHFilePath);
	FindClassInfo();
	return 0;
}


BOOL CHFileToDoc::ExistFile(char *pszFilePath)
{
	CFileFind find;
	return find.FindFile(pszFilePath, 0);
}

int CHFileToDoc::MoveRemark(char *pszHFilePath)
{
	if (ExistFile(theApp.m_strCodePath.GetBuffer(0)))
	{
		DeleteFile(theApp.m_strCodePath.GetBuffer(0));
	}

	BOOL bESC = false;
	BOOL bStr = false;
	BOOL bRemark = false;
	BOOL bRemarkBlock = false;
	char readChar;
	FILE *pHFile,*pHFileCode;
	pHFile = fopen(pszHFilePath, "r");
	pHFileCode = fopen(theApp.m_strCodePath, "w");
	if ((pHFile != NULL)&&(pHFileCode != NULL))
	{
		while((readChar = fgetc(pHFile)) != EOF)
		{
			if(bRemark)
			{
				if(readChar == '\n')
				{
					bRemark = false;
					fputc('\n', pHFileCode);
					fputc(' ', pHFileCode);
				}
				continue;
			}

			if(bRemarkBlock)
			{
				if(readChar == '*')
				{
					readChar = fgetc(pHFile);
					if(readChar == '/')
					{
						bRemarkBlock = false;
						fputc('\n', pHFileCode);
						fputc(' ', pHFileCode);
					}
				}			
				continue;
			}

			if(readChar == '\n')
			{
				fputc('\n', pHFileCode);
				fputc(' ', pHFileCode);		
				continue;
			}

			if (readChar == '\"' && bESC == false)
			{
				bStr = !bStr;
			}
			if (!bStr)
			{
				if(readChar == '/')
				{
					readChar = fgetc(pHFile);
					if(readChar == '/')
					{
						bRemark = true;
						continue;
					}
					if(readChar =='*')
					{
						bRemarkBlock = true;
						continue;
					}
					fputc('/', pHFileCode);
				}			
			}
			else
			{
				if(readChar == '\\')
					bESC = true;
				else
					bESC = false;
			}
			fputc(readChar, pHFileCode);
		}

		fclose(pHFile);
		fclose(pHFileCode);
	}
	return 0;
}


void CHFileToDoc::FindClassInfo()
{
	CString strClassBlock,strClassHead;
	strClassBlock.Empty();
	strClassHead.Empty();
	BOOL bClassBlock = false;
	int bracketNum = 0;
	char readChar;

	FILE *pHFileCode;
	pHFileCode = fopen(theApp.m_strCodePath, "r");
	if (pHFileCode != NULL)
	{
		while((readChar = fgetc(pHFileCode)) != EOF)
		{
			if(bClassBlock)
			{
				while((readChar = fgetc(pHFileCode)) != EOF)
				{
					strClassBlock += readChar;
					if (readChar =='{')
					{
						bracketNum++;
					}
					if (readChar =='}')
					{
						bracketNum--;
						if(bracketNum == 0)
						{
							OutClassInfo(strClassHead, strClassBlock);
							bClassBlock = false;
							strClassBlock.Empty();
							strClassHead.Empty();
							break;
						}
					}
				}
			}
			else
			{
				if(readChar == ' ')
				{
					if(    (readChar = fgetc(pHFileCode) == 'c') 
						&& (readChar = fgetc(pHFileCode) == 'l')
						&& (readChar = fgetc(pHFileCode) == 'a')
						&& (readChar = fgetc(pHFileCode) == 's')
						&& (readChar = fgetc(pHFileCode) == 's')
						&& (readChar = fgetc(pHFileCode) == ' '))
					{
						strClassHead = "class ";
						while((readChar = fgetc(pHFileCode)) != EOF)
						{
							if( readChar != '{')
							{
								strClassHead += readChar;
							}
							else
							{
								strClassBlock += readChar;
								bClassBlock = true;
								bracketNum++;
								break;
							}
						}
					}
				}
			}
		}
	}
	fclose(pHFileCode);
	DeleteFile(theApp.m_strCodePath);
}

BOOL CHFileToDoc::OutClassInfo(CString strClassHead, CString &strClassBlock)
{
	CString strClassName;
	strClassName = OutClassHeadInfo(strClassHead);
	if(strClassName.IsEmpty())
	{
		return false;
	}
	CUIntArray *keysortarray = DispartClass(strClassBlock);
	
	CString strSect;
	for(int i=0 ; i<keysortarray->GetSize()-1; i++)
	{
		int start = keysortarray->GetAt(i);
		int count = keysortarray->GetAt(i+1) - start;
		strSect = strClassBlock.Mid(start, count);
		OutSect(strSect, strClassName);
	}

	if(keysortarray->GetSize() != 0)
	{
		strSect = strClassBlock.Mid(keysortarray->GetAt(keysortarray->GetSize()-1));
		OutSect(strSect, strClassName);
	}

	delete keysortarray;
	return true;
}

char* CHFileToDoc::TrimBuff(char *buff)
{
	char* pData;
	pData = &buff[strlen(buff) - 1];
	while(((*pData <= ' ')||(*pData >= '~'))&&(pData!=buff))
		{ *pData=0;pData--;}

	pData = &buff[0];
	while((*pData <= ' ')||(*pData >= '~'))
		{ *pData=0;pData++;}
	return pData;
}

CString CHFileToDoc::OutClassHeadInfo(CString& strClassHead)
{
	char *pszData,pszBuff[1024];
	CString strClassName, strBaseClass;
	strClassName.Empty( );
	strBaseClass.Empty( );
	memset(pszBuff, 0, sizeof(pszBuff));
	sprintf(pszBuff, "%s", strClassHead);
	pszData = TrimBuff(pszBuff);
	int start = 0;
	int end = 0;
	char* pData;

	start = ((CString)pszData).Find("class ") + 6;
	pData = &pszData[start];
	end = start;
	while((*pData == ' ')||(*pData == '\t'))
	{
		pData++;
		end++;
	}
	while(((*pData != ' ')&&(*pData != '\t'))&&(start > 0))
	{
		pData++;
		end++;
	}
	strClassName = ((CString)pszData).Mid(start, end - start);
	start = ((CString)pszData).Find(":");
	if(start > -1)
	{
		strBaseClass = ((CString)pszData).Mid(start + 1);
	}
	

	USES_CONVERSION;
	HRESULT hr = NULL;
	hr = ::CoInitialize(NULL);
	if(FAILED(hr))
	{
		MessageBox(0,"error!", 0,0);
		return "";
	}
	{
		IXMLDOMDocumentPtr pXmlDoc;
		IXMLDOMNodePtr pXmlNode;
		IXMLDOMNodeListPtr pXmlNodeList;
		
		try
		{	
			hr = pXmlDoc.CreateInstance(__uuidof(DOMDocument));
			if(FAILED(hr))
			{
				MessageBox(0,"error!",0,0);
				strClassName = "";
			}
			else
			{
				char pszOutFilePath[160];
				BOOL bWriteClass = true;
				memset(pszOutFilePath, 0, sizeof(pszOutFilePath));
				sprintf(pszOutFilePath,"%s\\%s%s", theApp.m_strLocPath, strClassName, FILEEXT);

			

				//////////////////////////////////////////////
				if(bWriteClass)
				{
					CString strTemplateXML = CreateTemplate();
					pXmlDoc->loadXML(_bstr_t(strTemplateXML));
					pXmlNodeList = pXmlDoc->selectNodes(_bstr_t("Classes/class/name"));
					pXmlNode = pXmlNodeList->nextNode();
					pXmlNode->Puttext(_bstr_t(strClassName));
					
					pXmlNodeList = pXmlDoc->selectNodes(_bstr_t("Classes/class/declare"));
					pXmlNode = pXmlNodeList->nextNode();
					pXmlNode->Puttext(_bstr_t(pszData));
					pXmlDoc->save(_bstr_t(pszOutFilePath));
				}
			}
		}
		catch(_com_error& e)
		{
			MessageBox(0, W2A(e.Description()),0,0);
		}
	}