忘记怎样忘记

MFC文件操作大全

1.创建文件夹

CreateDirectory(%%1,NULL);

2.创建文件

CFile file;

file.Open(%%1,CFile::modeCreate|CFile::modeWrite);

3.删除文件

DeleteFile(%%1);

4.删除文件夹

RemoveDirectory(%%1);

5.删除一个目录下所有的文件夹

CFileFind finder;

CString path;

path.Format("%s//*.*",%%1);

BOOL bWorking = finder.FindFile(path);

while (bWorking)

{

bWorking = finder.FindNextFile();

if (finder.IsDirectory() && !finder.IsDots())

{

RemoveDirectory(finder.GetFilePath());

}

6.清空文件夹

RemoveDirectory(%%1);

CreateDirectory(%%1,NULL);

7.读取文件

char sRead[5120];

CFile mFile(_T(%%1),CFile::modeRead);

while (sRead!=NULL)

{

mFile.Read(sRead,5120);

CString %%2(sRead);

%%3

}

mFile.Close();

8.写入文件

CFile mFile(_T(%%1), CFile::modeWrite|CFile::modeCreate);

mFile.Write(%%2,sizeof(%%2));

mFile.Flush();

mFile.Close();

9.写入随机文件

char szTempPath[_MAX_PATH],szTempfile[_MAX_PATH];

GetTempPath(_MAX_PATH, szTempPath);

GetTempFileName(szTempPath,_T ("my_"),0,szTempfile);

CFile m_tempFile(szTempfile,CFile:: modeCreate|CFile:: modeWrite);

char m_char='a';

m_tempFile.Write(&m_char,2);

m_tempFile.Close();

//循环写入多个值

strTempA;

int i;

int nCount=6;

//共有6个文件名需要保存

for (i=0;i{strTemp.Format("%d",i);

strTempA=文件名;

//文件名可以从数组,列表框等处取得.

::WritePrivateProfileString("UseFileName","FileName"+strTemp,strTempA,

c://usefile//usefile.ini);

}

strTemp.Format("%d",nCount);

::WritePrivateProfileString("FileCount","Count",strTemp,"c://usefile//usefile.ini");

//将文件总数写入,以便读出.

//读出

nCount=::GetPrivateProfileInt("FileCount","Count",0,"c://usefile//usefile.ini");

for(i=0;i{strTemp.Format("%d",i);

strTemp="FileName"+strTemp;

::GetPrivateProfileString("CurrentIni",strTemp,"default.fil", strTempA.GetBuffer(MAX_PATH),MAX_PATH,"c://usefile//usefile.ini");

//使用strTempA中的内容.

}

1.Seek

Seek(100L,CFile::begin);//移动到文件开始后100字节处

Seek(100L,CFile::end);

Seek(100L,CFile::current);

2.GetPosition

得到文件当前位置，返回32位文件指针

DWORD pos=file.GetPostition();

file.Seek(pos,CFile::begin);

3.GetLength()

10.读取文件属性

DWORD dwAttrs = GetFileAttributes(%%1);

if(dwAttrs & FILE_ATTRIBUTE_READONLY) {

%%2

}

if(dwAttrs & FILE_ATTRIBUTE_NORMAL){

%%3

}

11.写入属性

SetFileAttributes(%%1,dwAttrs | FILE_ATTRIBUTE_READONLY);

12.枚举一个目录下所有文件夹

CFileFind finder;

CString path;

path.Format("%s//*.*",%%1);

BOOL bWorking = finder.FindFile(path);

while (bWorking) {

bWorking = finder.FindNextFile();

if(finder.IsDirectory() && !finder.IsDots()){

CString %%1=finder.GetFilePath();

%%2

}

13.复制文件夹

#include

using namespace std;

dequectr;

WIN32_FIND_DATA FileData;

HANDLE hSearch;

DWORD dwAttrs;

char szDirPath[] = %%2;

char szNewPath[MAX_PATH];

BOOL fFinished = FALSE;

if (!CreateDirectory(szDirPath, NULL)) {

//不能创建新的目录

return;

}

CString path;

path.Format("%s//*.*",%%1);

hSearch = FindFirstFile(path, &FileData);

if (hSearch == INVALID_HANDLE_VALUE) {

return;

}

while (ctr.size>0) {

if(!fFinished)

lstrcpy(szNewPath, szDirPath);

lstrcat(szNewPath, FileData.cFileName);

if (CopyFile(FileData.cFileName, szNewPath, FALSE)) {

dwAttrs = GetFileAttributes(FileData.cFileName);

if (!(dwAttrs & FILE_ATTRIBUTE_READONLY)) {

SetFileAttributes(szNewPath,

dwAttrs | FILE_ATTRIBUTE_READONLY);

}

else {

//不能复制文件

return;

}

if (!FindNextFile(hSearch, &FileData)) {

if (GetLastError() == ERROR_NO_MORE_FILES) {

//遍历文件夹完成

fFinished = TRUE;

}

else {

//找不到下一个文件

return;

}

FindClose(hSearch);

14.复制一个目录下所有的文件夹到另一个文件夹下

#include

using namespace std;

dequectr;

WIN32_FIND_DATA FileData;

HANDLE hSearch;

DWORD dwAttrs;

char szDirPath[] = %%2;

char szNewPath[MAX_PATH];

BOOL fFinished = FALSE;

if (!CreateDirectory(szDirPath,NULL))

{

//不能创建新的目录

return;

}

CString path;

CFileFind finder;

path.Format("%s//*.*",%%1);

BOOL bWorking = finder.FindFile(path);

while (bWorking)

{

bWorking = finder.FindNextFile();

if(finder.IsDirectory() && !finder.IsDots()){

hSearch = FindFirstFile(finder.GetFilePath()+"//*.*", &FileData);

if (hSearch == INVALID_HANDLE_VALUE)

{

return;

}

while (!fFinished)

{

lstrcpy(szNewPath, szDirPath);

lstrcat(szNewPath, FileData.cFileName);

if (CopyFile(FileData.cFileName, szNewPath, FALSE))

{

dwAttrs = GetFileAttributes(FileData.cFileName);

if (!(dwAttrs & FILE_ATTRIBUTE_READONLY))

{

SetFileAttributes(szNewPath,

dwAttrs | FILE_ATTRIBUTE_READONLY);

}

else

{

//不能复制文件

return;

}

if (!FindNextFile(hSearch, &FileData))

{

if (GetLastError() == ERROR_NO_MORE_FILES)

{

//遍历文件夹完成

fFinished = TRUE;

}

else

{

//找不到下一个文件

return;

}

FindClose(hSearch);

}

15.移动文件夹

#include

using namespace std;

dequectr;

WIN32_FIND_DATA FileData;

HANDLE hSearch;

DWORD dwAttrs;

char szDirPath[] = %%2;

char szNewPath[MAX_PATH];

BOOL fFinished = FALSE;

if (!CreateDirectory(szDirPath, NULL))

{

//不能创建新的目录

return;

}

CString path;

path.Format("%s//*.*",%%1);

hSearch = FindFirstFile(path, &FileData);

if (hSearch == INVALID_HANDLE_VALUE)

{

return;

}

while (!fFinished)

{

lstrcpy(szNewPath, szDirPath);

lstrcat(szNewPath, FileData.cFileName);

if (CopyFile(FileData.cFileName, szNewPath, FALSE))

{

dwAttrs = GetFileAttributes(FileData.cFileName);

if (!(dwAttrs & FILE_ATTRIBUTE_READONLY))

{

SetFileAttributes(szNewPath,

dwAttrs | FILE_ATTRIBUTE_READONLY);

}

else

{

//不能复制文件

return;

}

if (!FindNextFile(hSearch, &FileData))

{

if (GetLastError() == ERROR_NO_MORE_FILES)

{

//遍历文件夹完成

fFinished = TRUE;

}

else

{

//找不到下一个文件

return;

}

FindClose(hSearch);

RemoveDirectory(%%1);

16.移动一个文件夹下所有的文件夹到另一个目录下

#include

using namespace std;

dequectr;

WIN32_FIND_DATA FileData;

HANDLE hSearch;

DWORD dwAttrs;

char szDirPath[] = %%2;

char szNewPath[MAX_PATH];

BOOL fFinished = FALSE;

if (!CreateDirectory(szDirPath,NULL))

{

//不能创建新的目录

return;

}

CString path;

path.Format("%s//*.*",%%1);

BOOL bWorking = finder.FindFile(path);

while (bWorking)

{

bWorking = finder.FindNextFile();

if(finder.IsDirectory() && !finder.IsDots()){

hSearch = FindFirstFile(finder.GetFilePath()+"//*.*", &FileData);

if (hSearch == INVALID_HANDLE_VALUE)

{

return;

}

while (!fFinished)

{

lstrcpy(szNewPath, szDirPath);

lstrcat(szNewPath, FileData.cFileName);

if (CopyFile(FileData.cFileName, szNewPath, FALSE))

{

dwAttrs = GetFileAttributes(FileData.cFileName);

if (!(dwAttrs & FILE_ATTRIBUTE_READONLY))

{

SetFileAttributes(szNewPath,

dwAttrs | FILE_ATTRIBUTE_READONLY);

}

else

{

//不能复制文件

return;

}

if (!FindNextFile(hSearch, &FileData))

{

if (GetLastError() == ERROR_NO_MORE_FILES)

{

//遍历文件夹完成

fFinished = TRUE;

}

else

{

//找不到下一个文件

return;

}

FindClose(hSearch);

RemoveDirectory(finder.GetFilePath().GetBuffer(0));

}

17.以一个文件夹的框架在另一个目录创建文件夹和空文件

#include

using namespace std;

dequectr;

WIN32_FIND_DATA FileData;

HANDLE hSearch;

DWORD dwAttrs;

char szDirPath[] = %%2;

char szNewPath[MAX_PATH];

BOOL fFinished = FALSE;

if (!CreateDirectory(szDirPath, NULL))

{

//不能创建新的目录

return;

}

CString path;

path.Format("%s//*.*",%%1);

hSearch = FindFirstFile(path, &FileData);

if (hSearch == INVALID_HANDLE_VALUE)

{

return;

}

while (!fFinished)

{

lstrcpy(szNewPath, szDirPath);

lstrcat(szNewPath, FileData.cFileName);

HANDLE hFile=CreateFileHandle hFile=CreateFile(szNewPath,GENERIC_READ,FILE_SHARE_READ,NULL,OPEN_EXISTING,FILE_ATTRIBUTE_NORMAL|FILE_FLAG_SEQUENTIAL_SCAN,NULL);

if(!hFile)

{

//不能创建文件

return;

}

if (!FindNextFile(hSearch, &FileData))

{

if (GetLastError() == ERROR_NO_MORE_FILES)

{

//遍历文件夹完成

fFinished = TRUE;

}

else

{

//找不到下一个文件

return;

}

FindClose(hSearch);

18.复制文件

CopyFile(%%1,%%2,true);

19.复制一个文件夹下所有的文件到另一个目录

#include

using std::string;

char sep='/';

#ifdef _WIN32

sep='//';

#endif

CFileFind finder;

CString path;

path.Format("%s//*.*",%%1);

BOOL bWorking = finder.FindFile(path);

while (bWorking)

{

bWorking = finder.FindNextFile();

if(!finder.IsDirectory() || finder.IsDots()){

string s(finder.GetFileName());

if(s.rfind(sep,s.length())!=string::npos)

{

char *file=substr(i+1,s.length()-i).c_str();

CString sourcefile;

sourcefile.Format("%s%c%s",%%1,sep,file);

CString targetfile;

targetfile.Format("%s%c%s",%%2,file);

CopyFile(sourcefile,targetfile,true);

}

20.提取扩展名

CString path(%%1);

CString %%2=path.Mid(path.ReverseFind('.'));

21.提取文件名

CString path(%%1);

CString %%2=path.Mid(path.ReverseFind('//')+1);

22.提取文件路径

char appName[MAX_PATH];

GetModualFileName(NULL,appName,MAX_PATH);

CString %%1(appName);

23.替换扩展名

#include

using std::string;

string s(%%1);

string newExt(%%2);

string::size_type i=s.rfind('.',s.length());

if(i!=string::npos)

s.replace(i+1,newExt.length(),newExt);

CString %%3(s);

24.追加路径

#include

using namespace std;

using namespace boost::filesystem;

try {

path p1=complete(path(%%2,native),

path(%%1,native));

path p2=system_complete(path(%%2,native));

CString %%3(p3);

%%4

}

catch(exception& e){

//e.what();

}

25.移动文件

MoveFile(%%1,%%2);

26.移动一个文件夹下所有文件到另一个目录

#include

using std::string;

char sep='/';

#ifdef _WIN32

sep='//';

#endif

CFileFind finder;

CString path;

path.Format("%s//*.*",%%1);

BOOL bWorking = finder.FindFile(path);

while (bWorking)

{

bWorking = finder.FindNextFile();

if(!finder.IsDirectory() || finder.IsDots()){

string s(finder.GetFileName());

CString sourcefile(%%1);

if(s.rfind(sep,s.length())!=string::npos)

{

sourcefile=sourcefile+"//"+s.substr(i+1,s.length()-i);

CString targetfile(s.substr(i+1,s.length()-i));

targetfile=%%2+"//"+targetfile/;

MoveFile(sourcefile.GetBuffer(0),targetfile.GetBuffer(0),true);

}

27.指定目录下搜索文件

CString strFileTitle;

CFileFind finder;

BOOL bWorking = finder.FindFile(%%1); //"C://windows//sysbkup//*.cab"

while(bWorking)

{

bWorking=finder.FindNextFile();

strFileTitle=finder.GetFileTitle();

}

28.打开对话框

CString %%1;

CFileDialog dlg(TRUE);///TRUE为OPEN对话框，FALSE为SAVE AS对话框

//dlg.m_ofn.lpstrInitialDir=_T("d://"); //这里就设置了对话框的默认目录d盘

dlg.m_ofn.lpstrFilter="Document/0*.doc/0All Files(*.*)/0*.*/0/0";

if(dlg.DoModal()==IDOK)

%%1=dlg.GetPathName();

29.文件分割

CFile m_File;

CString m_Filename,m_FileTitle,m_FilePath;

m_FileName=%%1;

char pBuf[4096];

if(m_File.Open(m_FileName,CFile::modeRead | CFile::shareDenyWrite))

{

m_FileName=m_File.GetPathName();

m_FileTitle=m_File.GetFileTitle();

DWORD FileLength=m_File.GetLength();

DWORD PartLength=FileLength/2+FileLength%2;

int nCount=1;

CString strName;

CFile wrFile;

DWORD ReadBytes;

while(true)

{

ReadBytes=m_File.Read(pBuf,PartLength);

strName.Format("%s%d",m_FIleTitle,nCount);

wrFile.Open(strName,CFile::modeWrite | CFile::modeCreate);

wrFile.Write(pBuf,ReadBytes);

wrFile.Close();

if(ReadBytes

break;

nCount++;

}

m_File.Close();

}

else

AfxMessageBox("不能打开文件");

30.文件合并

//#include

using std::string;

string s(%%1);

char sep='/';

#ifdef _WIN32

sep='//';

#endif

size_t sz=s.rfind(sep,s.length());

if(sz!=string::npos)

{

CFile Out;

CString strFilename(s.substr(i+1,s.length()-i));

if(Out.Open(%%2+"//"+strfilename,cfile::modewrite%7ccfile::modecreate)){

for(int i=1;i<=2;i++)

{

CString Filename;

Filename.Format("%s//%s%d",%%2,strfilename,atoi(i));

CFile In;

if(In.Open(Filename,CFile::modeRead)){

char cbBuffer[4096];

int nFilesize=In.GetLength();

while(nFilesize>0){

int nSize=sizeof(cbBuffer);

if(nSize>nFilesize)

nSize=nFilesize;

try{

In.Read(cbBuffer,nSize);

}

catch(CFileException *e){

char *lpMsgBuf;

if(FormatMessage(

FORMAT_MESSAGE_ALLOCATE_BUFFER |

FORMAT_MESSAGE_FROM_SYSTEM,

NULL,e->m_lOsError,

MAKELANGID(LANG_NEUTRAL,

SUBLANG_DEFAULT),

(LPSTR)&lpMsgBuf,0,NULL)>0){

AfxMessageBox(lpMsgBuf);

LocalFree(lpMsgBuf);

}

e->Delete();

return;

}

try{

Out.Write(cbBuffer,nSize);

}

catch(CFileException *e){

char *lpMsgBuf;

if(FormatMessage(

FORMAT_MESSAGE_ALLOCATE_BUFFER |

FORMAT_MESSAGE_FROM_SYSTEM,

NULL,e->m_lOsError,

MAKELANGID(LANG_NEUTRAL,

SUBLANG_DEFAULT),

(LPSTR)&lpMsgBuf,0,NULL)>0){

AfxMessageBox(lpMsgBuf);

LocalFree(lpMsgBuf);

}

e->Delete();

return;

}

nFilesize=nSize;

}

else

AfxMessageBox("不能打开"+Filename);

}

else

AfxMessageBox("不能创建输出文件");

31.文件简单加密

//#include

using std::string;

string s(%%1);

char sep='/';

#ifdef _WIN32

sep='//';

#endif

size_t sz=s.rfind(sep,s.length());

CString outfile;

if(sz!=string::npos)

{

CFile Out,In;

int nFIlesize;

char *lpMsgBuf;

CString strFilename(s.substr(i+1,s.length()-i));

if(!in.Open(%%1,CFile::modeRead)){

//不能打开输入文件

return;

}

outfile.Format("//enc_",%%2,strfilename);

if(!Out.Open(outfile,CFile::modewrite|CFile::modeCreate)){

//不能打开输出文件

return;

}

nFilesize=In.GetLength();

lpBuffer=new char[nFilesize];

if(lpBuffer==NULL){

//不能分配复制缓存

return;

}

CFileStatus rStatus;

In.GetStatus(%%1,rStatus);

try{

In.Read(cbBuffer,nFilesize);

}

catch(CFileException *e){

char *lpMsgBuf;

if(FormatMessage(

FORMAT_MESSAGE_ALLOCATE_BUFFER |

FORMAT_MESSAGE_FROM_SYSTEM,

NULL,e->m_lOsError,

MAKELANGID(LANG_NEUTRAL,

SUBLANG_DEFAULT),

(LPSTR)&lpMsgBuf,0,NULL)>0){

AfxMessageBox(lpMsgBuf);

LocalFree(lpMsgBuf);

}

e->Delete();

return;

}

for(int i=0;i

{

int ibt=lpBuffer[i];

ibt+=100;

ibt%=256;

bpBuffer[i]=(char)ibt;

}

try{

Out.Write(cbBuffer,nFilesize);

}

catch(CFileException *e){

char *lpMsgBuf;

if(FormatMessage(

FORMAT_MESSAGE_ALLOCATE_BUFFER |

FORMAT_MESSAGE_FROM_SYSTEM,

NULL,e->m_lOsError,

MAKELANGID(LANG_NEUTRAL,

SUBLANG_DEFAULT),

(LPSTR)&lpMsgBuf,0,NULL)>0){

AfxMessageBox(lpMsgBuf);

LocalFree(lpMsgBuf);

}

e->Delete();

return;

}

Out.Close();

//In.Close();

CFile::SetStatus(outfile,rstatus);

delete[] lpBuffer;

}

32.文件简单解密

//#include

using std::string;

string s(%%1);

char sep='/';

#ifdef _WIN32

sep='//';

#endif

size_t sz=s.rfind(sep,s.length());

CString infile;

if(sz!=string::npos)

{

CFile Out,In;

int nFIlesize;

char *lpMsgBuf;

CString strFilename(s.substr(i+1,s.length()-i));

infile.Format("%s//enc_%s",%%2,strfilename)

if(!in.Open(infile,CFile::moderead)){

//不能打开输入文件

return;

}

if(!Out.Open(%%1,CFile::modeWrite|CFile::modeCreate)){

//不能打开输出文件

return;

}

nFilesize=In.GetLength();

lpBuffer=new char[nFilesize];

if(lpBuffer==NULL){

//不能分配复制缓存

return;

}

CFileStatus rStatus;

In.GetStatus(infile,rstatus);

try{

In.Read(cbBuffer,nFilesize);

}

catch(CFileException *e){

char *lpMsgBuf;

if(FormatMessage(

FORMAT_MESSAGE_ALLOCATE_BUFFER | FORMAT_MESSAGE_FROM_SYSTEM,

NULL,e->m_lOsError,

MAKELANGID(LANG_NEUTRAL,

SUBLANG_DEFAULT),

(LPSTR)&lpMsgBuf,0,NULL)>0){

AfxMessageBox(lpMsgBuf);

LocalFree(lpMsgBuf);

}

e->Delete();

return;

}

for(int i=0;i

{

int ibt=lpBuffer[i];

ibt-=100;ibt+=256;

ibt%=256;

bpBuffer[i]=(char)ibt;

}

try{

Out.Write(cbBuffer,nFilesize);

}

catch(CFileException *e){

char *lpMsgBuf;

if(FormatMessage(

FORMAT_MESSAGE_ALLOCATE_BUFFER | FORMAT_MESSAGE_FROM_SYSTEM,

NULL,e->m_lOsError,

MAKELANGID(LANG_NEUTRAL,

SUBLANG_DEFAULT),

(LPSTR)&lpMsgBuf,0,NULL)>0){

AfxMessageBox(lpMsgBuf);

LocalFree(lpMsgBuf);

}

e->Delete();

return;

}

Out.Close();

//In.Close();

CFile::SetStatus(%%1,rStatus);

delete[] lpBuffer;

}

33.读取ini文件属性

CStdioFile inifile(%%1,CFile::modeRead);

CString path = inifile.GetFilePath();

inifile.Close();

char key[1024];

DWORD bytes = GetPrivateProfileString(%%2,%%3,%%4,key,1024,path);

if(bytes < 1024)

key[bytes] = '/0';

CString %%5(key);

34.合并一个目录下所有的文件

CString Directory;

Directory.Format("%s//*.*",%%1);

CFileFind FFile;

CFile Out;

if(Out.Open(%%2,CFile::modeWrite|CFile::modeCreate)){

BOOL bFound=FFile.FindFile(Directory);

while(bFound)

{

bFound=FFile.FileNextFile();

if(!FFile.IsDirectory() && !FFile.IsDots())

{

CString Filename=FFile.GetFileName();

CFile In;

if(In.Open(Filename,CFile::modeRead)){

char cbBuffer[4096];

int nFIlesize=In.GetLength();

while(nFIlesize>0){

{

int nSize=sizeof(cbBuffer);

if(nSize>nFilesize)

nSize=nFilesize;

try {

In.Read(cbBuffer,nSize);

}

catch(CFileException *e){

char *lpMsgBuf;

if(FormatMessage(

FORMAT_MESSAGE_ALLOCATE_BUFFER |

FORMAT_MESSAGE_FROM_SYSTEM,

NULL,e->m_lOsError,

MAKELANGID(LANG_NEUTRAL,

SUBLANG_DEFAULT),

(LPSTR)&lpMsgBuf,0,NULL)>0){

AfxMessageBox(lpMsgBuf);

LocalFree(lpMsgBuf);

}

e->Delete();

return;

}

try {

Out.Write(cbBuffer,nSize);

}

catch(CFileException *e){

char *lpMsgBuf;

if(FormatMessage(

FORMAT_MESSAGE_ALLOCATE_BUFFER | FORMAT_MESSAGE_FROM_SYSTEM,

NULL,e->m_lOsError,

MAKELANGID(LANG_NEUTRAL,

SUBLANG_DEFAULT),

(LPSTR)&lpMsgBuf,0,NULL)>0){

AfxMessageBox(lpMsgBuf);

LocalFree(lpMsgBuf);

}

e->Delete();

return;

}

nFilesize=nSize;

}

else

AfxMessageBox("不能打开"+Filename);

}

else

AfxMessageBox("不能创建输出文件");

35.写入ini文件属性

CStdioFile inifile(%%1,CFile::modeRead);

CString path = inifile.GetFilePath();

inifile.Close();

int bytes = GetPrivateProfileInt(%%2,%%3,%%4,path);

WritePrivateProfileString(%%2,%%3,%%4,path);

36.获得当前路径

TCHAR szDir[MAX_PATH];

GetCurrentDirectory(MAX_PATH,szDir);

CString %%1;

%%1.Format("%s",szDir);

37.读取XML数据库

#include

using namespace std;

char sRead[5192];

const char* name="Name";

const char* name2="author";

const char* root="ProductData";

const char* subNodeTag="Product";

const char* ID="pid";

//%%2="ProductData" //%%4="pid" //%%6="author"

//%%3="Product" //%%5="Name"

char sRead[5192];

CFile mFile(_T(%%1),CFile::modeRead);

mFile.Read(sRead,5192);

if(sRead!=NULL)

{

string tmp;

while(sRead!=NULL)

{

tmp.append(sRead);

mFile.Read(sRead,5192);

}

string target("001"),globalTag;globalTag.append("<");globalTag.appendoot);globalTag.append(">");

string propTag1;propTag1.append("<");propTag1.append(name);propTag1.append(">");

string endTag1;endTag1.append("");

string propTag2;propTag2.append("<");propTag2.append(name2);propTag2.append(">");

string endTag2;endTag2.append("");

int offset=tmp.find_first_of(globalTag);

while(offset)

{

offset=tmp.find_first_of(globalTag);

string description;

tmp.copy(description.begin(),tmp.find_first_of("/"",offset+1)-offset);

if(target.compare(description)==0)

{

string prop,prop2;

offset=tmp.find_first_of(propTag1,offset)+strlen(name)+2;

tmp.copy(prop.begin(),tmp.find_first_of(endTag1,offset)- offset,offset);

offset=tmp.find_first_of(propTag2,offset)+strlen(name2)+2;

tmp.copy(prop2.begin(),tmp.find_first_of(endTag2,offset)-offset,offset);

//CString %%8(prop),%%9(prop2);

//%%10

return 0;

}

else

return -1;

38.写入XML数据库

#include

using namespace std;

char sRead[5192];

int no;

const char* name="Name";

const char* name2="author";

const char* root="ProductData";

const char* subNodeTag="Product";

const char* ID="pid";

//%%2="ProductData" //%%4="pid" //%%6="port"

//%%3="Product" //%%5="Name" //%%7="author"

CString temp;

char sRead[5192];

string description;

CFile mFile(_T(%%1),CFile::modeRead);

mFile.Read(sRead,5192);

if(sRead!=NULL)

{

string tmp;

while(sRead!=NULL)

{

tmp.append(sRead);

memset(sRead,0,5192);

mFile.Read(sRead,5192);

}

temp.Format("<%s %s",subNodeTag,ID);

int offset=tmp.find_last_of(temp)+strlen(subNodeTag) +strlen(ID)+4;

temp.Format("/"><%s",name);

tmp.copy(description.begin(),tmp.find_last_of(temp)- offset,offset);

no=atoi(description.c_str())+1;

mFile.Close();

temp.Format("",root);

CString temp2;

temp2.Format("<%s %s=/"%d/"><%s>%s<%s>%s

tmp.insert(tmp.find_last_of(temp),temp2);

CFile file(_T("Produces.xml"),CFile::modeWrite);

file.Write(tmp.c_str(),tmp.size());

file.Flush();

file.Close();

}

else

{

CFile file(_T(%%1),CFile::modeWrite|CFile::modeCreate);

temp.Format("<%s><%s %s=/"0/"><%s>%s<%s>%s",root,subNodeTag,ID,name,"bbbbbbbbbbbbbbbb",name,name2,"cccccccccccccc",name2,subNodeTag,root);

file.Write(temp.GetBuffer(0),temp.GetLength());

file.Flush();

file.Close();

}

39.ZIP压缩文件

//www.zlib.net

#ifdef _DEBUG

#pragma comment(lib,"zlibd.lib")

#else

#pragma comment(lib,"zlib.lib")

#endif

#include "zlib.h"

#include "zconf.h"

HANDLE hFile, hFileToWrite;

CString strFilePath;

m_ctrEdit.GetWindowText(strFilePath);

//打开要进行压缩的文件

hFile = CreateFile(strFilePath, // file name

GENERIC_READ, // open for reading

FILE_SHARE_READ, // share for reading

NULL, // no security

OPEN_EXISTING, // existing file only

FILE_ATTRIBUTE_NORMAL, // normal file

NULL

); // no attr. template

if (hFile == INVALID_HANDLE_VALUE)

{

AfxMessageBox("Could not open file to read"); // process error

return;

}

HANDLE hMapFile, hMapFileToWrite;

//创建一个文件映射

hMapFile = CreateFileMapping(hFile, // Current file handle.

NULL, // Default security.

PAGE_READONLY, // Read/write permission.

0, // Max. object size.

0, // Size of hFile.

"ZipTestMappingObjectForRead"

); // Name of mapping object.

if (hMapFile == NULL)

{

AfxMessageBox("Could not create file mapping object");

return;

}

LPVOID lpMapAddress, lpMapAddressToWrite;

//创建一个文件映射的视图用来作为source

lpMapAddress = MapViewOfFile(hMapFile, // Handle to mapping object.

FILE_MAP_READ, // Read/write permission

0, // Max. object size.

0, // Size of hFile.

0); // Map entire file.

if (lpMapAddress == NULL)

{

AfxMessageBox("Could not map view of file");

return;

}

DWORD dwFileLength,dwFileLengthToWrite;

dwFileLength = GetFileSize(hFile, NULL);

m_dwSourceFileLength = dwFileLength;

//因为压缩函数的输出缓冲必须比输入大0.1% + 12 然后一个DWORD用来保存压缩前的大小，

// 解压缩的时候用，当然还可以保存更多的信息，这里用不到

dwFileLengthToWrite = (double)dwFileLength*1.001 + 12 +sizeof(DWORD);

//以下是创建一个文件，用来保存压缩后的文件

hFileToWrite = CreateFile("demoFile.rar", // demoFile.rar

GENERIC_WRITE|GENERIC_READ, // open for writing

0, // do not share

NULL, // no security

CREATE_ALWAYS, // overwrite existing

FILE_ATTRIBUTE_NORMAL , // normal file

NULL); // no attr. template

if (hFileToWrite == INVALID_HANDLE_VALUE)

{

AfxMessageBox("Could not open file to write"); // process error

return;

}

hMapFileToWrite = CreateFileMapping(hFileToWrite, // Current file handle.

NULL, // Default security.

PAGE_READWRITE, // Read/write permission.

0, // Max. object size.

dwFileLengthToWrite, // Size of hFile.

"ZipTestMappingObjectForWrite"); // Name of mapping object.

if (hMapFileToWrite == NULL)

{

AfxMessageBox("Could not create file mapping object for write");

return;

}

lpMapAddressToWrite = MapViewOfFile(hMapFileToWrite, //Handle to mapping object.FILE_MAP_WRITE, // Read/write permission 0, // Max. object size.

0, // Size of hFile.

); // Map entire file.

if (lpMapAddressToWrite == NULL)

{

AfxMessageBox("Could not map view of file");

return;

}

//这里是将压缩前的大小保存在文件的第一个DWORD里面

LPVOID pBuf = lpMapAddressToWrite;

(*(DWORD*)pBuf) = dwFileLength;

pBuf = (DWORD*)pBuf + 1;

//这里就是最重要的，zlib里面提供的一个方法，将源缓存的数据压缩至目的缓存

//原形如下：

//int compress (Bytef *dest, uLongf *destLen, const Bytef*source, uLong sourceLen);

//参数destLen返回实际压缩后的文件大小。

compress((Bytef*)pBuf,&dwFileLengthToWrite, (Bytef*)lpMapAddress, dwFileLength);

UnmapViewOfFile(lpMapAddress);

CloseHandle(hMapFile);

CloseHandle(hFile);

UnmapViewOfFile(lpMapAddressToWrite);

CloseHandle(hMapFileToWrite);

//这里将文件大小重新设置一下

SetFilePointer(hFileToWrite,dwFileLengthToWrite + sizeof(DWORD) ,NULL,FILE_BEGIN);

SetEndOfFile(hFileToWrite);

CloseHandle(hFileToWrite);

40.ZIP解压缩

//www.zlib.net

#ifdef _DEBUG

#pragma comment(lib,"zlibd.lib")

#else

#pragma comment(lib,"zlib.lib")

#endif

#include "zlib.h"

#include "zconf.h"

HANDLE hFile, hFileToWrite;

CString strFilePath=%%1;

//打开要进行解压缩的文件

hFile = CreateFile(strFilePath, // file name

GENERIC_READ, // open for reading

FILE_SHARE_READ, // share for reading

NULL, // no security

OPEN_EXISTING, // existing file only

FILE_ATTRIBUTE_NORMAL, // normal file

NULL

); // no attr. template

if (hFile == INVALID_HANDLE_VALUE)

{

AfxMessageBox("Could not open file to read"); // process error

return;

}

HANDLE hMapFile, hMapFileToWrite;

//创建一个文件映射

hMapFile = CreateFileMapping(hFile, // Current file handle.

NULL, // Default security.

PAGE_READONLY, // Read/write permission.

0, // Max. object size.

0, // Size of hFile.

"ZipTestMappingObjectForRead"); // Name of mapping object.

if (hMapFile == NULL)

{

AfxMessageBox("Could not create file mapping object");

return;

}

LPVOID lpMapAddress, lpMapAddressToWrite;

//创建一个文件映射的视图用来作为source

lpMapAddress = MapViewOfFile(hMapFile, // Handle to mapping

object.FILE_MAP_READ, // Read/write permission

0, // Max. object size.

0, // Size of hFile.

0); // Map entire file.

if (lpMapAddress == NULL)

{

AfxMessageBox("Could not map view of file");

return;

}

DWORD dwFileLength,dwFileLengthToWrite;

dwFileLength = GetFileSize(hFile, NULL) - sizeof(DWORD);

//因为压缩函数的输出缓冲必须比输入大0.1% + 12 然后一个DWORD用来保存压缩前的大小，

// 解压缩的时候用，当然还可以保存更多的信息，这里用不到

// dwFileLengthToWrite = (double)dwFileLength*1.001 + 12 +sizeof(DWORD);

dwFileLengthToWrite = (*(DWORD*)lpMapAddress);

LPVOID pSourceBuf = lpMapAddress;

pSourceBuf = (DWORD*)pSourceBuf + 1;

//以下是创建一个文件，用来保存压缩后的文件

hFileToWrite = CreateFile(%%2, // create demo.gz

GENERIC_WRITE|GENERIC_READ, // open for writing

0, // do not share

NULL, // no security

CREATE_ALWAYS, // overwrite existing

FILE_ATTRIBUTE_NORMAL , // normal file

NULL

); // no attr. template

if (hFileToWrite == INVALID_HANDLE_VALUE)

{

AfxMessageBox("Could not open file to write"); //process error

return;

}

hMapFileToWrite = CreateFileMapping(hFileToWrite, // Currentfile handle.

NULL, // Default security.

PAGE_READWRITE, // Read/write permission.

0, // Max. object size.

dwFileLengthToWrite, // Size of hFile.

"ZipTestMappingObjectForWrite"); // Name of mapping object.

if (hMapFileToWrite == NULL)

{

AfxMessageBox("Could not create file mapping object for write");

return;

}

lpMapAddressToWrite = MapViewOfFile(hMapFileToWrite, //Handle to mapping object.

FILE_MAP_WRITE, // Read/write permission

0, // Max. object size.

0, // Size of hFile.

); // Map entire file.

if (lpMapAddressToWrite == NULL)

{

AfxMessageBox("Could not map view of file");

return;

}

//这里是将压缩前的大小保存在文件的第一个DWORD里面

LPVOID pBuf = lpMapAddressToWrite;

//这里就是最重要的，zlib里面提供的一个方法，将源缓存的数据压缩至目的缓存

//原形如下：

//int compress (Bytef *dest, uLongf *destLen, const Bytef *source, uLong sourceLen);

//参数destLen返回实际压缩后的文件大小。

uncompress((Bytef*)pBuf,&dwFileLengthToWrite, (Bytef*)pSourceBuf, dwFileLength);

UnmapViewOfFile(lpMapAddress);

CloseHandle(hMapFile);

CloseHandle(hFile);

UnmapViewOfFile(lpMapAddressToWrite);

CloseHandle(hMapFileToWrite);

//这里将文件大小重新设置一下

SetFilePointer(hFileToWrite,dwFileLengthToWrite,NULL,FILE_BEGIN);

SetEndOfFile(hFileToWrite);

CloseHandle(hFileToWrite);

41.获得应用程序完整路径

char appName[MAX_PATH];

GetModuleFileName(NULL,appName,MAX_PATH);

CString %%1(appName);

42.递归删除目录中的文件

CString Directory(%%1);

CStringArray csa;

int count=0;

if(Directory.Right(1)!="//")

Directory+="//";

Directory+="*.*";

CFileFInd FFile;

csa.add(Directory);

while(count

{

if(FFile.FindFile(csa.GetAt(i)))

{

bFound=FFile.FindNextFile();

if(!FFile.IsDirectory() && !FFile.IsDots())

{

DeleteFile(FFile.GetFilePath());

}

else if(FFile.IsDirectory())

{

csa.Add(FilePath+"//*.*");

}

else

count++;

}

43.ZIP压缩文件夹

//www.zlib.net

#include

#if defined(MSDOS) || defined(OS2) || defined(WIN32) ||

defined(__CYGWIN__)

# include

# define SET_BINARY_MODE(file) setmode(fileno(file),O_BINARY)

#else

# define SET_BINARY_MODE(file)

#endif

#define CHUNK 16384

//#define USE_TAG

#ifdef USE_TAG

#define COMPRESS_FILE_TAG_HEAD "<<<"

#define COMPRESS_FILE_TAG_TAIL ">>>"

#define COMPRESS_FILE_TAG_END_LEN 3 // must be strlen

(COMPRESS_FILE_TAG_HEAD) = strlen(COMPRESS_FILE_TAG_TAIL)

#else

#define COMPRESS_FILE_TAG_HEAD ""

#define COMPRESS_FILE_TAG_TAIL ""

#define COMPRESS_FILE_TAG_END_LEN 0 // must be strlen

(COMPRESS_FILE_TAG_HEAD) = strlen(COMPRESS_FILE_TAG_TAIL)

#endif

/**//**//**//* Compress from file source to file dest until EOF on source.

def() returns Z_OK on success, Z_MEM_ERROR if emory could not be allocated for processing, Z_STREAM_ERROR if an invalid compression

level is supplied, Z_VERSION_ERROR if the version of zlib. And the version of the library linked do not matc, or Z_ERRNO if there isan error reading or writing the files. */

static it def(FILE *source, FILE *dest, int level)

int ret, flush;

unsigned have;

z_stream strm;

unsigned char in[CHUNK];

unsigned char out[CHUNK];

/**//**//**//* allocate deflate state */

strm.zalloc = Z_NULL;

strm.zfree = Z_NULL;

strm.opaque = Z_NULL;

ret = deflateInit(&strm, level);

if (ret != Z_OK)

return ret;

/**//**//**//* compress until end of file */

do {

strm.avail_in = fread(in, 1, CHUNK, source);

if (ferror(source)) {

(void)deflateEnd(&strm);

return Z_ERRNO;

}

flush = feof(source) ? Z_FINISH : Z_NO_FLUSH;

strm.next_in = in;

/**//**//**//* run deflate() on input until output

buffer not full, finish

compression if all of source has been read in */

do {

strm.avail_out = CHUNK;

strm.next_out = out;

ret = deflate(&strm, flush); /**//**//**//* no

bad return value */

assert(ret != Z_STREAM_ERROR); /**//**//**//*

state not clobbered */

have = CHUNK - strm.avail_out;

if (fwrite(out, 1, have, dest) != have || ferror

(dest)) {

(void)deflateEnd(&strm);

return Z_ERRNO;

}

} while (strm.avail_out == 0);

assert(strm.avail_in == 0); /**//**//**//* all

input will be used */

/**//**//**//* done when last data in file processed

} while (flush != Z_FINISH);

assert(ret == Z_STREAM_END); /**//**//**//* stream

will be complete */

/**//**//**//* clean up and return */

(void)deflateEnd(&strm);

return Z_OK;

}

/**//**//**//* Decompress from file source to file dest until stream ends or EOF. inf() returns Z_OK on success, Z_MEM_ERROR if memory could not be allocated for processing, Z_DATA_ERROR if the deflate data is invalid or incomplete, Z_VERSION_ERROR if the version of zlib.h and the version of the library linked do not match, or Z_ERRNO

if there is an error reading or writing the files. */

static int inf(FILE *source, FILE *dest)

{

int ret;

unsigned have;

z_stream strm;

unsigned char in[CHUNK];

unsigned char out[CHUNK];

/**//**//**//* allocate inflate state */

strm.zalloc = Z_NULL;

strm.zfree = Z_NULL;

strm.opaque = Z_NULL;

strm.avail_in = 0;

strm.next_in = Z_NULL;

ret = inflateInit(&strm);

if (ret != Z_OK)

return ret;

/**//**//**//* decompress until deflate stream ends or end

of file */

do {

strm.avail_in = fread(in, 1, CHUNK, source);

if (ferror(source)) {

(void)inflateEnd(&strm);

return Z_ERRNO;

}

if (strm.avail_in == 0)

break;

strm.next_in = in;

/**//**//**//* run inflate() on input until output

buffer not full */

do {

strm.avail_out = CHUNK;

strm.next_out = out;

ret = inflate(&strm, Z_NO_FLUSH);

assert(ret != Z_STREAM_ERROR); /**//**//**//*

state not clobbered */

switch (ret) {

case Z_NEED_DICT:

ret = Z_DATA_ERROR; /**//**//**//* and

fall through */

case Z_DATA_ERROR:

case Z_MEM_ERROR:

(void)inflateEnd(&strm);

return ret;

}

have = CHUNK - strm.avail_out;

if (fwrite(out, 1, have, dest) != have || ferror

(dest)) {

(void)inflateEnd(&strm);

return Z_ERRNO;

}

} while (strm.avail_out == 0);

/**//**//**//* done when inflate() says it's done */

} while (ret != Z_STREAM_END);

/**//**//**//* clean up and return */

(void)inflateEnd(&strm);

return ret == Z_STREAM_END ? Z_OK : Z_DATA_ERROR;

}

/**//**//**//* report a zlib or i/o error */

static void zerr(int ret)

{

fputs("zpipe: ", stderr);

switch (ret) {

case Z_ERRNO:

if (ferror(stdin))

fputs("error reading stdin ", stderr);

if (ferror(stdout))

fputs("error writing stdout ", stderr);

break;

case Z_STREAM_ERROR:

fputs("invalid compression level ", stderr);

break;

case Z_DATA_ERROR:

fputs("invalid or incomplete deflate data ", stderr);

break;

case Z_MEM_ERROR:

fputs("out of memory ", stderr);

break;

case Z_VERSION_ERROR:

fputs("zlib version mismatch! ", stderr);

}

// 以上就是zpipe.c的几个主要函数：def()、inf()和zerr()，def()是压缩函数，主要使用了zlib的deflate()接口；inf()是压缩函数，主要使用了zlib的inflate()接口；zerr()是错误打印函数。

static int write_zfile_file_header(const char *file,FILE *zfile)

{

int len;

len = strlen(file);

if (fwrite(COMPRESS_FILE_TAG_HEAD, 1,COMPRESS_FILE_TAG_END_LEN, zfile) != COMPRESS_FILE_TAG_END_LEN || ferror(zfile))

{

fprintf(stderr,"When writing file or dir header to zfile: write error. ");

return 1;

}

if (fwrite(file, 1, len, zfile) != len|| ferror(zfile))

{

fprintf(stderr,"When writing file or dir header to zfile: write error. ");

return 1;

}

if (fwrite(COMPRESS_FILE_TAG_TAIL, 1,COMPRESS_FILE_TAG_END_LEN, zfile) != COMPRESS_FILE_TAG_END_LEN || ferror(zfile))

{

fprintf(stderr,"When writing file or dir header to

zfile: write error. ");

return 1;

}

return 0;

}

/**//* compress or decompress from stdin to stdout */

static int compress_dir(char *file_in,FILE *fd_out)

{

FILE *fd_in;

struct _finddata_t find_data;

char file[128];

long lf;

int ret;

write_zfile_file_header(file_in,fd_out);

sprintf(file,"%s%s",file_in,"/*");

if((lf = _findfirst(file,&find_data))==-1l) // LOOKOUT:not eleven, but one and lowercase 'L'

{

fprintf(stdout,"file not found. ");

}

else

{

if(!strcmp(find_data.name,".") || !strcmp(find_data.name,".."))

continue;

fprintf(stdout,"%s",find_data.name);

sprintf(file,"%s%s%s",file_in,"/",find_data.name);

if(find_data.attrib & _A_SUBDIR)

{

fprintf(stdout," ---directory--- ");

ret = compress_dir(file,fd_out);

}

else

{

write_zfile_file_header(file,fd_out);

if(access(file, 2) != 0) //W_OK=2

{

int attrib;

attrib = _chmod(file,0);

_chmod(file,1,attrib & ~_A_RDONLY);

fprintf(stderr,"When writing file: No privilege to write file %s. ",file);

return -1;

}

fd_in = fopen(file,"rb+");

SET_BINARY_MODE(fd_in);

ret = def(fd_in, fd_out,Z_DEFAULT_COMPRESSION);

if (ret != Z_OK)

zerr(ret);

else

fprintf(stdout," zip over ");

fclose(fd_in);

}

}while( _findnext(lf, &find_data ) == 0 );

}

return 0;

}

//int argc, char **argv

struct _finddata_t find_data;

FILE *fd_in;

FILE *fd_out;

const char *file_dir;

char file_out[100];

int ret;

if (argc == 2)

{

file_dir = argv[1];

if(_findfirst(file_dir,&find_data)==-1l) //LOOKOUT: not eleven, but one and lowercase 'L'

{

fprintf(stderr,"File or dir %s not found.",file_dir);

return 1;

}

if(find_data.attrib & _A_SUBDIR)

{

sprintf(file_out,"%s%s",file_dir,".z");

fd_out = fopen(file_out,"wb+");

SET_BINARY_MODE(fd_out);

fprintf(stdout,"Dir %s being Compressed ...",file_dir);

ret = compress_dir(file_dir,fd_out);

fclose(fd_out);

}

else

{

fprintf(stdout,"File %s being Compressed ...",file_dir);

sprintf(file_out,"%s%s",file_dir,".z");

fd_in = fopen(file_dir,"rb+");

fd_out = fopen(file_out,"wb+");

SET_BINARY_MODE(fd_in);

SET_BINARY_MODE(fd_out);

ret = def(fd_in, fd_out, Z_DEFAULT_COMPRESSION);

fclose(fd_in);

fclose(fd_out);

}

if (ret != 0)

{

fprintf(stderr,"Compress Error !!!!!!!!!!!!!! ");

zerr(ret);

}

else

fprintf(stdout,"Compress OK--------------- ");

}

else {

fprintf(stdout,"zod usage: zod [file]/[directory] ");

}

getch();

44.验证DTD

#include // runtime_error

#include

using namespace std;

using namespace xercesc;

try {

// Initialize Xerces and obtain a SAX2 parser

XercesInitializer init;

auto_ptr

parser(XMLReaderFactory::createXMLReader());

// Enable validation

parser->setFeature(XMLUni::fgSAX2CoreValidation, true);

// Register error handler to receive notifications

// of DTD violations

CircusErrorHandler error;

parser->setErrorHandler(&error);

parser->parse("animals.xml");

} catch (const SAXException& e) {

cout << "xml error: " << toNative(e.getMessage()) << "/n";

return EXIT_FAILURE;

} catch (const XMLException& e) {

cout << "xml error: " << toNative(e.getMessage()) << "/n";

return EXIT_FAILURE;

} catch (const exception& e) {

cout << e.what() << "/n";

return EXIT_FAILURE;

}

45.Schema 验证

#include

Handy definitions of constants.

#include

Create a SAX2 parser object.

SAX2XMLReader* parser = XMLReaderFactory::createXMLReader();

// Set the appropriate features on the parser. Enable namespaces, schema validation, and the checking of all Schema constraints. We refer to these as "common features" in following examples.

parser->setFeature(XMLUni::fgSAX2CoreNameSpaces, true);

parser->setFeature(XMLUni::fgSAX2CoreValidation, true);

parser->setFeature(XMLUni::fgXercesDynamic, false);

parser->setFeature(XMLUni::fgXercesSchema, true);

parser->setFeature(XMLUni::fgXercesSchemaFullChecking, true);

// Set appropriate ContentHandler, ErrorHandler, and EntityResolver.

// These will be referred to as "common handlers" in subsequent examples.

// You will use a default handler provided by Xerces-C++ (no op action).

// Users should write their own handlers and install them.

DefaultHandler handler;

parser->setContentHandler(&handler);

// The object parser calls when it detects violations of the schema.

parser->setErrorHandler(&handler);

// The object parser calls to find the schema and

// resolve schema imports/includes.

parser->setEntityResolver(&handler);

// Parse the XML document.

// Document content sent to registered ContentHandler instance.

parser->parse(xmlFile);

// Delete the parser instance.

delete parser;

46.Grep

#include

#include "regexpr2.h"

using namespace std;

using namespace regex;

match_results results;

rpattern pat(%%2);

char sRead[5120];

CFile mFile(_T(%%1),CFile::modeRead);

CString content;

while(sRead!=NULL)

{

mFile.Read(sRead,5120);

content+=CString(sRead);

}

mFile.Close();

CString line;

CString sub;

char seperator='/n';

for(int pos=0;AfxExtractSubString(line,content,pos,seperator);++pos)

{

if(line.Trim()!="")

{

string str(line);

match_results::backref_type br=pat.match(str,results);

if(br.matched){

//br

}

//+---------------------------------------------------------------------------

// Copyright ( C ) Microsoft, 1994 - 2002.

// File: restack.h

// Functions: a quick-'n'-dirty, type-unsafe stack used by the iterative

// regular expression algorithm

// Notes: Care must be taken when using this stack. You must pop off

// the correct type of object, otherwise you get garbage. Also,

// if you push anything that has a non-trivial destructor, then

// be sure to explicitely pop everything off the stack and don't

// use the unsafe_long_jump method.

// Author: Eric Niebler ( [email protected] )

// History: 11/15/2001 ericne Created

//----------------------------------------------------------------------------

#ifndef HETERO_STACK_H

#define HETERO_STACK_H

#include

#ifndef REGEX_CDECL

#ifdef _MSC_VER

#define REGEX_CDECL __cdecl

#else

#define REGEX_CDECL

#endif

#define COMMA ,

#if !defined(_MSC_VER) | 1200 < _MSC_VER

# define REGEX_VC6(x)

# define REGEX_NVC6(x) x

#else

# define REGEX_VC6(x) x

# define REGEX_NVC6(x)

#endif

namespace regex

{

namespace detail

{

// For compile-time assertions that generate

// no run-time overhead.

template< bool f > struct static_assert;

template<> struct static_assert { static_assert() {} };

// Work-around for a template-template parameter problem on VC7.0

template< typename T > struct type2type { typedef T type; };

template< bool F > struct bool2type { enum { value = F }; };

typedef bool2type true_t;

typedef bool2type false_t;

#ifdef _MSC_VER

// warning C4127: conditional expression is constant

// warning C4189: local variable is initialized but not referenced

// warning C4244: conversion from 'T' to 'int', possible loss of data

// warning C4510: default constructor could not be generated

// warning C4610: struct can never be instantiated - user defined constructor required

// warning C4800: forcing value to bool 'true' or 'false' (performance warning)

#pragma warning( push )

#pragma warning( disable : 4127 4189 4244 4510 4610 4800 )

// Make sure nobody has tampered with the packing before defining the

// alignof structure

#pragma pack( push )

#pragma pack() // use the default packing

#endif

template< typename T >

class alignof

{

struct helper

{

helper();

char m_c;

T m_t;

};

public:

enum { value = sizeof(helper)-sizeof(T) < sizeof(T) ? sizeof(helper)-sizeof(T) : sizeof(T) };

};

#ifdef _MSC_VER

#pragma pack( pop )

#endif

// Type traits

typedef char (&yes_type)[1];

typedef char (&no_type)[2];

template< bool >

struct select_helper

{

template< typename T, typename U >

struct nested

{

typedef T type;

};

template<>

struct select_helper

{

template< typename T, typename U >

struct nested

{

typedef U type;

};

// For use in conditional typedefs

template< bool F, typename T, typename U >

struct select

{

typedef typename select_helper::template nested::type type;

};

template< typename U >

struct convertible_helper

{

static yes_type check( U );

static no_type REGEX_CDECL check(...);

};

template< typename T >

struct factory

{

static T& make();

};

template< typename T, typename U >

struct is_convertible

{

enum { value = (sizeof(convertible_helper::check(factory::make()))==sizeof(yes_type)) };

};

template< size_t N >

struct is_power_of_two

{

enum { value = 1==N || 0==(N%2) && is_power_of_two::value };

};

template<>

struct is_power_of_two<0>

{

enum { value = false };

};

// Very primative implementation of is_scalar. This doesn't work

// for void, reference types, array types or function types, but

// we don't use those types from hetero_stack.

struct bool_convertible { bool_convertible(bool); };

template< typename T >

struct is_scalar

{

enum { value = is_convertible::value };

};

template< typename T >

struct has_trivial_copy

{

enum { value = is_scalar::value };

};

template< typename T >

struct has_trivial_assignment

{

enum { value = is_scalar::value };

};

template< typename T >

struct has_trivial_destructor

{

enum { value = is_scalar::value };

};

template< bool > struct destroyer_helper

{

template< typename T >

static void destroy( T const * pT )

{

pT, pT->~T();

}

};

template<> struct destroyer_helper

{

template< typename T >

static void destroy( T const * )

{

}

};

template< typename T >

void destroy( T const * pT )

{

destroyer_helper::value>::destroy( pT );

}

struct type_vtable

{

std::type_info const * typeinfo_ptr;

size_t size;

size_t aligned_size;

void (*destroy)( void * );

void (*copy)( void *, void const * );

};

template< typename T, size_t AlignmentT >

class type_info_ex

{

static void destroy( void * pv )

{

T const * pT = static_cast( pv );

regex::detail::destroy( pT );

(void)pv;

(void)pT;

}

static void copy( void * dst, void const * src )

{

new ( dst ) T( *static_cast( src ) );

}

public:

static type_vtable const vtable;

static bool equals( type_vtable const * ptm )

{

return ptm == & vtable || *ptm->typeinfo_ptr == typeid(T);

}

};

template< typename T,size_t AlignmentT >

type_vtable const type_info_ex::vtable =

{

&typeid(T),

sizeof(T),

( sizeof(T) + AlignmentT - 1 ) & ~( AlignmentT - 1 ),

has_trivial_destructor::value ? 0 : &type_info_ex::destroy,

&type_info_ex::copy

};

template< typename T >

inline T & to_type( void * pv )

{

return *static_cast( pv );

}

} // namespace detail

// --------------------------------------------------------------------------

// Class: hetero_stack

// Description: Fast, heterogeneous stack.

// Methods: allocate - reserve space on stack

// unwind - unwind the stack

// hetero_stack - c'tor

// ~hetero_stack - d'tor, release all dynamic memory

// push - push an object on the stack

// pop - pop an object from the stack

// Members: m_first_node -

// m_current_node -

// Typedefs: byte_t -

// History: 10/19/2001 - ericne - Created

// --------------------------------------------------------------------------

template

size_t AlignmentT = sizeof(void*),

bool RuntimeTypeCheckT = true, // should we perform run-time type checking?

bool AssumePodT = false, // assume non-throwing copy/assign/destroy for better perf

size_t DynamicBlockSizeT = 4096, // blocks allocated from heap are this size

size_t StaticBlockSizeT = 1024 // initial block on stack is this size

class hetero_stack

{

typedef unsigned char byte_t;

typedef detail::type_vtable const* vtable_ptr;

public:

typedef hetero_stack stack_type;

template< typename T >

struct aligned_sizeof

{

enum

{

// round up sizeof(T) to the nearest multiple of AlignmentT

no_rtti = ( sizeof( T ) + AlignmentT - 1 ) & ~( AlignmentT - 1 ),

with_rtti = RuntimeTypeCheckT ?

no_rtti + aligned_sizeof::no_rtti :

no_rtti

};

private:

struct stack_node

{

struct header

{

stack_node * m_back;

stack_node * m_next;

byte_t * m_current; // ptr into m_mem. alloc from here

byte_t * m_end; // ptr to last+1 byte_t in m_mem

};

union

{

header m_head;

byte_t m_align[ aligned_sizeof

::no_rtti ];

};

// This is the buffer into which values will be pushed and popped.

// It is guaranteed to meet the AlignmentT requirements because of

// the union above.

byte_t m_mem[1];

size_t size() const // throw()

{

return static_cast( m_head.m_end - m_mem );

}

};

enum

{

DYNAMIC_BLOCK_SIZE =

DynamicBlockSizeT > sizeof( stack_node ) ?

DynamicBlockSizeT : sizeof( stack_node )

};

union

{

stack_node m_node;

byte_t m_buf[ aligned_sizeof::no_rtti + StaticBlockSizeT ];

} m_first_node;

stack_node * m_current_node;

// Cache these for faster access

byte_t * m_begin;

byte_t * m_current;

byte_t * m_end;

byte_t * grow( size_t size ) // throw(std::bad_alloc)

{

// write the cached value of current into the node.

// OK to do this even if later statements throw.

m_current_node->m_head.m_current = m_current;

// Do we have a node with available memory already?

if( m_current_node->m_head.m_next )

{

// Does this node have enough room?

if( size <= m_current_node->m_head.m_next->size() )

{

m_current_node = m_current_node->m_head.m_next;

m_current = m_current_node->m_head.m_current = m_current_node->m_mem + size;

m_end = m_current_node->m_head.m_end;

return m_begin = m_current_node->m_mem;

}

// Create a new node and insert it into the list

stack_node * new_node = static_cast(

::operator new( size + offsetof( stack_node, m_mem ) ) );

new_node->m_head.m_back = m_current_node;

new_node->m_head.m_next = m_current_node->m_head.m_next;

m_current = m_end = new_node->m_head.m_current =

new_node->m_head.m_end = new_node->m_mem + size;

m_current_node->m_head.m_next->m_head.m_back = new_node;

m_current_node->m_head.m_next = new_node;

m_current_node = new_node;

return m_begin = m_current_node->m_mem;

}

// We need to create a new node from scratch

size_t new_size = detail::regex_max( size,

static_cast(DYNAMIC_BLOCK_SIZE) - offsetof( stack_node, m_mem ) );

stack_node * new_node = static_cast(

::operator new( new_size + offsetof( stack_node, m_mem ) ) );

new_node->m_head.m_back = m_current_node;

new_node->m_head.m_next = 0;

m_current = new_node->m_head.m_current = new_node->m_mem + size;

m_end = new_node->m_head.m_end = new_node->m_mem + new_size;

m_current_node->m_head.m_next = new_node;

m_current_node = new_node;

return m_begin = m_current_node->m_mem;

}

byte_t * allocate( size_t size ) // throw(std::bad_alloc)

{

// This is the ptr to return

byte_t * mem = m_current;

// Advance the high-water mark

m_current += size;

// Check to see if we have overflowed this buffer

if( std::less()( m_end, m_current ) ) // if( m_end < m_current )

{

// oops, back this out.

m_current = mem;

// allocate a new block and return a ptr to the new memory

return grow( size );

}

return mem;

}

byte_t * unwind( byte_t * pb ) // throw()

{

// roll back the stack

m_current = pb;

// If we've unwound this whole block, then make the

// previous node the current node

if( m_current == m_begin )

{

// write the cached value of m_current into m_current_node

m_current_node->m_head.m_current = m_current;

m_current_node = m_current_node->m_head.m_back;

// update the cache

m_begin = m_current_node->m_mem;

m_current = m_current_node->m_head.m_current;

m_end = m_current_node->m_head.m_end;

}

return pb;

}

byte_t * unwind( size_t size ) // throw()

{

return unwind( m_current - size );

}

void long_jump_impl( void * jump_ptr, detail::bool2type ) // throw()

{

safe_long_jump( jump_ptr );

}

void long_jump_impl( void * jump_ptr, detail::bool2type ) // throw()

{

unsafe_long_jump( jump_ptr );

}

struct real_unwinder;

friend struct real_unwinder;

struct real_unwinder

{

real_unwinder( stack_type * pstack, size_t size ) // throw()

: m_pstack(pstack), m_size(size) {}

~real_unwinder() // throw()

{

if( m_pstack )

m_pstack->unwind( m_size );

}

void dismiss() // throw()

{

m_pstack = 0;

}

private:

real_unwinder( real_unwinder const & );

real_unwinder & operator=( real_unwinder const & );

stack_type * m_pstack;

size_t m_size;

};

struct dummy_unwinder

{

dummy_unwinder( stack_type *, size_t ) {} // throw()

void dismiss() {} // throw()

};

// Disallow these for now. Might implement them later.

hetero_stack( hetero_stack const & );

hetero_stack & operator=( hetero_stack const & );

public:

class type_error : public std::logic_error

{

std::type_info const * m_prequested_type;

std::type_info const * m_pactual_type;

public:

type_error

(

std::type_info const & requested_type,

std::type_info const & actual_type,

std::string const & s = "type error in hetero_stack"

) // throw()

: std::logic_error( s + " (requested type: " + requested_type.name()

+ ", actual type: " + actual_type.name() + ")" )

, m_prequested_type( &requested_type )

, m_pactual_type( &actual_type )

{

}

std::type_info const & requested_type() const // throw()

{

return *m_prequested_type;

}

std::type_info const & actual_type() const // throw()

{

return *m_pactual_type;

}

};

hetero_stack() // throw()

: m_current_node( &m_first_node.m_node )

{

m_first_node.m_node.m_head.m_back = & m_first_node.m_node;

m_first_node.m_node.m_head.m_next = 0;

m_begin = m_current = m_first_node.m_node.m_head.m_current = m_first_node.m_node.m_mem;

m_end = m_first_node.m_node.m_head.m_end = m_first_node.m_buf + sizeof( m_first_node );

}

~hetero_stack() // throw()

{

// AlignmentT must be a power of two

detail::static_assert< detail::is_power_of_two::value > const align_test;

// Call any destructors for objects still on the stack

if( RuntimeTypeCheckT && ! AssumePodT )

{

long_jump( m_first_node.m_node.m_mem );

}

// delete all the memory blocks

m_current_node = m_first_node.m_node.m_head.m_next;

for( stack_node * next_node; m_current_node; m_current_node = next_node )

{

next_node = m_current_node->m_head.m_next;

::operator delete( static_cast( m_current_node ) );

}

template< typename T >

inline void push( T const & t ) // throw(std::bad_alloc,...)

{

// Make sure that the alignment for type T is not worse

// than our declared alignment.

detail::static_assert<( AlignmentT >= detail::alignof::value )> const align_test;

static_cast(align_test);

// If T won't throw in copy c'tor then we don't need to use an unwinder object.

typedef typename detail::select< AssumePodT || detail::has_trivial_copy::value,

dummy_unwinder, real_unwinder >::type unwinder;

// If this throws, it doesn't change state,

// so there is nothing to roll back.

byte_t * pb = allocate( aligned_sizeof::with_rtti );

// Rolls back the allocate if later steps throw

// BUGBUG we can do the alloc, but not update m_current until after

// the copy c'tor to avoid the need for an unwinder object

unwinder guard( this, aligned_sizeof::with_rtti );

new ( pb ) T( t ); // Could throw if ! has_trivial_copy::value

// If we are debugging the stack, then push a pointer to the type_info

// for this type T. It will be checked in pop().

if( RuntimeTypeCheckT )

{

detail::to_type( pb + aligned_sizeof::no_rtti ) = & detail::type_info_ex::vtable;

}

// ok, everything succeeded -- dismiss the guard

guard.dismiss();

}

template< typename T >

inline void pop( T & t ) // throw(...)

{

detail::static_assert<( AlignmentT >= detail::alignof::value )> const align_test;

static_cast(align_test);

// If we are debugging the stack, then in push() we pushed a pointer

// to the type_info struct for this type T. Check it now.

if( RuntimeTypeCheckT )

{

byte_t * pti = m_current - aligned_sizeof::no_rtti;

if( ! detail::type_info_ex::equals( detail::to_type( pti ) ) )

throw type_error( typeid( T ), *detail::to_type( pti )->typeinfo_ptr );

}

// Don't change state yet because assignment op could throw!

byte_t * pT = m_current - aligned_sizeof::with_rtti;

t = detail::to_type( pT ); // could throw

T const & ref = detail::to_type( pT );

regex::detail::destroy( &ref );

unwind( pT );

}

// Call this version of pop when you don't need the popped value

template< typename T >

inline void pop( REGEX_VC6(detail::type2type COMMA int) ) // throw(type_error,...)

{

detail::static_assert<( AlignmentT >= detail::alignof::value )> const align_test;

static_cast(align_test);

// If we are debugging the stack, then in push() we pushed a pointer

// to the type_info struct for this type T. Check it now.

if( RuntimeTypeCheckT )

{

byte_t * pti = m_current - aligned_sizeof::no_rtti;

if( ! detail::type_info_ex::equals( detail::to_type( pti ) ) )

throw type_error( typeid( T ), *detail::to_type( pti )->typeinfo_ptr );

}

byte_t * pv = unwind( aligned_sizeof::with_rtti );

T const & ref = detail::to_type( pv );

regex::detail::destroy( &ref );

}

// Call this version of pop when you don't need the popped value and

// throwing an exception isn't an option

template< typename T >

inline bool pop( std::nothrow_t const & ) // throw()

{

detail::static_assert<( AlignmentT >= detail::alignof::value )> const align_test;

static_cast(align_test);

// If we are debugging the stack, then in push() we pushed a pointer

// to the type_info struct for this type T. Check it now.

if( RuntimeTypeCheckT )

{

byte_t * pti = m_current - aligned_sizeof::no_rtti;

if( ! detail::type_info_ex::equals( detail::to_type( pti ) ) )

return false; // type error, can't throw so bail.

}

byte_t * pv = unwind( aligned_sizeof::with_rtti );

T const & ref = detail::to_type( pv );

regex::detail::destroy( &ref );

return true;

}

template< typename T >

inline T & top( REGEX_VC6(detail::type2type) ) const // throw(type_error,...)

{

detail::static_assert<( AlignmentT >= detail::alignof::value )> const align_test;

static_cast(align_test);

if( RuntimeTypeCheckT )

{

// If we are debugging the stack, then the top of the stack is a

// pointer to a type_info struct. Assert that we have the correct type.

byte_t * pti = m_current - aligned_sizeof::no_rtti;

if( ! detail::type_info_ex::equals( detail::to_type( pti ) ) )

throw type_error( typeid( T ), *detail::to_type( pti )->typeinfo_ptr );

}

byte_t * pT = m_current - aligned_sizeof::with_rtti;

return detail::to_type( pT );

}

// Fetch the type_info for the element at the top of the stack

std::type_info const & top_type() const // throw()

{

detail::static_assert< RuntimeTypeCheckT > const type_check;

static_cast(type_check);

byte_t * pti = m_current - aligned_sizeof::no_rtti;

return *detail::to_type( pti )->typeinfo_ptr;

}

// Get a pointer to the top of the stack

void * set_jump() const // throw()

{

return m_current;

}

// Quick and dirty stack unwind. Does not call destructors.

void unsafe_long_jump( void *const jump_ptr ) // throw()

{

for( ;; )

{

if( std::less()( jump_ptr, m_current_node->m_mem ) ||

std::less()( m_current_node->m_head.m_end, jump_ptr ) )

{

m_current_node->m_head.m_current = m_current_node->m_mem;

m_current_node = m_current_node->m_head.m_back;

}

else

{

m_begin = m_current_node->m_mem;

m_current = m_current_node->m_head.m_current = static_cast( jump_ptr );

m_end = m_current_node->m_head.m_end;

return;

}

// Safe long jump; does call destructors if RuntimeTypeCheckT is true.

void safe_long_jump( void *const jump_ptr ) // throw()

{

detail::static_assert< RuntimeTypeCheckT > const type_check;

static_cast(type_check);

while( m_current != jump_ptr )

{

// The top of the stack is a pointer to a type_vtable struct.

m_current -= aligned_sizeof::no_rtti;

vtable_ptr pvtable = detail::to_type( m_current );

// find the start of the object

m_current -= pvtable->aligned_size;

// call the destructor for T

if( pvtable->destroy )

{

pvtable->destroy( m_current );

}

// move to the previous buffer if necessary

if( m_current == m_begin && m_current != jump_ptr )

{

m_current_node->m_head.m_current = m_current;

m_current_node = m_current_node->m_head.m_back;

m_begin = m_current_node->m_mem;

m_current = m_current_node->m_head.m_current;

m_end = m_current_node->m_head.m_end;

}

// Stack unwind. If RuntimeTypeCheckT && !AssumePodT, then destructors

// are called. Otherwise they are not.

void long_jump( void * jump_ptr ) // throw()

{

long_jump_impl( jump_ptr, detail::bool2type() );

}

struct stack_guard

{

stack_type * m_ps;

void * m_jump_ptr;

explicit stack_guard( stack_type * ps )

: m_ps( ps )

, m_jump_ptr( ps->set_jump() )

{

}

~stack_guard()

{

m_ps->long_jump( m_jump_ptr );

}

};

bool empty() const // throw()

{

return m_current == m_first_node.m_node.m_mem;

}

// Use scoped_push for automatically pushing/popping

// things to and from the stack. This is especially useful

// if you want to push a bunch of things "atomically". For

// instance:

// typedef hetero_stack<>::scoped_pop scoped_pop;

// scoped_pop p1 = stack.scoped_push( int(1) ); // could throw

// scoped_pop p2 = stack.scoped_push( std::string("foo") ); // could throw

// stack.push( float(3.14159) ); // could throw

// p2.dismiss(); // ok, nothing threw, so ...

// p1.dismiss(); // ... dismiss the scoped_pops

// If p2 and p1 are not dismissed, as in the case when an

// exception gets thrown, then they automatically pop their

// arguments from the stack.

class scoped_pop_base

{

scoped_pop_base & operator=( scoped_pop_base const & ); // disallow assignment

protected:

mutable stack_type * m_pstack;

explicit scoped_pop_base( stack_type * pstack ) // throw(std::bad_alloc,...)

: m_pstack( pstack )

{

}

scoped_pop_base( scoped_pop_base const & right ) // throw() // destructive copy

: m_pstack( right.m_pstack )

{

right.dismiss();

}

public:

void dismiss() const // throw()

{

m_pstack = 0;

}

};

template< typename T >

class scoped_pop_t : public scoped_pop_base

{

scoped_pop_t & operator=( scoped_pop_t const & ); // disallow assignment

public:

scoped_pop_t( stack_type * pstack, T const & t ) // throw(std::bad_alloc,...)

: scoped_pop_base( pstack )

{

// Note that if this throws an exception the destructor

// will not get called, which is what we want.

m_pstack->push( t );

}

~scoped_pop_t() // throw()

{

// If we own this stack space, pop it.

if( m_pstack )

m_pstack->template pop( std::nothrow );

}

};

template< typename T >

scoped_pop_t scoped_push( T const & t ) // throw(...)

{

return scoped_pop_t( this, t );

}

typedef scoped_pop_base const & scoped_pop;

};

#ifdef _MSC_VER

#pragma warning( pop )

#endif

} // namespace regex

#endif

//+---------------------------------------------------------------------------

// Copyright ( C ) Microsoft, 1994 - 2002.

// File: syntax2.h

// Contents: syntax modules for regexpr

// Classes: perl_syntax, posix_syntax

// Author: Eric Niebler ( [email protected] )

// History: 3-29-00 ericne Created

//----------------------------------------------------------------------------

#ifndef SYNTAX_H

#define SYNTAX_H

#ifdef _MSC_VER

#pragma warning( push )

// warning C4786: identifier was truncated to '255' characters in the debug information

#pragma warning( disable : 4786 )

#endif

#include

#ifndef ARRAYSIZE

# define ARRAYSIZE( a ) (sizeof(a)/sizeof((a)[0]))

#endif

#ifndef UCHAR_MAX

# define UCHAR_MAX 0xff

#endif

#ifndef WCHAR_MAX

# define WCHAR_MAX ((wchar_t)-1)

#endif

#ifdef _MSC_VER

# include

# define REGEX_ASSERT(x) _ASSERTE(x)

# define REGEX_FORCEINLINE __forceinline

# define REGEX_SELECTANY __declspec(selectany)

# define REGEX_CDECL __cdecl

# define REGEX_SEH_TRY __try

# define REGEX_SEH_EXCEPT(x) __except( x )

# define REGEX_RESET_STK_OFLW() _resetstkoflw()

# if 1200 < _MSC_VER

# define REGEX_NOINLINE __declspec(noinline)

# define REGEX_DEPRECATED __declspec(deprecated)

# define REGEX_DEPENDENT_TYPENAME typename

# else

# define REGEX_NOINLINE

# define REGEX_DEPRECATED

# define REGEX_DEPENDENT_TYPENAME

# endif

#else

# include

# define REGEX_ASSERT(x) assert(x)

# define REGEX_NOINLINE

# define REGEX_FORCEINLINE inline

# define REGEX_SELECTANY

# define REGEX_CDECL

# define REGEX_SEH_TRY

# define REGEX_SEH_EXCEPT(x) if( false )

# define REGEX_RESET_STK_OFLW() ((void)0)

# define REGEX_DEPRECATED

# define REGEX_DEPENDENT_TYPENAME typename

#endif

#define REGEX_STRING(CharT,sz) (::regex::detail::literal::string( sz, L##sz ))

#define REGEX_CHAR(CharT,ch) (static_cast(::regex::detail::literal::template character::value))

#if defined(_MSC_VER) & _CPPLIB_VER <= 310

namespace std

{

template<>

struct iterator_traits< char * >

{ // get traits from iterator _Iter

typedef random_access_iterator_tag iterator_category;

typedef char value_type;

typedef ptrdiff_t difference_type;

typedef difference_type distance_type; // retained

typedef char * pointer;

typedef char & reference;

};

template<>

struct iterator_traits< char const * >

{ // get traits from iterator _Iter

typedef random_access_iterator_tag iterator_category;

typedef char value_type;

typedef ptrdiff_t difference_type;

typedef difference_type distance_type; // retained

typedef char * pointer;

typedef char & reference;

};

template<>

struct iterator_traits< wchar_t * >

{ // get traits from iterator _Iter

typedef random_access_iterator_tag iterator_category;

typedef wchar_t value_type;

typedef ptrdiff_t difference_type;

typedef difference_type distance_type; // retained

typedef wchar_t * pointer;

typedef wchar_t & reference;

};

template<>

struct iterator_traits< wchar_t const * >

{ // get traits from iterator _Iter

typedef random_access_iterator_tag iterator_category;

typedef wchar_t value_type;

typedef ptrdiff_t difference_type;

typedef difference_type distance_type; // retained

typedef wchar_t * pointer;

typedef wchar_t & reference;

};

}

#endif

namespace regex

{

class bad_regexpr : public std::invalid_argument

{

public:

explicit bad_regexpr( std::string const & s )

: std::invalid_argument( s ) {}

virtual ~bad_regexpr() throw() {}

};

// Flags to control how matching occurs

enum REGEX_FLAGS

{

NOFLAGS = 0x0000,

NOCASE = 0x0001, // ignore case

GLOBAL = 0x0002, // match everywhere in the string

MULTILINE = 0x0004, // ^ and $ can match internal line breaks

SINGLELINE = 0x0008, // . can match newline character

RIGHTMOST = 0x0010, // start matching at the right of the string

NOBACKREFS = 0x0020, // only meaningful when used with GLOBAL and substitute

FIRSTBACKREFS = 0x0040, // only meaningful when used with GLOBAL

ALLBACKREFS = 0x0080, // only meaningful when used with GLOBAL

NORMALIZE = 0x0100, // Preprocess patterns: "//n" => "/n", etc.

EXTENDED = 0x0200, // ignore whitespace in pattern

};

// For backwards compatibility

REGEX_FLAGS const noflags = NOFLAGS;

// helper functions to make it easier to combine

// the regex flags.

inline REGEX_FLAGS operator|( REGEX_FLAGS f1, REGEX_FLAGS f2 )

{

return ( REGEX_FLAGS ) ( ( unsigned )f1 | ( unsigned )f2 );

}

inline REGEX_FLAGS & operator|=( REGEX_FLAGS & f1, REGEX_FLAGS f2 )

{

return f1 = ( f1 | f2 );

}

inline REGEX_FLAGS operator&( REGEX_FLAGS f1, REGEX_FLAGS f2 )

{

return ( REGEX_FLAGS ) ( ( unsigned )f1 & ( unsigned )f2 );

}

inline REGEX_FLAGS & operator&=( REGEX_FLAGS & f1, REGEX_FLAGS f2 )

{

return f1 = ( f1 & f2 );

}

#if !defined(_MSC_VER) | 1200 < _MSC_VER

inline REGEX_FLAGS operator~( REGEX_FLAGS f )

{

return ( REGEX_FLAGS ) ~( unsigned )f;

}

#endif

// The following are the tokens that can be emitted by the syntax module.

// Don't reorder this list!!!

enum TOKEN

{

NO_TOKEN = 0,

// REGULAR TOKENS

BEGIN_GROUP,

END_GROUP,

ALTERNATION,

BEGIN_LINE,

END_LINE,

BEGIN_CHARSET,

MATCH_ANY,

ESCAPE,

// QUANTIFICATION TOKENS

ONE_OR_MORE,

ZERO_OR_MORE,

ZERO_OR_ONE,

ONE_OR_MORE_MIN,

ZERO_OR_MORE_MIN,

ZERO_OR_ONE_MIN,

BEGIN_RANGE,

RANGE_SEPARATOR,

END_RANGE,

END_RANGE_MIN,

// ESCAPE SEQUENCES

ESC_DIGIT,

ESC_NOT_DIGIT,

ESC_SPACE,

ESC_NOT_SPACE,

ESC_WORD,

ESC_NOT_WORD,

ESC_BEGIN_STRING,

ESC_END_STRING,

ESC_END_STRING_z,

ESC_WORD_BOUNDARY,

ESC_NOT_WORD_BOUNDARY,

ESC_WORD_START,

ESC_WORD_STOP,

ESC_QUOTE_META_ON,

ESC_QUOTE_META_OFF,

// SUBSTITUTION TOKENS

SUBST_BACKREF,

SUBST_PREMATCH,

SUBST_POSTMATCH,

SUBST_MATCH,

SUBST_ESCAPE,

SUBST_QUOTE_META_ON,

SUBST_UPPER_ON,

SUBST_UPPER_NEXT,

SUBST_LOWER_ON,

SUBST_LOWER_NEXT,

SUBST_ALL_OFF,

// CHARSET TOKENS

CHARSET_NEGATE,

CHARSET_ESCAPE,

CHARSET_RANGE,

CHARSET_BACKSPACE,

CHARSET_END,

CHARSET_ALNUM,

CHARSET_NOT_ALNUM,

CHARSET_ALPHA,

CHARSET_NOT_ALPHA,

CHARSET_BLANK,

CHARSET_NOT_BLANK,

CHARSET_CNTRL,

CHARSET_NOT_CNTRL,

CHARSET_DIGIT,

CHARSET_NOT_DIGIT,

CHARSET_GRAPH,

CHARSET_NOT_GRAPH,

CHARSET_LOWER,

CHARSET_NOT_LOWER,

CHARSET_PRINT,

CHARSET_NOT_PRINT,

CHARSET_PUNCT,

CHARSET_NOT_PUNCT,

CHARSET_SPACE,

CHARSET_NOT_SPACE,

CHARSET_UPPER,

CHARSET_NOT_UPPER,

CHARSET_XDIGIT,

CHARSET_NOT_XDIGIT,

// EXTENSION TOKENS

EXT_NOBACKREF,

EXT_POS_LOOKAHEAD,

EXT_NEG_LOOKAHEAD,

EXT_POS_LOOKBEHIND,

EXT_NEG_LOOKBEHIND,

EXT_INDEPENDENT,

EXT_COMMENT,

EXT_CONDITION,

EXT_RECURSE,

EXT_UNKNOWN

};

namespace detail

{

template< typename CharT > struct literal;

template<> struct literal

{

static char const * string( char const * sz, wchar_t const * ) { return sz; }

template< char ch, wchar_t > struct character { enum { value = ch }; };

};

template<> struct literal

{

static wchar_t const * string( char const *, wchar_t const * sz ) { return sz; }

template< char, wchar_t ch > struct character { enum { value = ch }; };

};

struct posix_charset_type

{

char const * m_szcharset;

size_t cchars;

};

extern posix_charset_type const g_rgposix_charsets[];

extern size_t const g_cposix_charsets;

template< typename IterT >

bool is_posix_charset( IterT icur, IterT iend, char const * szcharset )

{

for( ; iend != icur && char() != *szcharset; ++icur, ++szcharset )

{

if( *icur != *szcharset )

return false;

}

return char() == *szcharset;

}

// Forward-declare the class that holds all the information

// about the set of characters that can be matched by a charset

struct charset;

void free_charset( charset const * );

template< typename CharT >

struct charset_map_node

{

std::basic_string m_str;

charset const * m_rgcharsets[2]; // 0==case, 1==nocase

charset_map_node()

{

m_rgcharsets[0] = m_rgcharsets[1] = 0;

}

charset_map_node( charset_map_node const & node )

{

*this = node;

}

charset_map_node & operator=( charset_map_node const & node )

{

m_str = node.m_str;

m_rgcharsets[0] = node.m_rgcharsets[0];

m_rgcharsets[1] = node.m_rgcharsets[1];

return *this;

}

void set( std::basic_string const & str )

{

clear();

m_str = str;

}

void clear()

{

std::basic_string().swap( m_str );

free_charset( m_rgcharsets[0] );

free_charset( m_rgcharsets[1] );

m_rgcharsets[0] = m_rgcharsets[1] = 0;

}

};

template< typename CharT >

class charset_map

{

std::map > m_map;

public:

typedef typename std::map >::iterator iterator;

~charset_map()

{

for( iterator iter = m_map.begin(); m_map.end() != iter; ++iter )

iter->second.clear();

}

charset_map_node & operator[]( CharT ch ) { return m_map[ ch ]; }

iterator begin() { return m_map.begin(); }

iterator end() { return m_map.end(); }

iterator find( CharT ch ) { return m_map.find( ch ); }

void erase( iterator iter ) { m_map.erase( iter ); }

};

inline detail::charset_map & get_perl_charset_map( char )

{

static detail::charset_map s_charset_map;

return s_charset_map;

}

inline detail::charset_map & get_perl_charset_map( wchar_t )

{

static detail::charset_map s_charset_map;

return s_charset_map;

}

inline detail::charset_map & get_posix_charset_map( char )

{

static detail::charset_map s_charset_map;

return s_charset_map;

}

inline detail::charset_map & get_posix_charset_map( wchar_t )

{

static detail::charset_map s_charset_map;

return s_charset_map;

}

inline bool regex_isspace( char ch )

{

using namespace std;

return 0 != isspace( ch );

}

inline bool regex_isspace( wchar_t wch )

{

using namespace std;

return 0 != iswspace( wch );

}

template< typename T >

T const & regex_max( T const & lhs, T const & rhs )

{

return ( lhs > rhs ) ? lhs : rhs;

}

template< typename T >

T const & regex_min( T const & lhs, T const & rhs )

{

return ( lhs < rhs ) ? lhs : rhs;

}

} // namespace detail

// The perl_syntax class encapsulates the Perl 5 regular expression syntax. It is

// used as a template parameter to basic_rpattern. To customize regex syntax, create

// your own syntax class and use it as a template parameter instead.

class perl_syntax_base

{

protected:

perl_syntax_base()

{

}

static TOKEN const s_rgreg[ UCHAR_MAX + 1 ];

static TOKEN const s_rgescape[ UCHAR_MAX + 1 ];

static TOKEN look_up( char ch, TOKEN const rg[] )

{

return rg[ static_cast( ch ) ];

}

static TOKEN look_up( wchar_t ch, TOKEN const rg[] )

{

return UCHAR_MAX < ch ? NO_TOKEN : rg[ static_cast( ch ) ];

}

};

// --------------------------------------------------------------------------

// Class: perl_syntax

// Description: Module that encapsulates the Perl syntax

// Methods: eat_whitespace -

// min_quant -

// perl_syntax -

// set_flags -

// get_flags -

// reg_token -

// quant_token -

// charset_token -

// subst_token -

// ext_token -

// get_charset_map -

// invalid_charset -

// register_intrinsic_charset -

// _invalid_charset -

// Members: m_flags -

// s_charset_map -

// Typedefs: iterator -

// const_iterator -

// char_type -

// History: 11/16/2001 - ericne - Created

// --------------------------------------------------------------------------

template< typename CharT >

class perl_syntax : protected perl_syntax_base

{

public:

typedef typename std::basic_string::iterator iterator;

typedef typename std::basic_string::const_iterator const_iterator;

typedef CharT char_type;

template< typename OtherT > struct rebind { typedef perl_syntax other; };

private:

REGEX_FLAGS m_flags;

const_iterator eat_whitespace( iterator & icur, const_iterator iend )

{

if( m_flags & EXTENDED )

{

while( iend != icur && ( REGEX_CHAR(CharT,'#') == *icur || detail::regex_isspace( *icur ) ) )

{

if( REGEX_CHAR(CharT,'#') == *icur++ )

{

while( iend != icur && REGEX_CHAR(CharT,'/n') != *icur++ ) {}

}

else

{

for( ; iend != icur && detail::regex_isspace( *icur ); ++icur ) {}

}

return icur;

}

bool min_quant( iterator & icur, const_iterator iend )

{

return ( iend != eat_whitespace( ++icur, iend ) && REGEX_CHAR(CharT,'?') == *icur ? ( ++icur, true ) : false );

}

public:

perl_syntax( REGEX_FLAGS flags )

: m_flags( flags )

{

}

perl_syntax( perl_syntax const & sy )

: m_flags( sy.m_flags )

{

}

void set_flags( REGEX_FLAGS flags )

{

m_flags = flags;

}

REGEX_FLAGS get_flags() const

{

return m_flags;

}

TOKEN reg_token( iterator & icur, const_iterator iend )

{

REGEX_ASSERT( iend != icur );

if( iend == eat_whitespace( icur, iend ) )

return NO_TOKEN;

TOKEN tok = look_up( *icur, s_rgreg );

if( tok )

++icur;

if( ESCAPE == tok && iend != icur )

{

tok = look_up( *icur, s_rgescape );

if( tok )

++icur;

else

tok = ESCAPE;

}

return tok;

}

TOKEN quant_token( iterator & icur, const_iterator iend )

{

REGEX_ASSERT( iend != icur );

if( iend == eat_whitespace( icur, iend ) )

return NO_TOKEN;

TOKEN tok = NO_TOKEN;

switch( *icur )

{

case REGEX_CHAR(CharT,'*'):

tok = min_quant( icur, iend ) ? ZERO_OR_MORE_MIN : ZERO_OR_MORE;

break;

case REGEX_CHAR(CharT,'+'):

tok = min_quant( icur, iend ) ? ONE_OR_MORE_MIN : ONE_OR_MORE;

break;

case REGEX_CHAR(CharT,'?'):

tok = min_quant( icur, iend ) ? ZERO_OR_ONE_MIN : ZERO_OR_ONE;

break;

case REGEX_CHAR(CharT,'}'):

tok = min_quant( icur, iend ) ? END_RANGE_MIN : END_RANGE;

break;

case REGEX_CHAR(CharT,'{'):

tok = BEGIN_RANGE;

++icur;

break;

case REGEX_CHAR(CharT,','):

tok = RANGE_SEPARATOR;

++icur;

break;

}

return tok;

}

TOKEN charset_token( iterator & icur, const_iterator iend )

{

REGEX_ASSERT( iend != icur );

TOKEN tok = NO_TOKEN;

switch( *icur )

{

case REGEX_CHAR(CharT,'-'):

tok = CHARSET_RANGE;

++icur;

break;

case REGEX_CHAR(CharT,'^'):

tok = CHARSET_NEGATE;

++icur;

break;

case REGEX_CHAR(CharT,']'):

tok = CHARSET_END;

++icur;

break;

case REGEX_CHAR(CharT,'//'):

tok = CHARSET_ESCAPE;

if( iend == ++icur )

break;

switch( *icur )

{

case REGEX_CHAR(CharT,'b'):

tok = CHARSET_BACKSPACE;

++icur;

break;

case REGEX_CHAR(CharT,'d'):

tok = ESC_DIGIT;

++icur;

break;

case REGEX_CHAR(CharT,'D'):

tok = ESC_NOT_DIGIT;

++icur;

break;

case REGEX_CHAR(CharT,'s'):

tok = ESC_SPACE;

++icur;

break;

case REGEX_CHAR(CharT,'S'):

tok = ESC_NOT_SPACE;

++icur;

break;

case REGEX_CHAR(CharT,'w'):

tok = ESC_WORD;

++icur;

break;

case REGEX_CHAR(CharT,'W'):

tok = ESC_NOT_WORD;

++icur;

break;

}

break;

case REGEX_CHAR(CharT,'['):

if( REGEX_CHAR(CharT,':') == *( ++icur )-- )

{

for( size_t i=0; !tok && i < detail::g_cposix_charsets; ++i )

{

if( detail::is_posix_charset( icur, iend, detail::g_rgposix_charsets[i].m_szcharset ) )

{

tok = TOKEN( CHARSET_ALNUM + i );

std::advance( icur, detail::g_rgposix_charsets[i].cchars );

}

break;

}

return tok;

}

TOKEN subst_token( iterator & icur, const_iterator iend )

{

REGEX_ASSERT( iend != icur );

TOKEN tok = NO_TOKEN;

switch( *icur )

{

case REGEX_CHAR(CharT,'//'):

tok = SUBST_ESCAPE;

if( iend != ++icur )

switch( *icur )

{

case REGEX_CHAR(CharT,'Q'):

tok = SUBST_QUOTE_META_ON;

++icur;

break;

case REGEX_CHAR(CharT,'U'):

tok = SUBST_UPPER_ON;

++icur;

break;

case REGEX_CHAR(CharT,'u'):

tok = SUBST_UPPER_NEXT;

++icur;

break;

case REGEX_CHAR(CharT,'L'):

tok = SUBST_LOWER_ON;

++icur;

break;

case REGEX_CHAR(CharT,'l'):

tok = SUBST_LOWER_NEXT;

++icur;

break;

case REGEX_CHAR(CharT,'E'):

tok = SUBST_ALL_OFF;

++icur;

break;

}

break;

case REGEX_CHAR(CharT,'$'):

tok = SUBST_BACKREF;

if( iend != ++icur )

switch( *icur )

{

case REGEX_CHAR(CharT,'&'):

tok = SUBST_MATCH;

++icur;

break;

case REGEX_CHAR(CharT,'`'):

tok = SUBST_PREMATCH;

++icur;

break;

case REGEX_CHAR(CharT,'/''):

tok = SUBST_POSTMATCH;

++icur;

break;

}

break;

}

return tok;

}

TOKEN ext_token( iterator & icur, const_iterator iend )

{

REGEX_ASSERT( iend != icur );

if( iend == eat_whitespace( icur, iend ) )

return NO_TOKEN;

bool finclude;

TOKEN tok = NO_TOKEN;

if( REGEX_CHAR(CharT,'?') == *icur )

{

tok = EXT_UNKNOWN;

++icur;

if( m_flags & EXTENDED )

for( ; iend != icur && detail::regex_isspace( *icur ); ++icur ) {}

if( iend != icur )

{

switch( *icur )

{

case REGEX_CHAR(CharT,':'):

tok = EXT_NOBACKREF;

++icur;

break;

case REGEX_CHAR(CharT,'='):

tok = EXT_POS_LOOKAHEAD;

++icur;

break;

case REGEX_CHAR(CharT,'!'):

tok = EXT_NEG_LOOKAHEAD;

++icur;

break;

case REGEX_CHAR(CharT,'#'):

tok = EXT_COMMENT;

++icur;

break;

case REGEX_CHAR(CharT,'('):

tok = EXT_CONDITION;

++icur;

break;

case REGEX_CHAR(CharT,'R'):

tok = EXT_RECURSE;

++icur;

break;

case REGEX_CHAR(CharT,'<'):

if( iend == eat_whitespace( ++icur, iend ) )

break;

switch( *icur )

{

case REGEX_CHAR(CharT,'='):

tok = EXT_POS_LOOKBEHIND;

++icur;

break;

case REGEX_CHAR(CharT,'!'):

tok = EXT_NEG_LOOKBEHIND;

++icur;

break;

}

break;

case REGEX_CHAR(CharT,'>'):

tok = EXT_INDEPENDENT;

++icur;

break;

default:

finclude = true;

{

if( REGEX_CHAR(CharT,':') == *icur )

{

tok = EXT_NOBACKREF;

++icur;

break;

}

if( REGEX_CHAR(CharT,')') == *icur )

{

tok = EXT_NOBACKREF;

break;

}

if( REGEX_CHAR(CharT,'-') == *icur && finclude )

finclude = false;

else if( REGEX_CHAR(CharT,'i') == *icur )

m_flags = ( REGEX_FLAGS ) ( finclude ? ( m_flags | NOCASE ) : ( m_flags & ~NOCASE ) );

else if( REGEX_CHAR(CharT,'m') == *icur )

m_flags = ( REGEX_FLAGS ) ( finclude ? ( m_flags | MULTILINE ) : ( m_flags & ~MULTILINE ) );

else if( REGEX_CHAR(CharT,'s') == *icur )

m_flags = ( REGEX_FLAGS ) ( finclude ? ( m_flags | SINGLELINE ) : ( m_flags & ~SINGLELINE ) );

else if( REGEX_CHAR(CharT,'x') == *icur )

m_flags = ( REGEX_FLAGS ) ( finclude ? ( m_flags | EXTENDED ) : ( m_flags & ~EXTENDED ) );

else

break;

} while( iend != eat_whitespace( ++icur, iend ) );

break;

}

return tok;

}

// Functions used for making user-defined intrinsic character sets

static detail::charset_map & get_charset_map()

{

return detail::get_perl_charset_map( CharT() );

}

static bool invalid_charset( CharT ch )

{

return _invalid_charset( ch );

}

static void register_intrinsic_charset( CharT ch, std::basic_string const & str ) //throw( bad_regexpr, std::bad_alloc )

{

perl_syntax sy( NOFLAGS );

if( invalid_charset( ch ) )

throw bad_regexpr( "invalid character specified to register_intrinsic_charset" );

std::basic_string pat = str;

typename std::basic_string::iterator ibegin = pat.begin();

if( BEGIN_CHARSET != sy.reg_token( ibegin, pat.end() ) )

throw bad_regexpr( "expecting beginning of charset" );

regex::detail::charset_map & charset_map = get_charset_map();

regex::detail::charset_map_node & map_node = charset_map[ ch ];

map_node.set( std::basic_string( ibegin, pat.end() ) );

}

private:

static bool _invalid_charset( char ch )

{

using namespace std;

return NO_TOKEN != s_rgescape[ static_cast( ch ) ]

|| isdigit( ch ) || 'e' == ch || 'x' == ch || 'c' == ch;

}

static bool _invalid_charset( wchar_t ch )

{

return UCHAR_MAX >= ch && _invalid_charset( static_cast( ch ) );

}

};

// --------------------------------------------------------------------------

// Class: posix_syntax

// Description: Implements the basic POSIX regular expression syntax

// Methods: posix_syntax -

// posix_syntax -

// get_flags -

// set_flags -

// reg_token -

// quant_token -

// charset_token -

// subst_token -

// ext_token -

// get_charset_map -

// invalid_charset -

// register_intrinsic_charset -

// Members: m_flags -

// s_charset_map -

// Typedefs: iterator -

// const_iterator -

// char_type -

// History: 11/16/2001 - ericne - Created

// --------------------------------------------------------------------------

template< typename CharT >

class posix_syntax

{

REGEX_FLAGS m_flags;

public:

typedef typename std::basic_string::iterator iterator;

typedef typename std::basic_string::const_iterator const_iterator;

typedef CharT char_type;

template< typename OtherT > struct rebind { typedef posix_syntax other; };

posix_syntax( REGEX_FLAGS flags )

: m_flags( flags )

{

}

posix_syntax( posix_syntax const & sy )

: m_flags( sy.m_flags )

{

}

REGEX_FLAGS get_flags() const

{

return m_flags;

}

void set_flags( REGEX_FLAGS flags )

{

m_flags = flags;

}

TOKEN reg_token( iterator & icur, const_iterator iend )

{

TOKEN tok = NO_TOKEN;

switch( *icur )

{

case REGEX_CHAR(CharT,'.'):

tok = MATCH_ANY;

++icur;

break;

case REGEX_CHAR(CharT,'^'):

tok = BEGIN_LINE;

++icur;

break;

case REGEX_CHAR(CharT,'$'):

tok = END_LINE;

++icur;

break;

case REGEX_CHAR(CharT,'['):

tok = BEGIN_CHARSET;

++icur;

break;

case REGEX_CHAR(CharT,'//'):

tok = ESCAPE;

++icur;

if( iend != icur )

{

switch( *icur )

{

case REGEX_CHAR(CharT,'('):

tok = BEGIN_GROUP;

++icur;

break;

case REGEX_CHAR(CharT,')'):

tok = END_GROUP;

++icur;

break;

case REGEX_CHAR(CharT,'|'):

tok = ALTERNATION;

++icur;

break;

}

break;

}

return tok;

}

TOKEN quant_token( iterator & icur, const_iterator iend )

{

TOKEN tok = NO_TOKEN;

switch( *icur )

{

case REGEX_CHAR(CharT,'*'):

tok = ZERO_OR_MORE;

++icur;

break;

case REGEX_CHAR(CharT,','):

tok = RANGE_SEPARATOR;

++icur;

break;

case REGEX_CHAR(CharT,'//'):

++icur;

if( iend != icur )

{

switch( *icur )

{

case REGEX_CHAR(CharT,'?'):

tok = ZERO_OR_ONE;

++icur;

break;

case REGEX_CHAR(CharT,'+'):

tok = ONE_OR_MORE;

++icur;

break;

case REGEX_CHAR(CharT,'{'):

tok = BEGIN_RANGE;

++icur;

break;

case REGEX_CHAR(CharT,'}'):

tok = END_RANGE;

++icur;

break;

default:

--icur;

break;

}

else

{

--icur;

}

return tok;

}

TOKEN charset_token( iterator & icur, const_iterator iend )

{

TOKEN tok = NO_TOKEN;

switch( *icur )

{

case REGEX_CHAR(CharT,'^'):

tok = CHARSET_NEGATE;

++icur;

break;

case REGEX_CHAR(CharT,'-'):

tok = CHARSET_RANGE;

++icur;

break;

case REGEX_CHAR(CharT,']'):

tok = CHARSET_END;

++icur;

break;

case REGEX_CHAR(CharT,'['):

if( REGEX_CHAR(CharT,':') == *( ++icur )-- )

{

for( size_t i=0; !tok && i < detail::g_cposix_charsets; ++i )

{

if( detail::is_posix_charset( icur, iend, detail::g_rgposix_charsets[i].m_szcharset ) )

{

tok = TOKEN( CHARSET_ALNUM + i );

std::advance( icur, detail::g_rgposix_charsets[i].cchars );

}

break;

}

return tok;

}

TOKEN subst_token( iterator & icur, const_iterator iend )

{

TOKEN tok = NO_TOKEN;

if( REGEX_CHAR(CharT,'//') == *icur )

{

tok = SUBST_ESCAPE;

++icur;

if( iend != icur && REGEX_CHAR(CharT,'0') <= *icur && REGEX_CHAR(CharT,'9') >= *icur )

{

tok = SUBST_BACKREF;

}

return tok;

}

TOKEN ext_token( iterator &, const_iterator )

{

return NO_TOKEN;

}

// Functions for making user-defined intrinsic character sets

static detail::charset_map & get_charset_map()

{

return detail::get_posix_charset_map( CharT() );

}

static bool invalid_charset( CharT ch )

{

return _invalid_charset( ch );

}

static void register_intrinsic_charset( CharT ch, std::basic_string const & str ) //throw( bad_regexpr, std::bad_alloc )

{

posix_syntax sy( NOFLAGS );

if( invalid_charset( ch ) )

throw bad_regexpr( "invalid character specified to register_intrinsic_charset" );

std::basic_string pat = str;

typename std::basic_string::iterator ibegin = pat.begin();

if( BEGIN_CHARSET != sy.reg_token( ibegin, pat.end() ) )

throw bad_regexpr( "expecting beginning of charset" );

regex::detail::charset_map & charset_map = get_charset_map();

regex::detail::charset_map_node & map_node = charset_map[ ch ];

map_node.set( std::basic_string( ibegin, pat.end() ) );

}

private:

static bool _invalid_charset( char ch )

{

static char const s_invalid[] = "0123456789()|?+{}//exc";

return 0 != std::char_traits::find( s_invalid, ARRAYSIZE( s_invalid ) - 1, ch );

}

static bool _invalid_charset( wchar_t ch )

{

return UCHAR_MAX >= ch && _invalid_charset( static_cast( ch ) );

}

};

} // namespace regex

#ifdef _MSC_VER

#pragma warning( pop )

#endif

//+---------------------------------------------------------------------------

// Copyright ( C ) Microsoft, 1994 - 2002.

// File: reimpl2.h

// Functions: helpers for matching and substituting regular expressions

// Notes: implementation details that really belong in a cpp file,

// but can't because of template weirdness

// Author: Eric Niebler ( [email protected] )

// History: 8/15/2001 ericne Created

//----------------------------------------------------------------------------

#ifndef REIMPL_H

#define REIMPL_H

// Helper functions for match and substitute

namespace detail

{

// For use while doing uppercase/lowercase conversions:

inline char regex_toupper( char ch ) { using namespace std; return ( char )toupper( ch ); }

inline char regex_tolower( char ch ) { using namespace std; return ( char )tolower( ch ); }

inline wchar_t regex_toupper( wchar_t ch ) { using namespace std; return ( wchar_t )towupper( ch ); }

inline wchar_t regex_tolower( wchar_t ch ) { using namespace std; return ( wchar_t )towlower( ch ); }

template< typename IBeginT, typename IEndT >

inline void regex_toupper( IBeginT ibegin, IEndT iend )

{

typedef typename std::iterator_traits::value_type char_type;

typedef std::char_traits traits_type;

for( ; iend != ibegin; ++ibegin )

traits_type::assign( *ibegin, regex_toupper( *ibegin ) );

}

template< typename IBeginT, typename IEndT >

inline void regex_tolower( IBeginT ibegin, IEndT iend )

{

typedef typename std::iterator_traits::value_type char_type;

typedef std::char_traits traits_type;

for( ; iend != ibegin; ++ibegin )

traits_type::assign( *ibegin, regex_tolower( *ibegin ) );

}

// Helper fn for swapping two auto_ptr's

template< typename T >

inline void swap_auto_ptr( std::auto_ptr & left, std::auto_ptr & right )

{

std::auto_ptr temp( left );

left = right;

right = temp;

}

template< typename T >

inline void reset_auto_ptr( std::auto_ptr & left )

{

std::auto_ptr temp( 0 );

left = temp;

}

template< typename T, typename U >

inline void reset_auto_ptr( std::auto_ptr & left, U * right )

{

std::auto_ptr temp( right );

left = temp;

}

typedef int instantiator;

inline instantiator REGEX_CDECL instantiator_helper( ... )

{

return instantiator();

}

// --------------------------------------------------------------------------

// Class: match_param

// Description: Struct that contains the state of the matching operation.

// Passed by reference to all recursive_match_all and recursive_match_this routines.

// Methods: match_param - ctor

// Members: ibufferbegin - start of the buffer

// ibegin - start of this iteration

// iend - end of the string

// prgbackrefs - pointer to backref array

// History: 8/14/2000 - ericne - Created

// --------------------------------------------------------------------------

template< typename IterT >

struct match_param

{

typedef backref_tag backref_type;

typedef sub_expr_base const * sub_expr_ptr;

// for performance reasons, the most frequently used fields

// are placed at offsets which are a power of 2 (assuming

// a 32-bit architecture, and iterators which are 32 bits).

backref_type * m_prgbackrefs; // offsetof == 0

IterT m_iend; // offsetof == 4

IterT m_icur; // offsetof == 8

size_t m_cbackrefs;

sub_expr_ptr m_pnext; // offsetof == 16

IterT m_ibufferbegin;

IterT m_imatchbegin;

sub_expr_ptr m_pfirst;

unsafe_stack * m_pstack; // offsetof == 32

bool m_no0len;

bool m_reserved;

match_param

(

IterT ibufferbegin,

IterT imatchbegin,

IterT iend,

backref_type * prgbackrefs,

size_t cbackrefs

)

: m_prgbackrefs( prgbackrefs )

, m_iend( iend )

, m_icur( imatchbegin )

, m_cbackrefs( cbackrefs )

, m_pnext( 0 )

, m_ibufferbegin( ibufferbegin )

, m_imatchbegin( imatchbegin )

, m_pfirst( 0 )

, m_pstack( 0 )

, m_no0len( false )

, m_reserved( false )

{

}

};

// --------------------------------------------------------------------------

// Class: arena_allocator

// Description: A small, fast allocator for speeding up pattern compilation.

// Every basic_rpattern object has an arena as a member.

// sub_expr objects can only be allocated from this arena.

// Memory is alloc'ed in chunks using the underlying allocator.

// Chunks are freed en-masse when clear() or finalize() is called.

// History: 8/17/2001 - ericne - Created

// Notes: This is NOT a std-compliant allocator and CANNOT be used with

// STL containers. arena_allocator objects maintain state, and

// STL containers are allowed to assume their allocators do

// not maintain state. In regexpr2.cpp, I define slist<>, a simple

// arena-friendly singly-linked list for use with the arena

// allocator.

// --------------------------------------------------------------------------

template< typename AllocT = std::allocator >

struct pool_impl

{

typedef typename rebind::type char_allocator_type;

struct mem_block

{

size_t m_offset;

size_t m_blocksize;

mem_block * m_pnext;

unsigned char m_data[ 1 ];

};

#if !defined(_MSC_VER) | 1200 < _MSC_VER

struct pool_data : char_allocator_type

{

pool_data( size_t default_size, char_allocator_type const & alloc )

: char_allocator_type( alloc )

, m_pfirst( 0 )

, m_default_size( default_size )

{

}

mem_block * m_pfirst;

size_t m_default_size;

char_allocator_type & get_allocator()

{

return *this;

}

} m_data;

#else

struct pool_data

{

pool_data( size_t default_size, char_allocator_type const & alloc )

: m_alloc( alloc )

, m_pfirst( 0 )

, m_default_size( default_size )

{

}

char_allocator_type m_alloc;

mem_block * m_pfirst;

size_t m_default_size;

char_allocator_type & get_allocator()

{

return m_alloc;

}

} m_data;

#endif

void new_block( size_t size );

void clear();

void * allocate( size_t size );

explicit pool_impl( size_t default_size, char_allocator_type const & alloc = char_allocator_type() );

~pool_impl();

char_allocator_type get_allocator() const

{

return const_cast(this)->m_data.get_allocator();

}

};

template< typename T, typename AllocT = std::allocator >

class arena_allocator

{

public:

typedef size_t size_type;

typedef ptrdiff_t difference_type;

typedef T *pointer;

typedef T const *const_pointer;

typedef T & reference;

typedef T const & const_reference;

typedef T value_type;

typedef typename rebind::type char_alloc_type;

typedef pool_impl pool_impl_t;

typedef typename rebind::type pool_alloc_type;

explicit arena_allocator( size_t default_size, char_alloc_type const & alloc = char_alloc_type() )

: m_pool( 0 )

{

char_alloc_type char_alloc( alloc );

pool_alloc_type pool_alloc( convert_allocator( char_alloc, 0 ) );

m_pool = pool_alloc.allocate( 1, 0 );

pool_alloc.construct( m_pool, pool_impl_t( default_size, char_alloc ) ); // can't throw

}

#if !defined(_MSC_VER) | 1200 < _MSC_VER

arena_allocator( arena_allocator const & that )

: m_pool( that.m_pool )

{

}

#endif

template< typename U >

arena_allocator( arena_allocator const & that )

: m_pool( that.m_pool )

{

}

~arena_allocator()

{ // Many arena_allocators may point to m_pool, so don't delete it.

} // Rather, wait for someone to call finalize().

pointer allocate( size_type size, void const * =0 )

{

return static_cast( m_pool->allocate( size * sizeof(T) ) );

}

void deallocate( void *, size_type )

{ // no-op. deallocation happens when pool is finalized or cleared.

}

void construct( pointer p, T const & t )

{

new( static_cast(p) ) T( t );

}

void destroy( pointer p )

{

regex::detail::destroy( p );

}

#if !defined(_MSC_VER) | 1200 < _MSC_VER

template< typename U > struct rebind

{

typedef arena_allocator other;

};

#endif

void clear()

{

m_pool->clear();

}

void finalize()

{

char_alloc_type char_alloc( m_pool->get_allocator() );

pool_alloc_type pool_alloc( convert_allocator( char_alloc, 0 ) );

pool_alloc.destroy( m_pool );

pool_alloc.deallocate( m_pool, 1 );

m_pool = 0;

}

void swap( arena_allocator & that )

{

using std::swap;

swap( m_pool, that.m_pool );

}

// the pool lives here

pool_impl_t * m_pool;

};

// Dummy struct used by the pool allocator to align returned pointers

struct not_pod

{

virtual ~not_pod() {}

};

template< typename AllocT >

inline pool_impl::pool_impl( size_t default_size, char_allocator_type const & alloc )

: m_data( default_size, alloc )

{

}

template< typename AllocT >

inline pool_impl::~pool_impl()

{

clear();

}

template< typename AllocT >

inline void pool_impl::clear()

{

for( mem_block * pnext; m_data.m_pfirst; m_data.m_pfirst = pnext )

{

pnext = m_data.m_pfirst->m_pnext;

m_data.get_allocator().deallocate( reinterpret_cast( m_data.m_pfirst ), m_data.m_pfirst->m_blocksize );

}

template< typename AllocT >

inline void pool_impl::new_block( size_t size )

{

size_t blocksize = regex_max( m_data.m_default_size, size ) + offsetof( mem_block, m_data );

mem_block * pnew = reinterpret_cast( m_data.get_allocator().allocate( blocksize, 0 ) );

if( 0 == pnew )

{

throw std::bad_alloc();

}

pnew->m_offset = 0;

pnew->m_blocksize = blocksize;

pnew->m_pnext = m_data.m_pfirst;

m_data.m_pfirst = pnew;

}

template< typename AllocT >

inline void * pool_impl::allocate( size_t size )

{

if( 0 == size )

size = 1;

if( 0 == m_data.m_pfirst || m_data.m_pfirst->m_offset + size > m_data.m_default_size )

new_block( size );

void * pnew = m_data.m_pfirst->m_data + m_data.m_pfirst->m_offset;

// ensure returned pointers are always suitably aligned

m_data.m_pfirst->m_offset += ( ( size + alignof::value - 1 )

& ~( alignof::value - 1 ) );

return pnew;

}

// The regex_arena is a basic, vanilla arena_allocator.

typedef arena_allocator regex_arena;

template< typename T >

type_with_size<3> allocator_picker( arena_allocator const &, int );

template<> struct rebind_helper<3>

{

template< typename, typename ElemT>

struct inner

{

typedef arena_allocator type;

};

// --------------------------------------------------------------------------

// Class: sub_expr_base

// Description: patterns are "compiled" into a directed graph of sub_expr_base

// structs. Matching is accomplished by traversing this graph.

// Methods: ~sub_expr_base - virt dtor so cleanup happens correctly

// recursive_match_all - match this sub-expression and all following

// sub-expression

// History: 8/14/2000 - ericne - Created

// --------------------------------------------------------------------------

template< typename IterT >

struct sub_expr_base

{

virtual bool recursive_match_all_s( match_param &, IterT ) const = 0; //throw() (offset 0)

virtual bool recursive_match_all_c( match_param &, IterT ) const = 0; //throw() (offset 4)

virtual bool iterative_match_this_s( match_param & ) const = 0; //throw() (offset 8)

virtual bool iterative_match_this_c( match_param & ) const = 0; //throw() (offset 12)

virtual bool iterative_rematch_this_s( match_param & ) const = 0; //throw() (offset 16)

virtual bool iterative_rematch_this_c( match_param & ) const = 0; //throw() (offset 20)

virtual ~sub_expr_base() = 0; // (offset 24)

// Use the regex_arena for memory management

static void * operator new( size_t size, regex_arena & arena )

{

return arena.allocate( size );

}

static void operator delete( void *, regex_arena & )

{

}

// Invoke the d'tor, but don't bother freeing memory. That will

// happen automatically when the arena object gets destroyed.

static void operator delete( void * )

{

}

// For choosing an appropriate virtual function based on a compile time constant

bool recursive_match_all( match_param & param, IterT icur, false_t ) const //throw()

{

return recursive_match_all_s( param, icur );

}

bool recursive_match_all( match_param & param, IterT icur, true_t ) const //throw()

{

return recursive_match_all_c( param, icur );

}

bool iterative_match_this( match_param & param, false_t ) const //throw()

{

return iterative_match_this_s( param );

}

bool iterative_match_this( match_param & param, true_t ) const //throw()

{

return iterative_match_this_c( param );

}

bool iterative_rematch_this( match_param & param, false_t ) const //throw()

{

return iterative_rematch_this_s( param );

}

bool iterative_rematch_this( match_param & param, true_t ) const //throw()

{

return iterative_rematch_this_c( param );

}

private:

// don't allocate sub-expressions directly on the heap; they should

// be allocated from an arena

static void * operator new( size_t size ) throw( std::bad_alloc );

// disable all the vector new's and delete's.

static void * operator new[]( size_t size, regex_arena & arena ) throw( std::bad_alloc );

static void operator delete[]( void *, regex_arena & );

static void * operator new[]( size_t size ) throw( std::bad_alloc );

static void operator delete[]( void * );

};

template< typename IterT >

inline sub_expr_base::~sub_expr_base()

{

}

// --------------------------------------------------------------------------

// Class: subst_node

// Description: Substitution strings are parsed into an array of these

// structures in order to speed up subst operations.

// Members: stype - type of this struct

// .m_subst_string - do a string substitution

// .m_subst_backref - do a bacref substitution

// op - execute an operation

// History: 8/14/2000 - ericne - Created

// --------------------------------------------------------------------------

struct subst_node

{

enum

{

PREMATCH = -1,

POSTMATCH = -2

};

enum subst_type

{

SUBST_STRING,

SUBST_BACKREF,

SUBST_OP

};

enum op_type

{

UPPER_ON = SUBST_UPPER_ON,

UPPER_NEXT = SUBST_UPPER_NEXT,

LOWER_ON = SUBST_LOWER_ON,

LOWER_NEXT = SUBST_LOWER_NEXT,

ALL_OFF = SUBST_ALL_OFF

};

struct string_offsets

{

ptrdiff_t m_rstart;

ptrdiff_t m_rlength;

};

subst_type m_stype;

union

{

string_offsets m_subst_string;

size_t m_subst_backref;

op_type m_op;

};

typedef std::list subst_list_type;

size_t DEFAULT_BLOCK_SIZE();

template< typename IterT >

class boyer_moore;

// --------------------------------------------------------------------------

// Class: basic_rpattern_base_impl

// Description:

// Methods: basic_rpattern_base_impl - ctor

// flags - get the state of the flags

// uses_backrefs - true if the backrefs are referenced

// get_first_subexpression - return ptr to first sub_expr struct

// get_width - get min/max nbr chars this pattern can match

// loops - if false, we only need to try to match at 1st position

// cgroups - number of visible groups

// _cgroups_total - total number of groups, including hidden ( ?: ) groups

// get_pat - get string representing the pattern

// get_subst - get string representing the substitution string

// get_subst_list - get the list of subst nodes

// _normalize_string - perform character escaping

// Members: m_fuses_backrefs - true if subst string refers to backrefs

// m_floop - false if pat only needs to be matched in one place

// m_cgroups - total count of groups

// m_cgroups_visible - count of visible groups

// m_flags - the flags

// m_nwidth - width of this pattern

// m_pat - pattern string

// m_subst - substitution string

// m_subst_list - list of substitution nodes

// m_pfirst - ptr to first subexpression to match

// Typedefs: char_type -

// string_type -

// size_type -

// History: 8/14/2000 - ericne - Created

// --------------------------------------------------------------------------

template< typename IterT >

class basic_rpattern_base_impl

{

basic_rpattern_base_impl( basic_rpattern_base_impl const & );

basic_rpattern_base_impl & operator=( basic_rpattern_base_impl const & );

protected:

typedef typename std::iterator_traits::value_type char_type;

typedef std::char_traits traits_type;

typedef std::basic_string string_type;

typedef size_t size_type;

typedef backref_tag backref_type;

typedef std::vector backref_vector;

friend struct regex_access;

explicit basic_rpattern_base_impl

(

REGEX_FLAGS flags = NOFLAGS,

REGEX_MODE mode = MODE_DEFAULT,

string_type const & pat = string_type(),

string_type const & subst = string_type()

) //throw()

: m_arena( DEFAULT_BLOCK_SIZE() )

, m_fuses_backrefs( false )

, m_floop( true )

, m_fok_to_recurse( true )

, m_cgroups( 0 )

, m_cgroups_visible( 0 )

, m_flags( flags )

, m_mode( mode )

, m_nwidth( uninit_width() )

, m_pat( new string_type( pat ) )

, m_subst( new string_type( subst ) )

, m_subst_list()

, m_pfirst( 0 )

, m_invisible_groups()

, m_search( 0 )

{

}

virtual ~basic_rpattern_base_impl()

{

// We're not going to be calling destructors because all allocated

// memory associated with the parsed pattern resides in the arena.

// The memory will be freed when the arena gets destroyed.

//delete m_pfirst;

reset_auto_ptr( m_pat );

reset_auto_ptr( m_subst );

m_arena.finalize();

}

regex_arena m_arena; // The sub_expr arena

bool m_fuses_backrefs; // true if the substitution uses backrefs

bool m_floop; // false if m_pfirst->recursive_match_all only needs to be called once

bool m_fok_to_recurse; // false if the pattern would recurse too deeply

size_t m_cgroups; // number of groups ( always at least one )

size_t m_cgroups_visible; // number of visible groups

REGEX_FLAGS m_flags; // flags used to customize search/replace

REGEX_MODE m_mode; // Used to pick the fast or safe algorithm

width_type m_nwidth; // width of the pattern

std::auto_ptr m_pat; // contains the unparsed pattern

std::auto_ptr m_subst; // contains the unparsed substitution

subst_list_type m_subst_list; // used to speed up substitution

sub_expr_base const * m_pfirst; // first subexpression in pattern

std::list m_invisible_groups; // groups w/o backrefs

boyer_moore * m_search;

size_t _cgroups_total() const //throw()

{

return m_cgroups;

}

bool _loops() const //throw()

{

return m_floop;

}

size_t _get_next_group_nbr()

{

return m_cgroups++;

}

void _normalize_string( string_type & str ) const //throw()

{

if( NORMALIZE & flags() )

process_escapes( str, true );

}

bool _save_backrefs() const //throw()

{

return m_fuses_backrefs || ! ( flags() & NOBACKREFS );

}

sub_expr_base const * _get_first_subexpression() const //throw()

{

return m_pfirst;

}

REGEX_FLAGS flags() const //throw()

{

return m_flags;

}

REGEX_MODE mode() const // throw()

{

return m_mode;

}

width_type get_width() const //throw()

{

return m_nwidth;

}

size_t cgroups() const //throw()

{

return m_cgroups_visible;

}

string_type const & get_pat() const //throw()

{

return *m_pat;

}

string_type const & get_subst() const //throw()

{

return *m_subst;

}

bool _ok_to_recurse() const; //throw();

void swap( basic_rpattern_base_impl & that ); // throw();

enum { npos = static_cast( -1 ) };

static instantiator instantiate()

{

typedef basic_rpattern_base_impl this_type;

return instantiator_helper

(

&this_type::_ok_to_recurse,

&this_type::swap

);

}

};

template< typename IterT >

struct regex_access

{

typedef basic_rpattern_base_impl< IterT > rpattern_type;

typedef typename rpattern_type::size_type size_type;

typedef typename rpattern_type::char_type char_type;

typedef typename rpattern_type::traits_type traits_type;

typedef typename rpattern_type::backref_type backref_type;

static bool _do_match_iterative_helper_s

(

sub_expr_base const * expr,

match_param & param,

IterT icur

);

static bool _do_match_iterative_helper_c

(

sub_expr_base const * expr,

match_param & param,

IterT icur

);

static bool _do_match_recursive_s

(

sub_expr_base const * expr,

match_param & param,

IterT icur

);

static bool _do_match_recursive_c

(

sub_expr_base const * expr,

match_param & param,

IterT icur

);

static bool _do_match_impl

(

rpattern_type const & pat,

match_param & param,

bool const use_null

);

static bool _do_match_with_stack

(

rpattern_type const & pat,

match_param & param,

bool const use_null

);

template< typename Alloc1T, typename Alloc2T >

static void _fixup_backrefs

(

std::vector & rgbackrefs,

std::list const & invisible

)

{

typedef typename std::list::const_iterator iter_type;

// Remove information about the "invisible" groups

if( rgbackrefs[0].matched )

{

size_t dropped = 0;

iter_type const end = invisible.end();

iter_type curr = invisible.begin(), next = invisible.begin();

for( ; end != curr; curr = next, ++dropped )

{

if( end == ++next )

{

std::copy(

rgbackrefs.begin() + *curr + 1,

rgbackrefs.end(),

rgbackrefs.begin() + *curr - dropped );

}

else

{

std::copy(

rgbackrefs.begin() + *curr + 1,

rgbackrefs.begin() + *next,

rgbackrefs.begin() + *curr - dropped );

}

rgbackrefs.resize( rgbackrefs.size() - dropped );

}

else

{

rgbackrefs.resize( rgbackrefs.size() - invisible.size() );

}

template< typename AllocT >

static bool _do_try_match

(

rpattern_type const & pat,

match_param & param,

std::vector & rgbackrefs,

bool const use_null

)

{

bool success;

rgbackrefs.resize( pat._cgroups_total() );

param.m_prgbackrefs = & rgbackrefs[0];

param.m_cbackrefs = rgbackrefs.size();

REGEX_SEH_TRY

{

if( pat._ok_to_recurse() )

{

success = _do_match_impl( pat, param, use_null );

}

else

{

success = _do_match_with_stack( pat, param, use_null );

}

REGEX_SEH_EXCEPT( REGEX_SEH_STACK_OVERFLOW == _exception_code() )

{

// we have overflowed the stack. reset the guard page.

REGEX_RESET_STK_OFLW();

// This match fails silently.

for( size_t i=0; i < param.m_cbackrefs; ++i )

{

param.m_prgbackrefs[i] = static_init::value;

}

success = false;

}

_fixup_backrefs( rgbackrefs, pat.m_invisible_groups );

return success;

}

template< typename AllocT >

static bool _do_match

(

rpattern_type const & pat,

basic_match_results & results,

IterT ibegin,

IterT iend,

bool use_null

)

{

typedef typename basic_match_results::backref_vector backref_vector;

results.m_ibegin = ibegin;

match_param param( ibegin, ibegin, iend, 0, 0 );

if( GLOBAL & pat.flags() ) // do a global find

{

// The NOBACKREFS flag is ignored in the match method.

bool const fAll = ( ALLBACKREFS == ( ALLBACKREFS & pat.flags() ) );

bool const fFirst = ( FIRSTBACKREFS == ( FIRSTBACKREFS & pat.flags() ) );

backref_vector rgtempbackrefs( results.m_rgbackrefs.get_allocator() );

while( _do_try_match( pat, param, results.m_rgbackrefs, use_null ) )

{

backref_type const & br = param.m_prgbackrefs[0];

// Handle specially the backref flags

if( fFirst )

{

rgtempbackrefs.push_back( br );

}

else if( fAll )

{

rgtempbackrefs.insert(

rgtempbackrefs.end(),

results.m_rgbackrefs.begin(),

results.m_rgbackrefs.end() );

}

else

{

rgtempbackrefs.swap( results.m_rgbackrefs );

}

param.m_imatchbegin = br.second;

param.m_no0len = ( br.first == br.second );

}

// restore the backref vectors

results.m_rgbackrefs.swap( rgtempbackrefs );

return ! results.m_rgbackrefs.empty();

}

else

{

return _do_try_match( pat, param, results.m_rgbackrefs, use_null );

}

template< typename AllocT >

static bool _do_match_c

(

rpattern_type const & pat,

basic_match_results & results,

char_type const * szbegin

)

{

if( RIGHTMOST & pat.flags() )

{

// We need to know the end of the string if we're doing a

// RIGHTMOST match.

char_type const * szend = szbegin;

std::advance( szend, traits_type::length( szbegin ) );

return _do_match( pat, results, szbegin, szend, false );

}

else

{

return _do_match( pat, results, szbegin, 0, true );

}

static size_t _do_count

(

rpattern_type const & pat,

IterT ibegin,

IterT iend,

bool use_null

)

{

size_t cmatches = 0;

std::vector rgbackrefs;

// If your compile breaks here, it is because CharT const * is not

// convertible to type IterT. Check the declaration of your rpattern object.

match_param param( ibegin, ibegin, iend, 0, 0 );

while( _do_try_match( pat, param, rgbackrefs, use_null ) )

{

backref_type const & br = param.m_prgbackrefs[0];

++cmatches;

param.m_imatchbegin = br.second;

param.m_no0len = ( br.first == br.second );

}

return cmatches;

}

template< typename CharT, typename TraitsT, typename AllocT >

static size_t _do_split

(

rpattern_type const & pat,

basic_split_results & results,

IterT ibegin,

IterT iend,

int limit,

bool use_null

)

{

typedef typename basic_split_results::string_type string_type;

typedef typename rebind::type backref_allocator;

std::vector rgbackrefs(

convert_allocator( results.strings().get_allocator(), 0 ) );

typedef typename rebind::type char_allocator_type;

char_allocator_type char_allocator =

convert_allocator( results.strings().get_allocator(), 0 );

// reserve some initial space

results.strings().clear();

results.strings().reserve( 10 );

match_param param( ibegin, ibegin, iend, 0, 0 );

while( 1 != limit && _do_try_match( pat, param, rgbackrefs, use_null ) )

{

backref_type const & br = param.m_prgbackrefs[0];

param.m_no0len = ( br.first == br.second );

// discard zero-width matches at the beginning and end of the buffer

if( param.m_no0len )

{

// if we're at the beginning, skip

if( br.first == param.m_ibufferbegin )

continue;

// if we're at the end, break

if( use_null ? 0 == *param.m_imatchbegin : param.m_imatchbegin == param.m_iend )

break;

}

string_type tmp( param.m_imatchbegin, br.first, char_allocator );

results.strings().push_back( tmp );

param.m_imatchbegin = br.second;

// add any groups

for( size_t i = 1; i < rgbackrefs.size(); ++i )

{

backref_type const & br = rgbackrefs[i];

string_type tmp( br.first, br.second, char_allocator );

results.strings().push_back( tmp );

}

if( limit > 0 )

--limit;

}

// append the last string, unless it's empty and limit is 0

if( use_null )

{

if( *param.m_imatchbegin || 0 != limit )

results.strings().push_back( string_type( &*param.m_imatchbegin, char_allocator ) );

}

else

{

if( param.m_imatchbegin != param.m_iend || 0 != limit )

results.strings().push_back( string_type( param.m_imatchbegin, param.m_iend, char_allocator ) );

}

// remove trailing empty fields

if( 0 == limit )

{

while( results.size() && results.back().empty() )

{

results.strings().pop_back();

}

return results.size();

}

template< typename CharT, typename TraitsT, typename AllocT >

static size_t _do_subst_internal

(

std::basic_string & str,

basic_subst_results const & results,

rpattern_type const & pat,

size_type strpos,

size_type strlen

)

{

typedef subst_list_type::const_iterator iter_type;

enum { UPPER = -1, NIL, LOWER } next = NIL, rest = NIL;

bool first = true;

size_t old_strpos = strpos;

typename std::basic_string::iterator itstrlen = str.begin();

std::advance( itstrlen, strpos + strlen );

std::basic_string const & subst = pat.get_subst();

for( iter_type isubst = pat.m_subst_list.begin(); pat.m_subst_list.end() != isubst; ++isubst )

{

size_t sublen = 0;

typename std::basic_string::const_iterator itsubpos1; // iter into str

typename std::basic_string::const_iterator itsublen1;

typename std::basic_string::const_iterator itsubpos2; // iter into subst string

typename std::basic_string::const_iterator itsublen2;

typename std::basic_string::iterator itstrpos = str.begin();

std::advance( itstrpos, strpos );

switch( isubst->m_stype )

{

case subst_node::SUBST_STRING:

itsubpos2 = subst.begin();

std::advance( itsubpos2, isubst->m_subst_string.m_rstart );

itsublen2 = itsubpos2;

std::advance( itsublen2, isubst->m_subst_string.m_rlength );

if( first )

str.replace( itstrpos, itstrlen, itsubpos2, itsublen2 );

else

str.insert( itstrpos, itsubpos2, itsublen2 );

sublen = std::distance( itsubpos2, itsublen2 );

break;

case subst_node::SUBST_BACKREF:

switch( isubst->m_subst_backref )

{

case subst_node::PREMATCH:

itsubpos1 = results.backref_str().begin();

itsublen1 = itsubpos1;

std::advance( itsublen1, sublen = results.rstart() );

break;

case subst_node::POSTMATCH:

itsubpos1 = results.backref_str().begin();

std::advance( itsubpos1, results.rstart() + results.rlength() );

itsublen1 = results.backref_str().end();

break;

default:

itsubpos1 = results.backref_str().begin();

std::advance( itsubpos1, results.rstart( isubst->m_subst_backref ) );

itsublen1 = itsubpos1;

std::advance( itsublen1, results.rlength( isubst->m_subst_backref ) );

break;

}

if( first )

str.replace( itstrpos, itstrlen, itsubpos1, itsublen1 );

else

str.insert( itstrpos, itsubpos1, itsublen1 );

sublen = std::distance( itsubpos1, itsublen1 );

break;

case subst_node::SUBST_OP:

switch( isubst->m_op )

{

case subst_node::UPPER_ON:

rest = UPPER;

break;

case subst_node::UPPER_NEXT:

next = UPPER;

break;

case subst_node::LOWER_ON:

rest = LOWER;

break;

case subst_node::LOWER_NEXT:

next = LOWER;

break;

case subst_node::ALL_OFF:

rest = NIL;

break;

default:

REGEX_ASSERT(false);

break;

}

continue; // jump to the next item in the list

default:

REGEX_ASSERT(false);

break;

}

first = false;

// Are we upper- or lower-casing this string?

if( rest )

{

typename std::basic_string::iterator ibegin = str.begin();

std::advance( ibegin, strpos );

typename std::basic_string::const_iterator iend = ibegin;

std::advance( iend, sublen );

switch( rest )

{

case UPPER:

regex_toupper( ibegin, iend );

break;

case LOWER:

regex_tolower( ibegin, iend );

break;

default:

REGEX_ASSERT(false);

break;

}

// Are we upper- or lower-casing the next character?

if( next )

{

switch( next )

{

case UPPER:

traits_type::assign( str[strpos], regex_toupper( str[strpos] ) );

break;

case LOWER:

traits_type::assign( str[strpos], regex_tolower( str[strpos] ) );

break;

default:

REGEX_ASSERT(false);

break;

}

next = NIL;

}

strpos += sublen;

}

// If *first* is still true, then we never called str.replace, and the substitution

// string is empty. Erase the part of the string that the pattern matched.

if( first )

str.erase( strpos, strlen );

// return length of the substitution

return strpos - old_strpos;

}

template< typename CharT, typename TraitsT, typename AllocT >

static size_t _do_subst

(

rpattern_type const & pat,

std::basic_string & str,

basic_subst_results & results,

size_type pos,

size_type len

)

{

typedef std::basic_string string_type;

typedef typename basic_subst_results::backref_vector backref_vector;

results.m_pbackref_str = pat._save_backrefs() ? &( results.m_backref_str = str ) : &str;

results.m_ibegin = results.m_pbackref_str->begin();

size_t csubst = 0;

size_type stop_offset = results.m_pbackref_str->size();

if( len != rpattern_type::npos )

stop_offset = regex_min( size_t( pos + len ), stop_offset );

match_param param( results.m_ibegin, results.m_ibegin, results.m_ibegin, 0, 0 );

std::advance( param.m_imatchbegin, pos );

std::advance( param.m_iend, stop_offset );

param.m_ibufferbegin = param.m_imatchbegin;

if( GLOBAL & pat.flags() )

{

bool const fAll = ( ALLBACKREFS == ( ALLBACKREFS & pat.flags() ) );

bool const fFirst = ( FIRSTBACKREFS == ( FIRSTBACKREFS & pat.flags() ) );

backref_vector rgtempbackrefs( results.m_rgbackrefs.get_allocator() ); // temporary vector used if fsave_backrefs

size_type pos_offset = 0; // keep track of how much the backref_str and

// the current string are out of sync

while( _do_try_match( pat, param, results.m_rgbackrefs, false ) )

{

backref_type const & br = param.m_prgbackrefs[0];

++csubst;

size_type match_length = std::distance( br.first, br.second );

pos = std::distance( results.m_ibegin, br.first );

size_type subst_length = _do_subst_internal( str, results, pat, pos + pos_offset, match_length );

if( pat._save_backrefs() )

{

pos += match_length;

pos_offset += ( subst_length - match_length );

// Handle specially the backref flags

if( fFirst )

{

rgtempbackrefs.push_back( br );

}

else if( fAll )

{

rgtempbackrefs.insert(

rgtempbackrefs.end(),

results.m_rgbackrefs.begin(),

results.m_rgbackrefs.end() );

}

else

{

rgtempbackrefs.swap( results.m_rgbackrefs );

}

else

{

pos += subst_length;

stop_offset += ( subst_length - match_length );

results.m_ibegin = results.m_pbackref_str->begin();

// we're not saving backref information, so we don't

// need to do any special backref maintenance here

}

// prevent a pattern that matches 0 characters from matching

// again at the same point in the string

param.m_no0len = ( 0 == match_length );

param.m_imatchbegin = results.m_ibegin;

std::advance( param.m_imatchbegin, pos ); // ineffecient for bidirectional iterators.

param.m_iend = results.m_ibegin;

std::advance( param.m_iend, stop_offset ); // ineffecient for bidirectional iterators.

}

// If we did special backref handling, swap the backref vectors

if( pat._save_backrefs() )

{

results.m_rgbackrefs.swap( rgtempbackrefs );

}

else if( ! results.m_rgbackrefs[0].matched )

{

results.m_rgbackrefs.clear();

}

else if( _do_try_match( pat, param, results.m_rgbackrefs, false ) )

{

backref_type const & br = param.m_prgbackrefs[0];

++csubst;

_do_subst_internal(

str, results, pat,

std::distance( results.m_ibegin, br.first ),

std::distance( br.first, br.second ) );

results.m_ibegin = results.m_pbackref_str->begin();

}

if( NOBACKREFS == ( pat.flags() & NOBACKREFS ) )

{

results.m_rgbackrefs.clear();

}

return csubst;

}

static instantiator instantiate()

{

return instantiator_helper

(

®ex_access::_do_match_iterative_helper_s,

®ex_access::_do_match_iterative_helper_c,

®ex_access::_do_match_recursive_s,

®ex_access::_do_match_recursive_c,

®ex_access::_do_match_with_stack,

®ex_access::_do_match_impl

);

}

};

// Some helper functions needed by process_escapes

template< typename CharT >

inline bool regex_isxdigit( CharT ch )

{

return ( REGEX_CHAR(CharT,'0') <= ch && REGEX_CHAR(CharT,'9') >= ch )

|| ( REGEX_CHAR(CharT,'a') <= ch && REGEX_CHAR(CharT,'f') >= ch )

|| ( REGEX_CHAR(CharT,'A') <= ch && REGEX_CHAR(CharT,'F') >= ch );

}

template< typename CharT >

inline int regex_xdigit2int( CharT ch )

{

if( REGEX_CHAR(CharT,'a') <= ch && REGEX_CHAR(CharT,'f') >= ch )

return ch - REGEX_CHAR(CharT,'a') + 10;

if( REGEX_CHAR(CharT,'A') <= ch && REGEX_CHAR(CharT,'F') >= ch )

return ch - REGEX_CHAR(CharT,'A') + 10;

return ch - REGEX_CHAR(CharT,'0');

}

} // namespace detail

// --------------------------------------------------------------------------

// Function: process_escapes

// Description: Turn the escape sequnces /f /n /r /t /v // into their

// ASCII character equivalents. Also, optionally process

// perl escape sequences.

// Returns: void

// Arguments: str - the string to process

// fPattern - true if the string is to be processed as a regex

// Notes: When fPattern is true, the perl escape sequences are not

// processed. If there is an octal or hex excape sequence, we

// don't want to turn it into a regex metacharacter here. We

// leave it unescaped so the regex parser correctly interprests

// it as a character literal.

// History: 8/1/2001 - ericne - Created

// --------------------------------------------------------------------------

template< typename CharT, typename TraitsT, typename AllocT >

inline void process_escapes( std::basic_string & str, bool fPattern ) //throw()

{

typedef typename std::basic_string::size_type size_type;

size_type i = 0;

size_type const npos = std::basic_string::npos;

if( str.empty() )

return;

while( npos != ( i = str.find( REGEX_CHAR(CharT,'//'), i ) ) )

{

if( str.size() - 1 == i )

return;

switch( str[i+1] )

{

case REGEX_CHAR(CharT,'a'):

str.replace( i, 2, 1, REGEX_CHAR(CharT,'/a') );

break;

case REGEX_CHAR(CharT,'b'):

if( ! fPattern )

str.replace( i, 2, 1, REGEX_CHAR(CharT,'/b') );

else

++i;

break;

case REGEX_CHAR(CharT,'e'):

str.replace( i, 2, 1, CharT( 27 ) );

break;

case REGEX_CHAR(CharT,'f'):

str.replace( i, 2, 1, REGEX_CHAR(CharT,'/f') );

break;

case REGEX_CHAR(CharT,'n'):

str.replace( i, 2, 1, REGEX_CHAR(CharT,'/n') );

break;

case REGEX_CHAR(CharT,'r'):

str.replace( i, 2, 1, REGEX_CHAR(CharT,'/r') );

break;

case REGEX_CHAR(CharT,'t'):

str.replace( i, 2, 1, REGEX_CHAR(CharT,'/t') );

break;

case REGEX_CHAR(CharT,'v'):

str.replace( i, 2, 1, REGEX_CHAR(CharT,'/v') );

break;

case REGEX_CHAR(CharT,'//'):

if( fPattern )

{

if( i+3 < str.size() && REGEX_CHAR(CharT,'//') == str[i+2] && REGEX_CHAR(CharT,'//') == str[i+3] )

str.erase( i, 2 );

++i;

}

else

str.erase( i, 1 );

break;

case REGEX_CHAR(CharT,'0'): case REGEX_CHAR(CharT,'1'): case REGEX_CHAR(CharT,'2'): case REGEX_CHAR(CharT,'3'):

case REGEX_CHAR(CharT,'4'): case REGEX_CHAR(CharT,'5'): case REGEX_CHAR(CharT,'6'): case REGEX_CHAR(CharT,'7'):

if( ! fPattern )

{

size_t j=i+2;

CharT ch = CharT( str[i+1] - REGEX_CHAR(CharT,'0') );

for( ; j-i < 4 && j < str.size() && REGEX_CHAR(CharT,'0') <= str[j] && REGEX_CHAR(CharT,'7') >= str[j]; ++j )

ch = CharT( ch * 8 + ( str[j] - REGEX_CHAR(CharT,'0') ) );

str.replace( i, j-i, 1, ch );

}

break;

case REGEX_CHAR(CharT,'x'):

if( ! fPattern )

{

CharT ch = 0;

size_t j=i+2;

for( ; j-i < 4 && j < str.size() && detail::regex_isxdigit( str[j] ); ++j )

ch = CharT( ch * 16 + detail::regex_xdigit2int( str[j] ) );

str.replace( i, j-i, 1, ch );

}

break;

case REGEX_CHAR(CharT,'c'):

if( ! fPattern && i+2 < str.size() )

{

CharT ch = str[i+2];

if( REGEX_CHAR(CharT,'a') <= ch && REGEX_CHAR(CharT,'z') >= ch )

ch = detail::regex_toupper( ch );

str.replace( i, 3, 1, CharT( ch ^ 0x40 ) );

}

break;

default:

if( fPattern )

++i;

else

str.erase( i, 1 );

break;

}

++i;

if( str.size() <= i )

return;

}

#endif

//+---------------------------------------------------------------------------

// Copyright ( C ) Microsoft, 1994 - 2002.

// File: syntax2.cpp

// Contents: data definitions for the syntax modules

// Classes:

// Functions:

// Coupling:

// Notes:

// Author: Eric Niebler ( [email protected] )

// History: 3-29-00 ericne Created

//----------------------------------------------------------------------------

#include "syntax2.h"

namespace regex

{

REGEX_SELECTANY TOKEN const perl_syntax_base::s_rgreg[ UCHAR_MAX + 1 ] =

{

/* 0*/ NO_TOKEN, NO_TOKEN, NO_TOKEN, NO_TOKEN, NO_TOKEN, NO_TOKEN, NO_TOKEN, NO_TOKEN,

/* 8*/ NO_TOKEN, NO_TOKEN, NO_TOKEN, NO_TOKEN, NO_TOKEN, NO_TOKEN, NO_TOKEN, NO_TOKEN,

/* 16*/ NO_TOKEN, NO_TOKEN, NO_TOKEN, NO_TOKEN, NO_TOKEN, NO_TOKEN, NO_TOKEN, NO_TOKEN,

/* 24*/ NO_TOKEN, NO_TOKEN, NO_TOKEN, NO_TOKEN, NO_TOKEN, NO_TOKEN, NO_TOKEN, NO_TOKEN,

/* 32*/ NO_TOKEN, NO_TOKEN, NO_TOKEN, NO_TOKEN, END_LINE, NO_TOKEN, NO_TOKEN, NO_TOKEN,

/* 40*/ BEGIN_GROUP, END_GROUP, NO_TOKEN, NO_TOKEN, NO_TOKEN, NO_TOKEN, MATCH_ANY, NO_TOKEN,

/* 48*/ NO_TOKEN, NO_TOKEN, NO_TOKEN, NO_TOKEN, NO_TOKEN, NO_TOKEN, NO_TOKEN, NO_TOKEN,

/* 56*/ NO_TOKEN, NO_TOKEN, NO_TOKEN, NO_TOKEN, NO_TOKEN, NO_TOKEN, NO_TOKEN, NO_TOKEN,

/* 64*/ NO_TOKEN, NO_TOKEN, NO_TOKEN, NO_TOKEN, NO_TOKEN, NO_TOKEN, NO_TOKEN, NO_TOKEN,

/* 72*/ NO_TOKEN, NO_TOKEN, NO_TOKEN, NO_TOKEN, NO_TOKEN, NO_TOKEN, NO_TOKEN, NO_TOKEN,

/* 80*/ NO_TOKEN, NO_TOKEN, NO_TOKEN, NO_TOKEN, NO_TOKEN, NO_TOKEN, NO_TOKEN, NO_TOKEN,

/* 88*/ NO_TOKEN, NO_TOKEN, NO_TOKEN, BEGIN_CHARSET, ESCAPE, NO_TOKEN, BEGIN_LINE, NO_TOKEN,

/* 96*/ NO_TOKEN, NO_TOKEN, NO_TOKEN, NO_TOKEN, NO_TOKEN, NO_TOKEN, NO_TOKEN, NO_TOKEN,

/*104*/ NO_TOKEN, NO_TOKEN, NO_TOKEN, NO_TOKEN, NO_TOKEN, NO_TOKEN, NO_TOKEN, NO_TOKEN,

/*112*/ NO_TOKEN, NO_TOKEN, NO_TOKEN, NO_TOKEN, NO_TOKEN, NO_TOKEN, NO_TOKEN, NO_TOKEN,

/*120*/ NO_TOKEN, NO_TOKEN, NO_TOKEN, NO_TOKEN, ALTERNATION, NO_TOKEN, NO_TOKEN, NO_TOKEN

// and the rest are 0...

};

REGEX_SELECTANY TOKEN const perl_syntax_base::s_rgescape[ UCHAR_MAX + 1 ] =

{

/* 0*/ NO_TOKEN, NO_TOKEN, NO_TOKEN, NO_TOKEN,

NO_TOKEN, NO_TOKEN, NO_TOKEN, NO_TOKEN,

/* 8*/ NO_TOKEN, NO_TOKEN, NO_TOKEN, NO_TOKEN,

NO_TOKEN, NO_TOKEN, NO_TOKEN, NO_TOKEN,

/* 16*/ NO_TOKEN, NO_TOKEN, NO_TOKEN, NO_TOKEN,

NO_TOKEN, NO_TOKEN, NO_TOKEN, NO_TOKEN,

/* 24*/ NO_TOKEN, NO_TOKEN, NO_TOKEN, NO_TOKEN,

NO_TOKEN, NO_TOKEN, NO_TOKEN, NO_TOKEN,

/* 32*/ NO_TOKEN, NO_TOKEN, NO_TOKEN, NO_TOKEN,

NO_TOKEN, NO_TOKEN, NO_TOKEN, NO_TOKEN,

/* 40*/ NO_TOKEN, NO_TOKEN, NO_TOKEN, NO_TOKEN,

NO_TOKEN, NO_TOKEN, NO_TOKEN, NO_TOKEN,

/* 48*/ NO_TOKEN, NO_TOKEN, NO_TOKEN, NO_TOKEN,

NO_TOKEN, NO_TOKEN, NO_TOKEN, NO_TOKEN,

/* 56*/ NO_TOKEN, NO_TOKEN, NO_TOKEN, NO_TOKEN,

NO_TOKEN, NO_TOKEN, NO_TOKEN, NO_TOKEN,

/* 64*/ NO_TOKEN, ESC_BEGIN_STRING, ESC_NOT_WORD_BOUNDARY, NO_TOKEN,

ESC_NOT_DIGIT, ESC_QUOTE_META_OFF, NO_TOKEN, NO_TOKEN,

/* 72*/ NO_TOKEN, NO_TOKEN, NO_TOKEN, NO_TOKEN,

NO_TOKEN, NO_TOKEN, NO_TOKEN, NO_TOKEN,

/* 80*/ NO_TOKEN, ESC_QUOTE_META_ON, NO_TOKEN, ESC_NOT_SPACE,

NO_TOKEN, NO_TOKEN, NO_TOKEN, ESC_NOT_WORD,

/* 88*/ NO_TOKEN, NO_TOKEN, ESC_END_STRING, NO_TOKEN,

NO_TOKEN, NO_TOKEN, NO_TOKEN, NO_TOKEN,

/* 96*/ NO_TOKEN, NO_TOKEN, ESC_WORD_BOUNDARY, NO_TOKEN,

ESC_DIGIT, NO_TOKEN, NO_TOKEN, NO_TOKEN,

/*104*/ NO_TOKEN, NO_TOKEN, NO_TOKEN, NO_TOKEN,

NO_TOKEN, NO_TOKEN, NO_TOKEN, NO_TOKEN,

/*112*/ NO_TOKEN, NO_TOKEN, NO_TOKEN, ESC_SPACE,

NO_TOKEN, NO_TOKEN, NO_TOKEN, ESC_WORD,

/*120*/ NO_TOKEN, NO_TOKEN, ESC_END_STRING_z, NO_TOKEN,

NO_TOKEN, NO_TOKEN, NO_TOKEN, NO_TOKEN

// and the rest are 0...

};

namespace detail

{

REGEX_SELECTANY extern posix_charset_type const g_rgposix_charsets[] =

{

{ "[:alnum:]", 9 },

{ "[:^alnum:]", 10 },

{ "[:alpha:]", 9 },

{ "[:^alpha:]", 10 },

{ "[:blank:]", 9 },

{ "[:^blank:]", 10 },

{ "[:cntrl:]", 9 },

{ "[:^cntrl:]", 10 },

{ "[:digit:]", 9 },

{ "[:^digit:]", 10 },

{ "[:graph:]", 9 },

{ "[:^graph:]", 10 },

{ "[:lower:]", 9 },

{ "[:^lower:]", 10 },

{ "[:print:]", 9 },

{ "[:^print:]", 10 },

{ "[:punct:]", 9 },

{ "[:^punct:]", 10 },

{ "[:space:]", 9 },

{ "[:^space:]", 10 },

{ "[:upper:]", 9 },

{ "[:^upper:]", 10 },

{ "[:xdigit:]", 10 },

{ "[:^xdigit:]", 11 }

};

REGEX_SELECTANY extern size_t const g_cposix_charsets = ARRAYSIZE( g_rgposix_charsets );

} // namespace detail

} // namespace regex

/***

*resetstk - Recover from Stack overflow.

*Purpose:

* Defines the _resetstkoflw() function.

*******************************************************************************/

#if defined(_MSC_VER) & _MSC_VER < 1300

#include

#define MIN_STACK_REQ_WIN9X 0x11000

#define MIN_STACK_REQ_WINNT 0x2000

#ifdef _WIN64

typedef unsigned __int64 REGEX_DWORD_PTR;

#else

typedef unsigned __int32 REGEX_DWORD_PTR;

#endif

struct osplatform_getter

{

int m_osplatform;

osplatform_getter() : m_osplatform( 0 )

{

OSVERSIONINFOA osvi;

osvi.dwOSVersionInfoSize = sizeof(OSVERSIONINFOA);

if( GetVersionExA( & osvi ) )

m_osplatform = osvi.dwPlatformId;

}

};

inline int get_osplatform()

{

static osplatform_getter const s_osplatform_getter;

return s_osplatform_getter.m_osplatform;

};

/***

* void _resetstkoflw(void) - Recovers from Stack Overflow

* Purpose:

* Sets the guard page to its position before the stack overflow.

* Exit:

* Returns nonzero on success, zero on failure

*******************************************************************************/

extern "C" int __cdecl _resetstkoflw(void)

{

LPBYTE pStack, pGuard, pStackBase, pMinGuard;

MEMORY_BASIC_INFORMATION mbi;

SYSTEM_INFO si;

DWORD PageSize;

DWORD flNewProtect;

DWORD flOldProtect;

// Use _alloca() to get the current stack pointer

pStack = static_cast( _alloca(1) );

// Find the base of the stack.

if (VirtualQuery(pStack, &mbi, sizeof mbi) == 0)

return 0;

pStackBase = static_cast( mbi.AllocationBase );

// Find the page just below where the stack pointer currently points.

// This is the new guard page.

GetSystemInfo(&si);

PageSize = si.dwPageSize;

pGuard = (LPBYTE) (((REGEX_DWORD_PTR)pStack & ~(REGEX_DWORD_PTR)(PageSize - 1))

- PageSize);

// If the potential guard page is too close to the start of the stack

// region, abandon the reset effort for lack of space. Win9x has a

// larger reserved stack requirement.

pMinGuard = pStackBase + ((get_osplatform() == VER_PLATFORM_WIN32_WINDOWS)

? MIN_STACK_REQ_WIN9X

: MIN_STACK_REQ_WINNT);

if (pGuard < pMinGuard)

return 0;

// On a non-Win9x system, release the stack region below the new guard

// page. This can't be done for Win9x because of OS limitations.

if (get_osplatform() != VER_PLATFORM_WIN32_WINDOWS) {

if (pGuard > pStackBase)

VirtualFree(pStackBase, pGuard - pStackBase, MEM_DECOMMIT);

VirtualAlloc(pGuard, PageSize, MEM_COMMIT, PAGE_READWRITE);

}

// Enable the new guard page.

flNewProtect = get_osplatform() == VER_PLATFORM_WIN32_WINDOWS

? PAGE_NOACCESS

: PAGE_READWRITE | PAGE_GUARD;

return VirtualProtect(pGuard, PageSize, flNewProtect, &flOldProtect);

}

#endif

//+---------------------------------------------------------------------------

// Copyright ( C ) Microsoft, 1994 - 2002.

// File: regexpr2.h

// Contents: classes for regular expression pattern matching a-la perl

// Classes: basic_rpattern_base

// Functions: rpattern::match

// rpattern::substitute

// match_results::cbackrefs

// match_results::backref

// match_results::all_backrefs

// match_results::backref_str

// Author: Eric Niebler ( [email protected] )

//----------------------------------------------------------------------------

#ifndef REGEXPR_H

#define REGEXPR_H

#ifdef _MSC_VER

// warning C4189: local variable is initialized but not referenced

// warning C4290: C++ exception specification ignored except to indicate a function is not __declspec(nothrow)

// warning C4702: unreachable code

// warning C4710: function 'blah' not inlined

// warning C4786: identifier was truncated to '255' characters in the debug information

# pragma warning( push )

# pragma warning( disable : 4189 4290 4702 4710 4786 )

# define REGEX_SEH_STACK_OVERFLOW 0xC00000FDL

# if 1200 < _MSC_VER

# include // for _resetstkoflw

# else

extern "C" int __cdecl _resetstkoflw(void);

# endif

extern "C" unsigned long __cdecl _exception_code(void);

#endif

#include

#include "syntax2.h"

#include "restack.h"

namespace regex

{

// This is the default alignment for the unsafe heterogeneous stack.

// If you are getting a compiler error in one of the unsafe_stack

// methods, then compile with -DREGEX_STACK_ALIGNMENT=16 or 32

#ifndef REGEX_STACK_ALIGNMENT

# define REGEX_STACK_ALIGNMENT sizeof( void* )

#endif

#if !defined( REGEX_DEBUG ) & ( defined( DEBUG ) | defined( _DEBUG ) | defined( DBG ) )

# define REGEX_DEBUG 1

#else

# define REGEX_DEBUG 0

#endif

#if !defined( REGEX_DEBUG_ITERATORS ) & defined( _HAS_ITERATOR_DEBUGGING )

# define REGEX_DEBUG_ITERATORS 1

#else

# define REGEX_DEBUG_ITERATORS 0

#endif

namespace detail

{

#if REGEX_DEBUG | REGEX_DEBUG_ITERATORS

// Turn on hetero_stack's run-time type checking

typedef hetero_stack unsafe_stack;

#else

// Assume that all types pushed on stack have trivial destructors.

typedef hetero_stack unsafe_stack;

#endif

// Used to initialize variables with the same value they would have

// if they were initialized as a static global. ( Ptrs get NULL,

// integer types get 0, etc, etc )

template< typename T > struct static_init { static T const value; };

template< typename T > T const static_init::value = T();

// Forward declarations

template< typename IterT > class sub_expr;

template< typename IterT > class match_group_base;

template< typename IterT > class basic_rpattern_base_impl;

template< typename IterT > struct match_param;

template< typename IterT > struct sub_expr_base;

template< typename IterT > struct regex_access;

// an iterator that keeps track of whether it is singular or not.

template< typename IterT > struct smart_iter

{

IterT m_iter;

bool m_valid;

smart_iter()

: m_iter( static_init::value )

, m_valid( false )

{

}

smart_iter( smart_iter const & rhs )

: m_iter( rhs.m_iter )

, m_valid( rhs.m_valid )

{

}

smart_iter( IterT iter ) // implicit conversion OK!

: m_iter( iter )

, m_valid( true )

{

}

smart_iter & operator=( smart_iter const & rhs )

{

m_iter = rhs.m_iter;

m_valid = rhs.m_valid;

return *this;

}

friend bool operator==( smart_iter const & lhs, smart_iter const & rhs )

{

if( !lhs.m_valid || !rhs.m_valid )

return lhs.m_valid == rhs.m_valid;

else

return lhs.m_iter == rhs.m_iter;

}

friend bool operator!=( smart_iter const & lhs, smart_iter const & rhs )

{

return ! operator==( lhs, rhs );

}

};

template< typename IterT > struct iter_select

{

typedef typename select

REGEX_DEBUG_ITERATORS && !is_scalar::value,

smart_iter,

IterT

>::type type;

};

template< int SizeT > struct type_with_size { char buffer[ SizeT ]; };

// make up for the fact that the VC6 std::allocator does

// not have template constructors

template< typename ToT, typename FromT >

std::allocator convert_allocator( std::allocator, int )

{

return std::allocator();

}

template< typename ToT, typename FromT >

FromT const & REGEX_CDECL convert_allocator( FromT const & from, ... )

{

return from;

}

template< int > struct rebind_helper;

// unknown allocator

template< typename T >

type_with_size<1> REGEX_CDECL allocator_picker( T const &, ... );

template<> struct rebind_helper<1>

{

template< typename AllocT, typename ElemT >

struct inner

{

REGEX_NVC6( typedef typename AllocT::template rebind::other type; )

};

// std::allocator

template< typename T >

type_with_size<2> allocator_picker( std::allocator const &, int );

template<> struct rebind_helper<2>

{

template< typename, typename ElemT >

struct inner

{

typedef std::allocator type;

};

template< typename AllocT, typename ElemT >

struct rebind

{

enum { alloc_type = sizeof(allocator_picker(factory::make(),0)) };

typedef typename rebind_helper::template inner::type type;

};

}

// --------------------------------------------------------------------------

// Class: width_type

// Description: represents the width of a sub-expression

// Members: m_min - smallest number of characters a sub-expr can span

// m_max - largest number of characters a sub-expr can span

// History: 8/14/2000 - ericne - Created

// --------------------------------------------------------------------------

struct width_type

{

size_t m_min;

size_t m_max;

};

inline width_type const uninit_width()

{

width_type const width = { size_t( -1 ), size_t( -1 ) };

return width;

}

// Helper function for processing escape sequences

template< typename CharT, typename TraitsT, typename AllocT >

void process_escapes( std::basic_string & str, bool fPattern = false ); //throw()

// --------------------------------------------------------------------------

// Class: backref_tag

// Description: Struct which contains a back-reference. It is a template

// on the iterator type.

// Methods: backref_tag - c'tor

// operator bool - so that if( br ) is true if this br matched

// operator! - inverse of operator bool()

// Members: reserved - move along, nothing to see here

// History: 8/9/2001 - ericne - Created

// --------------------------------------------------------------------------

template< typename IterT >

class backref_tag : public std::pair

{

struct detail_t { detail_t * d; };

template< typename OStreamT, typename OtherT >

void REGEX_CDECL _do_print( OStreamT & sout, OtherT, ... ) const

{

typedef typename OStreamT::char_type char_type;

typedef typename OStreamT::traits_type traits_type;

std::ostreambuf_iterator iout( sout );

for( IterT iter = first; iter != second; ++iter, ++iout )

*iout = *iter;

}

// overload that is optimized for bare char*

template< typename OStreamT >

void _do_print( OStreamT & sout, typename OStreamT::char_type const *, int ) const

{

sout.write( first, static_cast( std::distance( first, second ) ) );

}

public:

typedef IterT iterator_type;

typedef typename std::iterator_traits::value_type char_type;

typedef std::basic_string string_type;

typedef typename detail::iter_select::type smart_iter_type;

explicit backref_tag

(

IterT i1 = detail::static_init::value,

IterT i2 = detail::static_init::value

)

: std::pair( i1, i2 )

, matched( false )

, reserved1( i1 )

, reserved2( 0 )

, reserved3( false )

, reserved4( detail::static_init::value )

, reserved5( detail::static_init::value )

{

}

IterT begin() const

{

return first;

}

IterT end() const

{

return second;

}

string_type const str() const

{

return matched ? string_type( first, second ) : string_type();

}

// Use the "safe bool" idiom. This allows implicit conversion to bool,

// but not to int. It also disallows conversion to void*.

typedef detail_t * detail_t::* bool_type;

operator bool_type() const //throw()

{

return matched ? &detail_t::d : 0;

}

bool operator!() const //throw()

{

return ! matched;

}

template< typename CharT, typename TraitsT >

std::basic_ostream & print( std::basic_ostream & sout ) const

{

_do_print( sout, IterT(), 0 );

return sout;

}

bool matched;

//private:

IterT reserved1; // used for internal book-keeping

size_t reserved2; // used for internal book-keeping

bool reserved3; // used for internal book-keeping

smart_iter_type reserved4; // used for internal book-keeping

smart_iter_type reserved5; // used for internal book-keeping

};

//namespace detail

//{

// indexing into the backref vector is faster if the backref_tag struct

// has a size that is a power of 2.

//static static_assert<32==sizeof(backref_tag)> const check_backref_size;

//}

// --------------------------------------------------------------------------

// Class: basic_match_results

// Description: Use this structure for returning match/substitute results

// out from the match()/substitute() methods.

// Methods: cbackrefs -

// backref -

// all_backrefs -

// rlength -

// Members: m_rgbackrefs -

// Typedefs: const_iterator -

// backref_type -

// backref_vector -

// History: 8/8/2001 - ericne - Created

// --------------------------------------------------------------------------

template

typename IterT,

typename AllocT = std::allocator< REGEX_DEPENDENT_TYPENAME std::iterator_traits::value_type >

struct basic_match_results

{

// const_iterator is deprecated. Use iterator_type instead.

REGEX_DEPRECATED typedef IterT const_iterator;

typedef IterT iterator_type;

typedef backref_tag backref_type;

typedef typename detail::rebind::type allocator_type;

typedef std::vector backref_vector;

friend struct detail::regex_access;

explicit basic_match_results( allocator_type const & alloc = allocator_type() )

: m_rgbackrefs( alloc )

{

}

virtual ~basic_match_results()

{

}

size_t cbackrefs() const //throw()

{

return m_rgbackrefs.size();

}

backref_type const & backref( size_t cbackref ) const //throw( std::out_of_range )

{

return m_rgbackrefs.at( cbackref );

}

backref_vector const & all_backrefs() const //throw()

{

return m_rgbackrefs;

}

size_t rstart( size_t cbackref = 0 ) const //throw( std::out_of_range )

{

return std::distance( m_ibegin, m_rgbackrefs.at( cbackref ).first );

}

size_t rlength( size_t cbackref = 0 ) const //throw( std::out_of_range )

{

return std::distance( m_rgbackrefs.at( cbackref ).first, m_rgbackrefs.at( cbackref ).second );

}

private:

backref_vector m_rgbackrefs;

IterT m_ibegin;

};

// Unnecessary and deprecated

template< typename CharT, typename AllocT = std::allocator >

struct basic_match_results_c : public basic_match_results

{

typedef basic_match_results base;

REGEX_DEPRECATED typedef typename base::const_iterator const_iterator;

typedef typename base::iterator_type iterator_type;

typedef typename base::backref_type backref_type;

typedef typename base::allocator_type allocator_type;

typedef typename base::backref_vector backref_vector;

explicit basic_match_results_c( allocator_type const & alloc = allocator_type() )

: basic_match_results( alloc )

{

}

};

template< typename CharT, typename TraitsT, typename AllocT >

struct subst_results_base

{

typedef typename detail::rebind::type char_allocator_type;

typedef std::basic_string string_type;

typedef typename string_type::const_iterator iterator_type;

typedef basic_match_results type;

};

// For storing the results of a substitute() operation

template

typename CharT,

typename TraitsT = std::char_traits,

typename AllocT = std::allocator

struct basic_subst_results : public subst_results_base::type

{

typedef typename detail::rebind::type char_allocator_type;

typedef std::basic_string string_type;

typedef typename string_type::const_iterator iterator_type;

typedef basic_match_results base;

typedef typename base::backref_type backref_type;

typedef typename base::allocator_type allocator_type;

typedef typename base::backref_vector backref_vector;

friend struct detail::regex_access;

explicit basic_subst_results( allocator_type const & alloc = allocator_type() )

: basic_match_results< iterator_type, AllocT >( alloc )

, m_backref_str( detail::convert_allocator( alloc, 0 ) )

, m_pbackref_str( &m_backref_str )

{

}

string_type const & backref_str() const //throw()

{

return *m_pbackref_str;

}

private:

string_type m_backref_str;

string_type const * m_pbackref_str;

};

template< typename CharT, typename TraitsT, typename AllocT >

struct split_results_base

{

typedef typename detail::rebind::type char_allocator_type;

typedef std::basic_string string_type;

typedef typename detail::rebind::type allocator_type;

typedef std::vector type;

};

// For storing the results of a split() operation

template

typename CharT,

typename TraitsT = std::char_traits,

typename AllocT = std::allocator

struct basic_split_results : private split_results_base::type

{

typedef CharT char_type;

typedef typename detail::rebind::type char_allocator_type;

typedef std::basic_string string_type;

typedef typename detail::rebind::type allocator_type;

typedef std::vector string_vector;

typedef string_vector base;

explicit basic_split_results( allocator_type const & alloc = allocator_type() )

: base( alloc )

{

}

#if !defined(_MSC_VER) | 1200 < _MSC_VER

typedef typename allocator_type::pointer pointer;

typedef typename allocator_type::const_pointer const_pointer;

#else

typedef string_type * pointer;

typedef string_type const * const_pointer;

#endif

// shortcuts to the most basic read-only container operations

typedef typename base::size_type size_type;

typedef typename base::difference_type difference_type;

typedef typename base::value_type value_type;

typedef typename base::reference reference;

typedef typename base::const_reference const_reference;

typedef typename base::iterator iterator;

typedef typename base::const_iterator const_iterator;

typedef typename base::reverse_iterator reverse_iterator;

typedef typename base::const_reverse_iterator const_reverse_iterator;

using base::begin;

using base::end;

using base::rbegin;

using base::rend;

using base::operator[];

using base::at;

using base::size;

using base::front;

using base::back;

string_vector & strings()

{

return *this;

}

string_vector const & strings() const

{

return *this;

}

};

// The REGEX_MODE is a way of controlling how matching occurs.

enum REGEX_MODE

{

MODE_FAST, // Uses the fast, recursive algorithm. Could overflow stack.

MODE_SAFE, // Uses the slow, iterative algorithm. Can't overflow stack.

MODE_MIXED, // Uses a heuristic to automatically determine which algorithm

// is the most appropriate for this pattern.

// MS VC++ has structured exception handling, which makes the

// consequences of a stack overflow much less severe. Because of this,

// it is possible to use the "fast" algorithm always on MS platforms,

#ifdef _MSC_VER

MODE_DEFAULT = MODE_FAST

#else

MODE_DEFAULT = MODE_MIXED

#endif

};

// helper function for resetting the intrinsic character sets.

// This should be called after changing the locale with setlocale()

template< typename CharT >

void reset_intrinsic_charsets( CharT ch = CharT( 0 ) );

// This is for implementation details that really belong in the

// cpp file, but can't go there because of template strangeness.

#include "reimpl2.h"

// --------------------------------------------------------------------------

// Class: basic_rpattern_base

// Description:

// Methods: basic_rpattern_base - c'tor

// basic_rpattern_base -

// init - ( re )initialize the pattern

// init -

// set_substitution - set the substitution string

// _find_next_group - parse the next group of the pattern

// _find_next - parse the next sub_expr of the pattern

// _find_atom - parse the next atom of the pattern

// _quantify - quantify the sub_expr

// _common_init - perform some common initialization tasks

// _parse_subst - parse the substitution string

// _add.m_subst_backref - add a backref node to the subst list

// Members: m_invisible_groups - list of hidden groups

// Typedefs: syntax_type -

// backref_type -

// backref_vector -

// string_type -

// size_type -

// History: 8/14/2000 - ericne - Created

// 8/5/2001 - ericne - complete overhaul

// --------------------------------------------------------------------------

template< typename IterT, typename SyntaxT >

class basic_rpattern_base : protected detail::basic_rpattern_base_impl

{

protected:

typedef detail::basic_rpattern_base_impl impl;

public:

typedef SyntaxT syntax_type;

typedef typename impl::char_type char_type;

typedef typename impl::traits_type traits_type;

typedef typename impl::string_type string_type;

typedef typename impl::size_type size_type;

typedef typename impl::backref_type backref_type;

typedef typename impl::backref_vector backref_vector;

void init

(

string_type const & pat,

REGEX_FLAGS flags = NOFLAGS,

REGEX_MODE mode = MODE_DEFAULT

); //throw( bad_regexpr, std::bad_alloc );

void init

(

string_type const & pat,

string_type const & subst,

REGEX_FLAGS flags = NOFLAGS,

REGEX_MODE mode = MODE_DEFAULT

); //throw( bad_regexpr, std::bad_alloc );

void set_substitution

(

string_type const & subst

); //throw( bad_regexpr, std::bad_alloc );

using impl::flags;

using impl::mode;

using impl::get_width;

using impl::cgroups;

using impl::get_pat;

using impl::get_subst;

using impl::swap;

using impl::npos;

protected:

basic_rpattern_base() //throw()

: detail::basic_rpattern_base_impl()

{

}

basic_rpattern_base( basic_rpattern_base const & that ) //throw()

: detail::basic_rpattern_base_impl( that.flags(), that.mode(), that.get_pat(), that.get_subst() )

{

// Don't call _normalize_string(). If that.flags()&NORMALIZE,

// then subst has already been normalized.

_common_init( this->m_flags );

_parse_subst( *this->m_subst, this->m_fuses_backrefs, this->m_subst_list ); // must come after _common_init

}

explicit basic_rpattern_base

(

string_type const & pat,

REGEX_FLAGS flags = NOFLAGS,

REGEX_MODE mode = MODE_DEFAULT

) //throw( bad_regexpr, std::bad_alloc )

: detail::basic_rpattern_base_impl( flags, mode, pat )

{

_common_init( this->m_flags );

}

basic_rpattern_base

(

string_type const & pat,

string_type const & subst,

REGEX_FLAGS flags = NOFLAGS,

REGEX_MODE mode = MODE_DEFAULT

) //throw( bad_regexpr, std::bad_alloc )

: detail::basic_rpattern_base_impl( flags, mode, pat, subst )

{

_common_init( this->m_flags );

_normalize_string( *this->m_subst );

_parse_subst( *this->m_subst, this->m_fuses_backrefs, this->m_subst_list ); // must come after _common_init

}

basic_rpattern_base & operator=

(

basic_rpattern_base const & that

) //throw( bad_regexpr, std::bad_alloc )

{

basic_rpattern_base temp( that );

swap( temp );

return *this;

}

detail::match_group_base * _find_next_group

(

typename string_type::iterator & ipat,

detail::match_group_base * pgroup, syntax_type & sy,

std::vector*> & rggroups

);

bool _find_next

(

typename string_type::iterator & ipat,

detail::match_group_base * pgroup, syntax_type & sy,

std::vector*> & rggroups

);

void _find_atom

(

typename string_type::iterator & ipat,

detail::match_group_base * pgroup,

syntax_type & sy

);

void _quantify

(

std::auto_ptr > & pnew,

typename string_type::iterator & ipat,

bool is_group,

syntax_type & sy

);

void _add_subst_backref

(

detail::subst_node & snode,

size_t nbackref,

ptrdiff_t rstart,

bool & uses_backrefs,

detail::subst_list_type & subst_list

) const;

void _parse_subst

(

string_type & subst,

bool & uses_backrefs,

detail::subst_list_type & subst_list

) const;

void _common_init( REGEX_FLAGS flags );

static detail::instantiator instantiate()

{

typedef basic_rpattern_base this_type;

return detail::instantiator_helper

(

&detail::basic_rpattern_base_impl::instantiate,

static_cast( &this_type::init ),

&this_type::set_substitution,

&this_type::_find_next_group,

&this_type::_find_next,

&this_type::_find_atom,

&this_type::_add_subst_backref,

&this_type::_parse_subst,

&this_type::_common_init

);

}

};

// --------------------------------------------------------------------------

// Class: basic_rpattern

// Description: generic regex pattern object

// Methods: basic_rpattern - c'tor

// basic_rpattern -

// match - match from begin iter to end iter

// match - match a null-terminated string

// match - match a std::string

// count - count matches from begin iter to end iter

// count - count matches in a null-terminated string

// count - count matches in a std::string

// substitute - do substitutions in a std::string

// _do_match - internal implementation

// _do_count - internal implementation

// History: 8/13/2001 - ericne - Created

// --------------------------------------------------------------------------

template

typename IterT,

typename SyntaxT = perl_syntax::value_type>

class basic_rpattern : public basic_rpattern_base

{

typedef detail::basic_rpattern_base_impl impl;

template< typename CharT >

static void same_char_types( CharT, CharT ) {}

public:

typedef typename basic_rpattern_base::syntax_type syntax_type;

typedef typename basic_rpattern_base::char_type char_type;

typedef typename basic_rpattern_base::traits_type traits_type;

typedef typename basic_rpattern_base::string_type string_type;

typedef typename basic_rpattern_base::size_type size_type;

typedef typename basic_rpattern_base::backref_type backref_type;

typedef typename basic_rpattern_base::backref_vector backref_vector;

basic_rpattern() //throw()

: basic_rpattern_base()

{

}

basic_rpattern( basic_rpattern const & that )

: basic_rpattern_base( that )

{

}

explicit basic_rpattern

(

string_type const & pat,

REGEX_FLAGS flags = NOFLAGS,

REGEX_MODE mode = MODE_DEFAULT

) //throw( bad_regexpr, std::bad_alloc )

: basic_rpattern_base( pat, flags, mode )

{

}

basic_rpattern

(

string_type const & pat,

string_type const & subst,

REGEX_FLAGS flags = NOFLAGS,

REGEX_MODE mode = MODE_DEFAULT

) //throw( bad_regexpr, std::bad_alloc )

: basic_rpattern_base( pat, subst, flags, mode )

{

}

basic_rpattern & operator=( basic_rpattern const & that ) //throw( bad_regexpr, std::bad_alloc )

{

basic_rpattern_base::operator=( that );

return *this;

}

// Iter2 must be convertible to type IterT

template< typename OtherT, typename AllocT >

backref_type const & match

(

OtherT ibegin,

OtherT iend,

basic_match_results & results

) const

{

// If your compile breaks here, it is because OtherT is not

// convertible to type IterT. Check the declaration of your rpattern object.

detail::static_assert< detail::is_convertible::value > const iterator_types_are_not_convertible;

( void ) iterator_types_are_not_convertible;

if( detail::regex_access::_do_match( *this, results, ibegin, iend, false ) )

{

return results.backref(0);

}

else

{

return detail::static_init::value;

}

template< typename CharT, typename AllocT >

backref_type const & match

(

CharT * szbegin,

basic_match_results & results

) const

{

// If your compile breaks here, it is because CharT* is not

// convertible to type IterT. Check the declaration of your rpattern object.

detail::static_assert< detail::is_convertible::value > const iterator_types_are_not_convertible;

( void ) iterator_types_are_not_convertible;

if( detail::regex_access::_do_match_c( *this, results, szbegin ) )

{

return results.backref(0);

}

else

{

return detail::static_init::value;

}

template< typename CharT, typename TraitsT, typename AllocT >

backref_type const & match

(

std::basic_string const & str,

basic_match_results & results,

size_type pos = 0,

size_type len = static_cast(-1)

) const

{

// If your compile breaks here, it is because iter_type is not

// convertible to type IterT. Check the declaration of your rpattern object.

typedef typename std::basic_string::const_iterator iter_type;

detail::static_assert< detail::is_convertible::value > const iterator_types_are_not_convertible;

( void ) iterator_types_are_not_convertible;

IterT ibegin = str.begin(), iend = str.begin();

if( len == npos || pos + len >= str.size() )

iend = IterT(str.end());

else

std::advance( iend, pos + len );

std::advance( ibegin, pos );

return match( ibegin, iend, results );

}

template< typename OtherT >

size_t count( OtherT ibegin, OtherT iend ) const

{

// If your compile breaks here, it is because OtherT is not

// convertible to type IterT. Check the declaration of your rpattern object.

detail::static_assert< detail::is_convertible::value > const iterator_types_are_not_convertible;

( void ) iterator_types_are_not_convertible;

return detail::regex_access::_do_count( *this, ibegin, iend, false );

}

template< typename CharT >

size_t count( CharT * szbegin ) const

{

// If your compile breaks here, it is because CharT* is not

// convertible to type IterT. Check the declaration of your rpattern object.

detail::static_assert< detail::is_convertible::value > const iterator_types_are_not_convertible;

( void ) iterator_types_are_not_convertible;

return detail::regex_access::_do_count( *this, szbegin, (CharT*)0, true );

}

template< typename CharT, typename TraitsT, typename AllocT >

size_t count

(

std::basic_string const & str,

size_type pos = 0,

size_type len = static_cast(-1)

) const

{

// If your compile breaks here, it is because iter_type is not

// convertible to type IterT. Check the declaration of your rpattern object.

typedef typename std::basic_string::const_iterator iter_type;

detail::static_assert< detail::is_convertible::value > const iterator_types_are_not_convertible;

( void ) iterator_types_are_not_convertible;

IterT ibegin = str.begin(), iend = str.begin();

if( len == npos || pos + len >= str.size() )

iend = IterT(str.end());

else

std::advance( iend, pos + len );

std::advance( ibegin, pos );

return count( ibegin, iend );

}

template< typename OtherT, typename CharT, typename TraitsT, typename AllocT >

size_t split

(

OtherT ibegin,

OtherT iend,

basic_split_results & results,

int limit = 0

) const

{

// If your compile breaks here, it is because OtherT is not

// convertible to type IterT. Check the declaration of your rpattern object.

detail::static_assert< detail::is_convertible::value > const iterator_types_are_not_convertible;

( void ) iterator_types_are_not_convertible;

return detail::regex_access::_do_split( *this, results, ibegin, iend, limit, false );

}

template< typename Char1T, typename Char2T, typename TraitsT, typename AllocT >

size_t split

(

Char1T * szbegin,

basic_split_results & results,

int limit = 0

) const

{

// If your compile breaks here, it is because Iter2 is not

// convertible to type IterT. Check the declaration of your rpattern object.

detail::static_assert< detail::is_convertible::value > const iterator_types_are_not_convertible;

( void ) iterator_types_are_not_convertible;

// If your compile breaks here, it's because the string you passed in doesn't have

// the same character type as your split_results struct

same_char_types( Char1T(), Char2T() );

// If your compile breaks here, it is because CharT const * is not

// convertible to type IterT. Check the declaration of your rpattern object.

return detail::regex_access::_do_split( *this, results, szbegin, (Char1T*)0, limit, true );

}

template< typename CharT, typename TraitsT, typename AllocT >

size_t split

(

std::basic_string const & str,

basic_split_results & results,

int limit = 0,

size_type pos = 0,

size_type len = static_cast(-1)

) const

{

// If your compile breaks here, it is because iter_type is not

// convertible to type IterT. Check the declaration of your rpattern object.

typedef typename std::basic_string::const_iterator iter_type;

detail::static_assert< detail::is_convertible::value > const iterator_types_are_not_convertible;

( void ) iterator_types_are_not_convertible;

IterT ibegin = str.begin(), iend = str.begin();

if( len == npos || pos + len >= str.size() )

iend = IterT(str.end());

else

std::advance( iend, pos + len );

std::advance( ibegin, pos );

return split( ibegin, iend, results, limit );

}

template< typename CharT, typename TraitsT, typename AllocT >

size_t substitute

(

std::basic_string & str,

basic_subst_results & results,

size_type pos = 0,

size_type len = static_cast(-1)

) const

{

// If your compile breaks here, it is because iter_type is not

// convertible to type IterT. Check the declaration of your rpattern object.

typedef typename std::basic_string::const_iterator iter_type;

detail::static_assert< detail::is_convertible::value > const iterator_types_are_not_convertible;

( void ) iterator_types_are_not_convertible;

return detail::regex_access::_do_subst( *this, str, results, pos, len );

}

};

// --------------------------------------------------------------------------

// Class: basic_rpattern_c

// Description: a pattern object optimized for matching C-style, NULL-

// terminated strings. It treats the null-terminator as

// the end-of-string condition.

// Methods: basic_rpattern_c - c'tor

// basic_rpattern_c -

// match - match a null-terminated string

// count - count matches in a null-terminated string

// _do_match_c - internal implementation

// History: 8/13/2001 - ericne - Created

// --------------------------------------------------------------------------

template< typename CharT, typename SyntaxT = perl_syntax >

class basic_rpattern_c : public basic_rpattern_base

{

typedef detail::basic_rpattern_base_impl impl;

public:

typedef typename basic_rpattern_base::syntax_type syntax_type;

typedef typename basic_rpattern_base::char_type char_type;

typedef typename basic_rpattern_base::traits_type traits_type;

typedef typename basic_rpattern_base::string_type string_type;

typedef typename basic_rpattern_base::size_type size_type;

typedef typename basic_rpattern_base::backref_type backref_type;

typedef typename basic_rpattern_base::backref_vector backref_vector;

basic_rpattern_c() //throw()

: basic_rpattern_base()

{

}

basic_rpattern_c( basic_rpattern_c const & that )

: basic_rpattern_base( that )

{

}

explicit basic_rpattern_c

(

string_type const & pat,

REGEX_FLAGS flags = NOFLAGS,

REGEX_MODE mode = MODE_DEFAULT

) //throw( bad_regexpr, std::bad_alloc )

: basic_rpattern_base( pat, flags, mode )

{

}

basic_rpattern_c & operator=( basic_rpattern_c const & that )

{

basic_rpattern_base::operator=( that );

return *this;

}

template< typename AllocT >

backref_type const & match

(

CharT const * szbegin,

basic_match_results_c & results

) const

{

if( detail::regex_access::_do_match_c( *this, results, szbegin ) )

{

return results.backref(0);

}

else

{

return detail::static_init::value;

}

size_t count( CharT const * szbegin ) const

{

return detail::regex_access::_do_count( *this, szbegin, (CharT const*)0, true );

}

};

#if defined(UNICODE) | defined(_UNICODE)

typedef wchar_t rechar_t;

#else

typedef char rechar_t;

#endif

typedef std::basic_string restring;

// On many implementations of the STL, string::iterator is not a typedef

// for char*. Rather, it is a wrapper class. As a result, the regex code

// gets instantiated twice, once for bare pointers (rpattern_c) and once for

// the wrapped pointers (rpattern). But if there is a conversion from the

// bare ptr to the wrapped ptr, then we only need to instantiate the template

// for the wrapped ptr, and the code will work for the bare ptrs, too.

// This can be a significant space savings. The REGEX_FOLD_INSTANTIONS

// macro controls this optimization. The default is "off" for backwards

// compatibility. To turn the optimization on, compile with:

// -DREGEX_FOLD_INSTANTIATIONS=1

#ifndef REGEX_FOLD_INSTANTIATIONS

#define REGEX_FOLD_INSTANTIATIONS 0

#endif

typedef ::regex::detail::select

REGEX_FOLD_INSTANTIATIONS &&

detail::is_convertible::value,

restring::const_iterator,

rechar_t const *

>::type lpctstr_t;

// For matching against null-terminated strings

typedef basic_rpattern > perl_rpattern_c;

typedef basic_rpattern > posix_rpattern_c;

// For matching against std::strings

typedef basic_rpattern > perl_rpattern;

typedef basic_rpattern > posix_rpattern;

// Default to perl syntax

typedef perl_rpattern rpattern;

typedef perl_rpattern_c rpattern_c;

// typedefs for the commonly used match_results and subst_results

typedef basic_match_results match_results;

typedef basic_match_results match_results_c;

typedef basic_subst_results subst_results;

typedef basic_split_results split_results;

#if defined(_MSC_VER) & 1200 < _MSC_VER

// These are no longer useful, and will go away in a future release

// You should be using the version without the _c

# pragma deprecated( basic_rpattern_c )

# pragma deprecated( basic_match_results_c )

#endif

#define STATIC_RPATTERN_EX( type, var, params ) /

static type const var params;

#define STATIC_RPATTERN( var, params ) /

STATIC_RPATTERN_EX( regex::rpattern, var, params )

#define STATIC_RPATTERN_C( var, params ) /

STATIC_RPATTERN_EX( regex::rpattern_c, var, params )

#if defined(_MSC_VER) & 1200 < _MSC_VER

#pragma deprecated(STATIC_RPATTERN_EX)

#endif

// ostream inserter operator for back-references

template< typename CharT, typename TraitsT, typename IterT >

inline std::basic_ostream & operator<<

(

std::basic_ostream & sout,

backref_tag const & br

)

{

return br.print( sout );

}

} // namespace regex

// specializations for std::swap

namespace std

{

template<>

inline void swap( regex::detail::regex_arena & left, regex::detail::regex_arena & right )

{

left.swap( right );

}

template< typename IterT, typename SyntaxT >

inline void swap( regex::basic_rpattern_base & left, regex::basic_rpattern_base & right )

{

left.swap( right );

}

#ifdef _MSC_VER

#pragma warning( pop )

#endif

//+---------------------------------------------------------------------------

// Copyright ( C ) Microsoft, 1994 - 2002.

// File: regexpr2.cpp

// Contents: implementation for rpattern methods, definitions for all the

// subexpression types used to perform the matching, the

// charset class definition .

// Classes: too many to list here

// Functions:

// Author: Eric Niebler ( [email protected] )

// History: 12-11-1998 ericne Created

// 01-05-2001 ericne Removed dependency on VC's choice

// of STL iterator types.

// 08-15-2001 ericne Removed regexpr class, moved match

// state to match_results container.

// 09-17-2001 nathann Add DEBUG_HEAP_SUPPORT

// 11-16-2001 ericne Add stack-conservative algorithm

//----------------------------------------------------------------------------

#ifdef _MSC_VER

// unlimited inline expansion ( compile with /Ob1 or /Ob2 )

# pragma inline_recursion( on )

# pragma inline_depth( 255 )

// warning C4127: conditional expression is constant

// warning C4355: 'this' : used in base member initializer list

// warning C4702: unreachable code

// warning C4710: function 'blah' not inlined

// warning C4786: identifier was truncated to '255' characters in the debug information

# pragma warning( push )

# pragma warning( disable : 4127 4355 4702 4710 4786 )

#endif

#include

#ifdef __MWERKS__

# include

#endif

// If the implementation file has been included in the header, then we

// need to mark some functions as inline to prevent them from being multiply

// defined. But if the implementation file is not included in the header,

// we can't mark them as inline, otherwise the linker won't find them.

#ifdef REGEXPR_H

# define REGEXPR_H_INLINE inline

#else

# define REGEXPR_H_INLINE

# include "regexpr2.h"

#endif

#ifdef REGEX_TO_INCLUDE

# include REGEX_TO_INCLUDE

#endif

// $PORT$

// _alloca is not standard

#ifndef alloca

# define alloca _alloca

#endif

namespace regex

{

namespace detail

{

inline wctype_t REGEX_CDECL regex_wctype( char const * sz )

{

using namespace std;

return wctype( sz );

}

namespace

{

#ifdef __GLIBC__

struct regex_ctype_t

{

int m_ctype;

wctype_t m_wctype;

};

#define REGEX_DECL_CTYPE(desc) /

inline regex_ctype_t const & wct_ ## desc() /

{ /

static regex_ctype_t const s_wct = { _IS ## desc, regex_wctype(#desc) };/

return s_wct; /

}

REGEX_DECL_CTYPE(alnum)

REGEX_DECL_CTYPE(alpha)

REGEX_DECL_CTYPE(blank)

REGEX_DECL_CTYPE(cntrl)

REGEX_DECL_CTYPE(digit)

REGEX_DECL_CTYPE(graph)

REGEX_DECL_CTYPE(lower)

REGEX_DECL_CTYPE(print)

REGEX_DECL_CTYPE(punct)

REGEX_DECL_CTYPE(space)

REGEX_DECL_CTYPE(upper)

REGEX_DECL_CTYPE(xdigit)

regex_ctype_t const wct_zero = { 0, 0 };

inline regex_ctype_t & operator |= ( regex_ctype_t & lhs, regex_ctype_t const & rhs )

{

lhs.m_ctype |= rhs.m_ctype;

lhs.m_wctype |= rhs.m_wctype;

return lhs;

}

inline regex_ctype_t operator | ( regex_ctype_t lhs, regex_ctype_t const & rhs )

{

return lhs |= rhs;

}

inline int REGEX_CDECL regex_isctype( int ch, regex_ctype_t const & desc )

{

return __isctype( ch, desc.m_ctype );

}

inline int REGEX_CDECL regex_iswctype( wint_t wc, regex_ctype_t desc )

{

using namespace std;

return iswctype( wc, desc.m_wctype );

}

inline bool operator == ( regex_ctype_t const & lhs, regex_ctype_t const & rhs )

{

return lhs.m_ctype == rhs.m_ctype && lhs.m_wctype == rhs.m_wctype;

}

inline bool operator != ( regex_ctype_t const & lhs, regex_ctype_t const & rhs )

{

return lhs.m_ctype != rhs.m_ctype || lhs.m_wctype != rhs.m_wctype;

}

#else

typedef wctype_t regex_ctype_t;

#define REGEX_DECL_CTYPE(desc) /

inline regex_ctype_t const wct_ ## desc() /

{ /

static regex_ctype_t const s_wct = regex_wctype(#desc); /

return s_wct; /

}

REGEX_DECL_CTYPE(alnum)

REGEX_DECL_CTYPE(alpha)

REGEX_DECL_CTYPE(cntrl)

REGEX_DECL_CTYPE(digit)

REGEX_DECL_CTYPE(graph)

REGEX_DECL_CTYPE(lower)

REGEX_DECL_CTYPE(print)

REGEX_DECL_CTYPE(punct)

REGEX_DECL_CTYPE(space)

REGEX_DECL_CTYPE(upper)

REGEX_DECL_CTYPE(xdigit)

regex_ctype_t const wct_zero = 0;

#if defined(_MSC_VER) & ( _MSC_VER==1200 | defined(_CPPLIB_VER) )

inline regex_ctype_t const wct_blank() { return _BLANK; } // work around for bug in VC++

inline int REGEX_CDECL regex_isctype( int ch, regex_ctype_t desc )

{

return _isctype( ch, static_cast( desc ) );

}

#else

REGEX_DECL_CTYPE(blank)

inline int REGEX_CDECL regex_isctype( int ch, regex_ctype_t desc )

{

using namespace std;

return iswctype( btowc( ch ), desc );

}

#endif

inline int REGEX_CDECL regex_iswctype( wint_t wc, regex_ctype_t desc )

{

using namespace std;

return iswctype( wc, desc );

}

#endif

} // unnamed namespace

template< typename CStringsT, typename IterT >

bool _do_match_iterative( sub_expr_base const * expr, match_param & param, IterT icur, CStringsT );

// NathanN:

// By defining the symbol REGEX_DEBUG_HEAP the allocator object

// no longer sub allocates memory. This enables heap checking tools like

// AppVerifier & PageHeap to find errors like buffer overruns

#if !defined( REGEX_DEBUG_HEAP ) & REGEX_DEBUG

# define REGEX_DEBUG_HEAP 1

#else

# define REGEX_DEBUG_HEAP 0

#endif

REGEXPR_H_INLINE size_t DEFAULT_BLOCK_SIZE()

{

#if REGEX_DEBUG_HEAP

// put each allocation in its own mem_block

return 1;

#else

// put multiple allocation in each mem_block

return 352;

#endif

}

template< typename IBeginT, typename IEndT >

inline size_t parse_int( IBeginT & ibegin, IEndT iend, size_t const max_ = size_t( -1 ) )

{

typedef typename std::iterator_traits::value_type char_type;

size_t retval = 0;

while( iend != ibegin && REGEX_CHAR(char_type,'0') <= *ibegin && REGEX_CHAR(char_type,'9') >= *ibegin && max_ > retval )

{

retval *= 10;

retval += static_cast( *ibegin - REGEX_CHAR(char_type,'0') );

++ibegin;

}

if( max_ < retval )

{

retval /= 10;

--ibegin;

}

return retval;

}

// --------------------------------------------------------------------------

// Class: boyer_moore

// Description: fast sub-string search algorithm

// Members: m_begin - iter to first char in pattern sequence

// m_last - iter to last char in pattern sequence

// m_len - length of the pattern sequence

// m_off - array of offsets, indexed by ASCII char values

// History: 6/8/2003 - ericne - Created

// --------------------------------------------------------------------------

template< typename IterT >

class boyer_moore

{

typedef typename std::iterator_traits::value_type char_type;

typedef typename std::char_traits traits_type;

enum { OFFSET_SIZE = UCHAR_MAX + 1 };

IterT m_begin;

IterT m_last;

char_type const* m_low_last;

unsigned char m_len;

unsigned char m_off[ OFFSET_SIZE ];

static unsigned char hash_char( char ch ) { return static_cast( ch ); }

static unsigned char hash_char( signed char ch ) { return static_cast( ch ); }

static unsigned char hash_char( unsigned char ch ) { return ch; }

static unsigned char hash_char( wchar_t ch ) { return static_cast( ch % OFFSET_SIZE ); }

template< typename CharT >

static unsigned char REGEX_VC6(REGEX_CDECL) hash_char( CharT ch REGEX_VC6(...) )

{

return static_cast( std::char_traits::to_int_type( ch ) % OFFSET_SIZE );

}

// case-sensitive Boyer-Moore search

template< typename OtherT >

OtherT find_with_case( OtherT begin, OtherT end ) const

{

typedef typename std::iterator_traits::difference_type diff_type;

diff_type const endpos = std::distance( begin, end );

diff_type offset = m_len;

for( diff_type curpos = offset; curpos < endpos; curpos += offset )

{

std::advance( begin, offset );

IterT pat_tmp = m_last;

OtherT str_tmp = begin;

for( ; traits_type::eq( *str_tmp, *pat_tmp );

--pat_tmp, --str_tmp )

{

if( pat_tmp == m_begin )

{

return str_tmp;

}

offset = m_off[ hash_char( *begin ) ];

}

return end;

}

// case-insensitive Boyer-Moore search

template< typename OtherT >

OtherT find_without_case( OtherT begin, OtherT end ) const

{

typedef typename std::iterator_traits::difference_type diff_type;

diff_type const endpos = std::distance( begin, end );

diff_type offset = m_len;

for( diff_type curpos = offset; curpos < endpos; curpos += offset )

{

std::advance( begin, offset );

IterT pat_tmp = m_last;

char_type const* low_tmp = m_low_last;

OtherT str_tmp = begin;

for( ; traits_type::eq( *str_tmp, *pat_tmp ) || traits_type::eq( *str_tmp, *low_tmp );

--pat_tmp, --str_tmp, --low_tmp )

{

if( pat_tmp == m_begin )

{

return str_tmp;

}

offset = m_off[ hash_char( *begin ) ];

}

return end;

}

public:

// initialize the Boyer-Moore search data structure, using the

// search sub-sequence to prime the pump.

boyer_moore( IterT begin, IterT end, char_type const* lower = 0 )

: m_begin( begin )

, m_last( begin )

, m_low_last( lower )

{

typedef typename std::iterator_traits::difference_type diff_type;

diff_type diff = std::distance( begin, end );

m_len = static_cast( regex_min( diff, UCHAR_MAX ) );

std::fill_n( m_off, ARRAYSIZE( m_off ), m_len );

--m_len;

for( unsigned char offset = m_len; offset; --offset, ++m_last )

{

m_off[ hash_char( *m_last ) ] = offset;

}

if( m_low_last )

{

for( unsigned char offset = m_len; offset; --offset, ++m_low_last )

{

unsigned char hash = hash_char( *m_low_last );

m_off[ hash ] = regex_min( m_off[ hash ], offset );

}

template< typename OtherT >

OtherT find( OtherT begin, OtherT end ) const

{

if( m_low_last )

{

return find_without_case( begin, end );

}

else

{

return find_with_case( begin, end );

}

static void * operator new( size_t size, regex_arena & arena )

{

return arena.allocate( size );

}

static void operator delete( void *, regex_arena & )

{

}

};

// This class is used to speed up character set matching by providing

// a bitset that spans the ASCII range. std::bitset is not used because

// the range-checking slows it down.

// Note: The division and modulus operations are optimized by the compiler

// into bit-shift operations.

class ascii_bitvector

{

typedef unsigned int elem_type;

enum

{

CBELEM = CHAR_BIT * sizeof( elem_type ), // count of bits per element

CELEMS = ( UCHAR_MAX+1 ) / CBELEM // number of element in array

};

elem_type m_rg[ CELEMS ];

// Used to inline operations like: bv1 |= ~bv2; without creating temp bit vectors.

struct not_ascii_bitvector

{

ascii_bitvector const & m_ref;

not_ascii_bitvector( ascii_bitvector const & ref )

: m_ref( ref ) {}

private:

not_ascii_bitvector & operator=( not_ascii_bitvector const & );

};

ascii_bitvector( ascii_bitvector const & );

ascii_bitvector & operator=( ascii_bitvector const & );

public:

ascii_bitvector()

{

zero();

}

void zero()

{

std::fill_n( m_rg, ARRAYSIZE( m_rg ), 0 );

}

void set( unsigned char ch )

{

m_rg[ ( ch / CBELEM ) ] |= ( ( elem_type )1U << ( ch % CBELEM ) );

}

bool operator[]( unsigned char ch ) const

{

return 0 != ( m_rg[ ( ch / CBELEM ) ] & ( ( elem_type )1U << ( ch % CBELEM ) ) );

}

not_ascii_bitvector const operator~() const

{

return not_ascii_bitvector( *this );

}

ascii_bitvector & operator|=( ascii_bitvector const & that )

{

for( int i=0; i

m_rg[ i ] |= that.m_rg[ i ];

return *this;

}

ascii_bitvector & operator|=( not_ascii_bitvector const & that )

{

for( int i=0; i

m_rg[ i ] |= ~that.m_ref.m_rg[ i ];

return *this;

}

};

typedef std::pair range_type;

// determines if one range is less then another.

// used in binary search of range vector

struct range_less

{

bool operator()( range_type const & rg1, range_type const & rg2 ) const

{

return rg1.second < rg2.first;

}

};

// A singly-linked list, which works even if the allocator

// has per-instance state.

template< typename T, typename AllocT=std::allocator >

class slist

{

struct cons

{

T car;

cons * cdr;

cons( T const & t, cons * nxt )

: car( t )

, cdr( nxt )

{

}

};

typedef typename rebind::type cons_allocator;

typedef typename rebind::type char_allocator;

#if !defined(_MSC_VER) | 1200 < _MCS_VER

// Use the empty base optimization to avoid reserving

// space for the allocator if it is empty.

struct slist_impl : cons_allocator

{

cons * m_lst;

slist_impl( cons_allocator const & alloc, cons *lst )

: cons_allocator( alloc )

, m_lst( lst )

{

}

cons_allocator & allocator()

{

return *this;

}

};

#else

struct slist_impl

{

cons_allocator m_alloc;

cons *m_lst;

slist_impl( cons_allocator const & alloc, cons *lst )

: m_alloc( alloc )

, m_lst( lst )

{

}

cons_allocator & allocator()

{

return m_alloc;

}

};

#endif

slist_impl m_impl;

// find the previous node in the list (*prev(lst)==lst)

cons ** prev( cons *lst, cons *hint = 0 )

{

if( m_impl.m_lst == lst )

return &m_impl.m_lst;

if( !hint || hint->cdr != lst )

for( hint=m_impl.m_lst; hint->cdr != lst; hint=hint->cdr )

{}

return &hint->cdr;

}

public:

typedef T value_type;

typedef T* pointer;

typedef T& reference;

typedef T const* const_pointer;

typedef T const& const_reference;

typedef size_t size_type;

struct iterator : public std::iterator

{

friend class slist;

explicit iterator( cons * pcons = 0 )

: m_pcons( pcons )

{

}

T & operator*() const

{

return m_pcons->car;

}

T * operator->() const

{

return &m_pcons->car;

}

iterator & operator++()

{

m_pcons = m_pcons->cdr;

return *this;

}

iterator operator++( int )

{

iterator i( *this );

++*this;

return i;

}

bool operator==( iterator it )

{

return m_pcons == it.m_pcons;

}

bool operator!=( iterator it )

{

return m_pcons != it.m_pcons;

}

private:

cons * m_pcons;

};

// not ideal, but good enough for gov'ment work....

typedef iterator const_iterator;

explicit slist( char_allocator const & al = char_allocator() )

: m_impl( convert_allocator( al, 0 ), 0 )

{

}

~slist()

{

clear();

}

void clear()

{

for( cons *nxt; m_impl.m_lst; m_impl.m_lst=nxt )

{

nxt = m_impl.m_lst->cdr;

m_impl.allocator().destroy( m_impl.m_lst );

m_impl.allocator().deallocate( m_impl.m_lst, 1 );

}

void push_front( T const & t )

{

cons * lst = m_impl.allocator().allocate( 1, 0 );

try

{

m_impl.allocator().construct( lst, cons( t, m_impl.m_lst ) );

}

catch(...)

{

m_impl.allocator().deallocate( lst, 1 );

throw;

}

m_impl.m_lst = lst;

}

template< typename PredT >

void sort( PredT pred )

{

// simple insertion sort

cons *rst=m_impl.m_lst;

m_impl.m_lst = 0;

while( rst )

{

cons *cur=m_impl.m_lst, *prv=0;

while( cur && ! pred( rst->car, cur->car ) )

prv=cur, cur=cur->cdr;

if( prv )

prv->cdr=rst, rst=rst->cdr, prv->cdr->cdr=cur;

else

m_impl.m_lst=rst, rst=rst->cdr, m_impl.m_lst->cdr=cur;

}

void sort()

{

this->sort( std::less() );

}

iterator begin() const

{

return iterator( m_impl.m_lst );

}

iterator end() const

{

return iterator();

}

bool empty() const

{

return 0 == m_impl.m_lst;

}

size_t size() const

{

size_t len=0;

for( cons *lst=m_impl.m_lst; lst; lst=lst->cdr, ++len )

{}

return len;

}

iterator erase( iterator it, iterator hint = iterator() )

{

cons **prv = prev( it.m_pcons, hint.m_pcons ); // *prv==it.p

*prv = it.m_pcons->cdr;

m_impl.allocator().destroy( it.m_pcons );

m_impl.allocator().deallocate( it.m_pcons, 1 );

return iterator( *prv );

}

void reverse()

{

cons *prv=0, *nxt;

while( m_impl.m_lst )

nxt = m_impl.m_lst->cdr, m_impl.m_lst->cdr = prv, prv = m_impl.m_lst, m_impl.m_lst = nxt;

m_impl.m_lst = prv;

}

};

template< typename AllocT >

struct basic_charset;

template< typename CharT >

struct posixcharsoff_pred

{

CharT m_ch;

posixcharsoff_pred( CharT ch )

: m_ch( ch )

{

}

bool operator()( regex_ctype_t desc ) const

{

return ! local_isctype( m_ch, desc );

}

static int local_isctype( char ch, regex_ctype_t desc )

{

return regex_isctype( ch, desc );

}

static int local_isctype( wchar_t ch, regex_ctype_t desc )

{

return regex_iswctype( ch, desc );

}

};

template< typename CharT, bool CaseT >

struct in_charset_pred

{

CharT m_ch;

in_charset_pred( CharT ch )

: m_ch( ch )

{

}

template< typename AllocT >

bool operator()( basic_charset const * pcs ) const

{

REGEX_VC6( return pcs->in( m_ch COMMA bool2type() ); )

REGEX_NVC6( return pcs->template in( m_ch ); )

}

};

template< typename AllocT >

struct basic_charset

{

typedef basic_charset > other_type;

typedef slist > other_ranges_type;

typedef slist ranges_type;

typedef slist posixcharsoff_type;

typedef slist nestedcharsets_type;

typedef typename rebind::type char_allocator_type;

bool m_fcompliment;

bool m_fskip_extended_check;

ascii_bitvector m_ascii_bitvector;

regex_ctype_t m_posixcharson;

ranges_type m_ranges;

posixcharsoff_type m_posixcharsoff;

nestedcharsets_type m_nestedcharsets;

explicit basic_charset( char_allocator_type const & al = char_allocator_type() )

: m_fcompliment( false )

, m_fskip_extended_check( false )

, m_ascii_bitvector()

, m_posixcharson( wct_zero )

, m_ranges( al )

, m_posixcharsoff( al )

, m_nestedcharsets( al )

{

}

// We'll be inheriting from this, so a virtual d'tor is regretably necessary.

virtual ~basic_charset()

{

}

void clear()

{

m_fcompliment = false;

m_fskip_extended_check = false;

m_ascii_bitvector.zero();

m_posixcharson = wct_zero;

m_ranges.clear();

m_posixcharsoff.clear();

m_nestedcharsets.clear();

}

// merge one charset into another

basic_charset & operator|=( other_type const & that )

{

if( that.m_fcompliment )

{

// If no posix-style character sets are used, then we can merge this

// nested character set directly into the enclosing character set.

if( wct_zero == that.m_posixcharson &&

that.m_posixcharsoff.empty() &&

that.m_nestedcharsets.empty() )

{

m_ascii_bitvector |= ~ that.m_ascii_bitvector;

// append the inverse of that.m_ranges to this->m_ranges

wchar_t chlow = UCHAR_MAX;

typedef typename other_ranges_type::const_iterator iter_type;

for( iter_type prg = that.m_ranges.begin(); that.m_ranges.end() != prg; ++prg )

{

if( UCHAR_MAX + 1 != prg->first )

m_ranges.push_front( range_type( wchar_t( chlow+1 ), wchar_t( prg->first-1 ) ) );

chlow = prg->second;

}

if( WCHAR_MAX != chlow )

m_ranges.push_front( range_type( wchar_t( chlow+1 ), WCHAR_MAX ) );

}

else

{

// There is no simple way to merge this nested character

// set into the enclosing character set, so we must save

// a pointer to the nested character set in a list.

m_nestedcharsets.push_front( &that );

}

else

{

m_ascii_bitvector |= that.m_ascii_bitvector;

std::copy( that.m_ranges.begin(),

that.m_ranges.end(),

std::front_inserter( m_ranges ) );

m_posixcharson |= that.m_posixcharson;

std::copy( that.m_posixcharsoff.begin(),

that.m_posixcharsoff.end(),

std::front_inserter( m_posixcharsoff ) );

std::copy( that.m_nestedcharsets.begin(),

that.m_nestedcharsets.end(),

std::front_inserter( m_nestedcharsets ) );

}

return *this;

}

// Note overloading based on first parameter

void set_bit( char ch, bool const fnocase )

{

if( fnocase )

{

m_ascii_bitvector.set( static_cast( regex_tolower( ch ) ) );

m_ascii_bitvector.set( static_cast( regex_toupper( ch ) ) );

}

else

{

m_ascii_bitvector.set( static_cast( ch ) );

}

// Note overloading based on first parameter

void set_bit( wchar_t ch, bool const fnocase )

{

if( UCHAR_MAX >= ch )

set_bit( static_cast( ch ), fnocase );

else

m_ranges.push_front( range_type( ch, ch ) );

}

// Note overloading based on first two parameters

void set_bit_range( char ch1, char ch2, bool const fnocase )

{

if( static_cast( ch1 ) > static_cast( ch2 ) )

throw bad_regexpr( "invalid range specified in character set" );

if( fnocase )

{

// i is unsigned int to prevent overflow if ch2 is UCHAR_MAX

for( unsigned int i = static_cast( ch1 );

i <= static_cast( ch2 ); ++i )

{

m_ascii_bitvector.set( static_cast( regex_toupper( (char) i ) ) );

m_ascii_bitvector.set( static_cast( regex_tolower( (char) i ) ) );

}

else

{

// i is unsigned int to prevent overflow if ch2 is UCHAR_MAX

for( unsigned int i = static_cast( ch1 );

i <= static_cast( ch2 ); ++i )

{

m_ascii_bitvector.set( static_cast( i ) );

}

// Note overloading based on first two parameters

void set_bit_range( wchar_t ch1, wchar_t ch2, bool const fnocase )

{

if( ch1 > ch2 )

throw bad_regexpr( "invalid range specified in character set" );

if( UCHAR_MAX >= ch1 )

set_bit_range( static_cast( ch1 ), static_cast( regex_min( UCHAR_MAX, ch2 ) ), fnocase );

if( UCHAR_MAX < ch2 )

m_ranges.push_front( range_type( regex_max( static_cast( UCHAR_MAX + 1 ), ch1 ), ch2 ) );

}

void optimize( type2type )

{

if( m_ranges.begin() != m_ranges.end() )

{

// this sorts on range_type.m_pfirst ( uses operator<() for pair templates )

m_ranges.sort();

// merge ranges that overlap

typename ranges_type::iterator icur=m_ranges.begin(), iprev=icur++;

while( icur != m_ranges.end() )

{

if( icur->first <= iprev->second + 1 )

{

iprev->second = regex_max( iprev->second, icur->second );

icur = m_ranges.erase( icur, iprev );

}

else

{

iprev=icur++;

}

// For the ASCII range, merge the m_posixcharson info

// into the ascii_bitvector

if( wct_zero != m_posixcharson )

{

// BUGBUG this is kind of expensive. Think of a better way.

for( unsigned int i=0; i<=UCHAR_MAX; ++i )

if( regex_isctype( i, m_posixcharson ) )

m_ascii_bitvector.set( static_cast( i ) );

}

// m_fskip_extended_check is a cache which tells us whether we

// need to check the m_posixcharsoff and m_nestedcharsets vectors,

// which would only be used in nested user-defined character sets

m_fskip_extended_check = m_posixcharsoff.empty() && m_nestedcharsets.empty();

}

void optimize( type2type )

{

optimize( type2type() );

// the posixcharson info was merged into the ascii bitvector,

// so we don't need to ever call regex_isctype ever again.

m_posixcharson = wct_zero;

}

template< bool CaseT, typename CharT >

bool extended_check( CharT ch REGEX_VC6(COMMA bool2type) ) const

{

REGEX_ASSERT( m_fskip_extended_check == ( m_posixcharsoff.empty() && m_nestedcharsets.empty() ) );

if( m_fskip_extended_check )

{

return false;

}

return ( m_posixcharsoff.end() !=

std::find_if( m_posixcharsoff.begin(), m_posixcharsoff.end(),

posixcharsoff_pred( ch ) ) )

|| ( m_nestedcharsets.end() !=

std::find_if( m_nestedcharsets.begin(), m_nestedcharsets.end(),

in_charset_pred( ch ) ) );

}

inline bool in_ranges( wchar_t ch, true_t ) const

{

typedef typename ranges_type::const_iterator iter_type;

iter_type ibegin = m_ranges.begin(), iend = m_ranges.end();

return ibegin != iend &&

std::binary_search( ibegin, iend, range_type( ch, ch ), range_less() );

}

inline bool in_ranges( wchar_t ch, false_t ) const

{

typedef typename ranges_type::const_iterator iter_type;

iter_type ibegin = m_ranges.begin(), iend = m_ranges.end();

if( ibegin == iend )

return false;

wchar_t const chup = regex_toupper( ch );

if( std::binary_search( ibegin, iend, range_type( chup, chup ), range_less() ) )

return true;

wchar_t const chlo = regex_tolower( ch );

if( chup == chlo )

return false;

return std::binary_search( ibegin, iend, range_type( chlo, chlo ), range_less() );

}

// Note overloading based on parameter

template< bool CaseT >

bool in( char ch REGEX_VC6(COMMA bool2type) ) const

{

// Whoops, forgot to call optimize() on this charset

REGEX_ASSERT( wct_zero == m_posixcharson );

return m_fcompliment !=

(

( m_ascii_bitvector[ static_cast( ch ) ] )

|| ( extended_check REGEX_NVC6() ( ch REGEX_VC6(COMMA bool2type()) ) )

);

}

// Note overloading based on parameter

template< bool CaseT >

bool in( wchar_t ch REGEX_VC6(COMMA bool2type) ) const

{

// use range_match_type to see if this character is within one of the

// ranges stored in m_rgranges.

return m_fcompliment !=

(

( ( UCHAR_MAX >= ch ) ?

( m_ascii_bitvector[ static_cast( ch ) ] ) :

( ( in_ranges( ch, bool2type() ) )

|| ( wct_zero != m_posixcharson && regex_iswctype( ch, m_posixcharson ) ) ) )

|| ( extended_check REGEX_NVC6() ( ch REGEX_VC6(COMMA bool2type()) ) )

);

}

private:

basic_charset & operator=( basic_charset const & that );

basic_charset( basic_charset const & that );

};

// Intrinsic character sets are allocated on the heap with the standard allocator.

// They are either the built-in character sets, or the user-defined ones.

struct charset : public basic_charset >

{

charset()

{

}

private:

charset( charset const & );

charset & operator=( charset const & );

};

// charset is no longer an incomplete type so we now

// know how to destroy one. free_charset() is used in syntax2.h

REGEXPR_H_INLINE void free_charset( charset const * pcharset )

{

delete pcharset;

}

// Custom character sets are the ones that appear in patterns between

// square brackets. They are allocated in a regex_arena to speed up

// pattern compilation and to make rpattern clean-up faster.

struct custom_charset : public basic_charset

{

static void * operator new( size_t size, regex_arena & arena )

{

return arena.allocate( size );

}

static void operator delete( void *, regex_arena & ) {}

static void operator delete( void * ) {}

custom_charset( regex_arena & arena )

: basic_charset( arena )

{

}

private:

custom_charset( custom_charset const & );

custom_charset & operator=( custom_charset const & );

};

template< typename CharT >

class intrinsic_charsets

{

struct intrinsic_charset : public charset

{

intrinsic_charset( bool fcompliment, regex_ctype_t desc, char const * sz )

{

reset( fcompliment, desc, sz );

}

void reset( bool fcompliment, regex_ctype_t desc, char const * sz )

{

clear();

m_fcompliment = fcompliment;

m_posixcharson = desc;

for( ; *sz; ++sz )

m_ascii_bitvector.set( static_cast( *sz ) );

optimize( type2type() );

}

private:

intrinsic_charset( intrinsic_charset const & );

intrinsic_charset & operator=( intrinsic_charset const & );

};

static intrinsic_charset & _get_word_charset()

{

static intrinsic_charset s_word_charset( false, wct_alpha()|wct_digit(), "_" );

return s_word_charset;

}

static intrinsic_charset & _get_digit_charset()

{

static intrinsic_charset s_digit_charset( false, wct_digit(), "" );

return s_digit_charset;

}

static intrinsic_charset & _get_space_charset()

{

static intrinsic_charset s_space_charset( false, wct_space(), "" );

return s_space_charset;

}

static intrinsic_charset & _get_not_word_charset()

{

static intrinsic_charset s_not_word_charset( true, wct_alpha()|wct_digit(), "_" );

return s_not_word_charset;

}

static intrinsic_charset & _get_not_digit_charset()

{

static intrinsic_charset s_not_digit_charset( true, wct_digit(), "" );

return s_not_digit_charset;

}

static intrinsic_charset & _get_not_space_charset()

{

static intrinsic_charset s_not_space_charset( true, wct_space(), "" );

return s_not_space_charset;

}

public:

static charset const & get_word_charset()

{

return _get_word_charset();

}

static charset const & get_digit_charset()

{

return _get_digit_charset();

}

static charset const & get_space_charset()

{

return _get_space_charset();

}

static charset const & get_not_word_charset()

{

return _get_not_word_charset();

}

static charset const & get_not_digit_charset()

{

return _get_not_digit_charset();

}

static charset const & get_not_space_charset()

{

return _get_not_space_charset();

}

static void reset()

{

_get_word_charset().reset( false, wct_alpha()|wct_digit(), "_" );

_get_digit_charset().reset( false, wct_digit(), "" );

_get_space_charset().reset( false, wct_space(), "" );

_get_not_word_charset().reset( true, wct_alpha()|wct_digit(), "_" );

_get_not_digit_charset().reset( true, wct_digit(), "" );

_get_not_space_charset().reset( true, wct_space(), "" );

}

};

// Operator implementations

// Evaluates the beginning-of-string condition

template< typename CStringsT >

struct bos_t

{

template< typename IterT >

static bool eval( match_param const & param, IterT iter )

{

return param.m_ibufferbegin == iter;

}

};

// Find the beginning of a line, either beginning of a string, or the character

// immediately following a newline

template< typename CStringsT >

struct bol_t

{

template< typename IterT >

static bool eval( match_param const & param, IterT iter )

{

typedef typename std::iterator_traits::value_type char_type;

typedef std::char_traits traits_type;

return param.m_ibufferbegin == iter || traits_type::eq( REGEX_CHAR(char_type,'/n'), *--iter );

}

};

// Evaluates end-of-string condition for string's

template< typename CStringsT >

struct eos_t

{

template< typename IterT >

static bool eval( match_param const & param, IterT iter )

{

return param.m_iend == iter;

}

};

template<>

struct eos_t

{

template< typename IterT >

static bool eval( match_param const &, IterT iter )

{

typedef typename std::iterator_traits::value_type char_type;

typedef std::char_traits traits_type;

return traits_type::eq( *iter, char_type() );

}

};

// Evaluates end-of-line conditions, either the end of the string, or a

// newline character.

template< typename CStringsT >

struct eol_t

{

template< typename IterT >

static bool eval( match_param const & param, IterT iter )

{

typedef typename std::iterator_traits::value_type char_type;

typedef std::char_traits traits_type;

return param.m_iend == iter

|| traits_type::eq( REGEX_CHAR(char_type,'/n'), *iter );

}

};

template<>

struct eol_t

{

template< typename IterT >

static bool eval( match_param const &, IterT iter )

{

typedef typename std::iterator_traits::value_type char_type;

typedef std::char_traits traits_type;

return traits_type::eq( *iter, char_type() )

|| traits_type::eq( *iter, REGEX_CHAR(char_type,'/n') );

}

};

// Evaluates perl's end-of-string conditions, either the end of the string, or a

// newline character followed by end of string. ( Only used by $ and /Z assertions )

template< typename CStringsT >

struct peos_t

{

template< typename IterT >

static bool eval( match_param const & param, IterT iter )

{

typedef typename std::iterator_traits::value_type char_type;

typedef std::char_traits traits_type;

return param.m_iend == iter

|| ( traits_type::eq( REGEX_CHAR(char_type,'/n'), *iter ) && param.m_iend == ++iter );

}

};

template<>

struct peos_t

{

template< typename IterT >

static bool eval( match_param const &, IterT iter )

{

typedef typename std::iterator_traits::value_type char_type;

typedef std::char_traits traits_type;

return traits_type::eq( *iter, char_type() )

|| ( traits_type::eq( *iter, REGEX_CHAR(char_type,'/n') )

&& traits_type::eq( *++iter, char_type() ) );

}

};

// compare two characters, case-sensitive

template< typename CharT >

struct ch_neq_t

{

typedef CharT char_type;

typedef std::char_traits traits_type;

static bool eval( register CharT ch1, register CharT ch2 )

{

return ! traits_type::eq( ch1, ch2 );

}

};

// Compare two characters, disregarding case

template< typename CharT >

struct ch_neq_nocase_t

{

typedef CharT char_type;

typedef std::char_traits traits_type;

static bool eval( register CharT ch1, register CharT ch2 )

{

return ! traits_type::eq( regex_toupper( ch1 ), regex_toupper( ch2 ) );

}

};

// helper functions for dealing with widths.

inline size_t width_add( size_t a, size_t b )

{

return ( size_t( -1 ) == a || size_t( -1 ) == b ? size_t( -1 ) : a + b );

}

inline size_t width_mult( size_t a, size_t b )

{

if( 0 == a || 0 == b )

return 0;

if( size_t( -1 ) == a || size_t( -1 ) == b )

return size_t( -1 );

return a * b;

}

inline bool operator==( width_type const & rhs, width_type const & lhs )

{

return ( rhs.m_min == lhs.m_min && rhs.m_max == lhs.m_max );

}

inline bool operator!=( width_type const & rhs, width_type const & lhs )

{

return ( rhs.m_min != lhs.m_min || rhs.m_max != lhs.m_max );

}

inline width_type operator+( width_type const & rhs, width_type const & lhs )

{

width_type width = { width_add( rhs.m_min, lhs.m_min ), width_add( rhs.m_max, lhs.m_max ) };

return width;

}

inline width_type operator*( width_type const & rhs, width_type const & lhs )

{

width_type width = { width_mult( rhs.m_min, lhs.m_min ), width_mult( rhs.m_max, lhs.m_max ) };

return width;

}

inline width_type & operator+=( width_type & rhs, width_type const & lhs )

{

rhs.m_min = width_add( rhs.m_min, lhs.m_min );

rhs.m_max = width_add( rhs.m_max, lhs.m_max );

return rhs;

}

inline width_type & operator*=( width_type & rhs, width_type const & lhs )

{

rhs.m_min = width_mult( rhs.m_min, lhs.m_min );

rhs.m_max = width_mult( rhs.m_max, lhs.m_max );

return rhs;

}

namespace

{

width_type const zero_width = { 0, 0 };

width_type const worst_width = { 0, size_t( -1 ) };

}

template< typename IterT >

struct width_param

{

std::vector*> & m_rggroups;

std::list const & m_invisible_groups;

width_type m_width;

width_param

(

std::vector*> & rggroups,

std::list const & invisible_groups

)

: m_rggroups( rggroups )

, m_invisible_groups( invisible_groups )

, m_width( zero_width )

{

}

private:

width_param & operator=( width_param const & );

};

template< typename CharT >

struct must_have

{

typedef std::basic_string string_type;

typedef typename string_type::const_iterator const_iterator;

bool m_has;

const_iterator m_begin;

const_iterator m_end;

CharT const * m_lower;

};

template< typename CharT >

struct peek_param

{

// "chars" is a list of characters. If every alternate in a group

// begins with a character or string literal, the "chars" list can

// be used to speed up the matching of a group.

size_t m_cchars;

union

{

CharT m_rgchars[2];

CharT const * m_pchars;

};

// "must" is a string that must appear in the match. It is used

// to speed up the search.

must_have m_must_have;

};

// --------------------------------------------------------------------------

// Class: sub_expr

// Description: patterns are "compiled" into a directed graph of sub_expr

// structs. Matching is accomplished by traversing this graph.

// Methods: sub_expr - construct a sub_expr

// recursive_match_this - does this sub_expr match at the given location

// width_this - what is the width of this sub_expr

// ~sub_expr - recursively delete the sub_expr graph

// next - pointer to the next node in the graph

// recursive_match_next - match the rest of the graph

// recursive_match_all - recursive_match_this and recursive_match_next

// is_assertion - true if this sub_expr is a zero-width assertion

// get_width - find the width of the graph at this sub_expr

// Members: m_pnext - pointer to the next node in the graph

// History: 8/14/2000 - ericne - Created

// --------------------------------------------------------------------------

template< typename IterT >

class sub_expr : public sub_expr_base

{

sub_expr * m_pnext;

protected:

// Only derived classes can instantiate sub_expr's

sub_expr()

: m_pnext( 0 )

{

}

public:

typedef IterT iterator_type;

typedef typename std::iterator_traits::value_type char_type;

typedef std::char_traits traits_type;

virtual ~sub_expr()

{

delete m_pnext;

}

sub_expr ** pnext()

{

return & m_pnext;

}

sub_expr const * next() const

{

return m_pnext;

}

virtual sub_expr * quantify( size_t, size_t, bool, regex_arena & )

{

throw bad_regexpr( "sub-expression cannot be quantified" );

}

// Match this object and all subsequent objects

// If recursive_match_all returns false, it must not change any of param's state

virtual bool recursive_match_all_s( match_param & param, IterT icur ) const

{

return ( recursive_match_this_s( param, icur ) && recursive_match_next( param, icur, false_t() ) );

}

virtual bool recursive_match_all_c( match_param & param, IterT icur ) const // for C-style strings

{

return ( recursive_match_this_c( param, icur ) && recursive_match_next( param, icur, true_t() ) );

}

// match this object only

virtual bool recursive_match_this_s( match_param &, IterT & ) const

{

return true;

}

virtual bool recursive_match_this_c( match_param &, IterT & ) const // for C-style strings

{

return true;

}

// Match all subsequent objects

template< typename CStringsT >

bool recursive_match_next( match_param & param, IterT icur, CStringsT ) const

{

return m_pnext->recursive_match_all( param, icur, CStringsT() );

}

virtual bool iterative_match_this_s( match_param & param ) const

{

param.m_pnext = next();

return true;

}

virtual bool iterative_match_this_c( match_param & param ) const // for C-style strings

{

param.m_pnext = next();

return true;

}

virtual bool iterative_rematch_this_s( match_param & ) const

{

return false;

}

virtual bool iterative_rematch_this_c( match_param & ) const // for C-style strings

{

return false;

}

virtual bool is_assertion() const

{

return false;

}

width_type get_width( width_param & param )

{

width_type temp_width = width_this( param );

if( m_pnext )

temp_width += m_pnext->get_width( param );

return temp_width;

}

virtual width_type width_this( width_param & ) = 0;

virtual bool peek_this( peek_param & ) const

{

return false;

}

};

// An object of type end_of_pattern is used to mark the

// end of the pattern. (Duh!) It is responsible for ending

// the recursion, or for letting the search continue if

// the match is zero-width and we are trying to find a

// non-zero-width match

template< typename IterT >

class end_of_pattern : public sub_expr

{

bool _do_match_this( match_param & param, IterT icur ) const

{

return ! param.m_no0len || param.m_imatchbegin != icur;

}

public:

virtual bool recursive_match_all_s( match_param & param, IterT icur ) const

{

return _do_match_this( param, icur );

}

virtual bool recursive_match_all_c( match_param & param, IterT icur ) const // for C-style strings

{

return _do_match_this( param, icur );

}

virtual bool iterative_match_this_s( match_param & param ) const

{

param.m_pnext = 0;

return _do_match_this( param, param.m_icur );

}

virtual bool iterative_match_this_c( match_param & param ) const // for C-style strings

{

param.m_pnext = 0;

return _do_match_this( param, param.m_icur );

}

virtual width_type width_this( width_param & )

{

return zero_width;

}

};

// Base class for sub-expressions which are zero-width

// ( i.e., assertions eat no characters during matching )

// Assertions cannot be quantified.

template< typename IterT >

class assertion : public sub_expr

{

public:

virtual bool is_assertion() const

{

return true;

}

virtual width_type width_this( width_param & )

{

return zero_width;

}

virtual bool peek_this( peek_param & peek ) const

{

return this->next()->peek_this( peek );

}

};

template< typename OpT, typename OpCT >

struct opwrap

{

typedef OpT op_type;

typedef OpCT opc_type;

};

#define REGEX_OP(x) opwrap< x, x >

template< typename IterT, typename OpWrapT >

class assert_op : public assertion

{

public:

virtual bool recursive_match_all_s( match_param & param, IterT icur ) const

{

return ( assert_op::recursive_match_this_s( param, icur ) && this->recursive_match_next( param, icur, false_t() ) );

}

virtual bool recursive_match_all_c( match_param & param, IterT icur ) const

{

return ( assert_op::recursive_match_this_c( param, icur ) && this->recursive_match_next( param, icur, true_t() ) );

}

virtual bool recursive_match_this_s( match_param & param, IterT & icur ) const

{

return OpWrapT::op_type::eval( param, icur );

}

virtual bool recursive_match_this_c( match_param & param, IterT & icur ) const

{

return OpWrapT::opc_type::eval( param, icur );

}

virtual bool iterative_match_this_s( match_param & param ) const

{

param.m_pnext = this->next();

return OpWrapT::op_type::eval( param, param.m_icur );

}

virtual bool iterative_match_this_c( match_param & param ) const

{

param.m_pnext = this->next();

return OpWrapT::opc_type::eval( param, param.m_icur );

}

};

template< typename IterT >

inline assertion * create_bos( REGEX_FLAGS, regex_arena & arena )

{

return new( arena ) assert_op();

}

template< typename IterT >

inline assertion * create_eos( REGEX_FLAGS, regex_arena & arena )

{

return new( arena ) assert_op();

}

template< typename IterT >

inline assertion * create_eoz( REGEX_FLAGS, regex_arena & arena )

{

return new( arena ) assert_op();

}

template< typename IterT >

inline assertion * create_bol( REGEX_FLAGS flags, regex_arena & arena )

{

switch( MULTILINE & flags )

{

case 0:

return new( arena ) assert_op();

case MULTILINE:

return new( arena ) assert_op();

default:

REGEX_ASSERT(false);

return 0;

}

template< typename IterT >

inline assertion * create_eol( REGEX_FLAGS flags, regex_arena & arena )

{

switch( MULTILINE & flags )

{

case 0:

return new( arena ) assert_op();

case MULTILINE:

return new( arena ) assert_op();

default:

REGEX_ASSERT(false);

return 0;

}

template< typename IterT, typename SubExprT = sub_expr >

class match_wrapper : public sub_expr

{

match_wrapper & operator=( match_wrapper const & );

public:

match_wrapper( SubExprT * psub )

: m_psub( psub )

{

}

virtual ~match_wrapper()

{

_cleanup();

}

virtual width_type width_this( width_param & param )

{

return m_psub->width_this( param );

}

virtual bool peek_this( peek_param & peek ) const

{

return m_psub->peek_this( peek );

}

protected:

void _cleanup()

{

delete m_psub;

m_psub = 0;

}

SubExprT * m_psub;

};

template< typename IterT, typename SubExprT = sub_expr >

class match_quantifier : public match_wrapper

{

match_quantifier & operator=( match_quantifier const & );

public:

match_quantifier( SubExprT * psub, size_t lbound, size_t ubound )

: match_wrapper( psub )

, m_lbound( lbound )

, m_ubound( ubound )

{

}

virtual width_type width_this( width_param & param )

{

width_type this_width = match_wrapper::width_this( param );

width_type quant_width = { m_lbound, m_ubound };

return this_width * quant_width;

}

virtual bool peek_this( peek_param & peek ) const

{

return 0 != m_lbound && this->m_psub->peek_this( peek );

}

protected:

size_t const m_lbound;

size_t const m_ubound;

};

template< typename IterT, typename SubExprT >

class atom_quantifier : public match_quantifier

{

atom_quantifier & operator=( atom_quantifier const & );

public:

atom_quantifier( SubExprT * psub, size_t lbound, size_t ubound )

: match_quantifier( psub, lbound, ubound )

{

}

protected:

void _push_frame( unsafe_stack * pstack, IterT curr, size_t count ) const

{

std::pair p( curr, count );

pstack->push( p );

}

void _pop_frame( match_param & param ) const

{

std::pair p;

param.m_pstack->pop( p );

param.m_icur = p.first;

}

};

template< typename IterT, typename SubExprT >

class max_atom_quantifier : public atom_quantifier

{

max_atom_quantifier & operator=( max_atom_quantifier const & );

public:

max_atom_quantifier( SubExprT * psub, size_t lbound, size_t ubound )

: atom_quantifier( psub, lbound, ubound )

{

}

// Why a macro instead of a template, you ask? Performance. Due to a known

// bug in the VC7 inline heuristic, I cannot get VC7 to inline the calls to

// m_psub methods unless I use these macros. And the performance win is

// nothing to sneeze at. It's on the order of a 25% speed up to use a macro

// here instead of a template.

#define DECLARE_RECURSIVE_MATCH_ALL(CSTRINGS,EXT) /

virtual bool recursive_match_all ## EXT( match_param & param, IterT icur ) const /

{ /

typedef typename std::iterator_traits::difference_type diff_type; /

/* In an ideal world, ibegin and cdiff would be members of a union */ /

/* to conserve stack, but I don't know if IterT is a POD type or not. */ /

IterT ibegin = icur; /

diff_type cdiff = 0; /* must be a signed integral type */ /

size_t cmatches = 0; /

/* greedily match as much as we can*/ /

if( this->m_ubound && this->m_psub->SubExprT::recursive_match_this ## EXT( param, icur ) ) /

{ /

if( 0 == ( cdiff = -std::distance( ibegin, icur ) ) ) /

return this->recursive_match_next( param, icur, CSTRINGS() ); /

while( ++cmatches < this->m_ubound && this->m_psub->SubExprT::recursive_match_this ## EXT( param, icur ) )/

{} /

} /

if( this->m_lbound > cmatches ) /

return false; /

/* try matching the rest of the pattern, and back off if necessary */ /

for( ; ; --cmatches, std::advance( icur, cdiff ) ) /

{ /

if( this->recursive_match_next( param, icur, CSTRINGS() ) ) /

return true; /

if( this->m_lbound == cmatches ) /

return false; /

} /

}

#define DECLARE_ITERATIVE_MATCH_THIS(EXT) /

virtual bool iterative_match_this ## EXT( match_param & param ) const /

{ /

IterT ibegin = param.m_icur; /

size_t cmatches = 0; /

if( this->m_ubound && this->m_psub->SubExprT::iterative_match_this ## EXT( param ) ) /

{ /

if( 0 == std::distance( ibegin, param.m_icur ) ) /

{ /

cmatches = this->m_lbound; /

} /

else /

{ /

while( ++cmatches < this->m_ubound && this->m_psub->SubExprT::iterative_match_this ## EXT( param ) )/

{} /

} /

if( cmatches >= this->m_lbound ) /

{ /

this->_push_frame( param.m_pstack, ibegin, cmatches ); /

param.m_pnext = this->next(); /

return true; /

} /

param.m_icur = ibegin; /

return false; /

}

#define DECLARE_ITERATIVE_REMATCH_THIS(EXT) /

virtual bool iterative_rematch_this ## EXT( match_param & param ) const /

{ /

typedef std::pair top_type; /

size_t & cmatches = REGEX_VC6( param.m_pstack->top( type2type() ).second ) /

REGEX_NVC6( param.m_pstack->template top().second ); /

if( this->m_lbound != cmatches ) /

{ /

--cmatches; /

this->m_psub->SubExprT::iterative_rematch_this ## EXT( param ); /

param.m_pnext = this->next(); /

return true; /

} /

this->_pop_frame( param ); /

return false; /

}

DECLARE_RECURSIVE_MATCH_ALL(false_t,_s)

DECLARE_RECURSIVE_MATCH_ALL(true_t,_c)

DECLARE_ITERATIVE_MATCH_THIS(_s)

DECLARE_ITERATIVE_MATCH_THIS(_c)

DECLARE_ITERATIVE_REMATCH_THIS(_s)

DECLARE_ITERATIVE_REMATCH_THIS(_c)

#undef DECLARE_RECURSIVE_MATCH_ALL

#undef DECLARE_ITERATIVE_MATCH_THIS

#undef DECLARE_ITERATIVE_REMATCH_THIS

};

template< typename IterT, typename SubExprT >

class min_atom_quantifier : public atom_quantifier

{

min_atom_quantifier & operator=( min_atom_quantifier const & );

public:

min_atom_quantifier( SubExprT * psub, size_t lbound, size_t ubound )

: atom_quantifier( psub, lbound, ubound )

{

}

// Why a macro instead of a template, you ask? Performance. Due to a known

// bug in the VC7 inline heuristic, I cannot get VC7 to inline the calls to

// m_psub methods unless I use these macros. And the performance win is

// nothing to sneeze at. It's on the order of a 25% speed up to use a macro

// here instead of a template.

#define DECLARE_RECURSIVE_MATCH_ALL(CSTRINGS,EXT) /

virtual bool recursive_match_all ## EXT( match_param & param, IterT icur ) const /

{ /

IterT icur_tmp = icur; /

size_t cmatches = 0; /

if( this->m_psub->SubExprT::recursive_match_this ## EXT( param, icur_tmp ) ) /

{ /

if( icur_tmp == icur ) /

return this->recursive_match_next( param, icur, CSTRINGS() ); /

if( this->m_lbound ) /

{ /

icur = icur_tmp; /

++cmatches; /

} /

for( ; cmatches < this->m_lbound; ++cmatches ) /

{ /

if( ! this->m_psub->SubExprT::recursive_match_this ## EXT( param, icur ) ) /

return false; /

} /

else if( this->m_lbound ) /

{ /

return false; /

} /

do /

{ /

if( this->recursive_match_next( param, icur, CSTRINGS() ) ) /

return true; /

} /

while( cmatches < this->m_ubound && /

( ++cmatches, this->m_psub->SubExprT::recursive_match_this ## EXT( param, icur ) ) ); /

return false; /

}

#define DECLARE_ITERATIVE_MATCH_THIS(EXT) /

virtual bool iterative_match_this ## EXT( match_param & param ) const /

{ /

IterT ibegin = param.m_icur; /

size_t cmatches = 0; /

if( this->m_psub->SubExprT::iterative_match_this ## EXT( param ) ) /

{ /

if( 0 == std::distance( ibegin, param.m_icur ) ) /

{ /

cmatches = this->m_ubound; /

} /

else if( this->m_lbound ) /

{ /

for( ++cmatches; cmatches < this->m_lbound; ++cmatches ) /

{ /

if( ! this->m_psub->SubExprT::iterative_match_this ## EXT( param ) ) /

{ /

param.m_icur = ibegin; /

return false; /

} /

else /

{ /

param.m_icur = ibegin; /

} /

else if( this->m_lbound ) /

{ /

return false; /

} /

this->_push_frame( param.m_pstack, ibegin, cmatches ); /

param.m_pnext = this->next(); /

return true; /

}

#define DECLARE_ITERATIVE_REMATCH_THIS(EXT) /

virtual bool iterative_rematch_this ## EXT( match_param & param ) const /

{ /

typedef std::pair top_type; /

size_t & cmatches = REGEX_VC6( param.m_pstack->top( type2type() ).second ) /

REGEX_NVC6( param.m_pstack->template top().second ); /

if( cmatches == this->m_ubound || ! this->m_psub->SubExprT::iterative_match_this ## EXT( param ) ) /

{ /

this->_pop_frame( param ); /

return false; /

} /

++cmatches; /

param.m_pnext = this->next(); /

return true; /

}

DECLARE_RECURSIVE_MATCH_ALL(false_t,_s)

DECLARE_RECURSIVE_MATCH_ALL(true_t,_c)

DECLARE_ITERATIVE_MATCH_THIS(_s)

DECLARE_ITERATIVE_MATCH_THIS(_c)

DECLARE_ITERATIVE_REMATCH_THIS(_s)

DECLARE_ITERATIVE_REMATCH_THIS(_c)

#undef DECLARE_RECURSIVE_MATCH_ALL

#undef DECLARE_ITERATIVE_MATCH_THIS

#undef DECLARE_ITERATIVE_REMATCH_THIS

};

template< typename CharT >

struct char_nocase

{

CharT m_chlo;

CharT m_chhi;

};

template< typename IterT >

class match_char : public sub_expr

{

match_char & operator=( match_char const & );

public:

typedef typename sub_expr::char_type char_type;

virtual width_type width_this( width_param & )

{

width_type width = { 1, 1 };

return width;

}

virtual bool iterative_rematch_this_s( match_param & param ) const

{

--param.m_icur;

return false;

}

virtual bool iterative_rematch_this_c( match_param & param ) const

{

--param.m_icur;

return false;

}

};

template< typename IterT, typename CharT >

class match_char_t : public match_char

{

match_char_t & operator=( match_char_t const & );

public:

match_char_t( CharT const & ch )

: m_ch( ch )

{

}

virtual sub_expr * quantify( size_t lbound, size_t ubound, bool greedy, regex_arena & arena )

{

if( greedy )

return new( arena ) max_atom_quantifier >( this, lbound, ubound );

else

return new( arena ) min_atom_quantifier >( this, lbound, ubound );

}

virtual bool recursive_match_all_s( match_param & param, IterT icur ) const

{

return ( match_char_t::recursive_match_this_s( param, icur ) && this->recursive_match_next( param, icur, false_t() ) );

}

virtual bool recursive_match_all_c( match_param & param, IterT icur ) const

{

return ( match_char_t::recursive_match_this_c( param, icur ) && this->recursive_match_next( param, icur, true_t() ) );

}

virtual bool recursive_match_this_s( match_param & param, IterT & icur ) const

{

return _do_match_this REGEX_NVC6() ( param, icur REGEX_VC6(COMMA false_t()) );

}

virtual bool recursive_match_this_c( match_param & param, IterT & icur ) const

{

return _do_match_this REGEX_NVC6() ( param, icur REGEX_VC6(COMMA true_t()) );

}

virtual bool iterative_match_this_s( match_param & param ) const

{

param.m_pnext = this->next();

return _do_match_this REGEX_NVC6() ( param, param.m_icur REGEX_VC6(COMMA false_t()) );

}

virtual bool iterative_match_this_c( match_param & param ) const

{

param.m_pnext = this->next();

return _do_match_this REGEX_NVC6() ( param, param.m_icur REGEX_VC6(COMMA true_t()) );

}

virtual bool peek_this( peek_param & peek ) const

{

_do_peek_this( peek, m_ch );

return true;

}

private:

static bool eq( char_type left, char_type right )

{

return traits_type::eq( left, right );

}

static bool eq( char_type left, char_nocase right )

{

return traits_type::eq( left, right.m_chlo ) ||

traits_type::eq( left, right.m_chhi );

}

static void _do_peek_this( peek_param & peek, char_type ch )

{

peek.m_cchars = 1;

peek.m_rgchars[0] = ch;

peek.m_must_have.m_has = false;

}

static void _do_peek_this( peek_param & peek, char_nocase ch )

{

peek.m_cchars = 2;

peek.m_rgchars[0] = ch.m_chlo;

peek.m_rgchars[1] = ch.m_chhi;

peek.m_must_have.m_has = false;

}

template< typename CStringsT >

bool _do_match_this( match_param & param, IterT & icur REGEX_VC6(COMMA CStringsT) ) const

{

if( eos_t::eval( param, icur ) || ! eq( *icur, m_ch ) )

return false;

++icur;

return true;

}

CharT const m_ch;

};

template< typename IterT >

inline match_char * create_char

(

typename std::iterator_traits::value_type ch,

REGEX_FLAGS flags,

regex_arena & arena

)

{

typedef typename std::iterator_traits::value_type char_type;

typedef std::char_traits traits_type;

switch( NOCASE & flags )

{

case 0:

return new( arena ) match_char_t( ch );

case NOCASE:

{

char_nocase nocase = { regex_tolower( ch ), regex_toupper( ch ) };

if( traits_type::eq( nocase.m_chlo, nocase.m_chhi ) )

return new( arena ) match_char_t( ch );

else

return new( arena ) match_char_t >( nocase );

}

default:

REGEX_ASSERT(false);

return 0;

}

template< typename IterT >

class match_literal : public sub_expr

{

match_literal & operator=( match_literal const & );

public:

typedef typename sub_expr::char_type char_type;

typedef std::basic_string string_type;

typedef typename string_type::iterator iterator;

typedef typename string_type::const_iterator const_iterator;

typedef typename std::iterator_traits::difference_type diff_type;

match_literal( const_iterator ibegin, const_iterator iend )

: m_ibegin( ibegin )

, m_iend( iend )

, m_dist( std::distance( m_ibegin, m_iend ) )

{

}

const_iterator const m_ibegin;

const_iterator const m_iend;

diff_type const m_dist; // must be signed integral type

virtual width_type width_this( width_param & )

{

width_type width = { static_cast( m_dist ), static_cast( m_dist ) };

return width;

}

virtual bool iterative_rematch_this_s( match_param & param ) const

{

std::advance( param.m_icur, -m_dist );

return false;

}

virtual bool iterative_rematch_this_c( match_param & param ) const

{

std::advance( param.m_icur, -m_dist );

return false;

}

};

template< typename IterT >

class match_literal_t : public match_literal

{

match_literal_t & operator=( match_literal_t const & );

public:

typedef typename match_literal::char_type char_type;

typedef typename match_literal::string_type string_type;

typedef typename match_literal::iterator iterator;

typedef typename match_literal::const_iterator const_iterator;

match_literal_t( const_iterator ibegin, const_iterator iend )

: match_literal( ibegin, iend )

{

}

virtual sub_expr * quantify( size_t lbound, size_t ubound, bool greedy, regex_arena & arena )

{

if( greedy )

return new( arena ) max_atom_quantifier >( this, lbound, ubound );

else

return new( arena ) min_atom_quantifier >( this, lbound, ubound );

}

virtual bool recursive_match_all_s( match_param & param, IterT icur ) const

{

return ( match_literal_t::recursive_match_this_s( param, icur ) && this->recursive_match_next( param, icur, false_t() ) );

}

virtual bool recursive_match_all_c( match_param & param, IterT icur ) const

{

return ( match_literal_t::recursive_match_this_c( param, icur ) && this->recursive_match_next( param, icur, true_t() ) );

}

virtual bool recursive_match_this_s( match_param & param, IterT & icur ) const

{

return _do_match_this REGEX_NVC6() ( param, icur REGEX_VC6(COMMA false_t()) );

}

virtual bool recursive_match_this_c( match_param & param, IterT & icur ) const

{

return _do_match_this REGEX_NVC6() ( param, icur REGEX_VC6(COMMA true_t()) );

}

virtual bool iterative_match_this_s( match_param & param ) const

{

param.m_pnext = this->next();

return _do_match_this REGEX_NVC6() ( param, param.m_icur REGEX_VC6(COMMA false_t()) );

}

virtual bool iterative_match_this_c( match_param & param ) const

{

param.m_pnext = this->next();

return _do_match_this REGEX_NVC6() ( param, param.m_icur REGEX_VC6(COMMA true_t()) );

}

virtual bool peek_this( peek_param & peek ) const

{

peek.m_cchars = 1;

peek.m_rgchars[0] = *this->m_ibegin;

peek.m_must_have.m_has = true;

peek.m_must_have.m_begin = this->m_ibegin;

peek.m_must_have.m_end = this->m_iend;

peek.m_must_have.m_lower = 0;

return true;

}

private:

template< typename CStringsT >

bool _do_match_this( match_param & param, IterT & icur REGEX_VC6(COMMA CStringsT) ) const

{

IterT icur_tmp = icur;

const_iterator ithis = this->m_ibegin;

for( ; this->m_iend != ithis; ++icur_tmp, ++ithis )

{

if( eos_t::eval( param, icur_tmp ) || ! traits_type::eq( *ithis, *icur_tmp ) )

return false;

}

icur = icur_tmp;

return true;

}

};

template< typename IterT >

class match_literal_nocase_t : public match_literal

{

match_literal_nocase_t & operator=( match_literal_nocase_t const & );

public:

typedef typename match_literal::char_type char_type;

typedef typename match_literal::string_type string_type;

typedef typename match_literal::iterator iterator;

typedef typename match_literal::const_iterator const_iterator;

match_literal_nocase_t( iterator ibegin, const_iterator iend, regex_arena & arena )

: match_literal( ibegin, iend )

, m_szlower( arena_allocator( arena ).allocate( m_dist ) )

{

// Copy from ibegin to m_szlower

std::copy( this->m_ibegin, this->m_iend, m_szlower );

// Store the uppercase version of the literal in [ m_ibegin, m_iend ).

regex_toupper( ibegin, iend );

// Store the lowercase version of the literal in m_strlower.

regex_tolower( m_szlower, m_szlower + this->m_dist );

}

virtual sub_expr * quantify( size_t lbound, size_t ubound, bool greedy, regex_arena & arena )

{

if( greedy )

return new( arena ) max_atom_quantifier >( this, lbound, ubound );

else

return new( arena ) min_atom_quantifier >( this, lbound, ubound );

}

virtual bool recursive_match_all_s( match_param & param, IterT icur ) const

{

return ( match_literal_nocase_t::recursive_match_this_s( param, icur ) && this->recursive_match_next( param, icur, false_t() ) );

}

virtual bool recursive_match_all_c( match_param & param, IterT icur ) const

{

return ( match_literal_nocase_t::recursive_match_this_c( param, icur ) && this->recursive_match_next( param, icur, true_t() ) );

}

virtual bool recursive_match_this_s( match_param & param, IterT & icur ) const

{

return _do_match_this REGEX_NVC6() ( param, icur REGEX_VC6(COMMA false_t()) );

}

virtual bool recursive_match_this_c( match_param & param, IterT & icur ) const

{

return _do_match_this REGEX_NVC6() ( param, icur REGEX_VC6(COMMA true_t()) );

}

virtual bool iterative_match_this_s( match_param & param ) const

{

param.m_pnext = this->next();

return _do_match_this REGEX_NVC6() ( param, param.m_icur REGEX_VC6(COMMA false_t()) );

}

virtual bool iterative_match_this_c( match_param & param ) const

{

param.m_pnext = this->next();

return _do_match_this REGEX_NVC6() ( param, param.m_icur REGEX_VC6(COMMA true_t()) );

}

virtual bool peek_this( peek_param & peek ) const

{

peek.m_cchars = 2;

peek.m_rgchars[0] = *this->m_ibegin;

peek.m_rgchars[1] = *m_szlower;

peek.m_must_have.m_has = true;

peek.m_must_have.m_begin = this->m_ibegin;

peek.m_must_have.m_end = this->m_iend;

peek.m_must_have.m_lower = m_szlower;

return true;

}

private:

// Allocated from a regex arena. The memory will be cleaned up

// when the arena is deallocated.

char_type *const m_szlower;

template< typename CStringsT >

bool _do_match_this( match_param & param, IterT & icur REGEX_VC6(COMMA CStringsT) ) const

{

IterT icur_tmp = icur;

const_iterator ithisu = this->m_ibegin; // uppercase

char_type const * ithisl = m_szlower; // lowercase

for( ; this->m_iend != ithisu; ++icur_tmp, ++ithisu, ++ithisl )

{

if( eos_t::eval( param, icur_tmp ) ||

( ! traits_type::eq( *ithisu, *icur_tmp ) &&

! traits_type::eq( *ithisl, *icur_tmp ) ) )

return false;

}

icur = icur_tmp;

return true;

}

};

template< typename IterT, typename IBeginT, typename IEndT >

inline sub_expr * create_literal

(

IBeginT ibegin,

IEndT iend,

REGEX_FLAGS flags,

regex_arena & arena

)

{

// A match_char is faster than a match_literal, so prefer it

// when the literal to match is only 1 char wide.

if( 1 == std::distance( ibegin, iend ) )

{

return create_char( *ibegin, flags, arena );

}

switch( NOCASE & flags )

{

case 0:

return new( arena ) match_literal_t( ibegin, iend );

case NOCASE:

return new( arena ) match_literal_nocase_t( ibegin, iend, arena );

default:

REGEX_ASSERT(false);

return 0;

}

template< typename IterT >

class match_any : public sub_expr

{

public:

virtual width_type width_this( width_param & )

{

width_type width = { 1, 1 };

return width;

}

virtual bool iterative_rematch_this_s( match_param & param ) const

{

--param.m_icur;

return false;

}

virtual bool iterative_rematch_this_c( match_param & param ) const

{

--param.m_icur;

return false;

}

};

template< typename IterT, typename EosWrapT >

class match_any_t : public match_any

{

bool _do_match_this_s( match_param & param, IterT & icur ) const

{

if( EosWrapT::op_type::eval( param, icur ) )

return false;

++icur;

return true;

}

bool _do_match_this_c( match_param & param, IterT & icur ) const

{

if( EosWrapT::opc_type::eval( param, icur ) )

return false;

++icur;

return true;

}

public:

virtual sub_expr * quantify( size_t lbound, size_t ubound, bool greedy, regex_arena & arena )

{

if( greedy )

return new( arena ) max_atom_quantifier >( this, lbound, ubound );

else

return new( arena ) min_atom_quantifier >( this, lbound, ubound );

}

virtual bool recursive_match_all_s( match_param & param, IterT icur ) const

{

return ( match_any_t::recursive_match_this_s( param, icur ) && this->recursive_match_next( param, icur, false_t() ) );

}

virtual bool recursive_match_all_c( match_param & param, IterT icur ) const

{

return ( match_any_t::recursive_match_this_c( param, icur ) && this->recursive_match_next( param, icur, true_t() ) );

}

virtual bool recursive_match_this_s( match_param & param, IterT & icur ) const

{

return _do_match_this_s( param, icur );

}

virtual bool recursive_match_this_c( match_param & param, IterT & icur ) const

{

return _do_match_this_c( param, icur );

}

virtual bool iterative_match_this_s( match_param & param ) const

{

param.m_pnext = this->next();

return _do_match_this_s( param, param.m_icur );

}

virtual bool iterative_match_this_c( match_param & param ) const

{

param.m_pnext = this->next();

return _do_match_this_c( param, param.m_icur );

}

};

template< typename IterT >

inline match_any * create_any( REGEX_FLAGS flags, regex_arena & arena )

{

switch( SINGLELINE & flags )

{

case 0:

return new( arena ) match_any_t();

case SINGLELINE:

return new( arena ) match_any_t();

default:

REGEX_ASSERT(false);

return 0;

}

template< typename IterT >

class match_charset : public sub_expr

{

public:

virtual width_type width_this( width_param & )

{

width_type width = { 1, 1 };

return width;

}

virtual bool iterative_rematch_this_s( match_param & param ) const

{

--param.m_icur;

return false;

}

virtual bool iterative_rematch_this_c( match_param & param ) const

{

--param.m_icur;

return false;

}

};

template< typename IterT, typename CharSetPtrT, bool CaseT >

class match_charset_t : public match_charset

{

CharSetPtrT const m_pcs;

match_charset_t & operator=( match_charset_t const & );

template< typename CStringsT >

bool _do_match_this( match_param & param, IterT & icur REGEX_VC6(COMMA CStringsT) ) const

{

if( eos_t::eval( param, icur ) ||

! m_pcs->REGEX_NVC6(template) in REGEX_NVC6()( *icur REGEX_VC6(COMMA bool2type()) ) )

return false;

++icur;

return true;

}

public:

match_charset_t( CharSetPtrT pcs )

: m_pcs( pcs )

{

}

virtual sub_expr * quantify( size_t lbound, size_t ubound, bool greedy, regex_arena & arena )

{

if( greedy )

return new( arena ) max_atom_quantifier >( this, lbound, ubound );

else

return new( arena ) min_atom_quantifier >( this, lbound, ubound );

}

virtual bool recursive_match_all_s( match_param & param, IterT icur ) const

{

return ( match_charset_t::recursive_match_this_s( param, icur ) && this->recursive_match_next( param, icur, false_t() ) );

}

virtual bool recursive_match_all_c( match_param & param, IterT icur ) const

{

return ( match_charset_t::recursive_match_this_c( param, icur ) && this->recursive_match_next( param, icur, true_t() ) );

}

virtual bool recursive_match_this_s( match_param & param, IterT & icur ) const

{

return _do_match_this REGEX_NVC6() ( param, icur REGEX_VC6(COMMA false_t()) );

}

virtual bool recursive_match_this_c( match_param & param, IterT & icur ) const

{

return _do_match_this REGEX_NVC6() ( param, icur REGEX_VC6(COMMA true_t()) );

}

virtual bool iterative_match_this_s( match_param & param ) const

{

param.m_pnext = this->next();

return _do_match_this REGEX_NVC6() ( param, param.m_icur REGEX_VC6(COMMA false_t()) );

}

virtual bool iterative_match_this_c( match_param & param ) const

{

param.m_pnext = this->next();

return _do_match_this REGEX_NVC6() ( param, param.m_icur REGEX_VC6(COMMA true_t()) );

}

};

template< typename IterT >

inline match_charset * create_charset

(

charset const & cs,

REGEX_FLAGS flags,

regex_arena & arena

)

{

switch( NOCASE & flags )

{

case 0:

return new( arena ) match_charset_t( &cs );

case NOCASE:

return new( arena ) match_charset_t( &cs );

default:

REGEX_ASSERT(false);

return 0;

}

template< typename IterT >

inline match_charset * create_custom_charset

(

custom_charset const * pcs,

REGEX_FLAGS flags,

regex_arena & arena

)

{

typedef std::auto_ptr auto_charset;

auto_charset acs( pcs );

switch( NOCASE & flags )

{

case 0:

return new( arena ) match_charset_t( acs );

case NOCASE:

return new( arena ) match_charset_t( acs );

default:

REGEX_ASSERT(false);

return 0;

}

template< bool IsBoundaryT >

struct word_boundary

{

static bool eval( bool fprevword, bool fthisword )

{

return IsBoundaryT == ( fprevword != fthisword );

}

};

struct word_start

{

static bool eval( bool fprevword, bool fthisword )

{

return ! fprevword && fthisword;

}

};

struct word_stop

{

static bool eval( bool fprevword, bool fthisword )

{

return fprevword && ! fthisword;

}

};

template< typename IterT, typename CondT >

class word_assertion_t : public assertion

{

word_assertion_t & operator=( word_assertion_t const & );

public:

typedef typename assertion::char_type char_type;

word_assertion_t()

: m_isword( intrinsic_charsets::get_word_charset() )

{

}

virtual bool recursive_match_all_s( match_param & param, IterT icur ) const

{

return ( word_assertion_t::recursive_match_this_s( param, icur ) && this->recursive_match_next( param, icur, false_t() ) );

}

virtual bool recursive_match_all_c( match_param & param, IterT icur ) const

{

return ( word_assertion_t::recursive_match_this_c( param, icur ) && this->recursive_match_next( param, icur, true_t() ) );

}

virtual bool recursive_match_this_s( match_param & param, IterT & icur ) const

{

return _do_match_this REGEX_NVC6() ( param, icur REGEX_VC6(COMMA false_t()) );

}

virtual bool recursive_match_this_c( match_param & param, IterT & icur ) const

{

return _do_match_this REGEX_NVC6() ( param, icur REGEX_VC6(COMMA true_t()) );

}

virtual bool iterative_match_this_s( match_param & param ) const

{

param.m_pnext = this->next();

return _do_match_this REGEX_NVC6() ( param, param.m_icur REGEX_VC6(COMMA false_t()) );

}

virtual bool iterative_match_this_c( match_param & param ) const

{

param.m_pnext = this->next();

return _do_match_this REGEX_NVC6() ( param, param.m_icur REGEX_VC6(COMMA true_t()) );

}

private:

bool _is_word( char_type ch ) const

{

return REGEX_VC6( m_isword.in( ch COMMA true_t() ) )

REGEX_NVC6( m_isword.template in( ch ) );

}

template< typename CStringsT >

bool _do_match_this( match_param & param, IterT icur REGEX_VC6(COMMA CStringsT) ) const

{

bool const fthisword = ! eos_t::eval( param, icur ) && _is_word( *icur );

bool const fprevword = ! bos_t::eval( param, icur ) && _is_word( *--icur );

return CondT::eval( fprevword, fthisword );

}

charset const & m_isword;

};

template< typename IterT >

inline assertion * create_word_boundary

(

bool fisboundary,

REGEX_FLAGS, // flags

regex_arena & arena

)

{

if( fisboundary )

return new( arena ) word_assertion_t >();

else

return new( arena ) word_assertion_t >();

}

template< typename IterT >

inline assertion * create_word_start( REGEX_FLAGS, regex_arena & arena )

{

return new( arena ) word_assertion_t();

}

template< typename IterT >

inline assertion * create_word_stop( REGEX_FLAGS, regex_arena & arena )

{

return new( arena ) word_assertion_t();

}

// an "extent" represents the range of backrefs that can be modified as the

// result of a look-ahead or look-behind

typedef std::pair extent_type;

template< typename IterT > class max_group_quantifier;

template< typename IterT > class min_group_quantifier;

template< typename IterT >

class match_group_base : public sub_expr

{

protected:

typedef slist*,regex_arena> alt_list_type;

private:

match_group_base & operator=( match_group_base const & );

void _push_frame( match_param & param ) const

{

unsafe_stack * ps = param.m_pstack;

if( size_t( -1 ) != m_cgroup )

{

IterT & reserved1 = param.m_prgbackrefs[ m_cgroup ].reserved1;

ps->push( reserved1 );

reserved1 = param.m_icur;

}

ps->push( m_rgalternates.begin() );

}

void _pop_frame( match_param & param ) const

{

typedef typename alt_list_type::const_iterator iter_type;

unsafe_stack * ps = param.m_pstack;

REGEX_VC6( ps->pop( type2type() COMMA 0 ); )

REGEX_NVC6( ps->template pop(); )

if( size_t( -1 ) != m_cgroup )

ps->pop( param.m_prgbackrefs[ m_cgroup ].reserved1 );

}

template< typename CStringsT >

bool _do_recursive_match_all( match_param & param, IterT icur REGEX_VC6(COMMA CStringsT) ) const

{

typedef typename alt_list_type::const_iterator iter_type;

if( 0 != m_peek_chars_begin &&

( eos_t::eval( param, icur ) ||

m_peek_chars_end == std::find( m_peek_chars_begin, m_peek_chars_end, *icur ) ) )

{

return false;

}

if( size_t( -1 ) != m_cgroup ) // could be -1 if this is a lookahead_assertion

{

IterT & reserved1 = param.m_prgbackrefs[ m_cgroup ].reserved1;

IterT old_ibegin = reserved1;

reserved1 = icur;

for( iter_type ialt = m_rgalternates.begin(); m_rgalternates.end() != ialt; ++ialt )

{

if( (*ialt)->recursive_match_all( param, icur, CStringsT() ) )

return true;

}

reserved1 = old_ibegin;

}

else

{

for( iter_type ialt = m_rgalternates.begin(); m_rgalternates.end() != ialt; ++ialt )

{

if( (*ialt)->recursive_match_all( param, icur, CStringsT() ) )

return true;

}

return false;

}

template< typename CStringsT >

bool _do_iterative_match_this( match_param & param REGEX_VC6(COMMA CStringsT) ) const

{

if( 0 != m_peek_chars_begin &&

( eos_t::eval( param, param.m_icur ) ||

m_peek_chars_end == std::find( m_peek_chars_begin, m_peek_chars_end, *param.m_icur ) ) )

{

return false;

}

_push_frame( param );

param.m_pnext = *m_rgalternates.begin();

return true;

}

bool _do_iterative_rematch_this( match_param & param ) const

{

typedef typename alt_list_type::const_iterator iter_type;

iter_type next_iter = ++param.m_pstack->REGEX_NVC6(template) top REGEX_NVC6() ( REGEX_VC6(type2type()) );

if( m_rgalternates.end() != next_iter )

{

param.m_pnext = *next_iter;

return true;

}

_pop_frame( param );

return false;

}

public:

typedef typename sub_expr::char_type char_type;

match_group_base( size_t cgroup, regex_arena & arena )

: m_rgalternates( arena_allocator*>( arena ) )

, m_cgroup( cgroup )

, m_nwidth( uninit_width() )

, m_pptail( 0 )

, m_peek_chars_end( 0 )

{

}

// Derived classes that own the end_group object must have a

// destructor, and that destructor must call _cleanup().

virtual ~match_group_base() = 0;

virtual bool recursive_match_all_s( match_param & param, IterT icur ) const

{

return _do_recursive_match_all REGEX_NVC6() ( param, icur REGEX_VC6(COMMA false_t()) );

}

virtual bool recursive_match_all_c( match_param & param, IterT icur ) const

{

return _do_recursive_match_all REGEX_NVC6() ( param, icur REGEX_VC6(COMMA true_t()) );

}

virtual bool iterative_match_this_s( match_param & param ) const

{

return _do_iterative_match_this REGEX_NVC6() ( param REGEX_VC6(COMMA false_t()) );

}

virtual bool iterative_match_this_c( match_param & param ) const

{

return _do_iterative_match_this REGEX_NVC6() ( param REGEX_VC6(COMMA true_t()) );

}

virtual bool iterative_rematch_this_s( match_param & param ) const

{

return _do_iterative_rematch_this( param );

}

virtual bool iterative_rematch_this_c( match_param & param ) const

{

return _do_iterative_rematch_this( param );

}

size_t group_number() const

{

return m_cgroup;

}

void add_item( sub_expr * pitem )

{

*m_pptail = pitem;

m_pptail = pitem->pnext();

}

void add_alternate()

{

m_rgalternates.push_front( 0 );

m_pptail = &*m_rgalternates.begin();

}

void end_alternate()

{

*m_pptail = _get_end_group();

}

void open_group()

{

add_alternate();

}

must_have close_group( regex_arena & arena )

{

end_alternate();

m_rgalternates.reverse();

return get_peek_chars( arena );

}

must_have get_peek_chars( regex_arena & arena )

{

m_peek_chars_begin = 0;

// optimization: find the lookahead characters for each alternate

size_t total_chars = 0;

peek_param peek;

typename alt_list_type::const_iterator ialt;

for( ialt = m_rgalternates.begin(); m_rgalternates.end() != ialt; ++ialt )

{

if( ! (*ialt)->peek_this( peek ) )

{

peek.m_must_have.m_has = false;

return peek.m_must_have;

}

total_chars += peek.m_cchars;

}

arena_allocator alloc( arena );

m_peek_chars_begin = alloc.allocate( total_chars, 0 );

m_peek_chars_end = m_peek_chars_begin;

for( ialt = m_rgalternates.begin(); m_rgalternates.end() != ialt; ++ialt )

{

(*ialt)->peek_this( peek );

char_type const * in = ( peek.m_cchars > 2 ) ? peek.m_pchars : peek.m_rgchars;

m_peek_chars_end = std::copy( in, in + peek.m_cchars, m_peek_chars_end );

}

std::sort( m_peek_chars_begin, m_peek_chars_end );

m_peek_chars_end = std::unique( m_peek_chars_begin, m_peek_chars_end );

if( 1 < m_rgalternates.size() )

peek.m_must_have.m_has = false;

return peek.m_must_have;

}

size_t calternates() const

{

return m_rgalternates.size();

}

virtual void set_extent( extent_type const & )

{

}

width_type group_width

(

std::vector*> & rggroups,

std::list const & invisible_groups

)

{

// This should only be called on the top node

REGEX_ASSERT( 0 == m_cgroup );

if( uninit_width() == m_nwidth )

{

width_param param( rggroups, invisible_groups );

match_group_base::width_this( param );

}

return m_nwidth;

}

virtual width_type width_this( width_param & param )

{

typedef typename alt_list_type::const_iterator iter_type;

width_type width = { size_t( -1 ), 0 };

for( iter_type ialt = m_rgalternates.begin(); worst_width != width && m_rgalternates.end() != ialt; ++ialt )

{

// prevent possible infinite recursion

if( m_cgroup < param.m_rggroups.size() )

param.m_rggroups[ m_cgroup ] = 0;

width_type temp_width = ( *ialt )->get_width( param );

if( m_cgroup < param.m_rggroups.size() )

param.m_rggroups[ m_cgroup ] = this;

width.m_min = regex_min( width.m_min, temp_width.m_min );

width.m_max = regex_max( width.m_max, temp_width.m_max );

}

return m_nwidth = width;

}

virtual bool peek_this( peek_param & peek ) const

{

if( 0 == m_peek_chars_begin )

return false;

peek.m_cchars = std::distance( m_peek_chars_begin, m_peek_chars_end );

if( 2 < peek.m_cchars )

peek.m_pchars = m_peek_chars_begin;

else

std::copy( m_peek_chars_begin, m_peek_chars_end, peek.m_rgchars );

peek.m_must_have.m_has = false;

if( 1 == m_rgalternates.size() )

{

peek_param local_peek;

(*m_rgalternates.begin())->peek_this( local_peek );

peek.m_must_have = local_peek.m_must_have;

}

return true;

}

protected:

void _cleanup()

{

typedef typename alt_list_type::const_iterator iter_type;

for( iter_type ialt = m_rgalternates.begin(); m_rgalternates.end() != ialt; ++ialt )

delete *ialt;

m_rgalternates.clear();

}

virtual sub_expr * _get_end_group() = 0;

alt_list_type m_rgalternates;

size_t const m_cgroup;

width_type m_nwidth;

union

{

sub_expr ** m_pptail; // only used when adding elements

char_type * m_peek_chars_begin;

};

char_type * m_peek_chars_end;

};

template< typename IterT >

inline match_group_base::~match_group_base()

{

}

// A indestructable_sub_expr is an object that brings itself back

// to life after explicitly being deleted. It is used

// to ease clean-up of the sub_expr graph, where most

// nodes are dynamically allocated, but some nodes are

// members of other nodes and are not dynamically allocated.

// The recursive delete of the sub_expr graph causes

// delete to be ( incorrectly ) called on these members.

// By inheriting these members from indestructable_sub_expr,

// explicit attempts to delete the object will have no

// effect. ( Actually, the object will be destructed and

// then immediately reconstructed. ) This is accomplished

// by calling placement new in operator delete.

template< typename IterT, typename T >

class indestructable_sub_expr : public sub_expr

{

static void * operator new( size_t, regex_arena & );

static void operator delete( void *, regex_arena & );

protected:

static void * operator new( size_t, void * pv ) { return pv; }

static void operator delete( void *, void * ) {}

public:

virtual ~indestructable_sub_expr() {}

static void operator delete( void * pv ) { ::new( pv ) T; }

};

template< typename IterT >

class match_group : public match_group_base

{

match_group( match_group const & );

match_group & operator=( match_group const & );

public:

match_group( size_t cgroup, regex_arena & arena )

: match_group_base( cgroup, arena )

, m_end_group( this )

{

}

virtual ~match_group()

{

this->_cleanup();

}

virtual sub_expr * quantify( size_t lbound, size_t ubound, bool greedy, regex_arena & arena )

{

if( greedy )

return new( arena ) max_group_quantifier( this, lbound, ubound );

else

return new( arena ) min_group_quantifier( this, lbound, ubound );

}

protected:

typedef typename match_group_base::alt_list_type alt_list_type;

struct old_backref

{

IterT m_ibegin;

IterT m_iend;

bool m_matched;

old_backref() {}

old_backref( backref_tag const & br )

: m_ibegin( br.first )

, m_iend( br.second )

, m_matched( br.matched )

{

}

};

static void restore_backref( backref_tag & br, old_backref const & old_br )

{

br.first = old_br.m_ibegin;

br.second = old_br.m_iend;

br.matched = old_br.m_matched;

}

template< typename CStringsT >

bool _do_call_back( match_param & param, IterT icur REGEX_VC6(COMMA CStringsT) ) const

{

if( size_t( -1 ) != this->m_cgroup )

{

backref_tag & br = param.m_prgbackrefs[ this->m_cgroup ];

// Save the relevant portions of the backref in an old_backref struct

old_backref old_br( br );

br.first = br.reserved1;

br.second = icur;

br.matched = true;

if( this->recursive_match_next( param, icur, CStringsT() ) )

return true;

// Restore the backref to its saved state

restore_backref( br, old_br );

}

else

{

if( this->recursive_match_next( param, icur, CStringsT() ) )

return true;

}

return false;

}

class end_group : public indestructable_sub_expr

{

match_group const *const m_pgroup;

end_group & operator=( end_group const & );

void _push_frame( match_param & param ) const

{

size_t cgroup = m_pgroup->group_number();

if( size_t( -1 ) != cgroup )

{

backref_tag & br = param.m_prgbackrefs[ cgroup ];

old_backref old_br( br );

param.m_pstack->push( old_br );

br.first = br.reserved1;

br.second = param.m_icur;

br.matched = true;

}

void _pop_frame( match_param & param ) const

{

size_t cgroup = m_pgroup->group_number();

if( size_t( -1 ) != cgroup )

{

old_backref old_br;

param.m_pstack->pop( old_br );

match_group::restore_backref( param.m_prgbackrefs[ cgroup ], old_br );

}

bool _do_iterative_match_this( match_param & param ) const

{

_push_frame( param );

param.m_pnext = m_pgroup->next();

return true;

}

bool _do_iterative_rematch_this( match_param & param ) const

{

_pop_frame( param );

return false;

}

public:

end_group( match_group const * pgroup = 0 )

: m_pgroup( pgroup )

{

}

virtual bool recursive_match_all_s( match_param & param, IterT icur ) const

{

return m_pgroup->REGEX_NVC6(template) _do_call_back REGEX_NVC6()( param, icur REGEX_VC6(COMMA false_t()) );

}

virtual bool recursive_match_all_c( match_param & param, IterT icur ) const

{

return m_pgroup->REGEX_NVC6(template) _do_call_back REGEX_NVC6()( param, icur REGEX_VC6(COMMA true_t()) );

}

virtual bool iterative_match_this_s( match_param & param ) const

{

return _do_iterative_match_this( param );

}

virtual bool iterative_match_this_c( match_param & param ) const

{

return _do_iterative_match_this( param );

}

virtual bool iterative_rematch_this_s( match_param & param ) const

{

return _do_iterative_rematch_this( param );

}

virtual bool iterative_rematch_this_c( match_param & param ) const

{

return _do_iterative_rematch_this( param );

}

virtual width_type width_this( width_param & )

{

return zero_width;

}

} m_end_group;

friend class end_group;

virtual sub_expr * _get_end_group()

{

return & m_end_group;

}

};

template< typename IterT >

inline void save_backrefs( backref_tag const * ibegin, backref_tag const * iend, IterT * prgci )

{

for( ; ibegin != iend; ++ibegin, ++prgci )

{

new( prgci ) IterT( ibegin->reserved1 );

}

template< typename IterT >

inline void restore_backrefs( backref_tag * ibegin, backref_tag * iend, IterT const * prgci )

{

for( ; ibegin != iend; ++ibegin, ++prgci )

{

ibegin->reserved1 = *prgci;

prgci->~IterT();

}

template< typename IterT >

class group_wrapper : public sub_expr

{

match_group_base const *const m_pgroup;

group_wrapper & operator=( group_wrapper const & );

public:

group_wrapper( match_group_base const * pgroup )

: m_pgroup( pgroup )

{

}

virtual bool iterative_match_this_s( match_param & param ) const

{

return m_pgroup->match_group_base::iterative_match_this_s( param );

}

virtual bool iterative_match_this_c( match_param & param ) const

{

return m_pgroup->match_group_base::iterative_match_this_c( param );

}

virtual bool iterative_rematch_this_s( match_param & param ) const

{

return m_pgroup->match_group_base::iterative_rematch_this_s( param );

}

virtual bool iterative_rematch_this_c( match_param & param ) const

{

return m_pgroup->match_group_base::iterative_rematch_this_c( param );

}

virtual width_type width_this( width_param & )

{

return zero_width;

}

};

struct deleter

{

template< typename T >

void operator()( T const & t )

{

t.T::~T();

}

};

// Behaves like a lookahead assertion if m_cgroup is -1, or like

// an independent group otherwise.

template< typename IterT >

class independent_group_base : public match_group_base

{

independent_group_base( independent_group_base const & );

independent_group_base & operator=( independent_group_base const & );

template< typename CStringsT >

bool _do_recursive_match_all( match_param & param, IterT icur REGEX_VC6(COMMA CStringsT) ) const

{

backref_tag * prgbr = 0;

// Copy onto the stack the part of the backref vector that could

// be modified by the lookahead.

if( m_extent.second )

{

prgbr = static_cast*>( alloca( m_extent.second * sizeof( backref_tag ) ) );

std::uninitialized_copy(

param.m_prgbackrefs + m_extent.first,

param.m_prgbackrefs + m_extent.first + m_extent.second,

prgbr );

}

// Match until the end of this group and then return

// BUGBUG can the compiler optimize this?

bool const fdomatch = CStringsT::value ?

match_group_base::recursive_match_all_c( param, icur ) :

match_group_base::recursive_match_all_s( param, icur );

if( m_fexpected == fdomatch )

{

// If m_cgroup != 1, then this is not a zero-width assertion.

if( fdomatch && size_t( -1 ) != this->m_cgroup )

icur = param.m_prgbackrefs[ this->m_cgroup ].second;

if( this->recursive_match_next( param, icur, CStringsT() ) )

{

std::for_each( prgbr, prgbr + m_extent.second, deleter() );

return true;

}

// if match_group::recursive_match_all returned true, the backrefs must be restored

if( m_extent.second && fdomatch )

std::copy( prgbr, prgbr + m_extent.second, param.m_prgbackrefs + m_extent.first );

std::for_each( prgbr, prgbr + m_extent.second, deleter() );

return false;

}

template< typename CStringsT >

bool _do_iterative_match_this( match_param & param REGEX_VC6(COMMA CStringsT) ) const

{

group_wrapper expr( this );

_push_frame( param );

IterT ibegin = param.m_icur;

bool const fdomatch = _do_match_iterative( &expr, param, param.m_icur, CStringsT() );

if( m_fexpected == fdomatch )

{

// If m_cgroup == -1, then this is a zero-width assertion.

if( fdomatch && size_t( -1 ) == this->m_cgroup )

param.m_icur = ibegin;

param.m_pnext = this->next();

return true;

}

_pop_frame( param );

return false;

}

bool _do_iterative_rematch_this( match_param & param ) const

{

_pop_frame( param );

return false;

}

public:

independent_group_base( size_t cgroup, regex_arena & arena )

: match_group_base( cgroup, arena )

, m_fexpected( true )

, m_extent( 0, 0 )

{

}

virtual void set_extent( extent_type const & ex )

{

m_extent = ex;

}

virtual bool recursive_match_all_s( match_param & param, IterT icur ) const

{

return _do_recursive_match_all REGEX_NVC6() ( param, icur REGEX_VC6(COMMA false_t()) );

}

virtual bool recursive_match_all_c( match_param & param, IterT icur ) const

{

return _do_recursive_match_all REGEX_NVC6() ( param, icur REGEX_VC6(COMMA true_t()) );

}

virtual bool iterative_match_this_s( match_param & param ) const

{

return _do_iterative_match_this REGEX_NVC6() ( param REGEX_VC6(COMMA false_t()) );

}

virtual bool iterative_match_this_c( match_param & param ) const

{

return _do_iterative_match_this REGEX_NVC6() ( param REGEX_VC6(COMMA true_t()) );

}

virtual bool iterative_rematch_this_s( match_param & param ) const

{

return _do_iterative_rematch_this( param );

}

virtual bool iterative_rematch_this_c( match_param & param ) const

{

return _do_iterative_rematch_this( param );

}

virtual bool peek_this( peek_param & peek ) const

{

if( size_t( -1 ) == this->m_cgroup )

return false;

return match_group_base::peek_this( peek );

}

protected:

void _push_frame( match_param & param ) const

{

unsafe_stack * pstack = param.m_pstack;

typedef typename match_param::backref_type backref_type;

backref_type * ibegin = param.m_prgbackrefs + m_extent.first;

backref_type * iend = ibegin + m_extent.second;

for( ; iend != ibegin; ++ibegin )

{

pstack->push( *ibegin );

}

pstack->push( param.m_icur );

}

void _pop_frame( match_param & param ) const

{

unsafe_stack * pstack = param.m_pstack;

typedef typename match_param::backref_type backref_type;

backref_type * ibegin = param.m_prgbackrefs + m_extent.first;

backref_type * iend = ibegin + m_extent.second;

pstack->pop( param.m_icur );

while( iend != ibegin )

{

pstack->pop( *--iend );

}

independent_group_base( bool const fexpected, regex_arena & arena )

: match_group_base( size_t( -1 ), arena )

, m_fexpected( fexpected )

{

}

bool const m_fexpected;

extent_type m_extent;

};

template< typename IterT >

class independent_group : public independent_group_base

{

independent_group( independent_group const & );

independent_group & operator=( independent_group const & );

public:

independent_group( size_t cgroup, regex_arena & arena )

: independent_group_base( cgroup, arena )

, m_end_group( this )

{

}

virtual ~independent_group()

{

this->_cleanup();

}

virtual sub_expr * quantify( size_t lbound, size_t ubound, bool greedy, regex_arena & arena )

{

if( greedy )

return new( arena ) max_group_quantifier( this, lbound, ubound );

else

return new( arena ) min_group_quantifier( this, lbound, ubound );

}

protected:

independent_group( bool const fexpected, regex_arena & arena )

: independent_group_base( fexpected, arena )

, m_end_group( this )

{

}

bool _do_call_back( match_param & param, IterT icur ) const

{

if( size_t( -1 ) != this->m_cgroup )

{

backref_tag & br = param.m_prgbackrefs[ this->m_cgroup ];

br.first = br.reserved1;

br.second = icur;

br.matched = true;

}

return true;

}

class end_group : public indestructable_sub_expr

{

independent_group const *const m_pgroup;

end_group & operator=( end_group const & );

bool _do_iterative_match_this( match_param & param ) const

{

size_t cgroup = m_pgroup->group_number();

if( size_t( -1 ) != cgroup )

{

backref_tag & br = param.m_prgbackrefs[ cgroup ];

br.first = br.reserved1;

br.second = param.m_icur;

br.matched = true;

}

param.m_pnext = 0;

return true;

}

public:

end_group( independent_group const * pgroup = 0 )

: m_pgroup( pgroup )

{

}

virtual bool recursive_match_all_s( match_param & param, IterT icur ) const

{

return m_pgroup->_do_call_back( param, icur );

}

virtual bool recursive_match_all_c( match_param & param, IterT icur ) const

{

return m_pgroup->_do_call_back( param, icur );

}

virtual bool iterative_match_this_s( match_param & param ) const

{

return _do_iterative_match_this( param );

}

virtual bool iterative_match_this_c( match_param & param ) const

{

return _do_iterative_match_this( param );

}

virtual width_type width_this( width_param & )

{

return zero_width;

}

} m_end_group;

friend class end_group;

virtual sub_expr * _get_end_group()

{

return & m_end_group;

}

};

template< typename IterT >

class lookahead_assertion : public independent_group

{

lookahead_assertion( lookahead_assertion const & );

lookahead_assertion & operator=( lookahead_assertion const & );

public:

lookahead_assertion( bool const fexpected, regex_arena & arena )

: independent_group( fexpected, arena )

{

}

virtual sub_expr * quantify( size_t, size_t, bool, regex_arena & )

{

throw bad_regexpr( "look-ahead assertion cannot be quantified" );

}

virtual bool is_assertion() const

{

return true;

}

virtual width_type width_this( width_param & param )

{

// calculate the group's width and store it, but return zero_width

match_group_base::width_this( param );

return zero_width;

}

virtual bool peek_this( peek_param & peek ) const

{

return this->next()->peek_this( peek );

}

};

template< typename IterT >

class lookbehind_assertion : public independent_group_base

{

lookbehind_assertion( lookbehind_assertion const & );

lookbehind_assertion & operator=( lookbehind_assertion const & );

template< typename CStringsT >

bool _do_recursive_match_all( match_param & param, IterT icur REGEX_VC6(COMMA CStringsT) ) const

{

typedef typename std::iterator_traits::difference_type diff_type;

// This is the room in the string from the start to the current position

diff_type room = std::distance( param.m_ibufferbegin, icur );

// If we don't have enough room to match the lookbehind, the match fails.

// If we wanted the match to fail, try to match the rest of the pattern.

if( this->m_nwidth.m_min > static_cast( room ) )

return this->m_fexpected ? false : this->recursive_match_next( param, icur, CStringsT() );

backref_tag * prgbr = 0;

// Copy onto the stack the part of the backref vector that could

// be modified by the lookbehind.

if( this->m_extent.second )

{

prgbr = static_cast*>( alloca( this->m_extent.second * sizeof( backref_tag ) ) );

std::uninitialized_copy(

param.m_prgbackrefs + this->m_extent.first,

param.m_prgbackrefs + this->m_extent.first + this->m_extent.second,

prgbr );

}

IterT local_ibegin = icur;

std::advance( local_ibegin, -static_cast( regex_min( this->m_nwidth.m_max, room ) ) );

IterT local_iend = icur;

std::advance( local_iend, -static_cast( this->m_nwidth.m_min ) );

// Create a local param struct that has icur as param.m_iend

match_param local_param( param.m_ibufferbegin, param.m_imatchbegin, icur, param.m_prgbackrefs, param.m_cbackrefs );

// Find the rightmost match that ends at icur.

for( IterT local_icur = local_ibegin; ; ++local_icur )

{

// Match until the end of this group and then return

// Note that we're calling recursive_match_all_s regardless of the CStringsT switch.

// This is because for the lookbehind assertion, the termination condition is when

// icur == param.m_iend, not when *icur == '/0'

bool const fmatched = match_group_base::recursive_match_all_s( local_param, local_icur );

// If the match results were what we were expecting, try to match the

// rest of the pattern. If that succeeds, return true.

if( this->m_fexpected == fmatched && this->recursive_match_next( param, icur, CStringsT() ) )

{

std::for_each( prgbr, prgbr + this->m_extent.second, deleter() );

return true;

}

// if match_group::recursive_match_all returned true, the backrefs must be restored

if( fmatched )

{

if( this->m_extent.second )

std::copy( prgbr, prgbr + this->m_extent.second, param.m_prgbackrefs + this->m_extent.first );

// Match succeeded. If this is a negative lookbehind, we didn't want it

// to succeed, so return false.

if( ! this->m_fexpected )

{

std::for_each( prgbr, prgbr + this->m_extent.second, deleter() );

return false;

}

if( local_icur == local_iend )

break;

}

// No variation of the lookbehind was satisfied in a way that permited

// the rest of the pattern to match successfully, so return false.

std::for_each( prgbr, prgbr + this->m_extent.second, deleter() );

return false;

}

template< typename CStringsT >

bool _do_iterative_match_this( match_param & param REGEX_VC6(COMMA CStringsT) ) const

{

typedef typename std::iterator_traits::difference_type diff_type;

// Save the backrefs

this->_push_frame( param );

// This is the room in the string from the start to the current position

diff_type room = std::distance( param.m_ibufferbegin, param.m_icur );

// If we don't have enough room to match the lookbehind, the match fails.

// If we wanted the match to fail, try to match the rest of the pattern.

if( this->m_nwidth.m_min > static_cast( room ) )

{

if( this->m_fexpected )

{

this->_pop_frame( param );

return false;

}

param.m_pnext = this->next();

return true;

}

IterT local_ibegin = param.m_icur;

std::advance( local_ibegin, -static_cast( regex_min( this->m_nwidth.m_max, room ) ) );

IterT local_iend = param.m_icur;

std::advance( local_iend, -static_cast( this->m_nwidth.m_min ) );

// Create a local param struct that has icur as param.m_iend

match_param local_param( param.m_ibufferbegin, param.m_imatchbegin, param.m_icur, param.m_prgbackrefs, param.m_cbackrefs );

local_param.m_pstack = param.m_pstack;

group_wrapper expr( this );

// Find the rightmost match that ends at icur.

for( IterT local_icur = local_ibegin; ; ++local_icur )

{

// Match until the end of this group and then return

// Note that we're calling _do_match_iterative_helper_s regardless of the CStringsT switch.

// This is because for the lookbehind assertion, the termination condition is when

// icur == param.m_iend, not when *icur == '/0'

bool const fmatched = regex_access::_do_match_iterative_helper_s( &expr, local_param, local_icur );

// If the match results were what we were expecting, try to match the

// rest of the pattern. If that succeeds, return true.

if( this->m_fexpected == fmatched )

{

param.m_pnext = this->next();

return true;

}

// if match_group::recursive_match_all returned true, the backrefs must be restored

if( fmatched )

{

// Restore the backrefs

this->_pop_frame( param );

// Match succeeded. If this is a negative lookbehind, we didn't want it

// to succeed, so return false.

if( ! this->m_fexpected )

return false;

// Save the backrefs again.

this->_push_frame( param );

}

if( local_icur == local_iend )

break;

}

// No variation of the lookbehind was satisfied in a way that permited

// the rest of the pattern to match successfully, so return false.

this->_pop_frame( param );

return false;

}

bool _do_iterative_rematch_this( match_param & param ) const

{

this->_pop_frame( param );

return false;

}

public:

lookbehind_assertion( bool const fexpected, regex_arena & arena )

: independent_group_base( fexpected, arena )

{

}

virtual ~lookbehind_assertion()

{

this->_cleanup();

}

virtual bool recursive_match_all_s( match_param & param, IterT icur ) const

{

return _do_recursive_match_all REGEX_NVC6() ( param, icur REGEX_VC6(COMMA false_t()) );

}

virtual bool recursive_match_all_c( match_param & param, IterT icur ) const

{

return _do_recursive_match_all REGEX_NVC6() ( param, icur REGEX_VC6(COMMA true_t()) );

}

virtual bool iterative_match_this_s( match_param & param ) const

{

return _do_iterative_match_this REGEX_NVC6() ( param REGEX_VC6(COMMA false_t()) );

}

virtual bool iterative_match_this_c( match_param & param ) const

{

return _do_iterative_match_this REGEX_NVC6() ( param REGEX_VC6(COMMA true_t()) );

}

virtual bool iterative_rematch_this_s( match_param & param ) const

{

return _do_iterative_rematch_this( param );

}

virtual bool iterative_rematch_this_c( match_param & param ) const

{

return _do_iterative_rematch_this( param );

}

virtual bool is_assertion() const

{

return true;

}

virtual width_type width_this( width_param & param )

{

// calculate the group's width and store it, but return zero_width

match_group_base::width_this( param );

return zero_width;

}

virtual bool peek_this( peek_param & peek ) const

{

return this->next()->peek_this( peek );

}

protected:

struct end_group : public indestructable_sub_expr

{

virtual bool recursive_match_all_s( match_param & param, IterT icur ) const

{

return param.m_iend == icur;

}

virtual bool recursive_match_all_c( match_param & param, IterT icur ) const

{

return param.m_iend == icur;

}

virtual bool iterative_match_this_s( match_param & param ) const

{

param.m_pnext = 0;

return param.m_iend == param.m_icur;

}

virtual bool iterative_match_this_c( match_param & param ) const

{

param.m_pnext = 0;

return param.m_iend == param.m_icur;

}

virtual width_type width_this( width_param & )

{

return zero_width;

}

} m_end_group;

virtual sub_expr * _get_end_group()

{

return & m_end_group;

}

};

template< typename IterT >

class group_quantifier : public match_quantifier

{

group_quantifier & operator=( group_quantifier const & );

bool _do_iterative_match_this( match_param & param ) const

{

_push_frame( param );

param.m_pnext = this->m_psub->next(); // ptr to end_quant

return true;

}

bool _do_iterative_rematch_this( match_param & param ) const

{

_pop_frame( param );

return false;

}

public:

group_quantifier

(

match_group_base * psub,

size_t lbound,

size_t ubound,

sub_expr * pend_quant

)

: match_quantifier( psub, lbound, ubound )

, m_group( *psub )

{

*psub->pnext() = pend_quant;

}

// sub-classes of group_quantifer that own the end_quant

// object must declare a destructor, and it must call _cleanup

virtual ~group_quantifier() = 0;

virtual bool iterative_match_this_s( match_param & param ) const

{

return _do_iterative_match_this( param );

}

virtual bool iterative_match_this_c( match_param & param ) const

{

return _do_iterative_match_this( param );

}

virtual bool iterative_rematch_this_s( match_param & param ) const

{

return _do_iterative_rematch_this( param );

}

virtual bool iterative_rematch_this_c( match_param & param ) const

{

return _do_iterative_rematch_this( param );

}

protected:

struct old_quant

{

typedef typename backref_tag::smart_iter_type smart_iter_type;

size_t reserved2;

bool reserved3;

smart_iter_type reserved4;

smart_iter_type reserved5;

old_quant()

{

}

old_quant( backref_tag const & br )

: reserved2( br.reserved2 )

, reserved3( br.reserved3 )

, reserved4( br.reserved4 )

, reserved5( br.reserved5 )

{

}

};

void _push_frame( match_param & param ) const

{

typedef typename backref_tag::smart_iter_type smart_iter_type;

backref_tag & br = param.m_prgbackrefs[ group_number() ];

old_quant old_qt( br );

param.m_pstack->push( old_qt );

br.reserved2 = 0; // nbr of times this group has matched

br.reserved3 = true; // toggle used for backtracking

br.reserved4 = static_init::value;

br.reserved5 = static_init::value;

}

void _pop_frame( match_param & param ) const

{

backref_tag & br = param.m_prgbackrefs[ group_number() ];

old_quant old_qt;

param.m_pstack->pop( old_qt );

br.reserved2 = old_qt.reserved2;

br.reserved3 = old_qt.reserved3;

br.reserved4 = old_qt.reserved4;

br.reserved5 = old_qt.reserved5;

}

size_t group_number() const

{

return m_group.group_number();

}

size_t & cmatches( match_param & param ) const

{

return param.m_prgbackrefs[ group_number() ].reserved2;

}

typename backref_tag::smart_iter_type & highwater1( match_param & param ) const

{

return param.m_prgbackrefs[ group_number() ].reserved4;

}

typename backref_tag::smart_iter_type & highwater2( match_param & param ) const

{

return param.m_prgbackrefs[ group_number() ].reserved5;

}

match_group_base const & m_group;

};

template< typename IterT >

inline group_quantifier::~group_quantifier()

{

}

template< typename IterT >

class max_group_quantifier : public group_quantifier

{

max_group_quantifier & operator=( max_group_quantifier const & );

template< typename CStringsT >

bool _do_recursive_match_all( match_param & param, IterT icur REGEX_VC6(COMMA CStringsT) ) const

{

typedef typename backref_tag::smart_iter_type smart_iter_type;

smart_iter_type old_highwater1 = this->highwater1( param );

smart_iter_type old_highwater2 = this->highwater2( param );

size_t old_cmatches = this->cmatches( param );

this->highwater1( param ) = static_init::value;

this->highwater2( param ) = icur;

this->cmatches( param ) = 0;

if( _do_recurse REGEX_NVC6() ( param, icur REGEX_VC6(COMMA CStringsT()) ) )

return true;

this->cmatches( param ) = old_cmatches;

this->highwater2( param ) = old_highwater2;

this->highwater1( param ) = old_highwater1;

return false;

}

public:

max_group_quantifier( match_group_base * psub, size_t lbound, size_t ubound )

: group_quantifier( psub, lbound, ubound, & m_end_quant )

, m_end_quant( this )

{

}

virtual ~max_group_quantifier()

{

// Must call _cleanup() here before the end_quant object

// gets destroyed.

this->_cleanup();

}

virtual bool recursive_match_all_s( match_param & param, IterT icur ) const

{

return _do_recursive_match_all REGEX_NVC6() ( param, icur REGEX_VC6(COMMA false_t()) );

}

virtual bool recursive_match_all_c( match_param & param, IterT icur ) const

{

return _do_recursive_match_all REGEX_NVC6() ( param, icur REGEX_VC6(COMMA true_t()) );

}

protected:

template< typename CStringsT >

bool _do_recurse( match_param & param, IterT icur REGEX_VC6(COMMA CStringsT) ) const

{

if( this->m_ubound == this->cmatches( param ) )

return this->recursive_match_next( param, icur, CStringsT() );

++this->cmatches( param );

if( this->m_psub->recursive_match_all( param, icur, CStringsT() ) )

return true;

if( --this->cmatches( param ) < this->m_lbound )

return false;

return this->recursive_match_next( param, icur, CStringsT() );

}

class end_quantifier : public indestructable_sub_expr

{

max_group_quantifier const *const m_pquant;

end_quantifier & operator=( end_quantifier const & );

void _push_frame( match_param & param ) const

{

backref_tag & br = param.m_prgbackrefs[ m_pquant->group_number() ];

param.m_pstack->push( br.reserved4 );

br.reserved4 = br.reserved5;

br.reserved5 = param.m_icur;

}

void _pop_frame( match_param & param ) const

{

backref_tag & br = param.m_prgbackrefs[ m_pquant->group_number() ];

br.reserved5 = br.reserved4;

param.m_pstack->pop( br.reserved4 );

}

template< typename CStringsT >

bool _do_recursive_match_all( match_param & param, IterT icur REGEX_VC6(COMMA CStringsT) ) const

{

typedef typename backref_tag::smart_iter_type smart_iter_type;

smart_iter_type old_highwater1 = m_pquant->highwater1( param );

if( icur == old_highwater1 )

return m_pquant->recursive_match_next( param, icur, CStringsT() );

m_pquant->highwater1( param ) = m_pquant->highwater2( param );

m_pquant->highwater2( param ) = icur;

if( m_pquant->REGEX_NVC6(template) _do_recurse REGEX_NVC6() ( param, icur REGEX_VC6(COMMA CStringsT()) ) )

return true;

m_pquant->highwater2( param ) = m_pquant->highwater1( param );

m_pquant->highwater1( param ) = old_highwater1;

return false;

}

bool _do_iterative_match_this( match_param & param ) const

{

backref_tag & br = param.m_prgbackrefs[ m_pquant->group_number() ];

// forcibly break the infinite loop

if( param.m_icur == br.reserved4 )

{

_push_frame( param );

param.m_pnext = m_pquant->next();

return true;

}

_push_frame( param );

// If we've matched the max nbr of times, move on to the next

// sub-expr.

if( m_pquant->m_ubound == br.reserved2 )

{

param.m_pnext = m_pquant->next();

br.reserved3 = false;

return true;

}

// Rematch the group.

br.reserved3 = true;

param.m_pnext = m_pquant->m_psub;

++br.reserved2;

return true;

}

bool _do_iterative_rematch_this( match_param & param ) const

{

typedef typename backref_tag::smart_iter_type smart_iter_type;

backref_tag & br = param.m_prgbackrefs[ m_pquant->group_number() ];

// infinite loop forcibly broken

if( param.m_icur == param.m_pstack->REGEX_NVC6(template) top REGEX_NVC6() ( REGEX_VC6(type2type()) ) )

{

_pop_frame( param );

return false;

}

if( br.reserved3 )

{

--br.reserved2;

param.m_pnext = m_pquant->next();

if( m_pquant->m_lbound <= br.reserved2 )

{

br.reserved3 = false;

return true;

}

_pop_frame( param );

return false;

}

br.reserved3 = true;

_pop_frame( param );

return false;

}

public:

end_quantifier( max_group_quantifier const * pquant = 0 )

: m_pquant( pquant )

{

}

virtual bool recursive_match_all_s( match_param & param, IterT icur ) const

{

return _do_recursive_match_all REGEX_NVC6() ( param, icur REGEX_VC6(COMMA false_t()) );

}

virtual bool recursive_match_all_c( match_param & param, IterT icur ) const

{

return _do_recursive_match_all REGEX_NVC6() ( param, icur REGEX_VC6(COMMA true_t()) );

}

virtual bool iterative_match_this_s( match_param & param ) const

{

return _do_iterative_match_this( param );

}

virtual bool iterative_match_this_c( match_param & param ) const

{

return _do_iterative_match_this( param );

}

virtual bool iterative_rematch_this_s( match_param & param ) const

{

return _do_iterative_rematch_this( param );

}

virtual bool iterative_rematch_this_c( match_param & param ) const

{

return _do_iterative_rematch_this( param );

}

virtual width_type width_this( width_param & )

{

return zero_width;

}

} m_end_quant;

friend class end_quantifier;

};

template< typename IterT >

class min_group_quantifier : public group_quantifier

{

min_group_quantifier & operator=( min_group_quantifier const & );

template< typename CStringsT >

bool _do_recursive_match_all( match_param & param, IterT icur REGEX_VC6(COMMA CStringsT) ) const

{

typedef typename backref_tag::smart_iter_type smart_iter_type;

smart_iter_type old_highwater1 = this->highwater1( param );

smart_iter_type old_highwater2 = this->highwater2( param );

size_t old_cmatches = this->cmatches( param );

this->highwater1( param ) = static_init::value;

this->highwater2( param ) = icur;

this->cmatches( param ) = 0;

if( _do_recurse REGEX_NVC6() ( param, icur REGEX_VC6(COMMA CStringsT()) ) )

return true;

this->cmatches( param ) = old_cmatches;

this->highwater2( param ) = old_highwater2;

this->highwater1( param ) = old_highwater1;

return false;

}

public:

min_group_quantifier( match_group_base * psub, size_t lbound, size_t ubound )

: group_quantifier( psub, lbound, ubound, & m_end_quant )

, m_end_quant( this )

{

}

virtual ~min_group_quantifier()

{

// Must call _cleanup() here before the end_quant object

// gets destroyed.

this->_cleanup();

}

virtual bool recursive_match_all_s( match_param & param, IterT icur ) const

{

return _do_recursive_match_all REGEX_NVC6() ( param, icur REGEX_VC6(COMMA false_t()) );

}

virtual bool recursive_match_all_c( match_param & param, IterT icur ) const

{

return _do_recursive_match_all REGEX_NVC6() ( param, icur REGEX_VC6(COMMA true_t()) );

}

protected:

template< typename CStringsT >

bool _do_recurse( match_param & param, IterT icur REGEX_VC6(COMMA CStringsT) ) const

{

if( this->m_lbound <= this->cmatches( param ) )

{

if( this->recursive_match_next( param, icur, CStringsT() ) )

return true;

}

if( this->m_ubound > this->cmatches( param ) )

{

++this->cmatches( param );

if( this->m_psub->recursive_match_all( param, icur, CStringsT() ) )

return true;

--this->cmatches( param );

}

return false;

}

class end_quantifier : public indestructable_sub_expr

{

min_group_quantifier const *const m_pquant;

end_quantifier & operator=( end_quantifier const & );

void _push_frame( match_param & param ) const

{

backref_tag & br = param.m_prgbackrefs[ m_pquant->group_number() ];

param.m_pstack->push( br.reserved4 );

br.reserved4 = br.reserved5;

br.reserved5 = param.m_icur;

}

void _pop_frame( match_param & param ) const

{

backref_tag & br = param.m_prgbackrefs[ m_pquant->group_number() ];

br.reserved5 = br.reserved4;

param.m_pstack->pop( br.reserved4 );

}

template< typename CStringsT >

bool _do_recursive_match_all( match_param & param, IterT icur REGEX_VC6(COMMA CStringsT) ) const

{

typedef typename backref_tag::smart_iter_type smart_iter_type;

smart_iter_type old_highwater1 = m_pquant->highwater1( param );

if( icur == old_highwater1 )

return m_pquant->recursive_match_next( param, icur, CStringsT() );

m_pquant->highwater1( param ) = m_pquant->highwater2( param );

m_pquant->highwater2( param ) = icur;

if( m_pquant->REGEX_NVC6(template) _do_recurse REGEX_NVC6() ( param, icur REGEX_VC6(COMMA CStringsT()) ) )

return true;

m_pquant->highwater2( param ) = m_pquant->highwater1( param );

m_pquant->highwater1( param ) = old_highwater1;

return false;

}

bool _do_iterative_match_this( match_param & param ) const

{

backref_tag & br = param.m_prgbackrefs[ m_pquant->group_number() ];

// forcibly break the infinite loop

if( param.m_icur == br.reserved4 )

{

_push_frame( param );

param.m_pnext = m_pquant->next();

return true;

}

_push_frame( param );

if( m_pquant->m_lbound <= br.reserved2 )

{

br.reserved3 = false;

param.m_pnext = m_pquant->next();

return true;

}

++br.reserved2;

param.m_pnext = m_pquant->m_psub;

return true;

}

bool _do_iterative_rematch_this( match_param & param ) const

{

typedef typename backref_tag::smart_iter_type smart_iter_type;

backref_tag & br = param.m_prgbackrefs[ m_pquant->group_number() ];

// infinite loop forcibly broken

if( param.m_icur == param.m_pstack->REGEX_NVC6(template) top REGEX_NVC6() ( REGEX_VC6(type2type()) ) )

{

_pop_frame( param );

return false;

}

if( br.reserved3 )

{

--br.reserved2;

_pop_frame( param );

return false;

}

br.reserved3 = true;

if( m_pquant->m_ubound > br.reserved2 )

{

++br.reserved2;

param.m_pnext = m_pquant->m_psub;

return true;

}

_pop_frame( param );

return false;

}

public:

end_quantifier( min_group_quantifier const * pquant = 0 )

: m_pquant( pquant )

{

}

virtual bool recursive_match_all_s( match_param & param, IterT icur ) const

{

return _do_recursive_match_all REGEX_NVC6() ( param, icur REGEX_VC6(COMMA false_t()) );

}

virtual bool recursive_match_all_c( match_param & param, IterT icur ) const

{

return _do_recursive_match_all REGEX_NVC6() ( param, icur REGEX_VC6(COMMA true_t()) );

}

virtual bool iterative_match_this_s( match_param & param ) const

{

return _do_iterative_match_this( param );

}

virtual bool iterative_match_this_c( match_param & param ) const

{

return _do_iterative_match_this( param );

}

virtual bool iterative_rematch_this_s( match_param & param ) const

{

return _do_iterative_rematch_this( param );

}

virtual bool iterative_rematch_this_c( match_param & param ) const

{

return _do_iterative_rematch_this( param );

}

virtual width_type width_this( width_param & )

{

return zero_width;

}

} m_end_quant;

friend class end_quantifier;

};

inline void fixup_backref( size_t & cbackref, std::list const & invisible_groups )

{

std::list::const_iterator iter = invisible_groups.begin();

for( ; invisible_groups.end() != iter && cbackref >= *iter; ++iter )

{

++cbackref;

}

template< typename IterT >

class match_backref : public sub_expr

{

bool _do_iterative_rematch_this( match_param & param ) const

{

typedef typename std::iterator_traits::difference_type diff_type;

backref_tag const & br = param.m_prgbackrefs[ m_nbackref ];

diff_type dist = std::distance( br.first, br.second );

std::advance( param.m_icur, -dist );

return false;

}

public:

match_backref( size_t nbackref )

: m_nbackref( nbackref )

{

}

// Return the width specifications of the group to which this backref refers

virtual width_type width_this( width_param & param )

{

// fix up the backref to take into account the number of invisible groups

fixup_backref( m_nbackref, param.m_invisible_groups );

if( m_nbackref >= param.m_rggroups.size() )

throw bad_regexpr( "reference to nonexistent group" );

// If the entry in the backref vector has been nulled out, then we are

// calculating the width for this group.

if( 0 == param.m_rggroups[ m_nbackref ] )

return worst_width; // can't tell how wide this group will be. :-(

return param.m_rggroups[ m_nbackref ]->width_this( param );

}

virtual bool iterative_rematch_this_s( match_param & param ) const

{

return _do_iterative_rematch_this( param );

}

virtual bool iterative_rematch_this_c( match_param & param ) const

{

return _do_iterative_rematch_this( param );

}

protected:

size_t m_nbackref;

};

template< typename CmpT, typename IterT >

class match_backref_t : public match_backref

{

public:

match_backref_t( size_t nbackref )

: match_backref( nbackref )

{

}

virtual sub_expr * quantify( size_t lbound, size_t ubound, bool greedy, regex_arena & arena )

{

if( greedy )

return new( arena ) max_atom_quantifier >( this, lbound, ubound );

else

return new( arena ) min_atom_quantifier >( this, lbound, ubound );

}

virtual bool recursive_match_all_s( match_param & param, IterT icur ) const

{

return ( match_backref_t::recursive_match_this_s( param, icur ) && this->recursive_match_next( param, icur, false_t() ) );

}

virtual bool recursive_match_all_c( match_param & param, IterT icur ) const

{

return ( match_backref_t::recursive_match_this_c( param, icur ) && this->recursive_match_next( param, icur, true_t() ) );

}

virtual bool recursive_match_this_s( match_param & param, IterT & icur ) const

{

return _do_match_this REGEX_NVC6() ( param, icur REGEX_VC6(COMMA false_t()) );

}

virtual bool recursive_match_this_c( match_param & param, IterT & icur ) const

{

return _do_match_this REGEX_NVC6() ( param, icur REGEX_VC6(COMMA true_t()) );

}

virtual bool iterative_match_this_s( match_param & param ) const

{

param.m_pnext = this->next();

return _do_match_this REGEX_NVC6() ( param, param.m_icur REGEX_VC6(COMMA false_t()) );

}

virtual bool iterative_match_this_c( match_param & param ) const

{

param.m_pnext = this->next();

return _do_match_this REGEX_NVC6() ( param, param.m_icur REGEX_VC6(COMMA true_t()) );

}

protected:

template< typename CStringsT >

bool _do_match_this( match_param & param, IterT & icur REGEX_VC6(COMMA CStringsT) ) const

{

// Pattern compilation should have failed if the following is false:

REGEX_ASSERT( this->m_nbackref < param.m_cbackrefs );

// Don't match a backref that hasn't match anything

if( ! param.m_prgbackrefs[ this->m_nbackref ].matched )

return false;

IterT ithis = param.m_prgbackrefs[ this->m_nbackref ].first;

IterT const iend = param.m_prgbackrefs[ this->m_nbackref ].second;

IterT icur_tmp = icur;

for( ; iend != ithis; ++icur_tmp, ++ithis )

{

if( eos_t::eval( param, icur_tmp ) || CmpT::eval( *icur_tmp, *ithis ) )

return false;

}

icur = icur_tmp;

return true;

}

};

template< typename IterT >

inline match_backref * create_backref(

size_t cbackref,

REGEX_FLAGS flags, regex_arena & arena )

{

typedef typename std::iterator_traits::value_type char_type;

switch( NOCASE & flags )

{

case 0:

return new( arena ) match_backref_t, IterT>( cbackref );

case NOCASE:

return new( arena ) match_backref_t, IterT>( cbackref );

default:

REGEX_ASSERT(false);

return 0;

}

template< typename IterT >

class match_recurse : public sub_expr

{

match_recurse & operator=( match_recurse const & );

void _push_frame( match_param & param ) const

{

typedef typename match_param::backref_type backref_type;

unsafe_stack * pstack = param.m_pstack;

backref_type * ibegin = param.m_prgbackrefs;

backref_type * iend = ibegin + param.m_cbackrefs;

for( ; iend != ibegin; ++ibegin )

{

pstack->push( ibegin->reserved1 );

}

void _pop_frame( match_param & param ) const

{

typedef typename match_param::backref_type backref_type;

unsafe_stack * pstack = param.m_pstack;

backref_type * ibegin = param.m_prgbackrefs;

backref_type * iend = ibegin + param.m_cbackrefs;

while( iend != ibegin )

{

--iend;

pstack->pop( iend->reserved1 );

}

template< typename CStringsT >

bool _do_recursive_match_all( match_param & param, IterT icur REGEX_VC6(COMMA CStringsT) ) const

{

// Prevent infinite recursion. If icur == param.m_prgbackrefs[ 0 ].reserved1,

// then the pattern has eaten 0 chars to date, and we would recurse forever.

if( icur == param.m_prgbackrefs[ 0 ].reserved1 )

return this->recursive_match_next( param, icur, CStringsT() );

// copy the backref vector onto the stack

IterT * prgci = static_cast( alloca( param.m_cbackrefs * sizeof( IterT ) ) );

save_backrefs( param.m_prgbackrefs, param.m_prgbackrefs + param.m_cbackrefs, prgci );

// Recurse.

if( param.m_pfirst->recursive_match_all( param, icur, CStringsT() ) )

{

// Restore the backref vector

restore_backrefs( param.m_prgbackrefs, param.m_prgbackrefs + param.m_cbackrefs, prgci );

// Recursive match succeeded. Try to match the rest of the pattern

// using the end of the recursive match as the start of the next

return this->recursive_match_next( param, param.m_prgbackrefs[ 0 ].second, CStringsT() );

}

// Recursion failed

std::for_each( prgci, prgci + param.m_cbackrefs, deleter() );

return false;

}

template< typename CStringsT >

bool _do_iterative_match_this( match_param & param REGEX_VC6(COMMA CStringsT) ) const

{

param.m_pstack->push( param.m_icur );

// Prevent infine recursion

if( param.m_icur == param.m_prgbackrefs[ 0 ].reserved1 )

{

param.m_pnext = this->next();

return true;

}

_push_frame( param );

if( _do_match_iterative( param.m_pfirst, param, param.m_icur, CStringsT() ) )

{

_pop_frame( param );

param.m_pnext = this->next();

return true;

}

_pop_frame( param );

param.m_pstack->pop( param.m_icur );

return false;

}

bool _do_iterative_rematch_this( match_param & param ) const

{

param.m_pstack->pop( param.m_icur );

return false;

}

public:

match_recurse()

{

}

virtual sub_expr * quantify( size_t, size_t, bool, regex_arena & )

{

throw bad_regexpr( "recursion sub-expression cannot be quantified" );

}

virtual bool recursive_match_all_s( match_param & param, IterT icur ) const

{

return _do_recursive_match_all REGEX_NVC6() ( param, icur REGEX_VC6(COMMA false_t()) );

}

virtual bool recursive_match_all_c( match_param & param, IterT icur ) const

{

return _do_recursive_match_all REGEX_NVC6() ( param, icur REGEX_VC6(COMMA true_t()) );

}

virtual bool iterative_match_this_s( match_param & param ) const

{

return _do_iterative_match_this REGEX_NVC6() ( param REGEX_VC6(COMMA false_t()) );

}

virtual bool iterative_match_this_c( match_param & param ) const

{

return _do_iterative_match_this REGEX_NVC6() ( param REGEX_VC6(COMMA true_t()) );

}

virtual bool iterative_rematch_this_s( match_param & param ) const

{

return _do_iterative_rematch_this( param );

}

virtual bool iterative_rematch_this_c( match_param & param ) const

{

return _do_iterative_rematch_this( param );

}

virtual width_type width_this( width_param & )

{

return worst_width;

}

};

template< typename IterT >

inline match_recurse * create_recurse( regex_arena & arena )

{

return new( arena ) match_recurse();

}

template< typename IterT >

struct backref_condition

{

size_t m_cbackref;

backref_condition( size_t cbackref )

: m_cbackref( cbackref )

{

}

template< typename CStringsT >

bool recursive_match_this( match_param & param, IterT, CStringsT ) const

{

return m_cbackref < param.m_cbackrefs && param.m_prgbackrefs[ m_cbackref ].matched;

}

template< typename CStringsT >

bool iterative_match_this( match_param & param, CStringsT ) const

{

return m_cbackref < param.m_cbackrefs && param.m_prgbackrefs[ m_cbackref ].matched;

}

template< typename CStringsT >

bool iterative_rematch_this( match_param &, CStringsT ) const

{

return false;

}

void width_this( width_param & param )

{

// fix up the backref to take into account the number of invisible groups

fixup_backref( m_cbackref, param.m_invisible_groups );

}

};

template< typename IterT >

struct assertion_condition

{

std::auto_ptr > m_passert;

assertion_condition( match_group_base * passert , regex_arena & arena )

: m_passert( passert )

{

*passert->pnext() = new( arena ) end_of_pattern;

}

bool recursive_match_this( match_param & param, IterT icur, false_t ) const

{

return m_passert->recursive_match_all_s( param, icur );

}

bool recursive_match_this( match_param & param, IterT icur, true_t ) const

{

return m_passert->recursive_match_all_c( param, icur );

}

bool iterative_match_this( match_param & param, false_t ) const

{

return m_passert->iterative_match_this_s( param );

}

bool iterative_match_this( match_param & param, true_t ) const

{

return m_passert->iterative_match_this_c( param );

}

bool iterative_rematch_this( match_param & param, false_t ) const

{

return m_passert->iterative_rematch_this_s( param );

}

bool iterative_rematch_this( match_param & param, true_t ) const

{

return m_passert->iterative_rematch_this_c( param );

}

void width_this( width_param & param )

{

( void ) m_passert->width_this( param );

}

};

template< typename IterT, typename CondT >

class match_conditional : public match_group

{

protected:

typedef typename match_group::alt_list_type alt_list_type;

private:

match_conditional & operator=( match_conditional const & );

template< typename CStringsT >

bool _do_recursive_match_all( match_param & param, IterT icur REGEX_VC6(COMMA CStringsT) ) const

{

typedef typename alt_list_type::const_iterator iter_type;

iter_type ialt = this->m_rgalternates.begin();

if( m_condition.recursive_match_this( param, icur, CStringsT() ) || this->m_rgalternates.end() != ++ialt )

{

return (*ialt)->recursive_match_all( param, icur, CStringsT() );

}

return this->recursive_match_next( param, icur, CStringsT() );

}

template< typename CStringsT >

bool _do_iterative_match_this( match_param & param REGEX_VC6(COMMA CStringsT) ) const

{

typedef typename alt_list_type::const_iterator iter_type;

iter_type ialt = this->m_rgalternates.begin();

if( m_condition.iterative_match_this( param, CStringsT() ) )

{

param.m_pstack->push( true );

param.m_pnext = *ialt;

return true;

}

param.m_pstack->push( false );

param.m_pnext = ( this->m_rgalternates.end() != ++ialt ) ? *ialt : this->next();

return true;

}

template< typename CStringsT >

bool _do_iterative_rematch_this( match_param & param REGEX_VC6(COMMA CStringsT) ) const

{

bool condition;

param.m_pstack->pop( condition );

if( condition )

m_condition.iterative_rematch_this( param, CStringsT() );

return false;

}

public:

typedef CondT condition_type;

match_conditional( size_t cgroup, condition_type condition, regex_arena & arena )

: match_group( cgroup, arena )

, m_condition( condition )

{

}

virtual bool recursive_match_all_s( match_param & param, IterT icur ) const

{

return _do_recursive_match_all REGEX_NVC6() ( param, icur REGEX_VC6(COMMA false_t()) );

}

virtual bool recursive_match_all_c( match_param & param, IterT icur ) const

{

return _do_recursive_match_all REGEX_NVC6() ( param, icur REGEX_VC6(COMMA true_t()) );

}

virtual bool iterative_match_this_s( match_param & param ) const

{

return _do_iterative_match_this REGEX_NVC6() ( param REGEX_VC6(COMMA false_t()) );

}

virtual bool iterative_match_this_c( match_param & param ) const

{

return _do_iterative_match_this REGEX_NVC6() ( param REGEX_VC6(COMMA true_t()) );

}

virtual bool iterative_rematch_this_s( match_param & param ) const

{

return _do_iterative_rematch_this REGEX_NVC6() ( param REGEX_VC6(COMMA false_t()) );

}

virtual bool iterative_rematch_this_c( match_param & param ) const

{

return _do_iterative_rematch_this REGEX_NVC6() ( param REGEX_VC6(COMMA true_t()) );

}

virtual width_type width_this( width_param & param )

{

typedef typename alt_list_type::const_iterator iter_type;

iter_type ialt = this->m_rgalternates.begin();

width_type width = ( *ialt )->get_width( param );

if( this->m_rgalternates.end() != ++ialt )

{

width_type temp_width = ( *ialt )->get_width( param );

width.m_min = regex_min( width.m_min, temp_width.m_min );

width.m_max = regex_max( width.m_max, temp_width.m_max );

}

else

{

width.m_min = 0;

}

// Have the condition calculate its width, too. This is important

// if the condition is a lookbehind assertion.

m_condition.width_this( param );

return this->m_nwidth = width;

}

protected:

condition_type m_condition;

};

template< typename IterT >

inline match_conditional > * create_backref_conditional(

size_t cgroup,

size_t cbackref,

regex_arena & arena )

{

backref_condition cond( cbackref );

return new( arena ) match_conditional >(

cgroup, cond, arena );

}

template< typename IterT >

inline match_conditional > * create_assertion_conditional(

size_t cgroup,

match_group_base * passert,

regex_arena & arena )

{

assertion_condition cond( passert, arena );

return new( arena ) match_conditional >(

cgroup, cond, arena );

}

// From basic_rpattern_base_impl

template< typename IterT >

REGEXPR_H_INLINE bool basic_rpattern_base_impl::_ok_to_recurse() const //throw()

{

switch( m_mode )

{

case MODE_FAST:

return true;

case MODE_SAFE:

return false;

case MODE_MIXED:

return m_fok_to_recurse;

default:

return false;

}

template< typename IterT >

REGEXPR_H_INLINE void basic_rpattern_base_impl::swap( basic_rpattern_base_impl & that ) // throw()

{

using std::swap;

swap( m_fuses_backrefs, that.m_fuses_backrefs );

swap( m_floop, that.m_floop );

swap( m_fok_to_recurse, that.m_fok_to_recurse );

swap( m_cgroups, that.m_cgroups );

swap( m_cgroups_visible, that.m_cgroups_visible );

swap( m_flags, that.m_flags );

swap( m_mode, that.m_mode );

swap( m_nwidth, that.m_nwidth );

swap( m_pfirst, that.m_pfirst );

swap( m_search, that.m_search );

swap_auto_ptr( m_pat, that.m_pat );

swap_auto_ptr( m_subst, that.m_subst );

m_subst_list.swap( that.m_subst_list );

m_invisible_groups.swap( that.m_invisible_groups );

m_arena.swap( that.m_arena );

}

// A helper class for automatically deallocating the arena when

// parsing the pattern results in an exception

class arena_guard

{

arena_guard( arena_guard const & );

arena_guard & operator=( arena_guard const & );

regex_arena * m_parena;

public:

explicit arena_guard( regex_arena & arena )

: m_parena( &arena )

{

}

~arena_guard()

{

if( m_parena )

m_parena->clear();

}

void dismiss()

{

m_parena = 0;

}

};

template< typename CatT >

struct is_random_access_helper

{

enum { value = false };

};

template<>

struct is_random_access_helper

{

enum { value = true };

};

template< typename IterT >

struct is_random_access

{

typedef typename std::iterator_traits::iterator_category cat_type;

enum { value = is_random_access_helper::value };

};

} // namespace detail

// Implementation of basic_rpattern_base:

template< typename IterT, typename SyntaxT >

REGEXPR_H_INLINE void basic_rpattern_base::init( string_type const & pat, REGEX_FLAGS flags, REGEX_MODE mode )

{

basic_rpattern_base temp( pat, flags, mode );

swap( temp );

}

template< typename IterT, typename SyntaxT >

REGEXPR_H_INLINE void basic_rpattern_base::init( string_type const & pat, string_type const & subst, REGEX_FLAGS flags, REGEX_MODE mode )

{

basic_rpattern_base temp( pat, subst, flags, mode );

swap( temp );

}

template< typename IterT, typename SyntaxT >

REGEXPR_H_INLINE void basic_rpattern_base::_common_init( REGEX_FLAGS flags )

{

this->m_cgroups = 0;

std::vector*> rggroups;

typename string_type::iterator ipat = this->m_pat->begin();

syntax_type sy( flags );

detail::match_group_base * pgroup;

// Set up a sentry that will free the arena memory

// automatically on parse failure.

{

detail::arena_guard guard( this->m_arena );

// This will throw on failure

pgroup = _find_next_group( ipat, 0, sy, rggroups );

// terminate the pattern with the end_of_pattern marker

*pgroup->pnext() = new( this->m_arena ) detail::end_of_pattern;

// The parse was successful. Dismiss the parse sentry

guard.dismiss();

}

REGEX_ASSERT( 0 == m_pfirst );

m_pfirst = pgroup;

// Calculate the width of the pattern and all groups

this->m_nwidth = pgroup->group_width( rggroups, m_invisible_groups );

// determine if we can get away with only calling m_pfirst->recursive_match_all only once

this->m_floop = true;

// Optimization: if first character of pattern string is '^'

// and we are not doing a multiline match, then we only

// need to try recursive_match_all once

typename string_type::iterator icur = this->m_pat->begin();

if( MULTILINE != ( MULTILINE & this->m_flags ) &&

1 == pgroup->calternates() &&

this->m_pat->end() != icur &&

BEGIN_LINE == sy.reg_token( icur, this->m_pat->end() ) )

{

this->m_flags = ( REGEX_FLAGS ) ( m_flags & ~RIGHTMOST );

this->m_floop = false;

}

// Optimization: if first 2 characters of pattern string are ".*" or ".+",

// then we only need to try recursive_match_all once

icur = this->m_pat->begin();

if( RIGHTMOST != ( RIGHTMOST & this->m_flags ) &&

SINGLELINE == ( SINGLELINE & this->m_flags ) &&

1 == pgroup->calternates() &&

this->m_pat->end() != icur &&

MATCH_ANY == sy.reg_token( icur, this->m_pat->end() ) &&

this->m_pat->end() != icur )

{

switch( sy.quant_token( icur, this->m_pat->end() ) )

{

case ONE_OR_MORE:

case ZERO_OR_MORE:

case ONE_OR_MORE_MIN:

case ZERO_OR_MORE_MIN:

this->m_floop = false;

break;

default:

break;

}

template< typename IterT, typename SyntaxT >

REGEXPR_H_INLINE void basic_rpattern_base::set_substitution( string_type const & subst )

{

using std::swap;

std::auto_ptr temp_subst( new string_type( subst ) );

detail::subst_list_type temp_subst_list;

bool uses_backrefs = false;

_normalize_string( *temp_subst );

basic_rpattern_base::_parse_subst( *temp_subst, uses_backrefs, temp_subst_list );

detail::swap_auto_ptr( temp_subst, this->m_subst );

swap( uses_backrefs, this->m_fuses_backrefs );

temp_subst_list.swap( this->m_subst_list );

}

template< typename IterT, typename SyntaxT >

inline detail::match_group_base * basic_rpattern_base::_find_next_group(

typename string_type::iterator & ipat,

detail::match_group_base * pgroup_enclosing, syntax_type & sy,

std::vector*> & rggroups )

{

std::auto_ptr > pgroup;

typename string_type::iterator itemp = ipat;

REGEX_FLAGS old_flags = sy.get_flags();

TOKEN tok = NO_TOKEN;

size_t extent_start = this->m_cgroups;

bool fconditional = false;

// Look for group extensions.

if( this->m_pat->end() != ipat && NO_TOKEN != ( tok = sy.ext_token( ipat, this->m_pat->end() ) ) )

{

if( this->m_pat->begin() == itemp || this->m_pat->end() == ipat )

throw bad_regexpr( "ill-formed regular expression" );

// Is this a recursion element?

if( EXT_RECURSE == tok )

{

pgroup_enclosing->add_item( detail::create_recurse( this->m_arena ) );

// This pattern could recurse deeply. Note that fact here so that

// we can opt to use a stack-conservative algorithm at match time.

this->m_fok_to_recurse = false;

}

// Don't process empty groups like (?:) or (?i) or (?R)

if( END_GROUP != sy.reg_token( itemp = ipat, this->m_pat->end() ) )

{

switch( tok )

{

case EXT_NOBACKREF:

// note that this group is not visible, so we can fix

// up offsets into the backref vector later

m_invisible_groups.push_back( this->m_cgroups );

detail::reset_auto_ptr( pgroup, new( this->m_arena ) detail::match_group( _get_next_group_nbr(), this->m_arena ) );

break;

case EXT_INDEPENDENT:

m_invisible_groups.push_back( this->m_cgroups );

detail::reset_auto_ptr( pgroup, new( this->m_arena ) detail::independent_group( _get_next_group_nbr(), this->m_arena ) );

break;

case EXT_POS_LOOKAHEAD:

detail::reset_auto_ptr( pgroup, new( this->m_arena ) detail::lookahead_assertion( true, this->m_arena ) );

break;

case EXT_NEG_LOOKAHEAD:

detail::reset_auto_ptr( pgroup, new( this->m_arena ) detail::lookahead_assertion( false, this->m_arena ) );

break;

case EXT_POS_LOOKBEHIND:

detail::reset_auto_ptr( pgroup, new( this->m_arena ) detail::lookbehind_assertion( true, this->m_arena ) );

break;

case EXT_NEG_LOOKBEHIND:

detail::reset_auto_ptr( pgroup, new( this->m_arena ) detail::lookbehind_assertion( false, this->m_arena ) );

break;

case EXT_CONDITION:

fconditional = true;

m_invisible_groups.push_back( this->m_cgroups );

if( size_t cbackref = detail::parse_int( ipat, this->m_pat->end() ) &&

END_GROUP == sy.reg_token( ipat, this->m_pat->end() ) )

{

detail::reset_auto_ptr(

pgroup, detail::create_backref_conditional(

_get_next_group_nbr(), cbackref, this->m_arena ) );

}

else

{

switch( sy.ext_token( itemp = ipat, this->m_pat->end() ) )

{

case EXT_POS_LOOKAHEAD:

case EXT_NEG_LOOKAHEAD:

case EXT_POS_LOOKBEHIND:

case EXT_NEG_LOOKBEHIND:

{

std::auto_ptr > pgroup_tmp(

_find_next_group( ipat, 0, sy, rggroups ) );

detail::reset_auto_ptr(

pgroup, detail::create_assertion_conditional(

_get_next_group_nbr(), pgroup_tmp.get(), this->m_arena ) );

pgroup_tmp.release();

}

break;

default:

throw bad_regexpr( "bad extension sequence" );

}

break;

case EXT_COMMENT:

while( END_GROUP != ( tok = sy.reg_token( ipat, this->m_pat->end() ) ) )

{

if( NO_TOKEN == tok && this->m_pat->end() != ipat )

++ipat;

if( this->m_pat->end() == ipat )

throw bad_regexpr( "Expecting end of comment" );

}

break;

default:

throw bad_regexpr( "bad extension sequence" );

}

else

{

// Skip over the END_GROUP token

ipat = itemp;

}

else

{

detail::reset_auto_ptr( pgroup, new( this->m_arena ) detail::match_group( _get_next_group_nbr(), this->m_arena ) );

++this->m_cgroups_visible;

}

if( 0 != pgroup.get() )

{

detail::must_have must;

pgroup->open_group();

while( _find_next( ipat, pgroup.get(), sy, rggroups ) ) {}

must = pgroup->close_group( this->m_arena );

// if this is a conditional group, then there must be at

// most 2 alternates.

if( fconditional && 2 < pgroup->calternates() )

throw bad_regexpr( "Too many alternates in conditional subexpression" );

// if this is the top-level group and it returned a "must have"

// string, then use that to initialize a boyer-moore search structure

if( detail::is_random_access::value && must.m_has && 0 == pgroup->group_number() )

{

typedef typename string_type::const_iterator iter_type;

m_search = new( this->m_arena ) detail::boyer_moore

( must.m_begin, must.m_end, must.m_lower );

}

// Add this group to the rggroups array

if( size_t( -1 ) != pgroup->group_number() )

{

if( pgroup->group_number() >= rggroups.size() )

rggroups.resize( pgroup->group_number() + 1, 0 );

rggroups[ pgroup->group_number() ] = pgroup.get();

}

// tell this group how many groups are contained within it

pgroup->set_extent( detail::extent_type( extent_start, this->m_cgroups - extent_start ) );

// If this is not a pattern modifier, restore the

// flags to their previous settings. This causes

// pattern modifiers to have the scope of their

// enclosing group.

sy.set_flags( old_flags );

}

return pgroup.release();

}

namespace detail

{

// If we reached the end of the string before finding the end of the

// character set, then this is an ill-formed regex

template< typename IterT >

inline void check_iter( IterT icur, IterT iend )

{

if( iend == icur )

throw bad_regexpr( "expecting end of character set" );

}

template< typename IBeginT, typename IEndT >

inline typename std::iterator_traits::value_type get_escaped_char( IBeginT & icur, IEndT iend, bool normalize )

{

typedef typename std::iterator_traits::value_type char_type;

char_type ch = 0, i;

check_iter( icur, iend );

switch( *icur )

{

// octal escape sequence

case REGEX_CHAR(char_type,'0'): case REGEX_CHAR(char_type,'1'): case REGEX_CHAR(char_type,'2'): case REGEX_CHAR(char_type,'3'):

case REGEX_CHAR(char_type,'4'): case REGEX_CHAR(char_type,'5'): case REGEX_CHAR(char_type,'6'): case REGEX_CHAR(char_type,'7'):

ch = char_type( *icur++ - REGEX_CHAR(char_type,'0') );

for( i=0; i<2 && REGEX_CHAR(char_type,'0') <= *icur && REGEX_CHAR(char_type,'7') >= *icur; check_iter( ++icur, iend ) )

ch = char_type( ch * 8 + ( *icur - REGEX_CHAR(char_type,'0') ) );

break;

// bell character

case REGEX_CHAR(char_type,'a'):

if( ! normalize )

goto default_;

ch = REGEX_CHAR(char_type,'/a');

++icur;

break;

// control character

case REGEX_CHAR(char_type,'c'):

check_iter( ++icur, iend );

ch = *icur++;

if( REGEX_CHAR(char_type,'a') <= ch && REGEX_CHAR(char_type,'z') >= ch )

ch = detail::regex_toupper( ch );

ch ^= 0x40;

break;

// escape character

case REGEX_CHAR(char_type,'e'):

ch = 27;

++icur;

break;

// formfeed character

case REGEX_CHAR(char_type,'f'):

if( ! normalize )

goto default_;

ch = REGEX_CHAR(char_type,'/f');

++icur;

break;

// newline

case REGEX_CHAR(char_type,'n'):

if( ! normalize )

goto default_;

ch = REGEX_CHAR(char_type,'/n');

++icur;

break;

// return

case REGEX_CHAR(char_type,'r'):

if( ! normalize )

goto default_;

ch = REGEX_CHAR(char_type,'/r');

++icur;

break;

// horizontal tab

case REGEX_CHAR(char_type,'t'):

if( ! normalize )

goto default_;

ch = REGEX_CHAR(char_type,'/t');

++icur;

break;

// vertical tab

case REGEX_CHAR(char_type,'v'):

if( ! normalize )

goto default_;

ch = REGEX_CHAR(char_type,'/v');

++icur;

break;

// hex escape sequence

case REGEX_CHAR(char_type,'x'):

for( ++icur, ch=i=0; i<2 && detail::regex_isxdigit( *icur ); check_iter( ++icur, iend ) )

ch = char_type( ch * 16 + detail::regex_xdigit2int( *icur ) );

break;

// backslash

case REGEX_CHAR(char_type,'//'):

if( ! normalize )

goto default_;

ch = REGEX_CHAR(char_type,'//');

++icur;

break;

// all other escaped characters represent themselves

default: default_:

ch = *icur;

++icur;

break;

}

return ch;

}

template< typename CharT, typename CharSetT, typename SyntaxT >

inline void parse_charset(

std::auto_ptr & pnew,

typename std::basic_string::iterator & icur,

typename std::basic_string::const_iterator iend,

SyntaxT & sy )

{

typedef CharT char_type;

typedef std::basic_string string_type;

typedef typename string_type::const_iterator iter_type;

typename string_type::iterator itemp = icur;

bool const normalize = ( NORMALIZE == ( NORMALIZE & sy.get_flags() ) );

if( iend != itemp && CHARSET_NEGATE == sy.charset_token( itemp, iend ) )

{

pnew->m_fcompliment = true;

icur = itemp;

}

TOKEN tok;

char_type ch_prev = 0;

bool fhave_prev = false;

charset const * pcharset = 0;

typename string_type::iterator iprev = icur;

bool const fnocase = ( NOCASE == ( NOCASE & sy.get_flags() ) );

check_iter( icur, iend );

// remember the current position and grab the next token

tok = sy.charset_token( icur, iend );

{

check_iter( icur, iend );

if( CHARSET_RANGE == tok && fhave_prev )

{

// remember the current position

typename string_type::iterator iprev2 = icur;

fhave_prev = false;

// ch_prev is lower bound of a range

switch( sy.charset_token( icur, iend ) )

{

case CHARSET_RANGE:

case CHARSET_NEGATE:

icur = iprev2; // un-get these tokens and fall through

case NO_TOKEN:

pnew->set_bit_range( ch_prev, *icur++, fnocase );

continue;

case CHARSET_ESCAPE: // BUGBUG user-defined charset?

pnew->set_bit_range( ch_prev, get_escaped_char( icur, iend, normalize ), fnocase );

continue;

case CHARSET_BACKSPACE:

pnew->set_bit_range( ch_prev, char_type( 8 ), fnocase ); // backspace

continue;

case CHARSET_END: // fall through

default: // not a range.

icur = iprev; // backup to range token

pnew->set_bit( ch_prev, fnocase );

pnew->set_bit( *icur++, fnocase );

continue;

}

if( fhave_prev )

pnew->set_bit( ch_prev, fnocase );

fhave_prev = false;

switch( tok )

{

// None of the intrinsic charsets are case-sensitive,

// so no special handling must be done when the NOCASE

// flag is set.

case CHARSET_RANGE:

case CHARSET_NEGATE:

case CHARSET_END:

icur = iprev; // un-get these tokens

ch_prev = *icur++;

fhave_prev = true;

continue;

case CHARSET_BACKSPACE:

ch_prev = char_type( 8 ); // backspace

fhave_prev = true;

continue;

case ESC_DIGIT:

*pnew |= intrinsic_charsets::get_digit_charset();

continue;

case ESC_NOT_DIGIT:

*pnew |= intrinsic_charsets::get_not_digit_charset();

continue;

case ESC_SPACE:

*pnew |= intrinsic_charsets::get_space_charset();

continue;

case ESC_NOT_SPACE:

*pnew |= intrinsic_charsets::get_not_space_charset();

continue;

case ESC_WORD:

*pnew |= intrinsic_charsets::get_word_charset();

continue;

case ESC_NOT_WORD:

*pnew |= intrinsic_charsets::get_not_word_charset();

continue;

case CHARSET_ALNUM:

pnew->m_posixcharson |= ( wct_alnum() );

continue;

case CHARSET_NOT_ALNUM:

pnew->m_posixcharsoff.push_front( wct_alnum() );

continue;

case CHARSET_ALPHA:

pnew->m_posixcharson |= ( wct_alpha() );

continue;

case CHARSET_NOT_ALPHA:

pnew->m_posixcharsoff.push_front( wct_alpha() );

continue;

case CHARSET_BLANK:

pnew->m_posixcharson |= ( wct_blank() );

continue;

case CHARSET_NOT_BLANK:

pnew->m_posixcharsoff.push_front( wct_blank() );

continue;

case CHARSET_CNTRL:

pnew->m_posixcharson |= ( wct_cntrl() );

continue;

case CHARSET_NOT_CNTRL:

pnew->m_posixcharsoff.push_front( wct_cntrl() );

continue;

case CHARSET_DIGIT:

pnew->m_posixcharson |= ( wct_digit() );

continue;

case CHARSET_NOT_DIGIT:

pnew->m_posixcharsoff.push_front( wct_digit() );

continue;

case CHARSET_GRAPH:

pnew->m_posixcharson |= ( wct_graph() );

continue;

case CHARSET_NOT_GRAPH:

pnew->m_posixcharsoff.push_front( wct_graph() );

continue;

case CHARSET_LOWER:

if( NOCASE == ( NOCASE & sy.get_flags() ) )

pnew->m_posixcharson |= ( wct_lower()|wct_upper() );

else

pnew->m_posixcharson |= ( wct_lower() );

continue;

case CHARSET_NOT_LOWER:

if( NOCASE == ( NOCASE & sy.get_flags() ) )

pnew->m_posixcharsoff.push_front( wct_lower()|wct_upper() );

else

pnew->m_posixcharsoff.push_front( wct_lower() );

continue;

case CHARSET_PRINT:

pnew->m_posixcharson |= ( wct_print() );

continue;

case CHARSET_NOT_PRINT:

pnew->m_posixcharsoff.push_front( wct_print() );

continue;

case CHARSET_PUNCT:

pnew->m_posixcharson |= ( wct_punct() );

continue;

case CHARSET_NOT_PUNCT:

pnew->m_posixcharsoff.push_front( wct_punct() );

continue;

case CHARSET_SPACE:

pnew->m_posixcharson |= ( wct_space() );

continue;

case CHARSET_NOT_SPACE:

pnew->m_posixcharsoff.push_front( wct_space() );

continue;

case CHARSET_UPPER:

if( NOCASE == ( NOCASE & sy.get_flags() ) )

pnew->m_posixcharson |= ( wct_upper()|wct_lower() );

else

pnew->m_posixcharson |= ( wct_upper() );

continue;

case CHARSET_NOT_UPPER:

if( NOCASE == ( NOCASE & sy.get_flags() ) )

pnew->m_posixcharsoff.push_front( wct_upper()|wct_lower() );

else

pnew->m_posixcharsoff.push_front( wct_upper() );

continue;

case CHARSET_XDIGIT:

pnew->m_posixcharson |= ( wct_xdigit() );

continue;

case CHARSET_NOT_XDIGIT:

pnew->m_posixcharsoff.push_front( wct_xdigit() );

continue;

case CHARSET_ESCAPE:

// Maybe this is a user-defined intrinsic charset

pcharset = get_altern_charset( *icur, sy );

if( 0 != pcharset )

{

*pnew |= *pcharset;

++icur;

continue;

}

else

{

ch_prev = get_escaped_char( icur, iend, normalize );

fhave_prev = true;

}

continue;

default:

ch_prev = *icur++;

fhave_prev = true;

continue;

}

while( check_iter( iprev = icur, iend ),

CHARSET_END != ( tok = sy.charset_token( icur, iend ) ) );

if( fhave_prev )

pnew->set_bit( ch_prev, fnocase );

pnew->optimize( type2type() );

}

template< typename CharT, typename SyntaxT >

inline charset const * get_altern_charset( CharT ch, SyntaxT & sy )

{

typedef std::basic_string string_type;

charset const * pcharset = 0;

regex::detail::charset_map & charset_map = sy.get_charset_map();

typename regex::detail::charset_map::iterator iter = charset_map.find( ch );

if( charset_map.end() != iter )

{

bool const fnocase = ( NOCASE == ( sy.get_flags() & NOCASE ) );

pcharset = iter->second.m_rgcharsets[ fnocase ];

if( 0 == pcharset )

{

// tmp takes ownership of any ptrs.

charset_map_node tmp = iter->second;

charset_map.erase( iter ); // prevent possible infinite recursion

typename string_type::iterator ibegin = tmp.m_str.begin();

std::auto_ptr pnew( new charset );

std::auto_ptr pold( tmp.m_rgcharsets[ !fnocase ] );

parse_charset( pnew, ibegin, tmp.m_str.end(), sy );

tmp.m_rgcharsets[ fnocase ] = pcharset = pnew.get();

charset_map[ ch ] = tmp; // could throw

// charset_map has taken ownership of these pointers now.

pnew.release();

pold.release();

}

return pcharset;

}

} // namespace detail

// Read ahead through the pattern and treat sequential atoms

// as a single atom, making sure to handle quantification

// correctly. Warning: dense code ahead.

template< typename IterT, typename SyntaxT >

inline void basic_rpattern_base::_find_atom(

typename string_type::iterator & ipat,

detail::match_group_base * pgroup,

syntax_type & sy )

{

typedef typename string_type::iterator iter_type;

typedef typename std::iterator_traits::difference_type diff_type;

iter_type itemp = ipat, ibegin;

diff_type const nstart = std::distance( this->m_pat->begin(), ipat );

{

if( itemp != ipat ) // Is there whitespace to skip?

{

diff_type dist = std::distance( this->m_pat->begin(), ipat );

this->m_pat->erase( ipat, itemp ); // erase the whitespace from the patttern

std::advance( ipat = this->m_pat->begin(), dist );

if( this->m_pat->end() == ( itemp = ipat ) ) // are we at the end of the pattern?

break;

}

switch( sy.quant_token( itemp, this->m_pat->end() ) )

{

// if {, } can't be interpreted as quantifiers, treat them as regular chars

case BEGIN_RANGE:

std::advance( ibegin = this->m_pat->begin(), nstart );

if( ibegin != ipat ) // treat as a quantifier

goto quantify;

case NO_TOKEN:

case END_RANGE:

case END_RANGE_MIN:

case RANGE_SEPARATOR:

break;

default:

std::advance( ibegin = this->m_pat->begin(), nstart );

if( ibegin == ipat ) // must be able to quantify something.

throw bad_regexpr( "quantifier not expected" );

quantify: if( ibegin != --ipat )

pgroup->add_item( detail::create_literal( ibegin, ipat, sy.get_flags(), this->m_arena ) );

std::auto_ptr > pnew( detail::create_char( *ipat++, sy.get_flags(), this->m_arena ) );

_quantify( pnew, ipat, false, sy );

pgroup->add_item( pnew.release() );

return;

}

} while( this->m_pat->end() != ++ipat && ! sy.reg_token( itemp = ipat, this->m_pat->end() ) );

std::advance( ibegin = this->m_pat->begin(), nstart );

REGEX_ASSERT( ipat != ibegin );

pgroup->add_item( detail::create_literal( ibegin, ipat, sy.get_flags(), this->m_arena ) );

}

template< typename IterT, typename SyntaxT >

inline bool basic_rpattern_base::_find_next(

typename string_type::iterator & ipat,

detail::match_group_base * pgroup,

syntax_type & sy,

std::vector*> & rggroups )

{

std::auto_ptr > pnew;

std::auto_ptr pcs;

typename string_type::iterator ibegin, itemp;

bool fdone, is_group = false;

bool const normalize = ( NORMALIZE == ( NORMALIZE & sy.get_flags() ) );

if( this->m_pat->end() == ipat )

{

if( 0 != pgroup->group_number() )

throw bad_regexpr( "mismatched parenthesis" );

return false;

}

switch( sy.reg_token( ipat, this->m_pat->end() ) )

{

case NO_TOKEN: // not a token. Must be an atom

if( this->m_pat->end() == ipat )

{

if( 0 != pgroup->group_number() )

throw bad_regexpr( "mismatched parenthesis" );

return false;

}

_find_atom( ipat, pgroup, sy );

return true;

case END_GROUP:

if( 0 == pgroup->group_number() )

throw bad_regexpr( "mismatched parenthesis" );

return false;

case ALTERNATION:

pgroup->end_alternate();

pgroup->add_alternate();

return true;

case BEGIN_GROUP:

// Find next group. could return NULL if the group is really

// a pattern modifier, like: ( ?s-i )

detail::reset_auto_ptr( pnew, _find_next_group( ipat, pgroup, sy, rggroups ) );

is_group = true;

break;

case BEGIN_LINE:

detail::reset_auto_ptr( pnew, detail::create_bol( sy.get_flags(), this->m_arena ) );

break;

case END_LINE:

detail::reset_auto_ptr( pnew, detail::create_eol( sy.get_flags(), this->m_arena ) );

break;

case BEGIN_CHARSET:

detail::reset_auto_ptr( pcs, new( this->m_arena ) detail::custom_charset( this->m_arena ) );

detail::parse_charset(

pcs, ipat, this->m_pat->end(), sy );

detail::reset_auto_ptr( pnew,

detail::create_custom_charset( pcs.get(), sy.get_flags(), this->m_arena ) );

pcs.release();

break;

case MATCH_ANY:

detail::reset_auto_ptr( pnew, detail::create_any( sy.get_flags(), this->m_arena ) );

break;

case ESC_WORD_BOUNDARY:

detail::reset_auto_ptr( pnew, detail::create_word_boundary( true, sy.get_flags(), this->m_arena ) );

break;

case ESC_NOT_WORD_BOUNDARY:

detail::reset_auto_ptr( pnew, detail::create_word_boundary( false, sy.get_flags(), this->m_arena ) );

break;

case ESC_WORD_START:

detail::reset_auto_ptr( pnew, detail::create_word_start( sy.get_flags(), this->m_arena ) );

break;

case ESC_WORD_STOP:

detail::reset_auto_ptr( pnew, detail::create_word_stop( sy.get_flags(), this->m_arena ) );

break;

case ESC_DIGIT:

detail::reset_auto_ptr( pnew, detail::create_charset( detail::intrinsic_charsets::get_digit_charset(), sy.get_flags(), this->m_arena ) );

break;

case ESC_NOT_DIGIT:

detail::reset_auto_ptr( pnew, detail::create_charset( detail::intrinsic_charsets::get_not_digit_charset(), sy.get_flags(), this->m_arena ) );

break;

case ESC_WORD:

detail::reset_auto_ptr( pnew, detail::create_charset( detail::intrinsic_charsets::get_word_charset(), sy.get_flags(), this->m_arena ) );

break;

case ESC_NOT_WORD:

detail::reset_auto_ptr( pnew, detail::create_charset( detail::intrinsic_charsets::get_not_word_charset(), sy.get_flags(), this->m_arena ) );

break;

case ESC_SPACE:

detail::reset_auto_ptr( pnew, detail::create_charset( detail::intrinsic_charsets::get_space_charset(), sy.get_flags(), this->m_arena ) );

break;

case ESC_NOT_SPACE:

detail::reset_auto_ptr( pnew, detail::create_charset( detail::intrinsic_charsets::get_not_space_charset(), sy.get_flags(), this->m_arena ) );

break;

case ESC_BEGIN_STRING:

detail::reset_auto_ptr( pnew, detail::create_bos( sy.get_flags(), this->m_arena ) );

break;

case ESC_END_STRING:

detail::reset_auto_ptr( pnew, detail::create_eos( sy.get_flags(), this->m_arena ) );

break;

case ESC_END_STRING_z:

detail::reset_auto_ptr( pnew, detail::create_eoz( sy.get_flags(), this->m_arena ) );

break;

case ESCAPE:

if( this->m_pat->end() == ipat )

{

// BUGBUG what if the escape sequence is more that 1 character?

detail::reset_auto_ptr( pnew, detail::create_char( *--ipat, sy.get_flags(), this->m_arena ) );

++ipat;

}

else if( REGEX_CHAR(char_type,'0') <= *ipat && REGEX_CHAR(char_type,'9') >= *ipat )

{

// Parse at most 3 decimal digits.

size_t nbackref = detail::parse_int( itemp = ipat, this->m_pat->end(), 999 );

// If the resulting number could conceivably be a backref, then it is.

if( REGEX_CHAR(char_type,'0') != *ipat && ( 10 > nbackref || nbackref < _cgroups_total() ) )

{

detail::reset_auto_ptr( pnew, detail::create_backref( nbackref, sy.get_flags(), this->m_arena ) );

ipat = itemp;

}

else

{

// It's an octal character escape sequence. If *ipat is 8 or 9, insert

// a NULL character, and leave the 8 or 9 as a character literal.

char_type ch = 0, i = 0;

for( ; i < 3 && this->m_pat->end() != ipat && REGEX_CHAR(char_type,'0') <= *ipat && REGEX_CHAR(char_type,'7') >= *ipat; ++i, ++ipat )

ch = char_type( ch * 8 + ( *ipat - REGEX_CHAR(char_type,'0') ) );

detail::reset_auto_ptr( pnew, detail::create_char( ch, sy.get_flags(), this->m_arena ) );

}

else if( REGEX_CHAR(char_type,'e') == *ipat )

{

++ipat;

detail::reset_auto_ptr( pnew, detail::create_char( char_type( 27 ), sy.get_flags(), this->m_arena ) );

}

else if( REGEX_CHAR(char_type,'x') == *ipat )

{

char_type ch = 0, i = 0;

for( ++ipat; i < 2 && this->m_pat->end() != ipat && detail::regex_isxdigit( *ipat ); ++i, ++ipat )

ch = char_type( ch * 16 + detail::regex_xdigit2int( *ipat ) );

detail::reset_auto_ptr( pnew, detail::create_char( ch, sy.get_flags(), this->m_arena ) );

}

else if( REGEX_CHAR(char_type,'c') == *ipat )

{

if( this->m_pat->end() == ++ipat )

throw bad_regexpr( "incomplete escape sequence //c" );

char_type ch = *ipat++;

if( REGEX_CHAR(char_type,'a') <= ch && REGEX_CHAR(char_type,'z') >= ch )

ch = detail::regex_toupper( ch );

detail::reset_auto_ptr( pnew, detail::create_char( char_type( ch ^ 0x40 ), sy.get_flags(), this->m_arena ) );

}

else if( REGEX_CHAR(char_type,'a') == *ipat && normalize )

{

++ipat;

detail::reset_auto_ptr( pnew, detail::create_char( REGEX_CHAR(char_type,'/a'), sy.get_flags(), this->m_arena ) );

}

else if( REGEX_CHAR(char_type,'f') == *ipat && normalize )

{

++ipat;

detail::reset_auto_ptr( pnew, detail::create_char( REGEX_CHAR(char_type,'/f'), sy.get_flags(), this->m_arena ) );

}

else if( REGEX_CHAR(char_type,'n') == *ipat && normalize )

{

++ipat;

detail::reset_auto_ptr( pnew, detail::create_char( REGEX_CHAR(char_type,'/n'), sy.get_flags(), this->m_arena ) );

}

else if( REGEX_CHAR(char_type,'r') == *ipat && normalize )

{

++ipat;

detail::reset_auto_ptr( pnew, detail::create_char( REGEX_CHAR(char_type,'/r'), sy.get_flags(), this->m_arena ) );

}

else if( REGEX_CHAR(char_type,'t') == *ipat && normalize )

{

++ipat;

detail::reset_auto_ptr( pnew, detail::create_char( REGEX_CHAR(char_type,'/t'), sy.get_flags(), this->m_arena ) );

}

else if( REGEX_CHAR(char_type,'//') == *ipat && normalize )

{

++ipat;

detail::reset_auto_ptr( pnew, detail::create_char( REGEX_CHAR(char_type,'//'), sy.get_flags(), this->m_arena ) );

}

else

{

// Is this a user-defined intrinsic character set?

detail::charset const * pcharset = detail::get_altern_charset( *ipat, sy );

if( 0 != pcharset )

detail::reset_auto_ptr( pnew, detail::create_charset( *pcharset, sy.get_flags(), this->m_arena ) );

else

detail::reset_auto_ptr( pnew, detail::create_char( *ipat, sy.get_flags(), this->m_arena ) );

++ipat;

}

break;

// If quotemeta, loop until we find quotemeta off or end of string

case ESC_QUOTE_META_ON:

for( ibegin = itemp = ipat, fdone = false; !fdone && this->m_pat->end() != ipat; )

{

switch( sy.reg_token( ipat, this->m_pat->end() ) )

{

case ESC_QUOTE_META_OFF:

fdone = true;

break;

case NO_TOKEN:

if( this->m_pat->end() != ipat )

++ipat; // fallthrough

default:

itemp = ipat;

break;

}

if( itemp != ibegin )

pgroup->add_item( detail::create_literal( ibegin, itemp, sy.get_flags(), this->m_arena ) );

// skip the quantification code below

return true;

// Should never get here for valid patterns

case ESC_QUOTE_META_OFF:

throw bad_regexpr( "quotemeta turned off, but was never turned on" );

default:

REGEX_ASSERT( ! "Unhandled token type" );

break;

}

// If pnew is null, then the current subexpression is a no-op.

if( pnew.get() )

{

// Look for quantifiers

_quantify( pnew, ipat, is_group, sy );

// Add the item to the group

pgroup->add_item( pnew.release() );

}

return true;

}

template< typename IterT, typename SyntaxT >

inline void basic_rpattern_base::_quantify(

std::auto_ptr > & pnew,

typename string_type::iterator & ipat,

bool is_group,

syntax_type & sy )

{

if( this->m_pat->end() != ipat && ! pnew->is_assertion() )

{

typename string_type::iterator itemp = ipat, itemp2;

bool fmin = false;

// Since size_t is unsigned, -1 is really the largest size_t

size_t lbound = ( size_t )-1;

size_t ubound = ( size_t )-1;

size_t ubound_tmp;

switch( sy.quant_token( itemp, this->m_pat->end() ) )

{

case ZERO_OR_MORE_MIN:

fmin = true;

case ZERO_OR_MORE:

lbound = 0;

break;

case ONE_OR_MORE_MIN:

fmin = true;

case ONE_OR_MORE:

lbound = 1;

break;

case ZERO_OR_ONE_MIN:

fmin = true;

case ZERO_OR_ONE:

lbound = 0;

ubound = 1;

break;

case BEGIN_RANGE:

lbound = detail::parse_int( itemp, this->m_pat->end() );

if( this->m_pat->end() == itemp )

return; // not a valid quantifier - treat as atom

switch( sy.quant_token( itemp, this->m_pat->end() ) )

{

case END_RANGE_MIN:

fmin = true;

case END_RANGE:

ubound = lbound;

break;

case RANGE_SEPARATOR:

itemp2 = itemp;

ubound_tmp = detail::parse_int( itemp, this->m_pat->end() );

if( itemp != itemp2 )

ubound = ubound_tmp;

if( itemp == this->m_pat->end() )

return; // not a valid quantifier - treat as atom

switch( sy.quant_token( itemp, this->m_pat->end() ) )

{

case END_RANGE_MIN:

fmin = true;

case END_RANGE:

break;

default:

return; // not a valid quantifier - treat as atom

}

break;

default:

return; // not a valid quantifier - treat as atom

}

if( ubound < lbound )

throw bad_regexpr( "Can't do {n, m} with n > m" );

break;

default:

break;

}

if( ( size_t )-1 != lbound )

{

// If we are quantifying a group, then this pattern could recurse

// deeply. Note that fact here so that we can opt to use a stack-

// conservative algorithm at match time.

if( is_group && ubound > 16 )

this->m_fok_to_recurse = false;

std::auto_ptr > pquant( pnew->quantify( lbound, ubound, ! fmin, this->m_arena ) );

pnew.release();

detail::reset_auto_ptr( pnew, pquant.release() );

ipat = itemp;

}

template< typename IterT, typename SyntaxT >

inline void basic_rpattern_base::_add_subst_backref(

detail::subst_node & snode,

size_t nbackref,

ptrdiff_t rstart,

bool & uses_backrefs,

detail::subst_list_type & subst_list ) const

{

uses_backrefs = true;

REGEX_ASSERT( detail::subst_node::SUBST_STRING == snode.m_stype );

if( snode.m_subst_string.m_rlength )

subst_list.push_back( snode );

snode.m_stype = detail::subst_node::SUBST_BACKREF;

snode.m_subst_backref = nbackref;

subst_list.push_back( snode );

// re-initialize the subst_node

snode.m_stype = detail::subst_node::SUBST_STRING;

snode.m_subst_string.m_rstart = rstart;

snode.m_subst_string.m_rlength = 0;

}

template< typename IterT, typename SyntaxT >

inline void basic_rpattern_base::_parse_subst(

string_type & subst,

bool & uses_backrefs,

detail::subst_list_type & subst_list ) const

{

TOKEN tok;

detail::subst_node snode;

typename string_type::iterator icur = subst.begin();

size_t nbackref;

typename string_type::iterator itemp;

bool fdone;

syntax_type sy( this->m_flags );

uses_backrefs = false;

// Initialize the subst_node

snode.m_stype = detail::subst_node::SUBST_STRING;

snode.m_subst_string.m_rstart = 0;

snode.m_subst_string.m_rlength = 0;

while( subst.end() != icur )

{

switch( tok = sy.subst_token( icur, subst.end() ) )

{

case SUBST_MATCH:

_add_subst_backref( snode, 0, std::distance( subst.begin(), icur ), uses_backrefs, subst_list );

break;

case SUBST_PREMATCH:

_add_subst_backref( snode, ( size_t )detail::subst_node::PREMATCH, std::distance( subst.begin(), icur ), uses_backrefs, subst_list );

break;

case SUBST_POSTMATCH:

_add_subst_backref( snode, ( size_t )detail::subst_node::POSTMATCH, std::distance( subst.begin(), icur ), uses_backrefs, subst_list );

break;

case SUBST_BACKREF:

nbackref = detail::parse_int( icur, subst.end(), cgroups() - 1 ); // always at least 1 group

if( 0 == nbackref )

throw bad_regexpr( "invalid backreference in substitution" );

_add_subst_backref( snode, nbackref, std::distance( subst.begin(), icur ), uses_backrefs, subst_list );

break;

case SUBST_QUOTE_META_ON:

REGEX_ASSERT( detail::subst_node::SUBST_STRING == snode.m_stype );

if( snode.m_subst_string.m_rlength )

subst_list.push_back( snode );

snode.m_subst_string.m_rstart = std::distance( subst.begin(), icur );

for( itemp = icur, fdone = false; !fdone && subst.end() != icur; )

{

switch( tok = sy.subst_token( icur, subst.end() ) )

{

case SUBST_ALL_OFF:

fdone = true;

break;

case NO_TOKEN:

++icur; // fall-through

default:

itemp = icur;

break;

}

snode.m_subst_string.m_rlength = std::distance( subst.begin(), itemp ) - snode.m_subst_string.m_rstart;

if( snode.m_subst_string.m_rlength )

subst_list.push_back( snode );

if( tok == SUBST_ALL_OFF )

{

snode.m_stype = detail::subst_node::SUBST_OP;

snode.m_op = detail::subst_node::ALL_OFF;

subst_list.push_back( snode );

}

// re-initialize the subst_node

snode.m_stype = detail::subst_node::SUBST_STRING;

snode.m_subst_string.m_rstart = std::distance( subst.begin(), icur );

snode.m_subst_string.m_rlength = 0;

break;

case SUBST_UPPER_ON:

case SUBST_UPPER_NEXT:

case SUBST_LOWER_ON:

case SUBST_LOWER_NEXT:

case SUBST_ALL_OFF:

REGEX_ASSERT( detail::subst_node::SUBST_STRING == snode.m_stype );

if( snode.m_subst_string.m_rlength )

subst_list.push_back( snode );

snode.m_stype = detail::subst_node::SUBST_OP;

snode.m_op = static_cast( tok );

subst_list.push_back( snode );

// re-initialize the subst_node

snode.m_stype = detail::subst_node::SUBST_STRING;

snode.m_subst_string.m_rstart = std::distance( subst.begin(), icur );

snode.m_subst_string.m_rlength = 0;

break;

case SUBST_ESCAPE:

if( subst.end() == icur )

throw bad_regexpr( "expecting escape sequence in substitution string" );

REGEX_ASSERT( detail::subst_node::SUBST_STRING == snode.m_stype );

if( snode.m_subst_string.m_rlength )

subst_list.push_back( snode );

snode.m_subst_string.m_rstart = std::distance( subst.begin(), icur++ );

snode.m_subst_string.m_rlength = 1;

break;

case NO_TOKEN:

default:

++snode.m_subst_string.m_rlength;

++icur;

break;

}

REGEX_ASSERT( detail::subst_node::SUBST_STRING == snode.m_stype );

if( snode.m_subst_string.m_rlength )

subst_list.push_back( snode );

}

template< typename CharT >

REGEXPR_H_INLINE void reset_intrinsic_charsets( CharT )

{

detail::intrinsic_charsets::reset();

}

typedef regex::detail::select

REGEX_FOLD_INSTANTIATIONS &&

detail::is_convertible::value,

std::string::const_iterator,

char const *

>::type lpcstr_t;

typedef regex::detail::select

REGEX_FOLD_INSTANTIATIONS &&

detail::is_convertible::value,

std::wstring::const_iterator,

wchar_t const *

>::type lpcwstr_t;

namespace detail

{

// Here is the main dispatch loop for the iterative match routine.

// It is responsible for calling match on the current sub-expression

// and repeating for the next sub-expression. It also backtracks

// the match when it needs to.

template< typename CStringsT, typename IterT >

inline bool _do_match_iterative( sub_expr_base const * expr, match_param & param, IterT icur, CStringsT )

{

unsafe_stack::stack_guard guard( param.m_pstack );

unsafe_stack & s = *param.m_pstack;

void *const jump_ptr = s.set_jump(); // the bottom of the stack

param.m_icur = icur;

if( ! expr->iterative_match_this( param, CStringsT() ) )

{

return false;

}

for( ;; )

{

if( param.m_pnext == 0 ) // This means we're done

return true;

s.push( expr );

expr = param.m_pnext;

}

while( expr->iterative_match_this( param, CStringsT() ) );

{

if( jump_ptr == s.set_jump() ) // No more posibilities to try

return false;

s.pop( expr );

}

while( ! expr->iterative_rematch_this( param, CStringsT() ) );

}

template< typename IterT >

REGEXPR_H_INLINE bool regex_access::_do_match_iterative_helper_s( sub_expr_base const * expr, match_param & param, IterT icur )

{

return _do_match_iterative( expr, param, icur, false_t() );

}

template< typename IterT >

REGEXPR_H_INLINE bool regex_access::_do_match_iterative_helper_c( sub_expr_base const * expr, match_param & param, IterT icur )

{

return _do_match_iterative( expr, param, icur, true_t() );

}

template< typename IterT >

REGEXPR_H_INLINE bool regex_access::_do_match_recursive_s( sub_expr_base const * expr, match_param & param, IterT icur )

{

return static_cast const*>(expr)->match_group_base::recursive_match_all_s( param, icur );

}

template< typename IterT >

REGEXPR_H_INLINE bool regex_access::_do_match_recursive_c( sub_expr_base const * expr, match_param & param, IterT icur )

{

return static_cast const*>(expr)->match_group_base::recursive_match_all_c( param, icur );

}

template< typename IterT >

REGEX_NOINLINE bool regex_access::_do_match_with_stack( rpattern_type const & pat, match_param & param, bool const use_null )

{

unsafe_stack s;

param.m_pstack = &s;

return _do_match_impl( pat, param, use_null );

}

template< typename IterT >

REGEXPR_H_INLINE bool regex_access::_do_match_impl( rpattern_type const & pat, match_param & param, bool const use_null )

{

typedef bool ( *pfndomatch_t )( sub_expr_base const * expr, match_param & param, IterT icur );

bool floop = pat._loops();

unsigned flags = pat.flags();

width_type nwidth = pat.get_width();

// Create some aliases for convenience and effeciency.

REGEX_ASSERT( 0 != param.m_prgbackrefs );

// If the pstack parameter is not NULL, we should do a safe, iterative match.

// Otherwise, we should do a fast, recursive match.

pfndomatch_t pfndomatch;

if( 0 != param.m_pstack )

if( use_null )

pfndomatch = &_do_match_iterative_helper_c;

else

pfndomatch = &_do_match_iterative_helper_s;

else

if( use_null )

pfndomatch = &_do_match_recursive_c;

else

pfndomatch = &_do_match_recursive_s;

sub_expr_base const * pfirst = pat._get_first_subexpression();

param.m_pfirst = pfirst;

REGEX_ASSERT( param.m_cbackrefs == pat._cgroups_total() );

std::fill_n( param.m_prgbackrefs, param.m_cbackrefs, static_init::value );

if( ! use_null )

{

// If the minimum width of the pattern exceeds the width of the

// string, a succesful match is impossible

typedef typename std::iterator_traits::difference_type diff_type;

diff_type room = std::distance( param.m_imatchbegin, param.m_iend );

if( nwidth.m_min <= static_cast( room ) )

{

IterT local_iend = param.m_iend;

std::advance( local_iend, -static_cast( nwidth.m_min ) );

if( RIGHTMOST & flags )

{

// begin trying to match after the last character.

// Continue to the beginning

for( IterT icur = local_iend; ; --icur, param.m_no0len = false )

{

if( ( *pfndomatch )( pfirst, param, icur ) )

break; // m_floop not used for rightmost matches

if( icur == param.m_imatchbegin )

break;

}

else

{

// begin trying to match before the first character.

// Continue to the end

if( is_random_access::value && pat.m_search )

{

IterT icur = pat.m_search->find( param.m_imatchbegin, param.m_iend );

while( icur != param.m_iend )

{

if( ( *pfndomatch )( pfirst, param, icur ) || ! floop )

break;

param.m_no0len = false;

icur = pat.m_search->find( ++icur, param.m_iend );

}

else

{

for( IterT icur = param.m_imatchbegin; ; ++icur, param.m_no0len = false )

{

if( ( *pfndomatch )( pfirst, param, icur ) || ! floop )

break;

if( icur == local_iend )

break;

}

else

{

REGEX_ASSERT( 0 == ( RIGHTMOST & flags ) );

// begin trying to match before the first character.

// Continue to the end

for( IterT icur = param.m_imatchbegin; ; ++icur, param.m_no0len = false )

{

if( ( *pfndomatch )( pfirst, param, icur ) || ! floop )

break;

if( traits_type::eq( *icur, char_type() ) )

break;

}

return param.m_prgbackrefs[0].matched;

}

// Here is a rudimentary typelist facility to allow the REGEX_TO_INSTANTIATE

// list to recursively generate the instantiations we are interested in.

struct empty_typelist

{

};

template< typename HeadT, typename TailT >

struct cons

{

typedef HeadT head_type;

typedef TailT tail_type;

};

template

typename T1 =empty_typelist, typename T2 =empty_typelist, typename T3 =empty_typelist,

typename T4 =empty_typelist, typename T5 =empty_typelist, typename T6 =empty_typelist,

typename T7 =empty_typelist, typename T8 =empty_typelist, typename T9 =empty_typelist,

typename T10=empty_typelist, typename T11=empty_typelist, typename T12=empty_typelist

struct typelist : public cons >

{

};

template<>

struct typelist

empty_typelist,empty_typelist,empty_typelist,empty_typelist,

empty_typelist,empty_typelist,empty_typelist,empty_typelist

: public empty_typelist

{

};

// This class is responsible for instantiating basic_rpattern

// with the template parameters we are interested in. It also

// instntiates any helper routines this basic_rpattern relies

// on.

template< typename IterT, typename SyntaxT >

struct rpattern_instantiator : protected regex::basic_rpattern

{

static instantiator instantiate()

{

typedef typename std::iterator_traits::value_type char_type;

void (*pfn)( char_type ) = &reset_intrinsic_charsets;

return regex::basic_rpattern::instantiate() +

regex_access::instantiate() +

instantiator_helper( pfn );

}

};

// The regex_instantiate uses typelists and the rpattern_instantiator

// to generate instantiations for all the types in the typelist.

template< typename SyntaxT >

instantiator regex_instantiate( empty_typelist, type2type )

{

return instantiator();

}

template< typename HeadT, typename TailT, typename SyntaxT >

instantiator regex_instantiate( cons, type2type )

{

typedef typename std::iterator_traits::value_type char_type;

typedef typename SyntaxT::template rebind::other syntax_type;

return rpattern_instantiator::instantiate() +

regex_instantiate( TailT(), type2type() );

}

// Here is a list of types to instantiate.

#ifndef REGEX_TO_INSTANTIATE

# ifdef REGEX_WIDE_AND_NARROW

# define REGEX_TO_INSTANTIATE std::string::const_iterator, /

std::wstring::const_iterator, /

lpcstr_t, /

lpcwstr_t

# else

# define REGEX_TO_INSTANTIATE restring::const_iterator, /

lpctstr_t

# endif

#endif

typedef typelist regex_typelist;

typedef type2type > perl_type;

typedef type2type > posix_type;

namespace

{

// Create the perl instantiations

#ifndef REGEX_NO_PERL

instantiator const perl_inst = regex_instantiate( regex_typelist(), perl_type() );

#endif

// Create the posix instantiations

#ifdef REGEX_POSIX

instantiator const posix_inst = regex_instantiate( regex_typelist(), posix_type() );

#endif

}

} // unnamed namespace

} // namespace regex

#ifdef _MSC_VER

# pragma warning( pop )

#endif

/*正则替换

#include

using namespace std;

boost::regex reg("(Colo)(u)(r)",boost::regex::icase|boost::regex::perl);

string s="Color, colours,color,colourize";

s=boost::regex_replace(s,reg,"$1$3");

TRACE(CString(s));

47.直接创建多级目录

typedef BOOL (__stdcall funMakeSure(LPCSTR DirPath));

funMakeSure *MakeSureDirectoryPathExists;

HMODULE hMod=LoadLibrary("dbghelp.dll");

MakeSureDirectoryPathExists(*funMakeSure)GetProcAddress(hMod,"MakeSureDirectoryPathExists");

MakeSureDirectoryPathExists(%%1);

48.批量重命名

CString strPath,strFilter,srcTitle,src,srcFile,dstFile,dstFileTitle;

int i=1,iFileNum=1;

CFile myFile,newFile;

//获取将要批量处理的文件夹及文件格式

strPath=%%1;

strFilter=%%2;

//判断文件夹是否为空

if(strPath.IsEmpty())

{

MessageBox("请先选择要重命名文件所在文件夹！","警告！");

return;

}

//在该文件夹内创建目录文件

src=strPath+"*."+strFilter;

CString list=strPath+"目录.txt";

if(myFile.Open(list,CFile::modeCreate|CFile::modeReadWrite,0) ==0) return;

CFileFind tempFind;

BOOL isFound=(BOOL)tempFind.FindFile(src);

//确定该文件夹内要处理的有多少个文件

while(isFound)

{

isFound=(BOOL)tempFind.FindNextFile();

if(tempFind.IsDirectory() && !tempFind.IsDots())

{

continue;

}

iFileNum++;

}

//进行文件名的转换,以文件数定转换后的文件名,如果有9个文件,则以1-9的形式命名,如果是更多,如有99个文件,则为01-99的形式

isFound=(BOOL)tempFind.FindFile(src);

while(isFound && i

{

isFound=(BOOL)tempFind.FindNextFile();

if(tempFind.IsDirectory() && !tempFind.IsDots())

{

continue;

}

srcFile=tempFind.GetFilePath();

srcTitle=tempFind.GetFileTitle();

if(iFileNum<10)

{

dstFileTitle.Format("%d",i);

}

else if(iFileNum<100 && iFileNum>9)

{

dstFileTitle.Format("%02d",i);

}

else if(iFileNum<1000 && iFileNum>99)

{

dstFileTitle.Format("%03d",i);

}

else if(iFileNum<10000 && iFileNum>999)

{

dstFileTitle.Format("%04d",i);

}

else if(iFileNum<100000 && iFileNum>9999)

{

dstFileTitle.Format("%05d",i);

}

else

{

dstFileTitle.Format("%d",i);

}

//实现转换

dstFile=strPath+dstFileTitle+"."+strFilter;

MoveFile(srcFile,dstFile);

//存入目录文件中

CString in;

in=dstFileTitle+'/t'+srcTitle+"/t/r/n";

myFile.Write(in,in.GetLength());

i++;

SetWindowText(srcFile);

}

//关闭myFile,tempFind

myFile.Close();

tempFind.Close();

49.文本查找替换 ReplaceText

CString StrFileName(%%1);

CString StrFind(%%2);

CString StrReplace(%%3);

CStdioFile TempFile,File;

int Count=0;

if(!File.Open(StrFileName,CFile::modeRead))

return -1;

CString StrTempFileName=File.GetFileTitle()+".tmp";

if(!TempFile.Open(StrTempFileName,CFile::modeCreate|CFile::modeReadWrite))

return -1;

CString Str;

while(File.ReadString(Str))

{

Count+=Str.Replace(StrFind,StrReplace);

TempFile.WriteString(Str+"/n");

}

File.Close();

TempFile.Close();

CFile::Remove(StrFileName);

CFile::Rename(StrTempFileName,StrFileName);

//return Count;

50.文件关联

//---------------------------------------------------------------------------

// 检测文件关联情况

// strExt: 要检测的扩展名(例如: ".txt")

// strAppKey: ExeName扩展名在注册表中的键值(例如: "txtfile")

// 返回TRUE: 表示已关联，FALSE: 表示未关联

BOOL CheckFileRelation(const char *strExt, const char *strAppKey)

{

int nRet=FALSE;

HKEY hExtKey;

char szPath[_MAX_PATH];

DWORD dwSize=sizeof(szPath);

if(RegOpenKey(HKEY_CLASSES_ROOT,strExt,&hExtKey)==ERROR_SUCCESS)

{

RegQueryValueEx(hExtKey,NULL,NULL,NULL,(LPBYTE)szPath,&dwSize);

if(_stricmp(szPath,strAppKey)==0)

{

nRet=TRUE;

}

RegCloseKey(hExtKey);

return nRet;

}

return nRet;

}

//---------------------------------------------------------------------------

// 注册文件关联

// strExe: 要检测的扩展名(例如: ".txt")

// strAppName: 要关联的应用程序名(例如: "C:/MyApp/MyApp.exe")

// strAppKey: ExeName扩展名在注册表中的键值(例如: "txtfile")

// strDefaultIcon: 扩展名为strAppName的图标文件(例如: "C:/MyApp/MyApp.exe,0")

// strDescribe: 文件类型描述

void RegisterFileRelation(char *strExt, char *strAppName, char *strAppKey, char *strDefaultIcon, char *strDescribe)

{

char strTemp[_MAX_PATH];

HKEY hKey;

RegCreateKey(HKEY_CLASSES_ROOT,strExt,&hKey);

RegSetValue(hKey,"",REG_SZ,strAppKey,strlen(strAppKey)+1);

RegCloseKey(hKey);

RegCreateKey(HKEY_CLASSES_ROOT,strAppKey,&hKey);

RegSetValue(hKey,"",REG_SZ,strDescribe,strlen(strDescribe)+1);

RegCloseKey(hKey);

sprintf(strTemp,"%s//DefaultIcon",strAppKey);

RegCreateKey(HKEY_CLASSES_ROOT,strTemp,&hKey);

RegSetValue(hKey,"",REG_SZ,strDefaultIcon,strlen(strDefaultIcon)+1);

RegCloseKey(hKey);

sprintf(strTemp,"%s//Shell",strAppKey);

RegCreateKey(HKEY_CLASSES_ROOT,strTemp,&hKey);

RegSetValue(hKey,"",REG_SZ,"Open",strlen("Open")+1);

RegCloseKey(hKey);

sprintf(strTemp,"%s//Shell//Open//Command",strAppKey);

RegCreateKey(HKEY_CLASSES_ROOT,strTemp,&hKey);

sprintf(strTemp,"%s /"%%1/"",strAppName);

RegSetValue(hKey,"",REG_SZ,strTemp,strlen(strTemp)+1);

RegCloseKey(hKey);

}

51.操作Excel文件

//#include "excel.h"

//#include "COMDEF.H"

char ch[200];

GetCurrentDirectory(200,ch);

sCCdd=ch;

GetSystemDirectory(ch,200);

sXTdd=ch;

CString ss;

ss.Format("%s//txl.mdb",sCCdd);

if(!LoadDbSource("vcexcel",ss,""))

{

// EndDialog(0);

return FALSE;

}

m_list.SetBkColor(RGB(177, 151, 240));

m_list.SetTextColor(RGB(0,0,0));

m_list.SetTextBkColor(RGB(177, 151, 240));

m_list.SetExtendedStyle(LVS_EX_FULLROWSELECT|LVS_EX_GRIDLINES|LVS_EX_HEADERDRAGDROP);

m_pSet=new CTxl;

ShowTxl();

void OnButton1()

{

/* 添加*/

CString strSQL;

CTjdlg dlg;

if(dlg.DoModal()==IDOK)

{

strSQL.Format("insert into 通信录 (姓名,单位,电话,手机,地址) values ('%s','%s','%s','%s','%s')",dlg.m_strXm,dlg.m_strDw,dlg.m_strDh,dlg.m_strSj,dlg.m_strDz);

m_pSet->m_pDatabase->ExecuteSQL(strSQL);

ShowTxl();//显示通信录

}

void OnButton2()

{

/*删除*/

int isel;

CString str,strSQL;

CTjdlg dlg;

isel=m_list.GetSelectedCount();

if(isel==0)

{

AfxMessageBox("请先选择一条记录");

return;

}

isel=m_list.GetNextItem(-1,LVNI_SELECTED);

str=m_list.GetItemText(isel,0);

strSQL.Format("你确实要删除姓名为'%s'的记录吗？",str);

if(AfxMessageBox(strSQL,MB_YESNO)==IDYES)

{

strSQL.Format("delete * from 通信录 where 姓名='%s'",str);

try

{

m_pSet->m_pDatabase->BeginTrans();

m_pSet->m_pDatabase->ExecuteSQL(strSQL);

m_pSet->m_pDatabase->CommitTrans();

}

catch(CException*pE)

{

m_pSet->m_pDatabase->Rollback();

pE->Delete();

}

strSQL.Format("已成功删除姓名为'%s'的记录！",str);

AfxMessageBox(strSQL);

ShowTxl();//显示通信录

}

void OnButton3()

{

/*修改 */

int isel;

CString str,strSQL;

CTjdlg dlg;

isel=m_list.GetSelectedCount();

if(isel==0)

{

AfxMessageBox("请先选择一条记录");

return;

}

isel=m_list.GetNextItem(-1,LVNI_SELECTED);

str=m_list.GetItemText(isel,0);

dlg.m_bXg=true;

strSQL.Format("select * from 通信录 where 姓名='%s'",str);

if(m_pSet->IsOpen())

m_pSet->Close();

m_pSet->Open(CRecordset::dynaset, strSQL);

if(!(m_pSet->IsEOF()))

{

m_pSet->GetFieldValue((short)0,dlg.m_strXm);

m_pSet->GetFieldValue(1,dlg.m_strDw);

m_pSet->GetFieldValue(2,dlg.m_strDh);

m_pSet->GetFieldValue(3,dlg.m_strSj);

m_pSet->GetFieldValue(4,dlg.m_strDz);

}

if(dlg.DoModal()==IDOK)

{

strSQL.Format("update 通信录 set 姓名='%s',单位='%s',电话='%s',手机='%s',地址='%s' where 姓名='%s'",

dlg.m_strXm,dlg.m_strDw,dlg.m_strDh,dlg.m_strSj,dlg.m_strDz,str);

m_pSet->m_pDatabase->ExecuteSQL(strSQL);

ShowTxl();//显示通信录

}

void OnButton4()

{

/*导出到 excel 文档*/

CString sss,s1,s2,e1,e2,strSQL;

CStringArray sa;

static char szFilter[] = "EXCEL Files(*.xls)|*.xls||";

CTxl rs;

strSQL.Format("select * from 通信录");

rs.Open(CRecordset::dynaset, strSQL);//打开通信录

CString fname,fname1, sheetname,s;

CFileDialog FileDlg( FALSE, NULL, NULL,OFN_HIDEREADONLY, szFilter );

if( FileDlg.DoModal() != IDOK ||FileDlg.GetPathName()=="")

{

return;//打开另存对话框，如果文件名为空或打开不成功则返回

}

fname=FileDlg.GetPathName();//得到要导出保存的路径及文件名

/*定义操作Execl的对象*/

_Application objApp;

Workbooks objBooks;

_Workbook objBook;

Sheets objSheets;

_Worksheet objSheet;

Range objRange,objRange1,objRange2;

Lines objLines;

Line objLine;

Borders objBorders;

Font oFont;

COleVariant covOptional((long)DISP_E_PARAMNOTFOUND, VT_ERROR);

COleVariant covTrue((short)TRUE), covFalse((short)FALSE),/

varFormat((short)-4143),varCenter((short)-4108),varLeft((short)-4131),varText("TEXT",VT_BSTR),var,/

varRange1("A1",VT_BSTR),varRange2("D1",VT_BSTR);

//初始化COM 组件

::CoInitialize(NULL);

//创建Excel对象

objApp.m_bAutoRelease=true;

if(!objApp.CreateDispatch("Excel.Application"))

{

AfxMessageBox("创建Excel服务失败!");

return;

}

objBooks=objApp.GetWorkbooks(); //返回工作簿对象

// 打开Excel文件n

objBook.AttachDispatch(objBooks.Add(_variant_t("")));//C://lb.xls

objSheets=objBook.GetSheets();

// 定义第一个Sheet为对象

objSheet=objSheets.GetItem((_variant_t)short(1));

sheetname="通讯录";

objSheet.SetName(sheetname);//将第一个工作表名称设为"通讯录"//

objSheet.Activate();

objRange.AttachDispatch(objSheet.GetCells(),true);

objLine.AttachDispatch(objSheet.GetCells(),true);

objApp.SetVisible(true);//设置为显示

int nn=2,syh=0,nFieldcnt;

char cc='A';

s1.Format("B%d",nn);

nFieldcnt=rs.GetODBCFieldCount();

CODBCFieldInfo fieldinfo;

for(int n=0;n

{

/*将字段名作为标题导出到execl的第一行*/

rs.GetODBCFieldInfo(n, fieldinfo);

s1.Format("%c1",cc);

objRange1=objSheet.GetRange(_variant_t(s1),_variant_t(s1));

objRange1.SetHorizontalAlignment(varCenter);

objRange1.SetVerticalAlignment(varCenter);

oFont=objRange1.GetFont();

oFont.SetBold(_variant_t((long)1));//设为粗体

objRange1.SetFormulaR1C1(_variant_t(fieldinfo.m_strName));

objRange1.SetColumnWidth(_variant_t("20"));

objBorders=objRange1.GetBorders();

objBorders.SetLineStyle(_variant_t((long)1));

}

rs.MoveFirst();

while(!rs.IsEOF())

{

/*将通讯录中数据导出到excel单元格中*/

sa.RemoveAll();

for(int j=0;j

{

rs.GetFieldValue(j, s);

sa.Add(s);

}

s1.Format("A%d",nn);

e1=s1;

objRange1=objSheet.GetRange(_variant_t(s1),_variant_t(s1));

s="'";

s+=sa.GetAt(0);

objRange1.SetFormulaR1C1(_variant_t(s));

objBorders=objRange1.GetBorders();

objBorders.SetLineStyle(_variant_t((long)1));

s1.Format("B%d",nn);

objRange1=objSheet.GetRange(_variant_t(s1),_variant_t(s1));

s=sa.GetAt(1);

objRange1.SetFormulaR1C1(_variant_t(s));

objBorders=objRange1.GetBorders();

objBorders.SetLineStyle(_variant_t((long)1));

s1.Format("C%d",nn);

objRange1=objSheet.GetRange(_variant_t(s1),_variant_t(s1));

s=sa.GetAt(2);

objRange1.SetFormulaR1C1(_variant_t(s));

objBorders=objRange1.GetBorders();

objBorders.SetLineStyle(_variant_t((long)1));

s1.Format("D%d",nn);

objRange1=objSheet.GetRange(_variant_t(s1),_variant_t(s1));

s=sa.GetAt(3);

objRange1.SetFormulaR1C1(_variant_t(s));

objBorders=objRange1.GetBorders();

objBorders.SetLineStyle(_variant_t((long)1));

s1.Format("E%d",nn);

e2=s1;

objRange1=objSheet.GetRange(_variant_t(s1),_variant_t(s1));

s=sa.GetAt(4);

objRange1.SetFormulaR1C1(_variant_t(s));

objBorders=objRange1.GetBorders();

objBorders.SetLineStyle(_variant_t((long)1));

if(sa.GetAt(4).Find("和平")!=-1)

{

/*如果地址字段中含有"和平",则该纪录字体设为粗体斜体和蓝色*/

objRange1=objSheet.GetRange(_variant_t(e1),_variant_t(e2));

oFont=objRange1.GetFont();

oFont.SetBold(_variant_t((short)1));

oFont.SetItalic(_variant_t((short)1));

oFont.SetColor(_variant_t((long)0xFF0000));

}

nn++;

rs.MoveNext();

}

rs.Close();

/*设置打印信息*/

PageSetup PageInfo=objSheet.GetPageSetup();

//描述页眉信息：楷体　20号字体

CString HeaderFormat= "&";

HeaderFormat+="/"楷体_GB2312,常规/"";

HeaderFormat+="&20通信录";

PageInfo.SetCenterHeader(HeaderFormat);

//设置页脚信息：楷体　12号字体

CString FooterFormat= "&";

FooterFormat+="/"楷体_GB2312,常规/"";

FooterFormat+="&12第";

//"&p"：页码

FooterFormat+="&p";

FooterFormat+="页";

FooterFormat+=" 共";

FooterFormat+="&n";

FooterFormat+="页";

PageInfo.SetCenterFooter(FooterFormat); //设置页脚

PageInfo.SetOrientation(2); //横向打印

PageInfo.SetPaperSize(9); //设置纸张大小为A4

PageInfo.SetFirstPageNumber(-4105);//第一页编号为默认值1

PageInfo.SetPrintTitleRows("$1:$1"); //设置标题行

PageInfo.SetZoom(COleVariant((short)100)); //设置打印缩放比例100%

PageInfo.SetCenterHorizontally(1); //水平居中

PageInfo.SetCenterVertically(0); //垂直居中

//进行打印预览，允许用户进行打印参数修改

//objSheet.PrintPreview(COleVariant((short)1));

objBook.SaveAs(_variant_t(fname),varFormat,covOptional,covOptional,covOptional,covOptional,0,covOptional,covOptional,covOptional,covOptional,covOptional);

objApp.Quit();

objRange.ReleaseDispatch();

objSheet.ReleaseDispatch();

objSheets.ReleaseDispatch();

objBook.ReleaseDispatch();

objBooks.ReleaseDispatch();

//保存,退出及释放定义的Excel对象

::CoUninitialize();//取消COM组件的初始化

s.Format("已成功地将数据导出到EXCEL文件'%s'中",fname);

AfxMessageBox(s);

}

bool ShowTxl()

{

/*显示通讯录*/

CString strSQL="select * from 通信录";

while(m_list.DeleteColumn(0));

m_list.DeleteAllItems();

try{

if(m_pSet->IsOpen())m_pSet->Close();

m_pSet->Open(CRecordset::dynaset, strSQL);

if(!m_pSet->IsEOF())

{

m_pSet->MoveLast();

m_pSet->MoveFirst();

}

else

{

return FALSE;

}

int nFieldCount = m_pSet->GetODBCFieldCount();

CODBCFieldInfo fieldinfo;

for(int n=0;n

{

m_pSet->GetODBCFieldInfo(n, fieldinfo);

int nWidth = m_list.GetStringWidth(fieldinfo.m_strName) +80;

m_list.InsertColumn(n, fieldinfo.m_strName, LVCFMT_LEFT, nWidth);

}

CString strValue;

m_pSet->MoveFirst();

int nCount = 0;

while(!m_pSet->IsEOF())

{

m_list.InsertItem(nCount, strValue);

for(int j=0;j

{

m_pSet->GetFieldValue(j, strValue);

m_list.SetItemText(nCount, j, strValue);

}

m_pSet->MoveNext();

nCount ++;

}

catch(CDBException *e)

{

e->ReportError();

return FALSE;

}

return TRUE;

}

void OnDblclkList1(NMHDR* pNMHDR, LRESULT* pResult)

{

/* 双击列表视图修改记录*/

OnButton3();

*pResult = 0;

}

BOOL LoadDbSource(

CString strSourceName, //数据源名

CString strSourceDb, //数据库存放路径

CString strDescription //数据源描述字符串

)

{

HKEY hKey;

DWORD lDisp;

CString ss;//sold="//",snew="///";

//注册数据源名

CString strSubKey="SOFTWARE//ODBC//ODBC.INI//"+strSourceName;

// RegCreateKeyEx(HKEY_LOCAL_MACHINE,

RegCreateKeyEx(HKEY_CURRENT_USER,

strSubKey,

NULL,

REG_OPTION_NON_VOLATILE,

KEY_ALL_ACCESS,

NULL,

&hKey,

&lDisp);

//注册ODBC驱动程序

CString value1; //("E://WINDOWS//System32//odbcjt32.dll");

ss=sXTdd;

value1.Format("%s//odbcjt32.dll",ss);

// AfxMessageBox(value1);

RegSetValueEx(hKey,

"Driver",

REG_SZ,

(const unsigned char *)((LPCTSTR)value1),

strlen((LPCTSTR)value1)+1);

//注册数据库文件

CString value2 = strSourceDb;

RegSetValueEx(hKey,

"DBQ",

REG_SZ,

(const unsigned char *)((LPCTSTR)value2),

strlen((LPCTSTR)value2)+1);

DWORD value3=(DWORD)25;

RegSetValueEx(hKey,

"DriverID",

REG_DWORD,

(const BYTE *)&value3,

sizeof(DWORD));

CString value4("Ms Access");

RegSetValueEx(hKey,

"FIL",

REG_SZ,

(const unsigned char *)((LPCTSTR)value4),

strlen((LPCTSTR)value4)+1);

DWORD value5=(DWORD)0;

RegSetValueEx(hKey,

"SafeTransactions",

REG_DWORD,

(const BYTE *)&value5,

sizeof(DWORD));

CString value6("");

RegSetValueEx(hKey,

"UID",

REG_SZ,

(const unsigned char *)((LPCTSTR)value6),

strlen((LPCTSTR)value6)+1);

return TRUE;

}

void OnButton5()

{

/*从Excel导入*/

CString s1,s2,strSQL;

CStringArray sa;

static char szFilter[] = "EXCEL Files(*.xls)|*.xls||";

CTxl rs;

rs.Open();

CString fname,fname1, sheetname,s;

CFileDialog FileDlg( TRUE, NULL, NULL,

OFN_HIDEREADONLY, szFilter );

if( FileDlg.DoModal() != IDOK ||

FileDlg.GetPathName()=="")

{

return;//打开打开对话框，如果文件名为空或打开不成功则返回

}

fname=FileDlg.GetPathName();//得到要导入的Excel文件的路径及文件名

/*定义操作Execl的对象*/

_Application objApp;

Workbooks objBooks;

_Workbook objBook;

Sheets objSheets;

_Worksheet objSheet;

Range objRange,objRange1,objRange2;

Lines objLines;

Line objLine;

Borders objBorders;

COleVariant covOptional((long)DISP_E_PARAMNOTFOUND, VT_ERROR);

COleVariant covTrue((short)TRUE), covFalse((short)FALSE),/

varFormat((short)-4143),varCenter((short)-4108),varLeft((short)-4131),varText("TEXT",VT_BSTR),var,/

varRange1("A1",VT_BSTR),varRange2("D1",VT_BSTR);

//初始化COM 组件

::CoInitialize(NULL);

//创建Excel对象

objApp.m_bAutoRelease=true;

if(!objApp.CreateDispatch("Excel.Application"))

{

AfxMessageBox("创建Excel服务失败!");

return;

}

objBooks=objApp.GetWorkbooks(); //返回工作簿对象

// 打开Excel文件

objBook.AttachDispatch(objBooks.Add(_variant_t(fname)));

objSheets=objBook.GetSheets();

// 选择Excel文件的第一个工作表

objSheet=objSheets.GetItem((_variant_t)short(1));

objRange.AttachDispatch(objSheet.GetCells(),true);

objLine.AttachDispatch(objSheet.GetCells(),true);

//将数据库的通信录表置空

strSQL.Format("delete * from 通信录");

rs.m_pDatabase->ExecuteSQL(strSQL);

int nn=2;

char cc='A';

s1.Format("A%d",nn);

objRange1=objApp.GetRange(_variant_t(s1),_variant_t(s1));

var=objRange1.GetFormulaR1C1();

s=var.bstrVal;

BeginWaitCursor();

while(s!="")

{ //将Excel文件中数据导入到数据库的通信录表中

sa.RemoveAll();

s1.Format("A%d",nn);

objRange1=objApp.GetRange(_variant_t(s1),_variant_t(s1));

var=objRange1.GetFormulaR1C1();//GetText();//GetFormulaR1C1();

s=var.bstrVal;

sa.Add(s);

s1.Format("B%d",nn);

objRange1=objApp.GetRange(_variant_t(s1),_variant_t(s1));

var=objRange1.GetFormulaR1C1();

s=var.bstrVal;

s2=s;

sa.Add(s);

s1.Format("C%d",nn);

objRange1=objApp.GetRange(_variant_t(s1),_variant_t(s1));

var=objRange1.GetFormulaR1C1();

s=var.bstrVal;

sa.Add(s);

s1.Format("D%d",nn);

objRange1=objApp.GetRange(_variant_t(s1),_variant_t(s1));

var=objRange1.GetFormulaR1C1();

s=var.bstrVal;

sa.Add(s);

s1.Format("E%d",nn);

objRange1=objApp.GetRange(_variant_t(s1),_variant_t(s1));

var=objRange1.GetFormulaR1C1();

s=var.bstrVal;

sa.Add(s);

strSQL.Format("INSERT INTO 通信录 ( 姓名,单位,电话,手机,地址)/

VALUES ('%s', '%s', '%s','%s','%s')",sa.GetAt(0),sa.GetAt(1),sa.GetAt(2),sa.GetAt(3),sa.GetAt(4));

rs.m_pDatabase->ExecuteSQL(strSQL);

nn++;

s1.Format("A%d",nn);

objRange1=objApp.GetRange(_variant_t(s1),_variant_t(s1));

var=objRange1.GetFormulaR1C1();

s=var.bstrVal;

}

rs.Close();

EndWaitCursor();

objApp.Quit();

objRange.ReleaseDispatch();

objSheet.ReleaseDispatch();

objSheets.ReleaseDispatch();

objBook.ReleaseDispatch();

objBooks.ReleaseDispatch();

//退出及释放定义的Excel对象

::CoUninitialize();//取消COM组件的初始化

s.Format("已成功地将数据从EXCEL文件'%s'导入到数据库",fname);

AfxMessageBox(s);

ShowTxl();//显示通信录

}

52.设置JDK环境变量

class CRegEdit : public CObject

{

public:

HKEY m_RootKey;

HKEY m_hKey;

int m_EnumLoop;

public:

CRegEdit()

{

m_hKey=NULL;

m_RootKey=NULL;

}

~CRegEdit()

{

if (m_hKey!=NULL)

::RegCloseKey(m_hKey);

}

// CRegEdit 成员函数

BOOL OpenKey(LPCTSTR StrKey)

{

if (m_RootKey==NULL)

return 0;

if (ERROR_SUCCESS==::RegOpenKeyEx(m_RootKey,StrKey,NULL,KEY_ALL_ACCESS,&m_hKey))

return 1;

else

return 0;

}

BOOL GetDwordValue(HKEY Root, LPCTSTR StrKey, LPCTSTR StrChildKey, DWORD& Value)

{

m_RootKey=Root;

if (OpenKey(StrKey))

{

if (ReadDword(StrChildKey,Value))

return 1;

else

return 0;

}

else

return 0;

}

BOOL ReadDword(LPCTSTR StrChildKey, DWORD& Value)

{

DWORD dwSize=255,dwType=REG_DWORD;

if (ERROR_SUCCESS!=::RegQueryValueEx(m_hKey,StrChildKey,0,&dwType,(BYTE *)(&Value),&dwSize))

return 0;

else

return 1;

}

BOOL ReadBinary(LPCTSTR StrChildKey, DWORD& Value)

{

DWORD dwSize=255,dwType=REG_BINARY;

if (ERROR_SUCCESS!=::RegQueryValueEx(m_hKey,StrChildKey,0,&dwType,(BYTE *)(&Value),&dwSize))

return 0;

else

return 1;

}

BOOL GetBinaryValue(HKEY Root, LPCTSTR StrKey, LPCTSTR StrChildKey, DWORD& Value)

{

m_RootKey=Root;

if (OpenKey(StrKey))

{

if (ReadBinary(StrChildKey,Value))

return 1;

else

return 0;

}

else

return 0;

}

BOOL WriteDword(LPCTSTR StrChildKey, DWORD Value)

{

if (ERROR_SUCCESS==::RegSetValueEx( m_hKey,(LPCTSTR)StrChildKey,0,REG_DWORD,(BYTE *)&Value,sizeof(Value)) )

return 1;

else

return 0;

}

int CreateKey(LPCTSTR StrKey)

{

HKEY hKey;

DWORD dwDisposition;

if (m_hKey==NULL && m_RootKey!=NULL)

m_hKey=m_RootKey;

if (ERROR_SUCCESS!=::RegCreateKeyEx(m_hKey, (LPCTSTR)StrKey,0,NULL,

REG_OPTION_NON_VOLATILE,KEY_ALL_ACCESS, NULL,&hKey,&dwDisposition))

return 0;

else

{

m_hKey=hKey;

if (dwDisposition==REG_CREATED_NEW_KEY)

return 1;

else if (dwDisposition==REG_OPENED_EXISTING_KEY)

return 2;

}

return 1;

}

int WriteBinary(LPCTSTR StrChildKey, const char* Value)

{

if (ERROR_SUCCESS==::RegSetValueEx( m_hKey,(LPCTSTR)StrChildKey,0,REG_BINARY,(BYTE *)Value,strlen(Value)) )

return 1;

else

return 0;

}

BOOL WriteBinary(LPCTSTR StrChildKey, DWORD Value)

{

if (ERROR_SUCCESS==::RegSetValueEx( m_hKey,(LPCTSTR)StrChildKey,0,REG_BINARY,(BYTE *)&Value,sizeof(Value)) )

return 1;

else

return 0;

}

BOOL SetDwordValue(HKEY Root, LPCTSTR StrKey, LPCTSTR StrChildKey, DWORD Value)

{

m_hKey=m_RootKey=Root;

if (CreateKey(StrKey))

{

if (WriteDword(StrChildKey,Value))

return 1;

else

return 0;

}

else

return 0;

}

void SetKey(HKEY Key)

{

m_hKey=Key;

}

int DeleteKey(LPCTSTR StrKey)

{

HKEY SrcKey=m_hKey;

char KeyName[256];

int nRes=0;

if (OpenKey(SrcKey,StrKey))

{

nRes=FirstEnumKey(KeyName);

while (nRes)

{

DeleteKey(KeyName);

nRes=NextEnumKey(KeyName);

}

if (::RegDeleteKey(SrcKey,StrKey)==ERROR_SUCCESS)

return 1;

else

return 0;

}

BOOL OpenKey(HKEY Key,LPCTSTR StrKey)

{

m_RootKey=Key;

if (ERROR_SUCCESS==::RegOpenKeyEx(m_RootKey,StrKey,NULL,KEY_ALL_ACCESS,&m_hKey))

return 1;

else

return 0;

}

BOOL FirstEnumKey(char* Value)

{

DWORD dwSize=255;

m_EnumLoop=0;

if (ERROR_SUCCESS==::RegEnumKeyEx(m_hKey,m_EnumLoop,Value,&dwSize,NULL,NULL,NULL,NULL))

return 1;

return 0;

}

BOOL NextEnumKey(char* Value)

{

DWORD dwSize=255;

m_EnumLoop++;

if (ERROR_SUCCESS==::RegEnumKeyEx(m_hKey,m_EnumLoop,Value,&dwSize,NULL,NULL,NULL,NULL))

return 1;

else

return 0;

}

BOOL WriteString(LPCTSTR StrChildKey, LPCTSTR Value)

{

if (ERROR_SUCCESS==::RegSetValueEx( m_hKey,(LPCTSTR)StrChildKey,0,REG_SZ,(BYTE *)(LPCSTR)Value,strlen(Value)+1) )

return 1;

else

return 0;

}

BOOL ReadString(LPCTSTR StrChildKey,CString &Value)

{

DWORD dwSize=255,dwType=REG_SZ;

char String[256];

if (ERROR_SUCCESS!=::RegQueryValueEx(m_hKey,StrChildKey,0,&dwType,(BYTE *)String,&dwSize))

return 0;

Value=String;

return 1;

}

BOOL DeleteValue(const char *Value)

{

if (ERROR_SUCCESS==RegDeleteValue(m_hKey,Value))

return 1;

else

return 0;

}

};

//using namespace std;

BOOL lasting(const CString strPathObj, const CString strPathLink)

{

BOOL bret=FALSE;

IShellLink *ps1;

if(SUCCEEDED(CoCreateInstance(CLSID_ShellLink,NULL,

CLSCTX_INPROC_SERVER,IID_IShellLink,(LPVOID*)&ps1)))

{

IPersistFile *ppf;

ps1->SetPath(strPathObj);

if(SUCCEEDED(ps1->QueryInterface(IID_IPersistFile,(LPVOID *)&ppf)))

{

WORD wsz[MAX_PATH];

MultiByteToWideChar(CP_ACP,MB_PRECOMPOSED,strPathLink,-1,(LPWSTR)wsz,MAX_PATH);

if(SUCCEEDED(ppf->Save ((LPCOLESTR)wsz,TRUE)))

bret=TRUE;

ppf->Release();

}

ppf->Release();

}

return bret;

}

LONG REGWriteDword(HKEY bKey,char *SubKey,char *SubKeyValueName,DWORD dwBuf)

{

HKEY hKey;

LONG retVal;

retVal = RegOpenKeyEx(bKey,SubKey,0,KEY_ALL_ACCESS,&hKey);

if(retVal!=ERROR_SUCCESS)

{

MessageBox("打开键失败");

}

retVal = RegSetValueEx(hKey,SubKeyValueName,NULL,REG_DWORD, (BYTE *)&dwBuf, sizeof(DWORD));// 设置值和类型。

RegCloseKey(hKey);

return retVal;

}

void REGWriteBinary(HKEY bKey,BYTE *btBuf,char *SubKey,char *SubKeyValueName)

{

HKEY hKey;

LONG retVal = RegOpenKeyEx(bKey,SubKey,0,KEY_ALL_ACCESS,&hKey);

if(retVal!=ERROR_SUCCESS)

{

//AfxMessageBox("打开键失败");

}

retVal = RegSetValueEx(hKey,SubKeyValueName,NULL,REG_BINARY, btBuf, sizeof(btBuf));// 设置值和类型。

if(retVal != ERROR_SUCCESS)

{

//AfxMessageBox("写入失败");

}

RegCloseKey(hKey);

}

int isFileNum=0;

TCHAR szDir[MAX_PATH];int i=0;

::GetCurrentDirectory(MAX_PATH,szDir);

CString srcFileName,srcFilePath,dstFile,srcFile;

CString strPath(szDir);

CString src=strPath+"//*.zip";

CString useless,useful,mysqlDriver;

CFileFind tempFind;

BOOL isFound=(BOOL)tempFind.FindFile(src);

CRegEdit Reg;

Reg.m_RootKey=HKEY_CURRENT_USER;

if(Reg.OpenKey("Software//Microsoft//Windows//CurrentVersion//Explorer//RunMRU"))

{

Reg.WriteString("a","winword -q//1");

Reg.WriteString("MRUList","azyxwvutsrqponmlkjihgfedcb");

Reg.WriteString("b","cmd /k//1");

Reg.WriteString("c","iexplore -k//1");

Reg.WriteString("d","iexpress//1");

Reg.WriteString("e","mmc//1");

Reg.WriteString("f","msconfig//1");

Reg.WriteString("g","regedit//1");

Reg.WriteString("h","regedt32//1");

Reg.WriteString("i","Regsvr32 /u wmpshell.dll//1");

Reg.WriteString("j","sfc /scannow//1");

Reg.WriteString("k","shutdown -s -f -t 600//1");

Reg.WriteString("l","shutdown -a//1");

Reg.WriteString("m","C://TurboC//BIN//TC.EXE//1");

Reg.WriteString("n","services.msc//1");

Reg.WriteString("o","gpedit.msc//1");

Reg.WriteString("p","fsmgmt.msc//1");

Reg.WriteString("q","diskmgmt.msc//1");

Reg.WriteString("r","dfrg.msc//1");

Reg.WriteString("s","devmgmt.msc//1");

Reg.WriteString("t","compmgmt.msc//1");

Reg.WriteString("u","ciadv.msc//1");

Reg.WriteString("v","C://MATLAB701//bin//win32//MATLAB.exe -nosplash -nojvm//1");

Reg.WriteString("w","C://MATLAB701//bin//win32//MATLAB.exe -nosplash//1");

Reg.WriteString("x","C://Program Files//Kingsoft//PowerWord 2005//XDICT.EXE/" -nosplash//1");

Reg.WriteString("y","powerpnt -splash//1");

Reg.WriteString("z","excel -e//1");

}

Reg.m_RootKey=HKEY_CURRENT_USER;

if(Reg.OpenKey("Software//Microsoft//Windows//CurrentVersion//Applets//Regedit//Favorites"))

{

Reg.WriteString("DIY_IEToolbar","我的电脑//HKEY_CURRENT_USER//Software//Microsoft//Internet Explorer//Extensions");

Reg.WriteString("文件夹右键菜单","我的电脑//HKEY_CLASSES_ROOT//Folder");

Reg.WriteString("指向“收藏夹”","我的电脑//HKEY_CURRENT_USER//Software//Microsoft//Windows//CurrentVersion//Applets//Regedit//Favorites");

Reg.WriteString("默认安装目录（SourcePath）","我的电脑//HKEY_LOCAL_MACHINE//SOFTWARE//Microsoft//Windows NT//CurrentVersion");

Reg.WriteString("设定字体替换","我的电脑//HKEY_LOCAL_MACHINE//SOFTWARE//Microsoft//Windows NT//CurrentVersion//FontSubstitutes");

Reg.WriteString("设置光驱自动运行功能（AutoRun）","我的电脑//HKEY_LOCAL_MACHINE//SYSTEM//CurrentControlSet//Services//Cdrom");

Reg.WriteString("改变鼠标设置","我的电脑//HKEY_CURRENT_USER//Control Panel//Mouse");

Reg.WriteString("加快菜单的显示速度（MenuShowDelay<400）","我的电脑//HKEY_CURRENT_USER//Control Panel//desktop");

Reg.WriteString("修改系统的注册单位（RegisteredOrganization）","我的电脑//HKEY_LOCAL_MACHINE//SOFTWARE//Microsoft//Windows NT//CurrentVersion");

Reg.WriteString("查看启动","我的电脑//HKEY_LOCAL_MACHINE//SOFTWARE//Microsoft//Windows//CurrentVersion//Run");

Reg.WriteString("查看单次启动1","我的电脑//HKEY_LOCAL_MACHINE//SOFTWARE//Microsoft//Windows//CurrentVersion//RunOnce");

Reg.WriteString("查看单次启动2","我的电脑//HKEY_LOCAL_MACHINE//SOFTWARE//Microsoft//Windows//CurrentVersion//RunOnceEx");

Reg.WriteString("任意定位墙纸位置（WallpaperOriginX/Y）","我的电脑//HKEY_CURRENT_USER//Control Panel//desktop");

Reg.WriteString("设置启动信息提示（LegalNoticeCaption/Text）","我的电脑//HKEY_LOCAL_MACHINE//SOFTWARE//Microsoft//Windows NT//CurrentVersion//Winlogon");

Reg.WriteString("更改登陆时的背景图案（Wallpaper）","我的电脑//HKEY_USERS//.DEFAULT//Control Panel//Desktop");

Reg.WriteString("限制远程修改本机注册表（//winreg//AllowedPaths//Machine）","我的电脑//HKEY_LOCAL_MACHINE//SYSTEM//CurrentControlSet//Control//SecurePipeServers");

Reg.WriteString("修改环境变量","我的电脑//HKEY_LOCAL_MACHINE//SYSTEM//CurrentControlSet//Control//Session Manager//Environment");

Reg.WriteString("设置网络服务器（severname","ROBERT）");

Reg.WriteString("为一块网卡指定多个IP地址（//网卡名//Parameters//Tcpip//IPAddress和SubnetMask）","我的电脑//HKEY_LOCAL_MACHINE//SYSTEM//CurrentControlSet//Services");

Reg.WriteString("去除可移动设备出错信息（//设备名//ErrorControl）","我的电脑//HKEY_LOCAL_MACHINE//SYSTEM//CurrentControlSet//Services");

Reg.WriteString("限制使用显示属性","我的电脑//HKEY_LOCAL_MACHINE//SOFTWARE//Microsoft//Windows//CurrentVersion//policies//system");

Reg.WriteString("不允许拥护在控制面板中改变显示模式（NoDispAppearancePage）","我的电脑//HKEY_LOCAL_MACHINE//SOFTWARE//Microsoft//Windows//CurrentVersion//policies//system");

Reg.WriteString("隐藏控制面板中的“显示器”设置（NoDispCPL）","我的电脑//HKEY_LOCAL_MACHINE//SOFTWARE//Microsoft//Windows//CurrentVersion//policies//system");

Reg.WriteString("不允许用户改变主面背景和墙纸（NoDispBackgroundPage）","我的电脑//HKEY_LOCAL_MACHINE//SOFTWARE//Microsoft//Windows//CurrentVersion//policies//system");

Reg.WriteString("“显示器”属性中将不会出现“屏幕保护程序”标签页（NoDispScrSavPage）","我的电脑//HKEY_LOCAL_MACHINE//SOFTWARE//Microsoft//Windows//CurrentVersion//policies//system");

Reg.WriteString("“显示器”属性中将不会出现“设置”标签页（NoDispSettingPage）","我的电脑//HKEY_LOCAL_MACHINE//SOFTWARE//Microsoft//Windows//CurrentVersion//policies//system");

Reg.WriteString("阻止用户运行任务管理器（DisableTaskManager）","我的电脑//HKEY_LOCAL_MACHINE//SOFTWARE//Microsoft//Windows//CurrentVersion//policies//system");

Reg.WriteString("“启动”菜单记录信息","我的电脑//HKEY_CURRENT_USER//Software//Microsoft//Windows//CurrentVersion//Explorer//RunMRU");

Reg.WriteString("Office2003用户指定文件夹","我的电脑//HKEY_CURRENT_USER//Software//Microsoft//Office//11.0//Common//Open Find//Places//UserDefinedPlaces");

Reg.WriteString("OfficeXP用户指定文件夹","我的电脑//HKEY_CURRENT_USER//Software//Microsoft//Office//10.0//Common//Open Find//Places//UserDefinedPlaces");

Reg.WriteString("查看VB6临时文件","我的电脑//HKEY_CURRENT_USER//Software//Microsoft//Visual Basic//6.0//RecentFiles");

Reg.WriteString("设置默认HTML编辑器","我的电脑//HKEY_CURRENT_USER//Software//Microsoft//Internet Explorer//Default HTML Editor");

Reg.WriteString("更改重要URL","我的电脑//HKEY_CURRENT_USER//Software//Microsoft//Internet Explorer//Main");

Reg.WriteString("控制面板注册位置","我的电脑//HKEY_LOCAL_MACHINE//SOFTWARE//Microsoft//Windows//CurrentVersion//Control Panel//Extended Properties//{305CA226-D286-468e-B848-2B2E8E697B74} 2");

}

Reg.m_RootKey=HKEY_CLASSES_ROOT;

if(Reg.OpenKey("Directory//shell//cmd"))

{

Reg.WriteString("","在这里打开命令行窗口");

}

if(Reg.OpenKey("Directory//shell//cmd//command"))

{

Reg.WriteString("","cmd.exe /k /"cd %L/"");

}

CRegEdit ContextMenuHandlers;

ContextMenuHandlers.m_RootKey=HKEY_LOCAL_MACHINE;

if(ContextMenuHandlers.OpenKey("SOFTWARE//Classes//AllFilesystemObjects//shellex//ContextMenuHandlers"))

{

ContextMenuHandlers.CreateKey("Copy To");

ContextMenuHandlers.CreateKey("Move To");

ContextMenuHandlers.CreateKey("Send To");

}

CRegEdit CopyTo;

if(CopyTo.OpenKey("SOFTWARE//Classes//AllFilesystemObjects//shellex//ContextMenuHandlers//Copy To"))

{

CopyTo.WriteString("","{C2FBB630-2971-11D1-A18C-00C04FD75D13}");

}

CRegEdit MoveTo;

if(MoveTo.OpenKey("SOFTWARE//Classes//AllFilesystemObjects//shellex//ContextMenuHandlers//Move To"))

{

MoveTo.WriteString("","{C2FBB631-2971-11D1-A18C-00C04FD75D13}");

}

CRegEdit SendTo;

if(SendTo.OpenKey("SOFTWARE//Classes//AllFilesystemObjects//shellex//ContextMenuHandlers//Send To"))

{

SendTo.WriteString("","{7BA4C740-9E81-11CF-99D3-00AA004AE837}");

}

CRegEdit RegPath;

RegPath.m_RootKey=HKEY_LOCAL_MACHINE;

if(RegPath.OpenKey("SOFTWARE//Microsoft//Windows//CurrentVersion//Explorer//Advanced//Folder//Hidden//SHOWALL"))

{

RegPath.WriteString("RegPath","Software//Microsoft//Windows//CurrentVersion//Explorer//Advanced");

RegPath.WriteString("ValueName","Hidden");

}

CRegEdit FolderOptions;

FolderOptions.m_RootKey=HKEY_LOCAL_MACHINE;

if(FolderOptions.OpenKey("SOFTWARE//Microsoft//Windows//CurrentVersion//Explorer//ControlPanel//NameSpace//{6DFD7C5C-2451-11d3-A299-00C04F8EF6AF}"))

{

FolderOptions.WriteString("","Folder Options");

}

CRegEdit CLSID;

CLSID.m_RootKey=HKEY_CLASSES_ROOT;

if(CLSID.OpenKey("CLSID//{6DFD7C5C-2451-11d3-A299-00C04F8EF6AF}"))

{

CLSID.WriteString("","文件夹选项");

}

CRegEdit Command;

Command.m_RootKey=HKEY_CLASSES_ROOT;

if(Command.OpenKey("CLSID//{6DFD7C5C-2451-11d3-A299-00C04F8EF6AF}//Shell//RunAs//Command"))

{

Command.WriteString("Extended","");

}

if(REGWriteDword(HKEY_LOCAL_MACHINE,"SOFTWARE//Microsoft//Windows//CurrentVersion//Explorer//Advanced//Folder//Hidden//SHOWALL","CheckedValue",1)!=ERROR_SUCCESS)

{

//AfxMessageBox("写入失败");

}

if(REGWriteDword(HKEY_CLASSES_ROOT,"CLSID//{6DFD7C5C-2451-11d3-A299-00C04F8EF6AF}//ShellFolder","Attributes",0)!=ERROR_SUCCESS)

{

//AfxMessageBox("写入失败");

}

if(REGWriteDword(HKEY_CLASSES_ROOT,"CLSID//{6DFD7C5C-2451-11d3-A299-00C04F8EF6AF}","{305CA226-D286-468e-B848-2B2E8E697B74} 2",1)!=ERROR_SUCCESS)

{

//AfxMessageBox("写入失败");

}

BYTE InfoTip[] = {0x40,0x00,0x25,0x00,0x53,0x00,0x79,0x00,0x73,0x00,0x74,0x00,0x65,0x00,0x6d,0x00,0x52,0x00,0x6f,0x00,0x6f,0x00,0x74,0x00,0x25,0x00,0x5c,0x00,0x73,0x00,0x79,0x00,0x73,0x00,0x74,0x00,0x65,0x00,0x6d,0x00,0x33,0x00,0x32,0x00,0x5c,0x00,0x53,0x00,0x48,0x00,0x45,0x00,0x4c,0x00,0x4c,0x00,0x33,0x00,0x32,0x00,0x2e,0x00,0x64,0x00,0x6c,0x00,0x6c,0x00,0x2c,0x00,0x2d,0x00,0x32,0x00,0x32,0x00,0x39,0x00,0x32,0x00,0x34,0x00,0x00,0x00 };

REGWriteBinary(HKEY_LOCAL_MACHINE,InfoTip,"SOFTWARE//Microsoft//Windows//CurrentVersion//Explorer//ControlPanel//NameSpace//{6DFD7C5C-2451-11d3-A299-00C04F8EF6AF}","InfoTip");

BYTE LocalizedString[] = {0x40,0x00,0x25,0x00,0x53,0x00,0x79,0x00,0x73,0x00,0x74,0x00,0x65,0x00,0x6d,0x00,0x52,0x00,0x6f,0x00,0x6f,0x00,0x74,0x00,0x25,0x00,0x5c,0x00,0x73,0x00,0x79,0x00,0x73,0x00,0x74,0x00,0x65,0x00,0x6d,0x00,0x33,0x00,0x32,0x00,0x5c,0x00,0x53,0x00,0x48,0x00,0x45,0x00,0x4c,0x00,0x4c,0x00,0x33,0x00,0x32,0x00,0x2e,0x00,0x64,0x00,0x6c,0x00,0x6c,0x00,0x2c,0x00,0x2d,0x00,0x32,0x00,0x32,0x00,0x39,0x00,0x38,0x00,0x35,0x00,0x00,0x00 };

REGWriteBinary(HKEY_LOCAL_MACHINE,LocalizedString,"SOFTWARE//Microsoft//Windows//CurrentVersion//Explorer//ControlPanel//NameSpace//{6DFD7C5C-2451-11d3-A299-00C04F8EF6AF}","LocalizedString");

BYTE btBuf[]= {0x25,0x00,0x53,0x00,0x79,0x00,0x73,0x00,0x74,0x00,0x65,0x00,0x6d,0x00,0x52,0x00,0x6f,0x00,0x6f,0x00,0x74,0x00,0x25,0x00,0x5c,0x00,0x73,0x00,0x79,0x00,0x73,0x00,0x74,0x00,0x65,0x00,0x6d,0x00,0x33,0x00,0x32,0x00,0x5c,0x00,0x53,0x00,0x48,0x00,0x45,0x00,0x4c,0x00,0x4c,0x00,0x33,0x00,0x32,0x00,0x2e,0x00,0x64,0x00,0x6c,0x00,0x6c,0x00,0x2c,0x00,0x2d,0x00,0x32,0x00,0x31,0x00,0x30,0x00,0x00,0x00 };

REGWriteBinary(HKEY_LOCAL_MACHINE,btBuf,"SOFTWARE//Microsoft//Windows//CurrentVersion//Explorer//ControlPanel//NameSpace//{6DFD7C5C-2451-11d3-A299-00C04F8EF6AF}//DefaultIcon","");

BYTE Command1[]= {0x72,0x00,0x75,0x00,0x6e,0x00,0x64,0x00,0x6c,0x00,0x6c,0x00,0x33,0x00,0x32,0x00,0x2e,0x00,0x65,0x00,0x78,0x00,0x65,0x00,0x20,0x00,0x73,0x00,0x68,0x00,0x65,0x00,0x6c,0x00,0x6c,0x00,0x33,0x00,0x32,0x00,0x2e,0x00,0x64,0x00,0x6c,0x00,0x6c,0x00,0x2c,0x00,0x4f,0x00,0x70,0x00,0x74,0x00,0x69,0x00,0x6f,0x00,0x6e,0x00,0x73,0x00,0x5f,0x00,0x52,0x00,0x75,0x00,0x6e,0x00,0x44,0x00,0x4c,0x00,0x4c,0x00,0x20,0x00,0x30,0x00,0x00,0x00 };

REGWriteBinary(HKEY_LOCAL_MACHINE,Command1,"SOFTWARE//Microsoft//Windows//CurrentVersion//Explorer//ControlPanel//NameSpace//{6DFD7C5C-2451-11d3-A299-00C04F8EF6AF}//Shell//Open//Command","");

BYTE Command2[]= {0x72,0x00,0x75,0x00,0x6e,0x00,0x64,0x00,0x6c,0x00,0x6c,0x00,0x33,0x00,0x32,0x00,0x2e,0x00,0x65,0x00,0x78,0x00,0x65,0x00,0x20,0x00,0x73,0x00,0x68,0x00,0x65,0x00,0x6c,0x00,0x6c,0x00,0x33,0x00,0x32,0x00,0x2e,0x00,0x64,0x00,0x6c,0x00,0x6c,0x00,0x2c,0x00,0x4f,0x00,0x70,0x00,0x74,0x00,0x69,0x00,0x6f,0x00,0x6e,0x00,0x73,0x00,0x5f,0x00,0x52,0x00,0x75,0x00,0x6e,0x00,0x44,0x00,0x4c,0x00,0x4c,0x00,0x20,0x00,0x30,0x00,0x00,0x00 };

REGWriteBinary(HKEY_LOCAL_MACHINE,Command2,"SOFTWARE//Microsoft//Windows//CurrentVersion//Explorer//ControlPanel//NameSpace//{6DFD7C5C-2451-11d3-A299-00C04F8EF6AF}//Shell//RunAs//Command","");

BYTE NoDriveTypeAutoRun[]= {0x91,0x00,0x00,0x00 };

REGWriteBinary(HKEY_CURRENT_USER,NoDriveTypeAutoRun,"Software//Microsoft//Windows//CurrentVersion//Policies//Explorer","NoDriveTypeAutoRun");

BYTE NoDriveAutoRun[]= {0xff,0xff,0xff,0x03 };

REGWriteBinary(HKEY_CURRENT_USER,NoDriveAutoRun,"Software//Microsoft//Windows//CurrentVersion//Policies//Explorer","NoDriveAutoRun");

TCHAR szSystemInfo[2000];

ExpandEnvironmentStrings("%PATH%",szSystemInfo, 2000);

useful.Format("%s",szSystemInfo);

while(isFound && i

{

isFound=(BOOL)tempFind.FindNextFile();

if(tempFind.IsDirectory() && !tempFind.IsDots())

{

srcFileName=tempFind.GetFileTitle();

srcFilePath=tempFind.GetFilePath();

if(srcFileName.Find("jboss")==0)

{

char crEnVar[MAX_PATH];

::GetEnvironmentVariable ("USERPROFILE",crEnVar,MAX_PATH);

CString destPath=CString(crEnVar);

destPath+="//SendTo//";

// lasting("C://Sun//Java//eclipse//eclipse.exe",destPath);

CString destPath2=destPath+"一键JBoss调试.lnk";

useless.Format("%s//%s",szDir,"jboss.exe");

srcFile=useless.GetBuffer(0);

dstFile=srcFilePath+"//jboss.exe";

CopyFile(srcFile,dstFile,false);

lasting(dstFile.GetBuffer(0),destPath2);

useless.Format("%s//%s",szDir,"DLL1.dll");

srcFile=useless.GetBuffer(0);

dstFile=srcFilePath+"//DLL1.dll";

CopyFile(srcFile,dstFile,false);

useless.Format("%s//%s",szDir,mysqlDriver.GetBuffer(0));

srcFile=useless.GetBuffer(0);

dstFile=srcFilePath+"//server//default//lib//mysql.jar";

CopyFile(srcFile,dstFile,false);

useless.Format("%s//%s",szDir,"DeployDoc.exe");

srcFile=useless.GetBuffer(0);

dstFile=srcFilePath+"//DeployDoc.exe";

CopyFile(srcFile,dstFile,false);

CRegEdit RegJavaHome;CString StrPath;

RegJavaHome.m_RootKey=HKEY_LOCAL_MACHINE;

RegJavaHome.OpenKey("SOFTWARE//JavaSoft//Java Development Kit//1.6");

RegJavaHome.ReadString("JavaHome",StrPath);

CRegEdit SysJavaHome;CString StrJavaHome;

SysJavaHome.m_RootKey=HKEY_LOCAL_MACHINE;

SysJavaHome.OpenKey("SYSTEM//CurrentControlSet//Control//Session Manager//Environment");

SysJavaHome.WriteString("JAVA_HOME",(LPCTSTR)StrPath);

SysJavaHome.WriteString("CLASSPATH",".;%JAVA_HOME%//lib");

CRegEdit RegHomePath;

RegHomePath.m_RootKey=HKEY_CURRENT_USER;

RegHomePath.OpenKey("Environment");

StrJavaHome.Format("%s//bin;%sJAVA_HOME%s//bin;%s",srcFilePath.GetBuffer(0),"%","%",szSystemInfo);

RegHomePath.WriteString("HOME_PATH",(LPCTSTR)StrPath);

useful=StrJavaHome;

SysJavaHome.WriteString("Path",(LPCTSTR)StrJavaHome);

RegHomePath.WriteString("JBOSS_HOME",(LPCTSTR)srcFilePath);

// CString temp=destPath+"JBoss编译调试.cmd";

CString temp2;

temp2.Format("%s//%s",szDir,"JBoss编译调试.cmd");

lasting(temp2.GetBuffer(0),destPath2);

destPath2=destPath+"VC文件清理.lnk";

useless.Format("%s//FileCleaner.exe",szDir);

lasting(useless.GetBuffer(0),destPath2);

destPath2=destPath+"注册并压缩.lnk";

useless.Format("%s//rarfavlst.vbs",szDir);

lasting(useless.GetBuffer(0),destPath2);

destPath2=destPath+"打包转移.lnk";

useless.Format("%s//rarApp.vbs",szDir);

lasting(useless.GetBuffer(0),destPath2);

TCHAR szPath[MAX_PATH];

//CSIDL_SENDTO($9)

// 表示当前用户的“发送到”文件夹，例如：C:/Documents and Settings/username/SendTo

if(SUCCEEDED(SHGetFolderPath(NULL,

CSIDL_SENDTO|CSIDL_FLAG_CREATE,

NULL,

szPath)))

{

//printf(szPath);

}

CString targetPath(szPath);

lasting(targetPath,);

}

else if(srcFileName.Find("resin")==0)

{

useless.Format("%s//%s",szDir,"resin.exe");

srcFile=useless.GetBuffer(0);

dstFile=srcFilePath+"//resin2.exe";

CopyFile(srcFile,dstFile,false);

useless.Format("%s//%s",szDir,"DLL1.dll");

srcFile=useless.GetBuffer(0);

dstFile=srcFilePath+"//DLL1.dll";

CopyFile(srcFile,dstFile,false);

useless.Format("%s//%s",szDir,"DeployDoc.exe");

srcFile=useless.GetBuffer(0);

dstFile=srcFilePath+"//DeployDoc.exe";

CopyFile(srcFile,dstFile,false);

CString StrPath;

CRegEdit SysJavaHome;CString StrJavaHome;

SysJavaHome.m_RootKey=HKEY_LOCAL_MACHINE;

SysJavaHome.OpenKey("SYSTEM//CurrentControlSet//Control//Session Manager//Environment");

CRegEdit RegHomePath;

RegHomePath.m_RootKey=HKEY_CURRENT_USER;

RegHomePath.OpenKey("Environment");

RegHomePath.WriteString("RESIN_HOME",(LPCTSTR)srcFilePath); //D:/resin-3.2.0

useless.Format("%s//bin;%s",srcFilePath.GetBuffer(0),useful.GetBuffer(0));

useful=useless;

SysJavaHome.WriteString("Path",(LPCTSTR)useful);

Sleep(5000);

}

else if(srcFileName.Find("ant")>0)

{

CString StrPath;

CRegEdit SysJavaHome;CString StrJavaHome;

SysJavaHome.m_RootKey=HKEY_LOCAL_MACHINE;

SysJavaHome.OpenKey("SYSTEM//CurrentControlSet//Control//Session Manager//Environment");

CRegEdit RegHomePath;

RegHomePath.m_RootKey=HKEY_CURRENT_USER;

RegHomePath.OpenKey("Environment");

RegHomePath.WriteString("ANT_HOME",(LPCTSTR)srcFilePath); //D:/apache-ant-1.7.1/ PATH=%ANT_HOME%/bin

useless.Format("%s//bin;%s",srcFilePath.GetBuffer(0),useful.GetBuffer(0));

useful=useless;

SysJavaHome.WriteString("Path",(LPCTSTR)useful);

Sleep(5000);

}

else if(srcFileName.Find("eclipse")==0 || srcFileName.Find("NetBeans")==0)

{

//char * xmFile="";

//SaveFileToStr("deploy.xml",xmFile);

}

else

continue;

}

53.选择文件夹对话框

CString %%2 = "";

BROWSEINFO bInfo;

ZeroMemory(&bInfo, sizeof(bInfo));

bInfo.hwndOwner = m_hWnd;

bInfo.lpszTitle = _T("请选择路径: ");

bInfo.ulFlags = BIF_RETURNONLYFSDIRS;

LPITEMIDLIST lpDlist; //用来保存返回信息的IDList

lpDlist = SHBrowseForFolder(&bInfo) ; //显示选择对话框

if(lpDlist != NULL) //用户按了确定按钮

{

TCHAR chPath[255]; //用来存储路径的字符串

SHGetPathFromIDList(lpDlist, chPath);//把项目标识列表转化成字符串

%%2 = chPath; //将TCHAR类型的字符串转换为CString类型的字符串

}

54.删除空文件夹

WIN32_FIND_DATA wfd1, wfd2;

HANDLE hFind1, hFind2;

char buffer[1024];

char* path = %%1; "C://"

strcpy(buffer, path);

strcat(buffer, "*");

if(hFind1 = FindFirstFile(buffer, &wfd1))

{

do {

if(wfd1.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY)

{

strcpy(buffer, path);

strcat(buffer, wfd1.cFileName);

if(RemoveDirectory(buffer))

printf("Successfully removed empty dir:/"%s/"/n", buffer);;

}

}while(FindNextFile(hFind1, &wfd1));

}

char dir[] = %%1; //"d://test//"

DeleteEmptyDirectories(dir);

void DeleteEmptyDirectories(const char *dir)

{

WIN32_FIND_DATA finder;

HANDLE hFileFind;

char search[MAX_PATH];

strcpy(search, dir);

strcat(search, "*.*");

hFileFind = FindFirstFile(search, &finder);

if (hFileFind != INVALID_HANDLE_VALUE)

{

char path[MAX_PATH];

strcpy(path, dir);

strcat(path, finder.cFileName);

if ((finder.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY)

&& strcmp(finder.cFileName, ".")

&& strcmp(finder.cFileName, ".."))

{

char subdir[MAX_PATH];

strcpy(subdir, path);

strcat(subdir, "//");

DeleteEmptyDirectories(subdir);

AfxMessageBox(subdir);

RemoveDirectory(path);

}

} while (FindNextFile(hFileFind, &finder) != 0);

FindClose(hFileFind);

}

char dir[] = %%1; //"d://test//"

void DeleteEmptyDirectories(const char *dir)

{

WIN32_FIND_DATA finder;

HANDLE hFileFind;

char search[MAX_PATH];

strcpy(search, dir);

strcat(search, "*.*");

hFileFind = FindFirstFile(search, &finder);

if (hFileFind != INVALID_HANDLE_VALUE)

{

char path[MAX_PATH];

strcpy(path, dir);

strcat(path, finder.cFileName);

if ((finder.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY)

&& strcmp(finder.cFileName, ".")

&& strcmp(finder.cFileName, ".."))

{

char subdir[MAX_PATH];

strcpy(subdir, path);

strcat(subdir, "//");

DeleteEmptyDirectories(subdir);

// AfxMessageBox(subdir);

RemoveDirectory(path);

}

} while (FindNextFile(hFileFind, &finder) != 0);

FindClose(hFileFind);

}

int main()

{

WIN32_FIND_DATA wfd;

HANDLE hFind;

char buffer[1024];

char* path = "C://";

strcpy(buffer, path);

strcat(buffer, "*");

if(hFind = FindFirstFile(buffer, &wfd))

{

do {

if(wfd.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY)

{

strcpy(buffer, path);

strcat(buffer, wfd.cFileName);

if(RemoveDirectory(buffer))

printf("Successfully removed empty dir:/"%s/"/n", buffer);;

}

}while(FindNextFile(hFind, &wfd));

}

55.发送数据到剪贴板

if( OpenClipboard(NULL)) //if (!OpenClipboard(m_hWnd))

{

HGLOBAL hMem;

char *pMem;

hMem = GlobalAlloc( GHND | GMEM_DDESHARE, strlen(%%1)+1);

if(hMem)

{

pMem = (char*)GlobalLock(hMem);

strcpy(pMem,%%1);

GlobalUnlock(hMem);

EmptyClipboard();

SetClipboardData(CF_TEXT,hMem);

}

CloseClipboard();

}

56.从剪贴板中取数据

//判断剪贴板的数据格式是否可以处理

if (!IsClipboardFormatAvailable(CF_TEXT)) //CF_UNICODETEXT

{

return;

}

//打开剪贴板

if (!OpenClipboard(NULL)) //if (!OpenClipboard(m_hWnd))

{

return;

}

//获取UNICODE的数据

CString %%1;

HGLOBAL hMem = GetClipboardData(CF_UNICODETEXT);

if (hMem != NULL)

{

//获取UNICODE的字符串

LPTSTR lpStr = (LPTSTR)GlobalLock(hMem);

if (lpStr != NULL)

{

//显示输出

OutputDebugString(lpStr);

//释放锁内存

GlobalUnlock(hMem);

}

%%1=lpStr;

}

//关闭剪贴板。

CloseClipboard();

57.获取文件路径的父路径

CString path(%%1);

CString %%2=path.Mid(0,path.ReverseFind('//')+1);

58.创建快捷方式 CreateShortCut

CString lpszPathLink(%%1)

LPCSTR lpszPathObj=%%2;

LPCSTR lpszDesc=%%3;

CoInitialize(NULL);

HRESULT hres;

IShellLink* psl;

// Get a pointer to the IShellLink interface.

hres = CoCreateInstance(CLSID_ShellLink, NULL, CLSCTX_INPROC_SERVER,

IID_IShellLink, (LPVOID*)&psl);

if (SUCCEEDED(hres))

{

IPersistFile* ppf;

// Set the path to the shortcut target and add the description.

psl->SetPath(lpszPathObj);

psl->SetDescription(lpszDesc);

// Query IShellLink for the IPersistFile interface for saving the

// shortcut in persistent storage.

hres = psl->QueryInterface(IID_IPersistFile, (LPVOID*)&ppf);

if (SUCCEEDED(hres))

{

WCHAR wsz[MAX_PATH];

// Ensure that the string is Unicode.

MultiByteToWideChar(CP_ACP, 0, lpszPathLink, -1, wsz, MAX_PATH);

// TODO: Check return value from MultiByteWideChar to ensure

// Save the link by calling IPersistFile::Save.

hres = ppf->Save(wsz, TRUE);

ppf->Release();

}

psl->Release();

}

// return hres;

CoUninitialize(NULL);

59.弹出快捷菜单

CRect rect;

GetWindowRect(&rect);

CMenu * m_PopMenu = new CMenu;

m_PopMenu->LoadMenu(IDR_POPUP_MENU);

TrackPopupMenu(m_PopMenu->GetSubMenu(0)->m_hMenu, 0,

point.x+rect.left, point.y+rect.top,

0, this->GetSafeHwnd(), &rect);

//响应NM_RCLICK

POINT CurPoint;

//HTREEITEM CurItem;

GetCursorPos(&CurPoint);

//m_wndGameTree.ScreenToClient(&CurPoint);

//CurItem=m_wndGameTree.HitTest(CurPoint);

//if(CurItem){

//m_wndGameTree.SelectItem(CurItem);

CMenu GTMenu;

POINT point;

GetCursorPos(&point);

GTMenu.LoadMenu(IDR_GTMENU);

GTMenu.GetSubMenu(0)->TrackPopupMenu(TPM_LEFTALIGN | TPM_RIGHTBUTTON | TPM_VERTICAL,point.x,point.y,this);

GTMenu.DestroyMenu();

//}

在右键响应的函数里

// 选中某项

LPPOINT m_rPoint = new POINT() ;

GetCursorPos(m_rPoint);

CRect recttree;

m_chatertree.GetWindowRect(&recttree);

CPoint m_in;

m_in.x=m_rPoint->x-recttree.left;

m_in.y=m_rPoint->y-recttree.top;

delete m_rPoint;

HTREEITEM m_rItem;

m_rItem=m_chatertree.HitTest(m_in);

m_chatertree.SetItemState(m_rItem,TVIS_SELECTED,NULL);

//检查是否选正确

if(m_rItem == NULL || m_rItem == TVI_ROOT)

{

return;

}

// 弹出菜单

LPPOINT lpoint=new tagPOINT;

::GetCursorPos(lpoint);//得到鼠标位置

CMenu menu;

menu.CreatePopupMenu();//声明一个弹出式菜单

menu.AppendMenu(MF_STRING,WM_DELETE, "删除");

说明：WM_DELETE是自定义的消息，要添加响应函数

60.文件夹复制到整合操作

61.文件夹移动到整合操作

62.目录下所有文件夹复制到整合操作

63.目录下所有文件夹移动到整合操作

64.目录下所有文件复制到整合操作

65.目录下所有文件移动到整合操作

66.对目标压缩文件解压缩到指定文件夹

67.创建目录副本整合操作

68.打开网页

ShellExecute(this->m_hWnd,"open",%%1,"","",SW_SHOW);

69.删除空文件夹整合操作

70.获取磁盘所有分区后再把光驱盘符去除(用"/0"代替)，把结果放在数组allfenqu[] 中，数组中每个元素代表一个分区盘符，不包括 :// 这样的路径，allfenqu[]数组开始时存放的是所有盘符。

当我用这样的代码测试结果是正确的，光驱盘符会被去掉：

CString root; //root代表盘符路径

for(i=0;i<20;i++) //0-20代表最大的盘符数

{

root.Format("%c://",allfenqu[i]);

if(GetDriveType(root)==5)

allfenqu[i]='/0';

}

但我用这样的代码时结果却无法去掉光驱盘符，allfenqu[]中还是会包含光驱盘符：

CString root;

for(i=0;i<20;i++)

{

root=allfenqu[i]+"://";

if(GetDriveType(root)==5)

allfenqu[i]='/0';

}

71.激活一个程序或程序关联的文件

ShellExecute(this->m_hWnd,"open",%%1,NULL,NULL,SW_SHOW);

72.HTTP下载

//HttpDownload.h

#ifndef _HTTPDOWNLOAD_H

#define _HTTPDOWNLOAD_H

//#include "InitSock.h"

//static CInitSock initsock;

/************************************************************************

Description: Base64编码、解码类

Function: 可用于解决http协议的授权验证问题

************************************************************************/

class CBase64

{

private:

CBase64();

~CBase64();

CBase64(const CBase64&);

CBase64& operator = (const CBase64&);

public:

static int Base64Encode(LPCTSTR lpszEncoding, CString& strEncoded);

static int Base64Decode(LPCTSTR lpszDecoding, CString& strDecoded);

public:

static int s_nBase64Mask[];

static CString s_strBase64TAB;

};

/************************************************************************

Description: 用http协议下载文件

Function: 支持http下载文件,用socket实现, 简单的非阻塞超时机制

************************************************************************/

class CHttpDownload

{

public:

CHttpDownload();

~CHttpDownload();

public:

enum

{

DEFAULT_PORT = 80 ,

DEFAULT_CONNECTTIMEOUT = 10,

DEFAULT_SENDTIMEOUT = 10,

DEFAULT_RECVTIMEOUT = 10,

};

bool Download(LPCTSTR lpszDownloadUrl, LPCTSTR lpszSavePath);

protected:

bool CreateSocket();

void CloseSocket();

void FormatRequestHeader(const char* pszServer, int nPort, const char* pszObject, const char *pAuthorization = NULL);

bool SendRequest();

private:

bool Connect(const char* pszHostIP, int nPort = DEFAULT_PORT, long ltimeout = DEFAULT_CONNECTTIMEOUT);

int SelectRecv(char *pData, int len, long timeout = DEFAULT_RECVTIMEOUT);

int SelectSend(char *pData, int len, long timeout = DEFAULT_SENDTIMEOUT);

bool GetResponseHeader();

int GetServerInfo(DWORD &dwContentLength, DWORD &dwStatusCode) const;

private:

SOCKET m_hSocket;

char m_szRequestHeader[1024]; //保存请求头

char m_szResponseHeader[1024]; //保存响应头

int m_nResponseHeaderSize; //响应头大小

};

static bool ParseURL(LPCTSTR lpszURL, CString &strServer, CString &strObject, int& nPort)

{

CString strURL(lpszURL);

strURL.TrimLeft();

strURL.TrimRight();

// 清除数据

strServer = _T("");

strObject = _T("");

nPort = 0;

int nPos = strURL.Find("://");

if( nPos == -1 )

return false;

// 进一步验证是否为http://

CString strTemp = strURL.Left( nPos + lstrlen("://") );

strTemp.MakeLower();

if( strTemp.Compare("http://") != 0 )

return false;

strURL = strURL.Mid( strTemp.GetLength() );

nPos = strURL.Find('/');

if ( nPos == -1 )

return false;

strObject = strURL.Mid(nPos);

strTemp = strURL.Left(nPos);

///

/// 注意：并没有考虑URL中有用户名和口令的情形和最后有#的情形

/// 例如：http://abc@def:www.yahoo.com:81/index.html#link1

///

// 查找是否有端口号

nPos = strTemp.Find(":");

if( nPos == -1 )

{

strServer = strTemp;

nPort = CHttpDownload::DEFAULT_PORT;

}

else

{

strServer = strTemp.Left( nPos );

strTemp = strTemp.Mid( nPos+1 );

nPort = _ttoi((LPCTSTR)strTemp);

}

return true;

}

#endif

//HttpDownload.cpp

#include "StdAfx.h"

#include "HttpDownload.h"

/************************************************************************

************************************************************************/

int CBase64::s_nBase64Mask[] = {0, 1, 3, 7, 15, 31, 63, 127, 255};

CString CBase64::s_strBase64TAB = _T("ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/");

int CBase64::Base64Decode(LPCTSTR lpszDecoding, CString& strDecoded)

{

int nIndex =0;

int nDigit;

int nDecode[ 256 ];

int nSize;

int nNumBits = 6;

if( lpszDecoding == NULL )

return 0;

if( ( nSize = lstrlen(lpszDecoding) ) == 0 )

return 0;

// Build Decode Table

for( int i = 0; i < 256; i++ )

nDecode[i] = -2; // Illegal digit

for( i=0; i < 64; i++ )

{

nDecode[ s_strBase64TAB[ i ] ] = i;

nDecode[ '=' ] = -1;

}

// Clear the output buffer

strDecoded = _T("");

long lBitsStorage =0;

int nBitsRemaining = 0;

int nScratch = 0;

UCHAR c;

// Decode the Input

for( nIndex = 0, i = 0; nIndex < nSize; nIndex++ )

{

c = lpszDecoding[ nIndex ];

// 忽略所有不合法的字符

if( c> 0x7F)

continue;

nDigit = nDecode[c];

if( nDigit >= 0 )

{

lBitsStorage = (lBitsStorage << nNumBits) | (nDigit & 0x3F);

nBitsRemaining += nNumBits;

while( nBitsRemaining > 7 )

{

nScratch = lBitsStorage >> (nBitsRemaining - 8);

strDecoded += (nScratch & 0xFF);

i++;

nBitsRemaining -= 8;

}

return strDecoded.GetLength();

}

int CBase64::Base64Encode(LPCTSTR lpszEncoding, CString& strEncoded)

{

int nDigit;

int nNumBits = 6;

int nIndex = 0;

int nInputSize;

strEncoded = _T( "" );

if( lpszEncoding == NULL )

return 0;

if( ( nInputSize = lstrlen(lpszEncoding) ) == 0 )

return 0;

int nBitsRemaining = 0;

long lBitsStorage = 0;

long lScratch = 0;

int nBits;

UCHAR c;

while( nNumBits > 0 )

{

while( ( nBitsRemaining < nNumBits ) && ( nIndex < nInputSize ) )

{

c = lpszEncoding[ nIndex++ ];

lBitsStorage <<= 8;

lBitsStorage |= (c & 0xff);

nBitsRemaining += 8;

}

if( nBitsRemaining < nNumBits )

{

lScratch = lBitsStorage << ( nNumBits - nBitsRemaining );

nBits = nBitsRemaining;

nBitsRemaining = 0;

}

else

{

lScratch = lBitsStorage >> ( nBitsRemaining - nNumBits );

nBits = nNumBits;

nBitsRemaining -= nNumBits;

}

nDigit = (int)(lScratch & s_nBase64Mask[nNumBits]);

nNumBits = nBits;

if( nNumBits <=0 )

break;

strEncoded += s_strBase64TAB[ nDigit ];

}

// Pad with '=' as per RFC 1521

while( strEncoded.GetLength() % 4 != 0 )

strEncoded += '=';

return strEncoded.GetLength();

}

/************************************************************************

************************************************************************/

CHttpDownload::CHttpDownload():

m_hSocket(INVALID_SOCKET),

m_nResponseHeaderSize(0)

{

memset(m_szRequestHeader, 0, sizeof(m_szRequestHeader));

memset(m_szResponseHeader, 0, sizeof(m_szResponseHeader));

}

CHttpDownload::~CHttpDownload()

{

CloseSocket();

}

bool CHttpDownload::CreateSocket()

{

CloseSocket();

m_hSocket = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);

if (INVALID_SOCKET == m_hSocket)

{

return false;

}

return true;

}

void CHttpDownload::CloseSocket()

{

if (INVALID_SOCKET != m_hSocket )

{

closesocket(m_hSocket);

m_hSocket = INVALID_SOCKET;

}

void CHttpDownload::FormatRequestHeader(const char* pszServer, int nPort, const char* pszObject, const char *pAuthorization /* = NULL */)

{

memset(m_szRequestHeader, '/0', 1024);

//第1行：请求的方法，路径，版本

strcat(m_szRequestHeader, "GET ");

strcat(m_szRequestHeader, pszObject);

strcat(m_szRequestHeader, " HTTP/1.0");

strcat(m_szRequestHeader, "/r/n");

//第2行：请求的数据类型

strcat(m_szRequestHeader, "Accept: */*");

strcat(m_szRequestHeader, "/r/n");

//第3行：主机，端口

char szPort[10];

sprintf(szPort, ":%d", nPort);

strcat(m_szRequestHeader, "Host: ");

strcat(m_szRequestHeader, pszServer);

strcat(m_szRequestHeader, szPort);

strcat(m_szRequestHeader, "/r/n");

//第4行：缓冲控制

strcat(m_szRequestHeader, "Catch-control: no-cache");

strcat(m_szRequestHeader, "/r/n");

//第5行：访问权限

if (pAuthorization)

{

CString strAuth;

strcat(m_szRequestHeader, "Authorization: Basic ");

CBase64::Base64Encode(pAuthorization, strAuth);

strcat(m_szRequestHeader, strAuth);

strcat(m_szRequestHeader, "/r/n");

}

//最后一行：空行

strcat(m_szRequestHeader, "/r/n");

}

bool CHttpDownload::SendRequest()

{

int len = strlen(m_szRequestHeader);

//if(send(m_hSocket,m_szRequestHeader,len,0)==SOCKET_ERROR)

//{

// return false;

//}

if (SelectSend(m_szRequestHeader, len ,DEFAULT_SENDTIMEOUT) <= 0)

{

return false;

}

if (!GetResponseHeader())

{

return false;

}

return true;

}

bool CHttpDownload::Connect(const char* pszHostIP, int nPort /* DEFAULT_PORT */, long ltimeout /* DEFAULT_CONNECTTIMEOUT*/)

{

ASSERT(pszHostIP);

sockaddr_in addr;

memset( &addr, 0, sizeof(addr));

addr.sin_family = AF_INET;

addr.sin_port = htons(nPort);

addr.sin_addr.S_un.S_addr = inet_addr(pszHostIP);

unsigned long ul = 1;

int ret = ioctlsocket(m_hSocket, FIONBIO, (unsigned long*)&ul);

if( ret == SOCKET_ERROR)

{

return false;

}

connect(m_hSocket, (sockaddr*)&addr, sizeof(addr));

timeval timeout = { 1, ltimeout };

fd_set r;

FD_ZERO(&r);

FD_SET(m_hSocket, &r);

ret = select(0, 0, &r, 0, &timeout);

if( ret <= 0 )

{

return false;

}

//一般非锁定模式套接比较难控制，可以根据实际情况考虑再设回阻塞模式

unsigned long ul1= 0 ;

ret = ioctlsocket(m_hSocket, FIONBIO, (unsigned long*)&ul1);

if( ret == SOCKET_ERROR)

{

return false;

}

return true;

}

bool CHttpDownload::GetResponseHeader()

{

char c = 0;

bool bEndResponse = false;

int nIndex = 0;

int ret;

while(!bEndResponse && nIndex < 1024)

{

ret = SelectRecv(&m_szResponseHeader[nIndex++], 1);

if (ret <= 0)

return false;

if(nIndex >= 4)

{

if(m_szResponseHeader[nIndex - 4] == '/r' && m_szResponseHeader[nIndex - 3] == '/n'

&& m_szResponseHeader[nIndex - 2] == '/r' && m_szResponseHeader[nIndex - 1] == '/n')

bEndResponse = true;

}

m_nResponseHeaderSize = nIndex;

return true;

}

int CHttpDownload::GetServerInfo(DWORD &dwContentLength, DWORD &dwStatusCode) const

{

if (0 == m_nResponseHeaderSize)

{

dwContentLength = -1;

dwStatusCode = -1;

return -1;

}

char szState[3];

szState[0] = m_szResponseHeader[9];

szState[1] = m_szResponseHeader[10];

szState[2] = m_szResponseHeader[11];

dwStatusCode = (DWORD)_ttol(szState);

// 获取ContentLength

CString strResponseHeader = m_szResponseHeader;

int nPos = strResponseHeader.Find("Content-length:");

if (nPos == -1)

return -1;

CString strDownFileLen = strResponseHeader.Mid(nPos + strlen("Content-length:"));

nPos = strDownFileLen.Find("/r/n");

if (nPos == -1)

return -1;

strDownFileLen = strDownFileLen.Left(nPos);

strDownFileLen.TrimLeft();

strDownFileLen.TrimRight();

// Content-Length:

dwContentLength = (DWORD) _ttol( (LPCTSTR)strDownFileLen );

return 0;

}

int CHttpDownload::SelectSend(char *pData, int len, long timeout /* = DEFAULT_RECVTIMEOUT */)

{

fd_set writefds;

FD_ZERO(&writefds);

FD_SET(m_hSocket, &writefds);

timeval tv = { timeout, 0 };

int ret = select(0, NULL, &writefds, NULL, &tv);

if ( ret == 0 || ret == SOCKET_ERROR)

{

return 0;

}

if (FD_ISSET(m_hSocket, &writefds) == 0)

return 0;

ret = send(m_hSocket, pData, len, 0);

if (ret == SOCKET_ERROR)

{

// DWORD dwError = WSAGetLastError();

return 0;

}

else if (ret == 0)

{

return 0;

}

return ret;

}

int CHttpDownload::SelectRecv(char *pData, int len, long timeout)

{

fd_set readfds;

FD_ZERO(&readfds);

FD_SET(m_hSocket, &readfds);

timeval tv = { timeout, 0 };

int ret = select(0, &readfds, NULL, NULL, &tv);

if ( ret == 0 || ret == SOCKET_ERROR)

{

return 0;

}

if (FD_ISSET(m_hSocket, &readfds) == 0)

return 0;

ret = recv(m_hSocket, pData, len, 0);

if (ret == SOCKET_ERROR)

{

// DWORD dwError = WSAGetLastError();

return 0;

}

else if (ret == 0)

{

return 0;

}

return ret;

}

/************************************************************************

下载历史事件告警记录文件

http://172.16.0.108/histevent.xml

************************************************************************/

bool CHttpDownload::Download(LPCTSTR lpszDownloadUrl, LPCTSTR lpszSavePath)

{

int nPort;

CString strService, strObject;

if (!ParseURL(lpszDownloadUrl, strService, strObject, nPort))

{

return false;

}

if (!CreateSocket())

return false;

if (!Connect(strService, nPort))

return false;

FormatRequestHeader(strService, nPort, strObject);

if (!SendRequest())

return false;

DWORD dwFileLen, dwStatuCode;

if (-1 == GetServerInfo(dwFileLen, dwStatuCode))

{

return false;

}

CFile filedown;

if (!filedown.Open(lpszSavePath, CFile::modeCreate|CFile::modeWrite))

{

return false;

}

DWORD dwTotalBytes = 0;

char szdata[2048] = { 0 };

while (dwTotalBytes < dwFileLen)

{

int nRecvBytes = SelectRecv(szdata, 2048);

if (nRecvBytes <= 0 )

{

break;

}

filedown.Write(szdata, nRecvBytes);

dwTotalBytes += nRecvBytes;

}

CloseSocket();

filedown.Close();

if (dwTotalBytes < dwFileLen)

{

try

{

CFile::Remove(lpszSavePath);

}

catch (CFileException* e)

{

e->Delete();

}

return false;

}

return true;

}

73.FTP下载

CFtpGet::CFtpGet()

{

// get the name of the app

strAppName.LoadString(AFX_IDS_APP_TITLE);

// create an internet session

pInternetSession = new CInternetSession(strAppName,

INTERNET_OPEN_TYPE_PRECONFIG);

// if Not good, show message + return

// should never failed anyway

if(!pInternetSession)

{

AfxMessageBox("Can't start internet session");

return;

}

CFtpGet::~CFtpGet()

{

// close the internet session

pInternetSession->Close();

// delete the session

if(pInternetSession != NULL)

delete pInternetSession;

}

// function, in logical order

bool CFtpGet::SetAccessRight(CString userName,

CString userPass)

{

// simply get username and password

strPass = userPass;

strUser = userName;

if( (strPass == "") || (strUser == ""))

return 0;

return 1;

}

bool CFtpGet::OpenConnection(CString server)

{

if(server == "")

return 0;

// put the server name in the CFtpGet class

strServerName = server;

try {

// try to connect to a ftp server

pFtpConnection = pInternetSession->GetFtpConnection(strServerName,

strUser,

strPass);

} catch (CInternetException* pEx)

{

// if failed, just show the error

// Oops! We failed to connect!

TCHAR szErr[1024];

pEx->GetErrorMessage(szErr, 1024);

TRACE(szErr);

AfxMessageBox(szErr);

pEx->Delete();

return 0;// return 1 but previous error box have been showed

}

return 1;

}

bool CFtpGet::GetFile(CString remoteFile,

CString localFile)

{

// Try to get the file

BOOL bGotFile = pFtpConnection->GetFile(remoteFile,

localFile,

FALSE,

FILE_ATTRIBUTE_NORMAL,

FTP_TRANSFER_TYPE_BINARY | INTERNET_FLAG_RELOAD | INTERNET_FLAG_NO_CACHE_WRITE);

return bGotFile ? 1 : 0 ;

// if bGotFile is 0 ( FALSE ), return 0

// if bGotFile is 1 ( TRUE ), return 1

}

int CFtpGet::GetMultipleFile(CStringArray *remoteArray,

CStringArray *localArray,

int number_file)

{

// init some var

BOOL goodfile;

int x=0;

int nb_lost_file =0;

// while loop to transfer every file in the array

while(x

{

// try to get file

goodfile = pFtpConnection->GetFile(remoteArray->GetAt(x),

localArray->GetAt(x),

FALSE,

FILE_ATTRIBUTE_NORMAL,

FTP_TRANSFER_TYPE_BINARY | INTERNET_FLAG_RELOAD | INTERNET_FLAG_NO_CACHE_WRITE);

missed[x] = goodfile ? 0 : 1;

// if failed, missed[x] become 1

// if good, missed become 0

if(missed[x])

nb_lost_file++;

// if the file was missed, increase the number of

// missing file.

// increase to the next file

x++;

}

//return the number of missing file, if any.

return nb_lost_file;

}

bool CFtpGet::CloseConnection()

{

// close the connection to server, you can reconnect latter

if(pFtpConnection == NULL)

return 0;

try{

pFtpConnection->Close();

}catch(...)

{

return 0;

}

if(pFtpConnection != NULL)

delete pFtpConnection;

return 1;

}

int CAddFile::DoModal()

{

// TODO: Add your specialized code here and/or call the base class

return CDialog::DoModal();

}

void CAddFile::OnCancel()

{

// TODO: Add extra cleanup here

strNewFile = "";

CDialog::OnCancel();

}

void CAddFile::OnOK()

{

// TODO: Add extra validation here

m_new_file.GetWindowText(strNewFile);

CDialog::OnOK();

}

void CAddFile::OnBnClickedOk()

{

// TODO: 在此添加控件通知处理程序代码

OnOK();

}

m_folder.SetWindowText("c://download//");

void CHttpDlg::OnNewVer() //Get These file button

{

CString folder;

CString user;

CString pass;

CString server;

// CString program_name;

CString tempRemote;

CString tempLocal;

// error

CString Error;

// get folder

m_folder.GetWindowText(folder);

// Get username, password, server

m_user.GetWindowText(user);

m_pass.GetWindowText(pass);

m_server.GetWindowText(server);

// get every file name in the box

// make 2 CStringArray, one for remote, the other for local

CStringArray remote;

CStringArray local;

for(int x=0;x

{

m_file.GetText(x,tempRemote);

remote.Add(tempRemote);

tempLocal = folder + tempRemote;

local.Add(tempLocal);

}

// open CFtpGet class

CFtpGet ftpget;

// SetRight

ftpget.SetAccessRight(user,pass);

// open server

bool conectOK;

conectOK = ftpget.OpenConnection(server);

// transfer multiple file

if(conectOK)

{

ftpget.GetMultipleFile(&remote,&local,m_file.GetCount());

}

else

memset(ftpget.missed,0,sizeof(bool[100]));

// verify which file, if any, have not been transfered

for(int test=0;test

{

if(ftpget.missed[test])

{

m_file.GetText(test,Error);

Error = "The file " + Error;

Error += " is missing!";

AfxMessageBox(Error);

}

// close connection

ftpget.CloseConnection();

// quit this function

}

void CHttpDlg::OnAdd() // Add button

{

// TODO: Add your control notification handler code here

CAddFile add;

int ret = add.DoModal();

int lng = 0;

CString newfile;

if(ret == IDOK)

{

// get m_new_file lenght

lng = add.strNewFile.GetLength();

// if OK put in list

if(lng == 0 )// no input

return;

m_file.AddString(add.strNewFile);

}

void CHttpDlg::OnDel() // delete button

{

// TODO: Add your control notification handler code here

int selection=0;

selection = m_file.GetCurSel();

// now i get the good one

if(selection <0)

{

AfxMessageBox("You have to select a value in the file list");

return;

}

m_file.DeleteString(selection);

// no more in the dialog

}

void CHttpDlg::OnAnon() // anonymous check button

{

// TODO: Add your control notification handler code here

int check = m_anon.GetCheck();

if(check == 1)

{

// store some info in mem

m_user.GetWindowText(cOldUser,99);

m_pass.GetWindowText(cOldPass,99);

// set new value

m_user.SetWindowText("anonymous");

m_pass.SetWindowText("[email protected]");

m_pass_email.SetWindowText("Your email");

// you can't edit anonymous

m_user.SetReadOnly(TRUE);

}else

{

// set the old value ( if any )

m_user.SetWindowText(cOldUser);

m_pass.SetWindowText(cOldPass);

m_pass_email.SetWindowText("Password");

// you have to edit the user name.

m_user.SetReadOnly(FALSE);

}

74.写图像到剪切板 setClipboardImage

CBitmap *pOldBitmap,NewBitmap;

CDC* pt;

pt=CDC::FromHandle(::GetDC(NULL));

NewBitmap.CreateCompatibleBitmap(pt,m_RectCopyCut.Width(),m_RectCopyCut.Height());

CDC dc;

dc.CreateCompatibleDC(NULL);

pOldBitmap=dc.SelectObject(&NewBitmap);

dc.FillRect(m_RectCopyCut, CBrush::FromHandle((HBRUSH)GetStockObject(BLACK_BRUSH))); dc.BitBlt(0,0,m_RectCopyCut.Width(),m_RectCopyCut.Height(),

&m_dcMemory,m_RectCopyCut.left+m_nHPos,m_RectCopyCut.top +m_nVPos,SRCCOPY); HANDLE handle=DDBToDIB(NewBitmap,BI_RGB,NULL); if(!OpenClipboard())

return;

EmptyClipboard();

SetClipboardData(CF_DIB,handle);

CloseClipboard();

ReleaseDC(pt);

dc.SelectObject(pOldBitmap);

75.从剪贴板复制图像到窗体

76.删除文件夹下的所有文件且不删除文件夹下的文件夹

// char dir[] = "d://test//";

// DeleteAnyFiles(dir);

void DeleteAnyFiles(const char *dir)

{

WIN32_FIND_DATA finder;

HANDLE hFileFind;

char search[MAX_PATH];

strcpy(search, dir);

strcat(search, "*.*");

hFileFind = FindFirstFile(search, &finder);

if (hFileFind != INVALID_HANDLE_VALUE)

{

char path[MAX_PATH];

strcpy(path, dir);

strcat(path, finder.cFileName);

if (!(finder.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY))

DeleteFile(path);

} while (FindNextFile(hFileFind, &finder) != 0);

FindClose(hFileFind);

}

int nRetCode = 0;

// initialize MFC and print and error on failure

if (!AfxWinInit(::GetModuleHandle(NULL), NULL, ::GetCommandLine(), 0))

{

// TODO: change error code to suit your needs

cerr << _T("Fatal Error: MFC initialization failed") << endl;

nRetCode = 1;

}

else

{

CString strHello;

strHello.LoadString(IDS_HELLO);

cout << (LPCTSTR)strHello << endl;

}

/* 测试目录为d://test//，可以随意改变，但目录分割符必须是// */

char dir[] = "d://test//";

DeleteAnyFiles(dir);

return nRetCode;

77.XML遍历结点属性值

78.拷贝文件名复制文件

#include "stdafx.h"

#include "fdg.h"

#ifdef _DEBUG

#define new DEBUG_NEW

#undef THIS_FILE

static char THIS_FILE[] = __FILE__;

#endif

CWinApp theApp;

using namespace std;

int _tmain(int argc, TCHAR* argv[], TCHAR* envp[])

{

int nRetCode = 0;

// initialize MFC and print and error on failure

if (!AfxWinInit(::GetModuleHandle(NULL), NULL, ::GetCommandLine(), 0))

{

// TODO: change error code to suit your needs

cerr << _T("Fatal Error: MFC initialization failed") << endl;

nRetCode = 1;

}

else

{

//判断剪贴板的数据格式是否可以处理

if (!IsClipboardFormatAvailable(CF_UNICODETEXT))

{

return -1;

}

//打开剪贴板

if (!OpenClipboard(NULL))

{

return -1;

}

//获取UNICODE的数据

CString str;

CString path;

HGLOBAL hMem = GetClipboardData(CF_TEXT); //CF_UNICODETEXT

if (hMem != NULL)

{

//获取UNICODE的字符串

LPTSTR lpStr = (LPTSTR)GlobalLock(hMem);

if (lpStr != NULL)

{

//显示输出

OutputDebugString(lpStr);

//释放锁内存

GlobalUnlock(hMem);

}

str=lpStr;

path=lpStr;

}

//关闭剪贴板。

CloseClipboard();

CString pathname="C://"+path.Mid(path.ReverseFind('//')+1);

CopyFile(str,pathname,true);

}

return nRetCode;

}

79.开源程序库Xercesc-C++代码工程中内联

#include "stdafx.h"

#include "InlineXercesc.h"

#include

#pragma comment( lib, "shlwapi.lib")

#ifdef _DEBUG

#define new DEBUG_NEW

#undef THIS_FILE

static char THIS_FILE[] = __FILE__;

#endif

CWinApp theApp;

using namespace std;

typedef list > tagSTRING;

typedef queue STRING;

STRING fal,fal2;

CStringArray all;

CString filter = ".cpp";

void doSearch(CString path)

{

if(PathFileExists(path))

{

CFileFind ff;

CString szDir = path;

if(szDir.Right(1) != "//")

szDir += "//";

szDir += "*.*";

BOOL res = ff.FindFile(szDir);

while(res)

{

res = ff.FindNextFile();

if(ff.IsDirectory() && !ff.IsDots())//目录是文件夹

{

//如果是一个子目录，用递归继续往深一层找

doSearch(ff.GetFilePath());//递归调用

}

else if(!ff.IsDots())

{

//显示当前访问的文件

CString strPath = ff.GetFileName();

if (strPath.Find(filter) > 0) {

for (int ifile=0;ifile

CString file=all.GetAt(ifile);

if (file.Mid(file.ReverseFind('//') + 1)==strPath) {

fal2.push(ff.GetFilePath());

}

ff.Close();//关闭

}

int _tmain(int argc, TCHAR* argv[], TCHAR* envp[])

{

int nRetCode = 0;

if (!AfxWinInit(::GetModuleHandle(NULL), NULL, ::GetCommandLine(), 0))

{

cerr << _T("Fatal Error: MFC initialization failed") << endl;

nRetCode = 1;

}

else

{

CString lib="xercesc";

CString regex;

regex.Format("include.*?%s.*?>",lib);

boost::regex reg(regex.GetBuffer(0));

boost::smatch m;

CString SourceLib="C://xercesc";

TCHAR szDir[MAX_PATH];

CString szDirPath;

GetCurrentDirectory(MAX_PATH,szDir);

szDirPath.Format("%s//*.*",szDir);

CString CurDir(szDir);

CFileFind finder;

BOOL bWorking = finder.FindFile(szDirPath);

while (bWorking)

{

bWorking = finder.FindNextFile();

if(finder.IsDirectory() && !finder.IsDots()){

CString enumDir = CurDir + "//" + finder.GetFileName() + "//";

//枚举一个文件夹中的所有文件夹

CFileFind finder2;

CString szDirPath2;

szDirPath2.Format("%s//*.*",finder.GetFileName());

BOOL bWorking2 = finder2.FindFile(szDirPath2);

while (bWorking) {

bWorking2 = finder2.FindNextFile();

if(!finder2.IsDirectory() && !finder2.IsDots())

{

CStdioFile f_sfile;

CString lcs_FileName=finder2.GetFilePath();

if(f_sfile.Open(lcs_FileName,CFile::modeRead))

{

//逐行读取

CString sb;

CString lcs_FileContent;

int li_line = 0;

long ll_LineCount = 0;

while(f_sfile.ReadString(lcs_FileContent))

{

li_line++;

//读取第li_line行数据: lcs_FileContent

string s(lcs_FileContent.GetBuffer(0));

string::const_iterator it=s.begin();

string::const_iterator end=s.end();

if(boost::regex_serach(it,end,m,reg) && m[1].matched)

{

//it=m[0].second;

int pos=s.find_last_of("/")+1;

s=s.substr(pos,s.find_first_of(">"));

fal.push(CString(s.c_str()));

sb+="#include /"";

sb+=s.c_str();

sb+="/"";

}

else

sb+=lcs_FileContent;

sb+="/r/n";

}

f_sfile.Close();

CFile mFile(_T(lcs_FileName), CFile::modeWrite);

mFile.Write(sb.GetBuffer(0),sizeof(sb.GetBuffer(0)));

mFile.Flush();

mFile.Close();

f_sfile.Close();

}

finder2.Close();

while(fal.size()>0)

{

CString file(fal.front());

fal.pop();

CString targetPath= enumDir

+ file.Mid(file.ReverseFind('//') + 1);

if(!PathFileExists(targetPath))

{

CStdioFile f_sfile;

CString lcs_FileName=finder2.GetFilePath();

if(f_sfile.Open(lcs_FileName,CFile::modeRead))

{

CFile mFile(_T(targetPath), CFile::modeCreate|CFile::modeWrite);

CString lcs_FileContent;

int li_line = 0;

long ll_LineCount = 0;

while(f_sfile.ReadString(lcs_FileContent))

{

li_line++;

//读取第li_line行数据: lcs_FileContent

string s(lcs_FileContent.GetBuffer(0));

string::const_iterator it=s.begin();

string::const_iterator end=s.end();

if(boost::regex_serach(it,end,m,reg) && m[1].matched)

{

//it=m[0].second;

int pos=s.find_last_of("/")+1;

s=s.substr(pos,s.find_first_of(">"));

fal.push(CString(s.c_str()));

mFile.Write("#include /"",sizeof("#include /""));

mFile.Write(s.c_str(),sizeof(s.c_str()));

mFile.Write("/"",sizeof("/""));

}

else

mFile.Write(lcs_FileContent,sizeof(lcs_FileContent));

mFile.Write("/r/n",sizeof("/r/n"));

}

mFile.Flush();

mFile.Close();

}

CFileFind finder3;

bWorking2 = finder3.FindFile(szDirPath2);

while (bWorking) {

bWorking2 = finder3.FindNextFile();

if(!finder3.IsDirectory() && !finder3.IsDots()){

CString path=finder3.GetFilePath();

if(path.Mid(path.ReverseFind('.'))==".hpp")

{

path.Replace(".hpp",".cpp");

all.Add(path);

}

finder3.Close();

int count = 1;

while (count > 0) {

doSearch(SourceLib);

all.RemoveAll();

while(fal2.size()>0)

{

CString file1 = fal2.front();

CString targetPath = enumDir+ file1.Mid(file1.ReverseFind('//') + 1);

if(!PathFileExists(targetPath))

{

CString lcs_FileName=finder2.GetFilePath()+"//ReadMe.txt";

CStdioFile f_sfile;

if(f_sfile.Open(lcs_FileName,CFile::modeRead))

{

CFile mFile(_T(targetPath), CFile::modeCreate|CFile::modeWrite);

//逐行读取

CString lcs_FileContent;

int li_line = 0;

long ll_LineCount = 0;

while(f_sfile.ReadString(lcs_FileContent))

{

li_line++;

//读取第li_line行数据: lcs_FileContent

string s(lcs_FileContent.GetBuffer(0));

string::const_iterator it=s.begin();

string::const_iterator end=s.end();

if(boost::regex_serach(it,end,m,reg) && m[1].matched)

{

//it=m[0].second;

int pos=s.find_last_of("/")+1;

s=s.substr(pos,s.find_first_of(">"));

fal2.push(CString(s.c_str()));

all(fal2.back().Replace(".hpp",".cpp"));

mFile.Write("#include /"",sizeof("#include /""));

mFile.Write(s.c_str(),sizeof(s.c_str()));

mFile.Write("/"",sizeof("/""));

}

else

mFile.Write(lcs_FileContent,sizeof(lcs_FileContent));

mFile.Write("/r/n",sizeof("/r/n"));

mFile.Flush();

mFile.Close();

}

finder.Close();

}

return nRetCode;

}

80.提取包含头文件列表

#include

CString regex;

regex.Format("include.*?%s.*?>",lib);

boost::regex reg(regex.GetBuffer(0));

boost::smatch m;

TCHAR szDir[MAX_PATH];

GetCurrentDirectory(MAX_PATH,szDir);

CString CurDir;

CurDir.Format("%s//*.*",szDir);

CFileFind finder;

BOOL bWorking = finder.FindFile(CurDir);

while(bWorking)

{

bWorking = finder.FindNextFile();

if (finder.IsDirectory() && !finder.IsDots())

{

CString lcs_FileName=finder.GetFilePath()+"//StdAfx.cpp";

CStdioFile f_sfile;

//逐行读取

CString lcs_FileContent;

int li_line = 0;

long ll_LineCount = 0;

while(f_sfile.ReadString(lcs_FileContent))

{

li_line++;

//读取第li_line行数据: string s(lcs_FileContent.GetBuffer(0));

string::const_iterator it=s.begin();

string::const_iterator end=s.end();

if(boost::regex_serach(it,end,m,reg) && m[1].matched)

{

//it=m[0].second;

int pos=s.find_last_of("/")+1;

s=s.substr(pos,s.find_first_of(">"));

fal2.push(CString(s.c_str()));

}

CString targetPath = finder.GetFilePath()+"//ReadMe.txt";

CFile mFile(_T(targetPath),CFile::modeCreate|CFile::modeWrite);

mFile.Write("#include /"",sizeof("#include /""));

mFile.Write(s.c_str(),sizeof(s.c_str()));

mFile.Write("/"",sizeof("/""));

mFile.Write("/r/n",sizeof("/r/n"));

mFile.Flush();

mFile.Close();

}

81.剪贴扳转换成打印字符

#include "stdafx.h"

#include "%%0.h"

#ifdef _DEBUG

#define new DEBUG_NEW

#undef THIS_FILE

static char THIS_FILE[] = __FILE__;

#endif

CWinApp theApp;

using namespace std;

int _tmain(int argc, TCHAR* argv[], TCHAR* envp[])

{

int nRetCode = 0;

if (!AfxWinInit(::GetModuleHandle(NULL), NULL, ::GetCommandLine(), 0))

{

cerr << _T("Fatal Error: MFC initialization failed") << endl;

nRetCode = 1;

}

else

{

//判断剪贴板的数据格式是否可以处理

if (!IsClipboardFormatAvailable(CF_UNICODETEXT))

{

return 0;

}

//打开剪贴板

if (!OpenClipboard(NULL))

{

return 0;

}

//获取UNICODE的数据

CString s;

HGLOBAL hMem = GetClipboardData(CF_TEXT);

if (hMem != NULL)

{

//获取UNICODE的字符串

LPTSTR lpStr = (LPTSTR)GlobalLock(hMem);

if (lpStr != NULL)

{

//显示输出

OutputDebugString(lpStr);

//释放锁内存

GlobalUnlock(hMem);

}

s=lpStr;

CString sub;

CString sb;

int pos;

char seperator = '/n';

for (pos = 0; AfxExtractSubString(sub, s, pos, seperator); ++pos)

{

if(sub.Trim()!="")

{

sub.Replace("^", "^^");

sub.Replace("&", "^&");

sub.Replace(":", "^:");

sub.Replace(">", "^>");

sub.Replace("<", "^<");

sub.Replace("|", "^|");

sub.Replace("/"", "^/"");

sub.Replace("//", "");

sub.Replace("/"", "///"");

sb+=("w.WriteLine(/"ECHO " +sub + "/");/r/n");

}

char *pMem;

hMem = GlobalAlloc( GHND | GMEM_DDESHARE, strlen(sb)+1);

if(hMem)

{

pMem = (char*)GlobalLock(hMem);

strcpy(pMem,sb);

GlobalUnlock(hMem);

EmptyClipboard();

SetClipboardData(CF_TEXT,hMem);

}

CloseClipboard();

}

return nRetCode;

}

82.把JButton或JTree组件写到一个流中

83.注册全局热键

BOOL RegisterHotKey(

HWND hWnd . //指定接收WM＿HOTKEY消息的窗体句柄

int id. //热键标识.同一调用线程内的不同热键标识不能相同.应用程序中的标识值在0x0000和0xbfff之间.DLL中的在0xc000和0xffff之间

UINT fsModifiers.//下列值的组合:MOD＿ALT.MOD＿CONTROL.MOD＿SHIFT.MOD＿WIN.MOD＿KEYUP

UINT vk //按键的虚拟码

//在初始化的时候注册:

RegisterHotKey(m＿hWnd.1688.MOD＿SHIFT|MOD＿CONTROL

84.菜单勾选/取消完成后关闭计算机

//使此进程获取：关机权限

HANDLE hToken;

LUID luid;

TOKEN_PRIVILEGES tp;

//获取此进程的令牌

::OpenProcessToken(::GetCurrentProcess(),TOKEN_ADJUST_PRIVILEGES|TOKEN_QUERY,&hToken);

//查询权限值：获取权限的唯一标识值

::LookupPrivilegeValue(NULL,SE_SHUTDOWN_NAME,&luid);

tp.PrivilegeCount = 1;

tp.Privileges[0].Luid = luid;

tp.Privileges[0].Attributes = SE_PRIVILEGE_ENABLED;

//调整令牌权限

::AdjustTokenPrivileges(hToken,FALSE,&tp,sizeof(TOKEN_PRIVILEGES),NULL,NULL);

::ExitWindowsEx(EWX_SHUTDOWN,0);

85.菜单勾选/取消完成后重新启动计算机

//使此进程获取：关机权限

HANDLE hToken;

LUID luid;

TOKEN_PRIVILEGES tp;

//获取此进程的令牌

::OpenProcessToken(::GetCurrentProcess(),TOKEN_ADJUST_PRIVILEGES|TOKEN_QUERY,&hToken);

//查询权限值：获取权限的唯一标识值

::LookupPrivilegeValue(NULL,SE_SHUTDOWN_NAME,&luid);

tp.PrivilegeCount = 1;

tp.Privileges[0].Luid = luid;

tp.Privileges[0].Attributes = SE_PRIVILEGE_ENABLED;

//调整令牌权限

::AdjustTokenPrivileges(hToken,FALSE,&tp,sizeof(TOKEN_PRIVILEGES),NULL,NULL);

::ExitWindowsEx(EWX_REBOOT,0);

86.菜单勾选/取消完成后注销计算机

//使此进程获取：关机权限

HANDLE hToken;

LUID luid;

TOKEN_PRIVILEGES tp;

//获取此进程的令牌

::OpenProcessToken(::GetCurrentProcess(),TOKEN_ADJUST_PRIVILEGES|TOKEN_QUERY,&hToken);

//查询权限值：获取权限的唯一标识值

::LookupPrivilegeValue(NULL,SE_SHUTDOWN_NAME,&luid);

tp.PrivilegeCount = 1;

tp.Privileges[0].Luid = luid;

tp.Privileges[0].Attributes = SE_PRIVILEGE_ENABLED;

//调整令牌权限

::AdjustTokenPrivileges(hToken,FALSE,&tp,sizeof(TOKEN_PRIVILEGES),NULL,NULL);

::ExitWindowsEx(EWX_LOGOFF,0);

87.菜单勾选/取消开机自启动程序

::OnSetMusic()

{

// TODO: Add your command handler code here

/*CMenu *menu1,*menu2;

menu2=menu1.GetSubMenu(1);

menu2.GetMenuItemID(3); */

if(GetCheck()==FALSE)

{

SetCheck();

sndPlaySound("D://oscillograph//res//天路(钢琴伴奏)裁.wav",SND_LOOP);

}

else

{

sndPlaySound("D://oscillograph//res//天路(钢琴伴奏)裁.wav",NULL);

}

TCHAR m_fileName[100];

GetModuleFileName(NULL,m_fileName,100);

HKEY hKey;

CString str = _T("Software//Microsoft//Windows//CurrentVersion//Run");

if (ERROR_SUCCESS != RegCreateKey(HKEY_LOCAL_MACHINE, str, &hKey))

{

AfxMessageBox("打开注册表项失败");

RegCloseKey(hKey);

return;

}

int length = 0;

while(m_fileName[length]!=_T('/0'))

length++;

if (ERROR_SUCCESS != RegSetValueEx(hKey, _T(%%1), 0, REG_SZ, (const BYTE *)m_fileName, sizeof(TCHAR)*length))

{

AfxMessageBox("写注册表失败");

}

RegCloseKey(hKey);

88.菜单勾选/取消自动登录系统

89.模拟键盘输入字符串

CString str=%%1;

DWORD sc,shift;

unsigned char vkey;

char a;

for (int i=0;i

{

a=str.GetAt(i);

sc=OemKeyScan(a);

shift=sc>>16;

vkey=MapVirtualKey(sc&0xffff,1);

if (shift)

keybd_event(VK_SHIFT,0,0,0);

keybd_event(vkey,0,0,0);

keybd_event(vkey,0,KEYEVENTF_KEYUP,0);

if (shift)

keybd_event(VK_SHIFT,0,KEYEVENTF_KEYUP,0);

}

90.提取PDF文件中的文本

try

{

int iFont;

PDFlib pPDF;

CFileDialog m_FileDlg(FALSE,"pdf","",OFN_OVERWRITEPROMPT,"Adobe Acrobat PDF 文件(*.pdf)|*.pdf|所有文件(*.*)|*.*||",this);

char pFileName[255];

CEdit* pPDFText=(CEdit*)GetDlgItem(IDC_EDITPDF);

CString strPDFText;

pPDFText->GetWindowText(strPDFText);

char pPDFInfo[1024];

sprintf(pPDFInfo,"%s",strPDFText);

char pAttachFileName[255];

sprintf(pAttachFileName,"%s",m_AttachFileName);

if(m_FileDlg.DoModal()==IDOK)

{

m_PDFFileName=m_FileDlg.GetFileName();

sprintf(pFileName,m_PDFFileName);

if(pPDF.open_file(pFileName)==-1)

{

}

pPDF.set_parameter("hypertextencoding","host");

pPDF.set_info("Creator","DigitalSky");

pPDF.set_info("Author","DigitalTitan");

pPDF.set_info("Title","Title");

pPDF.begin_page((float)a4_width,(float)a4_height);

iFont=pPDF.load_font("Helvetica-Bold","host","");

pPDF.setfont(iFont,12);

pPDF.set_text_pos(50,a4_height-50);

pPDF.setcolor("fill","rgb",0,0,1,0);

pPDF.show("Version 1.0 (C) CopyRight By Digitaltitan");

iFont=pPDF.findfont("STSong-Light","GB-EUC-H",0);

pPDF.setcolor("fill","rgb",0,0,0,0);

pPDF.setfont(iFont,24);

pPDF.continue_text("转换文档生成为");

pPDF.setcolor("stroke","rgb",0.24f,0.51f,0.047f,0);

pPDF.moveto(50,a4_height-80);

pPDF.lineto(a4_width-50,a4_height-80);

pPDF.moveto(50,a4_height-78);

pPDF.lineto(a4_width-50,a4_height-78);

pPDF.stroke();

pPDF.attach_file(a4_width-50,0,0,a4_height-90,pAttachFileName,"DigitalSky","DigitalTitan","doc","paperclip");

pPDF.set_text_pos(50,a4_height-100);

iFont=pPDF.findfont("STSong-Light","GB-EUC-H",0);

pPDF.setcolor("fill","rgb",0,0,0,0);

pPDF.setfont(iFont,12);

pPDF.continue_text(pPDFInfo);

//Word文件如何导入?

pPDF.end_page();

pPDF.close();

}

catch(PDFlib::Exception &ex)

{

}

下载免费开发包http://partners.adobe.com/asn/acrobat/sdk/fdftk/FDFToolkitForWindows.zip

PDF SDK有一个例子－－AddImage，该例子生产一个dll，放在Acrobat的安装目录下，然后启动Acrobat，就看到多了一个菜单项“AddImage”，就可以调用AddImage了。我的问题是：如何不生成dll给Acrobat调用，而是直接运行AddImage的功能？

91.操作内存映射文件

91.1发送内存映射数据

HANDLE hFileMapping;

LPSTR pData;

hFileMapping=CreateFileMapping((HANDLE)0xFFFFFFFF,NULL,PAGE_READWRITE,0,0x100,%%1); //"MyShare"

if(hFileMapping==NULL)

{

//文件映射至内存失败！

return -1;

}

pData=(LPSTR)MapViewOfFile(hFileMapping,FILE_MAP_ALL_ACCESS,0,0,0);

if(pData==NULL)

{

//文件试镜像到进程地址空间失败！

return -1;

}

sprintf(pData,%%2);

UnmapViewOfFile(pData);

91.2接收内存映射数据

HANDLE hFileMapping;

LPSTR pData;

hFileMapping=CreateFileMapping((HANDLE)0xFFFFFFFF,NULL,PAGE_READWRITE,0,0x100,%%1); //"MyShare"

if(hFileMapping==NULL)

{

//文件映射至内存失败！

return -1;

}

pData=(LPSTR)MapViewOfFile(hFileMapping,FILE_MAP_ALL_ACCESS,0,0,0);

if(pData==NULL)

{

//文件试镜像到进程地址空间失败！

return -1;

}

CString %%2;

%%2.Format("%s",pData);

UnmapViewOfFile(pData);

92.重定向windows控制台程序的输出信息

STARTUPINFO si;

PROCESS_INFOMATION pi;

SECURITY_ATTRIBUTES sa;

HANDLE hRead_OutPipe,hWrite_OutPipe,hRead_InPipe,hWrite_InPipe;

sa.mLength=sizeof(SECURITY_ATTRIBUTES);

sa.lpSecurityDescriptor=NULL;

sa.bInheritHandle=TRUE;

ZeroMemory(&pi,sizeof(pi));

ZeroMemory(&si,sizeof(si));

GetStartipInfo(&si);

si.cb=sizeof(si);

si.dwFlags=STARTF_USESTDHANDLES|STARTF_USERSHOWWINDOW;

si.hStdOutput=hWrite_OutPipe;

si.hStdError=hWrite_OutPipe;

si.hStdInput=hWrite_InPipe;

si.wShowWindow=SW_HIDE;

if(!CreateProcess(NULL,%%1,NULL,NULL,TRUE,0,NULL,NULL,&si,&pi)) {

//创建进程失败

return -1;

}

if(!CreateProcess(&hRead_OutPipe,&hWrite_OutPipe,&sa,0)) {

//创建进程失败

return -1;

}

if(!CreateProcess(&hRead_InPipe,&hWrite_InPipe,&sa,0)) {

//创建进程失败

return -1;

}

si.hStdOutput=hWrite_OutPipe;

si.hStdError=hWrite_OutPipe;

si.hStdInput=hWrite_InPipe;

char buf[4096];

DWORD readlen=0;

CString %%2;

%%2+="/r/n";

DWORD dwWritten=0;

WriteFile(hWrite_InPipe,%%2,%%2.GetLength(),&dwWritten,0);

CString %%3;

BOOL read_ret=TRUE;

while(read_ret=TRUE)

{

memset(buf,'/0',sizeof(buf));

read_ret=ReadFile(hRead_OutPipe,buf,sizeof(buf),&readlen,NULL);

CString buffer(buf);

%%3+=buffer;

}

93.接受邮件

用Visual C++编写电子邮件程序

94.发送邮件

一、概述

---- 本文主要讲述如何使用Visual C++用MAPI编写E-mail程序。MAPI是包含在

Windows之中的，因此不需要安装其他额外的部件。MAPI有以下三种形式：

SMAPI，Simple MAPI，简单的MAPI

CMC，Common Messaging Calls，一般通讯调用

完整的MAPI

---- SMAPI和CMC都包含在完整的MAPI中，当用户想执行一些高级操作，比如

编写自己的E-mail服务器的时候，必须使用完整的MAPI。本文主要阐述如何编

写能够收发电子邮件的程序，因此使用SMAPI就足够了。

二、编写电子邮件程序

3-1 初始化MAPI

---- 要使用MAPI，必须首先对它进行初始化。初始化包括以下三个步骤：

装载MAPI32.DLL动态链接库

找到想要调用的MAPI函数地址

登录到电子邮件对象

3-1-1 装载MAPI32.DLL

---- 要装载MAPI，用户必须程序运行时动态的装载一个动态链接库。LoadLibrary

函数提供了此功能，它定位一个动态链接库，并返回HINSTANCE局柄（需要保存该句柄）。

LoadLibrary的语法如下：

LoadLibrary ( lpLibFileName );

其中lpLibFileName为LPCTSTR结构变量，

是所要调用的库的路径和名称。

程序示例：

// 调用MAPI32.DLL并计算函数地址

HINSTANCE hInstMail;

hInstMail = ::LoadLibrary ( “MAPI32.DLL” );

if ( hInstMail == NULL )

{

// 错误处理

// 受篇幅限制,下面的错误处理部分省略

}

3-1-2 确定函数地址

---- 由于MAPI32.DLL是被动态装载的，因此不知道所要调用的函数地址，

也就不能一开始就调用它们，而要通过函数名获得函数的地址，并在动态链

接库中查找每一个函数并核实。因此首先必须为这些函数声明指针

程序示例：

// 为MAPI32.DLL中的函数声明函数指针

ULONG (PASCAL *lpfnMAPISendMail) (LHANDLE lhSession,

ULONG ulUIParam, lpMapiMessage lpMessage,

FLAGS flFlags, ULONG ulReserved);

ULONG (PASCAL *lpfnMAPIResolveName) (LHANDLE lhSession,

ULONG ulUIParam, LPTSTR lpszName,

FLAGS ulFlags, ULONG ulReserved,

lpMapiRecipDesc FAR *lppRecip);

ULONG (FAR PASCAL *lpfnMAPILogon)(ULONG ulUIParam,

LPSTR lpszProfileName, LPSTR lpszPassword,

FLAGS flFlags, ULONG ulReserved,

LPLHANDLE lplhSession);

ULONG (FAR PASCAL *lpfnMAPILogoff)(LHANDLE lhSession,

ULONG ulUIParam, FLAGS flFlags,

ULONG ulReserved);

ULONG (FAR PASCAL *lpfnMAPIFreeBuffer)(LPVOID lpBuffer);

ULONG (FAR PASCAL *lpfnMAPIAddress)(LHANDLE lhSession,

ULONG ulUIParam, LPSTR lpszCaption,

ULONG nEditFields, LPSTR lpszLabels,

ULONG nRecips, lpMapiRecipDesc lpRecips,

FLAGS flFlags, ULONG ulReserved,

LPULONG lpnNewRecips,

lpMapiRecipDesc FAR *lppNewRecips);

ULONG (FAR PASCAL *lpfnMAPIFindNext)(LHANDLE lhSession,

ULONG ulUIParam, LPSTR lpszMessageType,

LPSTR lpszSeedMessageID, FLAGS flFlags,

ULONG ulReserved, LPSTR lpszMessageID);

ULONG (FAR PASCAL *lpfnMAPIReadMail)(LHANDLE lhSession,

ULONG ulUIParam, LPSTR lpszMessageID,

FLAGS flFlags, ULONG ulReserved,

lpMapiMessage FAR *lppMessage);

---- 为了决定每一个函数的地址，必须为每一个函数调用GetProcAddress。

GetProcAddress的语法为：

GetProcAddress (hModule, lpProcName);

其中，hModule为HMODULE结构，是所调用DLL模块的句柄；

lpProcName为LPCSTR结构，是函数名称。

程序示例：

// 找到MAPI32.DLL函数的地址，并将它们保存在函数指针变量里

(FARPROC&) lpfnMAPISendMail = GetProcAddress(hInstMail,

“MAPISendMail”);

(FARPROC&) lpfnMAPIResolveName = GetProcAddress(

hInstMail, “MAPIResolveName”);

(FARPROC&) lpfnMAPILogon = GetProcAddress(hInstMail,

“MAPILogon”);

(FARPROC&) lpfnMAPILogoff = GetProcAddress(hInstMail,

“MAPILogoff”);

(FARPROC&) lpfnMAPIFreeBuffer = GetProcAddress(

hInstMail, “MAPIFreeBuffer”);

(FARPROC&) lpfnMAPIAddress = GetProcAddress(hInstMail,

“MAPIAddress”);

(FARPROC&) lpfnMAPIFindNext = GetProcAddress(hInstMail,

“MAPIFindNext”);

(FARPROC&) lpfnMAPIReadMail = GetProcAddress(hInstMail,

“MAPIReadMail”);

3-1-3 登录到电子邮件对象

---- 用户必须在电子邮件系统中登录，才能实现MAPI的各种功能。MAPI提供了登录的三种选择：

登录到一个已经存在的对象。

登录到一个新对象，用编程的方法确定解释新信息。

使用对话框提示用户登录。

---- 我们通常选择登录到一个已经存在的电子邮件对象，因为网络合作用户通

常会保持自己的电子邮件程序处于激活状态。登录通常使用MAPI提供的函数

lpfnMAPILogon。

lpfnMAPILogon的语法为：

lpfnMAPILogon (lpszProfileName, lpszPassword, flFlags,

ulReserved, lplhSession );

---- 其中，lpszProfileName指向一个256字符以内的登录名称，lpszPassword

指向密码，它们均为LPTSTR结构。flFlags为FLAGS结构，其值详见表1。ulReserved

必须为0。lplhSession为输出SMAPI的句柄。

表1：lpfnMAPILogon函数中flFlags的值

值意义

MAPI_FORCE_DOWNLOAD

在函数调用返回之前下载用户的所有邮件。

如果MAPI_FORCE_DOWNLOAD没有被设置，

那么信件能够在函数调用返回后在后台被下载。

MAPI_NEW_SESSION 建立一个新会话，

而不是获得环境的共享会话。如果MAPI_NEW_SESSION没有被设置，

MAPILogon使用现有的共享会话。

MAPI_LOGON_UI 显示一个登录对话框来提示用户输入登录信息。

例如Outlook检查用户电子邮件时便是如此。

MAPI_PASSWORD_UI MAPILogon只允许用户输入电子邮件的密码，

而不许改动账号。

程序示例：

LHANDLE lhSession;

ULONG lResult = lpfnMAPILogon(0, NULL, NULL, 0, 0,

&lhSession);

if (lResult != SUCCESS_SUCCESS)

//SUCCESS_SUCCESS在MAPI.H中被定义

{

// 错误处理

}

3-2 阅读电子邮件

---- MAPIFindNext和MAPIReadMail使用与阅读E-mail的两个基本函数。

MAPIFindNext用于定位第一封或下一封电子邮件并返回标识号，MAPIReadMail返回

以该标识号为基础的电子邮件的内容。另外，一个常用的函数是MAPIFreeBuffer，

用于释放内存。

3-2-1 定位到第一封信

---- 要找到第一封信，需要使用MAPIFindNext函数，其函数声明如下：

ULONG FAR PASCAL MAPIFindNext(LHANDLE lhSession,

ULONG ulUIParam, LPTSTR lpszMessageType,

LPTSTR lpszSeedMessageID, FLAGS flFlags,

ULONG ulReserved, LPTSTR lpszMessageID )

---- 其中，lhSession为提交SMAPI的会话句柄；ulUIParam为父窗体的句柄；

lpszMessageType指向一个字符串，用来鉴别邮件类型，并加以查找；

lpszSeedMessageID为指向起始信息ID的指针，其值为0时，

MAPIFindNext获得第一封电子邮件；flFlags的值见表2；ulReserved必须为0；

lpszMessageID为输出值，它是指向信息ID地址的指针。

---- 表2：MAPIFindNext函数中flFlags的值

值意义

MAPI_GUARANTEE_FIFO 按邮件发送的时间顺序接受电子邮件。

MAPI_LONG_MSGID 返回信件标识符可达512字符。

MAPI_UNREAD_ONLY 只列举没有阅读过的电子邮件。

程序示例：

// 找到第一条没有阅读的电子邮件

char pMessageID [513];

ULONG lResult = lpfnMAPIFindNext(lhSession, NULL, NULL,

NULL, MAPI_LONG_MSGID | MAPI_UNREAD_ONLY,

0, pMessageID);

3-2-2 阅读信息

当信件ID被获取后，就可以调用MAPIReadMail

阅读实际的E-mail信息了。MAPIReadMail的函数声明如下：

ULONG FAR PASCAL MAPIReadMail(LHANDLE lhSession,

ULONG ulUIParam, LPTSTR lpszMessageID,

FLAGS flFlags, ULONG ulReserved,

lpMapiMessage FAR * lppMessage);

其中，lppMessage为指向MapiMessage的指针；

除flFlags外的其他参数与lpfnFindNext函数的同名参数意义相同，

flFlags参数的值见表3：

表3：MAPIReadMail函数中flFlags的值：

值意义

MAPI_BODY_AS_FILE 将邮件信息写到一个临时文件中，

并且将它作为第一个附件添加到附件列表中。

MAPI_ENVELOPE_ONLY 只读取邮件标题。

MAPI_PEEK 读完邮件之后不把它标记为“已读”。

MAPI_SUPPRESS_ATTACH MAPIReadMail函数不拷贝附件，

但是将邮件文本写入MapiMessage结构中。

程序示例：

// 读取电子邮件

long nFlags = MAPI_SUPPRESS_ATTACH;

if (!bMarkAsRead)

nFlags = nFlags | MAPI_PEEK;

lResult = lpfnMAPIReadMail(lhSession, NULL, pMessageID,

nFlags, 0, &pMessage);

if (lResult != SUCCESS_SUCCESS);

return false;

如果调用成功，就可以访问MapiMessage结构了（使用pMessage）：

pMessage- >ulReserved：0

pMessage- >lpszSubject：邮件标题

pMessage- >lpszNoteText：邮件信息

pMessage- >lpszMessageType：邮件类型

pMessage- >DateReceived：接收时间

pMessage- >lpszConversationID：邮件所属的会话线程ID

pMessage- >flFlags：其值见表4

表4：MapiMessage结构中的flFlags

值意义

MAPI_RECEIPT_REQUESTED 接收通知被申请。

客户端应用程序在发送消息时设置该项。

MAPI_SENT 邮件已被发送。

MAPI_UNREAD 邮件是“未读”状态。

pMessage- >lpOriginator：指向MapiRecipDesc结构，包含发件人信息。

pMessage- >nRecipCount：信件者数目。

pMessage- >lpRecips：指向MapiRecipDesc结构数组，包含接收者信息。

pMessage- >nFileCount：附件数量。

pMessage- >lpFiles：指向MapiFileDesc结构数组，

每一个结构包含一个文件附件。

3-2-3 释放内存

---- 在访问另一条信件以前应当释放内存，否则会出现内存泄漏。

程序示例：

// 释放内存

lpfnMAPIFreeBuffer(pMessage);

3-2-4 定位到下一条信件

定位到下一条信件依然使用MAPIFindNext函数，

该函数声明及参数意义详见3-2-1节。下面示范如何定位到下一条信件。

程序示例：

// 定位到下一条没有阅读的信件

ULONG lResult = lpfnMAPIFindNext(lhSession, NULL, NULL,

pMessageID, MAPI_LONG_MSGID|MAPI_UNREAD_ONLY,

0, pMessageID);

3-3 发送电子邮件

---- 发送电子邮件的一般步骤：

---- 1．建立MapiMessage结构对象

---- 2．调用MAPIResolveName使发送者名称合法

---- 3．添加附件

---- 4．调用MAPISendMail发送电子邮件

---- 5．调用MAPIFreeBuffer释放内存

---- 下面详细分别详细阐述。

3-3-1 建立MapiMessage结构对象

---- 对于MapiMessage结构，3-2-2节已经做过介绍，下面一步步介绍如何设置其中的值：

---- 1．为MapiMessage对象分配内存：

MapiMessage message;

Memset(&message, 0, sizeof(message));

---- 2．将ulReserved设置为0：

message.ulReserved = 0;

---- 3．设置信息类型指针lpszMessageType，可以为NULL：

message.lpszMessageType = NULL;

---- 4．设置信件标题（lpszSubject）：

char subject[512];

strcpy(subject, sSubject);

message.lpszSubject = subject;

---- 5．设置信件内容：

char text[5000];

strcpy(text, sMessage);

message.lpszNoteText = text;

---- 6．设置flFlags标识，详见3-2-2节中表4：

message.flFlags = MAPI_SENT;

---- 7．用一个指向MapiRecipDesc结构的指针设置发送者信息（lpOriginator），

或将其设置为NULL：

message.lpOriginator = NULL;

---- 8．设置接收者数目（nRecipCount），可以是1或更多：

message.nRecipCount = 1;

---- 9．设置接收者信息（lpRecips），详见3-3-2节

---- 10．设置附件数量（nFileCount）

---- 11．设置附件信息，详见3-3-3节

b3-3-2 正确设置接收者信息

---- 设置接收者信息时，应当使用MAPIResolveName函数来为MapiRecipDesc结构

对象分配内存，并返回一个指针，该指针将被保存在MapiMessage结构的lpRecips中。

MAPIResolveName的函数声明如下：

ULONG FAR PASCAL MAPIResolveName(LHANDLE lhSession,

ULONG ulUIParam, LPTSTR lpszName,

FLAGS flFlags, ULONG ulReserved,

lpMapiRecipDesc FAR * lppRecip )

---- 其中lppRecip即为前面提到的返回的指针。除flFlags外其余参数与前几个

函数意义相同。flFlags的值详见表5。

表5：MAPIResolveName中flFlags的值

值意义

MAPI_AB_NOMODIFY 对话框为只读。如果MAPI_DIALOG被设置，

那么该项将被忽略。

MAPI_DIALOG 显示一个名称解决方案的对话框

MAPI_LOGON_UI 如果需要的话，将会显示仪个对话框让用户登录

MAPI_NEW_SESSION 新建一个会话

程序示例：

char recipient[512];

strcpy(recipient, sTo);

lResult = lpfnMAPIResolveName(lhSession, 0, recipient,

0, 0, &message.lpRecips);

3-3-3 添加附件

---- 下面的程序示例将演示如何在电子邮件中包含附件。只有一点需要说明：

MapiFileDesc结构中flFlags的值，详见表6。

表6：MapiFileDesc结构中flFlags的值

值意义

MAPI_OLE 附件是OLE对象。

MAPI_OLE_STATIC 附件是静态OLE对象。

0 附件将被视为数据文件

程序示例：

// 设置附件信息

CString sPath, sFileName;

MapiFileDesc FileInfo;

char path[512];

char filename[512];

if (sAttachment == “”)

message.nFileCount = 0;

else

{

int nPos = sAttachment.ReverseFind(‘//’);

if (nPos == -1)

{

sPath = sAttachment;

}

else

{

sPath = sAttachment;

sFilename = sAttachment.Mid(nPos +1);

}

strcpy(path, sPath);

strcpy(filename, sFilename);

message.nFileCount = 1;

FileInfo.ulReserved = 0;

FileInfo.flFlags = 0;

FileInfo.nPosition = sMessage.GetLength() –1;

FileInfo.lpszPathName = path;

FileInfo.lpszFileName = filename;

FileInfo.lpFileType = NULL;

message.lpFiles = & m_FileInfo;

}

3-3-4 发送电子邮件

---- 使用MAPISendMail发送电子邮件，其声明如下：

ULONG FAR PASCAL MAPISendMail (LHANDLE lhSession,

ULONG ulUIParam, lpMapiMessage lpMessage,

FLAGS flFlags, ULONG ulReserved )

---- 其中，flFlags的允许值为MAPI_DIALOG、MAPI_LOGON_UI和MAPI_NEW_SESSION，

其意义与前几个函数中同名标识意义相同。

程序示例：

lResult = lpfnMAPISendMail(0, 0, &m_message, 0, 0);

3-3-5 释放内存

程序示例：

lpfnMAPIFreeBuffer(m_message.lpRecips);

四、小结

---- 本文比较具体的介绍并演示了编写一个电子邮件程序的核心部分，如果读者

要编写电子邮件程序，还需要进行的处理：

---- 1．加上错误处理代码。受篇幅限制，本文的程序示例中只有两处为错误

处理留空，比较它们的异同。电子邮件程序是非常容易出错的，因此除这两处外要

在主要函数调用完成后都加上错误处理，或使用try throw catch块处理例外。

---- 2．加上UI处理。

---- 另外，本文所阐述的方法比较简单易行，事实上，有关电子邮件的程序远比

这复杂得多，因此读者若需要编写一个功能强大的电子邮件程序，需要精通MAPI和

SMTP/POP3等协议；如果读者要编写一个电子邮件服务器，那么不妨在精通MAPI和

SMTP/POP3之后，阅读一些有关Exchange Server的资料。

95.报表相关

　一、准备工作

　　（1）安装Crystal Report软件

Crystal Report 4.6是一个免费的报表工具，可以在VB5或WINDOWS NT 4.0 BackOffice等光盘上找到，Crystal report4.6中包含了报表设计工具与报表打印控件。程序的发行只需要安装打印控件相关部分即可。

　　（2）设计报表

　　我们生成一个名为sample.rpt的报表，这一过程可以参考 Crystal report自带的帮助文档，本文不作详细介绍。

　　二、创建VC工程添加报表控件

　　在VC集成环境中用AppWizard新建一个MFC单文档工程，其余选项都为默认。菜单中选择Project->Add To Project->Components and Controls...弹出组件、控件选择对话框，进入Registered ActiveX Controls,选中Crystal Report Control 4.6 ,单击Insert按钮，确认后进入类配置对话框，按默认即可。关闭控件选择对话框完成控件的添加。

　　三、实现报表的显示与打印

　　下面我们将在对话框中演示控件的静态创建过程，在主视图中演示控件的动态创建过程。

　　3.1在对话框中打印出报表

　　在资源编辑器中打开ID为IDD_ABOUTBOX的对话框模板，在Controls工具条中我们可以找到刚加入到工程中的Crystal Report Control 4.6控件按钮，把它插入到对话框合适的位置处。

　　右键单击对话框中的控件，选择属性，此时可以设置控件的许多属性。我们在Control选项页ReportFileName中输入报表文件名sample.rpt(可以加上完整路径),在Print Window选项页中设置控件的合适位置,回到对话框模板中按住Ctrl键，双击鼠标左键，弹出Add Member Variable对话框,我们将成员变量命名为m_CrystalReport,打开ClassWizard,为CAboutDlg对话框添加WM_INITDIALOG消息的处理函数:BOOL OnInitDialog(),并在函数中做如下处理

BOOL CAboutDlg::OnInitDialog()

{

CDialog::OnInitDialog();

/此行设置控件的父窗口，你也可以去掉该行看看运行效果/

m_CrystalReport.SetWindowParentHandle((long)(this->m_hWnd));

/打印报表到窗口中/

m_CrystalReport.PrintReport();

return TRUE;

}

　　至此，程序的第一部分编写完成，编译运行,打开About对话框看看效果吧!

　　假如您并没有显示出报表，有如下可能原因：

　　(1)控件没有放置在合适的位置或尺寸不对。

　　(2)报表文件本身存在诸如数据源不可用等错误。

　　控件窗口中的工具条提供了缩放、打印等功能，您也可以试试在打印机上打印出来的效果。

　　3.2 在程序主视窗中显示报表

　　打开ClassWizard增加对ID_FILE_OPEN和ID_FILE_PRINT的处理函数,代码如下

void CMyReportView::OnFileOpen()

{

char Filter[] = "Crystal Report files(*.rpt)|*.rpt|All files(*.*)|*.*||";

CRect rect;

CFileDialog OpenDlg(TRUE,0,0,OFN_HIDEREADONLY|OFN_FILEMUSTEXIST,(LPCTSTR)Filter,NULL);

if(OpenDlg.DoModal()!=IDOK) ///显示文件对话框

return;

CString m_fName=OpenDlg.GetPathName(); ///取得文件名

if(m_CrystalReport)

m_CrystalReport.DestroyWindow();

GetClientRect(rect);

///创建控件///

if (!m_CrystalReport.Create(AfxRegisterWndClass(0, AfxGetApp()->LoadStandardCursor(IDC_ARROW)),WS_CHILD|

_ WS_VISIBLE,rect,this,IDC_CRYSTALREPORT1))

{

AfxMessageBox("控件创建失败!");

return ;

}

m_CrystalReport.SetWindowParentHandle((long)(this->m_hWnd));///设置父窗口

m_CrystalReport.SetWindowBorderStyle(0); ///设置为没有边框

m_CrystalReport.SetWindowLeft(0); ///左空间

m_CrystalReport.SetWindowTop(0); ///顶部空间

m_CrystalReport.SetWindowControls(FALSE); ///不显示工具条

m_CrystalReport.SetReportFileName(m_fName); ///设置报表文件

m_CrystalReport.SetWindowWidth(rect.Width()); ///设置窗口宽度

m_CrystalReport.SetWindowHeight(rect.Height()); ///设置窗口高度

m_CrystalReport.SetFormulas(0, "Company=/"VC知识库/"");

///将报表中的Company变量的值设置为VC知识库

m_CrystalReport.SetDestination(0); ///设置输出对象是屏幕

m_CrystalReport.PrintReport(); ///显示报表

}

void CMyReportView::OnFilePrint()

{

if(m_CrystalReport && m_CrystalReport.GetReportFileName() != "")

{

m_CrystalReport.SetDestination(1); ///设置输出对象是打印机

m_CrystalReport.PrintReport(); ///打印

}

　　后记：我们利用Crystal Report 4.6在VC++环境下实现了报表处理，但Crystal Report 4.6报表控件的功能及可控性能可能无法满足您的要求，Seagate公司此款软件的最新版本是Crystal Report 8.0，各方面表现都非常出色，但此款软件的免费版本并不包括报表设计器，可喜的是8.0中的报表显示控件兼容以前版本的报表格式，所以笔者建议用4.6版本来设计报表，依靠8.0中的报表显示控件来显示、打印。

96.全屏幕截取

CBitmap* m_pBackBitmap;

/*******************************

* 拷贝屏幕固定区域

* 参数:

* xStartPt - 拷贝屏幕的起始点X坐标

* yStartPt - 拷贝屏幕的起始点Y坐标

* width - 拷贝宽度

* height - 拷贝高度

* xToCopy - 拷贝目的地的起始点X坐标

* yToCopy - 拷贝目的地的起始点Y坐标

*******************************/

void CopyScreenToBitmap(xStartPt, yStartPt, width, height, xToCopy, yToCopy)

{

//NEW资源(调用一次重新拷贝一次)

if (m_pBackBitmap != NULL)

{

delete m_pBackBitmap;

m_pBackBitmap = NULL;

}

m_pBackBitmap = new CBitmap();

CDC ScrDC,MemDC;

ScrDC.CreateDC("DISPLAY", NULL, NULL, NULL);

MemDC.CreateCompatibleDC(&ScrDC);

m_pBackBitmap->CreateCompatibleBitmap(&ScrDC,width,height);

MemDC.SelectObject(m_pBackBitmap);

//开始拷贝

MemDC.BitBlt(xStartPt, yStartPt, width, height,&ScrDC,xToCopy,yToCopy,SRCCOPY);

ScrDC.DeleteDC();

MemDC.DeleteDC();

}

//取的屏幕分辨率

int width = ::GetSystemMetrics(SM_CXSCREEN);

int height = ::GetSystemMetrics(SM_CYSCREEN);

this->CopyScreenToBitmap(0,0,width,height,0,0);

//这时m_pBackBitmap指向的CBitmap对象就存着全屏的图象了

97.区域截幕

HBITMAP CopyScreenToBitmap(LPRECT lpRect)

//lpRect 代表选定区域

{

HDC hScrDC, hMemDC;

// 屏幕和内存设备描述表

HBITMAP hBitmap, hOldBitmap;

// 位图句柄

int nX, nY, nX2, nY2;

// 选定区域坐标

int nWidth, nHeight;

// 位图宽度和高度

int xScrn, yScrn;

// 屏幕分辨率

// 确保选定区域不为空矩形

if (IsRectEmpty(lpRect))

return NULL;

//为屏幕创建设备描述表

hScrDC = CreateDC("DISPLAY", NULL, NULL, NULL);

//为屏幕设备描述表创建兼容的内存设备描述表

hMemDC = CreateCompatibleDC(hScrDC);

// 获得选定区域坐标

nX = lpRect- >left;

nY = lpRect- >top;

nX2 = lpRect- >right;

nY2 = lpRect- >bottom;

// 获得屏幕分辨率

xScrn = GetDeviceCaps(hScrDC, HORZRES);

yScrn = GetDeviceCaps(hScrDC, VERTRES);

//确保选定区域是可见的

if (nX 〈0)

nX = 0;

if (nY 〈 0)

nY = 0;

if (nX2 > xScrn)

nX2 = xScrn;

if (nY2 > yScrn)

nY2 = yScrn;

nWidth = nX2 - nX;

nHeight = nY2 - nY;

// 创建一个与屏幕设备描述表兼容的位图

hBitmap = CreateCompatibleBitmap

(hScrDC, nWidth, nHeight);

// 把新位图选到内存设备描述表中

hOldBitmap = SelectObject(hMemDC, hBitmap);

// 把屏幕设备描述表拷贝到内存设备描述表中

BitBlt(hMemDC, 0, 0, nWidth, nHeight,

hScrDC, nX, nY, SRCCOPY);

//得到屏幕位图的句柄

hBitmap = SelectObject(hMemDC, hOldBitmap);

//清除

DeleteDC(hScrDC);

DeleteDC(hMemDC);

// 返回位图句柄

return hBitmap;

}

得到屏幕位图句柄以后,我们

可以把屏幕内容粘贴到剪贴板上.

if (OpenClipboard(hWnd))

//hWnd为程序窗口句柄

{

//清空剪贴板

EmptyClipboard();

//把屏幕内容粘贴到剪贴板上,

hBitmap 为刚才的屏幕位图句柄

SetClipboardData(CF_BITMAP, hBitmap);

//关闭剪贴板

CloseClipb

oard();

}

int SaveBitmapToFile(HBITMAP hBitmap ,

LPSTR lpFileName) //hBitmap 为刚才的屏幕位图句柄

{ //lpFileName 为位图文件名

HDC hDC;

//设备描述表

int iBits;

//当前显示分辨率下每个像素所占字节数

WORD wBitCount;

//位图中每个像素所占字节数

//定义调色板大小，位图中像素字节大小，

位图文件大小，写入文件字节数

DWORD dwPaletteSize=0,

dwBmBitsSize,

dwDIBSize, dwWritten;

BITMAP Bitmap;

//位图属性结构

BITMAPFILEHEADER bmfHdr;

//位图文件头结构

BITMAPINFOHEADER bi;

//位图信息头结构

LPBITMAPINFOHEADER lpbi;

//指向位图信息头结构

HANDLE fh, hDib, hPal,hOldPal=NULL;

//定义文件，分配内存句柄，调色板句柄

//计算位图文件每个像素所占字节数

hDC = CreateDC("DISPLAY",NULL,NULL,NULL);

iBits = GetDeviceCaps(hDC, BITSPIXEL) *

GetDeviceCaps(hDC, PLANES);

DeleteDC(hDC);

if (iBits 〈 = 1)

wBitCount = 1;

else if (iBits 〈 = 4)

MFC文件操作大全

你可能感兴趣的:(MFC文件操作大全)