wdatato.cpp

压缩程序函数体：十六进制的除法、十进制的除法、二十六进制的除法(表示范围为字符串）、三十六进制的除法、九十六进制的除法

// 压缩程序函数体
//
// Usage: TaxDataEnDe Method[EN/DE] Data DataType[1/2/3/4/5]
//		Method: EN -- ENcode the Tax Data
//				DE -- DEcode the Tax Data
//		DataType:	1 ---- NUMBER
//					2 ---- ALPHA
//					3 ---- ALPHA and NUMBER
//					4 ---- ASCII 
//					5 ---- HEX
//
#include "stdafx.h"
#include "wDataTo.h"
#include "nn.h" //RSA加密

ERROR_TaxDataEnDE TaxDataErrorNumber = ERROR_NOERROR;		// 处理的错误编号

//==============================================================================
// 任意长度十进制除法 ，返回余数
// 输入为十进制串，输出为余数
//==============================================================================
long DecDivision(char *Numerator/*分子*/,long Denominator/*分母*/,char *Quot/*商*/)
{
	long TempNum=0;
	ldiv_t tDiv;
	char *tempQuot = Quot;
	while(*Numerator){
		assert(isdigit(*Numerator));
		TempNum = TempNum*10 + (*Numerator-'0');
		if(TempNum>Denominator) {	// 余数比除数大
			tDiv = ldiv(TempNum,Denominator);
			*tempQuot++ = '0' + (unsigned char)tDiv.quot;	// 商,因为是10进制，所以不会比9大
			TempNum = tDiv.rem;								// 余数
		}
		else {
			if(tempQuot != Quot) *tempQuot++ = '0';	// 若不是头，则补0，否则不用补
		}
		Numerator++;
	}
	*tempQuot = '\0';
	return TempNum;
}

//==============================================================================
// 取十六进制字符的值
//==============================================================================
unsigned char GetHexValue(char HexChar)
{
	if(HexChar >= 'a')
		return (10 + (HexChar - 'a'));
	else if(HexChar >= 'A')
		return (10 + (HexChar - 'A'));
	else
		return (HexChar - '0');
}
//==============================================================================
// 转换为十六进制字符
//==============================================================================
char ToHexChar(unsigned char HexValue)
{
	if(HexValue >= 10)
		return 'A'+(HexValue - 10);
	else
		return '0' + HexValue;
}

//==============================================================================
// 任意长度十六进制除法 ，返回余数 
// 输入为十六进制串，输出为余数
//==============================================================================
long HexDivision(char *Numerator/*分子*/,long Denominator/*分母*/,char *Quot/*商*/)
{
	long TempNum=0;
	ldiv_t tDiv;
	char *tempQuot = Quot;
	while(*Numerator){
		assert(isxdigit(*Numerator));
		TempNum = TempNum * 16 + GetHexValue(*Numerator);
		if(TempNum>Denominator) {		// 余数比除数大
			tDiv = ldiv(TempNum,Denominator);
			*tempQuot++ = ToHexChar((unsigned char)tDiv.quot);	// 商,因为是16进制，所以不会比F大
			TempNum = tDiv.rem;								// 余数
		}
		else {
			if(tempQuot != Quot) *tempQuot++ = '0';	// 若不是头，则补0，否则不用补
		}
		Numerator++;
	}
	*tempQuot = '\0';
	return TempNum;
}

//==============================================================================
// 将任意长度的十六进制数字串转化为十进制串
// 输入：strSource -- 源串（为16进制的数字串）
//       strDest   -- 目标串（为10进制的字符串）
// 返回：错误号
//==============================================================================
int HexToDec(char *strSource,unsigned char *strDest)
{
	short sTemp = 0,TempStrLen=0;
	char *pDest = (char *)(strDest+MAX_STRLEN);
	char TempStr[10];
	*pDest = '\0';
	char  tstr[MAX_STRLEN+1];
	strcpy(tstr,strSource);
	long Denominator = 100000000,Reminder;	// 每次转出8个字节(2^32)/16 
		// 输入值检查.
		// 数制转换
	do{
		Reminder = HexDivision(tstr,Denominator,tstr);
		if(tstr[0]){	// 不是最后一组
			sprintf(TempStr,"%08ld",Reminder);	// 不用ltoa,因为方便前面补0,未直接用pDest缓冲区，是因为结束符会冲掉后面的数据
			pDest -= 8;		// 因为是倒序出，所以先将结果认在尾，然后再移动。
			TempStrLen += 8;
			strncpy(pDest,TempStr,8);
		}
		else {			// 最后一组，不需要前导0
			sprintf(TempStr,"%ld",Reminder);	// 不用ltoa,因为方便前面补0,未直接用pDest缓冲区，是因为结束符会冲掉后面的数据
			pDest -= strlen(TempStr);		// 因为是倒序出，所以先将结果认在尾，然后再移动。
			TempStrLen += (short)(strlen(TempStr));
			strncpy(pDest,TempStr,strlen(TempStr));
		}
	}while(tstr[0]);	// 当还有商时，要继续处理，直到商为0
	memmove(strDest,pDest,TempStrLen+1);	// 将结束符出加到最后。
	return ERROR_NOERROR;
}

//==============================================================================
// 将任意长度的十进制数字串转化为十六进制串
// 输入：strSource -- 源串（为10进制的数字串）
//	     strDest   -- 目标串（为16进制的字符串）
// 返回：错误号
//==============================================================================
int DecToHex(char *strSource,unsigned char *strDest)
{
	short sTemp = 0,TempStrLen=0;
	char *pDest = (char *)(strDest+MAX_STRLEN);
	char TempStr[10];
	*pDest = '\0';
	char  tstr[MAX_STRLEN+1];
	strcpy(tstr,strSource);
	long Denominator = 256*256*256,Reminder;	// 每次转出三个字节
		// 输入值检查
		// 数制转换
	do{
		Reminder = DecDivision(tstr,Denominator,tstr);
		if(tstr[0]){	// 不是最后一组
			sprintf(TempStr,"%06X",Reminder);	// 不用ltoa,因为方便前面补0,未直接用pDest缓冲区，是因为结束符会冲掉后面的数据
			pDest -= 6;		// 因为是倒序出，所以先将结果认在尾，然后再移动。
			TempStrLen += 6;
			strncpy(pDest,TempStr,6);
		}
		else {			// 最后一组，不需要前导0
			sprintf(TempStr,"%X",Reminder);	// 不用ltoa,因为方便前面补0,未直接用pDest缓冲区，是因为结束符会冲掉后面的数据
			pDest -= strlen(TempStr);		// 因为是倒序出，所以先将结果认在尾，然后再移动。
			TempStrLen += (short)strlen(TempStr);
			strncpy(pDest,TempStr,strlen(TempStr));
		}
	}while(tstr[0]);	// 当还有商时，要继续处理，直到商为0
	memmove(strDest,pDest,TempStrLen+1);	// 将结束符出加到最后。
	return ERROR_NOERROR;
}

//==============================================================================
// 取ALPHA字符的值
//==============================================================================
unsigned char GetAlphaValue(char AlphaChar)
{
	if(AlphaChar>='a')  return (AlphaChar - 'a');
	else				return (AlphaChar - 'A');
}
char ToAlphaChar(unsigned char AlphaValue)
{
	return 'A'+AlphaValue;
}
char *ToAlphaStr(long AlphaValue,unsigned char AlphaNum)
{
	static char AlphaStr[10];
	int i=0;
	ldiv_t tDiv;
	tDiv.quot = AlphaValue;
	do{
		tDiv = ldiv(tDiv.quot,26);
		AlphaStr[i++]=ToAlphaChar((unsigned char)tDiv.rem);
	}while(tDiv.quot);	// 商不为
	while(i<AlphaNum && i<10) AlphaStr[i++]=ToAlphaChar(0);	// 补位
	AlphaStr[i] = '\0';
	return strrev(AlphaStr);
}

//==============================================================================
// 任意长度二十六进制除法 ，返回余数 
// 输入为二十六进制串，输出为余数
//==============================================================================
long AlphaDivision(char *Numerator/*分子*/,long Denominator/*分母*/,char *Quot/*商*/)
{
	long TempNum=0;
	ldiv_t tDiv;
	char *tempQuot = Quot;
	while(*Numerator){
		assert(isalpha(*Numerator));
		TempNum = TempNum * 26 + GetAlphaValue(*Numerator);
		if(TempNum>Denominator) {		// 余数比除数大
			tDiv = ldiv(TempNum,Denominator);
			*tempQuot++ = ToAlphaChar((unsigned char)tDiv.quot);	// 商,因为是26进制，所以不会比Z大
			TempNum = tDiv.rem;								// 余数
		}
		else {
			if(tempQuot != Quot) *tempQuot++ = '0';	// 若不是头，则补0，否则不用补
		}
		Numerator++;
	}
	*tempQuot = '\0';
	return TempNum;
}

//==============================================================================
// 将任意长度的二十六进制串转化为十六进制串
// 输入：strSource -- 源串（为26进制的串）
//       strDest   -- 目标串（为16进制的字符串）
// 返回：错误号
//==============================================================================
int AlphaToHex(char *strSource,unsigned char *strDest)
{
	short sTemp = 0,TempStrLen=0;
	char *pDest = (char *)(strDest+MAX_STRLEN);
	char TempStr[10];
	*pDest = '\0';
	char  tstr[MAX_STRLEN+1];
	strcpy(tstr,strSource);
	long Denominator = 256*256*256,Reminder;	// 每次转出三个字节
		// 输入值检查
		// 数制转换
	do{
		Reminder = AlphaDivision(tstr,Denominator,tstr);
		if(tstr[0]){	// 不是最后一组
			sprintf(TempStr,"%06X",Reminder);	// 不用ltoa,因为方便前面补0,未直接用pDest缓冲区，是因为结束符会冲掉后面的数据
			pDest -= 6;		// 因为是倒序出，所以先将结果认在尾，然后再移动。
			TempStrLen += 6;
			strncpy(pDest,TempStr,6);
		}
		else {			// 最后一组，不需要前导0
			sprintf(TempStr,"%X",Reminder);	// 不用ltoa,因为方便前面补0,未直接用pDest缓冲区，是因为结束符会冲掉后面的数据
			pDest -= strlen(TempStr);		// 因为是倒序出，所以先将结果认在尾，然后再移动。
			TempStrLen += (short)strlen(TempStr);
			strncpy(pDest,TempStr,strlen(TempStr));
		}
	}while(tstr[0]);	// 当还有商时，要继续处理，直到商为0
	memmove(strDest,pDest,TempStrLen+1);	// 将结束符出加到最后。
	return ERROR_NOERROR;
}

//==============================================================================
// 将任意长度的十六进制数字串转化为二十六进制串
// 输入：strSource -- 源串（为16进制的串）
//       strDest   -- 目标串（为26进制的串）
// 返回：错误号
//==============================================================================
int  HexToAlpha(char *strSource,unsigned char *strDest)
{
	short sTemp = 0,TempStrLen=0;
	char *pDest = (char *)(strDest+MAX_STRLEN);
	char TempStr[10];
	*pDest = '\0';
	char  tstr[MAX_STRLEN+1];
	strcpy(tstr,strSource);
	long Denominator = 26*26*26*26*26,Reminder;	// 每次转出5个字节(2^32)/16 > 26*26*26*26*26
		// 输入值检查.
		// 数制转换
	do{
		Reminder = HexDivision(tstr,Denominator,tstr);
		if(tstr[0]){	// 不是最后一组
			pDest -= 5;		// 因为是倒序出，所以先将结果认在尾，然后再移动。
			TempStrLen += 5;
			strncpy(pDest,ToAlphaStr(Reminder,5),5);
		}
		else {			// 最后一组，不需要前导0
			strcpy(TempStr,ToAlphaStr(Reminder,0));
			pDest -= strlen(TempStr);		// 因为是倒序出，所以先将结果认在尾，然后再移动。
			TempStrLen += (short)(strlen(TempStr));
			strncpy(pDest,TempStr,strlen(TempStr));
		}
	}while(tstr[0]);	// 当还有商时，要继续处理，直到商为0
	memmove(strDest,pDest,TempStrLen+1);	// 将结束符出加到最后。
	return ERROR_NOERROR;
}

//==============================================================================
// 三十六进制的处理
// 取ALPHANum字符的值
//==============================================================================
unsigned char GetAlphaNumValue(char AlphaNumChar){
	if(AlphaNumChar>='a')  return 10+ (AlphaNumChar - 'a');
	else if(AlphaNumChar>='A') return 10 + (AlphaNumChar - 'A');
	else				return (AlphaNumChar - '0');
}
char ToAlphaNumChar(unsigned char AlphaNumValue){
	if(AlphaNumValue>=10) return 'A'+(AlphaNumValue-10);
	else return '0'+AlphaNumValue;
}

char *ToAlphaNumStr(long AlphaNumValue,unsigned char AlphaNumNum)
{
	static char AlphaNumStr[10];
	int i=0;
	ldiv_t tDiv;
	tDiv.quot = AlphaNumValue;
	do{
		tDiv = ldiv(tDiv.quot,36);
		AlphaNumStr[i++]=ToAlphaNumChar((unsigned char)tDiv.rem);
	}while(tDiv.quot);	// 商不为0
	while(i<AlphaNumNum && i<10) AlphaNumStr[i++]=ToAlphaNumChar(0);	// 补位
	AlphaNumStr[i] = '\0';
	return strrev(AlphaNumStr);
}

//==============================================================================
// 任意长度三十六进制除法 ，返回余数 
// 输入为三十六进制串，输出为余数
//==============================================================================
long AlphaNumDivision(char *Numerator/*分子*/,long Denominator/*分母*/,char *Quot/*商*/){
	long TempNum=0;
	ldiv_t tDiv;
	char *tempQuot = Quot;
	while(*Numerator){
		assert(isalnum(*Numerator));
		TempNum = TempNum * 36 + GetAlphaNumValue(*Numerator);
		if(TempNum>Denominator) {		// 余数比除数大
			tDiv = ldiv(TempNum,Denominator);
			*tempQuot++ = ToAlphaNumChar((unsigned char)tDiv.quot);	// 商,因为是26进制，所以不会比Z大
			TempNum = tDiv.rem;								// 余数
		}
		else {
			if(tempQuot != Quot) *tempQuot++ = '0';	// 若不是头，则补0，否则不用补
		}
		Numerator++;
	}
	*tempQuot = '\0';
	return TempNum;
}

//==============================================================================
// 将任意长度的三十六进制串转化为十六进制串
// 输入：strSource -- 源串（为36进制的串）
//       strDest   -- 目标串（为16进制的字符串）
// 返回：错误号
//==============================================================================
int  AlphaNumToHex(char *strSource,unsigned char *strDest){
	short sTemp = 0,TempStrLen=0;
	char *pDest = (char *)(strDest+MAX_STRLEN);
	char TempStr[10];
	*pDest = '\0';
	char  tstr[MAX_STRLEN+1];
	strcpy(tstr,strSource);
	long Denominator = 256*256*256,Reminder;	// 每次转出三个字节
		// 输入值检查
		// 数制转换
	do{
		Reminder = AlphaNumDivision(tstr,Denominator,tstr);
		if(tstr[0]){	// 不是最后一组
			sprintf(TempStr,"%06X",Reminder);	// 不用ltoa,因为方便前面补0,未直接用pDest缓冲区，是因为结束符会冲掉后面的数据
			pDest -= 6;		// 因为是倒序出，所以先将结果认在尾，然后再移动。
			TempStrLen += 6;
			strncpy(pDest,TempStr,6);
		}
		else {			// 最后一组，不需要前导0
			sprintf(TempStr,"%X",Reminder);	// 不用ltoa,因为方便前面补0,未直接用pDest缓冲区，是因为结束符会冲掉后面的数据
			pDest -= strlen(TempStr);		// 因为是倒序出，所以先将结果认在尾，然后再移动。
			TempStrLen += (short)strlen(TempStr);
			strncpy(pDest,TempStr,strlen(TempStr));
		}
	}while(tstr[0]);	// 当还有商时，要继续处理，直到商为0
	memmove(strDest,pDest,TempStrLen+1);	// 将结束符出加到最后。
	return ERROR_NOERROR;
}

//==============================================================================
// 将任意长度的十六进制数字串转化为三十六进制串
// 输入：strSource -- 源串（为16进制的串）
//       strDest   -- 目标串（为36进制的串）
// 返回：错误号
//==============================================================================