example1.cpp

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

char *Time(void);
char *Time(void)
{
	char *ReturnedTime="";
	char *ReturnValue="";
	SYSTEMTIME DtNow;
	DWORD DateLen;
	DWORD DateMem;
	memset(&DtNow,0,sizeof(DtNow));
	GetLocalTime(&DtNow);
	DateLen=GetTimeFormat(LOCALE_USER_DEFAULT,TIME_FORCE24HOURFORMAT,&DtNow,0,0,0);
	DateMem=(DWORD)MallocZero(DateLen+1);
	if(DateMem!=0)
	{
		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=ReturnedTime;
	}
	return(ReturnValue);
}

// --------------------------- InStr() function
int InStr(int,char *MainString,char *SubString=0,int=VbCompareMethod_vbBinaryCompare);
int InStr(int SStart,char *MainString,char *SubString,int Search)
{
	char *InstrMainString;
	char *InstrSubString;
	DWORD i=0;
	DWORD MainStringLen;
	DWORD SubStringLen=0;
	DWORD FirstChar=0;
	BOOL FoundFirstChar=FALSE;
	DWORD PosInSubString=0;
	DWORD FoundStart=0;
	DWORD SaveFoundStart=0;
	DWORD CharChecked=0;
	MainStringLen=strlen(MainString);
	if (SubString==0)
	{
		if (MainStringLen==0) return 1;
			return 0;
	}
	if (strlen(SubString)==0)
	{
		if (MainStringLen==0) return 0;
		return(SStart);
	}
	if (SStart<=0) return 0;
	if (SStart > MainStringLen) return 0;
	InstrMainString=MainString;
	InstrSubString=SubString;
	if (Search==VbCompareMethod_vbTextCompare)
	{
		InstrMainString=UCase(MainString);
		InstrSubString=UCase(SubString);
	}
	FirstChar=InstrSubString[0];
	MainStringLen=strlen(InstrMainString);
	SubStringLen=strlen(InstrSubString);
	FoundStart=SStart;
SearchFirstChar:
	FoundFirstChar=FALSE;
	PosInSubString=1;
	for(i=FoundStart;i<=MainStringLen;i++)
	{
		if(InstrMainString[i-1]==FirstChar)
		{
			FoundFirstChar=TRUE;
			break;
		}
	}
	if(FoundFirstChar==FALSE)
	{
		return(0);
	}
	FoundStart=i;
	SaveFoundStart=FoundStart;
	FoundFirstChar=FALSE;
	CharChecked=0;
	while(FoundStart <= MainStringLen)
	{
		if(PosInSubString>SubStringLen)
		{
			break;
		}
		CharChecked=CharChecked+1;
		if(InstrMainString[FoundStart-1]!=InstrSubString[PosInSubString-1])
		{
			FoundFirstChar=TRUE;
			break;
		}
		PosInSubString++;
		FoundStart++;
	}
	if(FoundFirstChar==TRUE)
	{
		FoundStart=SaveFoundStart+1;
		if(FoundStart>=MainStringLen)
		{
			return(0);
		}
		goto SearchFirstChar;
	}
	if(CharChecked<SubStringLen)
	{
		SaveFoundStart=0;
	}
	return(SaveFoundStart);
}

// --------------------------- StrComp() function
int StrComp(char *,char *,int=-1);
int StrComp(char *String1,char *String2,int Search)
{
	if(Search==-1) Search=VBCompareBase;
	if(Search==VbCompareMethod_vbBinaryCompare)
	{
		return strcmp(String1,String2);
	}
	else
	{
		return stricmp(String1,String2);
	}
}

// --------------------------- Replace() function
char *Replace(char *,char *,char *,int=1,int=-1,int=VbCompareMethod_vbBinaryCompare);
char *Replace(char *MainString,char *StringToFind,char *StringToReplace,int ReplaceStart,int RepCount,int CompareType)
{
	char *ReturnString;
	int OldPosInString;
	int PosInString;
	int LenToFind;
	int LenToReplace;
	char *TmpString;
	int NbrToReplace;
	char *SunMainString;
	int SunMainStringLen;
	char *RetReplaceString;
	NbrToReplace=RepCount;
	LenToFind = strlen(StringToFind);
	if (LenToFind!=0)
	{
		LenToReplace = strlen(StringToReplace);
		if(ReplaceStart<=0) ReplaceStart = 1;
		SunMainString = Mid(MainString,ReplaceStart);
		PosInString = 1;
		OldPosInString = 1;
ReplaceAll:
		if(NbrToReplace==0) goto StopReplace;
		PosInString = InStr(PosInString, SunMainString, StringToFind, CompareType);
		if(PosInString!=0)
		{
			TmpString=Left(SunMainString,PosInString - 1);
			TmpString = TmpString >>(VBStr) StringToReplace;
			TmpString = TmpString >>(VBStr) Mid(SunMainString, PosInString + LenToFind);
			PosInString = PosInString + LenToReplace;
			OldPosInString = PosInString;
			if(NbrToReplace!=-1) NbrToReplace = NbrToReplace - 1;
			SunMainString = TmpString;
			goto ReplaceAll;
		}
StopReplace:
		SunMainStringLen=strlen(SunMainString);
		RetReplaceString=garbagestring(SunMainStringLen);
		strncpy(RetReplaceString,SunMainString,SunMainStringLen);
		ReturnString = RetReplaceString;
	}
	else {
		ReturnString = MainString;
	}
	return ReturnString;
}

// --------------------------- Hex() function
char *Hex(DWORD);
char *Hex(DWORD d)
{
	char *HexStrTmp;
	HexStrTmp=garbagestring(30);
	sprintf(HexStrTmp,"%X",d);
	return HexStrTmp;
}

// --------------------------- Oct() function
char *Oct(DWORD);
char *Oct(DWORD d)
{
	char *OctStrTmp;
	OctStrTmp=garbagestring(30);
	sprintf(OctStrTmp,"%o",d);
	return OctStrTmp;
}

// --------------------------- Environ() function
char *Environ(char *);
char *Environ(char *EnvStr)
{
	char *EnvStrTmp;
	EnvStrTmp=garbagestring(2048+1);
	GetEnvironmentVariable(EnvStr,EnvStrTmp,2048);
	return EnvStrTmp;
}

// --------------------------- Command() function
__inline char *Command();
__inline char *Command()
{
	return VBCommand;
}

// --------------------------- QBColor() function
__inline DWORD QBColor(int);
__inline DWORD QBColor(int ColorIndex)
{
	return vbQBColorTable[ColorIndex];
}

// --------------------------- UBound() function
__inline DWORD ubound(DWORD);
__inline DWORD ubound(DWORD Req)
{
	return VBRequestedArrayBound;
}

// --------------------------- LBound() function
__inline DWORD lbound(DWORD);
__inline DWORD lbound(DWORD Req)
{
	return 0;
}

// --------------------------- VBMidCommand() function
void VBMidCommand(char *,DWORD,DWORD=-1,char * ="");
void VBMidCommand(char *StrDestMid,DWORD MidPos,DWORD MidLen,char *StrSourceMid){
	DWORD i;
	DWORD StrDestPos;
	DWORD StrSourceMidLen;
	StrSourceMidLen=strlen(StrSourceMid);
	if(MidLen==-1)
	{
		i=StrSourceMidLen;
	}
	else
	{
		i=MidLen;
		if(StrSourceMidLen<i) i=StrSourceMidLen;
	}
	StrDestPos=MidPos-1;
	strncpy(StrDestMid+StrDestPos,StrSourceMid,i);
}

// --------------------------- VBGetDirectory() function
char *VBGetDirectory(char *);
char *VBGetDirectory(char *FileName)
{
	DWORD i;
	i=strlen(FileName);
	if(i==0) return("");
	while(i--)
	{
		if(FileName[i]=='\\') break;
	}
	return(Left(FileName,i));
}

// --------------------------- killFiles() function
void Kill(char *);
void Kill(char *FileName)
{
	WIN32_FIND_DATA KillDat;
	DWORD hKillFile;
	VBGetDirectory(FileName);
	hKillFile=FindFirstFile(FileName,&KillDat);
	while(hKillFile!=INVALID_HANDLE_VALUE)
	{
		DeleteFile(VBGetDirectory(FileName)>>(VBStr)"\\">>(VBStr)KillDat.cFileName);
		if(FindNextFile(hKillFile,&KillDat)==0)
		{
			if(GetLastError()==ERROR_NO_MORE_FILES) break;
		}
	}
	if(hKillFile!=INVALID_HANDLE_VALUE) FindClose(hKillFile);
}

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

// --------------------------- SngToStr() function
__inline char *SngToStr(float);
__inline char *SngToStr(float d)
{
	char *SngToStrStrTmp;
	SngToStrStrTmp=garbagestring(32);
	sprintf(SngToStrStrTmp,"%.7g",d);
	return Replace(SngToStrStrTmp,".",",");
}

// --------------------------- StrToDbl() function
__inline double StrToDbl(char *);
__inline double StrToDbl(char *Str)
{
	return atof(Replace(Str,",","."));
}

// --------------------------- StrToSng() function
__inline float StrToSng(char *);
__inline float StrToSng(char *Str)
{
	float strtosngfloat=0.0;
	sscanf(Replace(Str,",","."),"%g",&strtosngfloat);
	return strtosngfloat;
}

// --------------------------- StrToBool() function
__inline BOOL StrToBool(char *);
__inline BOOL StrToBool(char *Str)
{
	if(stricmp(Str,"TRUE")==0) return TRUE;
	if(stricmp(Str,"FALSE")==0) return FALSE;
	return FALSE;
}

// --------------------------- BoolToStr() function
__inline char *BoolToStr(BOOL);
__inline char *BoolToStr(BOOL Boolean)
{
	if(Boolean==TRUE) return "True";
	return "False";
}

// --------------------------- BoolToStrNum() function
__inline char *BoolToStrNum(BOOL);
__inline char *BoolToStrNum(BOOL Boolean)
{
	if(Boolean==TRUE) return "-1";
	return "0";
}

// --------------------------- LongToBool() function
__inline BOOL LongToBool(DWORD);
__inline BOOL LongToBool(DWORD LongToConvert)
{
	if(LongToConvert==0) return(FALSE);
	return(TRUE);
}

// --------------------------- DblToBool() function
__inline BOOL DblToBool(double);
__inline BOOL DblToBool(double DblToConvert)
{
	if(DblToConvert==0.0) return(FALSE);
	return(TRUE);
}

// --------------------------- SngToBool() function
__inline BOOL SngToBool(float);
__inline BOOL SngToBool(float SngToConvert)
{
	if(SngToConvert==0.0) return(FALSE);
	return(TRUE);
}

// --------------------------- DWORDToStr() function
__inline char *DWORDToStr(DWORD);
__inline char *DWORDToStr(DWORD d)
{
	char *StrStrTmp;
	StrStrTmp=garbagestring(32);
	sprintf(StrStrTmp,"%d",d);
	return StrStrTmp;