Example #1
0
void CGoToDlg::OnBnClickedOk2()
{
	UpdateData();

	int frame = 0;
	float fps = 0;

	CAtlRegExp<> re;

	REParseError status = re.Parse(_T("{\\z}[^0-9\\.]+{[0-9\\.]+}"), FALSE);
	if(REPARSE_ERROR_OK == status)
	{
		CAtlREMatchContext<> mc;
		const CAtlREMatchContext<>::RECHAR* s = m_framestr.GetBuffer();
		const CAtlREMatchContext<>::RECHAR* e = NULL;
		if(re.Match(s, &mc, &e))
		{
			const CAtlREMatchContext<>::RECHAR* szStart = 0;
			const CAtlREMatchContext<>::RECHAR* szEnd = 0;

			mc.GetMatch(0, &szStart, &szEnd);
			frame = _tcstol(szStart, (TCHAR**)&szStart, 10);

			mc.GetMatch(1, &szStart, &szEnd);
			if(_stscanf(szStart, _T("%f"), &fps) != 1) fps = 0;
			else AfxGetMyApp()->WriteProfileString(ResStr(IDS_R_SETTINGS), _T("fps"), szStart);
		}
		else
		{
			AfxMessageBox(_T("Error parsing entered text!"));
			return;
		}

		if(fps == 0)
		{
			AfxMessageBox(_T("Error parsing entered frame-rate!"));
			return;
		}

		m_time = (int)(1000.0*frame/fps) + 1;

		AfxGetMyApp()->WriteProfileInt(ResStr(IDS_R_SETTINGS), _T("gotoluf"), 1);

		OnOK();
	}
}
Example #2
0
void CGoToDlg::OnBnClickedOk1()
{
	UpdateData();

	int hh, mm, ss, ms;
	hh = mm = ss = ms = 0;

	CAtlRegExp<> re;

	REParseError status = re.Parse(_T("{\\z}"), FALSE);
	if(REPARSE_ERROR_OK == status)
	{
		CAtlREMatchContext<> mc;
		const CAtlREMatchContext<>::RECHAR* s = m_timestr.GetBuffer();
		const CAtlREMatchContext<>::RECHAR* e = NULL;
		while(s && re.Match(s, &mc, &e))
		{
			const CAtlREMatchContext<>::RECHAR* szStart = 0;
			const CAtlREMatchContext<>::RECHAR* szEnd = 0;
			mc.GetMatch(0, &szStart, &szEnd);

			if(hh != 0 || hh > 59 || mm > 59 || ss > 59)
			{
				AfxMessageBox(_T("Error parsing entered time!"));
				return;
			}

			hh = mm;
			mm = ss;
			ss = ms;
			ms = _tcstol(szStart, (TCHAR**)&szStart, 10);

			s = e;
		}

		m_time = ((hh*60+mm)*60+ss)*1000+ms;

		AfxGetMyApp()->WriteProfileInt(ResStr(IDS_R_SETTINGS), _T("gotoluf"), 0);

		OnOK();
	}
}
void CRemoteGraphForm::OnRefreshClick()
{
	// let's load objects from ROT
	CComPtr<IRunningObjectTable>	rot;
	HRESULT							hr;

	graphs.RemoveAll();
    list_graphs.DeleteAllItems();
    sel_graph = RemoteGraph();

	hr = GetRunningObjectTable(0, &rot);
	if (FAILED(hr)) return ;

	// scan through running objects
	CComPtr<IEnumMoniker>			emon;
	CComPtr<IMoniker>				moniker;
	CComPtr<IBindCtx>				bindctx;
	ULONG							f;

	hr = CreateBindCtx(0, &bindctx);
	if (FAILED(hr)) {
		return ;
	}

    CAtlRegExp<> regex;
    REParseError status = regex.Parse(_T("^\\!FilterGraph {[0-9A-F]+} pid {[0-9A-F]+}(; process\\: {.+?}, time\\: {[0-9]+\\-[0-9]+\\-[0-9]+})?"), FALSE);

	rot->EnumRunning(&emon);
	emon->Reset();
	while (emon->Next(1, &moniker, &f) == NOERROR) {
		
		// is this a graph object ?
		LPOLESTR	displayname;
		moniker->GetDisplayName(bindctx, NULL, &displayname);

		CString		name(displayname);
		if (name.Find(_T("!FilterGraph")) == 0 && !GraphStudio::DisplayGraph::IsOwnRotGraph(name)) {
            RemoteGraph	gr = {0};

            CAtlREMatchContext<> mc;
            gr.name = name;
			gr.moniker = moniker;
            gr.pid = 0;
            gr.instance = 0;
            gr.processIsWOW64 = FALSE;

            if (regex.Match(name, &mc))
            {
                const CAtlREMatchContext<>::RECHAR* szStart = 0;
                const CAtlREMatchContext<>::RECHAR* szEnd = 0;
                mc.GetMatch(0, &szStart, &szEnd);
                int nLength = (int) (szEnd - szStart);
                const CString textInstance(szStart, nLength);
                StrToInt64ExW(CStringW(L"0x") + textInstance, STIF_SUPPORT_HEX, &reinterpret_cast<LONGLONG&>(gr.instance));

                mc.GetMatch(1, &szStart, &szEnd);
                nLength = (int) (szEnd - szStart);
                const CString textPID(szStart, nLength);
				CString nameSuffix(szEnd ? szEnd : _T(""));
				nameSuffix.Trim();

			    if (StrToIntExW(CStringW(L"0x") + textPID, STIF_SUPPORT_HEX, &reinterpret_cast<INT&>(gr.pid)))
                {
                    CHandle process;
					process.Attach(OpenProcess(PROCESS_QUERY_INFORMATION | PROCESS_VM_READ, FALSE, gr.pid));
					if (process)
                    {
                        TCHAR pszPath[MAX_PATH] = { 0 };
					    if (GetModuleFileNameEx(process, NULL, pszPath, sizeof(pszPath)))
                        {
                            gr.processImagePath = pszPath;

                            // Extract filename
                            int fileNamePos = gr.processImagePath.FindFileName();
                            if (fileNamePos >= 0)
                                gr.processImageFileName = CString(gr.processImagePath).Mid(fileNamePos);
                        }
                        else
                        {
                            // a 32Bit process can't list the modules of a 64Bit process, so try to get the processImageFileName from the ROT-Name (works only for FilterGraphSpy-Entries)
                            mc.GetMatch(2, &szStart, &szEnd);
                            nLength = (int) (szEnd - szStart);
                            if (nLength > 0)
                            {
                                CString textFileName(szStart, nLength);
                                gr.processImageFileName = textFileName;
                            }
							else if (nameSuffix.GetLength() > 0)
							{
								gr.processImageFileName = nameSuffix;		// as a last resort add any suffix information from the ROT name rather than leaving blank
#ifndef _WIN64
								gr.processImageFileName += _T(" *64");		// If we're 32bit, assume that we can't get process name because remote process is 64bit and show this on the dialog
#endif
							}
                        }

                        IsWow64Process(process, &gr.processIsWOW64);
                    }
                }

                mc.GetMatch(3, &szStart, &szEnd);
                nLength = (int) (szEnd - szStart);
                if (nLength > 0)
                {
                    CString textTime(szStart, nLength);
                    textTime.Replace(_T("-"), _T(":"));
                    gr.time = textTime;
                }
            }
            graphs.Add(gr);

            CString entryName = gr.name;
            if (gr.pid > 0)
                entryName.Format(_T("%d (0x%08lX)"), gr.pid, gr.pid);
			int nIndex = list_graphs.InsertItem(list_graphs.GetItemCount(), entryName);
            
            if (gr.processIsWOW64)
            {
                CString val = gr.processImageFileName;
                val.Append(_T(" *32"));
                list_graphs.SetItemText(nIndex, 1, val);
            }
            else
                list_graphs.SetItemText(nIndex, 1, gr.processImageFileName);

            if (gr.instance > 0)
            {
                CString val;
                val.Format(_T("0x%I64d"), gr.instance);
                list_graphs.SetItemText(nIndex, 2, val);
            }

            list_graphs.SetItemText(nIndex, 3, gr.time);
            list_graphs.SetItemText(nIndex, 4, gr.processImagePath);

			if (graphs.GetCount() == 1) {
                list_graphs.SetItemState(0, LVIS_SELECTED, LVIS_SELECTED);
                list_graphs.SetSelectionMark(0);
			}
		}

		if (displayname) {
			CComPtr<IMalloc>	alloc;
			if (SUCCEEDED(CoGetMalloc(0, &alloc))) {
				alloc->Free(displayname);
			}
		}
		moniker = NULL;
	}

	// Set column width automatically to fit contents refreshed above
	for (int n=0; n<=4; n++) {
		list_graphs.SetColumnWidth(n, LVSCW_AUTOSIZE_USEHEADER);
	}
}
void CProjectInfoWriteDlg::OnBnClickedButtonSenddata()
{
	// TODO: 在此添加控件通知处理程序代码
	//更新成员内容
	UpdateData(TRUE);
	//检查项目名称
	if(m_ProjectName.IsEmpty())
	{
		MessageBox(L"项目名称不能为空!",L"项目发送",MB_ICONWARNING);
		return;
	}
	//检查邮箱地址
	if(m_MailAddr.IsEmpty())
	{
		MessageBox(L"请填写一个邮箱地址!",L"项目发送",MB_ICONWARNING);
		return;
	}
	//检查邮箱格式
	CString strRegex=L"({[a-zA-Z0-9_]+@[a-zA-Z0-9]+[.][a-zA-Z0-9]+[.]?[a-zA-Z0-9]+})";
	CAtlRegExp<CAtlRECharTraitsW> reRule;
	wchar_t *wt = (wchar_t *)(LPCTSTR)strRegex;
	REParseError status = reRule.Parse((const ATL::CAtlRegExp<CAtlRECharTraitsW>::RECHAR *)wt);
	if (REPARSE_ERROR_OK != status)
	{
		AfxMessageBox(L"输入的邮件地址不合法!");
		return;
	}
	CAtlREMatchContext<CAtlRECharTraitsW> mcRule;
	wt = (wchar_t *)(LPCTSTR)m_MailAddr;
	if (!reRule.Match((const ATL::CAtlRegExp<CAtlRECharTraitsW>::RECHAR *)wt,&mcRule))
	{
		AfxMessageBox(L"输入的邮件地址不合法!");
		return;
	}
	else
	{
		for (UINT nGroupIndex = 0; nGroupIndex < mcRule.m_uNumGroups; ++nGroupIndex)
		{
			const CAtlREMatchContext<>::RECHAR* szStart = 0;
			const CAtlREMatchContext<>::RECHAR* szEnd = 0;
			mcRule.GetMatch(nGroupIndex, &szStart, &szEnd);
			ptrdiff_t nLength = szEnd - szStart;
			CString strEmailAddress(szStart,  static_cast<int>(nLength));
			if(strEmailAddress.Compare(m_MailAddr)!=0)
			{
				CString strPrompt;
				strPrompt.Format(L"输入的邮件地址不合法,您要输入%s 吗!",strEmailAddress);
				AfxMessageBox(strPrompt);
				return;
			}
		}
	}
	//检查发送人姓名
	if(m_SenderName.IsEmpty())
	{
		MessageBox(L"请如实填写发送人姓名!",L"项目发送",MB_ICONWARNING);
		return;
	}
	if(m_AnaType.IsEmpty())
	{
		MessageBox(L"请选择一个溯源模式!",L"项目发送",MB_ICONWARNING);
		return;
	}
	CDialogEx::OnOK();
}
Example #5
0
void aux_sscanf(CAstSig &ast, const AstNode *pnode, const AstNode *p)
{
	const char *fnsigs[] = {
		"(string, format_string)", 0};
	checkNumArgs(pnode, p, fnsigs, 2, 0);

	string srcstring = ast.ComputeString(p);
	p = p->next;
	string fmtstring = ast.ComputeString(p);
	processEscapes(fmtstring);
	const char *fmtstr = fmtstring.c_str();
	const char *srcstr = srcstring.c_str();

	CAtlRegExp<> regexp;
	REParseError status = regexp.Parse("{%}([-+ #0]+)?({\\*})?({\\z})?[hlL]?{[cuoxXideEgGfs]}" );
	if (REPARSE_ERROR_OK != status)
		throw "Internal error! RegExp.Parse( ) failed.";
	CAtlREMatchContext<> mcFormat;
	char fmttype;
	const char *fmtspec;	// pointer to '%', for the error message.
	int CharWidth, fmtcnt = 0;
	for (const char *next; fmtstr && regexp.Match(fmtstr, &mcFormat, &next); fmtstr=next) {
		const CAtlREMatchContext<>::RECHAR* szStart = 0;
		const CAtlREMatchContext<>::RECHAR* szEnd = 0;
		bool fIgnore = false;
		for (UINT nGroupIndex = 0; nGroupIndex < mcFormat.m_uNumGroups; ++nGroupIndex) {
			mcFormat.GetMatch(nGroupIndex, &szStart, &szEnd);
			switch (nGroupIndex) {
			case 3:	// type specifier
				if (++fmtcnt > 1)
					throw "Only one value can be read and returned.";
				fmttype = *szStart;
				break;
			case 2:	// width specifier
				CharWidth = -1;
				if (szStart && sscanf(szStart, "%d", &CharWidth) != 1)
					throw "Invalid width.";
				break;
			case 1:	// starting asterisk : read and ignore (don't store)
				if (szStart)
					fIgnore = true;
				break;
			case 0:	// '%'
				fmtspec = szStart;
				break;
			}
			if (fIgnore)
				break;
		}
		if (fIgnore)
			continue;	
	}
	int res, iv;
	unsigned uv;
	float fv;
	vector<char> vbuf;
	switch (fmttype) {
	case 'e': case 'E':
	case 'g': case 'G':
	case 'f':
		if ((res = sscanf(srcstr, fmtstring.c_str(), &fv)) == 1)
			ast.Sig.SetValue(fv);
		break;
	case 'd': case 'o':
	case 'x': case 'X':
	case 'i':
		if ((res = sscanf(srcstr, fmtstring.c_str(), &iv)) == 1)
			ast.Sig.SetValue(iv);
		break;
	case 'u':
		if ((res = sscanf(srcstr, fmtstring.c_str(), &uv)) == 1)
			ast.Sig.SetValue(uv);
		break;
	case 's': case 'c':
		if (CharWidth == -1)
			CharWidth = fmttype=='s'?(int)srcstring.size():1;
		vbuf.resize(CharWidth+1);
		if ((res = sscanf(srcstr, fmtstring.c_str(), &vbuf[0])) == 1) {
			ast.Sig.UpdateBuffer((int)strlen(&vbuf[0]));
			for (int i=0; vbuf[i]; ++i)
				ast.Sig.buf[i] = vbuf[i];
		}
	}
	if (res != 1)
		throw CAstException(pnode, "sscanf failed at", fmtspec);
	return;
}
Example #6
0
void aux_fprintf(CAstSig &ast, const AstNode *pnode, const AstNode *p)
{
	const char *fnsigs[] = {
		"(filename, format_string, ...)", 0};
	checkNumArgs(pnode, p, fnsigs, 2, 0);

	CAtlRegExp<> regexp;
	REParseError status = regexp.Parse("%([-+ #0]+)?({\\z|\\*})?(\\.{\\z|\\*})?[hlL]?{[cuoxXideEgGfs]}" );
	if (REPARSE_ERROR_OK != status)
		throw "Internal error! RegExp.Parse( ) failed.";

	string filename = ast.MakeFilename(ast.ComputeString(p), "txt");
	FILE *file;
	if (!(file = fopen(filename.c_str(), "a")))
		throw CAstException(pnode, "Cannot open file", filename);
	try {	// need this to close the file on exception
		CAtlREMatchContext<> mcFormat;
		p = p->next;
		string fmtstring = ast.ComputeString(p);
		processEscapes(fmtstring);
		const char *fmtstr = fmtstring.c_str();
		for (const char *next; fmtstr && regexp.Match(fmtstr, &mcFormat, &next); fmtstr=next) {
			const CAtlREMatchContext<>::RECHAR* szStart = 0;
			const CAtlREMatchContext<>::RECHAR* szEnd = 0;
			string vstring;
			double v;
			string fmt1string(fmtstr, mcFormat.m_Match.szEnd-fmtstr);
			for (UINT nGroupIndex = 0; nGroupIndex < mcFormat.m_uNumGroups; ++nGroupIndex) {
				mcFormat.GetMatch(nGroupIndex, &szStart, &szEnd);
				if (nGroupIndex == 2 || (nGroupIndex < 2 && szStart && *szStart == '*')) {	// condition for consuming an argument
					if ((p = p->next) == NULL)
						throw CAstException(pnode, pnode, fnsigs, "Not enough arguments.");
					if (nGroupIndex == 2 && *szStart == 's')
						vstring = ast.ComputeString(p);
					else if (ast.Compute(p).IsScalar())
						v = ast.Sig.value();
					else
						throw CAstException(pnode, p, fnsigs, "Scalar value expected for this argument.");
					if (nGroupIndex != 2) {
						char width[20];
						sprintf(width, "%d", round(v));
						fmt1string.replace(szStart-fmtstr, 1, width);
					}
				}
			}
			switch (*szStart) {
			case 'e': case 'E':
			case 'g': case 'G':
			case 'f':
				fprintf(file, fmt1string.c_str(), v);
				break;
			case 'c': case 'o':
			case 'x': case 'X':
			case 'i': case 'u':
			case 'd':
				fprintf(file, fmt1string.c_str(), round(v));
				break;
			case 's':
				fprintf(file, fmt1string.c_str(), vstring.c_str());
				break;
			}
		}
		fprintf(file, fmtstr);
		fclose(file);
	} catch (const char *) {
		fclose(file);
		throw;
	} catch (const CAstException &) {
		fclose(file);
		throw;
	}
}
Example #7
0
void aux_sprintf(CAstSig &ast, const AstNode *pnode, const AstNode *p)
{
	const char *fnsigs[] = {
		"(format_string, ...)", 0};
	checkNumArgs(pnode, p, fnsigs, 1, 0);

	CAtlRegExp<> regexp;
	REParseError status = regexp.Parse("%([-+ #0]+)?({\\z|\\*})?(\\.{\\z|\\*})?[hlL]?{[cuoxXideEgGfs]}" );
	if (REPARSE_ERROR_OK != status)
		throw "Internal error! RegExp.Parse( ) failed.";

	ast.Sig.Reset(2);	// to get the output string
	CAstSig tast(&ast);	// to preserve this->Sig
	CAtlREMatchContext<> mcFormat;
	string fmtstring = tast.ComputeString(p);
	processEscapes(fmtstring);
	const char *fmtstr = fmtstring.c_str();
	for (const char *next; fmtstr && regexp.Match(fmtstr, &mcFormat, &next); fmtstr=next) {
		const CAtlREMatchContext<>::RECHAR* szStart = 0;
		const CAtlREMatchContext<>::RECHAR* szEnd = 0;
		string vstring;
		double v;
		string fmt1str(fmtstr, mcFormat.m_Match.szEnd-fmtstr);
		vector<char> outStr;
		outStr.resize(100);
		for (UINT nGroupIndex = 0; nGroupIndex < mcFormat.m_uNumGroups; ++nGroupIndex) {
			mcFormat.GetMatch(nGroupIndex, &szStart, &szEnd);
			if (nGroupIndex == 2 || (nGroupIndex < 2 && szStart && *szStart == '*')) {	// condition for consuming an argument
				if ((p = p->next) == NULL)
					throw CAstException(pnode, pnode, fnsigs, "Not enough arguments.");
				if (nGroupIndex == 2 && *szStart == 's')
					vstring = tast.ComputeString(p);
				else if (tast.Compute(p).IsScalar())
					v = tast.Sig.value();
				else
					throw CAstException(pnode, p, fnsigs, "Scalar value expected for this argument.");
				if (nGroupIndex != 2) {
					char width[20];
					sprintf(width, "%d", round(v));
					fmt1str.replace(szStart-fmtstr, 1, width);
				}
			}
		}
		switch (*szStart) {
		case 'e': case 'E':
		case 'g': case 'G':
		case 'f':
			sprintf(&outStr[0], fmt1str.c_str(), v);
			break;
		case 'c': case 'o':
		case 'x': case 'X':
		case 'i': case 'u':
		case 'd':
			sprintf(&outStr[0], fmt1str.c_str(), round(v));
			break;
		case 's':
			outStr.resize(vstring.size()+100);
			sprintf(&outStr[0], fmt1str.c_str(), vstring.c_str());
			break;
		}
		int n = ast.Sig.nSamples;
		ast.Sig.UpdateBuffer(n + (int)strlen(&outStr[0]));
		for (int j=0; outStr[j]; j++)
			ast.Sig.buf[n+j] = outStr[j];
	}
	int n = ast.Sig.nSamples;
	ast.Sig.UpdateBuffer(n + (int)strlen(fmtstr));
	for (int j=0; fmtstr[j]; j++)
		ast.Sig.buf[n+j] = fmtstr[j];
}
Example #8
0
//用正则表达式来转换
int CWebBase::HtmlCodeToUniCodeByteReg( char *  pszHtmlcode, int iLen )
{

	int     i;
	char  * pcTemp = NULL;
	char *  pcWord = NULL;

	REParseError status;
	CAtlRegExp<>            reurl;
	CAtlREMatchContext<>    mcurl;
	const CAtlREMatchContext<>::RECHAR * szStart = 0;
	const CAtlREMatchContext<>::RECHAR * szEnd = 0;

	unsigned short usData;
	char cbuffGbt[8] = {0};
	char cBuffGbs[8] = {0}; 


	pcTemp = strstr( pszHtmlcode, "&#") ;
	if( pcTemp == NULL ) 
	{
		return iLen;
	}
	status = reurl.Parse( "&#{.*?};");
	if( REPARSE_ERROR_OK != status)
	{
		return iLen;
	}
	for ( i = 0; i < 4000; i++ )
	{
		if (!reurl.Match( pcTemp , &mcurl ) )
		{
			break;
		}
		if( mcurl.m_uNumGroups <= 0 )
		{
			break;
		}
		szStart = NULL;
		szEnd = NULL;
		mcurl.GetMatch( 0, &szStart, &szEnd );
		pcTemp = (char*)szStart;
		if( pcTemp == NULL || szStart == NULL )
		{
			break;
		}
		pcWord = pcTemp;
		//nLength = szEnd - szStart;        
		usData = (unsigned short)atoi(pcWord);
		//转换Unicode码到Gb码繁体,使用API函数WideCharToMultiByte 
		WideCharToMultiByte ( 936, 0, (PWSTR)&usData, -1, 
			cbuffGbt,2, NULL, NULL) ; 
		//转换Gb码繁体到Gb码简体,使用API函数LCMapString 
		LCMapString( 0x0804,LCMAP_SIMPLIFIED_CHINESE, cbuffGbt, -1, 
			cBuffGbs , 2); 
		memcpy( pcWord, cBuffGbs, 2);
		memset( pcWord + 2, '^' , 3 );                        

	}
	return iLen;
}
Example #9
0
BOOL CBoxHttpHost::URLRewrite(CString strURL, CString &strNewURL, CString &strNewQueryString)
{
	UINT i, c;
	int uNumGroups;
	CAtlREMatchContext<CURLRECharTraits> mc;
	LPCTSTR ptr, ptr1, ptrEnd;
	CString *pstrRewrite;

	c = m_areUrl.GetCount();
	for (i=0;i<c;i++)
		if (m_areUrl[i]->Match(strURL, &mc))
			break;

	if (i==c)
	{
		strNewURL = strURL;
		return false;
	}

	pstrRewrite = &strNewURL;
	uNumGroups = mc.m_uNumGroups;
	ptr = m_aUrl[i];
	ptrEnd = ptr + m_aUrl[i].GetLength();

	while(ptr < ptrEnd)
	{
		ptr1 = ptr;
		while(ptr1 < ptrEnd && *ptr1 != '$' && *ptr1 != '?')
			ptr1 ++;

		pstrRewrite->Append(ptr, ptr1 - ptr);
		ptr = ptr1 + 1;

		if (*ptr1 == '?')
		{
			pstrRewrite = &strNewQueryString;
			continue;
		}

		if(ptr < ptrEnd)
		{
			int ch = *ptr - '1';

			if(ch >= 0 && ch <= 9)
			{
				if (ch<uNumGroups)
				{
					const TCHAR* szStart = 0;
					const TCHAR* szEnd = 0;

					mc.GetMatch(ch, &szStart, &szEnd);
					pstrRewrite->Append(szStart, szEnd - szStart);
				}
				ptr ++;
			}
			else if(*ptr == '0')
			{
				if (0<uNumGroups)
				{
					const TCHAR* szStart = 0;
					const TCHAR* szEnd = 0;

					mc.GetMatch(0, &szStart, &szEnd);
					pstrRewrite->Append(szStart, szEnd - szStart);
				}
				ptr ++;
			}
			else if(*ptr == '$')
			{
				pstrRewrite->AppendChar('$');
				ptr ++;
			}
		}
	}

	return (pstrRewrite == &strNewQueryString);
}