#include "stdafx.h"

// del by xlc on 100309 移到Geo去了
// 是否全部为数字
/*
BOOL IsDigital(const TCHAR *pStr) 
{
	ASSERT(pStr);
	int nLen = _tcslen(pStr);
	if (!nLen)
		return FALSE;
	for (int i=0; i<nLen; i++)
	{
		if (!isdigit(pStr[i]))
			return FALSE;
	}
	return TRUE;
}
*/


/////////////////////////////////////////////////////////////////////////////////
// 字母的向后推导
TCHAR GetNextAxisAlpha(TCHAR cCur)
{
	if (cCur == _T('Z')) // 本身已经不合理，但不管
		return _T('a');
	if (cCur == _T('z')) // 不再往下推导
		return cCur;

	cCur++;
	if (cCur==_T('I') || cCur==_T('i') || cCur==_T('O') || cCur==_T('o'))
		cCur++;
	else if (cCur == _T('Z'))
		cCur = _T('a');
	return cCur;
}


/////////////////////////////////////////////////////////////////////////////////
// 如果没有_T('/')，则全部作为分母
// 如果有_T('/')，_T('/')后的部分，作为分母
BOOL XAxisNoParser::GetDenominator(XString &sDenominator) const // 求分母
{
	TCHAR *pSep = _tcschr(str, _T('/'));
	if (pSep ==	NULL)
	{
		sDenominator = str;
	}
	else
	{
		TCHAR szTemp[256] = _T("");
		StrCpy(szTemp, pSep+1, NULL);
		sDenominator = szTemp;
	}
	return TRUE;
}

// 如果没有_T('/')，则返回FALSE
// 如果有_T('/')，_T('/')前的部分，作为分子
BOOL XAxisNoParser::GetNumerator(XString &sNumerator) const // 求分子
{
	TCHAR *pSep = _tcschr(str, _T('/'));
	if (pSep == NULL)
	{
		return FALSE;
	}
	else
	{
		TCHAR szTemp[256] = _T("");
		StrCpy(szTemp, str, pSep);
		sNumerator = szTemp;
	}
	return TRUE;
}


/////////////////////////////////////////////////////////////////////////////////
// 求分区号，分区号用_T('-')分割
// 如：_T("1-A")，回传_T("1")
BOOL XAxisNoParser::GetRegionNo(XString &sRegion) const
{
/*
	TCHAR *pSep = _tcschr(str, _T('-'));
	if (!pSep)
		return FALSE;
	TCHAR szPrefix[256]=_T("");
	StrCpy(szPrefix, str, pSep);
	sRegion = szPrefix;
	return TRUE;
*/
	// 求分母
	XString sDenominator;
	GetDenominator(sDenominator);

	// 判断分母中是否有分区符号
	TCHAR *pSep = _tcschr(sDenominator, _T('-'));
	if (pSep == NULL)
		return FALSE;

	TCHAR szPrefix[256] = _T("");
	StrCpy(szPrefix, (const TCHAR *)sDenominator, pSep);
	sRegion = szPrefix;
	return TRUE;
}

// 求主轴号
// 如：_T("2-2/AB")回传_T("AB")
// 返回值：0--主轴号前有前置标志_T('0')；1--正常
int XAxisNoParser::GetMajorNo(XString &sMajorNo) const
{
/*
	int nRetCode=1;
	TCHAR *pSep = _tcschr(str, _T('-'));
	if (!pSep)
	pSep=str;
	else pSep++;

	// 消除了分区号
	TCHAR *pBegin=pSep;
	pSep = _tcschr(pBegin, _T('/'));
	if (!pSep) //没有附加轴线号
	pSep = pBegin;
	else {
	pSep++;
	if (*pSep==_T('0')) { // 前置附加轴线号, 如_T("1/0A")应当回传_T("A")
	pSep ++;
	nRetCode=0;
	}
	}
	sMajorNo=pSep;
	return nRetCode;
*/

	XString sDenominator, sNumerator, sRetNo;
	BOOL bHasNumerator = GetNumerator(sNumerator);	// 求分子
	GetDenominator(sDenominator);					// 求分母

	TCHAR *pSep = _tcschr(sDenominator, _T('-'));
	if (pSep != NULL)
	{
		TCHAR szSuffix[256] = _T("");
		StrCpy(szSuffix, pSep+1, NULL);
		sRetNo = szSuffix;
	}
	else
	{
		sRetNo = sDenominator;
	}

	int nRetCode = 1;
	if (bHasNumerator && sRetNo[0]==_T('0')) // 判断分母中是否首位是0
	{
		sMajorNo = &sRetNo[1];
		nRetCode = 0;
	} 
	else
	{
		sMajorNo = sRetNo;
	}
	return nRetCode;
}

// 求主轴号中可变的部分（对于双字母）
// 如：_T("1-A")，变前项，回传_T("1")；变后项，回传_T("A")
// 如：_T("AB")，变前项，回传_T("A")；变后项，回传_T("B")
BOOL XAxisNoParser::GetMajorVarNo(XString &sMajorVar) const
{
	XString sMajorNo;
	GetMajorNo(sMajorNo); // 求主轴号

	// 字母轴号或有字母强制，如：_T("B3")
	if (!IsDigital(sMajorNo))
	{
		if (_tcslen(sMajorNo) < 2) // 单字母
		{
			ASSERT(!!sMajorNo);
			sMajorVar = sMajorNo;
			return TRUE;
		}

		size_t nLen = _tcslen(&sMajorNo[1]);		// 从第二个字符开始
		if (nLen>1 && !IsDigital(&sMajorNo[1]))	// 字母的主轴号超过2个字符
			return FALSE;

		// 主轴号可变部分是数字或单字母
		sMajorVar = &sMajorNo[1];
	}
	else // 主轴号是数字
	{
		sMajorVar = sMajorNo;
	}

	return TRUE;
}

// 求主轴号中不变的部分（对于双字母）
// 如：_T("1-A")，回传_T("A")
// 如：_T("AB")，回传_T("B")
BOOL XAxisNoParser::GetMajorConstNo(XString &sMajorConst) const
{
	XString sMajorNo;
	GetMajorNo(sMajorNo); // 求主轴号

	if (IsDigital(sMajorNo)) // 不存在不变的前缀
		return FALSE;

	// 字母轴号或有字母前缀如 _T("B3")
	if (_tcslen(sMajorNo) < 2) // 单字母
	{
		return FALSE;
	}

	size_t nLen = _tcslen(&sMajorNo[1]);		// 从第二个字符开始
	if (nLen>1 && !IsDigital(&sMajorNo[1]))	// 字母的主轴号超过2个字符
		return FALSE;

	TCHAR szTemp[2] = _T("");
	szTemp[0] = sMajorNo[0];
	szTemp[1] = EOS;
	sMajorConst = szTemp;
	return TRUE;
}


// 求附加轴线号（分子），一般为数字
// 如：_T("1/A")，_T("1/0A")，回传_T("1")
// BOOL XAxisNoParser::GetSubNo(XString &sSubNo) const
BOOL XAxisNoParser::GetSubNo(int &nSubNo) const
{
/*
	TCHAR *pSep = _tcschr(str, _T('-'));
	if (!pSep)
		pSep = str;
	else
		pSep++;

	// 消除了分区号
	TCHAR *pBegin = pSep;
	pSep = _tcschr(pBegin, _T('/'));
	if (!pSep)
		return FALSE;

	TCHAR szTemp[80] = _T("");
	StrCpy(szTemp, pBegin, pSep);
*/

	XString szTemp;
	if (!GetNumerator(szTemp)) // 求分子
	{
		return FALSE;
	}

	if (!IsDigital(szTemp)) // 分轴号不是数字，不常见，暂时认为没有分子
	{
		return FALSE;
	}

//	sSubNo = szTemp;
	nSubNo = _ttoi(szTemp);
	return TRUE;
}



/////////////////////////////////////////////////////////////////////////////////
// sg add 100602，根据8.5的新需求，当字母不够使用时，根据高级选项中的设置，使用字母组合或字母数字组合排列，因此有可能不再是两位
// bChangeOther用于控制是否改变另外一位数
TCHAR XAxisNoParser::GetNextAxisAlpha(TCHAR cCur, bool &bChangeOther) const
{
	bChangeOther = true; // 需要改变另外一位
	if (cCur == _T('Z') || cCur == _T('Y')) // 单字母已不够使用
	{
		return _T('A');
	}

	if (cCur == _T('z') || cCur == _T('y'))
	{
		return _T('a');
	}

	cCur++;
	bChangeOther = false; // 不需要改变另外一位
	if (cCur == _T('I') || cCur == _T('i') || cCur == _T('O') || cCur == _T('o'))
	{
		cCur++; // 规范中要求，不允许使用下列字母做为轴标
	}
	return cCur;
}

// 将szNo拆分为前项szFront和后项szBehind
// 返回0：出现错误；返回1：正常解析；返回2：单个字母或全部都是数字
short XAxisNoParser::GetFrontAndBehindNo(XString szNo, XString &szFront, XString &szBehind) const
{
	TCHAR *pSep = _tcschr(szNo, _T('-'));
	if (pSep != NULL) // 判断是否含有分区轴号
	{
		TCHAR szFNo[256] = _T("");
		StrCpy(szFNo, (const TCHAR *)szNo, pSep);
		szFront = szFNo;

		TCHAR szBNo[256] = _T("");
		StrCpy(szBNo, pSep+1, NULL);
		szBehind = szBNo;

		return 3;
	}

	int nLen = (int)_tcslen(szNo);
	if (nLen<2 || IsDigital(szNo)) // 单字母，或全部都是数字
	{
		szFront = szNo;
		return 2;
	}

	nLen = (int)_tcslen(&szNo[1]);	// 从第二个字符开始
	if (nLen > 1)				// 主轴号超过2个字符，如：A10、10A、100B、AB1、AAA、1A1，前三种正确，后三种返回0，不做自动编号
	{
		XString szTempNo;
		szTempNo = &szNo[1];

		int nAlphaIndex = -1; // 首个字符的位置
		for (int i=0; i<nLen; i++)
		{
			if (!isdigit(szTempNo[i]))
			{
				nAlphaIndex = i; // 逐个判断是否是数字，获取出现首个字符的位置
				break;
			}
		}

		if (nAlphaIndex != -1) // 出现字母，如：10A、100B、AB1、AAA、1A1
		{
			if (nAlphaIndex != nLen - 1) // 首个字符的位置只要不出现在最后一位，就不做自动编号处理，如：AB1、AAA、1A1
			{
				return 0;
			}
			
			// 字母之前的数字，全属于szFront，如：10A、100B
			TCHAR szFNo[256] = _T("");
			for (i=0; i<nLen; i++)
			{
				szFNo[i] = szNo[i];
			}
			szFNo[nLen] = EOS;
			szFront = szFNo;

			TCHAR szBNo[2] = _T("");
			szBNo[0] = szNo[nLen];
			szBNo[1] = EOS;
			szBehind = szBNo;
			return 1;
		}
	}

	TCHAR szFTemp[2] = _T("");
	szFTemp[0] = szNo[0];
	szFTemp[1] = EOS;
	szFront = szFTemp;

	if (IsDigital(&szNo[1])) // 后面全部是数字
	{
		szBehind = &szNo[1];
	}
	else // 后面有字母
	{
		TCHAR szTemp[2] = _T("");
		szTemp[0] = szNo[1];
		szTemp[1] = EOS;
		szBehind = szTemp;
	}
	return 1;
}

bool XAxisNoParser::GetNext(XString szOld, XString &szNew) const
{
	// 将szOld拆分为前项szFront和后项szBehind
	// 注：单个字母，或者全部为数字的情况，都解析到szFront里
	XString szFront, szBehind;
	short nRet = GetFrontAndBehindNo(szOld, szFront, szBehind);

	// 前两位都为字母的情况，如：AB1、AAA、1A1，不处理
	if (nRet == 0)
	{
		return true;
	}

	if (nRet == 2)
	{
		GetNextNo(szFront, szNew, 1); // 单个字母，全部是数字
		return true;
	}

	// 判断是否含有分区号_T('-')
	XString szRegionNo;
	if (nRet == 3)
	{
		szRegionNo << _T("-");
	}

	bool bChange = false;					// 标记是否出现字母不够使用的情况
	XString szTempNext, szBTemp, szFTemp;	// 临时使用的保存字符串
	if (m_bChangePreNo) // 变前项
	{
		bChange = GetNextNo(szFront, szFTemp, 0); // 获取变前项的结果

		if (!bChange) // 需要变后项
		{
			bChange = GetNextNo(szBehind, szBTemp, 0);
			szTempNext << szFTemp << szRegionNo << szBTemp;

			// 后项字母也不够使用，需要增加1位
			if (!bChange)
			{
				if (g_nAfterYAxisStyle == 0) // 自动加字母
				{
					szTempNext << szRegionNo << _T("A");
				}
				else // 自动加数字
				{
					szTempNext << szRegionNo << _T("1");
				}
			}
		}
		else // 后前项固定
		{
			szTempNext << szFTemp << szRegionNo << szBehind;
		}
	}
	else // 变后项
	{
		bChange = GetNextNo(szBehind, szBTemp, 0); // 获取变后项的结果

		if (!bChange) // 需要变前项
		{
			bChange = GetNextNo(szFront, szFTemp, 0);
			szTempNext << szFTemp << szRegionNo << szBTemp;

			// 前项字母也不够使用，需要增加1位
			if (!bChange)
			{
				if (g_nAfterYAxisStyle == 0) // 自动加字母
				{
					szTempNext << szRegionNo << _T("A");
				}
				else // 自动加数字
				{
					szTempNext << szRegionNo << _T("1");
				}
			}
		}
		else // 前项固定
		{
			szTempNext << szFront << szRegionNo << szBTemp;
		}
	}
	szNew = szTempNext;
	return true;
}


// nType：表示处理方式，0：如果是字母，到Y时，不再处理；1：针对单个字母类，自动处理到szNew中
bool XAxisNoParser::GetNextNo(XString szOld, XString &szNew, int nType) const
{
	if (IsDigital(szOld)) // 数字
	{
		int nVar = _ttoi(szOld);
		nVar++;
		szNew << nVar;
		return true;
	}
	
	// 字母
	bool bChange = false;
	TCHAR cNextAlpha = GetNextAxisAlpha(szOld[0], bChange);
	if (!bChange || nType == 0) // 不需要改变另外一位
	{
		TCHAR szNextStr[2] = _T("");
		szNextStr[0] = cNextAlpha;
		szNextStr[1] = EOS;
		szNew << szNextStr;
		return (!bChange || nType!=0);
	}

	if (nType == 1) // 字母不够用，由一位生为两位
	{
		TCHAR szNextStr[3] = _T("");
		szNextStr[0] = cNextAlpha;
		if (g_nAfterYAxisStyle == 0) // 自动加字母
		{
			szNextStr[1] = _T('A');
		}
		else // 自动加数字
		{
			szNextStr[1] = _T('1');
		}
		szNextStr[2] = EOS;
		szNew << szNextStr;
	}
	return true;
}



/////////////////////////////////////////////////////////////////////////////////
// 求下一根轴号
// bNextIsMajor--下一根性质是主轴线吗
// 如：_T("2-3/AB")回传_T("2-4/AB")或_T("2-AC")
// sg modify 100707，根据8.5需求，进行了整体修改，增加了变前项、变后项等功能
/*
BOOL XAxisNoParser::GetNext(XString &sNextNo, BOOL bNextIsMajor) const
{
	if (!(*this)) // 当前轴号位空
	{
		sNextNo = _T("");
		return TRUE;
	}


	XString sRegionNo, sMajorConst, sMajorVar, sSubNo, sMajorNo;
	// 求分区号，分区号用_T('-')分割
	BOOL bHasRegionNo = GetRegionNo(sRegionNo);
	// 求主轴号中，不可变的部分(对于双字母)
	BOOL bHasMajorConst = GetMajorConstNo(sMajorConst);
	// 求主轴号中，不可变的部分(对于双字母)
	BOOL bHasMajorVar = GetMajorVarNo(sMajorVar);
	// 求附加轴线号
	BOOL bHasSubNo = GetSubNo(sSubNo);

	// 求主轴号
	// 含有/0，则返回0，其他，返回1
	int nRetCode = GetMajorNo(sMajorNo);
	if (!bHasMajorVar) // 不存在可变的主体, 编号有错
	{
		return FALSE;
	}

    XString sNextTemp(256);
//	if (bHasRegionNo)
//	{
//		sNextTemp << sRegionNo << _T("-");
//	}

	XString sRegPrefix;
	if (bHasRegionNo)
	{
		sRegPrefix << sRegionNo << _T("-");
	}

	if (bHasSubNo) // 有分子，并且分子为数字
	{
		int nSubNo = _ttoi(sSubNo);
		if (nRetCode==0)
		{
			if (nSubNo==1) // 变主轴号
			{
				sNextTemp << sRegPrefix << sMajorNo;
			}
			else
			{
				nSubNo--; // 前置附加号需要减1
				sNextTemp << nSubNo << _T("/") << sRegPrefix << _T("0") << sMajorNo;
			}
		}
		else
		{
			if (!bNextIsMajor) // 下一个仍然是附加号
			{
				nSubNo++;
				sNextTemp << nSubNo;
				sNextTemp << _T("/") << sRegPrefix << sMajorNo; // 主轴号不变
			}
			else // 下一个是主轴号, 由分轴变主轴
			{
				sNextTemp << sRegPrefix;
				if (bHasMajorConst)
					sNextTemp << sMajorConst;

				if (IsDigital(sMajorVar)) // 数字
				{
					int nMajorVar = _ttoi(sMajorVar);
					nMajorVar++;
					sNextTemp << nMajorVar;
				}
				else // 字母
				{
					TCHAR cNextAlpha = GetNextAxisAlpha(sMajorVar[0]);
					TCHAR szNextStr[2] = _T("");
					szNextStr[0] = cNextAlpha;
					szNextStr[1] = EOS;
					sNextTemp << szNextStr;
				}
			}
		}
	}
	else // 无分子，或者分子为字母
	{
		if (!bNextIsMajor) // 主轴变分轴
		{
			sNextTemp << _T("1/") << sRegPrefix << sMajorNo; 
		}
		else
		{
			sNextTemp << sRegPrefix;

			XString sNextMajor(256);
			if (bHasMajorConst)
				sNextMajor << sMajorConst;

			if (IsDigital(sMajorVar)) // 数字
			{
				int nMajorVar=_ttoi(sMajorVar);
				nMajorVar++;
				sNextMajor << nMajorVar;
			}
			else // 字母
			{
				TCHAR cNextAlpha = GetNextAxisAlpha(sMajorVar[0]);
				TCHAR szNextStr[2] = _T("");
				szNextStr[0] = cNextAlpha;
				szNextStr[1] = EOS;
				sNextMajor << szNextStr;
			}

			sNextTemp << sNextMajor;
		}
	}

	sNextNo = sNextTemp;
	return TRUE;
}
*/

BOOL XAxisNoParser::GetNext(XString &sNextNo, BOOL bNextIsMajor) const
{
	if (!(*this)) // 当前轴号位空
	{
		sNextNo = _T("");
		return TRUE;
	}

	// 首先判断是否含有附加轴号（分子），分子存在，并且是数字，才返回TRUE
	int nSubNo = 0;
	BOOL bHasSubNo = GetSubNo(nSubNo);

	// 求主轴号，如果含有“/0”，则返回0，其他，返回1
	XString szMajorNo;
	int nRetCode = GetMajorNo(szMajorNo);

	// 求分区号，分区号用_T('-')分割
	XString szRegionNo, szRegPrefix;
	if (GetRegionNo(szRegionNo))
	{
		szRegPrefix << szRegionNo << _T("-");
	}

	XString szTempNext;
	if (bHasSubNo) // 当前是附加轴号
	{
		if (nRetCode == 0) // 分母首位是0
		{
			if (nSubNo==1 || bNextIsMajor) // 变主轴号
			{
				szTempNext << szRegPrefix << szMajorNo;
			}
			else // 前置的附加号，分子自减，分母不变
			{
				nSubNo--;
				szTempNext << nSubNo << _T("/") << szRegPrefix << _T("0") << szMajorNo;
			}
		}
		else if (bNextIsMajor) // 下一个是主轴号，附加轴号变主轴号
		{
			XString szOld;
			szOld << szRegPrefix << szMajorNo;
			GetNext(szOld, szTempNext);
		}
		else // 下一个是附加轴号，分子自加，分母不变
		{
			nSubNo++;
			szTempNext << nSubNo << _T("/") << szRegPrefix << szMajorNo;
		}
	}
	else // 当前是主轴号
	{
		if (bNextIsMajor) // 下一个是主轴号，变前项，变后项
		{
			XString szOld;
			szOld << szRegPrefix << szMajorNo;
			GetNext(szOld, szTempNext);
		}
		else // 下一个是附加轴号，变为附加轴号
		{
			szTempNext << _T("1/") << szRegPrefix << szMajorNo;
		}
	}

	sNextNo = szTempNext;
	return TRUE;
}

// sg add 100531，求前一根轴号
// bPreIsMajor——前一根性质是主轴线嘛
BOOL  XAxisNoParser::GetPre(XString &sPreNo, BOOL bPreIsMajor) const
{
	if (!(*this)) // 空号
	{
		sPreNo = _T("");
		return TRUE;
	}

	// 首先判断是否含有附加轴号（分子），分子存在，并且是数字，才返回TRUE
	int nSubVar = 0;
	BOOL bHasSubNo = GetSubNo(nSubVar);

	// 如果不是附加轴号，根据8.5需求，只对单个字母和单个数字的首个主轴号进行推导，组合形式，返回空
	if (!bHasSubNo)
	{
		INT_PTR nLength = _tcslen(str);
		if (!IsDigital(str)) // 根据8.5需求，只对单个字母和单个数字的首个主轴号进行推导，组合形式，返回空
		{
			if (nLength > 1)
			{
				sPreNo = _T("");
				return TRUE;
			}
		}
	}

	// 求主轴号，如果含有“/0”，则返回0，其他，返回1
	XString szMajorNo;
	int nRetCode = GetMajorNo(szMajorNo);

	XString sPreTemp(256);
	if (bPreIsMajor) // 前一个为主轴号
	{
		if (IsDigital(szMajorNo)) // 数字
		{
			sPreTemp << _T("1");
		}
		else // 字母
		{
			sPreTemp << _T("A");
		}
	}
	else // 前一个为附加轴号
	{
		if (bHasSubNo) // 当前轴号是附加轴号
		{
			nSubVar++;
			sPreTemp << nSubVar << _T("/0") << szMajorNo;
		}
		else //当前轴号是主轴号
		{
			sPreTemp << _T("1/0") << szMajorNo; 
		}
	}

	sPreNo = sPreTemp;
	return TRUE;
}

// 求下一根轴号
// bNextIsMajor--下一根性质是主轴线吗
// 如：_T("2-3/AB")回传_T("2-4/AB")或_T("2-AC")
BOOL XAxisNoParser::GetNext(BOOL bNextIsMajor)
{
	XString sNextNo;
	if (!GetNext(sNextNo, bNextIsMajor))
		return FALSE;

	*(XString *)this = sNextNo;
	return TRUE;
}


int NextNo()
{
	resbuf *rbArgs = ads_getargs();
	RBList rbTemp(rbArgs);
	if (!rbArgs || rbArgs->restype!=RTSTR)
		return RTERROR;

	XString sAxisNo;
	sAxisNo = rbArgs->resval.rstring;
	rbArgs = rbArgs->rbnext;
	if (!rbArgs || rbArgs->restype!=RTSHORT)
		return RTERROR;

	int bMajor = rbArgs->resval.rint;
	XAxisNoParser parser(sAxisNo);
	if (!parser.GetNext(bMajor))
	{
		adsout << _T("\nError No");
	}

//	adsout << _T("\n") << parser;
	ads_retstr(parser);
	return RTNORM;
}

// add by xly on 100816 判断主轴号是否含有分区 
// 如：1——>/01; AA——>/0AA; 1-1——>/1-01; 1-A——>/1-01
bool XAxisNoParser::GetRegion(CString &csMajorAxis)
{
	CString csOld = csMajorAxis,csNew;
	int iPos = csMajorAxis.Find(_T("-"));
	if (iPos > -1)// 含有分区号
	{
		csMajorAxis = _T("/");
		csMajorAxis += csOld.Left(iPos+1);
		csMajorAxis += _T("0");

		csMajorAxis += csOld.Right(csOld.GetLength()-iPos-1);
		return true;
	}

	// 不含分区号，只有字母或者数字的组合
	csMajorAxis = _T("/0");
	csMajorAxis += csOld;
	return false;
}