www.gusucode.com > 一个VC++语法分析模块程序实例源码程序 > 一个VC++语法分析模块程序实例/CompileSys/CompileSys/PL/Compiler.cpp

    // Compiler.cpp: implementation of the CCompiler class.
// Download by http://www.codesc.net
//////////////////////////////////////////////////////////////////////

#include "stdafx.h"
#include "Compiler.h"

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

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

#define LEN_KEYWORDTAB 15//关键字表长
#define LEN_OPRSYMTAB  11//运算符表长
#define LEN_BNDSYMTAB  4 //界符表长

//关键字表
const char tabKeyWord[LEN_KEYWORDTAB][10]=
{
	"program",
	"const",
	"var",
	"procedure",
	"begin",
	"end",
	"if",
	"then",
	"else",
	"while",
	"do",
	"call",
	"read",
	"write",
	"odd",
};

//运算符表
const char tabOprSym[LEN_OPRSYMTAB][3]=
{
	"+",
	"-",
	"*",
	"/",
	"=",
	"<",
	">",
	"<>",
	"<=",
	">=",
	":=",
};

//界符表
const char tabBndSym[LEN_BNDSYMTAB][2]=
{
	";",
	",",
	"(",
	")",
};

CCompiler::CCompiler()
{

}

CCompiler::~CCompiler()
{
	//下面这段释放内存的代码不知道为什么出错
//	for(int i=0;i<m_iVecotrSymbolSize;i++)
//		delete m_vectorSymbol[i].szStr;
}

bool CCompiler::LexAnalysis(char *szStr)
{
	SYNTAXERR seTemp;

	if(!strcmp(szStr,""))
	{
		seTemp.iSyntaxErrCode=SE_FE_NOCODE;
		m_vectorSyntaxErr.push_back(seTemp);

		return 0;
	}

	int nLen;
	char *szTemp;
	LEXPROPERTYVS lpvTemp;
	char *szStrBU=szStr;

	strlwr(szStr);//小写字符串

	while(*szStr!='\0')
	{
		szStr=JumpNoMatterChar(szStr);
		if(*szStr=='\0')
			break;

		nLen=0;
		if(isalpha(*szStr))
		{
			lpvTemp.nStrPos=szStr-szStrBU;

			while(isalpha(*szStr) || isdigit(*szStr))
			{
				nLen++;
				szStr++;
			}
			
			szTemp=new char[nLen];
			memcpy(szTemp,szStr-nLen,nLen);
			szTemp[nLen]='\0';

			lpvTemp.nStrLen=nLen;
			if(IsKeyWord(szTemp))
				lpvTemp.lpProperty=KeyWord;//该字符串为关键字
			else
				lpvTemp.lpProperty=Id;     //该字符串可能为变量,过程名,常量
			lpvTemp.szStr=szTemp;
			m_vectorSymbol.push_back(lpvTemp);
		}
		else
		{
			if(isdigit(*szStr))
			{
				lpvTemp.nStrPos=szStr-szStrBU;

				while(isdigit(*szStr))
				{
					nLen++;
					szStr++;
				}

				szTemp=new char[nLen];
			    memcpy(szTemp,szStr-nLen,nLen);
				szTemp[nLen]='\0';

				lpvTemp.nStrLen=nLen;
				lpvTemp.lpProperty=Const;
				lpvTemp.szStr=szTemp;
				m_vectorSymbol.push_back(lpvTemp);
			}
			else
			{
				lpvTemp.nStrPos=szStr-szStrBU;

				szTemp=new char[2];
				if(!isalpha(*szStr) && !isdigit(*szStr) && *szStr!='\r' && *szStr!='\n' && *szStr!='\0' && *szStr!=' ' && *szStr!=9)
				{
					szTemp[0]=*szStr;
					szStr++;
				}

				switch(szTemp[0])
				{
				case '<':
					if(*szStr=='=' || *szStr=='>')
					{
						szTemp[1]='=';
						szTemp[2]='\0';
						lpvTemp.lpProperty=OprSym;
						lpvTemp.nStrLen=2;
						szStr++;
					}
					else
					{
						szTemp[1]='\0';
						lpvTemp.lpProperty=OprSym;
						lpvTemp.nStrLen=1;
					}
					break;

				case '>':
					if(*szStr=='=')
					{
						szTemp[1]='=';
						szTemp[2]='\0';
						lpvTemp.lpProperty=OprSym;
						lpvTemp.nStrLen=2;
						szStr++;
					}
					else
					{
						szTemp[1]='\0';
						lpvTemp.lpProperty=OprSym;
						lpvTemp.nStrLen=1;
					}
					break;

				case ':':
					if(*szStr=='=')
					{
						szTemp[1]='=';
						szTemp[2]='\0';
						lpvTemp.lpProperty=OprSym;
						lpvTemp.nStrLen=2;
						szStr++;
					}
					else
					{
						szTemp[1]='\0';
						lpvTemp.lpProperty=IllegalChar;
						lpvTemp.nStrLen=1;
						seTemp.iSyntaxErrCode=SE_ILLEGALCHAR;
						m_vectorSyntaxErr.push_back(seTemp);
					}
					break;
					
				default:
					szTemp[1]='\0';
					if(IsOprSym(szTemp))
					{
						lpvTemp.nStrLen=1;
						lpvTemp.lpProperty=OprSym;
					}
					else
					{
						if(IsBndSym(szTemp))
						{
							lpvTemp.nStrLen=1;
							lpvTemp.lpProperty=BndSym;
						}
						else//有错误产生
						{
							lpvTemp.nStrLen=1;
							lpvTemp.lpProperty=IllegalChar;
							seTemp.iSyntaxErrCode=SE_ILLEGALCHAR;
							m_vectorSyntaxErr.push_back(seTemp);
						}
					}
					
					break;
				}

				lpvTemp.szStr=szTemp;
				m_vectorSymbol.push_back(lpvTemp);
			}
		}
	}

	return 1;
}

bool CCompiler::IsKeyWord(char *szStr)
{
	for(int i=0;i<LEN_KEYWORDTAB;i++)
	{
		if(!strcmp(szStr,tabKeyWord[i]))
			return 1;
	}

	return 0;
}

bool CCompiler::IsBndSym(char *szStr)
{
	for(int i=0;i<LEN_BNDSYMTAB;i++)
	{
		if(!strcmp(szStr,tabBndSym[i]))
			return 1;
	}

	return 0;
}

bool CCompiler::IsOprSym(char *szStr)
{
	for(int i=0;i<LEN_OPRSYMTAB;i++)
	{
		if(!strcmp(szStr,tabOprSym[i]))
			return 1;
	}

	return 0;
}

bool CCompiler::IsInSymbolTab(char *szStr)
{
	for(int i=0;i<m_iVecotrSymbolSize;i++)
	{
		if(!strcmp(m_vectorSymbol[i].szStr,szStr))
			return 1;
	}

	return 0;
}

void CCompiler::SyntaxAnalysis()
{
	SyntaxAnalysis_Prog();
}

void CCompiler::Compile(char *szFile)
{
	char *szStr;
	int nLength;
	CFile file(szFile,0);
	CString str;
	CString strLeft,strRight;
	int nPos;

	m_iCurPointer=0;          //复位符号表指针
	m_vectorSyntaxErr.clear();//清空语法错误向量
	m_vectorSymbol.clear();   //清空符号表向量

	nLength=file.GetLength();
	szStr=new char[nLength];
	file.Read(szStr,nLength);
	szStr[nLength]='\0';

	if(!LexAnalysis(szStr))//词法分析
		return;

	//-----------输出符号表-----------
	str.Format("%s",szFile);
	nPos=str.ReverseFind('\\');
	strLeft=str.Left(nPos+1);
	strRight=str.Right(str.GetLength()-nPos-1);
	if(strRight.Right(4)==".pas")
		str=strLeft+strRight.Left(strRight.GetLength()-4)+"_LexAnanlysisResult.dat";
	else
		str=strLeft+strRight+"_LexAnanlysisResult.dat";

	OutSymbolTab((LPSTR)(LPCSTR)str);
	//--------------------------------

	m_iVecotrSymbolSize=m_vectorSymbol.size();

	SyntaxAnalysis();//语法分析
}

void CCompiler::SyntaxAnalysis_Prog()
{
	SYNTAXERR seTemp;

	if(strcmp("program",m_vectorSymbol[m_iCurPointer++].szStr))//语法出错:程序必须以Program开头
	{
		seTemp.iSyntaxErrCode=SE_PROGHEAD;
		m_vectorSyntaxErr.push_back(seTemp);
	}

	if(m_iVecotrSymbolSize==m_iCurPointer)//语法出错:遇到意外的文件结束:Program后应有程序名,分号和程序块
	{
		seTemp.iSyntaxErrCode=SE_FE_PROGNEEDIDSYMBLOCK;
		m_vectorSyntaxErr.push_back(seTemp);

		return;
	}

	switch(SyntaxAnalysis_Id())
	{
	case ID_FIRSTERR:
		seTemp.iSyntaxErrCode=SE_ID_PROGNAMEFIRST;//语法出错:定义程序名的变量名的第一个字符必须为字母
		m_vectorSyntaxErr.push_back(seTemp);
		break;

	case ID_MIDERR:
		seTemp.iSyntaxErrCode=SE_ID_PROGNAMEMID;//语法出错:定义程序名的变量名的中间字符或为字母
		m_vectorSyntaxErr.push_back(seTemp);
		break;
	}

	if(m_iVecotrSymbolSize==m_iCurPointer)//语法出错:遇到意外的文件结束:程序名后必须有分号和程序块
	{
		seTemp.iSyntaxErrCode=SE_FE_NEEDSYMBLOCK;
		m_vectorSyntaxErr.push_back(seTemp);
		
		return;
	}
	
	if(strcmp(";",m_vectorSymbol[m_iCurPointer++].szStr))//语法出错:定义程序名的变量名后必须以分号结束
	{
		seTemp.iSyntaxErrCode=SE_PROGTAIL;
		m_vectorSyntaxErr.push_back(seTemp);
	}

	if(m_iVecotrSymbolSize==m_iCurPointer)//语法出错:遇到意外的文件结束:程序必须有程序块
	{
		seTemp.iSyntaxErrCode=SE_FE_NEEDBLOCK;
		m_vectorSyntaxErr.push_back(seTemp);
		
		return;
	}

	SyntaxAnalysis_Block();

	if(m_iVecotrSymbolSize>m_iCurPointer)//语法出错:多余的文件尾-程序以程序块结束,程序块后面不应再有程序
	{
		seTemp.iSyntaxErrCode=SE_UNWANTEDTAIL;
		m_vectorSyntaxErr.push_back(seTemp);
	}
}

int CCompiler::SyntaxAnalysis_Id()
{
	int iSize=strlen(m_vectorSymbol[m_iCurPointer].szStr);

	if(!isalpha(m_vectorSymbol[m_iCurPointer].szStr[0]))
	{
		m_iCurPointer++;
		return ID_FIRSTERR;
	}

	for(int i=1;i<iSize;i++)
	{
		if(!isalpha(m_vectorSymbol[m_iCurPointer].szStr[i]) && !isdigit(m_vectorSymbol[m_iCurPointer].szStr[i]))//语法出错
		{
			m_iCurPointer++;
			return ID_MIDERR;
		}
	}

	m_iCurPointer++;
	return -1;
}

int CCompiler::SyntaxAnalysis_Block()
{
	SYNTAXERR seTemp;

	if(SyntaxAnalysis_Condecl()==FILEEND)
	{
		seTemp.iSyntaxErrCode=SE_FE_NEEDBODY;
		m_vectorSyntaxErr.push_back(seTemp);
		return FILEEND;
	}

	if(m_iVecotrSymbolSize==m_iCurPointer)//语法出错:遇到意外的文件结束:程序必须有程序体
	{
		seTemp.iSyntaxErrCode=SE_FE_NEEDBODY;
		m_vectorSyntaxErr.push_back(seTemp);
		
		return FILEEND;
	}

	if(SyntaxAnalysis_Vardecl()==FILEEND)
	{
		seTemp.iSyntaxErrCode=SE_FE_NEEDBODY;
		m_vectorSyntaxErr.push_back(seTemp);
		return FILEEND;
	}
	
	if(m_iVecotrSymbolSize==m_iCurPointer)//语法出错:遇到意外的文件结束:程序必须有程序体
	{
		seTemp.iSyntaxErrCode=SE_FE_NEEDBODY;
		m_vectorSyntaxErr.push_back(seTemp);
		
		return FILEEND;
	}

	if(SyntaxAnalysis_Proc()==FILEEND)
	{
		seTemp.iSyntaxErrCode=SE_FE_NEEDBODY;
		m_vectorSyntaxErr.push_back(seTemp);
		return FILEEND;
	}

	if(m_iVecotrSymbolSize==m_iCurPointer)//语法出错:遇到意外的文件结束:程序必须有程序体
	{
		seTemp.iSyntaxErrCode=SE_FE_NEEDBODY;
		m_vectorSyntaxErr.push_back(seTemp);
		
		return FILEEND;
	}

	return SyntaxAnalysis_Body();
}

int CCompiler::SyntaxAnalysis_Condecl()
{
	SYNTAXERR seTemp;

	if(strcmp("const",m_vectorSymbol[m_iCurPointer++].szStr))//语法出错:定义常量时必须以关键字Const开头
	{
		m_iCurPointer--;
		return 0;//不像是常量定义,返回
	}
	
	if(m_iVecotrSymbolSize==m_iCurPointer)//语法出错:遇到意外的文件结束:关键字Const后面必须有变量名
	{
		seTemp.iSyntaxErrCode=SE_FE_CONSTEND;
		m_vectorSyntaxErr.push_back(seTemp);
		
		return FILEEND;//应该是常量定义
	}

	if(SyntaxAnalysis_Const()==FILEEND)
		return FILEEND;

	if(m_iVecotrSymbolSize==m_iCurPointer)
		return 1;

	while(!strcmp(",",m_vectorSymbol[m_iCurPointer].szStr))
	{
		m_iCurPointer++;
		if(m_iVecotrSymbolSize==m_iCurPointer)//语法出错:遇到意外的文件结束:定义常量时，“，”后面应该有变量
		{
			seTemp.iSyntaxErrCode=SE_FE_CONSTSYMEND;
			m_vectorSyntaxErr.push_back(seTemp);
			
			return FILEEND;
		}

		if(SyntaxAnalysis_Const()==FILEEND)
			return FILEEND;

		if(m_iVecotrSymbolSize==m_iCurPointer)
			return 1;
	}

	return 1;
}

int CCompiler::SyntaxAnalysis_Vardecl()
{
	SYNTAXERR seTemp;

	if(strcmp("var",m_vectorSymbol[m_iCurPointer++].szStr))//语法出错
	{
		m_iCurPointer--;
		return 0;
	}

	if(m_iVecotrSymbolSize==m_iCurPointer)//语法出错:遇到意外的文件结束:关键字Var后面必须有变量名
	{
		seTemp.iSyntaxErrCode=SE_FE_VAREND;
		m_vectorSyntaxErr.push_back(seTemp);
		
		return FILEEND;//应该是变量定义
	}

	switch(SyntaxAnalysis_Id())//语法出错:定义变量的变量名的第一个字符必须为字母
	{
	case ID_FIRSTERR://语法出错:定义变量的变量名的第一个字符必须为字母
		seTemp.iSyntaxErrCode=SE_ID_VARNAMEFIRST;
		m_vectorSyntaxErr.push_back(seTemp);
		break;

	case ID_MIDERR://语法出错:定义变量的变量名的中间字符或为字母或为数字
		seTemp.iSyntaxErrCode=SE_ID_VARNAMEMID;
		m_vectorSyntaxErr.push_back(seTemp);
		break;
	}

	if(m_iVecotrSymbolSize==m_iCurPointer)
		return 1;

	while(!strcmp(",",m_vectorSymbol[m_iCurPointer].szStr))
	{
		m_iCurPointer++;
		if(m_iVecotrSymbolSize==m_iCurPointer)//语法出错:遇到意外的文件结束:定义变量还未结束
		{
			seTemp.iSyntaxErrCode=SE_FE_VARNOEND;
			m_vectorSyntaxErr.push_back(seTemp);
			
			return FILEEND;
		}

		switch(SyntaxAnalysis_Id())//语法出错:定义变量的变量名的第一个字符必须为字母
		{
		case ID_FIRSTERR://语法出错:定义变量的变量名的第一个字符必须为字母
			seTemp.iSyntaxErrCode=SE_ID_VARNAMEFIRST;
			m_vectorSyntaxErr.push_back(seTemp);
			break;
			
		case ID_MIDERR://语法出错:定义变量的变量名的中间字符或为字母或为数字
			seTemp.iSyntaxErrCode=SE_ID_VARNAMEMID;
			m_vectorSyntaxErr.push_back(seTemp);
			break;
		}

		if(m_iVecotrSymbolSize==m_iCurPointer)
			return 1;
	}

	return 1;
}

int CCompiler::SyntaxAnalysis_Proc()
{
	SYNTAXERR seTemp;

	if(strcmp("procedure",m_vectorSymbol[m_iCurPointer++].szStr))//语法出错
	{
		m_iCurPointer--;
		return 0;
	}

	if(m_iVecotrSymbolSize==m_iCurPointer)//语法出错:遇到意外的文件结束:关键字Procedure后面必须有过程名
	{
		seTemp.iSyntaxErrCode=SE_FE_PROCNONAME;
		m_vectorSyntaxErr.push_back(seTemp);
		
		return FILEEND;//应该是过程定义
	}

	//检查过程名
	switch(SyntaxAnalysis_Id())
	{
	case ID_FIRSTERR://语法出错:定义过程名的变量名的第一个字符必须为字母
		seTemp.iSyntaxErrCode=SE_ID_PROCNAMEFIRST;
		m_vectorSyntaxErr.push_back(seTemp);
		break;

	case ID_MIDERR://语法出错:定义过程名的变量名的中间字符或为字母或为数字
		seTemp.iSyntaxErrCode=SE_ID_PROCNAMEMID;
		m_vectorSyntaxErr.push_back(seTemp);
		break;
	}
	
	if(m_iVecotrSymbolSize==m_iCurPointer)//语法出错:遇到意外的文件结束:过程名后无括号和参数
	{
		seTemp.iSyntaxErrCode=SE_FE_NOPROCSYMARG;
		m_vectorSyntaxErr.push_back(seTemp);
		
		return FILEEND;//应该是过程定义
	}

	if(strcmp("(",m_vectorSymbol[m_iCurPointer++].szStr))//语法出错
	{
		seTemp.iSyntaxErrCode=SE_PROCLSYMBOL;
		m_vectorSyntaxErr.push_back(seTemp);
	}
	
	if(m_iVecotrSymbolSize==m_iCurPointer)//语法出错:遇到意外的文件结束:过程名后参数
	{
		seTemp.iSyntaxErrCode=SE_FE_PROCNOARG;
		m_vectorSyntaxErr.push_back(seTemp);
		
		return FILEEND;//应该是过程定义
	}

	//检查过程参数
	switch(SyntaxAnalysis_Id())
	{
	case ID_FIRSTERR://语法出错:定义过程参数的变量名的第一个字符必须为字母
		seTemp.iSyntaxErrCode=SE_ID_PROCARGNAMEFIRST;
		m_vectorSyntaxErr.push_back(seTemp);
		break;

	case ID_MIDERR://语法出错:定义过程参数的变量名的中间字符或为字母或为数字
		seTemp.iSyntaxErrCode=SE_ID_PROCARGNAMEMID;
		m_vectorSyntaxErr.push_back(seTemp);
		break;
	}

	if(m_iVecotrSymbolSize==m_iCurPointer)//语法出错:遇到意外的文件结束:过程名后无参数
	{
		seTemp.iSyntaxErrCode=SE_FE_PROCNORSYM;
		m_vectorSyntaxErr.push_back(seTemp);
		
		return FILEEND;//应该是过程定义
	}

	while(!strcmp(",",m_vectorSymbol[m_iCurPointer].szStr))
	{
		m_iCurPointer++;
		if(m_iVecotrSymbolSize==m_iCurPointer)//语法出错:遇到意外的文件结束:过程参数还未写完
		{
			seTemp.iSyntaxErrCode=SE_FE_PROCAGRNOEND;
			m_vectorSyntaxErr.push_back(seTemp);
			
			return FILEEND;
		}

		//检查过程参数
		switch(SyntaxAnalysis_Id())
		{
		case ID_FIRSTERR://语法出错:定义过程参数的变量名的第一个字符必须为字母
			seTemp.iSyntaxErrCode=SE_ID_PROCARGNAMEFIRST;
			m_vectorSyntaxErr.push_back(seTemp);
			break;
			
		case ID_MIDERR://语法出错:定义过程参数的变量名的中间字符或为字母或为数字
			seTemp.iSyntaxErrCode=SE_ID_PROCARGNAMEMID;
			m_vectorSyntaxErr.push_back(seTemp);
			break;
		}

		if(m_iVecotrSymbolSize==m_iCurPointer)//语法出错:遇到意外的文件结束:过程参数后应有')'
		{
			seTemp.iSyntaxErrCode=SE_FE_PROCNORSYM;
			m_vectorSyntaxErr.push_back(seTemp);
			
			return FILEEND;
		}
	}
	
	if(m_iVecotrSymbolSize==m_iCurPointer)//语法出错:遇到意外的文件结束:过程参数后应有')'
	{
		seTemp.iSyntaxErrCode=SE_FE_PROCNORSYM;
		m_vectorSyntaxErr.push_back(seTemp);
		
		return FILEEND;//应该是过程定义
	}

	if(strcmp(")",m_vectorSymbol[m_iCurPointer++].szStr))//语法出错
	{
		seTemp.iSyntaxErrCode=SE_PROCRSYMBOL;
		m_vectorSyntaxErr.push_back(seTemp);
	}

	if(m_iVecotrSymbolSize==m_iCurPointer)//语法出错:遇到意外的文件结束:定义完过程后必须以分号结束
	{
		seTemp.iSyntaxErrCode=SE_FE_PROCEND;
		m_vectorSyntaxErr.push_back(seTemp);
		
		return FILEEND;//应该是过程定义
	}

	if(strcmp(";",m_vectorSymbol[m_iCurPointer++].szStr))//语法出错:定义完过程后必须以分号结束
	{
		seTemp.iSyntaxErrCode=SE_PROCEND;
		m_vectorSyntaxErr.push_back(seTemp);
	}
	
	if(m_iVecotrSymbolSize==m_iCurPointer)//语法出错:遇到意外的文件结束:过程无块
	{
		seTemp.iSyntaxErrCode=SE_FE_PROCNOBLOCK;
		m_vectorSyntaxErr.push_back(seTemp);
		
		return FILEEND;
	}

	if(SyntaxAnalysis_Block()==FILEEND)
		return FILEEND;

	if(m_iVecotrSymbolSize==m_iCurPointer)
			return 1;

	while(!strcmp(";",m_vectorSymbol[m_iCurPointer].szStr))
	{
		m_iCurPointer++;
		if(m_iVecotrSymbolSize==m_iCurPointer)//语法出错:遇到意外的文件结束:另一个过程还未定义
		{
			seTemp.iSyntaxErrCode=SE_FE_PROCNOPROC;
			m_vectorSyntaxErr.push_back(seTemp);
			
			return FILEEND;
		}

		if(SyntaxAnalysis_Proc()==FILEEND)
			return FILEEND;
		
		if(m_iVecotrSymbolSize==m_iCurPointer)
			return 1;
	}

	return 1;
}

int CCompiler::SyntaxAnalysis_Body()
{
	SYNTAXERR seTemp;

	if(strcmp("begin",m_vectorSymbol[m_iCurPointer++].szStr))//语法出错:程序体必须以关键字Begin开头
	{
		seTemp.iSyntaxErrCode=SE_BEGINHEAD;
		m_vectorSyntaxErr.push_back(seTemp);
	}

	if(m_iVecotrSymbolSize==m_iCurPointer)//语法出错:遇到意外的文件结束:程序体无语句
	{
		seTemp.iSyntaxErrCode=SE_FE_BODYNOSTATE;
		m_vectorSyntaxErr.push_back(seTemp);
		
		return FILEEND;
	}

	if(SyntaxAnalysis_Statement()==FILEEND)
		return FILEEND;
	
	if(m_iVecotrSymbolSize==m_iCurPointer)//语法出错:遇到意外的文件结束:程序体应该以关键字End结束
	{
		seTemp.iSyntaxErrCode=SE_FE_BODYNOEND;
		m_vectorSyntaxErr.push_back(seTemp);
		
		return FILEEND;
	}

	while(!strcmp(";",m_vectorSymbol[m_iCurPointer].szStr))
	{
		m_iCurPointer++;
		if(m_iVecotrSymbolSize==m_iCurPointer)//语法出错:遇到意外的文件结束:语句后面的分号后面应该还有语句
		{
			seTemp.iSyntaxErrCode=SE_FE_BODYSYMNOSTATE;
			m_vectorSyntaxErr.push_back(seTemp);
			
			return FILEEND;
		}

		if(SyntaxAnalysis_Statement()==FILEEND)
			return FILEEND;

		if(m_iVecotrSymbolSize==m_iCurPointer)//语法出错:遇到意外的文件结束:程序体应该以关键字End结束
		{
			seTemp.iSyntaxErrCode=SE_FE_BODYNOEND;
			m_vectorSyntaxErr.push_back(seTemp);
			
			return FILEEND;
		}
	}

	if(m_iVecotrSymbolSize==m_iCurPointer)//语法出错:遇到意外的文件结束:程序体应该以关键字End结束
	{
		seTemp.iSyntaxErrCode=SE_FE_BODYNOEND;
		m_vectorSyntaxErr.push_back(seTemp);
		
		return FILEEND;
	}

	if(strcmp("end",m_vectorSymbol[m_iCurPointer++].szStr))//语法出错:程序体应该以关键字End结束
	{
		seTemp.iSyntaxErrCode=SE_BODYEND;
		m_vectorSyntaxErr.push_back(seTemp);
	}

	return 1;
}

bool CCompiler::SyntaxAnalysis_Integer()
{
	int iSize=strlen(m_vectorSymbol[m_iCurPointer].szStr);
	
	for(int i=0;i<iSize;i++)
	{
		if(!isdigit(m_vectorSymbol[m_iCurPointer].szStr[i]))//语法出错
		{
			m_iCurPointer++;
			return 0;
		}
	}

	m_iCurPointer++;
	return 1;
}

int CCompiler::SyntaxAnalysis_Const()
{
	SYNTAXERR seTemp;

	if(!SyntaxAnalysis_Id())
	{
		seTemp.iSyntaxErrCode=SE_ID_CONSTNAME;
		m_vectorSyntaxErr.push_back(seTemp);
	}

	if(m_iVecotrSymbolSize==m_iCurPointer)//语法出错:遇到意外的文件结束:必须给常量赋值
	{
		seTemp.iSyntaxErrCode=SE_FE_CONSTIDEND;
		m_vectorSyntaxErr.push_back(seTemp);
		
		return FILEEND;
	}

	if(strcmp(":=",m_vectorSymbol[m_iCurPointer++].szStr))//语法出错:常量赋值符号应为:=
	{
		seTemp.iSyntaxErrCode=SE_CONSTSYMBOL;
		m_vectorSyntaxErr.push_back(seTemp);
	}

	if(m_iVecotrSymbolSize==m_iCurPointer)//语法出错:遇到意外的文件结束:常量赋值符号":="后应有常量
	{
		seTemp.iSyntaxErrCode=SE_FE_CONSTSYMBOLEND;
		m_vectorSyntaxErr.push_back(seTemp);
		
		return FILEEND;
	}

	if(!SyntaxAnalysis_Integer())
	{
		seTemp.iSyntaxErrCode=SE_INT_CONST;
		m_vectorSyntaxErr.push_back(seTemp);
	}

	return 1;
}

int CCompiler::SyntaxAnalysis_Statement()
{
	SYNTAXERR seTemp;

	//为赋值语句
	if(SyntaxAnalysis_Id()==-1 && !IsKeyWord(m_vectorSymbol[m_iCurPointer-1].szStr))
	{
		if(m_iVecotrSymbolSize==m_iCurPointer)//语法出错:遇到意外的文件结束:赋值语句没有赋值符号与表达式
		{
			seTemp.iSyntaxErrCode=SE_FE_EVELUATENOSYMEXP;
			m_vectorSyntaxErr.push_back(seTemp);
			
			return FILEEND;
		}

		if(strcmp(":=",m_vectorSymbol[m_iCurPointer++].szStr))//语法出错:赋值符号应未:=
		{
			seTemp.iSyntaxErrCode=SE_VAREVELUATE;
			return 0;
		}

		if(m_iVecotrSymbolSize==m_iCurPointer)//语法出错:遇到意外的文件结束:赋值语句没有表达式
		{
			seTemp.iSyntaxErrCode=SE_FE_EVELUATENOEXP;
			m_vectorSyntaxErr.push_back(seTemp);
			
			return FILEEND;
		}

		if(SyntaxAnalysis_Exp()==FILEEND)
			return FILEEND;

		return 1;
	}
	
	m_iCurPointer--;
	//为if语句
	if(!strcmp("if",m_vectorSymbol[m_iCurPointer].szStr))
	{
		m_iCurPointer++;

		if(m_iVecotrSymbolSize==m_iCurPointer)//语法出错:遇到意外的文件结束:if语句后没有表达式,关键字then和表达式
		{
			seTemp.iSyntaxErrCode=SE_FE_IFNOLEXPTHENLEXP;
			m_vectorSyntaxErr.push_back(seTemp);
			
			return FILEEND;
		}

		if(SyntaxAnalysis_Lexp()==FILEEND)
			return FILEEND;

		if(m_iVecotrSymbolSize==m_iCurPointer)//语法出错:遇到意外的文件结束:if语句后没有关键字then和表达式
		{
			seTemp.iSyntaxErrCode=SE_FE_IFNOTHENLEXP;
			m_vectorSyntaxErr.push_back(seTemp);
			
			return FILEEND;
		}

		if(strcmp("then",m_vectorSymbol[m_iCurPointer++].szStr))//语法出错:if语句没有关键字then
		{
			seTemp.iSyntaxErrCode=SE_NOTHEN;
			m_vectorSyntaxErr.push_back(seTemp);
		}

		if(m_iVecotrSymbolSize==m_iCurPointer)//语法出错:遇到意外的文件结束:if语句没有表达式
		{
			seTemp.iSyntaxErrCode=SE_FE_IFNOLEXP;
			m_vectorSyntaxErr.push_back(seTemp);
			
			return FILEEND;
		}

		if(SyntaxAnalysis_Statement()==FILEEND)
			return FILEEND;

		if(!strcmp("else",m_vectorSymbol[m_iCurPointer].szStr))
		{
			m_iCurPointer++;
			
			if(m_iVecotrSymbolSize==m_iCurPointer)//语法出错:遇到意外的文件结束:if语句的关键字else后面没有表达式
			{
				seTemp.iSyntaxErrCode=SE_FE_IFELSENOLEXP;
				m_vectorSyntaxErr.push_back(seTemp);
				
				return FILEEND;
			}
			
			return SyntaxAnalysis_Statement();
		}

		return 1;
	}

	//为While语句
	if(!strcmp("while",m_vectorSymbol[m_iCurPointer].szStr))
	{
		m_iCurPointer++;

		if(m_iVecotrSymbolSize==m_iCurPointer)//语法出错:遇到意外的文件结束:while语句后没有表达式,关键字do和语句
		{
			seTemp.iSyntaxErrCode=SE_FE_WHILENOLEXPDOSTATE;
			m_vectorSyntaxErr.push_back(seTemp);
			
			return FILEEND;
		}

		if(SyntaxAnalysis_Lexp()==FILEEND)
			return FILEEND;
		
		if(m_iVecotrSymbolSize==m_iCurPointer)//语法出错:遇到意外的文件结束:while语句后没有表达式,关键字do和语句
		{
			seTemp.iSyntaxErrCode=SE_FE_WHILENODOSTATE;
			m_vectorSyntaxErr.push_back(seTemp);
			
			return FILEEND;
		}

		if(strcmp("do",m_vectorSymbol[m_iCurPointer++].szStr))//语法出错:while语句没有关键字then
		{
			seTemp.iSyntaxErrCode=SE_NODO;
			m_vectorSyntaxErr.push_back(seTemp);
		}

		if(m_iVecotrSymbolSize==m_iCurPointer)//语法出错:遇到意外的文件结束:while语句没有表达式
		{
			seTemp.iSyntaxErrCode=SE_FE_WHILENOSTATE;
			m_vectorSyntaxErr.push_back(seTemp);
			
			return FILEEND;
		}

		return SyntaxAnalysis_Statement();
	}

	//为Call语句
	if(!strcmp("call",m_vectorSymbol[m_iCurPointer].szStr))
	{
		m_iCurPointer++;

		if(m_iVecotrSymbolSize==m_iCurPointer)//语法出错:遇到意外的文件结束:call语句后过程名
		{
			seTemp.iSyntaxErrCode=SE_FE_CALLNOID;
			m_vectorSyntaxErr.push_back(seTemp);
			
			return FILEEND;
		}

		switch(SyntaxAnalysis_Id())
		{
		case ID_FIRSTERR://语法出错:关键字call所调用的过程名的第一个字符必须为字母
			seTemp.iSyntaxErrCode=SE_ID_CALLPROCFIRST;
			m_vectorSyntaxErr.push_back(seTemp);
			break;
			
		case ID_MIDERR://语法出错:关键字call所调用的过程名的中间字符或为字母或为数字
			seTemp.iSyntaxErrCode=SE_ID_CALLPROCMID;
			m_vectorSyntaxErr.push_back(seTemp);
			break;
		}

		if(m_iVecotrSymbolSize==m_iCurPointer)//语法出错:遇到意外的文件结束:Call语句后无表达式
		{
			seTemp.iSyntaxErrCode=SE_FE_CALLNOEXP;
			m_vectorSyntaxErr.push_back(seTemp);
			
			return FILEEND;
		}

		//过程调用带参数
		if(!strcmp("(",m_vectorSymbol[m_iCurPointer].szStr))
		{
			m_iCurPointer++;

			if(m_iVecotrSymbolSize==m_iCurPointer)//语法出错:遇到意外的文件结束:Call语句调用过程时'('后面必须有表达式和')'
			{
				seTemp.iSyntaxErrCode=SE_FE_CALLNOEXPRSYM;
				m_vectorSyntaxErr.push_back(seTemp);
				
				return FILEEND;
			}

			if(SyntaxAnalysis_Exp()==FILEEND)
				return FILEEND;
			
			if(m_iVecotrSymbolSize==m_iCurPointer)//语法出错:遇到意外的文件结束:Call语句调用过程时后面必须有')'
			{
				seTemp.iSyntaxErrCode=SE_FE_CALLNORSYM;
				m_vectorSyntaxErr.push_back(seTemp);
				
				return FILEEND;
			}
			
			while(!strcmp(",",m_vectorSymbol[m_iCurPointer].szStr))
			{
				m_iCurPointer++;
				
				if(m_iVecotrSymbolSize==m_iCurPointer)//语法出错:遇到意外的文件结束:call语句调用过程时'('后面必须有表达式和')'
				{
					seTemp.iSyntaxErrCode=SE_FE_CALLNOEXPRSYM;
					m_vectorSyntaxErr.push_back(seTemp);
					
					return FILEEND;
				}

				if(SyntaxAnalysis_Exp()==FILEEND)
					return FILEEND;
				
				if(m_iVecotrSymbolSize==m_iCurPointer)//语法出错:遇到意外的文件结束:call语句调用过程时后面必须有')'
				{
					seTemp.iSyntaxErrCode=SE_FE_CALLNORSYM;
					m_vectorSyntaxErr.push_back(seTemp);
					
					return FILEEND;
				}
			}

			if(m_iVecotrSymbolSize==m_iCurPointer)//语法出错:遇到意外的文件结束:Call语句调用过程时后面必须有')'
			{
				seTemp.iSyntaxErrCode=SE_FE_CALLNORSYM;
				m_vectorSyntaxErr.push_back(seTemp);
				
				return FILEEND;
			}

			if(strcmp(")",m_vectorSymbol[m_iCurPointer++].szStr))//语法出错:Call语句调用过程时后面必须有')'
			{
				seTemp.iSyntaxErrCode=SE_CALLEND;
				m_vectorSyntaxErr.push_back(seTemp);
			}

			return 1;
		}

		return 1;
	}

	//为Read语句
	if(!strcmp("read",m_vectorSymbol[m_iCurPointer].szStr))
	{
		m_iCurPointer++;

		if(m_iVecotrSymbolSize==m_iCurPointer)//语法出错:遇到意外的文件结束:read语句后无'('和变量和')'
		{
			seTemp.iSyntaxErrCode=SE_FE_READNOLSYMIDRSYM;
			m_vectorSyntaxErr.push_back(seTemp);
			
			return FILEEND;
		}

		if(strcmp("(",m_vectorSymbol[m_iCurPointer++].szStr))//语法出错:read语句没有'('
		{
			seTemp.iSyntaxErrCode=SE_READNOLSYM;
			m_vectorSyntaxErr.push_back(seTemp);
		}
		
		if(m_iVecotrSymbolSize==m_iCurPointer)//语法出错:遇到意外的文件结束:Read语句后无变量和')'
		{
			seTemp.iSyntaxErrCode=SE_FE_READNOIDRSYM;
			m_vectorSyntaxErr.push_back(seTemp);
			
			return FILEEND;
		}

		switch(SyntaxAnalysis_Id())
		{
		case ID_FIRSTERR://语法出错:关键字read后的变量的第一个字符必须为字母
			seTemp.iSyntaxErrCode=SE_ID_READIDFIRST;
			m_vectorSyntaxErr.push_back(seTemp);
			break;
			
		case ID_MIDERR://语法出错:关键字read后的变量的中间字符或为字母或为数字
			seTemp.iSyntaxErrCode=SE_ID_READIDMID;
			m_vectorSyntaxErr.push_back(seTemp);
			break;
		}

		if(m_iVecotrSymbolSize==m_iCurPointer)//语法出错:遇到意外的文件结束:read语句后无')'
		{
			seTemp.iSyntaxErrCode=SE_FE_READNORSYM;
			m_vectorSyntaxErr.push_back(seTemp);
			
			return FILEEND;
		}

		while(!strcmp(",",m_vectorSymbol[m_iCurPointer].szStr))
		{
			m_iCurPointer++;
			
			if(m_iVecotrSymbolSize==m_iCurPointer)//语法出错:遇到意外的文件结束:Read语句中逗号','后无变量
			{
				seTemp.iSyntaxErrCode=SE_FE_READNOID;
				m_vectorSyntaxErr.push_back(seTemp);
				
				return FILEEND;
			}

			switch(SyntaxAnalysis_Id())
			{
			case ID_FIRSTERR://语法出错:关键字read后的变量的第一个字符必须为字母
				seTemp.iSyntaxErrCode=SE_ID_READIDFIRST;
				m_vectorSyntaxErr.push_back(seTemp);
				break;
				
			case ID_MIDERR://语法出错:关键字read后的变量的中间字符或为字母或为数字
				seTemp.iSyntaxErrCode=SE_ID_READIDMID;
				m_vectorSyntaxErr.push_back(seTemp);
				break;
			}

			if(m_iVecotrSymbolSize==m_iCurPointer)//语法出错:遇到意外的文件结束:Read语句后无')'
			{
				seTemp.iSyntaxErrCode=SE_FE_READNORSYM;
				m_vectorSyntaxErr.push_back(seTemp);
				
				return FILEEND;
			}
		}

		if(m_iVecotrSymbolSize==m_iCurPointer)//语法出错:遇到意外的文件结束:Read语句后')'
		{
			seTemp.iSyntaxErrCode=SE_FE_READNORSYM;
			m_vectorSyntaxErr.push_back(seTemp);
			
			return FILEEND;
		}

		if(strcmp(")",m_vectorSymbol[m_iCurPointer++].szStr))//语法出错:Read语句没有')'
		{
			seTemp.iSyntaxErrCode=SE_READNORSYM;
			m_vectorSyntaxErr.push_back(seTemp);
		}

		return 1;
	}

	//为write语句
	if(!strcmp("write",m_vectorSymbol[m_iCurPointer].szStr))
	{
		m_iCurPointer++;

		if(m_iVecotrSymbolSize==m_iCurPointer)//语法出错:遇到意外的文件结束:Write语句后无'(',表达式和')'
		{
			seTemp.iSyntaxErrCode=SE_FE_WRITENOLSYMEXPRSYM;
			m_vectorSyntaxErr.push_back(seTemp);
			
			return FILEEND;
		}

		if(strcmp("(",m_vectorSymbol[m_iCurPointer++].szStr))//语法出错:Write语句没有'('
		{
			seTemp.iSyntaxErrCode=SE_WRITENOLSYM;
			m_vectorSyntaxErr.push_back(seTemp);
		}
		
		if(m_iVecotrSymbolSize==m_iCurPointer)//语法出错:遇到意外的文件结束:Write语句后无表达式和')'
		{
			seTemp.iSyntaxErrCode=SE_FE_WRITENOEXPRSYM;
			m_vectorSyntaxErr.push_back(seTemp);
			
			return FILEEND;
		}

		if(SyntaxAnalysis_Exp()==FILEEND)
			return FILEEND;
		
		if(m_iVecotrSymbolSize==m_iCurPointer)//语法出错:遇到意外的文件结束:Write语句后无')'
		{
			seTemp.iSyntaxErrCode=SE_FE_WRITENORSYM;
			m_vectorSyntaxErr.push_back(seTemp);
			
			return FILEEND;
		}

		while(!strcmp(",",m_vectorSymbol[m_iCurPointer].szStr))
		{
			m_iCurPointer++;
			
			if(m_iVecotrSymbolSize==m_iCurPointer)//语法出错:遇到意外的文件结束:Write语句中逗号','后无变量
			{
				seTemp.iSyntaxErrCode=SE_FE_WRITENOID;
				m_vectorSyntaxErr.push_back(seTemp);
				
				return FILEEND;
			}

			switch(SyntaxAnalysis_Id())
			{
			case ID_FIRSTERR://语法出错:关键字Write后的变量的第一个字符必须为字母
				seTemp.iSyntaxErrCode=SE_ID_WRITEIDFIRST;
				m_vectorSyntaxErr.push_back(seTemp);
				break;
				
			case ID_MIDERR://语法出错:关键字Write后的变量的中间字符或为字母或为数字
				seTemp.iSyntaxErrCode=SE_ID_WriteIDMID;
				m_vectorSyntaxErr.push_back(seTemp);
				break;
			}

			if(m_iVecotrSymbolSize==m_iCurPointer)//语法出错:遇到意外的文件结束:Write语句后无')'
			{
				seTemp.iSyntaxErrCode=SE_FE_WRITENORSYM;
				m_vectorSyntaxErr.push_back(seTemp);
				
				return FILEEND;
			}
		}

		if(strcmp(")",m_vectorSymbol[m_iCurPointer++].szStr))//语法出错:Write语句后没有')'
		{
			seTemp.iSyntaxErrCode=SE_WRITENORSYM;
			m_vectorSyntaxErr.push_back(seTemp);
		}

		return 1;
	}

	return SyntaxAnalysis_Body();
}

int CCompiler::SyntaxAnalysis_Exp()
{
	SYNTAXERR seTemp;

	if(!strcmp("+",m_vectorSymbol[m_iCurPointer].szStr))
		m_iCurPointer++;
	else
	{
		if(!strcmp("-",m_vectorSymbol[m_iCurPointer].szStr))
			m_iCurPointer++;
	}
	
	if(m_iVecotrSymbolSize==m_iCurPointer)//语法出错:遇到意外的文件结束:表达式后无项
	{
		seTemp.iSyntaxErrCode=SE_FE_EXPNOTERM;
		m_vectorSyntaxErr.push_back(seTemp);
		
		return FILEEND;
	}

	if(SyntaxAnalysis_Term()==FILEEND)
		return FILEEND;
	
	if(m_iVecotrSymbolSize==m_iCurPointer)//文件结束
		return FILEEND;

	while(SyntaxAnalysis_Aop())
	{
		if(m_iVecotrSymbolSize==m_iCurPointer)//语法出错:遇到意外的文件结束:表达式中'+'或'-'后无项
		{
			seTemp.iSyntaxErrCode=SE_FE_EXPSYMNOTERM;
			m_vectorSyntaxErr.push_back(seTemp);
			
			return FILEEND;
		}
		
		if(SyntaxAnalysis_Term()==FILEEND)
			return FILEEND;

		if(m_iVecotrSymbolSize==m_iCurPointer)//文件结束
			return FILEEND;
	}

	return 1;
}

int CCompiler::SyntaxAnalysis_Lexp()
{
	SYNTAXERR seTemp;

	if(!strcmp("odd",m_vectorSymbol[m_iCurPointer].szStr))
	{
		m_iCurPointer++;

		if(m_iVecotrSymbolSize==m_iCurPointer)//语法出错:遇到意外的文件结束:关键字Odd应有表达式
		{
			seTemp.iSyntaxErrCode=SE_FE_ODDNOEXP;
			m_vectorSyntaxErr.push_back(seTemp);
			
			return FILEEND;
		}

		if(SyntaxAnalysis_Exp()==FILEEND)
			return FILEEND;

		return 1;
	}

	if(SyntaxAnalysis_Exp()==1)
	{
		if(m_iVecotrSymbolSize==m_iCurPointer)//语法出错:遇到意外的文件结束:表达式后应有运算符和表达式
		{
			seTemp.iSyntaxErrCode=SE_FE_LEXPNOEXPLOPEXP;
			m_vectorSyntaxErr.push_back(seTemp);
			
			return FILEEND;
		}

		if(!SyntaxAnalysis_Lop())//语法出错:表达式之间无运算符号
		{
			seTemp.iSyntaxErrCode=SE_LEXPNOLOP;
			m_vectorSyntaxErr.push_back(seTemp);
		}

		if(m_iVecotrSymbolSize==m_iCurPointer)//语法出错:遇到意外的文件结束:表达式后应有运算符和表达式
		{
			seTemp.iSyntaxErrCode=SE_FE_LEXPNOEXPLOPEXP;
			m_vectorSyntaxErr.push_back(seTemp);
			
			return FILEEND;
		}

		if(SyntaxAnalysis_Exp()==FILEEND)
			return FILEEND;
		
		return 1;
	}

	return 0;
}

bool CCompiler::SyntaxAnalysis_Lop()
{
	if(strcmp("=",m_vectorSymbol[m_iCurPointer].szStr) && strcmp("<>",m_vectorSymbol[m_iCurPointer].szStr) && 
		strcmp("<",m_vectorSymbol[m_iCurPointer].szStr) && strcmp(">",m_vectorSymbol[m_iCurPointer].szStr) && 
		strcmp("<=",m_vectorSymbol[m_iCurPointer].szStr) && strcmp(">=",m_vectorSymbol[m_iCurPointer].szStr))
		return 0;

	m_iCurPointer++;
	return 1;
}

bool CCompiler::SyntaxAnalysis_Aop()
{
	if(strcmp("+",m_vectorSymbol[m_iCurPointer].szStr) && strcmp("-",m_vectorSymbol[m_iCurPointer].szStr))
		return 0;

	m_iCurPointer++;
	return 1;
}

int CCompiler::SyntaxAnalysis_Term()
{
	SYNTAXERR seTemp;

	if(SyntaxAnalysis_Factor()==FILEEND)
		return FILEEND;

	if(m_iVecotrSymbolSize==m_iCurPointer)
		return FILEEND;

	while(SyntaxAnalysis_Mop())
	{
		if(m_iVecotrSymbolSize==m_iCurPointer)//语法出错:遇到意外的文件结束:项无'(',表达式和')'
		{
			seTemp.iSyntaxErrCode=SE_FE_TERMNOFACTOR;
			m_vectorSyntaxErr.push_back(seTemp);
			
			return FILEEND;
		}

		if(SyntaxAnalysis_Factor()==FILEEND)
			return FILEEND;
	}

	return 1;
}

int CCompiler::SyntaxAnalysis_Factor()
{
	if(SyntaxAnalysis_Id())
		return 1;

	m_iCurPointer--;
	if(SyntaxAnalysis_Integer())
		return 1;

	SYNTAXERR seTemp;

	m_iCurPointer--;
	if(!strcmp("(",m_vectorSymbol[m_iCurPointer++].szStr))//语法出错
	{
		if(m_iVecotrSymbolSize==m_iCurPointer)//语法出错:遇到意外的文件结束:因子无'(',表达式和')'
		{
			seTemp.iSyntaxErrCode=SE_FE_FACTORNOLSYMEXPRSYM;
			m_vectorSyntaxErr.push_back(seTemp);
			
			return FILEEND;
		}

		if(SyntaxAnalysis_Exp()==FILEEND)
			return FILEEND;

		if(strcmp(")",m_vectorSymbol[m_iCurPointer++].szStr))//语法出错:因子后没有')'
		{
			seTemp.iSyntaxErrCode=SE_FACTORNORSYM;
			m_vectorSyntaxErr.push_back(seTemp);
		}
	}

	return 0;
}

bool CCompiler::SyntaxAnalysis_Mop()
{
	if(strcmp("*",m_vectorSymbol[m_iCurPointer].szStr) && strcmp("/",m_vectorSymbol[m_iCurPointer].szStr))
		return 0;

	m_iCurPointer++;
	return 1;
}

char* CCompiler::JumpNoMatterChar(char *szStr)
{
	//跳过空格,回车,换行符,Tab
	while(*szStr==' ' || *szStr=='\r' || *szStr=='\n' || *szStr==9)
		szStr++;

	return szStr;
}

void CCompiler::OutSymbolTab(char *szFile)
{
	ofstream ofs(szFile,ios::binary);
	int nLen=m_vectorSymbol.size();

	for(int i=0;i<nLen;i++)
		ofs.write((char*)&m_vectorSymbol[i],sizeof(LEXPROPERTYVS)-sizeof(char*));

	ofs.close();
}