#include "stdafx.h"

#include <Source.h>

#include "../BasicCompiler_Common/common.h"

void KillSpaces(char *str1,char *str2){
	int i,i2,i3,IsStr;
	for(i=0,i2=0,IsStr=0;;i++,i2++){
		if((str1[i]==' '||str1[i]=='\t')&&IsStr==0){
			i3=i+1;
			while(str1[i3]==' '||str1[i3]=='\t') i3++;
			if(i!=0){
				if(i==1){
					if(IsVariableChar(str1[i-1])&&
						IsVariableChar(str1[i3])){
						//識別子間にある省略すべきでない空白
						str2[i2++]=' ';
					}
				}
				else{
					if(str1[i-2]!=1&&IsVariableChar(str1[i-1])&&
						IsVariableChar(str1[i3])){
						//識別子間にある省略すべきでない空白
						str2[i2++]=' ';
					}
				}
			}
			i=i3;
		}
		if(str1[i]=='\"') IsStr^=1;
		str2[i2]=str1[i];
		if(str1[i]=='\0') break;
	}
}
void KillStringSpaces(char *str){
	char *s2;

	extern HANDLE hHeap;
	s2=(char *)HeapAlloc(hHeap,0,lstrlen(str)+1);
	lstrcpy(s2,str);
	KillSpaces(s2,str);
	HeapDefaultFree(s2);
	return;
}
BOOL RemoveStringQuotes(char *str){
	int i;
	if(str[0]!='\"') return 0;
	for(i=0;;i++){
		str[i]=str[i+1];
		if(str[i]=='\"') break;
	}
	str[i]=0;
	if(str[i+2]!='\0') return 0;
	return 1;
}
bool RemoveStringQuotes( std::string &str )
{
	if( str[0] != '\"' )
	{
		return false;
	}

	str = str.substr( 1, str.length() - 2 );
	return true;
}
void RemoveStringPare(char *str){
	int i;
	i=lstrlen(str);
	if(str[0]!='('||str[i-1]!=')') return;
	SlideString(str+1,-1);
	str[i-2]=0;
}
void RemoveStringBracket(char *str){
	int i;
	i=lstrlen(str);
	if(str[0]!='['||str[i-1]!=']') return;
	SlideString(str+1,-1);
	str[i-2]=0;
}
void SetStringQuotes(char *str){
	int i;
	if(str[0]=='\"') return;
	i=lstrlen(str);
	SlideString(str,1);
	str[0]='\"';
	str[i+1]='\"';
	str[i+2]=0;
}
int FormatString_EscapeSequence(char *buffer){
	int i2,i3,i4;

	for(i2=0,i3=0;;i2++,i3++){
		if(IsDBCSLeadByte(buffer[i3])){
			buffer[i2++]=buffer[i3++];
			buffer[i2]=buffer[i3];
			if(buffer[i3]=='\0') break;
			continue;
		}
		if(buffer[i3]=='\\'){
			switch(buffer[i3+1]){
				case '\\':
					buffer[i2]='\\';
					i3++;
					break;
				case '0':
					buffer[i2]='\0';
					i3++;
					break;
				case 'n':
					buffer[i2]='\n';
					i3++;
					break;
				case 'q':
					buffer[i2]='\"';
					i3++;
					break;
				case 'r':
					buffer[i2]='\r';
					i3++;
					break;
				case 't':
					buffer[i2]='\t';
					i3++;
					break;
				case 'x':
					//16進表記
					char temporary[8];
					temporary[0]=buffer[i3+2];
					temporary[1]=buffer[i3+3];
					temporary[2]=0;
					CharUpper(temporary);

					i4=temporary[0]-0x30;
					if(i4<0||9<i4){
						i4=temporary[0]-0x41+10;
						if(i4<0xA||0xF<i4){
							buffer[i2]=buffer[i3];
							break;
						}
					}
					temporary[0]=i4;

					i4=temporary[1]-0x30;
					if(i4<0||9<i4){
						i4=temporary[1]-0x41+10;
						if(i4<0xA||0xF<i4){
							buffer[i2]=buffer[i3];
							break;
						}
					}
					temporary[1]=i4;

					buffer[i2]=temporary[0]*0x10+temporary[1];
					i3+=3;
					break;
				default:
					buffer[i2]=buffer[i3];
					break;
			}
		}
		else{
			buffer[i2]=buffer[i3];
			if(buffer[i3]=='\0') break;
		}
	}
	return i2;
}
void SlideString(char *buffer, int slide){
	char *temp;
	temp=(char *)malloc(lstrlen(buffer)+1);
	lstrcpy(temp,buffer);
	lstrcpy(buffer+slide,temp);
	free(temp);
}
void SlideBuffer(char *buffer,int length,int slide){
	void *temp;
	temp=malloc(length+1);
	memcpy(temp,buffer,length);
	memcpy(buffer+slide,temp,length);
	free(temp);
}

int GetSourceCodeIndexFromLine( const char *source, int LineNum ){
	int i,nCount=0;
	for(i=0;;i++){
		if(source[i]=='\n'){
			nCount++;
			if(LineNum==nCount){
				for(i++;;i++){
					if(IsCommandDelimitation(source[i])) break;
				}
				return i;
			}
		}
	}
}

char GetEndXXXCommand(char es){
	switch(es){
		case ESC_SUB:
			return ESC_ENDSUB;
		case ESC_FUNCTION:
			return ESC_ENDFUNCTION;
		case ESC_MACRO:
			return ESC_ENDMACRO;
		case ESC_TYPE:
			return ESC_ENDTYPE;
		case ESC_CLASS:
			return ESC_ENDCLASS;
		case ESC_INTERFACE:
			return ESC_ENDINTERFACE;
		case ESC_ENUM:
			return ESC_ENDENUM;
	}
	return 0;
}
void GetDefaultNameFromES(char es,char *name){
	name[0]=0;
	switch(es){
		case ESC_PSMEM:
			lstrcpy(name,"->");
			break;
		case ESC_MOD:
			lstrcpy(name,"Mod");
			break;
		case ESC_AND:
			lstrcpy(name,"And");
			break;
		case ESC_OR:
			lstrcpy(name,"Or");
			break;
		case ESC_XOR:
			lstrcpy(name,"Xor");
			break;
		case ESC_NOT:
			lstrcpy(name,"Not");
			break;
		case ESC_AS:
			lstrcpy(name,"As");
			break;
		case ESC_THEN:
			lstrcpy(name,"Then");
			break;
		case ESC_ELSE:
			lstrcpy(name,"Else");
			break;
		case ESC_IF:
			lstrcpy(name,"If");
			break;
		case ESC_ELSEIF:
			lstrcpy(name,"ElseIf");
			break;
		case ESC_ENDIF:
			lstrcpy(name,"End If");
			break;
		case ESC_DEF:
			lstrcpy(name,"Def");
			break;
		case ESC_DECLARE:
			lstrcpy(name,"Declare");
			break;
		case ESC_ABSTRACT:
			lstrcpy(name,"Abstract");
			break;
		case ESC_VIRTUAL:
			lstrcpy(name,"Virtual");
			break;
		case ESC_OVERRIDE:
			lstrcpy(name,"Override");
			break;
		case ESC_SUB:
			lstrcpy(name,"Sub");
			break;
		case ESC_ENDSUB:
			lstrcpy(name,"End Sub");
			break;
		case ESC_EXITSUB:
			lstrcpy(name,"Exit Sub");
			break;
		case ESC_FUNCTION:
			lstrcpy(name,"Function");
			break;
		case ESC_ENDFUNCTION:
			lstrcpy(name,"End Function");
			break;
		case ESC_EXITFUNCTION:
			lstrcpy(name,"Exit Function");
			break;
		case ESC_BYVAL:
			lstrcpy(name,"ByVal ");
			break;
		case ESC_BYREF:
			lstrcpy(name,"ByRef ");
			break;
		case ESC_TYPE:
			lstrcpy(name,"Type");
			break;
		case ESC_ENDTYPE:
			lstrcpy(name,"End Type");
			break;
		case ESC_EXITFOR:
			lstrcpy(name,"Exit For");
			break;
		case ESC_EXITWHILE:
			lstrcpy(name,"Exit While");
			break;
		case ESC_EXITDO:
			lstrcpy(name,"Exit Do");
			break;
		case ESC_SELECTCASE:
			lstrcpy(name,"Select Case");
			break;
		case ESC_CASE:
			lstrcpy(name,"Case");
			break;
		case ESC_CASEELSE:
			lstrcpy(name,"Case Else");
			break;
		case ESC_ENDSELECT:
			lstrcpy(name,"End Select");
			break;
		case ESC_CONST:
			lstrcpy(name,"Const");
			break;
		case ESC_TYPEDEF:
			lstrcpy(name,"TypeDef");
			break;
		case ESC_WITH:
			lstrcpy(name,"With");
			break;
		case ESC_ENDWITH:
			lstrcpy(name,"End With");
			break;
		case ESC_CDECL:
			lstrcpy(name,"cdecl");
			break;
		case ESC_MACRO:
			lstrcpy(name,"Macro");
			break;
		case ESC_ENDMACRO:
			lstrcpy(name,"End Macro");
			break;
		case ESC_EXITMACRO:
			lstrcpy(name,"Exit Macro");
			break;
		case ESC_EXPORT:
			lstrcpy(name,"Export");
			break;
		case ESC_CONTINUE:
			lstrcpy(name,"Continue");
			break;
		case ESC_CLASS:
			lstrcpy(name,"Class");
			break;
		case ESC_ENDCLASS:
			lstrcpy(name,"End Class");
			break;
		case ESC_INTERFACE:
			lstrcpy(name,"Interface");
			break;
		case ESC_ENDINTERFACE:
			lstrcpy(name,"End Interface");
			break;
		case ESC_ENUM:
			lstrcpy(name,"Enum");
			break;
		case ESC_ENDENUM:
			lstrcpy(name,"End Enum");
			break;
	}
}
const std::string &FormatEscapeSequenceStringToDefaultString( const std::string &source )
{
	int maxLength = (int)source.size();

	char *temporary = (char *)malloc( source.size() + 8192 );
	lstrcpy( temporary, source.c_str() );

	for( int i=0; i<maxLength-1; i++ )
	{
		if( temporary[i] == 1 )
		{
			char temp2[255];
			GetDefaultNameFromES( temporary[i+1], temp2 );
			if( i>0 )
			{
				char temp3[255];
				wsprintf( temp3, " %s", temp2 );
				lstrcpy( temp2, temp3 );
			}
			if( i<maxLength-2 )
			{
				lstrcat( temp2, " " );
			}

			int length = lstrlen( temp2 );
			SlideString( temporary + i+2, length-2 );
			memcpy( temporary + i, temp2, length );
			maxLength = lstrlen( temporary );
		}
	}

	static std::string resultStr = "";
	resultStr = temporary;

	free( temporary );

	return resultStr;
}

bool IsFileExist(const char *path){
	WIN32_FIND_DATA wfd;
	HANDLE hFind;

	hFind=FindFirstFile(path,&wfd);
	if(hFind==INVALID_HANDLE_VALUE){
		return false;
	}
	FindClose(hFind);

	return true;
}
BOOL GetFolder(HWND hWnd,char *folder,char *OpenFolderTitle){
	BROWSEINFO BrowseInfo;
	LPITEMIDLIST pidlBrowse;
	LPMALLOC g_pMalloc;
	char temporary[MAX_PATH];

	BrowseInfo.hwndOwner=hWnd;
	BrowseInfo.pszDisplayName=temporary;
	BrowseInfo.pidlRoot=NULL;
	BrowseInfo.lpszTitle=OpenFolderTitle;
	BrowseInfo.ulFlags=BIF_RETURNONLYFSDIRS;
	BrowseInfo.lpfn=NULL;
	BrowseInfo.lParam=(LPARAM)0;
	BrowseInfo.iImage=0;
	pidlBrowse=SHBrowseForFolder(&BrowseInfo);
	if(pidlBrowse){
		if(SHGetMalloc(&g_pMalloc)!=0) return 0;
		SHGetPathFromIDList(pidlBrowse,folder);
		g_pMalloc->Free(pidlBrowse);
		g_pMalloc->Release();
		return 1;
	}
	return 0;
}

void ShortPathToLongPath(const char *ShortPath,char *LongPath){
	HANDLE hFind;
	WIN32_FIND_DATA wfd;
	int i;
	char dummy[MAX_PATH];
	for(i=0;i<MAX_PATH;i++){
		LongPath[i]=ShortPath[i];
		if((ShortPath[i-1]==':'&&ShortPath[i]=='\\')||(ShortPath[i-1]=='\\'&&ShortPath[i]=='\\')){
			LongPath[i+1]=0;
			break;
		}
	}
	if(ShortPath[i-1]=='\\'&&ShortPath[i]=='\\'){
		for(i++;i<MAX_PATH;i++){
			if(IsDBCSLeadByte(ShortPath[i])){
				i++;
				continue;
			}
			LongPath[i]=ShortPath[i];
			if(ShortPath[i]=='\\'){
				LongPath[i+1]=0;
				break;
			}
		}
		for(i++;i<MAX_PATH;i++){
			if(IsDBCSLeadByte(ShortPath[i])){
				i++;
				continue;
			}
			LongPath[i]=ShortPath[i];
			if(ShortPath[i]=='\\'){
				LongPath[i+1]=0;
				break;
			}
		}
	}
	for(i++;i<MAX_PATH;i++){
		if(IsDBCSLeadByte(ShortPath[i])){
			i++;
			continue;
		}
		if(ShortPath[i]=='\\'||ShortPath[i]=='\0'){
			strncpy(dummy,ShortPath,i);
			dummy[i]=0;
			if((hFind=FindFirstFile(dummy,&wfd))!=INVALID_HANDLE_VALUE) FindClose(hFind);
			lstrcat(LongPath,wfd.cFileName);

			if(ShortPath[i]=='\0') break;
			lstrcat(LongPath,"\\");

			if(ShortPath[i]=='\\'&&ShortPath[i+1]=='\0'){
				break;
			}
		}
	}
}


bool IsVariableTopChar(char c){
	if((c>='A'&&c<='Z')||(c>='a'&&c<='z')||c=='_')
	{
		return true;
	}
	return false;
}
bool IsVariableChar( char c, bool isGenericsChars ){
	if((c>='A'&&c<='Z')||(c>='a'&&c<='z')||(c>='0'&&c<='9')||
		c=='%'||c=='!'||c=='#'||c=='$'||
		c=='_'||c=='.')
	{
		return true;
	}

	if( isGenericsChars )
	{
		if( c == '<' || c == '>' )
		{
			return true;
		}
	}

	return false;
}
bool IsBlank(char c){
	if(c==' '||c=='\t') return 1;
	return 0;
}
int GetOneParameter(const char *Parameter,int pos,char *retAns){
	int i,i2,i3,IsStr;
	for(i=pos,i2=0,IsStr=0;;i++,i2++){
		if(Parameter[i]=='\"') IsStr^=1;
		else if(Parameter[i]=='('&&IsStr==0){
			i3=GetStringInPare(retAns+i2,Parameter+i);
			i+=i3-1;
			i2+=i3-1;
			continue;
		}
		else if(Parameter[i]=='['&&IsStr==0){
			i3=GetStringInBracket(retAns+i2,Parameter+i);
			i+=i3-1;
			i2+=i3-1;
			continue;
		}
		else if(Parameter[i]==','&&IsStr==0){
			retAns[i2]=0;
			i++;
			break;
		}

		if(IsCommandDelimitation(Parameter[i])&&IsStr==0
			|| Parameter[i] == ')' && IsStr == 0 ){
				retAns[i2]=0;
				break;
		}

		retAns[i2]=Parameter[i];
	}
	return i;
}
int JumpOneParameter(char *Parameter,int i){
	int i2,IsStr;
	for(i2=0,IsStr=0;;i++,i2++){
		if(Parameter[i]=='\"') IsStr^=1;
		else if(Parameter[i]=='('&&IsStr==0){
			i=JumpStringInPare(Parameter,i+1);
			continue;
		}
		else if(Parameter[i]=='['&&IsStr==0){
			i=JumpStringInBracket(Parameter,i+1);
			continue;
		}
		else if(Parameter[i]==','&&IsStr==0){
			i++;
			break;
		}
		if(IsCommandDelimitation(Parameter[i])) break;
	}
	return i;
}
int GetStringInQuotation(char *buffer,char *ReadBuffer){
	int i;

	if(ReadBuffer[0]=='\"'){
		buffer[0]=ReadBuffer[0];
		i=1;
	}
	else i=0;

	for(;;i++){
		buffer[i]=ReadBuffer[i];
		if(IsDBCSLeadByte(ReadBuffer[i])){
			i++;
			buffer[i]=ReadBuffer[i];
			continue;
		}
		if(ReadBuffer[i]=='\"'){
			i++;
			buffer[i]=0;
			break;
		}
		if(ReadBuffer[i]=='\0') return 0;
	}
	return i;
}
int GetStringInPare( char *buffer, const char *ReadBuffer, bool isRemovePare ){
	int i,IsStr,PareNum;
	for(i=0,IsStr=0,PareNum=0;;i++){
		buffer[i]=ReadBuffer[i];
		if(IsDBCSLeadByte(ReadBuffer[i])){
			i++;
			buffer[i]=ReadBuffer[i];
			continue;
		}
		if(ReadBuffer[i]=='\"') IsStr^=1;
		else if(ReadBuffer[i]=='('&&IsStr==0) PareNum++;
		else if(ReadBuffer[i]==')'&&IsStr==0){
			PareNum--;
			if(PareNum==0){
				i++;
				buffer[i]=0;
				break;
			}
		}
		else if(ReadBuffer[i]=='\0') return 0;
	}

	if( isRemovePare )
	{
		RemoveStringPare( buffer );
	}

	return i;
}
int GetStringInBracket(char *buffer,const char *ReadBuffer){
	int i,IsStr,PareNum;
	for(i=0,IsStr=0,PareNum=0;;i++){
		buffer[i]=ReadBuffer[i];
		if(IsDBCSLeadByte(ReadBuffer[i])){
			i++;
			buffer[i]=ReadBuffer[i];
			continue;
		}
		if(ReadBuffer[i]=='\"') IsStr^=1;
		else if(ReadBuffer[i]=='['&&IsStr==0) PareNum++;
		else if(ReadBuffer[i]==']'&&IsStr==0){
			PareNum--;
			if(PareNum==0){
				i++;
				buffer[i]=0;
				break;
			}
		}
		else if(ReadBuffer[i]=='\0') return 0;
	}
	return i;
}
int GetStringInGenericBracket(char *buffer,const char *ReadBuffer){
	int i,IsStr,PareNum;
	for(i=0,IsStr=0,PareNum=0;;i++){
		buffer[i]=ReadBuffer[i];
		if(IsDBCSLeadByte(ReadBuffer[i])){
			i++;
			buffer[i]=ReadBuffer[i];
			continue;
		}
		if(ReadBuffer[i]=='\"') IsStr^=1;
		else if(ReadBuffer[i]=='<'&&IsStr==0) PareNum++;
		else if(ReadBuffer[i]=='>'&&IsStr==0){
			PareNum--;
			if(PareNum==0){
				i++;
				buffer[i]=0;
				break;
			}
		}
		else if(ReadBuffer[i]=='\0') return 0;
	}
	return i;
}
int JumpStringInPare(const char *buffer,int pos){
	int PareNum;
	for(PareNum=1;;pos++){
		if(buffer[pos]=='\"'){
			for(pos++;;pos++){
				if(buffer[pos]=='\"') break;
			}
			continue;
		}
		else if(buffer[pos]=='(') PareNum++;
		else if(buffer[pos]==')'){
			PareNum--;
			if(PareNum==0) return pos;
		}
		else if(buffer[pos]=='\0') break;
	}
	return 0;
}
int JumpStringInBracket(const char *buffer,int pos){
	int PareNum;
	for(PareNum=1;;pos++){
		if(buffer[pos]=='\"'){
			for(pos++;;pos++){
				if(buffer[pos]=='\"') break;
			}
			continue;
		}
		else if(buffer[pos]=='[') PareNum++;
		else if(buffer[pos]==']'){
			PareNum--;
			if(PareNum==0) return pos;
		}
		else if(buffer[pos]=='\0') break;
	}
	return 0;
}
bool IsCommandDelimitation( char c ){
	if( c == '\n' || c == ':' || c == '\0' ){
		return true;
	}

	return false;
}

int GetStringInPare_RemovePare(char *buffer,const char *ReadBuffer){
	int i,IsStr,PareNum;
	for(i=0,IsStr=0,PareNum=1;;i++){
		buffer[i]=ReadBuffer[i];
		if(IsDBCSLeadByte(ReadBuffer[i])){
			i++;
			buffer[i]=ReadBuffer[i];
			continue;
		}
		if(ReadBuffer[i]=='\"') IsStr^=1;
		else if(ReadBuffer[i]=='('&&IsStr==0) PareNum++;
		else if(ReadBuffer[i]==')'&&IsStr==0){
			PareNum--;
			if(PareNum==0){
				buffer[i]=0;
				break;
			}
		}
		else if(ReadBuffer[i]=='\0') return 0;
	}
	return i;
}

void SplitParameter( const std::string &src, Jenga::Common::Strings &dests, bool isClear )
{
	const char *buffer = src.c_str();
	int i = 0;

	if( isClear )
	{
		dests.clear();
	}

	while( buffer[i] )
	{
		char result[8192];
		i = GetOneParameter( buffer, i, result );
		dests.push_back( result );
	}
}


bool SplitMemberName( const char *desc, char *object, char *member, ReferenceKind &refType ){
	int lastIndex = -1;
	for( int i=0; desc[i]; i++ ){
		if( desc[i] == '(' ){
			i=JumpStringInPare(desc,i+1);
			continue;
		}
		else if( desc[i] == '[' ){
			i=JumpStringInBracket(desc,i+1);
			continue;
		}
		else if(desc[i]=='.'||(desc[i]==1&&desc[i+1]==ESC_PSMEM)){
			lastIndex = i;
		}
	}
	if( lastIndex == -1 ){
		if( object )
		{
			object[0] = 0;
		}
		lstrcpy( member, desc );
		return false;
	}

	if(desc[lastIndex]=='.'){
		lstrcpy(member,desc+lastIndex+1);
		refType = RefDot;
	}
	else{
		lstrcpy(member,desc+lastIndex+2);
		refType = RefPointer;
	}

	if( object ){
		lstrcpy( object, desc );
		object[lastIndex]=0;
	}

	return true;
}
bool SplitMemberName( const char *desc, char *object, char *member ){
	ReferenceKind dummyRefType;
	return SplitMemberName( desc, object, member, dummyRefType );
}

void SplitSyntacticForAs( const char *src, char *varName, char *typeName)
{
	int i = 0;
	for( ; ; i++ )
	{
		if( src[i] == '\0' || src[i] == 1 && src[i+1] == ESC_AS )
		{
			varName[i] = 0;
			break;
		}
		varName[i] = src[i];
	}

	if( src[i] )
	{
		lstrcpy( typeName, src + i + 2 );
	}
	else
	{
		typeName[i] = 0;
	}
}

char *calcNames[255] = {
	"xor",
};
void InitCalcNames()
{
	if( calcNames[CALC_XOR] )
	{
		return;
	}

	memset( calcNames, 0, 255 * sizeof(char *) );
	calcNames[CALC_XOR] = "xor";
	calcNames[CALC_OR] = "or";
	calcNames[CALC_AND] = "and";
	calcNames[CALC_NOT] = "Not";
	calcNames[CALC_PE] = "<=";
	calcNames[CALC_QE] = ">=";
	calcNames[CALC_NOTEQUAL] = "<>";
	calcNames[CALC_EQUAL] = "=(compare)";
	calcNames[CALC_P] = "<";
	calcNames[CALC_Q] = ">";
	calcNames[CALC_SHL] = "<<";
	calcNames[CALC_SHR] = ">>";
	calcNames[CALC_ADDITION] = "+";
	calcNames[CALC_SUBTRACTION] = "-";
	calcNames[CALC_STRPLUS] = "&";
	calcNames[CALC_MOD] = "mod";
	calcNames[CALC_PRODUCT] = "*";
	calcNames[CALC_QUOTIENT] = "/";
	calcNames[CALC_INTQUOTIENT] = "\\";
	calcNames[CALC_AS] = "As";
	calcNames[CALC_BYVAL] = "ByVal";
	calcNames[CALC_MINUSMARK] = "-(mark)";
	calcNames[CALC_POWER] = "^";
	calcNames[CALC_SUBSITUATION] = "=";
	calcNames[CALC_ARRAY_GET] = "[]";
	calcNames[CALC_ARRAY_SET] = "[]=";
}
void GetCalcName(int idCalc,char *name){
	InitCalcNames();

	if( calcNames[idCalc] == NULL )
	{
		SetError();
	}
	lstrcpy( name, calcNames[idCalc] );
}
BYTE ToCalcId( const char *name )
{
	InitCalcNames();

	for( int i=0; i<255; i++ )
	{
		if( calcNames[i] )
		{
			if( lstrcmp( name, calcNames[i] ) == 0 )
			{
				return i;
			}
		}
	}
	SetError();
	return 0;
}

std::string Operator_NaturalStringToCalcMarkString( const std::string &name )
{
	if( name[0] == 1 && name[1] == ESC_OPERATOR )
	{
		BYTE calcId = ToCalcId( name.c_str()+2 );
		char temporary[255];
		temporary[0] = name[0];
		temporary[1] = name[1];
		temporary[2] = calcId;
		temporary[3] = 0;
		return temporary;
	}
	return name;
}
std::string Operator_CalcMarkStringToNaturalString( const std::string &name )
{
	if( name[0] == 1 && name[1] == ESC_OPERATOR )
	{
		BYTE calcId = name[2];
		char temporary[255], calcName[255];
		GetCalcName( calcId, calcName );
		temporary[0] = name[0];
		temporary[1] = name[1];
		lstrcpy( temporary+2, calcName );
		return temporary;
	}
	return name;
}

bool IsGenericTypeSourcePart( const char *buffer )
{
	if( buffer[0] != '<' )
	{
		Jenga::Throw( "意図しない文字列に対してIsGenericTypeSourcePart関数が呼ばれた" );
		return false;
	}

	int i=1, scopeCount=1;
	for( ; ; i++ )
	{
		if( buffer[i] == '\0' )
		{
			break;
		}
		if( buffer[i] == '<' )
		{
			scopeCount++;
		}
		else if( buffer[i] == '>' )
		{
			scopeCount--;

			if( scopeCount == 0 )
			{
				break;
			}
		}
	}

	if( buffer[i] != '>' )
	{
		return false;
	}


	/////////////////////////////////////////////////////////////////
	// '>'に続く文字を判定する
	/////////////////////////////////////////////////////////////////

	i++;
	while( IsBlank( buffer[i] ) )
	{
		i++;
	}

	if( IsVariableChar( buffer[i] ) )
	{
		return false;
	}

	return true;
}