bitset<32> binval;
	CBigInt bigInt;
    if( strin.fail())
        return ;
    switch(c)
    {
    case 'x':
        //strin>>hex>>tmp;break;
		tmp = CBigInt::HEX;
		break;
    case 'd':
        //strin>>dec>>tmp;break;
		tmp = CBigInt::DEC;
		break;
    //case 'o':
        //strin>>oct>>tmp;break;
		//bigInt.AtoI(s, CBigInt::);
	//	break;
    case 'b':
        //strin>>binval;
        //tmp=binval.to_ulong();
		tmp = CBigInt::BIN;
        break;
    default:;
		return ;
    }
	DWORD ret = bigInt.AtoI(s, tmp, 16);
	if (ret == ERR_SUCCESS)
    {
        m_pError->AddError(ERR_NO_ERROR);
        //cout<< "Hex:" <<hex << tmp
        //    << "   Dec:" <<dec << tmp
        //    << "   Oct:" <<oct << tmp
        //    << "   Bin:" <<hex << bitset<32> (tmp).to_string<char,std::char_traits<char> ,std::allocator<char> >() 
        //    << endl;
		cout<< "Hex:" << bigInt.ItoA(CBigInt::HEX, 16)
			<< "   Dec:" << bigInt.ItoA(CBigInt::DEC, 16)
			//<< "   Oct:" << bigInt.ItoA(CBigInt::HEX, 16)
			<< "   Bin:" << bigInt.ItoA(CBigInt::BIN, 16)
			<< endl;
//        HextoBin(tmp);
    }
	else
	{
		m_pError->AddError(ret);
	}
}
/*
void CTools::HextoBin(unsigned int ulHex)
{
    CHAR buf[33];
    int i=0;
    while(ulHex)
    {
        buf[i]=ulHex%2;
        ulHex=ulHex/2;
        i++;
    }
    buf[i]='\0';
    int k=8;
    while(k>i)
    {
        cout<< '0';
        k--;
        if(k%4==0)
            cout<< ' ';
    }
    for(i--;i>=0;i--)
    {
        if((i+1)%4==0)
            cout<< ' ';
        cout<< dec <<setw(1) << buf[i] <<hex;
    }
}
*/

unsigned int CTools::BintoHex(CHAR *argv)
{
    unsigned int ulVal=0;
    unsigned int i=0;
    if(*argv!=' ')
        return 0;
    argv++;
    while(  *argv!='\0' && i<(sizeof(unsigned int)*8) )
    {
        if( *argv=='0'|| *argv=='1' )
        {
            ulVal=ulVal*2+(*argv-'0');
            argv++;
        }
        else
        {
            return 0;
        }
        i++;
    }
    return ulVal;
}

void CTools::Status(void)
{
    cout<< "Current File:" << m_pszFileName<< endl
        << "m_uBufPos:" << m_uBufPos << endl
        << "m_ulBufOffset:"<< m_ulBufOffset << endl
        << "m_uDisk:" << m_uDisk << endl
		<< "m_pszFileName: " << m_pszFileName << endl;

    int i=0;
    for(;i<c_CMD_T_MAX_BUF;i++)
    {
        cout<< "Buffer " << setw(1) << i;
        cout<< "Size:" << setw(8) <<m_BufSize[i] << "Bytes" << endl;
        cout<< "CurSectorNumber: " << setw(10) << m_dqBufSector[i] << endl;
    }
    m_pError->AddError(ERR_NO_ERROR);
}

void CTools::HandleError(void)
{
    DWORD tmp=m_pError->GetLastError();
    if( tmp!=ERR_NO_ERROR &&tmp  !=c_CMD_T_CM_QUIT )
    {
        m_pError->ReportAllError();
//    m_pError->ReportLastError();
        m_pError->ClearAllError();
        cout<< "Type h for help" <<endl;
    }
    else if(tmp==ERR_NO_ERROR)
    {
        m_pError->ClearAllError();
    }
}

void CTools::DosCommand(CHAR *argv)
{
    if(*argv==' ')
    {
        argv++;
        //        int ret=system(argv);
        system(argv);
        m_pError->AddError(ERR_NO_ERROR);
        //        if(!ret)
        //			cout<< "Dos Command Executed Fail");
    }
}

void CTools::UseBuf(CHAR *argv)
{
    unsigned int tmp;
    istringstream strin(argv);
    strin.setf(ios_base::hex,ios_base::basefield);
    strin>>tmp;
    if( strin.fail())
        return ;
    if(tmp<c_CMD_T_MAX_BUF)
    {
        m_uBufPos=tmp;
        m_pError->AddError(ERR_NO_ERROR);
        return;
    }
}

void CTools::SearchPartition(CHAR *argv)
{
	DWORD ulStartCyl;
    istringstream strin(argv);
    strin.setf(ios_base::hex,ios_base::basefield);
    strin>>ulStartCyl;
    if( strin.fail())
        return ;

	BYTE buff[512];
	double tmp1 = 255L*63L*512L;
	double tmp2 = 1024L*1024L*100L;
	double tmp3 = 1024L*1024L*1024L;
	cout<< "The compacity of one cyliner is: "  << endl
		<< dec << (DWORD)tmp1 << "bytes(dec)  " 
		<< hex << (DWORD)tmp1 << "bytes(hex)  " 
		<< dec << tmp1/1024/1024 << "Mb(dec)  "  << endl
		<< "100 Mb = " << dec << tmp2/tmp1 << "(dec) cyliners\t\t 1 Gb = "  
		<< dec << tmp3/tmp1 << "(dec) cyliners" 
		<< endl;
		
#ifdef WIN32
    cout<<"Press any key to Stop.";
#endif//
#ifdef __DJGPP__
    cout<<"Press Ctrl+Break to Stop.";
    _go32_want_ctrl_break(1);
#endif//
	cout<< "	Please Wait. Searching ... " << endl
		<< "Current Sectors(Hex):" << endl;
	DWORD64 startSector=0;
	DWORD64 i;
	ostringstream ostr;
	//ostr.fill('0');
	ostr.setf(ios_base::right,ios_base::adjustfield);
	ostr.setf(ios_base::uppercase);
	ostr.setf(ios_base::hex,ios_base::basefield);

	for(i=ulStartCyl;;i++)
	{
//		startSector=i*255*63;
		cprintf("%llX\r", startSector);	//??
		for(int head=0;head<255;head++)
		{
			startSector=i*255*63+head*63;
			if(!m_pInt13->ReadSector(startSector,1,buff))
			{
				cout<< endl 
					<< "End of Disk. Search complete."
					<< endl;
				goto quit;
			}

			if( *( (WORD *)&buff[510] ) ==0xaa55)
			{
				cout<< endl
					<< "Found at: Cyl= " << hex << uppercase << i 
					<< " \tSectors Number= " << hex << uppercase <<( DWORD64) (startSector)
					<< endl;
				cout<< "Press any key to continue. " <<endl;
				getch();
			}
			else
			{
				#ifdef __DJGPP__
				if(_go32_was_ctrl_break_hit())
				{
				#endif
				#ifdef WIN32
				if (kbhit())
				{
					getch();
				#endif//
					if(SLib::GetYesNo())
					{
						m_pError->AddError(ERR_NO_ERROR);
						goto quit ;
					}
				}
			}
		}
	}
quit:
#ifdef __DJGPP__
    _go32_want_ctrl_break(0);
#endif
cout<<hex;
}

void CTools::SaveSectors(CHAR *argv)
{
    DWORD64 ulStartSec;
    DWORD ulLen;
    istringstream strin(argv);
    strin.setf(ios_base::hex,ios_base::basefield);
    strin>>ulStartSec>>ulLen;
    if( strin.fail())
        return ;
    if(ulLen*c_uBYTES_PER_SECTOR>m_BufSize[m_uBufPos])
    {
        m_pError->AddError(ERR_BUF_SMALL);
        return;
    }
    if(m_pInt13->WriteSector(ulStartSec,ulLen,(BYTE *)m_ppBuf[m_uBufPos]) )
        m_pError->AddError(ERR_NO_ERROR);
   // else
    //    m_pError->AddError();
}

void CTools::SaveFile(CHAR *argv)
{
	string sname;
	DWORD len;
	istringstream strin(argv);
	strin.setf(ios_base::hex,ios_base::basefield);
	strin>>sname;
	if( strin.fail())
		return;
	strin>>len;
	if( strin.fail())
		len=m_BufSize[m_uBufPos];
	if(WriteFile(sname.c_str(),len,m_ppBuf[m_uBufPos]))
		m_pError->AddError(ERR_NO_ERROR); 
}

void CTools::BackupDiskPartitions(CHAR *argv)
{
	int diskNumber;
	string spath;
	istringstream strin(argv);
	strin.setf(ios_base::hex,ios_base::basefield);
	strin>>spath;
	if (strin.fail())
	{
		diskNumber = 0x80;
		spath = "";
		cout<<"Use current directory to save backup file for disk 0x80" << endl;
	}
	else
	{
		strin>>diskNumber;
		if (strin.fail())
		{
			diskNumber = 0x80;
			cout<<"Use default disk 0x80" << endl;
		}
	}
	cout<<"Use directory " << spath << " to save backup file for disk " << hex<< showbase << uppercase << diskNumber << endl;
	int oldDiskNumber = m_pInt13->GetActiveDisk();
	if (!m_pInt13->SetPhyDiskNumber(diskNumber))
		return ;
	
	auto_ptr<CBackupDiskSector>pbackup (new CBackupDiskSector(m_pInt13, m_pError));
	if (pbackup->BackupOneDisk(spath))
		m_pError->AddError(ERR_NO_ERROR);

	m_pInt13->SetPhyDiskNumber(oldDiskNumber);
}

void CTools::RestoreDiskPartitions(CHAR *argv)
{
	int diskNumber;
	string spath;
	istringstream strin(argv);
	strin.setf(ios_base::hex,ios_base::basefield);
	strin>>spath;
	if (strin.fail())
	{
		diskNumber = 0x80;
		spath = "";
		cout<<"Use current directory to restore backup file for disk 0x80" << endl;
	}
	else
	{
		strin>>diskNumber;
		if (strin.fail())
		{
			diskNumber = 0x80;
			cout<<"Use default disk 0x80" << endl;
		}
	}
	cout<<"Use directory " << spath << " to restore backup file for disk " << hex<< showbase << uppercase << diskNumber << endl;
	int oldDiskNumber = m_pInt13->GetActiveDisk();
	if (!m_pInt13->SetPhyDiskNumber(diskNumber))
		return ;

	if (GetYesNo("Do you want to backup current disk ?(Y/N)"))
	{
		cout<< endl <<"Input backup directory:";
		string s;
		cin>> s;
		int c =getchar();
		auto_ptr<CBackupDiskSector>pbackup (new CBackupDiskSector(m_pInt13, m_pError));
		if (!pbackup->BackupOneDisk(s))
		{
			return;
		}
	}
	cout<< endl;
	auto_ptr<CBackupDiskSector>pbackup (new CBackupDiskSector(m_pInt13, m_pError));
	if (pbackup->RestoreOneDisk(spath))
		m_pError->AddError(ERR_NO_ERROR);

	m_pInt13->SetPhyDiskNumber(oldDiskNumber);}


#ifdef WIN32
extern void Counter(const char *argv);
void CTools::Counter(CHAR *argv)
{
	if (*argv == ' ' || *argv == '\t')
		;
	else
		return;
	string spath;
	istringstream strin(argv);
	strin.setf(ios_base::hex,ios_base::basefield);
	strin>>spath;
	if (strin.fail())
	{
		cout<<"Using current directory" <<endl;
		::Counter(".");
	}
	else
	{
		::Counter(spath.c_str());
	}
	m_pError->AddError(ERR_NO_ERROR);
}
#endif 

#ifdef __DJGPP__
void CTools::Cmos(CHAR *argv)
{
	if (*argv == ' ' || *argv == '\t')
		;
	else
		return;
	char c;
	string spath;
	istringstream strin(argv);
	strin.setf(ios_base::hex,ios_base::basefield);
	strin>>c>>spath;
	if (!strin.fail() || c== 'c')
	{
		string fileInfo = spath + "ifo";
		string fileBin = spath + "bin";
		switch(c)
		{
		case 'b':
			{
				int i;
				FILE *cmfp,*cmbfp;
				unsigned j;
				if((cmfp=fopen(fileInfo.c_str(),"w"))==NULL)
				{
					printf("can't creat %s\n", fileInfo.c_str());
					return ;
				}
				if((cmbfp=fopen(fileBin.c_str(),"wb"))==NULL)
				{
					printf("can't creat %s\n", fileBin.c_str());
					return ;
				}
				for(i=0;i<=0xff;i++)
				{
					outportb(0x70,i);
					j=inportb(0x71);
					fputc(j,cmbfp);
					if(i%16==0)
						fprintf(cmfp,"\n");
					fprintf(cmfp,"%02X %02X ",i,j );
				}
				fclose(cmfp);
				fclose(cmbfp);
				printf("Backup CMOS Information successfull.\n");
			}
			break;
		case 'c':
			{
				int i;
				for(i=0;i<=0xff;i++)
				{
						outportb(0x70,i);
						outportb(0x71,0);
				}
				printf("Clear CMOS Information successfull.\n");
			}
			break;
		case 'r':
			{
				FILE *cmopen;
				int j,i;
				if((cmopen=fopen(fileBin.c_str(),"r+b"))==NULL)
				{
					printf("can't open %s\n", fileBin.c_str());
					return ;
				}
				for( i=0;i<=0xff;i++)
				{
					outportb(0x70,i);
					j=fgetc(cmopen);
					outportb(0x71,j);
				}
				fclose(cmopen);
				printf("Restore CMOS Information successfull.\n");
			}
			break;
		default:
			return;
		}
	}
	else
	{
		return ;
	}
	m_pError->AddError(ERR_NO_ERROR);
}

#endif 

void DispError(CHAR *p)
{
    cout<<"Error is:" << p << endl;
}

void CTools::SetActivePhyDisk(CHAR *argv)
{
    unsigned int tmp;
    istringstream strin(argv);
    strin.setf(ios_base::hex,ios_base::basefield);
    strin>>tmp;
    if( strin.fail())
        return ;
    if( tmp>=0x80 && tmp < ( 0x80+c_iMAX_DISKS) )
    {
        if(m_pInt13->SetPhyDiskNumber(tmp))
		{
			m_uDisk=tmp;
			m_pError->AddError(ERR_NO_ERROR);
		}
    }
}

//__declspec(dllimport)  const SLib::ERROR_STRING g_allErrorString[];

CCmdToolError::CCmdToolError(void)
{

}

CCmdToolError::~CCmdToolError()
{

}

void CCmdToolError::OutputMsg(const tstring & msg)const 
{
    cout<< msg ;
}