example1.cpp

一个把VB原代码转换为VC原代码的软件代码。

			int StrMeltLen;
			StringRightTmp=IntToStr(StringRight);
			StrMeltLen=strlen(StringRightTmp);
			StrMeltTmp=garbagestring(strlen(StringLeft.Val())+StrMeltLen);
			strncpy(StrMeltTmp,StringLeft.Val(),StrMeltLen);
			return strcat(StrMeltTmp,StringRightTmp);
		}
	private:
		char *RealVBStr;
};

// ---------------------------
// Power operation replacement
// ---------------------------
class VBPow
{
	public:
		VBPow(double lv)
		{
			RealVBPow = lv;
		}
		double Val()
		{
			return RealVBPow;
		}
	private:
		double RealVBPow;
};
double operator<<(double OpLeft, VBPow OpRight)
{
	return pow(OpLeft,OpRight.Val());
}

// --------------------------- Left() function
char *Left(char *,int);
char *Left(char *LeftString,int length)
{
	char *StrLeftTmp;
	DWORD StrLeftLen;
	StrLeftLen=strlen(LeftString);
	StrLeftTmp=garbagestring(StrLeftLen+1);
	if(length>StrLeftLen) length=StrLeftLen;
	strncpy(StrLeftTmp,&LeftString[0],length);
	StrLeftTmp[length]=0;
	return StrLeftTmp;
}

// --------------------------- Right() function
char *Right(char *,int);
char *Right(char *RightString,int length)
{
	int start;
	char *StrRightTmp;
	DWORD StrRightLen;
	StrRightLen=strlen(RightString);
	StrRightTmp=garbagestring(StrRightLen+1);
	start=StrRightLen-length;
	if(start<0) start=0;
	strncpy(StrRightTmp,&RightString[start],length);
	StrRightTmp[length]=0;
	return StrRightTmp;
}

// --------------------------- Trim() function
char *Trim(char *);
char *Trim(char *TrimString)
{
	int i;
	char *OutTrimBuffer;
	char *StrTrimTmp;
	StrTrimTmp=garbagestring(strlen(TrimString));
	strcpy(StrTrimTmp,TrimString);
	i=strlen(TrimString);
	while(i--)
	{
		if(TrimString[i]!=32) break;
	}
	StrTrimTmp[++i]=0;
	if (StrTrimTmp)
	{
		for (OutTrimBuffer=StrTrimTmp;*OutTrimBuffer && (OutTrimBuffer[0]==32); ++OutTrimBuffer);
		if (StrTrimTmp!=OutTrimBuffer)
			memcpy(StrTrimTmp,OutTrimBuffer,strlen(OutTrimBuffer)+1);
	}
	return StrTrimTmp;
}

// --------------------------- RTrim() function
char *RTrim(char *);
char *RTrim(char *TrimString)
{
	int i;
	char *StrTrimTmp;
	StrTrimTmp=garbagestring(strlen(TrimString));
	strcpy(StrTrimTmp,TrimString);
	i=strlen(TrimString);
	while(i--)
	{
		if(TrimString[i]!=32) break;
	}
	StrTrimTmp[++i]=0;
	return StrTrimTmp;
}

// --------------------------- LTrim() function
char *LTrim(char *);
char *LTrim(char *TrimString)
{
	char *OutTrimBuffer;
	char *StrTrimTmp;
	StrTrimTmp=garbagestring(strlen(TrimString));
	strcpy(StrTrimTmp,TrimString);
	if (StrTrimTmp)
	{
		for(OutTrimBuffer=StrTrimTmp;*OutTrimBuffer && (OutTrimBuffer[0]==32); ++OutTrimBuffer);
		if (StrTrimTmp!=OutTrimBuffer)
			memcpy(StrTrimTmp,OutTrimBuffer,strlen(OutTrimBuffer)+1);
	}
	return StrTrimTmp;
}

// --------------------------- Chr() function
char *Chr(int);
char *Chr(int intchar)
{
	char *StrChrTmp;
	StrChrTmp=garbagestring(1);
	StrChrTmp[0]=intchar;
	return StrChrTmp;
}

// --------------------------- Asc() function
__inline int Asc(char *);
__inline int Asc(char *AscString)
{
	return (unsigned char) AscString[0];
}

// --------------------------- AscB() function
__inline BYTE AscB(char *);
__inline BYTE AscB(char *AscString)
{
	return (unsigned char) AscString[0];
}

// --------------------------- Mid() function
char *Mid(char *,int,int=-1);
char *Mid(char *MidString,int start,int length)
{
	int tmplen;
	char *StrMidTmp;
	tmplen=strlen(MidString);
	if(length==-1) length=tmplen-start+1;
	StrMidTmp=garbagestring(length);
	if(start>tmplen)
	{
		StrMidTmp[0]=0;
	}
	else
	{
		strncpy(StrMidTmp,&MidString[start-1],length);
	}
	StrMidTmp[length]=0;
	return StrMidTmp;
}

// --------------------------- Sgn() function
__inline long Sgn(double);
__inline long Sgn(double a)
{
	if(a<0.0) return -1;
	if(a>0.0) return 1;
	return 0;
}

// --------------------------- Space() function
__inline char *Space(int);
__inline char *Space(int count)
{
	char *StrSpaceTmp;
	StrSpaceTmp=garbagestring(count);
	memset(StrSpaceTmp,32,count);
	return StrSpaceTmp;
}

// --------------------------- String() function
__inline char *String(int,int);
__inline char *String(int count,int a)
{
	char *StrStringTmp;
	StrStringTmp=garbagestring(count);
	memset(StrStringTmp,a,count);
	return StrStringTmp;
}

// --------------------------- Str() function
__inline char *Str(double);
__inline char *Str(double d)
{
	char *StrStrTmp;
	StrStrTmp=garbagestring(32);
	sprintf(StrStrTmp,"%.15g",d);
	return StrStrTmp;
}

// --------------------------- UCase() function
char *UCase(char *);
char *UCase(char *UCaseString)
{
	char *StrUCaseTmp;
	int StrUCaseLen;
	StrUCaseLen=strlen(UCaseString);
	StrUCaseTmp=garbagestring(StrUCaseLen);
	strncpy(StrUCaseTmp,UCaseString,StrUCaseLen);
	StrUCaseTmp=strupr(StrUCaseTmp);
	return StrUCaseTmp;
}

// --------------------------- LCase() function
char *LCase(char *);
char *LCase(char *LCaseString)
{
	char *StrLCaseTmp;
	int StrLCaseLen;
	StrLCaseLen=strlen(LCaseString);
	StrLCaseTmp=garbagestring(StrLCaseLen);
	strncpy(StrLCaseTmp,LCaseString,StrLCaseLen);
	StrLCaseTmp=strlwr(StrLCaseTmp);
	return StrLCaseTmp;
}

// --------------------------- GetAttr() function
__inline DWORD GetAttr(char *);
__inline DWORD GetAttr(char *FileName)
{
	return(GetFileAttributes(FileName));
}

// --------------------------- StrReverse() function
char *StrReverse(char *);
char *StrReverse(char *RevStr)
{
	int RevStrLen;
	int i;
	char *RevStrTmp;
	unsigned char RevChar;
	RevStrLen=strlen(RevStr);
	RevStrTmp=garbagestring(RevStrLen+1);
	strncpy(RevStrTmp,RevStr,RevStrLen);
	if(RevStrLen>1)
	{
		for(i=0;i!=(RevStrLen/2);i++)
		{
			RevChar=RevStrTmp[RevStrLen-1-i];
			RevStrTmp[RevStrLen-1-i]=RevStrTmp[i];
			RevStrTmp[i]=RevChar;
		}
	}
	return RevStrTmp;
}

// --------------------------- IsNumeric() function
BOOL IsNumeric(char *);
BOOL IsNumeric(char *NumericStr)
{
	DWORD i;
	DWORD j=0;
	i=strlen(NumericStr);
	while(j < i)
	{
		if(NumericStr[j]!=43&&NumericStr[j]!=45) break;
		j++;
	}
	if(j>=i) return FALSE;
	while(i > j)
	{
		if(!isdigit(NumericStr[i-1]))
		{
			if(NumericStr[i-1]!=44) return FALSE;
		}
		i--;
	}
	return TRUE;
}

// --------------------------- ChDrive() function
void ChDrive(char *);
void ChDrive(char *DriveStr)
{
	char *ChDriveStrTmp;
	ChDriveStrTmp=garbagestring(MAX_PATH+1);
	GetCurrentDirectory(MAX_PATH,ChDriveStrTmp);
	strncpy(ChDriveStrTmp,Left(DriveStr,1),1);
	if (SetCurrentDirectory(ChDriveStrTmp)==0)
	{
		ChDriveStrTmp[1]=':';
		ChDriveStrTmp[2]='\\';
		ChDriveStrTmp[3]='\0';
		SetCurrentDirectory(ChDriveStrTmp);
	}
}

// --------------------------- ChDir() function
__inline void chdir(char *);
__inline void chdir(char *DirStr)
{
	SetCurrentDirectory(DirStr);
}

// --------------------------- CurDir() function
char *CurDir(char * ="");
char *CurDir(char *Drive)
{
	char *CurDriveStrTmp;
	CurDriveStrTmp=garbagestring(MAX_PATH+1);
	GetCurrentDirectory(MAX_PATH,CurDriveStrTmp);
	return(CurDriveStrTmp);
}

// --------------------------- Date() function
char *Date(void);
char *Date(void)
{
	char *ReturnedDate="";
	char *ReturnValue="";
	SYSTEMTIME DtNow;
	DWORD DateLen;
	DWORD DateMem;
	memset(&DtNow,0,sizeof(DtNow));
	GetLocalTime(&DtNow);
	DateLen=GetDateFormat(LOCALE_USER_DEFAULT,DATE_SHORTDATE,&DtNow,0,0,0);
	DateMem=(DWORD)MallocZero(DateLen+1);
	if(DateMem!=0)
	{
		GetDateFormat(LOCALE_USER_DEFAULT,DATE_SHORTDATE,&DtNow,0,DateMem,DateLen);
		ReturnedDate=String(strlen((char *)DateMem),0);
		memcpy(ReturnedDate,(void *)DateMem,strlen((char *)DateMem));
		free((void *)DateMem);
		ReturnValue=ReturnedDate;
	}
	return(ReturnValue);
}

// --------------------------- Now() function
char *Now(void);
char *Now(void)
{
	char *ReturnedDate="";
	char *ReturnedTime="";
	char *ReturnValue="";
	SYSTEMTIME DtNow;
	DWORD DateLen;
	DWORD DateMem;
	memset(&DtNow,0,sizeof(DtNow));
	GetLocalTime(&DtNow);
	DateLen=GetDateFormat(LOCALE_USER_DEFAULT,DATE_SHORTDATE,&DtNow,0,0,0);
	DateMem=(DWORD)MallocZero(DateLen+1);
	if(DateMem!=0)
	{
		GetDateFormat(LOCALE_USER_DEFAULT,DATE_SHORTDATE,&DtNow,0,DateMem,DateLen);
		ReturnedDate=String(strlen((char *)DateMem),0);
		memcpy(ReturnedDate,(void *)DateMem,strlen((char *)DateMem));
		free((void *)DateMem);
		ReturnValue=ReturnedDate;
		DateLen=GetTimeFormat(LOCALE_USER_DEFAULT,TIME_FORCE24HOURFORMAT,&DtNow,0,0,0);
		DateMem=(DWORD)MallocZero(DateLen+1);
		if(DateMem!=0)
		{
			ReturnValue = ReturnValue>>(VBStr)" ";
			GetTimeFormat(LOCALE_USER_DEFAULT,TIME_FORCE24HOURFORMAT,&DtNow,0,DateMem,DateLen);
			ReturnedTime=String(strlen((char *)DateMem),0);
			memcpy(ReturnedTime,(void *)DateMem,strlen((char *)DateMem));
			free((void *)DateMem);
			ReturnValue=ReturnValue>>(VBStr)ReturnedTime;
		}
	}
	return(ReturnValue);
}

// --------------------------- Time() function