This commit was manufactured by cvs2svn to create tag

'Version_1_30_1'.

[SVN r19444]

build/Jamfile.v2

@@ -0,0 +1,15 @@
+
+project boost/regex
+    : source-location ../src
+    ;
+SOURCES = c_regex_traits c_regex_traits_common cpp_regex_traits
+       cregex fileiter posix_api regex regex_debug
+       regex_synch w32_regex_traits wide_posix_api instances winstances ;
+
+
+lib boost_regex : $(SOURCES).cpp 
+    :         
+        <link>static:<define>BOOST_REGEX_NO_LIB=1
+        <link>static:<define>BOOST_REGEX_STATIC_LINK=1
+	<link>shared:<define>BOOST_RE_BUILD_DLL=1
+    ;

build/bcb4.mak

@@ -35,7 +35,7 @@ BCROOT=$(MAKEDIR)\..
 !endif
 
 
-ALL_HEADER= ../../../boost/regex/config.hpp ../../../boost/regex/pattern_except.hpp ../../../boost/regex/regex_traits.hpp ../../../boost/regex/user.hpp ../../../boost/regex/detail/fileiter.hpp ../../../boost/regex/detail/instances.hpp ../../../boost/regex/detail/regex_compile.hpp ../../../boost/regex/detail/regex_cstring.hpp ../../../boost/regex/detail/regex_format.hpp ../../../boost/regex/detail/regex_kmp.hpp ../../../boost/regex/detail/regex_library_include.hpp ../../../boost/regex/detail/regex_match.hpp ../../../boost/regex/detail/regex_raw_buffer.hpp ../../../boost/regex/detail/regex_split.hpp ../../../boost/regex/detail/regex_stack.hpp ../../../boost/regex/detail/regex_synch.hpp
+ALL_HEADER= ../../../boost/regex/config.hpp ../../../boost/regex/pattern_except.hpp ../../../boost/regex/regex_traits.hpp ../../../boost/regex/user.hpp ../../../boost/regex/v3/fileiter.hpp ../../../boost/regex/v3/instances.hpp ../../../boost/regex/v3/regex_compile.hpp ../../../boost/regex/v3/regex_cstring.hpp ../../../boost/regex/v3/regex_format.hpp ../../../boost/regex/v3/regex_kmp.hpp ../../../boost/regex/v3/regex_library_include.hpp ../../../boost/regex/v3/regex_match.hpp ../../../boost/regex/v3/regex_raw_buffer.hpp ../../../boost/regex/v3/regex_split.hpp ../../../boost/regex/v3/regex_stack.hpp ../../../boost/regex/v3/regex_synch.hpp
 
 all : bcb4 bcb4\boost_regex_bcb4_sss bcb4\boost_regex_bcb4_sss.lib bcb4\boost_regex_bcb4_mss bcb4\boost_regex_bcb4_mss.lib bcb4\boost_regex_bcb4_mdi bcb4\boost_regex_bcb4_mdi.lib bcb4\boost_regex_bcb4_sdi bcb4\boost_regex_bcb4_sdi.lib bcb4\boost_regex_bcb4_mds bcb4\boost_regex_bcb4_mds.lib bcb4\boost_regex_bcb4_sds bcb4\boost_regex_bcb4_sds.lib
 
@@ -565,3 +565,4 @@ bcb4\boost_regex_bcb4_sds.lib : bcb4\boost_regex_bcb4_sds\c_regex_traits.obj bcb
 /P128 /C /u /a $(XSFLAGS) bcb4\boost_regex_bcb4_sds.lib  -+bcb4\boost_regex_bcb4_sds\c_regex_traits.obj -+bcb4\boost_regex_bcb4_sds\c_regex_traits_common.obj -+bcb4\boost_regex_bcb4_sds\cpp_regex_traits.obj -+bcb4\boost_regex_bcb4_sds\cregex.obj -+bcb4\boost_regex_bcb4_sds\fileiter.obj -+bcb4\boost_regex_bcb4_sds\instances.obj -+bcb4\boost_regex_bcb4_sds\posix_api.obj -+bcb4\boost_regex_bcb4_sds\regex.obj -+bcb4\boost_regex_bcb4_sds\regex_debug.obj -+bcb4\boost_regex_bcb4_sds\regex_synch.obj -+bcb4\boost_regex_bcb4_sds\w32_regex_traits.obj -+bcb4\boost_regex_bcb4_sds\wide_posix_api.obj -+bcb4\boost_regex_bcb4_sds\winstances.obj
 |
 
+

build/bcb5.mak

@@ -35,7 +35,7 @@ BCROOT=$(MAKEDIR)\..
 !endif
 
 
-ALL_HEADER= ../../../boost/regex/config.hpp ../../../boost/regex/pattern_except.hpp ../../../boost/regex/regex_traits.hpp ../../../boost/regex/user.hpp ../../../boost/regex/detail/fileiter.hpp ../../../boost/regex/detail/instances.hpp ../../../boost/regex/detail/regex_compile.hpp ../../../boost/regex/detail/regex_cstring.hpp ../../../boost/regex/detail/regex_format.hpp ../../../boost/regex/detail/regex_kmp.hpp ../../../boost/regex/detail/regex_library_include.hpp ../../../boost/regex/detail/regex_match.hpp ../../../boost/regex/detail/regex_raw_buffer.hpp ../../../boost/regex/detail/regex_split.hpp ../../../boost/regex/detail/regex_stack.hpp ../../../boost/regex/detail/regex_synch.hpp
+ALL_HEADER= ../../../boost/regex/config.hpp ../../../boost/regex/pattern_except.hpp ../../../boost/regex/regex_traits.hpp ../../../boost/regex/user.hpp ../../../boost/regex/v3/fileiter.hpp ../../../boost/regex/v3/instances.hpp ../../../boost/regex/v3/regex_compile.hpp ../../../boost/regex/v3/regex_cstring.hpp ../../../boost/regex/v3/regex_format.hpp ../../../boost/regex/v3/regex_kmp.hpp ../../../boost/regex/v3/regex_library_include.hpp ../../../boost/regex/v3/regex_match.hpp ../../../boost/regex/v3/regex_raw_buffer.hpp ../../../boost/regex/v3/regex_split.hpp ../../../boost/regex/v3/regex_stack.hpp ../../../boost/regex/v3/regex_synch.hpp
 
 all : bcb5 bcb5\boost_regex_bcb5_sss bcb5\boost_regex_bcb5_sss.lib bcb5\boost_regex_bcb5_mss bcb5\boost_regex_bcb5_mss.lib bcb5\boost_regex_bcb5_mdi bcb5\boost_regex_bcb5_mdi.lib bcb5\boost_regex_bcb5_sdi bcb5\boost_regex_bcb5_sdi.lib bcb5\boost_regex_bcb5_mds bcb5\boost_regex_bcb5_mds.lib bcb5\boost_regex_bcb5_sds bcb5\boost_regex_bcb5_sds.lib
 
@@ -565,3 +565,4 @@ bcb5\boost_regex_bcb5_sds.lib : bcb5\boost_regex_bcb5_sds\c_regex_traits.obj bcb
 /P128 /C /u /a $(XSFLAGS) bcb5\boost_regex_bcb5_sds.lib  -+bcb5\boost_regex_bcb5_sds\c_regex_traits.obj -+bcb5\boost_regex_bcb5_sds\c_regex_traits_common.obj -+bcb5\boost_regex_bcb5_sds\cpp_regex_traits.obj -+bcb5\boost_regex_bcb5_sds\cregex.obj -+bcb5\boost_regex_bcb5_sds\fileiter.obj -+bcb5\boost_regex_bcb5_sds\instances.obj -+bcb5\boost_regex_bcb5_sds\posix_api.obj -+bcb5\boost_regex_bcb5_sds\regex.obj -+bcb5\boost_regex_bcb5_sds\regex_debug.obj -+bcb5\boost_regex_bcb5_sds\regex_synch.obj -+bcb5\boost_regex_bcb5_sds\w32_regex_traits.obj -+bcb5\boost_regex_bcb5_sds\wide_posix_api.obj -+bcb5\boost_regex_bcb5_sds\winstances.obj
 |
 
+

build/bcb6.mak

@@ -35,7 +35,7 @@ BCROOT=$(MAKEDIR)\..
 !endif
 
 
-ALL_HEADER= ../../../boost/regex/config.hpp ../../../boost/regex/pattern_except.hpp ../../../boost/regex/regex_traits.hpp ../../../boost/regex/user.hpp ../../../boost/regex/detail/fileiter.hpp ../../../boost/regex/detail/instances.hpp ../../../boost/regex/detail/regex_compile.hpp ../../../boost/regex/detail/regex_cstring.hpp ../../../boost/regex/detail/regex_format.hpp ../../../boost/regex/detail/regex_kmp.hpp ../../../boost/regex/detail/regex_library_include.hpp ../../../boost/regex/detail/regex_match.hpp ../../../boost/regex/detail/regex_raw_buffer.hpp ../../../boost/regex/detail/regex_split.hpp ../../../boost/regex/detail/regex_stack.hpp ../../../boost/regex/detail/regex_synch.hpp
+ALL_HEADER= ../../../boost/regex/config.hpp ../../../boost/regex/pattern_except.hpp ../../../boost/regex/regex_traits.hpp ../../../boost/regex/user.hpp ../../../boost/regex/v3/fileiter.hpp ../../../boost/regex/v3/instances.hpp ../../../boost/regex/v3/regex_compile.hpp ../../../boost/regex/v3/regex_cstring.hpp ../../../boost/regex/v3/regex_format.hpp ../../../boost/regex/v3/regex_kmp.hpp ../../../boost/regex/v3/regex_library_include.hpp ../../../boost/regex/v3/regex_match.hpp ../../../boost/regex/v3/regex_raw_buffer.hpp ../../../boost/regex/v3/regex_split.hpp ../../../boost/regex/v3/regex_stack.hpp ../../../boost/regex/v3/regex_synch.hpp
 
 all : bcb6 bcb6\boost_regex_bcb6_sss bcb6\boost_regex_bcb6_sss.lib bcb6\boost_regex_bcb6_mss bcb6\boost_regex_bcb6_mss.lib bcb6\boost_regex_bcb6_mdi bcb6\boost_regex_bcb6_mdi.lib bcb6\boost_regex_bcb6_sdi bcb6\boost_regex_bcb6_sdi.lib bcb6\boost_regex_bcb6_mds bcb6\boost_regex_bcb6_mds.lib bcb6\boost_regex_bcb6_sds bcb6\boost_regex_bcb6_sds.lib bcb6\boost_regex_bcb6_sssdd bcb6\boost_regex_bcb6_sssdd.lib bcb6\boost_regex_bcb6_mssdd bcb6\boost_regex_bcb6_mssdd.lib bcb6\boost_regex_bcb6_mdidd bcb6\boost_regex_bcb6_mdidd.lib bcb6\boost_regex_bcb6_sdidd bcb6\boost_regex_bcb6_sdidd.lib bcb6\boost_regex_bcb6_mdsdd bcb6\boost_regex_bcb6_mdsdd.lib bcb6\boost_regex_bcb6_sdsdd bcb6\boost_regex_bcb6_sdsdd.lib
 
@@ -1083,3 +1083,4 @@ bcb6\boost_regex_bcb6_sdsdd.lib : bcb6\boost_regex_bcb6_sdsdd\c_regex_traits.obj
 /P128 /C /u /a $(XSFLAGS) bcb6\boost_regex_bcb6_sdsdd.lib  -+bcb6\boost_regex_bcb6_sdsdd\c_regex_traits.obj -+bcb6\boost_regex_bcb6_sdsdd\c_regex_traits_common.obj -+bcb6\boost_regex_bcb6_sdsdd\cpp_regex_traits.obj -+bcb6\boost_regex_bcb6_sdsdd\cregex.obj -+bcb6\boost_regex_bcb6_sdsdd\fileiter.obj -+bcb6\boost_regex_bcb6_sdsdd\instances.obj -+bcb6\boost_regex_bcb6_sdsdd\posix_api.obj -+bcb6\boost_regex_bcb6_sdsdd\regex.obj -+bcb6\boost_regex_bcb6_sdsdd\regex_debug.obj -+bcb6\boost_regex_bcb6_sdsdd\regex_synch.obj -+bcb6\boost_regex_bcb6_sdsdd\w32_regex_traits.obj -+bcb6\boost_regex_bcb6_sdsdd\wide_posix_api.obj -+bcb6\boost_regex_bcb6_sdsdd\winstances.obj
 |
 
+

build/common.sh

@@ -6,13 +6,13 @@ for file in ../../../boost/regex/*.hpp ; do
 	fi
 done
 
-for file in ../../../boost/regex/detail/*.hpp; do
+for file in ../../../boost/regex/v3/*.hpp; do
 	if [ -f $file ]; then
 		header="$header $file"
 	fi
 done
 
-for file in ../../../boost/regex/detail/*.hxx; do
+for file in ../../../boost/regex/v3/*.hxx; do
 	if [ -f $file ]; then
 		header="$header $file"
 	fi
@@ -26,3 +26,4 @@ for file in ../src/*.cpp; do
 	fi
 done
 
+

build/gcc-shared.mak

@@ -29,7 +29,7 @@ C1=-c -O2 -I../../../ -fPIC
 C2=-c -g -I../../../ -fPIC
 
 
-ALL_HEADER= ../../../boost/regex/config.hpp ../../../boost/regex/pattern_except.hpp ../../../boost/regex/regex_traits.hpp ../../../boost/regex/user.hpp ../../../boost/regex/detail/fileiter.hpp ../../../boost/regex/detail/instances.hpp ../../../boost/regex/detail/regex_compile.hpp ../../../boost/regex/detail/regex_cstring.hpp ../../../boost/regex/detail/regex_format.hpp ../../../boost/regex/detail/regex_kmp.hpp ../../../boost/regex/detail/regex_library_include.hpp ../../../boost/regex/detail/regex_match.hpp ../../../boost/regex/detail/regex_raw_buffer.hpp ../../../boost/regex/detail/regex_split.hpp ../../../boost/regex/detail/regex_stack.hpp ../../../boost/regex/detail/regex_synch.hpp
+ALL_HEADER= ../../../boost/regex/config.hpp ../../../boost/regex/pattern_except.hpp ../../../boost/regex/regex_traits.hpp ../../../boost/regex/user.hpp ../../../boost/regex/v3/fileiter.hpp ../../../boost/regex/v3/instances.hpp ../../../boost/regex/v3/regex_compile.hpp ../../../boost/regex/v3/regex_cstring.hpp ../../../boost/regex/v3/regex_format.hpp ../../../boost/regex/v3/regex_kmp.hpp ../../../boost/regex/v3/regex_library_include.hpp ../../../boost/regex/v3/regex_match.hpp ../../../boost/regex/v3/regex_raw_buffer.hpp ../../../boost/regex/v3/regex_split.hpp ../../../boost/regex/v3/regex_stack.hpp ../../../boost/regex/v3/regex_synch.hpp
 
 all : gcc  gcc gcc/boost_regex_shared ./gcc/libboost_regex.so gcc gcc/boost_regex_debug_shared ./gcc/libboost_regex_debug.so
 
@@ -148,3 +148,4 @@ boost_regex_debug_clean :
 ./gcc/libboost_regex_debug.so : gcc/boost_regex_debug_shared/c_regex_traits.o gcc/boost_regex_debug_shared/c_regex_traits_common.o gcc/boost_regex_debug_shared/cpp_regex_traits.o gcc/boost_regex_debug_shared/cregex.o gcc/boost_regex_debug_shared/fileiter.o gcc/boost_regex_debug_shared/instances.o gcc/boost_regex_debug_shared/posix_api.o gcc/boost_regex_debug_shared/regex.o gcc/boost_regex_debug_shared/regex_debug.o gcc/boost_regex_debug_shared/regex_synch.o gcc/boost_regex_debug_shared/w32_regex_traits.o gcc/boost_regex_debug_shared/wide_posix_api.o gcc/boost_regex_debug_shared/winstances.o
 	$(LINKER) -o gcc/libboost_regex_debug.so $(LDFLAGS)  gcc/boost_regex_debug_shared/c_regex_traits.o gcc/boost_regex_debug_shared/c_regex_traits_common.o gcc/boost_regex_debug_shared/cpp_regex_traits.o gcc/boost_regex_debug_shared/cregex.o gcc/boost_regex_debug_shared/fileiter.o gcc/boost_regex_debug_shared/instances.o gcc/boost_regex_debug_shared/posix_api.o gcc/boost_regex_debug_shared/regex.o gcc/boost_regex_debug_shared/regex_debug.o gcc/boost_regex_debug_shared/regex_synch.o gcc/boost_regex_debug_shared/w32_regex_traits.o gcc/boost_regex_debug_shared/wide_posix_api.o gcc/boost_regex_debug_shared/winstances.o $(LIBS)
 
+

build/gcc.mak

@@ -30,7 +30,7 @@ C2=-c -g -I../../../
 
 
 
-ALL_HEADER= ../../../boost/regex/config.hpp ../../../boost/regex/pattern_except.hpp ../../../boost/regex/regex_traits.hpp ../../../boost/regex/user.hpp ../../../boost/regex/detail/fileiter.hpp ../../../boost/regex/detail/instances.hpp ../../../boost/regex/detail/regex_compile.hpp ../../../boost/regex/detail/regex_cstring.hpp ../../../boost/regex/detail/regex_format.hpp ../../../boost/regex/detail/regex_kmp.hpp ../../../boost/regex/detail/regex_library_include.hpp ../../../boost/regex/detail/regex_match.hpp ../../../boost/regex/detail/regex_raw_buffer.hpp ../../../boost/regex/detail/regex_split.hpp ../../../boost/regex/detail/regex_stack.hpp ../../../boost/regex/detail/regex_synch.hpp
+ALL_HEADER= ../../../boost/regex/config.hpp ../../../boost/regex/pattern_except.hpp ../../../boost/regex/regex_traits.hpp ../../../boost/regex/user.hpp ../../../boost/regex/v3/fileiter.hpp ../../../boost/regex/v3/instances.hpp ../../../boost/regex/v3/regex_compile.hpp ../../../boost/regex/v3/regex_cstring.hpp ../../../boost/regex/v3/regex_format.hpp ../../../boost/regex/v3/regex_kmp.hpp ../../../boost/regex/v3/regex_library_include.hpp ../../../boost/regex/v3/regex_match.hpp ../../../boost/regex/v3/regex_raw_buffer.hpp ../../../boost/regex/v3/regex_split.hpp ../../../boost/regex/v3/regex_stack.hpp ../../../boost/regex/v3/regex_synch.hpp
 
 all : gcc  gcc gcc/boost_regex ./gcc/libboost_regex.a gcc gcc/boost_regex_debug ./gcc/libboost_regex_debug.a
 
@@ -151,3 +151,4 @@ boost_regex_debug_clean :
 	ar -r gcc/libboost_regex_debug.a  gcc/boost_regex_debug/c_regex_traits.o gcc/boost_regex_debug/c_regex_traits_common.o gcc/boost_regex_debug/cpp_regex_traits.o gcc/boost_regex_debug/cregex.o gcc/boost_regex_debug/fileiter.o gcc/boost_regex_debug/instances.o gcc/boost_regex_debug/posix_api.o gcc/boost_regex_debug/regex.o gcc/boost_regex_debug/regex_debug.o gcc/boost_regex_debug/regex_synch.o gcc/boost_regex_debug/w32_regex_traits.o gcc/boost_regex_debug/wide_posix_api.o gcc/boost_regex_debug/winstances.o
 	-ar -s gcc/libboost_regex_debug.a
 
+

build/generic.mak

@@ -26,7 +26,7 @@ C1=-c -O2 -I../../../
 
 
 
-ALL_HEADER= ../../../boost/regex/config.hpp ../../../boost/regex/pattern_except.hpp ../../../boost/regex/regex_traits.hpp ../../../boost/regex/user.hpp ../../../boost/regex/detail/fileiter.hpp ../../../boost/regex/detail/instances.hpp ../../../boost/regex/detail/regex_compile.hpp ../../../boost/regex/detail/regex_cstring.hpp ../../../boost/regex/detail/regex_format.hpp ../../../boost/regex/detail/regex_kmp.hpp ../../../boost/regex/detail/regex_library_include.hpp ../../../boost/regex/detail/regex_match.hpp ../../../boost/regex/detail/regex_raw_buffer.hpp ../../../boost/regex/detail/regex_split.hpp ../../../boost/regex/detail/regex_stack.hpp ../../../boost/regex/detail/regex_synch.hpp
+ALL_HEADER= ../../../boost/regex/config.hpp ../../../boost/regex/pattern_except.hpp ../../../boost/regex/regex_traits.hpp ../../../boost/regex/user.hpp ../../../boost/regex/v3/fileiter.hpp ../../../boost/regex/v3/instances.hpp ../../../boost/regex/v3/regex_compile.hpp ../../../boost/regex/v3/regex_cstring.hpp ../../../boost/regex/v3/regex_format.hpp ../../../boost/regex/v3/regex_kmp.hpp ../../../boost/regex/v3/regex_library_include.hpp ../../../boost/regex/v3/regex_match.hpp ../../../boost/regex/v3/regex_raw_buffer.hpp ../../../boost/regex/v3/regex_split.hpp ../../../boost/regex/v3/regex_stack.hpp ../../../boost/regex/v3/regex_synch.hpp
 
 all : $(DIRNAME)  $(DIRNAME) $(DIRNAME)/boost_regex ./$(DIRNAME)/libboost_regex.so
 
@@ -92,3 +92,4 @@ boost_regex_clean :
 ./$(DIRNAME)/libboost_regex.so : $(DIRNAME)/boost_regex/c_regex_traits.o $(DIRNAME)/boost_regex/c_regex_traits_common.o $(DIRNAME)/boost_regex/cpp_regex_traits.o $(DIRNAME)/boost_regex/cregex.o $(DIRNAME)/boost_regex/fileiter.o $(DIRNAME)/boost_regex/instances.o $(DIRNAME)/boost_regex/posix_api.o $(DIRNAME)/boost_regex/regex.o $(DIRNAME)/boost_regex/regex_debug.o $(DIRNAME)/boost_regex/regex_synch.o $(DIRNAME)/boost_regex/w32_regex_traits.o $(DIRNAME)/boost_regex/wide_posix_api.o $(DIRNAME)/boost_regex/winstances.o
 	$(LINKER) $(LDFLAGS) -o $(DIRNAME)/libboost_regex.so  $(DIRNAME)/boost_regex/c_regex_traits.o $(DIRNAME)/boost_regex/c_regex_traits_common.o $(DIRNAME)/boost_regex/cpp_regex_traits.o $(DIRNAME)/boost_regex/cregex.o $(DIRNAME)/boost_regex/fileiter.o $(DIRNAME)/boost_regex/instances.o $(DIRNAME)/boost_regex/posix_api.o $(DIRNAME)/boost_regex/regex.o $(DIRNAME)/boost_regex/regex_debug.o $(DIRNAME)/boost_regex/regex_synch.o $(DIRNAME)/boost_regex/w32_regex_traits.o $(DIRNAME)/boost_regex/wide_posix_api.o $(DIRNAME)/boost_regex/winstances.o $(LIBS)
 
+

build/sunpro.mak

@@ -34,7 +34,7 @@ SUNWS_CACHE_NAME=SunWS_cache
 
 
 
-ALL_HEADER= ../../../boost/regex/config.hpp ../../../boost/regex/pattern_except.hpp ../../../boost/regex/regex_traits.hpp ../../../boost/regex/user.hpp ../../../boost/regex/detail/fileiter.hpp ../../../boost/regex/detail/instances.hpp ../../../boost/regex/detail/regex_compile.hpp ../../../boost/regex/detail/regex_cstring.hpp ../../../boost/regex/detail/regex_format.hpp ../../../boost/regex/detail/regex_kmp.hpp ../../../boost/regex/detail/regex_library_include.hpp ../../../boost/regex/detail/regex_match.hpp ../../../boost/regex/detail/regex_raw_buffer.hpp ../../../boost/regex/detail/regex_split.hpp ../../../boost/regex/detail/regex_stack.hpp ../../../boost/regex/detail/regex_synch.hpp
+ALL_HEADER= ../../../boost/regex/config.hpp ../../../boost/regex/pattern_except.hpp ../../../boost/regex/regex_traits.hpp ../../../boost/regex/user.hpp ../../../boost/regex/v3/fileiter.hpp ../../../boost/regex/v3/instances.hpp ../../../boost/regex/v3/regex_compile.hpp ../../../boost/regex/v3/regex_cstring.hpp ../../../boost/regex/v3/regex_format.hpp ../../../boost/regex/v3/regex_kmp.hpp ../../../boost/regex/v3/regex_library_include.hpp ../../../boost/regex/v3/regex_match.hpp ../../../boost/regex/v3/regex_raw_buffer.hpp ../../../boost/regex/v3/regex_split.hpp ../../../boost/regex/v3/regex_stack.hpp ../../../boost/regex/v3/regex_synch.hpp
 
 all : sunpro sunpro/libboost_regex$(LIBSUFFIX) sunpro/libboost_regex$(LIBSUFFIX).a sunpro/libboost_regex_mt$(LIBSUFFIX) sunpro/libboost_regex_mt$(LIBSUFFIX).a sunpro/shared_libboost_regex$(LIBSUFFIX) sunpro/libboost_regex$(LIBSUFFIX).so sunpro/shared_libboost_regex_mt$(LIBSUFFIX) sunpro/libboost_regex_mt$(LIBSUFFIX).so
 
@@ -262,3 +262,4 @@ libboost_regex_mt$(LIBSUFFIX)_clean_shared :
 sunpro/libboost_regex_mt$(LIBSUFFIX).so : sunpro/shared_libboost_regex_mt$(LIBSUFFIX)/c_regex_traits.o sunpro/shared_libboost_regex_mt$(LIBSUFFIX)/c_regex_traits_common.o sunpro/shared_libboost_regex_mt$(LIBSUFFIX)/cpp_regex_traits.o sunpro/shared_libboost_regex_mt$(LIBSUFFIX)/cregex.o sunpro/shared_libboost_regex_mt$(LIBSUFFIX)/fileiter.o sunpro/shared_libboost_regex_mt$(LIBSUFFIX)/instances.o sunpro/shared_libboost_regex_mt$(LIBSUFFIX)/posix_api.o sunpro/shared_libboost_regex_mt$(LIBSUFFIX)/regex.o sunpro/shared_libboost_regex_mt$(LIBSUFFIX)/regex_debug.o sunpro/shared_libboost_regex_mt$(LIBSUFFIX)/regex_synch.o sunpro/shared_libboost_regex_mt$(LIBSUFFIX)/w32_regex_traits.o sunpro/shared_libboost_regex_mt$(LIBSUFFIX)/wide_posix_api.o sunpro/shared_libboost_regex_mt$(LIBSUFFIX)/winstances.o
 	CC -KPIC -O2 -mt -I../../../ -G -o sunpro/libboost_regex_mt$(LIBSUFFIX).so $(LDFLAGS)  sunpro/shared_libboost_regex_mt$(LIBSUFFIX)/c_regex_traits.o sunpro/shared_libboost_regex_mt$(LIBSUFFIX)/c_regex_traits_common.o sunpro/shared_libboost_regex_mt$(LIBSUFFIX)/cpp_regex_traits.o sunpro/shared_libboost_regex_mt$(LIBSUFFIX)/cregex.o sunpro/shared_libboost_regex_mt$(LIBSUFFIX)/fileiter.o sunpro/shared_libboost_regex_mt$(LIBSUFFIX)/instances.o sunpro/shared_libboost_regex_mt$(LIBSUFFIX)/posix_api.o sunpro/shared_libboost_regex_mt$(LIBSUFFIX)/regex.o sunpro/shared_libboost_regex_mt$(LIBSUFFIX)/regex_debug.o sunpro/shared_libboost_regex_mt$(LIBSUFFIX)/regex_synch.o sunpro/shared_libboost_regex_mt$(LIBSUFFIX)/w32_regex_traits.o sunpro/shared_libboost_regex_mt$(LIBSUFFIX)/wide_posix_api.o sunpro/shared_libboost_regex_mt$(LIBSUFFIX)/winstances.o $(LIBS)
 
+

build/vc6-stlport.mak

@@ -40,7 +40,7 @@ NULL=nul
 !ENDIF
 
 
-ALL_HEADER= ../../../boost/regex/config.hpp ../../../boost/regex/pattern_except.hpp ../../../boost/regex/regex_traits.hpp ../../../boost/regex/user.hpp ../../../boost/regex/detail/fileiter.hpp ../../../boost/regex/detail/instances.hpp ../../../boost/regex/detail/regex_compile.hpp ../../../boost/regex/detail/regex_cstring.hpp ../../../boost/regex/detail/regex_format.hpp ../../../boost/regex/detail/regex_kmp.hpp ../../../boost/regex/detail/regex_library_include.hpp ../../../boost/regex/detail/regex_match.hpp ../../../boost/regex/detail/regex_raw_buffer.hpp ../../../boost/regex/detail/regex_split.hpp ../../../boost/regex/detail/regex_stack.hpp ../../../boost/regex/detail/regex_synch.hpp
+ALL_HEADER= ../../../boost/regex/config.hpp ../../../boost/regex/pattern_except.hpp ../../../boost/regex/regex_traits.hpp ../../../boost/regex/user.hpp ../../../boost/regex/v3/fileiter.hpp ../../../boost/regex/v3/instances.hpp ../../../boost/regex/v3/regex_compile.hpp ../../../boost/regex/v3/regex_cstring.hpp ../../../boost/regex/v3/regex_format.hpp ../../../boost/regex/v3/regex_kmp.hpp ../../../boost/regex/v3/regex_library_include.hpp ../../../boost/regex/v3/regex_match.hpp ../../../boost/regex/v3/regex_raw_buffer.hpp ../../../boost/regex/v3/regex_split.hpp ../../../boost/regex/v3/regex_stack.hpp ../../../boost/regex/v3/regex_synch.hpp
 
 all : main_dir boost_regex_vc6-stlport_mss_dir ./vc6-stlport/boost_regex_vc6-stlport_mss.lib boost_regex_vc6-stlport_mssd_dir ./vc6-stlport/boost_regex_vc6-stlport_mssd.lib boost_regex_vc6-stlport_mdid_dir ./vc6-stlport/boost_regex_vc6-stlport_mdid.lib boost_regex_vc6-stlport_mdi_dir ./vc6-stlport/boost_regex_vc6-stlport_mdi.lib boost_regex_vc6-stlport_mds_dir ./vc6-stlport/boost_regex_vc6-stlport_mds.lib boost_regex_vc6-stlport_mdsd_dir ./vc6-stlport/boost_regex_vc6-stlport_mdsd.lib boost_regex_vc6-stlport_mdidd_dir ./vc6-stlport/boost_regex_vc6-stlport_mdidd.lib boost_regex_vc6-stlport_mssdd_dir ./vc6-stlport/boost_regex_vc6-stlport_mssdd.lib boost_regex_vc6-stlport_mdsdd_dir ./vc6-stlport/boost_regex_vc6-stlport_mdsdd.lib
 
@@ -574,3 +574,4 @@ boost_regex_vc6-stlport_mdsdd_clean :
 ./vc6-stlport/boost_regex_vc6-stlport_mdsdd.lib : vc6-stlport/boost_regex_vc6-stlport_mdsdd/c_regex_traits.obj vc6-stlport/boost_regex_vc6-stlport_mdsdd/c_regex_traits_common.obj vc6-stlport/boost_regex_vc6-stlport_mdsdd/cpp_regex_traits.obj vc6-stlport/boost_regex_vc6-stlport_mdsdd/cregex.obj vc6-stlport/boost_regex_vc6-stlport_mdsdd/fileiter.obj vc6-stlport/boost_regex_vc6-stlport_mdsdd/instances.obj vc6-stlport/boost_regex_vc6-stlport_mdsdd/posix_api.obj vc6-stlport/boost_regex_vc6-stlport_mdsdd/regex.obj vc6-stlport/boost_regex_vc6-stlport_mdsdd/regex_debug.obj vc6-stlport/boost_regex_vc6-stlport_mdsdd/regex_synch.obj vc6-stlport/boost_regex_vc6-stlport_mdsdd/w32_regex_traits.obj vc6-stlport/boost_regex_vc6-stlport_mdsdd/wide_posix_api.obj vc6-stlport/boost_regex_vc6-stlport_mdsdd/winstances.obj
 	link -lib /nologo /out:vc6-stlport/boost_regex_vc6-stlport_mdsdd.lib $(XSFLAGS)  vc6-stlport/boost_regex_vc6-stlport_mdsdd/c_regex_traits.obj vc6-stlport/boost_regex_vc6-stlport_mdsdd/c_regex_traits_common.obj vc6-stlport/boost_regex_vc6-stlport_mdsdd/cpp_regex_traits.obj vc6-stlport/boost_regex_vc6-stlport_mdsdd/cregex.obj vc6-stlport/boost_regex_vc6-stlport_mdsdd/fileiter.obj vc6-stlport/boost_regex_vc6-stlport_mdsdd/instances.obj vc6-stlport/boost_regex_vc6-stlport_mdsdd/posix_api.obj vc6-stlport/boost_regex_vc6-stlport_mdsdd/regex.obj vc6-stlport/boost_regex_vc6-stlport_mdsdd/regex_debug.obj vc6-stlport/boost_regex_vc6-stlport_mdsdd/regex_synch.obj vc6-stlport/boost_regex_vc6-stlport_mdsdd/w32_regex_traits.obj vc6-stlport/boost_regex_vc6-stlport_mdsdd/wide_posix_api.obj vc6-stlport/boost_regex_vc6-stlport_mdsdd/winstances.obj
 
+

build/vc6.mak

@@ -36,7 +36,7 @@ NULL=nul
 !ENDIF
 
 
-ALL_HEADER= ../../../boost/regex/config.hpp ../../../boost/regex/pattern_except.hpp ../../../boost/regex/regex_traits.hpp ../../../boost/regex/user.hpp ../../../boost/regex/detail/fileiter.hpp ../../../boost/regex/detail/instances.hpp ../../../boost/regex/detail/regex_compile.hpp ../../../boost/regex/detail/regex_cstring.hpp ../../../boost/regex/detail/regex_format.hpp ../../../boost/regex/detail/regex_kmp.hpp ../../../boost/regex/detail/regex_library_include.hpp ../../../boost/regex/detail/regex_match.hpp ../../../boost/regex/detail/regex_raw_buffer.hpp ../../../boost/regex/detail/regex_split.hpp ../../../boost/regex/detail/regex_stack.hpp ../../../boost/regex/detail/regex_synch.hpp
+ALL_HEADER= ../../../boost/regex/config.hpp ../../../boost/regex/pattern_except.hpp ../../../boost/regex/regex_traits.hpp ../../../boost/regex/user.hpp ../../../boost/regex/v3/fileiter.hpp ../../../boost/regex/v3/instances.hpp ../../../boost/regex/v3/regex_compile.hpp ../../../boost/regex/v3/regex_cstring.hpp ../../../boost/regex/v3/regex_format.hpp ../../../boost/regex/v3/regex_kmp.hpp ../../../boost/regex/v3/regex_library_include.hpp ../../../boost/regex/v3/regex_match.hpp ../../../boost/regex/v3/regex_raw_buffer.hpp ../../../boost/regex/v3/regex_split.hpp ../../../boost/regex/v3/regex_stack.hpp ../../../boost/regex/v3/regex_synch.hpp
 
 all : main_dir boost_regex_vc6_sss_dir ./vc6/boost_regex_vc6_sss.lib boost_regex_vc6_mss_dir ./vc6/boost_regex_vc6_mss.lib boost_regex_vc6_sssd_dir ./vc6/boost_regex_vc6_sssd.lib boost_regex_vc6_mssd_dir ./vc6/boost_regex_vc6_mssd.lib boost_regex_vc6_mdid_dir ./vc6/boost_regex_vc6_mdid.lib boost_regex_vc6_mdi_dir ./vc6/boost_regex_vc6_mdi.lib boost_regex_vc6_mds_dir ./vc6/boost_regex_vc6_mds.lib boost_regex_vc6_mdsd_dir ./vc6/boost_regex_vc6_mdsd.lib
 
@@ -510,3 +510,5 @@ boost_regex_vc6_mdsd_clean :
 ./vc6/boost_regex_vc6_mdsd.lib : vc6/boost_regex_vc6_mdsd/c_regex_traits.obj vc6/boost_regex_vc6_mdsd/c_regex_traits_common.obj vc6/boost_regex_vc6_mdsd/cpp_regex_traits.obj vc6/boost_regex_vc6_mdsd/cregex.obj vc6/boost_regex_vc6_mdsd/fileiter.obj vc6/boost_regex_vc6_mdsd/instances.obj vc6/boost_regex_vc6_mdsd/posix_api.obj vc6/boost_regex_vc6_mdsd/regex.obj vc6/boost_regex_vc6_mdsd/regex_debug.obj vc6/boost_regex_vc6_mdsd/regex_synch.obj vc6/boost_regex_vc6_mdsd/w32_regex_traits.obj vc6/boost_regex_vc6_mdsd/wide_posix_api.obj vc6/boost_regex_vc6_mdsd/winstances.obj
 	link -lib /nologo /out:vc6/boost_regex_vc6_mdsd.lib $(XSFLAGS)  vc6/boost_regex_vc6_mdsd/c_regex_traits.obj vc6/boost_regex_vc6_mdsd/c_regex_traits_common.obj vc6/boost_regex_vc6_mdsd/cpp_regex_traits.obj vc6/boost_regex_vc6_mdsd/cregex.obj vc6/boost_regex_vc6_mdsd/fileiter.obj vc6/boost_regex_vc6_mdsd/instances.obj vc6/boost_regex_vc6_mdsd/posix_api.obj vc6/boost_regex_vc6_mdsd/regex.obj vc6/boost_regex_vc6_mdsd/regex_debug.obj vc6/boost_regex_vc6_mdsd/regex_synch.obj vc6/boost_regex_vc6_mdsd/w32_regex_traits.obj vc6/boost_regex_vc6_mdsd/wide_posix_api.obj vc6/boost_regex_vc6_mdsd/winstances.obj
 
+
+

build/vc7.mak

@@ -36,7 +36,7 @@ NULL=nul
 !ENDIF
 
 
-ALL_HEADER= ../../../boost/regex/config.hpp ../../../boost/regex/pattern_except.hpp ../../../boost/regex/regex_traits.hpp ../../../boost/regex/user.hpp ../../../boost/regex/detail/fileiter.hpp ../../../boost/regex/detail/instances.hpp ../../../boost/regex/detail/regex_compile.hpp ../../../boost/regex/detail/regex_cstring.hpp ../../../boost/regex/detail/regex_format.hpp ../../../boost/regex/detail/regex_kmp.hpp ../../../boost/regex/detail/regex_library_include.hpp ../../../boost/regex/detail/regex_match.hpp ../../../boost/regex/detail/regex_raw_buffer.hpp ../../../boost/regex/detail/regex_split.hpp ../../../boost/regex/detail/regex_stack.hpp ../../../boost/regex/detail/regex_synch.hpp
+ALL_HEADER= ../../../boost/regex/config.hpp ../../../boost/regex/pattern_except.hpp ../../../boost/regex/regex_traits.hpp ../../../boost/regex/user.hpp ../../../boost/regex/v3/fileiter.hpp ../../../boost/regex/v3/instances.hpp ../../../boost/regex/v3/regex_compile.hpp ../../../boost/regex/v3/regex_cstring.hpp ../../../boost/regex/v3/regex_format.hpp ../../../boost/regex/v3/regex_kmp.hpp ../../../boost/regex/v3/regex_library_include.hpp ../../../boost/regex/v3/regex_match.hpp ../../../boost/regex/v3/regex_raw_buffer.hpp ../../../boost/regex/v3/regex_split.hpp ../../../boost/regex/v3/regex_stack.hpp ../../../boost/regex/v3/regex_synch.hpp
 
 all : main_dir boost_regex_vc7_sss_dir ./vc7/boost_regex_vc7_sss.lib boost_regex_vc7_mss_dir ./vc7/boost_regex_vc7_mss.lib boost_regex_vc7_sssd_dir ./vc7/boost_regex_vc7_sssd.lib boost_regex_vc7_mssd_dir ./vc7/boost_regex_vc7_mssd.lib boost_regex_vc7_mdid_dir ./vc7/boost_regex_vc7_mdid.lib boost_regex_vc7_mdi_dir ./vc7/boost_regex_vc7_mdi.lib boost_regex_vc7_mds_dir ./vc7/boost_regex_vc7_mds.lib boost_regex_vc7_mdsd_dir ./vc7/boost_regex_vc7_mdsd.lib
 
@@ -510,3 +510,4 @@ boost_regex_vc7_mdsd_clean :
 ./vc7/boost_regex_vc7_mdsd.lib : vc7/boost_regex_vc7_mdsd/c_regex_traits.obj vc7/boost_regex_vc7_mdsd/c_regex_traits_common.obj vc7/boost_regex_vc7_mdsd/cpp_regex_traits.obj vc7/boost_regex_vc7_mdsd/cregex.obj vc7/boost_regex_vc7_mdsd/fileiter.obj vc7/boost_regex_vc7_mdsd/instances.obj vc7/boost_regex_vc7_mdsd/posix_api.obj vc7/boost_regex_vc7_mdsd/regex.obj vc7/boost_regex_vc7_mdsd/regex_debug.obj vc7/boost_regex_vc7_mdsd/regex_synch.obj vc7/boost_regex_vc7_mdsd/w32_regex_traits.obj vc7/boost_regex_vc7_mdsd/wide_posix_api.obj vc7/boost_regex_vc7_mdsd/winstances.obj
 	link -lib /nologo /out:vc7/boost_regex_vc7_mdsd.lib $(XSFLAGS)  vc7/boost_regex_vc7_mdsd/c_regex_traits.obj vc7/boost_regex_vc7_mdsd/c_regex_traits_common.obj vc7/boost_regex_vc7_mdsd/cpp_regex_traits.obj vc7/boost_regex_vc7_mdsd/cregex.obj vc7/boost_regex_vc7_mdsd/fileiter.obj vc7/boost_regex_vc7_mdsd/instances.obj vc7/boost_regex_vc7_mdsd/posix_api.obj vc7/boost_regex_vc7_mdsd/regex.obj vc7/boost_regex_vc7_mdsd/regex_debug.obj vc7/boost_regex_vc7_mdsd/regex_synch.obj vc7/boost_regex_vc7_mdsd/w32_regex_traits.obj vc7/boost_regex_vc7_mdsd/wide_posix_api.obj vc7/boost_regex_vc7_mdsd/winstances.obj
 
+

example/Jamfile

@@ -4,195 +4,45 @@ subproject libs/regex/example ;
 SEARCH on testing.jam = $(BOOST_BUILD_PATH) ;
 include testing.jam ;
 
-run timer/regex_timer.cpp 
-   <lib>../build/boost_regex$(SUFLIB) 
-	:
-		timer/input_script.txt
-	: 
-	:
-		<sysinclude>../../../
-		<define>BOOST_REGEX_NO_LIB=1
-		<define>BOOST_REGEX_STATIC_LINK=1
-	:
-		regex_timer
-	;
-
-run jgrep/jgrep.cpp jgrep/main.cpp
-   <lib>../build/boost_regex$(SUFLIB) 
-	: 
-		-n boost/ ../../../boost/regex.hpp
-	:
-	: 
-		<sysinclude>../../../
-		<define>BOOST_REGEX_NO_LIB=1
-		<define>BOOST_REGEX_STATIC_LINK=1
-	:
-		jgrep
-	;
-
-run snippets/credit_card_example.cpp
-   <lib>../build/boost_regex$(SUFLIB) 
-	: 
-	:
-	:
-		<sysinclude>../../../
-		<define>BOOST_REGEX_NO_LIB=1
-		<define>BOOST_REGEX_STATIC_LINK=1
-	:
-		credit_card_example
-	;
-
-
-run snippets/partial_regex_grep.cpp
-   <lib>../build/boost_regex$(SUFLIB) 
-	: 
-		../index.htm
-	:
-	:
-		<sysinclude>../../../
-		<define>BOOST_REGEX_NO_LIB=1
-		<define>BOOST_REGEX_STATIC_LINK=1
-	:
-		partial_regex_grep
-	;
-
-run snippets/partial_regex_match.cpp
-   <lib>../build/boost_regex$(SUFLIB) 
-	: 
-		1234-5678-8765-4
-	:
-	:
-		<sysinclude>../../../
-		<define>BOOST_REGEX_NO_LIB=1
-		<define>BOOST_REGEX_STATIC_LINK=1
-	:
-		partial_regex_match
-	;
-
-run snippets/regex_grep_example_1.cpp
-   <lib>../build/boost_regex$(SUFLIB) 
-	:
-		../../../boost/rational.hpp
-	: 
-	:
-		<sysinclude>../../../
-		<define>BOOST_REGEX_NO_LIB=1
-		<define>BOOST_REGEX_STATIC_LINK=1
-	: 
-		regex_grep_example_1
-	;
-
-run snippets/regex_grep_example_2.cpp
-   <lib>../build/boost_regex$(SUFLIB) 
-	:
-		../../../boost/rational.hpp
-	: 
-	:
-		<sysinclude>../../../
-		<define>BOOST_REGEX_NO_LIB=1
-		<define>BOOST_REGEX_STATIC_LINK=1
-	: 
-		regex_grep_example_2
-	;
-
-run snippets/regex_grep_example_3.cpp
-   <lib>../build/boost_regex$(SUFLIB) 
-	:
-		../../../boost/rational.hpp
-	: 
-	:
-		<sysinclude>../../../
-		<define>BOOST_REGEX_NO_LIB=1
-		<define>BOOST_REGEX_STATIC_LINK=1
-	: 
-		regex_grep_example_3
-	;
-
-run snippets/regex_grep_example_4.cpp
-   <lib>../build/boost_regex$(SUFLIB) 
-	:
-		../../../boost/rational.hpp
-	: 
-	:
-		<sysinclude>../../../
-		<define>BOOST_REGEX_NO_LIB=1
-		<define>BOOST_REGEX_STATIC_LINK=1
-	: 
-		regex_grep_example_4
-	;
-
-run snippets/regex_match_example.cpp
-   <lib>../build/boost_regex$(SUFLIB) 
-	:
-		-auto
-	: 
-	:
-		<sysinclude>../../../
-		<define>BOOST_REGEX_NO_LIB=1
-		<define>BOOST_REGEX_STATIC_LINK=1
-	: 
-		regex_match_example
-	;
-
-run snippets/regex_merge_example.cpp
-   <lib>../build/boost_regex$(SUFLIB) 
-	:
-		../../../boost/rational.hpp
-	: 
-	:
-		<sysinclude>../../../
-		<define>BOOST_REGEX_NO_LIB=1
-		<define>BOOST_REGEX_STATIC_LINK=1
-	: 
-		regex_merge_example
-	;
-
-run snippets/regex_search_example.cpp
-   <lib>../build/boost_regex$(SUFLIB) 
-	:
-		../../../boost/rational.hpp
-	: 
-	:
-		<sysinclude>../../../
-		<define>BOOST_REGEX_NO_LIB=1
-		<define>BOOST_REGEX_STATIC_LINK=1
-	: 
-		regex_search_example
-	;
-
-run snippets/regex_split_example_1.cpp
-   <lib>../build/boost_regex$(SUFLIB) 
-	:
-		-auto
-	: 
-	:
-		<sysinclude>../../../
-		<define>BOOST_REGEX_NO_LIB=1
-		<define>BOOST_REGEX_STATIC_LINK=1
-	: 
-		regex_split_example_1
-	;
-
-run snippets/regex_split_example_2.cpp
-   <lib>../build/boost_regex$(SUFLIB) 
-	:
-		../index.htm
-	: 
-	:
-		<sysinclude>../../../
-		<define>BOOST_REGEX_NO_LIB=1
-		<define>BOOST_REGEX_STATIC_LINK=1
-	: 
-		regex_split_example_2
-	;
-
-
-
-
+rule regex-test-run ( sources + : input * )
+{
+        return [ 
+           run
+             # sources
+             $(sources)
 
+             # dependencies
+             <lib>../build/boost_regex
+         :  # additional args
+            $(input)
+         :  # test-files
+         :  # requirements
+			<sysinclude>../../../
+			<define>BOOST_REGEX_NO_LIB=1
+			<define>BOOST_REGEX_STATIC_LINK=1
+			<threading>multi
+         :  # test name
+        ] ;
+}
 
+test-suite regex-examples :
 
+[ regex-test-run timer/regex_timer.cpp : $(BOOST_ROOT)/libs/regex/example/timer/input_script.txt ]
+[ regex-test-run jgrep/jgrep.cpp jgrep/main.cpp : -n boost/ $(BOOST_ROOT)/boost/regex.hpp ]
+[ regex-test-run snippets/credit_card_example.cpp ]
+[ regex-test-run snippets/partial_regex_grep.cpp : $(BOOST_ROOT)/libs/regex/index.htm ]
+[ regex-test-run snippets/partial_regex_match.cpp : 1234-5678-8765-4 ]
+[ regex-test-run snippets/regex_grep_example_1.cpp : $(BOOST_ROOT)/boost/rational.hpp ]
+[ regex-test-run snippets/regex_grep_example_2.cpp : $(BOOST_ROOT)/boost/rational.hpp ]
+[ regex-test-run snippets/regex_grep_example_3.cpp : $(BOOST_ROOT)/boost/rational.hpp ]
+[ regex-test-run snippets/regex_grep_example_4.cpp : $(BOOST_ROOT)/boost/rational.hpp ]
+[ regex-test-run snippets/regex_match_example.cpp : -auto ]
+[ regex-test-run snippets/regex_merge_example.cpp : $(BOOST_ROOT)/boost/rational.hpp ]
+[ regex-test-run snippets/regex_search_example.cpp : $(BOOST_ROOT)/boost/rational.hpp ]
+[ regex-test-run snippets/regex_split_example_1.cpp : -auto ]
+[ regex-test-run snippets/regex_split_example_2.cpp : $(BOOST_ROOT)/libs/regex/index.htm ]
 
+;
 
 
 

example/jgrep/jgrep.cpp

@@ -33,7 +33,7 @@ using std::endl;
 #  pragma hrdstop
 #endif
 
-#include <boost/regex/detail/fileiter.hpp>
+#include <boost/regex/v3/fileiter.hpp>
 
 #include "jgrep.h"
 
@@ -137,3 +137,4 @@ void process_grep(const char* file)
 
 
 
+

example/jgrep/main.cpp

@@ -34,7 +34,7 @@ using std::endl;
 #  pragma hrdstop
 #endif
 
-#include <boost/regex/detail/fileiter.hpp>
+#include <boost/regex/v3/fileiter.hpp>
 #include "jgrep.h"
 
 #ifndef JM_ALGO_INCLUDED
@@ -286,3 +286,4 @@ int main(int argc, char * argv[])
 
 
 
+

example/timer/regex_timer.cpp

@@ -13,6 +13,11 @@
  *
  */
 
+#include <string>
+#include <algorithm>
+#include <deque>
+#include <iterator>
+
 #ifdef BOOST_RE_OLD_IOSTREAM
 #include <iostream.h>
 #include <fstream.h>
@@ -27,19 +32,16 @@ using std::ostream;
 using std::endl;
 using std::ifstream;
 using std::streambuf;
+using std::getline;
 #endif
 
-#include <algorithm>
-#include <string>
-#include <deque>
-#include <iterator>
 #include <boost/config.hpp>
 #include <boost/regex.hpp>
 #include <boost/timer.hpp> 
 #include <boost/smart_ptr.hpp>
 
-#ifdef BOOST_MSVC
-// no Koenig lookup, use using declaration instead:
+#if defined(_MSC_VER) && (_MSC_VER <= 1300)
+// maybe no Koenig lookup, use using declaration instead:
 using namespace boost;
 #endif
 
@@ -360,3 +362,5 @@ int main(int argc, char**argv)
 
 
 
+
+

faq.htm

@@ -1,205 +0,0 @@
-<html>
-
-<head>
-<meta http-equiv="Content-Type"
-content="text/html; charset=iso-8859-1">
-<meta name="Template"
-content="C:\PROGRAM FILES\MICROSOFT OFFICE\OFFICE\html.dot">
-<meta name="GENERATOR" content="Microsoft FrontPage Express 2.0">
-<title>Regex++ - FAQ</title>
-</head>
-
-<body bgcolor="#FFFFFF" link="#0000FF" vlink="#800080">
-
-<p>&nbsp; </p>
-
-<table border="0" cellpadding="7" cellspacing="0" width="100%">
-    <tr>
-        <td valign="top"><h3><img src="../../c++boost.gif"
-        alt="C++ Boost" width="276" height="86"></h3>
-        </td>
-        <td valign="top"><h3 align="center">Regex++, FAQ.</h3>
-        <p align="left"><i>Copyright (c) 1998-2001 </i></p>
-        <p align="left"><i>Dr John Maddock</i></p>
-        <p align="left"><i>Permission to use, copy, modify,
-        distribute and sell this software and its documentation
-        for any purpose is hereby granted without fee, provided
-        that the above copyright notice appear in all copies and
-        that both that copyright notice and this permission
-        notice appear in supporting documentation. Dr John
-        Maddock makes no representations about the suitability of
-        this software for any purpose. It is provided &quot;as is&quot;
-        without express or implied warranty.</i></p>
-        </td>
-    </tr>
-</table>
-
-<p><font color="#FF0000">Q. Why does using parenthesis in a
-regular expression change the result of a match?</font></p>
-
-<p>Parentheses don't only mark; they determine what the best
-match is as well. regex++ tries to follow the POSIX standard
-leftmost longest rule for determining what matched. So if there
-is more than one possible match after considering the whole
-expression, it looks next at the first sub-expression and then
-the second sub-expression and so on. So...</p>
-
-<pre>&quot;(0*)([0-9]*)&quot; against &quot;00123&quot; would produce
-$1 = &quot;00&quot;
-$2 = &quot;123&quot;</pre>
-
-<p>where as</p>
-
-<pre>&quot;0*([0-9)*&quot; against &quot;00123&quot; would produce
-$1 = &quot;00123&quot;</pre>
-
-<p>If you think about it, had $1 only matched the &quot;123&quot;,
-this would be &quot;less good&quot; than the match &quot;00123&quot;
-which is both further to the left and longer. If you want $1 to
-match only the &quot;123&quot; part, then you need to use
-something like:</p>
-
-<pre>&quot;0*([1-9][0-9]*)&quot;</pre>
-
-<p>as the expression.</p>
-
-<p><font color="#FF0000">Q. Configure says that my compiler is
-unable to merge template instances, what does this mean?</font> </p>
-
-<p>A. When you compile template code, you can end up with the
-same template instances in multiple translation units - this will
-lead to link time errors unless your compiler/linker is smart
-enough to merge these template instances into a single record in
-the executable file. If you see this warning after running
-configure, then you can still link to libregex++.a if: </p>
-
-<ol>
-    <li>You use only the low-level template classes (reg_expression&lt;&gt;
-        match_results&lt;&gt; etc), from a single translation
-        unit, and use no other part of regex++.</li>
-    <li>You use only the POSIX API functions (regcomp regexec etc),
-        and no other part of regex++.</li>
-    <li>You use only the high level class RegEx, and no other
-        part of regex++. </li>
-</ol>
-
-<p>Another option is to create a master include file, which
-#include's all the regex++ source files, and all the source files
-in which you use regex++. You then compile and link this master
-file as a single translation unit. </p>
-
-<p><font color="#FF0000">Q. Configure says that my compiler is
-unable to merge template instances from archive files, what does
-this mean?</font> </p>
-
-<p>A. When you compile template code, you can end up with the
-same template instances in multiple translation units - this will
-lead to link time errors unless your compiler/linker is smart
-enough to merge these template instances into a single record in
-the executable file. Some compilers are able to do this for
-normal .cpp or .o files, but fail if the object file has been
-placed in a library archive. If you see this warning after
-running configure, then you can still link to libregex++.a if: </p>
-
-<ol>
-    <li>You use only the low-level template classes (reg_expression&lt;&gt;
-        match_results&lt;&gt; etc), and use no other part of
-        regex++.</li>
-    <li>You use only the POSIX API functions (regcomp regexec etc),
-        and no other part of regex++.</li>
-    <li>You use only the high level class RegEx, and no other
-        part of regex++. </li>
-</ol>
-
-<p>Another option is to add the regex++ source files directly to
-your project instead of linking to libregex++.a, generally you
-should do this only if you are getting link time errors with
-libregex++.a. </p>
-
-<p><font color="#FF0000">Q. Configure says that my compiler can't
-merge templates containing switch statements, what does this
-mean?</font> </p>
-
-<p>A. Some compilers can't merge templates that contain static
-data - this includes switch statements which implicitly generate
-static data as well as code. Principally this affects the egcs
-compiler - but note gcc 2.81 also suffers from this problem - the
-compiler will compile and link the code - but the code will not
-run because the code and the static data it uses have become
-separated. The default behaviour of regex++ is to try and fix
-this problem by declaring &quot;problem&quot; templates inside
-unnamed namespaces, so that the templates have internal linkage.
-Note that this can result in a great deal of code bloat. If the
-compiler doesn't support namespaces, or if code bloat becomes a
-problem, then follow the guidelines above for placing all the
-templates used in a single translation unit, and edit boost/regex/config.hpp
-so that BOOST_REGEX_NO_TEMPLATE_SWITCH_MERGE is no longer defined.
-</p>
-
-<p><font color="#FF0000">Q. I can't get regex++ to work with
-escape characters, what's going on?</font> </p>
-
-<p>A. If you embed regular expressions in C++ code, then remember
-that escape characters are processed twice: once by the C++
-compiler, and once by the regex++ expression compiler, so to pass
-the regular expression \d+ to regex++, you need to embed &quot;\\d+&quot;
-in your code. Likewise to match a literal backslash you will need
-to embed &quot;\\\\&quot; in your code. </p>
-
-<p><font color="#FF0000">Q. Why don't character ranges work
-properly?</font> <br>
-A. The POSIX standard specifies that character range expressions
-are locale sensitive - so for example the expression [A-Z] will
-match any collating element that collates between 'A' and 'Z'.
-That means that for most locales other than &quot;C&quot; or
-&quot;POSIX&quot;, [A-Z] would match the single character 't' for
-example, which is not what most people expect - or at least not
-what most people have come to expect from regular expression
-engines. For this reason, the default behaviour of regex++ is to
-turn locale sensitive collation off by setting the regbase::nocollate
-compile time flag (this is set by regbase::normal). However if
-you set a non-default compile time flag - for example regbase::extended
-or regbase::basic, then locale dependent collation will be
-enabled, this also applies to the POSIX API functions which use
-either regbase::extended or regbase::basic internally, in the
-latter case use REG_NOCOLLATE in combination with either
-REG_BASIC or REG_EXTENDED when invoking regcomp if you don't want
-locale sensitive collation. <i>[Note - when regbase::nocollate in
-effect, the library behaves &quot;as if&quot; the LC_COLLATE
-locale category were always &quot;C&quot;, regardless of what its
-actually set to - end note</i>]. </p>
-
-<p><font color="#FF0000">&nbsp;Q. Why can't I use the &quot;convenience&quot;
-versions of query_match/reg_search/reg_grep/reg_format/reg_merge?</font>
-</p>
-
-<p>A. These versions may or may not be available depending upon
-the capabilities of your compiler, the rules determining the
-format of these functions are quite complex - and only the
-versions visible to a standard compliant compiler are given in
-the help. To find out what your compiler supports, run &lt;boost/regex.hpp&gt;
-through your C++ pre-processor, and search the output file for
-the function that you are interested in. </p>
-
-<p><font color="#FF0000">Q. Why are there no throw specifications
-on any of the functions? What exceptions can the library throw?</font>
-</p>
-
-<p>A. Not all compilers support (or honor) throw specifications,
-others support them but with reduced efficiency. Throw
-specifications may be added at a later date as compilers begin to
-handle this better. The library should throw only three types of
-exception: boost::bad_expression can be thrown by reg_expression
-when compiling a regular expression, std::runtime_error can be
-thrown when a call to reg_expression::imbue tries to open a
-message catalogue that doesn't exist or when a call to RegEx::GrepFiles
-or RegEx::FindFiles tries to open a file that cannot be opened,
-finally std::bad_alloc can be thrown by just about any of the
-functions in this library. </p>
-
-<hr>
-
-<p><i>Copyright </i><a href="mailto:John_Maddock@compuserve.com"><i>Dr
-John Maddock</i></a><i> 1998-2000 all rights reserved.</i> </p>
-</body>
-</html>

format_string.htm

@@ -1,243 +0,0 @@
-<html>
-
-<head>
-<meta http-equiv="Content-Type"
-content="text/html; charset=iso-8859-1">
-<meta name="Template"
-content="C:\PROGRAM FILES\MICROSOFT OFFICE\OFFICE\html.dot">
-<meta name="GENERATOR" content="Microsoft FrontPage Express 2.0">
-<title>Regex++, Format String Reference</title>
-</head>
-
-<body bgcolor="#FFFFFF" link="#0000FF" vlink="#800080">
-
-<p>&nbsp; </p>
-
-<table border="0" cellpadding="7" cellspacing="0" width="100%">
-    <tr>
-        <td valign="top"><h3><img src="../../c++boost.gif"
-        alt="C++ Boost" width="276" height="86"></h3>
-        </td>
-        <td valign="top"><h3 align="center">Regex++, Format
-        String Reference.</h3>
-        <p align="left"><i>Copyright (c) 1998-2001 </i></p>
-        <p align="left"><i>Dr John Maddock</i></p>
-        <p align="left"><i>Permission to use, copy, modify,
-        distribute and sell this software and its documentation
-        for any purpose is hereby granted without fee, provided
-        that the above copyright notice appear in all copies and
-        that both that copyright notice and this permission
-        notice appear in supporting documentation. Dr John
-        Maddock makes no representations about the suitability of
-        this software for any purpose. It is provided &quot;as is&quot;
-        without express or implied warranty.</i></p>
-        </td>
-    </tr>
-</table>
-
-<hr>
-
-<h3><a name="format_string"></a>Format String Syntax</h3>
-
-<p>Format strings are used by the algorithms <a
-href="template_class_ref.htm#reg_format">regex_format</a> and <a
-href="template_class_ref.htm#reg_merge">regex_merge</a>, and are
-used to transform one string into another. </p>
-
-<p>There are three kind of format string: sed, perl and extended,
-the extended syntax is the default so this is covered first. </p>
-
-<p><b><i>Extended format syntax</i></b> </p>
-
-<p>In format strings, all characters are treated as literals
-except: ()$\?: </p>
-
-<p>To use any of these as literals you must prefix them with the
-escape character \ </p>
-
-<p>The following special sequences are recognized: <br>
-&nbsp; <br>
-&nbsp; </p>
-
-<p><i>Grouping:</i> </p>
-
-<p>Use the parenthesis characters ( and ) to group sub-expressions
-within the format string, use \( and \) to represent literal '('
-and ')'. <br>
-&nbsp; <br>
-&nbsp; </p>
-
-<p><i>Sub-expression expansions:</i> </p>
-
-<p>The following perl like expressions expand to a particular
-matched sub-expression: <br>
-&nbsp; </p>
-
-<table border="0" cellpadding="7" cellspacing="0" width="100%">
-    <tr>
-        <td valign="top" width="8%">&nbsp;</td>
-        <td valign="top" width="40%">$`</td>
-        <td valign="top" width="43%">Expands to all the text from
-        the end of the previous match to the start of the current
-        match, if there was no previous match in the current
-        operation, then everything from the start of the input
-        string to the start of the match.</td>
-        <td valign="top" width="9%">&nbsp;</td>
-    </tr>
-    <tr>
-        <td valign="top" width="8%">&nbsp;</td>
-        <td valign="top" width="40%">$'</td>
-        <td valign="top" width="43%">Expands to all the text from
-        the end of the match to the end of the input string.</td>
-        <td valign="top" width="9%">&nbsp;</td>
-    </tr>
-    <tr>
-        <td valign="top" width="8%">&nbsp;</td>
-        <td valign="top" width="40%">$&amp;</td>
-        <td valign="top" width="43%">Expands to all of the
-        current match.</td>
-        <td valign="top" width="9%">&nbsp;</td>
-    </tr>
-    <tr>
-        <td valign="top" width="8%">&nbsp;</td>
-        <td valign="top" width="40%">$0</td>
-        <td valign="top" width="43%">Expands to all of the
-        current match.</td>
-        <td valign="top" width="9%">&nbsp;</td>
-    </tr>
-    <tr>
-        <td valign="top" width="8%">&nbsp;</td>
-        <td valign="top" width="40%">$N</td>
-        <td valign="top" width="43%">Expands to the text that
-        matched sub-expression <i>N</i>.</td>
-        <td valign="top" width="9%">&nbsp;</td>
-    </tr>
-</table>
-
-<p><br>
-&nbsp; </p>
-
-<p><i>Conditional expressions:</i> </p>
-
-<p>Conditional expressions allow two different format strings to
-be selected dependent upon whether a sub-expression participated
-in the match or not: </p>
-
-<p>?Ntrue_expression:false_expression </p>
-
-<p>Executes true_expression if sub-expression <i>N</i>
-participated in the match, otherwise executes false_expression. </p>
-
-<p>Example: suppose we search for &quot;(while)|(for)&quot; then
-the format string &quot;?1WHILE:FOR&quot; would output what
-matched, but in upper case. <br>
-&nbsp; <br>
-&nbsp; </p>
-
-<p><i>Escape sequences:</i> </p>
-
-<p>The following escape sequences are also allowed: <br>
-&nbsp; </p>
-
-<table border="0" cellpadding="7" cellspacing="0" width="100%">
-    <tr>
-        <td valign="top" width="8%">&nbsp;</td>
-        <td valign="top" width="40%">\a</td>
-        <td valign="top" width="43%">The bell character.</td>
-        <td valign="top" width="9%">&nbsp;</td>
-    </tr>
-    <tr>
-        <td valign="top" width="8%">&nbsp;</td>
-        <td valign="top" width="40%">\f</td>
-        <td valign="top" width="43%">The form feed character.</td>
-        <td valign="top" width="9%">&nbsp;</td>
-    </tr>
-    <tr>
-        <td valign="top" width="8%">&nbsp;</td>
-        <td valign="top" width="40%">\n</td>
-        <td valign="top" width="43%">The newline character.</td>
-        <td valign="top" width="9%">&nbsp;</td>
-    </tr>
-    <tr>
-        <td valign="top" width="8%">&nbsp;</td>
-        <td valign="top" width="40%">\r</td>
-        <td valign="top" width="43%">The carriage return
-        character.</td>
-        <td valign="top" width="9%">&nbsp;</td>
-    </tr>
-    <tr>
-        <td valign="top" width="8%">&nbsp;</td>
-        <td valign="top" width="40%">\t</td>
-        <td valign="top" width="43%">The tab character.</td>
-        <td valign="top" width="9%">&nbsp;</td>
-    </tr>
-    <tr>
-        <td valign="top" width="8%">&nbsp;</td>
-        <td valign="top" width="40%">\v</td>
-        <td valign="top" width="43%">A vertical tab character.</td>
-        <td valign="top" width="9%">&nbsp;</td>
-    </tr>
-    <tr>
-        <td valign="top" width="8%">&nbsp;</td>
-        <td valign="top" width="40%">\x</td>
-        <td valign="top" width="43%">A hexadecimal character -
-        for example \x0D.</td>
-        <td valign="top" width="9%">&nbsp;</td>
-    </tr>
-    <tr>
-        <td valign="top" width="8%">&nbsp;</td>
-        <td valign="top" width="40%">\x{}</td>
-        <td valign="top" width="43%">A possible unicode
-        hexadecimal character - for example \x{1A0}</td>
-        <td valign="top" width="9%">&nbsp;</td>
-    </tr>
-    <tr>
-        <td valign="top" width="8%">&nbsp;</td>
-        <td valign="top" width="40%">\cx</td>
-        <td valign="top" width="43%">The ASCII escape character
-        x, for example \c@ is equivalent to escape-@.</td>
-        <td valign="top" width="9%">&nbsp;</td>
-    </tr>
-    <tr>
-        <td valign="top" width="8%">&nbsp;</td>
-        <td valign="top" width="40%">\e</td>
-        <td valign="top" width="43%">The ASCII escape character.</td>
-        <td valign="top" width="9%">&nbsp;</td>
-    </tr>
-    <tr>
-        <td valign="top" width="8%">&nbsp;</td>
-        <td valign="top" width="40%">\dd</td>
-        <td valign="top" width="43%">An octal character constant,
-        for example \10.</td>
-        <td valign="top" width="9%">&nbsp;</td>
-    </tr>
-</table>
-
-<p><br>
-&nbsp; </p>
-
-<p><b><i>Perl format strings</i></b> </p>
-
-<p>Perl format strings are the same as the default syntax except
-that the characters ()?: have no special meaning. </p>
-
-<p><b><i>Sed format strings</i></b> </p>
-
-<p>Sed format strings use only the characters \ and &amp; as
-special characters. </p>
-
-<p>\n where n is a digit, is expanded to the nth sub-expression. </p>
-
-<p>&amp; is expanded to the whole of the match (equivalent to \0).
-</p>
-
-<p>Other escape sequences are expanded as per the default syntax.
-<br>
-</p>
-
-<hr>
-
-<p><i>Copyright </i><a href="mailto:John_Maddock@compuserve.com"><i>Dr
-John Maddock</i></a><i> 1998-2000 all rights reserved.</i> </p>
-</body>
-</html>

hl_ref.htm

@@ -1,572 +0,0 @@
-<html>
-
-<head>
-<meta http-equiv="Content-Type"
-content="text/html; charset=iso-8859-1">
-<meta name="Template"
-content="C:\PROGRAM FILES\MICROSOFT OFFICE\OFFICE\html.dot">
-<meta name="GENERATOR" content="Microsoft FrontPage Express 2.0">
-<title>Regex++, RegEx Class Reference</title>
-</head>
-
-<body bgcolor="#FFFFFF" link="#0000FF" vlink="#800080">
-
-<p>&nbsp; </p>
-
-<table border="0" cellpadding="7" cellspacing="0" width="100%">
-    <tr>
-        <td valign="top"><h3><img src="../../c++boost.gif"
-        alt="C++ Boost" width="276" height="86"></h3>
-        </td>
-        <td valign="top"><h3 align="center">Regex++, RegEx Class
-        Reference. </h3>
-        <p align="left"><i>Copyright (c) 1998-2001 </i></p>
-        <p align="left"><i>Dr John Maddock</i></p>
-        <p align="left"><i>Permission to use, copy, modify,
-        distribute and sell this software and its documentation
-        for any purpose is hereby granted without fee, provided
-        that the above copyright notice appear in all copies and
-        that both that copyright notice and this permission
-        notice appear in supporting documentation. Dr John
-        Maddock makes no representations about the suitability of
-        this software for any purpose. It is provided &quot;as is&quot;
-        without express or implied warranty.</i></p>
-        </td>
-    </tr>
-</table>
-
-<hr>
-
-<h3><a name="RegEx"></a><i>Class RegEx</i></h3>
-
-<p>#include &lt;boost/cregex.hpp&gt; </p>
-
-<p>The class RegEx provides a high level simplified interface to
-the regular expression library, this class only handles narrow
-character strings, and regular expressions always follow the
-&quot;normal&quot; syntax - that is the same as the standard
-POSIX extended syntax, but with locale specific collation
-disabled, and escape characters inside character set declarations
-are allowed. </p>
-
-<pre><b>typedef</b> <b>bool</b> (*GrepCallback)(<b>const</b> RegEx&amp; expression);
-<b>typedef</b> <b>bool</b> (*GrepFileCallback)(<b>const</b> <b>char</b>* file, <b>const</b> RegEx&amp; expression);
-<b>typedef</b> <b>bool</b> (*FindFilesCallback)(<b>const</b> <b>char</b>* file);
-
-<b>class</b>&nbsp; RegEx
-{
-<b>public</b>:
-&nbsp;&nbsp; RegEx();
-&nbsp;&nbsp; RegEx(<b>const</b> RegEx&amp; o);
-&nbsp;&nbsp; ~RegEx();
-&nbsp;&nbsp; RegEx(<b>const</b> <b>char</b>* c, <b>bool</b> icase = <b>false</b>);
-&nbsp;&nbsp; <strong>explicit</strong> RegEx(<b>const</b> std::string&amp; s, <b>bool</b> icase = <b>false</b>);
-&nbsp;&nbsp; RegEx&amp; <b>operator</b>=(<b>const</b> RegEx&amp; o);
-&nbsp;&nbsp; RegEx&amp; <b>operator</b>=(<b>const</b> <b>char</b>* p);
-&nbsp;&nbsp; RegEx&amp; <b>operator</b>=(<b>const</b> std::string&amp; s);
-&nbsp;&nbsp; <b>unsigned</b> <b>int</b> SetExpression(<b>const</b> <b>char</b>* p, <b>bool</b> icase = <b>false</b>);
-&nbsp;&nbsp; <b>unsigned</b> <b>int</b> SetExpression(<b>const</b> std::string&amp; s, <b>bool</b> icase = <b>false</b>);
-&nbsp;&nbsp; std::string Expression()<b>const</b>;
-&nbsp;&nbsp; <font color="#000080"><i>//
- </i>&nbsp;&nbsp;<i>// now matching operators: </i>
-&nbsp;&nbsp; <i>// </i></font>
-&nbsp;&nbsp; <b>bool</b> Match(<b>const</b> <b>char</b>* p, <b>unsigned</b> <b>int</b> flags = match_default);
-&nbsp;&nbsp; <b>bool</b> Match(<b>const</b> std::string&amp; s, <b>unsigned</b> <b>int</b> flags = match_default); 
-&nbsp;&nbsp; <b>bool</b> Search(<b>const</b> <b>char</b>* p, <b>unsigned</b> <b>int</b> flags = match_default); 
-&nbsp;&nbsp; <b>bool</b> Search(<b>const</b> std::string&amp; s, <b>unsigned</b> <b>int</b> flags = match_default); 
-&nbsp;&nbsp; <b>unsigned</b> <b>int</b> Grep(GrepCallback cb, <b>const</b> <b>char</b>* p, <b>unsigned</b> <b>int</b> flags = match_default); 
-&nbsp;&nbsp; <b>unsigned</b> <b>int</b> Grep(GrepCallback cb, <b>const</b> std::string&amp; s, <b>unsigned</b> <b>int</b> flags = match_default); 
-&nbsp;&nbsp; <b>unsigned</b> <b>int</b> Grep(std::vector&lt;std::string&gt;&amp; v, <b>const</b> <b>char</b>* p, <b>unsigned</b> <b>int</b> flags = match_default); 
-&nbsp;&nbsp; <b>unsigned</b> <b>int</b> Grep(std::vector&lt;std::string&gt;&amp; v, <b>const</b> std::string&amp; s, <b>unsigned</b> <b>int</b> flags = match_default); 
-&nbsp;&nbsp; <b>unsigned</b> <b>int</b> Grep(std::vector&lt;<b>unsigned</b> <b>int</b>&gt;&amp; v, <b>const</b> <b>char</b>* p, <b>unsigned</b> <b>int</b> flags = match_default); 
-&nbsp;&nbsp; <b>unsigned</b> <b>int</b> Grep(std::vector&lt;<b>unsigned</b> <b>int</b>&gt;&amp; v, <b>const</b> std::string&amp; s, <b>unsigned</b> <b>int</b> flags = match_default); 
-&nbsp;&nbsp; <b>unsigned</b> <b>int</b> GrepFiles(GrepFileCallback cb, <b>const</b> <b>char</b>* files, <b>bool</b> recurse = <b>false</b>, <b>unsigned</b> <b>int</b> flags = match_default); 
-&nbsp;&nbsp; <b>unsigned</b> <b>int</b> GrepFiles(GrepFileCallback cb, <b>const</b> std::string&amp; files, <b>bool</b> recurse = <b>false</b>, <b>unsigned</b> <b>int</b> flags = match_default); 
-&nbsp;&nbsp; <b>unsigned</b> <b>int</b> FindFiles(FindFilesCallback cb, <b>const</b> <b>char</b>* files, <b>bool</b> recurse = <b>false</b>, <b>unsigned</b> <b>int</b> flags = match_default); 
-&nbsp;&nbsp; <b>unsigned</b> <b>int</b> FindFiles(FindFilesCallback cb, <b>const</b> std::string&amp; files, <b>bool</b> recurse = <b>false</b>, <b>unsigned</b> <b>int</b> flags = match_default); 
-&nbsp;&nbsp; std::string Merge(<b>const</b> std::string&amp; in, <b>const</b> std::string&amp; fmt, <b>bool</b> copy = <b>true</b>, <b>unsigned</b> <b>int</b> flags = match_default); 
-&nbsp;&nbsp; std::string Merge(<b>const</b> char* in, <b>const</b> char* fmt, <b>bool</b> copy = <b>true</b>, <b>unsigned int </b>flags = match_default); 
-&nbsp;&nbsp; <b>unsigned</b> Split(std::vector&lt;std::string&gt;&amp; v, std::string&amp; s, <b>unsigned</b> flags = match_default, <b>unsigned</b> max_count = ~0); 
-&nbsp;&nbsp; <font color="#000080"><i>// 
-</i>&nbsp;&nbsp; <i>// now operators for returning what matched in more detail: 
-</i>&nbsp;&nbsp; <i>// 
-</i></font>&nbsp;&nbsp; <b>unsigned</b> <b>int</b> Position(<b>int</b> i = 0)<b>const</b>; 
-&nbsp;&nbsp; <b>unsigned</b> <b>int</b> Length(<b>int</b> i = 0)<b>const</b>; 
-   <strong>bool</strong> Matched(<strong>int</strong> i = 0)<strong>const</strong>;
-&nbsp;&nbsp; <b>unsigned</b> <b>int</b> Line()<b>const</b>; 
-&nbsp;&nbsp; <b>unsigned int</b> Marks() const; 
-&nbsp;&nbsp; std::string What(<b>int</b> i)<b>const</b>; 
-&nbsp;&nbsp; std::string <b>operator</b>[](<b>int</b> i)<b>const</b> ; 
-
-   <strong>static const unsigned int</strong> npos;
-}; &nbsp; &nbsp; </pre>
-
-<p>Member functions for class RegEx are defined as follows: <br>
-&nbsp; </p>
-
-<table border="0" cellpadding="7" cellspacing="0" width="100%">
-    <tr>
-        <td valign="top" width="7%">&nbsp;</td>
-        <td valign="top" width="43%">RegEx();</td>
-        <td valign="top" width="42%">Default constructor,
-        constructs an instance of RegEx without any valid
-        expression.</td>
-        <td valign="top" width="7%">&nbsp;</td>
-    </tr>
-    <tr>
-        <td valign="top" width="7%">&nbsp;</td>
-        <td valign="top" width="43%">RegEx(<b>const</b>
-        RegEx&amp; o);</td>
-        <td valign="top" width="42%">Copy constructor, all the
-        properties of parameter <i>o</i> are copied.</td>
-        <td valign="top" width="7%">&nbsp;</td>
-    </tr>
-    <tr>
-        <td valign="top" width="7%">&nbsp;</td>
-        <td valign="top" width="43%">RegEx(<b>const</b> <b>char</b>*
-        c, <b>bool</b> icase = <b>false</b>);</td>
-        <td valign="top" width="42%">Constructs an instance of
-        RegEx, setting the expression to <i>c</i>, if <i>icase</i>
-        is <i>true</i> then matching is insensitive to case,
-        otherwise it is sensitive to case. Throws <i>bad_expression</i>
-        on failure.</td>
-        <td valign="top" width="7%">&nbsp;</td>
-    </tr>
-    <tr>
-        <td valign="top" width="7%">&nbsp;</td>
-        <td valign="top" width="43%">RegEx(<b>const</b> std::string&amp;
-        s, <b>bool</b> icase = <b>false</b>);</td>
-        <td valign="top" width="42%">Constructs an instance of
-        RegEx, setting the expression to <i>s</i>, if <i>icase </i>is
-        <i>true</i> then matching is insensitive to case,
-        otherwise it is sensitive to case. Throws <i>bad_expression</i>
-        on failure.</td>
-        <td valign="top" width="7%">&nbsp;</td>
-    </tr>
-    <tr>
-        <td valign="top" width="7%">&nbsp;</td>
-        <td valign="top" width="43%">RegEx&amp; <b>operator</b>=(<b>const</b>
-        RegEx&amp; o);</td>
-        <td valign="top" width="42%">Default assignment operator.</td>
-        <td valign="top" width="7%">&nbsp;</td>
-    </tr>
-    <tr>
-        <td valign="top" width="7%">&nbsp;</td>
-        <td valign="top" width="43%">RegEx&amp; <b>operator</b>=(<b>const</b>
-        <b>char</b>* p);</td>
-        <td valign="top" width="42%">Assignment operator,
-        equivalent to calling <i>SetExpression(p, false).</i>
-        Throws <i>bad_expression</i> on failure.</td>
-        <td valign="top" width="7%">&nbsp;</td>
-    </tr>
-    <tr>
-        <td valign="top" width="7%">&nbsp;</td>
-        <td valign="top" width="43%">RegEx&amp; <b>operator</b>=(<b>const</b>
-        std::string&amp; s);</td>
-        <td valign="top" width="42%">Assignment operator,
-        equivalent to calling <i>SetExpression(s, false).</i>
-        Throws <i>bad_expression</i> on failure.</td>
-        <td valign="top" width="7%">&nbsp;</td>
-    </tr>
-    <tr>
-        <td valign="top" width="7%">&nbsp;</td>
-        <td valign="top" width="43%"><b>unsigned</b> <b>int</b>
-        SetExpression(<b>constchar</b>* p, <b>bool</b> icase = <b>false</b>);</td>
-        <td valign="top" width="42%">Sets the current expression
-        to <i>p</i>, if <i>icase</i> is <i>true</i> then matching
-        is insensitive to case, otherwise it is sensitive to case.
-        Throws <i>bad_expression</i> on failure.</td>
-        <td valign="top" width="7%">&nbsp;</td>
-    </tr>
-    <tr>
-        <td valign="top" width="7%">&nbsp;</td>
-        <td valign="top" width="43%"><b>unsigned</b> <b>int</b>
-        SetExpression(<b>const</b> std::string&amp; s, <b>bool</b>
-        icase = <b>false</b>);</td>
-        <td valign="top" width="42%">Sets the current expression
-        to <i>s</i>, if <i>icase</i> is <i>true</i> then matching
-        is insensitive to case, otherwise it is sensitive to case.
-        Throws <i>bad_expression</i> on failure.</td>
-        <td valign="top" width="7%">&nbsp;</td>
-    </tr>
-    <tr>
-        <td valign="top" width="7%">&nbsp;</td>
-        <td valign="top" width="43%">std::string Expression()<b>const</b>;</td>
-        <td valign="top" width="42%">Returns a copy of the
-        current regular expression.</td>
-        <td valign="top" width="7%">&nbsp;</td>
-    </tr>
-    <tr>
-        <td valign="top" width="7%">&nbsp;</td>
-        <td valign="top" width="43%"><b>bool</b> Match(<b>const</b>
-        <b>char</b>* p, <b>unsigned</b> <b>int</b> flags =
-        match_default);</td>
-        <td valign="top" width="42%">Attempts to match the
-        current expression against the text <i>p</i> using the
-        match flags <i>flags</i> - see <a
-        href="template_class_ref.htm#match_type">match flags</a>.
-        Returns <i>true</i> if the expression matches the whole
-        of the input string.</td>
-        <td valign="top" width="7%">&nbsp;</td>
-    </tr>
-    <tr>
-        <td valign="top" width="7%">&nbsp;</td>
-        <td valign="top" width="43%"><b>bool</b> Match(<b>const</b>
-        std::string&amp; s, <b>unsigned</b> <b>int</b> flags =
-        match_default) ;</td>
-        <td valign="top" width="42%">Attempts to match the
-        current expression against the text <i>s</i> using the
-        match flags <i>flags</i> - see <a
-        href="template_class_ref.htm#match_type">match flags</a>.
-        Returns <i>true</i> if the expression matches the whole
-        of the input string.</td>
-        <td valign="top" width="7%">&nbsp;</td>
-    </tr>
-    <tr>
-        <td valign="top" width="7%">&nbsp;</td>
-        <td valign="top" width="43%"><b>bool</b> Search(<b>const</b>
-        <b>char</b>* p, <b>unsigned</b> <b>int</b> flags =
-        match_default);</td>
-        <td valign="top" width="42%">Attempts to find a match for
-        the current expression somewhere in the text <i>p</i>
-        using the match flags <i>flags </i>- see <a
-        href="template_class_ref.htm#match_type">match flags</a>.
-        Returns <i>true</i> if the match succeeds.</td>
-        <td valign="top" width="7%">&nbsp;</td>
-    </tr>
-    <tr>
-        <td valign="top" width="7%">&nbsp;</td>
-        <td valign="top" width="43%"><b>bool</b> Search(<b>const</b>
-        std::string&amp; s, <b>unsigned</b> <b>int</b> flags =
-        match_default) ;</td>
-        <td valign="top" width="42%">Attempts to find a match for
-        the current expression somewhere in the text <i>s</i>
-        using the match flags <i>flags </i>- see <a
-        href="template_class_ref.htm#match_type">match flags</a>.
-        Returns <i>true</i> if the match succeeds.</td>
-        <td valign="top" width="7%">&nbsp;</td>
-    </tr>
-    <tr>
-        <td valign="top" width="7%">&nbsp;</td>
-        <td valign="top" width="43%"><b>unsigned</b> <b>int</b>
-        Grep(GrepCallback cb, <b>const</b> <b>char</b>* p, <b>unsigned</b>
-        <b>int</b> flags = match_default);</td>
-        <td valign="top" width="42%">Finds all matches of the
-        current expression in the text <i>p</i> using the match
-        flags <i>flags </i>- see <a
-        href="template_class_ref.htm#match_type">match flags</a>.
-        For each match found calls the call-back function <i>cb</i>
-        as: cb(*this); <p>If at any stage the call-back function
-        returns false then the grep operation terminates,
-        otherwise continues until no further matches are found.
-        Returns the number of matches found.</p>
-        </td>
-        <td valign="top" width="7%">&nbsp;</td>
-    </tr>
-    <tr>
-        <td valign="top" width="7%">&nbsp;</td>
-        <td valign="top" width="43%"><b>unsigned</b> <b>int</b>
-        Grep(GrepCallback cb, <b>const</b> std::string&amp; s, <b>unsigned</b>
-        <b>int</b> flags = match_default);</td>
-        <td valign="top" width="42%">Finds all matches of the
-        current expression in the text <i>s</i> using the match
-        flags <i>flags </i>- see <a
-        href="template_class_ref.htm#match_type">match flags</a>.
-        For each match found calls the call-back function <i>cb</i>
-        as: cb(*this); <p>If at any stage the call-back function
-        returns false then the grep operation terminates,
-        otherwise continues until no further matches are found.
-        Returns the number of matches found. </p>
-        </td>
-        <td valign="top" width="7%">&nbsp;</td>
-    </tr>
-    <tr>
-        <td valign="top" width="7%">&nbsp;</td>
-        <td valign="top" width="43%"><b>unsigned</b> <b>int</b>
-        Grep(std::vector&lt;std::string&gt;&amp; v, <b>const</b> <b>char</b>*
-        p, <b>unsigned</b> <b>int</b> flags = match_default);</td>
-        <td valign="top" width="42%">Finds all matches of the
-        current expression in the text <i>p</i> using the match
-        flags <i>flags </i>- see <a
-        href="template_class_ref.htm#match_type">match flags</a>.
-        For each match pushes a copy of what matched onto <i>v</i>.
-        Returns the number of matches found.</td>
-        <td valign="top" width="7%">&nbsp;</td>
-    </tr>
-    <tr>
-        <td valign="top" width="7%">&nbsp;</td>
-        <td valign="top" width="43%"><b>unsigned</b> <b>int</b>
-        Grep(std::vector&lt;std::string&gt;&amp; v, <b>const</b>
-        std::string&amp; s, <b>unsigned</b> <b>int</b> flags =
-        match_default);</td>
-        <td valign="top" width="42%">Finds all matches of the
-        current expression in the text <i>s</i> using the match
-        flags <i>flags </i>- see <a
-        href="template_class_ref.htm#match_type">match flags</a>.
-        For each match pushes a copy of what matched onto <i>v</i>.
-        Returns the number of matches found.</td>
-        <td valign="top" width="7%">&nbsp;</td>
-    </tr>
-    <tr>
-        <td valign="top" width="7%">&nbsp;</td>
-        <td valign="top" width="43%"><b>unsigned</b> <b>int</b>
-        Grep(std::vector&lt;<b>unsigned int</b>&gt;&amp; v, <b>const</b>
-        <b>char</b>* p, <b>unsigned</b> <b>int</b> flags =
-        match_default);</td>
-        <td valign="top" width="42%">Finds all matches of the
-        current expression in the text <i>p</i> using the match
-        flags <i>flags </i>- see <a
-        href="template_class_ref.htm#match_type">match flags</a>.
-        For each match pushes the starting index of what matched
-        onto <i>v</i>. Returns the number of matches found.</td>
-        <td valign="top" width="7%">&nbsp;</td>
-    </tr>
-    <tr>
-        <td valign="top" width="7%">&nbsp;</td>
-        <td valign="top" width="43%"><b>unsigned</b> <b>int</b>
-        Grep(std::vector&lt;<b>unsigned int</b>&gt;&amp; v, <b>const</b>
-        std::string&amp; s, <b>unsigned</b> <b>int</b> flags =
-        match_default);</td>
-        <td valign="top" width="42%">Finds all matches of the
-        current expression in the text <i>s</i> using the match
-        flags <i>flags </i>- see <a
-        href="template_class_ref.htm#match_type">match flags</a>.
-        For each match pushes the starting index of what matched
-        onto <i>v</i>. Returns the number of matches found.</td>
-        <td valign="top" width="7%">&nbsp;</td>
-    </tr>
-    <tr>
-        <td valign="top" width="7%">&nbsp;</td>
-        <td valign="top" width="43%"><b>unsigned</b> <b>int</b>
-        GrepFiles(GrepFileCallback cb, <b>const</b> <b>char</b>*
-        files, <b>bool</b> recurse = <b>false</b>, <b>unsigned</b>
-        <b>int</b> flags = match_default);</td>
-        <td valign="top" width="42%">Finds all matches of the
-        current expression in the files <i>files</i> using the
-        match flags <i>flags </i>- see <a
-        href="template_class_ref.htm#match_type">match flags</a>.
-        For each match calls the call-back function cb.&nbsp; <p>If
-        the call-back returns false then the algorithm returns
-        without considering further matches in the current file,
-        or any further files.&nbsp; </p>
-        <p>The parameter <i>files</i> can include wild card
-        characters '*' and '?', if the parameter <i>recurse</i>
-        is true then searches sub-directories for matching file
-        names.&nbsp; </p>
-        <p>Returns the total number of matches found.</p>
-        <p>May throw an exception derived from std::runtime_error
-        if file io fails.</p>
-        </td>
-        <td valign="top" width="7%">&nbsp;</td>
-    </tr>
-    <tr>
-        <td valign="top" width="7%">&nbsp;</td>
-        <td valign="top" width="43%"><b>unsigned</b> <b>int</b>
-        GrepFiles(GrepFileCallback cb, <b>const</b> std::string&amp;
-        files, <b>bool</b> recurse = <b>false</b>, <b>unsigned</b>
-        <b>int</b> flags = match_default);</td>
-        <td valign="top" width="42%">Finds all matches of the
-        current expression in the files <i>files</i> using the
-        match flags <i>flags </i>- see <a
-        href="template_class_ref.htm#match_type">match flags</a>.
-        For each match calls the call-back function cb.&nbsp; <p>If
-        the call-back returns false then the algorithm returns
-        without considering further matches in the current file,
-        or any further files.&nbsp; </p>
-        <p>The parameter <i>files</i> can include wild card
-        characters '*' and '?', if the parameter <i>recurse</i>
-        is true then searches sub-directories for matching file
-        names.&nbsp; </p>
-        <p>Returns the total number of matches found.</p>
-        <p>May throw an exception derived from std::runtime_error
-        if file io fails.</p>
-        </td>
-        <td valign="top" width="7%">&nbsp;</td>
-    </tr>
-    <tr>
-        <td valign="top" width="7%">&nbsp;</td>
-        <td valign="top" width="43%"><b>unsigned</b> <b>int</b>
-        FindFiles(FindFilesCallback cb, <b>const</b> <b>char</b>*
-        files, <b>bool</b> recurse = <b>false</b>, <b>unsigned</b>
-        <b>int</b> flags = match_default);</td>
-        <td valign="top" width="42%">Searches <i>files</i> to
-        find all those which contain at least one match of the
-        current expression using the match flags <i>flags </i>-
-        see <a href="template_class_ref.htm#match_type">match
-        flags</a>. For each matching file calls the call-back
-        function cb.&nbsp; <p>If the call-back returns false then
-        the algorithm returns without considering any further
-        files.&nbsp; </p>
-        <p>The parameter <i>files</i> can include wild card
-        characters '*' and '?', if the parameter <i>recurse</i>
-        is true then searches sub-directories for matching file
-        names.&nbsp; </p>
-        <p>Returns the total number of files found.</p>
-        <p>May throw an exception derived from std::runtime_error
-        if file io fails.</p>
-        </td>
-        <td valign="top" width="7%">&nbsp;</td>
-    </tr>
-    <tr>
-        <td valign="top" width="7%">&nbsp;</td>
-        <td valign="top" width="43%"><b>unsigned</b> <b>int</b>
-        FindFiles(FindFilesCallback cb, <b>const</b> std::string&amp;
-        files, <b>bool</b> recurse = <b>false</b>, <b>unsigned</b>
-        <b>int</b> flags = match_default);</td>
-        <td valign="top" width="42%">Searches <i>files</i> to
-        find all those which contain at least one match of the
-        current expression using the match flags <i>flags </i>-
-        see <a href="template_class_ref.htm#match_type">match
-        flags</a>. For each matching file calls the call-back
-        function cb.&nbsp; <p>If the call-back returns false then
-        the algorithm returns without considering any further
-        files.&nbsp; </p>
-        <p>The parameter <i>files</i> can include wild card
-        characters '*' and '?', if the parameter <i>recurse</i>
-        is true then searches sub-directories for matching file
-        names.&nbsp; </p>
-        <p>Returns the total number of files found.</p>
-        <p>May throw an exception derived from std::runtime_error
-        if file io fails.</p>
-        </td>
-        <td valign="top" width="7%">&nbsp;</td>
-    </tr>
-    <tr>
-        <td valign="top" width="7%">&nbsp;</td>
-        <td valign="top" width="43%">std::string Merge(<b>const</b>
-        std::string&amp; in, <b>const</b> std::string&amp; fmt, <b>bool</b>
-        copy = <b>true</b>, <b>unsigned</b> <b>int</b> flags =
-        match_default);</td>
-        <td valign="top" width="42%">Performs a search and
-        replace operation: searches through the string <i>in</i>
-        for all occurrences of the current expression, for each
-        occurrence replaces the match with the format string <i>fmt</i>.
-        Uses <i>flags</i> to determine what gets matched, and how
-        the format string should be treated. If <i>copy</i> is
-        true then all unmatched sections of input are copied
-        unchanged to output, if the flag <em>format_first_only</em>
-        is set then only the first occurance of the pattern found
-        is replaced. Returns the new string. See <a
-        href="format_string.htm#format_string">also format string
-        syntax</a>, <a href="template_class_ref.htm#match_type">match
-        flags</a> and <a
-        href="template_class_ref.htm#format_flags">format flags</a>.</td>
-        <td valign="top" width="7%">&nbsp;</td>
-    </tr>
-    <tr>
-        <td valign="top" width="7%">&nbsp;</td>
-        <td valign="top" width="43%">std::string Merge(<b>const</b>
-        char* in, <b>const</b> char* fmt, <b>bool</b> copy = <b>true</b>,
-        <b>unsigned int </b>flags = match_default);</td>
-        <td valign="top" width="42%">Performs a search and
-        replace operation: searches through the string <i>in</i>
-        for all occurrences of the current expression, for each
-        occurrence replaces the match with the format string <i>fmt</i>.
-        Uses <i>flags</i> to determine what gets matched, and how
-        the format string should be treated. If <i>copy</i> is
-        true then all unmatched sections of input are copied
-        unchanged to output, if the flag <em>format_first_only</em>
-        is set then only the first occurance of the pattern found
-        is replaced. Returns the new string. See <a
-        href="format_string.htm#format_string">also format string
-        syntax</a>, <a href="template_class_ref.htm#match_type">match
-        flags</a> and <a
-        href="template_class_ref.htm#format_flags">format flags</a>.</td>
-        <td valign="top" width="7%">&nbsp;</td>
-    </tr>
-    <tr>
-        <td>&nbsp;</td>
-        <td valign="top"><b>unsigned</b> Split(std::vector&lt;std::string&gt;&amp;
-        v, std::string&amp; s, <b>unsigned</b> flags =
-        match_default, <b>unsigned</b> max_count = ~0);</td>
-        <td valign="top">Splits the input string and pushes each
-        one onto the vector. If the expression contains no marked
-        sub-expressions, then one string is outputted for each
-        section of the input that does not match the expression.
-        If the expression does contain marked sub-expressions,
-        then outputs one string for each marked sub-expression
-        each time a match occurs. Outputs no more than <i>max_count
-        </i>strings. Before returning, deletes from the input
-        string <i>s</i> all of the input that has been processed
-        (all of the string if <i>max_count</i> was not reached).
-        Returns the number of strings pushed onto the vector.</td>
-        <td>&nbsp;</td>
-    </tr>
-    <tr>
-        <td valign="top" width="7%">&nbsp;</td>
-        <td valign="top" width="43%"><b>unsigned</b> <b>int</b>
-        Position(<b>int</b> i = 0)<b>const</b>;</td>
-        <td valign="top" width="42%">Returns the position of what
-        matched sub-expression <i>i</i>. If <i>i = 0</i> then
-        returns the position of the whole match. Returns RegEx::npos
-        if the supplied index is invalid, or if the specified sub-expression
-        did not participate in the match.</td>
-        <td valign="top" width="7%">&nbsp;</td>
-    </tr>
-    <tr>
-        <td valign="top" width="7%">&nbsp;</td>
-        <td valign="top" width="43%"><b>unsigned</b> <b>int</b>
-        Length(<b>int</b> i = 0)<b>const</b>;</td>
-        <td valign="top" width="42%">Returns the length of what
-        matched sub-expression <i>i</i>. If <i>i = 0</i> then
-        returns the length of the whole match. Returns RegEx::npos
-        if the supplied index is invalid, or if the specified sub-expression
-        did not participate in the match.</td>
-        <td valign="top" width="7%">&nbsp;</td>
-    </tr>
-    <tr>
-        <td>&nbsp;</td>
-        <td><strong>bool</strong> Matched(<strong>int</strong> i
-        = 0)<strong>const</strong>;</td>
-        <td>Returns true if sub-expression <em>i</em> was
-        matched, false otherwise.</td>
-        <td>&nbsp;</td>
-    </tr>
-    <tr>
-        <td valign="top" width="7%">&nbsp;</td>
-        <td valign="top" width="43%"><b>unsigned</b> <b>int</b>
-        Line()<b>const</b>;</td>
-        <td valign="top" width="42%">Returns the line on which
-        the match occurred, indexes start from 1 not zero, if no
-        match occurred then returns RegEx::npos.</td>
-        <td valign="top" width="7%">&nbsp;</td>
-    </tr>
-    <tr>
-        <td valign="top" width="7%">&nbsp;</td>
-        <td valign="top" width="43%"><b>unsigned int</b> Marks()
-        const;</td>
-        <td valign="top" width="42%">Returns the number of marked
-        sub-expressions contained in the expression. Note that
-        this includes the whole match (sub-expression zero), so
-        the value returned is always &gt;= 1.</td>
-        <td valign="top" width="7%">&nbsp;</td>
-    </tr>
-    <tr>
-        <td valign="top" width="7%">&nbsp;</td>
-        <td valign="top" width="43%">std::string What(<b>int</b>
-        i)<b>const</b>;</td>
-        <td valign="top" width="42%">Returns a copy of what
-        matched sub-expression <i>i</i>. If <i>i = 0</i> then
-        returns a copy of the whole match. Returns a null string
-        if the index is invalid or if the specified sub-expression
-        did not participate in a match.</td>
-        <td valign="top" width="7%">&nbsp;</td>
-    </tr>
-    <tr>
-        <td valign="top" width="7%">&nbsp;</td>
-        <td valign="top" width="43%">std::string <b>operator</b>[](<b>int</b>
-        i)<b>const</b> ;</td>
-        <td valign="top" width="42%">Returns <i>what(i);</i> <p>Can
-        be used to simplify access to sub-expression matches, and
-        make usage more perl-like.</p>
-        </td>
-        <td valign="top" width="7%">&nbsp;</td>
-    </tr>
-</table>
-
-<hr>
-
-<p><i>Copyright </i><a href="mailto:John_Maddock@compuserve.com"><i>Dr
-John Maddock</i></a><i> 1998-2000 all rights reserved.</i> </p>
-</body>
-</html>

include/boost/cregex.hpp

@@ -14,7 +14,7 @@
  */
  
  /*
-  *   LOCATION:    see http://www.boost.org for most recent version.
+  *   LOCATION:    see http://www.boost.org/libs/regex for most recent version.
   *   FILE         cregex.cpp
   *   VERSION      see <boost/version.hpp>
   *   DESCRIPTION: Declares POSIX API functions
@@ -24,283 +24,7 @@
 #ifndef BOOST_RE_CREGEX_HPP
 #define BOOST_RE_CREGEX_HPP
 
-#include <boost/regex/config.hpp>
-
-#ifdef __BORLANDC__
-   #pragma option push -a8 -b -Vx -Ve -pc
-#endif
-
-/* include these defs only for POSIX compatablity */
-#ifdef __cplusplus
-namespace boost{
-extern "C" {
-#endif
-
-#if defined(__cplusplus) && !defined(BOOST_NO_STDC_NAMESPACE)
-typedef std::ptrdiff_t regoff_t;
-typedef std::size_t regsize_t;
-#else
-typedef ptrdiff_t regoff_t;
-typedef size_t regsize_t;
-#endif
-
-typedef struct
-{
-   unsigned int re_magic;
-   unsigned int re_nsub;      /* number of parenthesized subexpressions */
-   const char* re_endp;       /* end pointer for REG_PEND */
-   void* guts;             /* none of your business :-) */
-   unsigned int eflags;       /* none of your business :-) */
-} regex_tA;
-
-#ifndef BOOST_NO_WREGEX
-typedef struct
-{
-   unsigned int re_magic;
-   unsigned int re_nsub;      /* number of parenthesized subexpressions */
-   const wchar_t* re_endp;       /* end pointer for REG_PEND */
-   void* guts;             /* none of your business :-) */
-   unsigned int eflags;       /* none of your business :-) */
-} regex_tW;
-#endif
-
-typedef struct
-{
-   regoff_t rm_so;      /* start of match */
-   regoff_t rm_eo;      /* end of match */
-} regmatch_t;
-
-/* regcomp() flags */
-typedef enum{
-   REG_BASIC = 0000,
-   REG_EXTENDED = 0001,
-   REG_ICASE = 0002,
-   REG_NOSUB = 0004,
-   REG_NEWLINE = 0010,
-   REG_NOSPEC = 0020,
-   REG_PEND = 0040,
-   REG_DUMP = 0200,
-   REG_NOCOLLATE = 0400,
-   REG_ESCAPE_IN_LISTS = 01000,
-   REG_NEWLINE_ALT = 02000,
-
-   REG_PERL = REG_EXTENDED | REG_NOCOLLATE | REG_ESCAPE_IN_LISTS,
-   REG_AWK = REG_EXTENDED | REG_ESCAPE_IN_LISTS,
-   REG_GREP = REG_BASIC | REG_NEWLINE_ALT,
-   REG_EGREP = REG_EXTENDED | REG_NEWLINE_ALT,
-
-   REG_ASSERT = 15,
-   REG_INVARG = 16,
-   REG_ATOI = 255,   /* convert name to number (!) */
-   REG_ITOA = 0400   /* convert number to name (!) */
-} reg_comp_flags;
-
-/* regexec() flags */
-typedef enum{
-   REG_NOTBOL =    00001,
-   REG_NOTEOL =    00002,
-   REG_STARTEND =  00004
-} reg_exec_flags;
-
-BOOST_REGEX_DECL int BOOST_REGEX_CCALL regcompA(regex_tA*, const char*, int);
-BOOST_REGEX_DECL regsize_t BOOST_REGEX_CCALL regerrorA(int, const regex_tA*, char*, regsize_t);
-BOOST_REGEX_DECL int BOOST_REGEX_CCALL regexecA(const regex_tA*, const char*, regsize_t, regmatch_t*, int);
-BOOST_REGEX_DECL void BOOST_REGEX_CCALL regfreeA(regex_tA*);
-
-#ifndef BOOST_NO_WREGEX
-BOOST_REGEX_DECL int BOOST_REGEX_CCALL regcompW(regex_tW*, const wchar_t*, int);
-BOOST_REGEX_DECL regsize_t BOOST_REGEX_CCALL regerrorW(int, const regex_tW*, wchar_t*, regsize_t);
-BOOST_REGEX_DECL int BOOST_REGEX_CCALL regexecW(const regex_tW*, const wchar_t*, regsize_t, regmatch_t*, int);
-BOOST_REGEX_DECL void BOOST_REGEX_CCALL regfreeW(regex_tW*);
-#endif
-
-#ifdef UNICODE
-#define regcomp regcompW
-#define regerror regerrorW
-#define regexec regexecW
-#define regfree regfreeW
-#define regex_t regex_tW
-#else
-#define regcomp regcompA
-#define regerror regerrorA
-#define regexec regexecA
-#define regfree regfreeA
-#define regex_t regex_tA
-#endif
-
-/* regerror() flags */
-typedef enum
-{
-  REG_NOERROR = 0,   /* Success.  */
-  REG_NOMATCH = 1,      /* Didn't find a match (for regexec).  */
-
-  /* POSIX regcomp return error codes.  (In the order listed in the
-     standard.)  */
-  REG_BADPAT = 2,    /* Invalid pattern.  */
-  REG_ECOLLATE = 3,  /* Undefined collating element.  */
-  REG_ECTYPE = 4,    /* Invalid character class name.  */
-  REG_EESCAPE = 5,   /* Trailing backslash.  */
-  REG_ESUBREG = 6,   /* Invalid back reference.  */
-  REG_EBRACK = 7,    /* Unmatched left bracket.  */
-  REG_EPAREN = 8,    /* Parenthesis imbalance.  */
-  REG_EBRACE = 9,    /* Unmatched \{.  */
-  REG_BADBR = 10,    /* Invalid contents of \{\}.  */
-  REG_ERANGE = 11,   /* Invalid range end.  */
-  REG_ESPACE = 12,   /* Ran out of memory.  */
-  REG_BADRPT = 13,   /* No preceding re for repetition op.  */
-  REG_EEND = 14,     /* unexpected end of expression */
-  REG_ESIZE = 15,    /* expression too big */
-  REG_ERPAREN = 16,   /* unmatched right parenthesis */
-  REG_EMPTY = 17,    /* empty expression */
-  REG_E_MEMORY = REG_ESIZE, /* out of memory */
-  REG_E_UNKNOWN = 18 /* unknown error */
-} reg_errcode_t;
-
-enum match_flags
-{
-   match_default = 0,
-   match_not_bol = 1,                                // first is not start of line
-   match_not_eol = match_not_bol << 1,               // last is not end of line
-   match_not_bob = match_not_eol << 1,               // first is not start of buffer
-   match_not_eob = match_not_bob << 1,               // last is not end of buffer
-   match_not_bow = match_not_eob << 1,               // first is not start of word
-   match_not_eow = match_not_bow << 1,               // last is not end of word
-   match_not_dot_newline = match_not_eow << 1,       // \n is not matched by '.'
-   match_not_dot_null = match_not_dot_newline << 1,  // '\0' is not matched by '.'
-   match_prev_avail = match_not_dot_null << 1,       // *--first is a valid expression
-   match_init = match_prev_avail << 1,               // internal use
-   match_any = match_init << 1,                      // don't care what we match
-   match_not_null = match_any << 1,                  // string can't be null
-   match_continuous = match_not_null << 1,           // each grep match must continue from
-                                                     // uninterupted from the previous one
-   match_partial = match_continuous << 1,            // find partial matches
-   
-   match_stop = match_partial << 1,                  // stop after first match (grep)
-   match_all = match_stop << 1,                      // must find the whole of input even if match_any is set
-   match_max = match_all
-};
-
-
-#ifdef __cplusplus
-} // extern "C"
-} // namespace
-#endif
-
-
-#ifdef __BORLANDC__
- #if __BORLANDC__ > 0x520
-  #pragma option pop
- #endif
-#endif
-
-
-//
-// C++ high level wrapper goes here:
-//
-#if defined(__cplusplus)
-#include <string>
-#include <vector>
-namespace boost{
-
-#ifdef __BORLANDC__
-   #if __BORLANDC__ == 0x530
-    #pragma option push -a4 -b
-   #elif __BORLANDC__ > 0x530
-    #pragma option push -a8 -b
-   #endif
-#endif
-
-class RegEx;
-
-namespace re_detail{
-
-class RegExData;
-struct pred1;
-struct pred2;
-struct pred3;
-struct pred4;
-
-}  // namespace re_detail
-
-#if defined(BOOST_MSVC) || defined(__BORLANDC__)
-typedef bool (__cdecl *GrepCallback)(const RegEx& expression);
-typedef bool (__cdecl *GrepFileCallback)(const char* file, const RegEx& expression);
-typedef bool (__cdecl *FindFilesCallback)(const char* file);
-#else
-typedef bool (*GrepCallback)(const RegEx& expression);
-typedef bool (*GrepFileCallback)(const char* file, const RegEx& expression);
-typedef bool (*FindFilesCallback)(const char* file);
-#endif
-
-class BOOST_REGEX_DECL RegEx
-{
-private:
-   re_detail::RegExData* pdata;
-public:
-   RegEx();
-   RegEx(const RegEx& o);
-   ~RegEx();
-   explicit RegEx(const char* c, bool icase = false);
-   explicit RegEx(const std::string& s, bool icase = false);
-   RegEx& operator=(const RegEx& o);
-   RegEx& operator=(const char* p);
-   RegEx& operator=(const std::string& s){ return this->operator=(s.c_str()); }
-   unsigned int SetExpression(const char* p, bool icase = false);
-   unsigned int SetExpression(const std::string& s, bool icase = false){ return SetExpression(s.c_str(), icase); }
-   std::string Expression()const;
-   unsigned int error_code()const;
-   //
-   // now matching operators:
-   //
-   bool Match(const char* p, unsigned int flags = match_default);
-   bool Match(const std::string& s, unsigned int flags = match_default) { return Match(s.c_str(), flags); }
-   bool Search(const char* p, unsigned int flags = match_default);
-   bool Search(const std::string& s, unsigned int flags = match_default) { return Search(s.c_str(), flags); }
-   unsigned int Grep(GrepCallback cb, const char* p, unsigned int flags = match_default);
-   unsigned int Grep(GrepCallback cb, const std::string& s, unsigned int flags = match_default) { return Grep(cb, s.c_str(), flags); }
-   unsigned int Grep(std::vector<std::string>& v, const char* p, unsigned int flags = match_default);
-   unsigned int Grep(std::vector<std::string>& v, const std::string& s, unsigned int flags = match_default) { return Grep(v, s.c_str(), flags); }
-   unsigned int Grep(std::vector<std::size_t>& v, const char* p, unsigned int flags = match_default);
-   unsigned int Grep(std::vector<std::size_t>& v, const std::string& s, unsigned int flags = match_default) { return Grep(v, s.c_str(), flags); }
-#ifndef BOOST_REGEX_NO_FILEITER
-   unsigned int GrepFiles(GrepFileCallback cb, const char* files, bool recurse = false, unsigned int flags = match_default);
-   unsigned int GrepFiles(GrepFileCallback cb, const std::string& files, bool recurse = false, unsigned int flags = match_default) { return GrepFiles(cb, files.c_str(), recurse, flags); }
-   unsigned int FindFiles(FindFilesCallback cb, const char* files, bool recurse = false, unsigned int flags = match_default);
-   unsigned int FindFiles(FindFilesCallback cb, const std::string& files, bool recurse = false, unsigned int flags = match_default) { return FindFiles(cb, files.c_str(), recurse, flags); }
-#endif
-
-   std::string Merge(const std::string& in, const std::string& fmt,
-                       bool copy = true, unsigned int flags = match_default);
-   std::string Merge(const char* in, const char* fmt,
-                       bool copy = true, unsigned int flags = match_default);
-
-   std::size_t Split(std::vector<std::string>& v, std::string& s, unsigned flags = match_default, unsigned max_count = ~0);
-   //
-   // now operators for returning what matched in more detail:
-   //
-   std::size_t Position(int i = 0)const;
-   std::size_t Length(int i = 0)const;
-   bool Matched(int i = 0)const;
-   unsigned int Line()const;
-   unsigned int Marks()const;
-   std::string What(int i = 0)const;
-   std::string operator[](int i)const { return What(i); }
-
-   static const unsigned int npos;
-
-   friend struct re_detail::pred1;
-   friend struct re_detail::pred2;
-   friend struct re_detail::pred3;
-   friend struct re_detail::pred4;
-};
-
-#ifdef __BORLANDC__
-  #pragma option pop
-#endif
-
-} // namespace boost
-
-#endif
+#include <boost/regex/v3/cregex.hpp>
 
 #endif // include guard
 
@@ -310,3 +34,4 @@ public:
 
 
 
+

include/boost/regex.h

@@ -14,7 +14,7 @@
  */
  
  /*
-  *   LOCATION:    see http://www.boost.org for most recent version.
+  *   LOCATION:    see http://www.boost.org/libs/regex for documentation.
   *   FILE         regex.h
   *   VERSION      3.12
   *   DESCRIPTION: Declares POSIX API functions

include/boost/regex/config.hpp

@@ -125,8 +125,10 @@
 // If there isn't good enough wide character support then there will
 // be no wide character regular expressions:
 //
-#if (defined(BOOST_NO_CWCHAR) || defined(BOOST_NO_CWCTYPE) || defined(BOOST_NO_STD_WSTRING)) && !defined(BOOST_NO_WREGEX)
-#  define BOOST_NO_WREGEX
+#if (defined(BOOST_NO_CWCHAR) || defined(BOOST_NO_CWCTYPE) || defined(BOOST_NO_STD_WSTRING))
+#  if !defined(BOOST_NO_WREGEX)
+#     define BOOST_NO_WREGEX
+#  endif
 #else
 #  if defined(__sgi) && defined(__SGI_STL_PORT)
       // STLPort on IRIX is misconfigured: <cwctype> does not compile
@@ -165,7 +167,7 @@
 
 // We don't make our templates external if the compiler
 // can't handle it:
-#if (defined(BOOST_NO_MEMBER_FUNCTION_SPECIALIZATIONS) || defined(__MWERKS__) || defined(__COMO__) || defined(__ICL) || defined(__ICC))\
+#if (defined(BOOST_NO_MEMBER_FUNCTION_SPECIALIZATIONS) || defined(__HP_aCC) || defined(__MWERKS__) || defined(__COMO__) || defined(__ICL) || defined(__ICC))\
    && !defined(BOOST_MSVC) && !defined(__BORLANDC__)
 #  define BOOST_REGEX_NO_EXTERNAL_TEMPLATES
 #endif
@@ -257,7 +259,7 @@ using std::distance;
 #endif
  
 #if (defined(BOOST_MSVC) || defined(__BORLANDC__)) && !defined(BOOST_REGEX_NO_LIB) && !defined(BOOST_REGEX_SOURCE)
-#  include <boost/regex/detail/regex_library_include.hpp>
+#  include <boost/regex/v3/regex_library_include.hpp>
 #endif
 
 /*****************************************************************************
@@ -643,3 +645,6 @@ inline void pointer_construct(T* p, const T& t)
 
 
 
+
+
+

include/boost/regex/regex_traits.hpp

@@ -23,787 +23,12 @@
 #ifndef BOOST_REGEX_TRAITS_HPP
 #define BOOST_REGEX_TRAITS_HPP
 
-#include <boost/cregex.hpp>
-#include <boost/static_assert.hpp>
-#include <boost/regex/detail/regex_cstring.hpp>
-
-namespace boost{
-
-#ifdef __BORLANDC__
-   #pragma option push -a8 -b -Vx -Ve -pc
+#ifndef BOOST_REGEX_TRAITS_HPP_INCLUDED
+#include <boost/regex/v3/regex_traits.hpp>
 #endif
 
-template <class charT>
-class c_regex_traits;
-
-namespace re_detail{
-
-struct mss
-{
-   unsigned int id;
-   const char* what;
-};
-
-BOOST_REGEX_DECL bool BOOST_REGEX_CALL re_lookup_def_collate_name(std::string& buf, const char* name);
-BOOST_REGEX_DECL std::size_t BOOST_REGEX_CALL re_get_default_message(char* buf, std::size_t len, std::size_t id);
-extern BOOST_REGEX_DECL const char *re_default_error_messages[];
-
-#ifndef BOOST_NO_WREGEX
-extern BOOST_REGEX_DECL wchar_t wide_lower_case_map[];
-extern BOOST_REGEX_DECL unsigned short wide_unicode_classes[];
-BOOST_REGEX_DECL bool BOOST_REGEX_CALL is_combining(wchar_t c);
-#endif
-
-
-struct BOOST_REGEX_DECL regex_traits_base
-{
-   enum char_syntax_type
-   {
-      syntax_char = 0,
-      syntax_open_bracket = 1,                  // (
-      syntax_close_bracket = 2,                 // )
-      syntax_dollar = 3,                        // $
-      syntax_caret = 4,                         // ^
-      syntax_dot = 5,                           // .
-      syntax_star = 6,                          // *
-      syntax_plus = 7,                          // +
-      syntax_question = 8,                      // ?
-      syntax_open_set = 9,                      // [
-      syntax_close_set = 10,                    // ]
-      syntax_or = 11,                           // |
-      syntax_slash = 12,                        //
-      syntax_hash = 13,                         // #
-      syntax_dash = 14,                         // -
-      syntax_open_brace = 15,                   // {
-      syntax_close_brace = 16,                  // }
-      syntax_digit = 17,                        // 0-9
-      syntax_b = 18,                            // for \b
-      syntax_B = 19,                            // for \B
-      syntax_left_word = 20,                    // for \<
-      syntax_right_word = 21,                   // for \>
-      syntax_w = 22,                            // for \w
-      syntax_W = 23,                            // for \W
-      syntax_start_buffer = 24,                 // for \`
-      syntax_end_buffer = 25,                   // for \'
-      syntax_newline = 26,                      // for newline alt
-      syntax_comma = 27,                        // for {x,y}
-
-      syntax_a = 28,                            // for \a
-      syntax_f = 29,                            // for \f
-      syntax_n = 30,                            // for \n
-      syntax_r = 31,                            // for \r
-      syntax_t = 32,                            // for \t
-      syntax_v = 33,                            // for \v
-      syntax_x = 34,                            // for \xdd
-      syntax_c = 35,                            // for \cx
-      syntax_colon = 36,                        // for [:...:]
-      syntax_equal = 37,                        // for [=...=]
-   
-      // perl ops:
-      syntax_e = 38,                            // for \e
-      syntax_l = 39,                            // for \l
-      syntax_L = 40,                            // for \L
-      syntax_u = 41,                            // for \u
-      syntax_U = 42,                            // for \U
-      syntax_s = 43,                            // for \s
-      syntax_S = 44,                            // for \S
-      syntax_d = 45,                            // for \d
-      syntax_D = 46,                            // for \D
-      syntax_E = 47,                            // for \Q\E
-      syntax_Q = 48,                            // for \Q\E
-      syntax_X = 49,                            // for \X
-      syntax_C = 50,                            // for \C
-      syntax_Z = 51,                            // for \Z
-      syntax_G = 52,                            // for \G
-
-      // new extentions:
-      syntax_not = 53,                          // for (?!...)
-
-      syntax_max = 54
-   };
-#ifdef __BORLANDC__
-private:
-   char dummy_member;
-#endif
-};
-
-struct BOOST_REGEX_DECL c_traits_base : public regex_traits_base
-{
-public:
-   enum{
-      char_class_none = 0,
-      char_class_alpha = 0x0001,
-      char_class_cntrl = 0x0002,
-      char_class_digit = 0x0004,
-      char_class_lower = 0x0008,
-      char_class_punct = 0x0010,
-      char_class_space = 0x0020,
-      char_class_upper = 0x0040,
-      char_class_xdigit = 0x0080,
-      char_class_blank = 0x0100,
-      char_class_underscore = 0x4000,
-      char_class_unicode = 0x8000,
-
-      char_class_alnum = char_class_alpha | char_class_digit,
-      char_class_graph = char_class_alpha | char_class_digit | char_class_punct | char_class_underscore,
-      char_class_print = char_class_alpha | char_class_digit | char_class_punct | char_class_underscore | char_class_blank,
-      char_class_word = char_class_alpha | char_class_digit | char_class_underscore
-   };
-   static std::string BOOST_REGEX_CALL set_message_catalogue(const std::string& s);
-protected:
-#if defined(__MWERKS__) && __MWERKS__ <= 0x6000
-   friend class c_regex_traits<char>;
-   friend class c_regex_traits<wchar_t>;
-#endif 
-
-   static char regex_message_catalogue[BOOST_REGEX_MAX_PATH];
-   enum syntax_map_size
-   {
-      map_size = UCHAR_MAX + 1
-   };
-
-   static unsigned char syntax_map[map_size];
-   static unsigned short class_map[map_size];
-   static char lower_case_map[map_size];
-
-   static boost::uint_fast32_t BOOST_REGEX_CALL do_lookup_class(const char* p);
-   static bool BOOST_REGEX_CALL do_lookup_collate(std::string& buf, const char* p);
-   static void BOOST_REGEX_CALL do_update_ctype();
-   static void BOOST_REGEX_CALL do_update_collate();
-public:
-   static std::string BOOST_REGEX_CALL error_string(unsigned id);
-   static char* BOOST_REGEX_CALL get_catalogue() { return regex_message_catalogue; }
-};
-
-} // namespace re_detail
-
-
-template<>
-class BOOST_REGEX_DECL c_regex_traits<char> : public re_detail::c_traits_base
-{
-   typedef re_detail::c_traits_base base_type;
-public:
-   typedef char char_type;
-   typedef unsigned char uchar_type;
-   typedef unsigned int size_type;
-   typedef std::string string_type;
-   typedef int locale_type;
-
-   static std::size_t BOOST_REGEX_CALL length(const char_type* p)
-   {
-      return std::strlen(p);
-   }
-   static unsigned int BOOST_REGEX_CALL syntax_type(size_type c)
-   {
-      return syntax_map[c];
-   }
-   static char BOOST_REGEX_CALL translate(char c, bool icase)
-   {
-      return icase ? lower_case_map[(size_type)(uchar_type)c] : c;
-   }
-   static void BOOST_REGEX_CALL transform(std::string& out, const std::string& in);
-
-   static void BOOST_REGEX_CALL transform_primary(std::string& out, const std::string& in);
-
-   static bool BOOST_REGEX_CALL is_separator(char c)
-   {
-      return BOOST_REGEX_MAKE_BOOL((c == '\n') || (c == '\r'));
-   }
-
-   static bool BOOST_REGEX_CALL is_combining(char)
-   {
-      return false;
-   }
-   
-   static bool BOOST_REGEX_CALL is_class(char c, boost::uint_fast32_t f)
-   {
-      return BOOST_REGEX_MAKE_BOOL(class_map[(size_type)(uchar_type)c] & f);
-   }
-
-   static int BOOST_REGEX_CALL toi(char c);
-   static int BOOST_REGEX_CALL toi(const char*& first, const char* last, int radix);
-
-   static boost::uint_fast32_t BOOST_REGEX_CALL lookup_classname(const char* first, const char* last)
-   {
-      std::string s(first, last);
-      return do_lookup_class(s.c_str());
-   }
-
-   static bool BOOST_REGEX_CALL lookup_collatename(std::string& buf, const char* first, const char* last)
-   {
-      std::string s(first, last);
-      return do_lookup_collate(buf, s.c_str());
-   }
-
-   static locale_type BOOST_REGEX_CALL imbue(locale_type l){ return l; }
-   locale_type BOOST_REGEX_CALL getloc()const{ return locale_type(); }
-
-   c_regex_traits()
-   {
-      init();
-   }
-   ~c_regex_traits()
-   {
-      m_free();
-   }
-   struct sentry
-   {
-      sentry(const c_regex_traits<char>&)
-      { c_regex_traits<char>::update(); }
-      operator void*() { return this; }
-   };
-   static void BOOST_REGEX_CALL update();
-private:
-   static void BOOST_REGEX_CALL init();
-   static void BOOST_REGEX_CALL m_free();
-   static c_regex_traits<char> i;
-
-   static unsigned sort_type;
-   static char sort_delim;
-};
-
-#ifndef BOOST_NO_WREGEX
-template<>
-class BOOST_REGEX_DECL c_regex_traits<wchar_t> : public re_detail::c_traits_base
-{
-   typedef re_detail::c_traits_base base_type;
-public:
-   typedef wchar_t char_type;
-   typedef unsigned short uchar_type;
-   typedef unsigned int size_type;
-   typedef std::basic_string<wchar_t> string_type;
-   typedef int locale_type; 
-   static std::size_t BOOST_REGEX_CALL length(const char_type* p)
-   {
-      return std::wcslen(p);
-   }
-   static unsigned int BOOST_REGEX_CALL syntax_type(size_type c);
-   static wchar_t BOOST_REGEX_CALL translate(wchar_t c, bool icase)
-   {
-      return icase ? ((c < 256) ? re_detail::wide_lower_case_map[(uchar_type)c] : std::towlower(c)) : c;
-   }
-
-   static void BOOST_REGEX_CALL transform(std::basic_string<wchar_t>& out, const std::basic_string<wchar_t>& in);
-
-   static void BOOST_REGEX_CALL transform_primary(std::basic_string<wchar_t>& out, const std::basic_string<wchar_t>& in);
-
-   static bool BOOST_REGEX_CALL is_separator(wchar_t c)
-   {
-      return BOOST_REGEX_MAKE_BOOL((c == L'\n') || (c == L'\r') || (c == (wchar_t)0x2028) || (c == (wchar_t)0x2029));
-   }
-
-   static bool BOOST_REGEX_CALL is_combining(wchar_t c)
-   { return re_detail::is_combining(c); }
-   
-   static bool BOOST_REGEX_CALL is_class(wchar_t c, boost::uint_fast32_t f)
-   {
-      return BOOST_REGEX_MAKE_BOOL(((uchar_type)c < 256) ? (re_detail::wide_unicode_classes[(size_type)(uchar_type)c] & f) : do_iswclass(c, f));
-   }
-
-   static int BOOST_REGEX_CALL toi(wchar_t c);
-   static int BOOST_REGEX_CALL toi(const wchar_t*& first, const wchar_t* last, int radix);
-
-   static boost::uint_fast32_t BOOST_REGEX_CALL lookup_classname(const wchar_t* first, const wchar_t* last);
-
-   static bool BOOST_REGEX_CALL lookup_collatename(std::basic_string<wchar_t>& s, const wchar_t* first, const wchar_t* last);
-
-   static locale_type BOOST_REGEX_CALL imbue(locale_type l){ return l; }
-   locale_type BOOST_REGEX_CALL getloc()const{ return locale_type(); }
-   c_regex_traits<wchar_t>()
-   { init(); }
-   ~c_regex_traits<wchar_t>()
-   { m_free(); }
-   struct sentry
-   {
-      sentry(const c_regex_traits<wchar_t>&)
-      { c_regex_traits<wchar_t>::update(); }
-      operator void*() { return this; }
-   };
-   static void BOOST_REGEX_CALL update();
-   static std::size_t BOOST_REGEX_CALL strnarrow(char *s1, std::size_t len, const wchar_t *s2);
-   static std::size_t BOOST_REGEX_CALL strwiden(wchar_t *s1, std::size_t len, const char *s2);
-private:
-   static bool BOOST_REGEX_CALL do_iswclass(wchar_t c, boost::uint_fast32_t f);
-   static void BOOST_REGEX_CALL m_free();
-   static void BOOST_REGEX_CALL init();
-   static bool BOOST_REGEX_CALL do_lookup_collate(std::basic_string<wchar_t>& out, const wchar_t* first, const wchar_t* last);
-   static c_regex_traits<wchar_t> init_;
-
-   static unsigned sort_type;
-   static wchar_t sort_delim;
-};
-#endif
-
-#if defined(_WIN32) && !defined(BOOST_REGEX_NO_W32)
-
-namespace re_detail{
-
-struct BOOST_REGEX_DECL w32_traits_base : public regex_traits_base
-{
-   enum{
-   char_class_none = 0,
-   char_class_alnum = C1_ALPHA | C1_DIGIT,
-   char_class_alpha = C1_ALPHA,
-   char_class_cntrl = C1_CNTRL,
-   char_class_digit = C1_DIGIT,
-   char_class_graph = C1_UPPER | C1_LOWER | C1_DIGIT | C1_PUNCT | C1_ALPHA,
-   char_class_lower = C1_LOWER,
-   char_class_print = C1_UPPER | C1_LOWER | C1_DIGIT | C1_PUNCT | C1_BLANK | C1_ALPHA,
-   char_class_punct = C1_PUNCT,
-   char_class_space = C1_SPACE,
-   char_class_upper = C1_UPPER,
-   char_class_xdigit = C1_XDIGIT,
-   char_class_blank = C1_BLANK,
-   char_class_underscore = 0x4000,
-   char_class_word = C1_ALPHA | C1_DIGIT | char_class_underscore,
-   char_class_unicode = 0x8000,
-   char_class_win = 0x01FF
-   };
-
-
-public:
-   static std::string BOOST_REGEX_CALL set_message_catalogue(const std::string& s);
-protected:
-   static char regex_message_catalogue[BOOST_REGEX_MAX_PATH];
-   enum syntax_map_size
-   {
-      map_size = UCHAR_MAX + 1
-   };
-
-   static unsigned char syntax_map[map_size];
-   static unsigned short class_map[map_size];
-   static char lower_case_map[map_size];
-
-   static boost::uint_fast32_t BOOST_REGEX_CALL do_lookup_class(const char* p);
-   static bool BOOST_REGEX_CALL do_lookup_collate(std::string& buf, const char* p);
-   static void BOOST_REGEX_CALL do_free();
-   static void BOOST_REGEX_CALL do_init();
-public:
-   static std::string BOOST_REGEX_CALL error_string(unsigned id);
-   static char* BOOST_REGEX_CALL get_catalogue() { return regex_message_catalogue; }
-};
-
-
-} // namespace re_detail
-
-template<class charT>
-class w32_regex_traits;
-
-template<>
-class BOOST_REGEX_DECL w32_regex_traits<char> : public re_detail::w32_traits_base
-{
-   typedef re_detail::w32_traits_base base_type;
-public:
-   typedef char char_type;
-   typedef unsigned char uchar_type;
-   typedef unsigned int size_type;
-   typedef std::string string_type;
-   typedef int locale_type;
-
-   static std::size_t BOOST_REGEX_CALL length(const char_type* p)
-   {
-      return std::strlen(p);
-   }
-   static unsigned int BOOST_REGEX_CALL syntax_type(size_type c)
-   {
-      return syntax_map[c];
-   }
-   static char BOOST_REGEX_CALL translate(char c, bool icase)
-   {
-      return icase ? lower_case_map[(size_type)(uchar_type)c] : c;
-   }
-   static void BOOST_REGEX_CALL transform(std::string& out, const std::string& in);
-
-   static void BOOST_REGEX_CALL transform_primary(std::string& out, const std::string& in);
-
-   static bool BOOST_REGEX_CALL is_separator(char c)
-   {
-      return BOOST_REGEX_MAKE_BOOL((c == '\n') || (c == '\r'));
-   }
-
-   static bool BOOST_REGEX_CALL is_combining(char)
-   {
-      return false;
-   }
-   
-   static bool BOOST_REGEX_CALL is_class(char c, boost::uint_fast32_t f)
-   {
-      return BOOST_REGEX_MAKE_BOOL(class_map[(size_type)(uchar_type)c] & f);
-   }
-
-   static int BOOST_REGEX_CALL toi(char c);
-   static int BOOST_REGEX_CALL toi(const char*& first, const char* last, int radix);
-
-   static boost::uint_fast32_t BOOST_REGEX_CALL lookup_classname(const char* first, const char* last)
-   {
-      std::string s(first, last);
-      return do_lookup_class(s.c_str());
-   }
-
-   static bool BOOST_REGEX_CALL lookup_collatename(std::string& buf, const char* first, const char* last)
-   {
-      std::string s(first, last);
-      return do_lookup_collate(buf, s.c_str());
-   }
-
-   static locale_type BOOST_REGEX_CALL imbue(locale_type l){ return l; }
-   locale_type BOOST_REGEX_CALL getloc()const{ return locale_type(); }
-
-   struct sentry
-   {
-      sentry(const w32_regex_traits<char>&)
-      { w32_regex_traits<char>::update(); }
-      ~sentry(){}
-      operator void*() { return this; }
-   };
-   static void BOOST_REGEX_CALL update();
-   w32_regex_traits();
-   ~w32_regex_traits();
-private:
-   static w32_regex_traits<char> i;
-};
-
-#ifndef BOOST_NO_WREGEX
-template<>
-class BOOST_REGEX_DECL w32_regex_traits<wchar_t> : public re_detail::w32_traits_base
-{
-   typedef re_detail::w32_traits_base base_type;
-public:
-   typedef wchar_t char_type;
-   typedef unsigned short uchar_type;
-   typedef unsigned int size_type;
-   typedef std::basic_string<wchar_t> string_type;
-   typedef int locale_type; 
-   static std::size_t BOOST_REGEX_CALL length(const char_type* p)
-   {
-      return std::wcslen(p);
-   }
-   static unsigned int BOOST_REGEX_CALL syntax_type(size_type c);
-   static wchar_t BOOST_REGEX_CALL translate(wchar_t c, bool icase)
-   {
-      return icase ? ((c < 256) ? re_detail::wide_lower_case_map[(uchar_type)c] : wtolower(c)) : c;
-   }
-
-   static void BOOST_REGEX_CALL transform(std::basic_string<wchar_t>& out, const std::basic_string<wchar_t>& in);
-
-   static void BOOST_REGEX_CALL transform_primary(std::basic_string<wchar_t>& out, const std::basic_string<wchar_t>& in);
-
-   static bool BOOST_REGEX_CALL is_separator(wchar_t c)
-   {
-      return BOOST_REGEX_MAKE_BOOL((c == L'\n') || (c == L'\r') || (c == (wchar_t)0x2028) || (c == (wchar_t)0x2029));
-   }
-
-   static bool BOOST_REGEX_CALL is_combining(wchar_t c)
-   { return re_detail::is_combining(c); }
-   
-   static bool BOOST_REGEX_CALL is_class(wchar_t c, boost::uint_fast32_t f)
-   {
-      return BOOST_REGEX_MAKE_BOOL(((uchar_type)c < 256) ? (wide_unicode_classes[(size_type)(uchar_type)c] & f) : do_iswclass(c, f));
-   }
-
-   static int BOOST_REGEX_CALL toi(wchar_t c);
-   static int BOOST_REGEX_CALL toi(const wchar_t*& first, const wchar_t* last, int radix);
-
-   static boost::uint_fast32_t BOOST_REGEX_CALL lookup_classname(const wchar_t* first, const wchar_t* last);
-
-   static bool BOOST_REGEX_CALL lookup_collatename(std::basic_string<wchar_t>& s, const wchar_t* first, const wchar_t* last);
-
-   static locale_type BOOST_REGEX_CALL imbue(locale_type l){ return l; }
-   locale_type BOOST_REGEX_CALL getloc()const{ return locale_type(); }
-
-   struct sentry
-   {
-      sentry(const w32_regex_traits<wchar_t>&)
-      { w32_regex_traits<wchar_t>::update(); }
-      ~sentry(){}
-      operator void*() { return this; }
-   };
-   static void BOOST_REGEX_CALL update();
-   w32_regex_traits();
-   ~w32_regex_traits();
-   static std::size_t BOOST_REGEX_CALL strnarrow(char *s1, std::size_t len, const wchar_t *s2);
-   static std::size_t BOOST_REGEX_CALL strwiden(wchar_t *s1, std::size_t len, const char *s2);
-
-private:
-   static bool BOOST_REGEX_CALL do_iswclass(wchar_t c, boost::uint_fast32_t f);
-   static bool BOOST_REGEX_CALL do_lookup_collate(std::basic_string<wchar_t>& out, const wchar_t* first, const wchar_t* last);
-   static w32_regex_traits<wchar_t> init_;
-   static wchar_t BOOST_REGEX_CALL wtolower(wchar_t c);
-   static unsigned short wide_unicode_classes[];
-};
-#endif // Wide strings
-#endif // Win32
-
-#if !defined(BOOST_NO_STD_LOCALE) && !defined(BOOST_NO_STD_WSTREAMBUF)
-
-} // namspace boost
-
-#ifdef __BORLANDC__
-  #pragma option pop
-#endif
-#include <locale>
-#ifdef __BORLANDC__
-   #pragma option push -a4 -b -Ve -pc
-#endif
-
-namespace boost{
-
-namespace re_detail
-{
-
-template <class charT>
-struct message_data;
-
-template <>
-struct message_data<char>;
-
-template <>
-struct message_data<wchar_t>;
-
-struct BOOST_REGEX_DECL cpp_regex_traits_base : public regex_traits_base
-{
-   enum char_class_type
-   {
-      char_class_none = 0,
-      char_class_alnum = std::ctype_base::alnum,
-      char_class_alpha = std::ctype_base::alpha,
-      char_class_cntrl = std::ctype_base::cntrl,
-      char_class_digit = std::ctype_base::digit,
-      char_class_graph = std::ctype_base::graph,
-      char_class_lower = std::ctype_base::lower,
-      char_class_print = std::ctype_base::print,
-      char_class_punct = std::ctype_base::punct,
-      char_class_space = std::ctype_base::space,
-      char_class_upper = std::ctype_base::upper,
-      char_class_xdigit = std::ctype_base::xdigit,
-      char_class_blank = 1<<12,
-      char_class_underscore = 1<<13,
-      char_class_word = std::ctype_base::alnum | char_class_underscore,
-      char_class_unicode = 1<<14,
-      char_class_all_base = char_class_alnum | char_class_alpha | char_class_cntrl
-                         | char_class_digit | char_class_graph | char_class_lower
-                         | char_class_print | char_class_punct | char_class_space
-                         | char_class_upper | char_class_xdigit
-   };
-
-   static std::string BOOST_REGEX_CALL set_message_catalogue(const std::string& s);
-protected:
-   static char regex_message_cat[BOOST_REGEX_MAX_PATH];
-};
-
-} // namespace re_detail
-
-template <class charT>
-class cpp_regex_traits;
-
-template<>
-class BOOST_REGEX_DECL cpp_regex_traits<char> : public re_detail::cpp_regex_traits_base
-{
-   typedef re_detail::cpp_regex_traits_base base_type;
-private:
-   re_detail::message_data<char>* pmd;
-   const unsigned char* psyntax;
-   char* lower_map;
-   const std::ctype<char>* pctype;
-   const std::collate<char>* pcollate;
-   std::locale locale_inst;
-   unsigned sort_type;
-   char sort_delim;
-
-   cpp_regex_traits(const cpp_regex_traits&);
-   cpp_regex_traits& operator=(const cpp_regex_traits&);
-
-public:
-   typedef char char_type;
-   typedef unsigned char uchar_type;
-   typedef unsigned int size_type;
-   typedef std::string string_type;
-   typedef std::locale locale_type;
-
-   cpp_regex_traits();
-   ~cpp_regex_traits();
-
-   static std::size_t BOOST_REGEX_CALL length(const char_type* p)
-   {
-      return std::strlen(p);
-   }
-   unsigned int BOOST_REGEX_CALL syntax_type(size_type c)const
-   {
-      return psyntax[c];
-   }
-   char BOOST_REGEX_CALL translate(char c, bool icase)const
-   {
-      return icase ? lower_map[(size_type)(uchar_type)c] : c;
-   }
-   void BOOST_REGEX_CALL transform(std::string& out, const std::string& in)const
-   {
-      out = pcollate->transform(in.c_str(), in.c_str() + in.size()).c_str();
-   }
-
-   void BOOST_REGEX_CALL transform_primary(std::string& out, const std::string& in)const;
-
-   static bool BOOST_REGEX_CALL is_separator(char c)
-   {
-      return BOOST_REGEX_MAKE_BOOL((c == '\n') || (c == '\r'));
-   }
-
-   static bool BOOST_REGEX_CALL is_combining(char)
-   {
-      return false;
-   }
-   
-   bool BOOST_REGEX_CALL is_class(char c, boost::uint_fast32_t f)const
-   {
-      if(pctype->is((std::ctype<char>::mask)(f & char_class_all_base), c))
-         return true;
-      if((f & char_class_underscore) && (c == '_'))
-         return true;
-      if((f & char_class_blank) && ((c == ' ') || (c == '\t')))
-         return true;
-      return false;
-   }
-
-   int BOOST_REGEX_CALL toi(char c)const;
-   int BOOST_REGEX_CALL toi(const char*& first, const char* last, int radix)const;
-
-   boost::uint_fast32_t BOOST_REGEX_CALL lookup_classname(const char* first, const char* last)const;
-   bool BOOST_REGEX_CALL lookup_collatename(std::string& s, const char* first, const char* last)const;
-
-   std::string BOOST_REGEX_CALL error_string(unsigned id)const;
-   locale_type BOOST_REGEX_CALL imbue(locale_type l);
-   locale_type BOOST_REGEX_CALL getloc()const{ return locale_inst; }
-
-   struct sentry
-   {
-      sentry(const cpp_regex_traits<char>&){}
-      operator void*() { return this; }
-   };
-};
-
-#ifndef BOOST_NO_WREGEX
-template<>
-class BOOST_REGEX_DECL cpp_regex_traits<wchar_t> : public re_detail::cpp_regex_traits_base
-{
-   typedef re_detail::cpp_regex_traits_base base_type;
-public:
-   typedef wchar_t char_type;
-   typedef unsigned short uchar_type;
-   typedef unsigned int size_type;
-   typedef std::basic_string<wchar_t> string_type;
-   typedef std::locale locale_type;
-
-private:
-   re_detail::message_data<wchar_t>* pmd;
-   const unsigned char* psyntax;
-   wchar_t* lower_map;
-   const std::ctype<wchar_t>* pctype;
-   const std::collate<wchar_t>* pcollate;
-   const std::codecvt<wchar_t, char, std::mbstate_t>* pcdv;
-   std::locale locale_inst;
-   unsigned int BOOST_REGEX_CALL do_syntax_type(size_type c)const;
-   unsigned sort_type;
-   wchar_t sort_delim;
-
-   cpp_regex_traits(const cpp_regex_traits&);
-   cpp_regex_traits& operator=(const cpp_regex_traits&);
-
-public:
-
-   static std::size_t BOOST_REGEX_CALL length(const char_type* p)
-   {
-      return std::wcslen(p);
-   }
-   unsigned int BOOST_REGEX_CALL syntax_type(size_type c)const
-   {
-      return (c < UCHAR_MAX) ? psyntax[c] : do_syntax_type(c);
-   }
-   wchar_t BOOST_REGEX_CALL translate(wchar_t c, bool icase)const
-   {
-      return icase ? (((uchar_type)c) <= UCHAR_MAX) ? lower_map[c] : pctype->tolower(c) : c;
-   }
-   void BOOST_REGEX_CALL transform(std::basic_string<wchar_t>& out, const std::basic_string<wchar_t>& in)const
-   {
-      out = pcollate->transform(in.c_str(), in.c_str() + in.size());
-   }
-
-   void BOOST_REGEX_CALL transform_primary(std::basic_string<wchar_t>& out, const std::basic_string<wchar_t>& in)const;
-
-   static bool BOOST_REGEX_CALL is_separator(wchar_t c)
-   {
-      return BOOST_REGEX_MAKE_BOOL((c == L'\n') || (c == L'\r') || (c == (wchar_t)0x2028) || (c == (wchar_t)0x2029));
-   }
-
-   static bool BOOST_REGEX_CALL is_combining(wchar_t c)
-   { return re_detail::is_combining(c); }
-   
-   bool BOOST_REGEX_CALL is_class(wchar_t c, boost::uint_fast32_t f)const
-   {
-      if(pctype->is((std::ctype<wchar_t>::mask)(f & char_class_all_base), c))
-         return true;
-      if((f & char_class_underscore) && (c == '_'))
-         return true;
-      if((f & char_class_blank) && ((c == ' ') || (c == '\t')))
-         return true;
-      if((f & char_class_unicode) && ((uchar_type)c > (uchar_type)255))
-         return true;
-      return false;
-   }
-
-   int BOOST_REGEX_CALL toi(wchar_t c)const;
-   int BOOST_REGEX_CALL toi(const wchar_t*& first, const wchar_t* last, int radix)const;
-
-   boost::uint_fast32_t BOOST_REGEX_CALL lookup_classname(const wchar_t* first, const wchar_t* last)const;
-   bool BOOST_REGEX_CALL lookup_collatename(std::basic_string<wchar_t>& s, const wchar_t* first, const wchar_t* last)const;
-
-   std::string BOOST_REGEX_CALL error_string(unsigned id)const;
-   cpp_regex_traits();
-   ~cpp_regex_traits();
-   locale_type BOOST_REGEX_CALL imbue(locale_type l);
-   locale_type BOOST_REGEX_CALL getloc()const{ return locale_inst; }
-   std::size_t BOOST_REGEX_CALL strwiden(wchar_t *s1, std::size_t len, const char *s2)const;
-
-   struct sentry
-   {
-      sentry(const cpp_regex_traits<wchar_t>&){}
-      operator void*() { return this; }
-   };
-};
-#endif // BOOST_NO_WREGEX
-
-#endif // BOOST_NO_STD_LOCALE
-
-#ifdef BOOST_REGEX_USE_WIN32_LOCALE
-
-template <class charT>
-class regex_traits : public w32_regex_traits<charT>
-{
-};
-
-#elif defined(BOOST_REGEX_USE_C_LOCALE)
-
-template <class charT>
-class regex_traits : public c_regex_traits<charT>
-{
-};
-
-#elif defined(BOOST_REGEX_USE_CPP_LOCALE)
-
-template <class charT>
-class regex_traits : public cpp_regex_traits<charT>
-{
-};
-
-#else
-#error No default localisation model defined
-#endif
-
-#ifdef __BORLANDC__
-  #pragma option pop
-#endif
-
-} // namespace boost
-
 #endif // include
 
 
 
+

include/boost/regex/src.cpp

@@ -19,15 +19,23 @@
   *   VERSION      see <boost/version.hpp>
   *   DESCRIPTION: Includes all the regex source files, include this
   *                file only if you need to build the regex library
-  *                as a single file.  Before including this file you
-  *                must define BOOST_REGEX_NO_LIB, or include this file
+  *                as a single file.  You must include this file
   *                before any other regex header.
+  *
+  *                CAUTION: THIS FILE IS DEPRICATED AND WILL CAUSE 
+  *                UNNECESSARY CODE BLOAT.
   */
 
-#if !defined(BOOST_REGEX_NO_LIB) && defined(BOOST_REGEX_CONFIG_HPP)
-#error too late you have already included a regex header - try defining BOOST_REGEX_NO_LIB when you build
+#if (!defined(BOOST_REGEX_NO_LIB) || !defined(BOOST_REGEX_NO_EXTERNAL_TEMPLATES)) && defined(BOOST_REGEX_CONFIG_HPP)
+#error too late you have already included a regex header - make sure that you include this header before any other boost header
 #endif
 
+#define BOOST_REGEX_NO_LIB
+#define BOOST_REGEX_STATIC_LINK
+#define BOOST_REGEX_NO_EXTERNAL_TEMPLATES
+
+#include <boost/regex.hpp>
+
 //
 // include library source files:
 //
@@ -47,3 +55,4 @@
 #include "libs/regex/src/regex_debug.cpp"
 #include "libs/regex/src/regex_synch.cpp"
 
+

include/boost/regex/v3/cregex.hpp

@@ -0,0 +1,316 @@
+/*
+ *
+ * Copyright (c) 1998-2002
+ * Dr John Maddock
+ *
+ * Permission to use, copy, modify, distribute and sell this software
+ * and its documentation for any purpose is hereby granted without fee,
+ * provided that the above copyright notice appear in all copies and
+ * that both that copyright notice and this permission notice appear
+ * in supporting documentation.  Dr John Maddock makes no representations
+ * about the suitability of this software for any purpose.  
+ * It is provided "as is" without express or implied warranty.
+ *
+ */
+ 
+ /*
+  *   LOCATION:    see http://www.boost.org for most recent version.
+  *   FILE         cregex.cpp
+  *   VERSION      see <boost/version.hpp>
+  *   DESCRIPTION: Declares POSIX API functions
+  *                + boost::RegEx high level wrapper.
+  */
+
+#ifndef BOOST_RE_CREGEX_HPP_INCLUDED
+#define BOOST_RE_CREGEX_HPP_INCLUDED
+
+#ifndef BOOST_REGEX_CONFIG_HPP
+#include <boost/regex/config.hpp>
+#endif
+
+#ifdef __BORLANDC__
+   #pragma option push -a8 -b -Vx -Ve -pc
+#endif
+
+/* include these defs only for POSIX compatablity */
+#ifdef __cplusplus
+namespace boost{
+extern "C" {
+#endif
+
+#if defined(__cplusplus) && !defined(BOOST_NO_STDC_NAMESPACE)
+typedef std::ptrdiff_t regoff_t;
+typedef std::size_t regsize_t;
+#else
+typedef ptrdiff_t regoff_t;
+typedef size_t regsize_t;
+#endif
+
+typedef struct
+{
+   unsigned int re_magic;
+   unsigned int re_nsub;      /* number of parenthesized subexpressions */
+   const char* re_endp;       /* end pointer for REG_PEND */
+   void* guts;             /* none of your business :-) */
+   unsigned int eflags;       /* none of your business :-) */
+} regex_tA;
+
+#ifndef BOOST_NO_WREGEX
+typedef struct
+{
+   unsigned int re_magic;
+   unsigned int re_nsub;      /* number of parenthesized subexpressions */
+   const wchar_t* re_endp;       /* end pointer for REG_PEND */
+   void* guts;             /* none of your business :-) */
+   unsigned int eflags;       /* none of your business :-) */
+} regex_tW;
+#endif
+
+typedef struct
+{
+   regoff_t rm_so;      /* start of match */
+   regoff_t rm_eo;      /* end of match */
+} regmatch_t;
+
+/* regcomp() flags */
+typedef enum{
+   REG_BASIC = 0000,
+   REG_EXTENDED = 0001,
+   REG_ICASE = 0002,
+   REG_NOSUB = 0004,
+   REG_NEWLINE = 0010,
+   REG_NOSPEC = 0020,
+   REG_PEND = 0040,
+   REG_DUMP = 0200,
+   REG_NOCOLLATE = 0400,
+   REG_ESCAPE_IN_LISTS = 01000,
+   REG_NEWLINE_ALT = 02000,
+
+   REG_PERL = REG_EXTENDED | REG_NOCOLLATE | REG_ESCAPE_IN_LISTS,
+   REG_AWK = REG_EXTENDED | REG_ESCAPE_IN_LISTS,
+   REG_GREP = REG_BASIC | REG_NEWLINE_ALT,
+   REG_EGREP = REG_EXTENDED | REG_NEWLINE_ALT,
+
+   REG_ASSERT = 15,
+   REG_INVARG = 16,
+   REG_ATOI = 255,   /* convert name to number (!) */
+   REG_ITOA = 0400   /* convert number to name (!) */
+} reg_comp_flags;
+
+/* regexec() flags */
+typedef enum{
+   REG_NOTBOL =    00001,
+   REG_NOTEOL =    00002,
+   REG_STARTEND =  00004
+} reg_exec_flags;
+
+BOOST_REGEX_DECL int BOOST_REGEX_CCALL regcompA(regex_tA*, const char*, int);
+BOOST_REGEX_DECL regsize_t BOOST_REGEX_CCALL regerrorA(int, const regex_tA*, char*, regsize_t);
+BOOST_REGEX_DECL int BOOST_REGEX_CCALL regexecA(const regex_tA*, const char*, regsize_t, regmatch_t*, int);
+BOOST_REGEX_DECL void BOOST_REGEX_CCALL regfreeA(regex_tA*);
+
+#ifndef BOOST_NO_WREGEX
+BOOST_REGEX_DECL int BOOST_REGEX_CCALL regcompW(regex_tW*, const wchar_t*, int);
+BOOST_REGEX_DECL regsize_t BOOST_REGEX_CCALL regerrorW(int, const regex_tW*, wchar_t*, regsize_t);
+BOOST_REGEX_DECL int BOOST_REGEX_CCALL regexecW(const regex_tW*, const wchar_t*, regsize_t, regmatch_t*, int);
+BOOST_REGEX_DECL void BOOST_REGEX_CCALL regfreeW(regex_tW*);
+#endif
+
+#ifdef UNICODE
+#define regcomp regcompW
+#define regerror regerrorW
+#define regexec regexecW
+#define regfree regfreeW
+#define regex_t regex_tW
+#else
+#define regcomp regcompA
+#define regerror regerrorA
+#define regexec regexecA
+#define regfree regfreeA
+#define regex_t regex_tA
+#endif
+
+/* regerror() flags */
+typedef enum
+{
+  REG_NOERROR = 0,   /* Success.  */
+  REG_NOMATCH = 1,      /* Didn't find a match (for regexec).  */
+
+  /* POSIX regcomp return error codes.  (In the order listed in the
+     standard.)  */
+  REG_BADPAT = 2,    /* Invalid pattern.  */
+  REG_ECOLLATE = 3,  /* Undefined collating element.  */
+  REG_ECTYPE = 4,    /* Invalid character class name.  */
+  REG_EESCAPE = 5,   /* Trailing backslash.  */
+  REG_ESUBREG = 6,   /* Invalid back reference.  */
+  REG_EBRACK = 7,    /* Unmatched left bracket.  */
+  REG_EPAREN = 8,    /* Parenthesis imbalance.  */
+  REG_EBRACE = 9,    /* Unmatched \{.  */
+  REG_BADBR = 10,    /* Invalid contents of \{\}.  */
+  REG_ERANGE = 11,   /* Invalid range end.  */
+  REG_ESPACE = 12,   /* Ran out of memory.  */
+  REG_BADRPT = 13,   /* No preceding re for repetition op.  */
+  REG_EEND = 14,     /* unexpected end of expression */
+  REG_ESIZE = 15,    /* expression too big */
+  REG_ERPAREN = 16,   /* unmatched right parenthesis */
+  REG_EMPTY = 17,    /* empty expression */
+  REG_E_MEMORY = REG_ESIZE, /* out of memory */
+  REG_E_UNKNOWN = 18 /* unknown error */
+} reg_errcode_t;
+
+enum match_flags
+{
+   match_default = 0,
+   match_not_bol = 1,                                // first is not start of line
+   match_not_eol = match_not_bol << 1,               // last is not end of line
+   match_not_bob = match_not_eol << 1,               // first is not start of buffer
+   match_not_eob = match_not_bob << 1,               // last is not end of buffer
+   match_not_bow = match_not_eob << 1,               // first is not start of word
+   match_not_eow = match_not_bow << 1,               // last is not end of word
+   match_not_dot_newline = match_not_eow << 1,       // \n is not matched by '.'
+   match_not_dot_null = match_not_dot_newline << 1,  // '\0' is not matched by '.'
+   match_prev_avail = match_not_dot_null << 1,       // *--first is a valid expression
+   match_init = match_prev_avail << 1,               // internal use
+   match_any = match_init << 1,                      // don't care what we match
+   match_not_null = match_any << 1,                  // string can't be null
+   match_continuous = match_not_null << 1,           // each grep match must continue from
+                                                     // uninterupted from the previous one
+   match_partial = match_continuous << 1,            // find partial matches
+   
+   match_stop = match_partial << 1,                  // stop after first match (grep)
+   match_all = match_stop << 1,                      // must find the whole of input even if match_any is set
+   match_max = match_all
+};
+
+
+#ifdef __cplusplus
+} // extern "C"
+} // namespace
+#endif
+
+
+#ifdef __BORLANDC__
+ #if __BORLANDC__ > 0x520
+  #pragma option pop
+ #endif
+#endif
+
+
+//
+// C++ high level wrapper goes here:
+//
+#if defined(__cplusplus)
+#include <string>
+#include <vector>
+namespace boost{
+
+#ifdef __BORLANDC__
+   #if __BORLANDC__ == 0x530
+    #pragma option push -a4 -b
+   #elif __BORLANDC__ > 0x530
+    #pragma option push -a8 -b
+   #endif
+#endif
+
+class RegEx;
+
+namespace re_detail{
+
+class RegExData;
+struct pred1;
+struct pred2;
+struct pred3;
+struct pred4;
+
+}  // namespace re_detail
+
+#if defined(BOOST_MSVC) || defined(__BORLANDC__)
+typedef bool (__cdecl *GrepCallback)(const RegEx& expression);
+typedef bool (__cdecl *GrepFileCallback)(const char* file, const RegEx& expression);
+typedef bool (__cdecl *FindFilesCallback)(const char* file);
+#else
+typedef bool (*GrepCallback)(const RegEx& expression);
+typedef bool (*GrepFileCallback)(const char* file, const RegEx& expression);
+typedef bool (*FindFilesCallback)(const char* file);
+#endif
+
+class BOOST_REGEX_DECL RegEx
+{
+private:
+   re_detail::RegExData* pdata;
+public:
+   RegEx();
+   RegEx(const RegEx& o);
+   ~RegEx();
+   explicit RegEx(const char* c, bool icase = false);
+   explicit RegEx(const std::string& s, bool icase = false);
+   RegEx& operator=(const RegEx& o);
+   RegEx& operator=(const char* p);
+   RegEx& operator=(const std::string& s){ return this->operator=(s.c_str()); }
+   unsigned int SetExpression(const char* p, bool icase = false);
+   unsigned int SetExpression(const std::string& s, bool icase = false){ return SetExpression(s.c_str(), icase); }
+   std::string Expression()const;
+   unsigned int error_code()const;
+   //
+   // now matching operators:
+   //
+   bool Match(const char* p, unsigned int flags = match_default);
+   bool Match(const std::string& s, unsigned int flags = match_default) { return Match(s.c_str(), flags); }
+   bool Search(const char* p, unsigned int flags = match_default);
+   bool Search(const std::string& s, unsigned int flags = match_default) { return Search(s.c_str(), flags); }
+   unsigned int Grep(GrepCallback cb, const char* p, unsigned int flags = match_default);
+   unsigned int Grep(GrepCallback cb, const std::string& s, unsigned int flags = match_default) { return Grep(cb, s.c_str(), flags); }
+   unsigned int Grep(std::vector<std::string>& v, const char* p, unsigned int flags = match_default);
+   unsigned int Grep(std::vector<std::string>& v, const std::string& s, unsigned int flags = match_default) { return Grep(v, s.c_str(), flags); }
+   unsigned int Grep(std::vector<std::size_t>& v, const char* p, unsigned int flags = match_default);
+   unsigned int Grep(std::vector<std::size_t>& v, const std::string& s, unsigned int flags = match_default) { return Grep(v, s.c_str(), flags); }
+#ifndef BOOST_REGEX_NO_FILEITER
+   unsigned int GrepFiles(GrepFileCallback cb, const char* files, bool recurse = false, unsigned int flags = match_default);
+   unsigned int GrepFiles(GrepFileCallback cb, const std::string& files, bool recurse = false, unsigned int flags = match_default) { return GrepFiles(cb, files.c_str(), recurse, flags); }
+   unsigned int FindFiles(FindFilesCallback cb, const char* files, bool recurse = false, unsigned int flags = match_default);
+   unsigned int FindFiles(FindFilesCallback cb, const std::string& files, bool recurse = false, unsigned int flags = match_default) { return FindFiles(cb, files.c_str(), recurse, flags); }
+#endif
+
+   std::string Merge(const std::string& in, const std::string& fmt,
+                       bool copy = true, unsigned int flags = match_default);
+   std::string Merge(const char* in, const char* fmt,
+                       bool copy = true, unsigned int flags = match_default);
+
+   std::size_t Split(std::vector<std::string>& v, std::string& s, unsigned flags = match_default, unsigned max_count = ~0);
+   //
+   // now operators for returning what matched in more detail:
+   //
+   std::size_t Position(int i = 0)const;
+   std::size_t Length(int i = 0)const;
+   bool Matched(int i = 0)const;
+   unsigned int Line()const;
+   unsigned int Marks()const;
+   std::string What(int i = 0)const;
+   std::string operator[](int i)const { return What(i); }
+
+   static const unsigned int npos;
+
+   friend struct re_detail::pred1;
+   friend struct re_detail::pred2;
+   friend struct re_detail::pred3;
+   friend struct re_detail::pred4;
+};
+
+#ifdef __BORLANDC__
+  #pragma option pop
+#endif
+
+} // namespace boost
+
+#endif
+
+#endif // include guard
+
+
+
+
+
+
+
+
+

include/boost/regex/v3/fileiter.hpp

@@ -22,10 +22,12 @@
   *                the form of class map_file.
   */
 
-#ifndef BOOST_RE_FILEITER_HPP
-#define BOOST_RE_FILEITER_HPP
+#ifndef BOOST_RE_FILEITER_HPP_INCLUDED
+#define BOOST_RE_FILEITER_HPP_INCLUDED
 
+#ifndef BOOST_REGEX_CONFIG_HPP
 #include <boost/regex/config.hpp>
+#endif
 
 #ifndef BOOST_REGEX_NO_FILEITER
 
@@ -451,3 +453,4 @@ using boost::re_detail::mapfile;
 
 
 
+

include/boost/regex/v3/instances.hpp

@@ -21,6 +21,9 @@
   *                library rather than in the users object files.
   */
 
+//
+// note no include guard, we may include this multiple times:
+//
 #ifndef BOOST_REGEX_NO_EXTERNAL_TEMPLATES
 
 namespace boost{
@@ -162,3 +165,4 @@ template void BOOST_REGEX_CALL match_results_base<iterator, Allocator>::cow();
 #endif // BOOST_REGEX_NO_EXTERNAL_TEMPLATES
  
 
+

include/boost/regex/v3/regex_compile.hpp

@@ -1266,6 +1266,10 @@ unsigned int BOOST_REGEX_CALL reg_expression<charT, traits, Allocator>::set_expr
 # ifdef BOOST_MSVC
 #  pragma warning(push)
 #  pragma warning(disable: 4127)
+#endif
+#ifdef __OpenBSD__
+   // strxfrm not working on OpenBSD??
+   f |= regbase::nocollate;
 #endif
 
    if(p == expression())
@@ -1986,6 +1990,8 @@ unsigned int BOOST_REGEX_CALL reg_expression<charT, traits, Allocator>::probe_re
    {
    case re_detail::syntax_element_startmark:
    case re_detail::syntax_element_endmark:
+      if(static_cast<const re_detail::re_brace*>(dat)->index == -2)
+         return regbase::restart_any;
       return probe_restart(dat->next.p);
    case re_detail::syntax_element_start_line:
       return regbase::restart_line;
@@ -2014,7 +2020,7 @@ unsigned int BOOST_REGEX_CALL reg_expression<charT, traits, Allocator>::fixup_le
          if((leading_lit) && (static_cast<re_detail::re_literal*>(dat)->length > 2))
          {
             // we can do a literal search for the leading literal string
-            // using Knuth-Morris-Pratt (or whatever), and only then check for 
+            // using Knuth-Morris-Pratt (or whatever), and only then check for
             // matches.  We need a decent length string though to make it
             // worth while.
             _leading_string = reinterpret_cast<charT*>(reinterpret_cast<char*>(dat) + sizeof(re_detail::re_literal));
@@ -2062,10 +2068,14 @@ unsigned int BOOST_REGEX_CALL reg_expression<charT, traits, Allocator>::fixup_le
       case re_detail::syntax_element_rep:
          if((len == 0) && (1 == fixup_leading_rep(dat->next.p, static_cast<re_detail::re_repeat*>(dat)->alt.p) ))
          {
-            static_cast<re_detail::re_repeat*>(dat)->leading = true;
+            static_cast<re_detail::re_repeat*>(dat)->leading = leading_lit;
             return len;
          }
          return len;
+      case re_detail::syntax_element_startmark:
+         if(static_cast<const re_detail::re_brace*>(dat)->index == -2)
+            return 0;
+         // fall through:
       default:
          break;
       }
@@ -2110,3 +2120,5 @@ void BOOST_REGEX_CALL reg_expression<charT, traits, Allocator>::fail(unsigned in
 
 
 
+
+

include/boost/regex/v3/regex_fwd.hpp

@@ -0,0 +1,70 @@
+/*
+ *
+ * Copyright (c) 1998-2002
+ * Dr John Maddock
+ *
+ * Permission to use, copy, modify, distribute and sell this software
+ * and its documentation for any purpose is hereby granted without fee,
+ * provided that the above copyright notice appear in all copies and
+ * that both that copyright notice and this permission notice appear
+ * in supporting documentation.  Dr John Maddock makes no representations
+ * about the suitability of this software for any purpose.
+ * It is provided "as is" without express or implied warranty.
+ *
+ */
+
+ /*
+  *   LOCATION:    see http://www.boost.org for most recent version.
+  *   FILE         regex_fwd.cpp
+  *   VERSION      see <boost/version.hpp>
+  *   DESCRIPTION: Forward declares boost::reg_expression<> and
+  *                associated typedefs.
+  */
+
+#ifndef BOOST_REGEX_FWD_HPP_INCLUDED
+#define BOOST_REGEX_FWD_HPP_INCLUDED
+
+#ifndef BOOST_REGEX_CONFIG_HPP
+#include <boost/config.hpp>
+#endif
+#include <boost/detail/allocator.hpp>
+
+//
+// define BOOST_REGEX_NO_FWD if this
+// header doesn't work!
+//
+#ifdef BOOST_REGEX_NO_FWD
+#  ifndef BOOST_RE_REGEX_HPP
+#     include <boost/regex.hpp>
+#  endif
+#else
+
+//
+// If there isn't good enough wide character support then there will
+// be no wide character regular expressions:
+//
+#if (defined(BOOST_NO_CWCHAR) || defined(BOOST_NO_CWCTYPE) || defined(BOOST_NO_STD_WSTRING)) && !defined(BOOST_NO_WREGEX)
+#  define BOOST_NO_WREGEX
+#endif
+
+namespace boost{
+
+template <class charT>
+class regex_traits;
+
+template <class charT, class traits = regex_traits<charT>, class Allocator = BOOST_DEFAULT_ALLOCATOR(charT) >
+class reg_expression;
+
+typedef reg_expression<char, regex_traits<char>, BOOST_DEFAULT_ALLOCATOR(char) > regex;
+#ifndef BOOST_NO_WREGEX
+typedef reg_expression<wchar_t, regex_traits<wchar_t>, BOOST_DEFAULT_ALLOCATOR(wchar_t) > wregex;
+#endif
+
+} // namespace boost
+
+#endif  // BOOST_REGEX_NO_FWD
+
+#endif
+
+
+

include/boost/regex/v3/regex_match.hpp

@@ -56,8 +56,10 @@ inline int string_compare(const std::basic_string<C,T,A>& s, const C* p)
 { return s.compare(p); }
 inline int string_compare(const std::string& s, const char* p)
 { return std::strcmp(s.c_str(), p); }
+# ifndef BOOST_NO_WREGEX
 inline int string_compare(const std::wstring& s, const wchar_t* p)
 { return std::wcscmp(s.c_str(), p); }
+# endif
 # define STR_COMP(s,p) string_compare(s,p)
 #endif
 
@@ -213,7 +215,11 @@ public:
    }
    void estimate_max_state_count(iterator a, iterator b, std::size_t states, std::random_access_iterator_tag*)
    {
+#ifndef BOOST_NO_STD_DISTANCE
       difference_type dist = std::distance(a,b);
+#else
+      difference_type dist = b - a;
+#endif
       states *= states;
       difference_type lim = std::numeric_limits<difference_type>::max() - 1000 - states;
       if(dist > (difference_type)(lim / states))
@@ -749,6 +755,15 @@ bool query_match_aux(iterator first,
                   start_loop[cur_acc] = first;
                   continue;
                }
+               else if((unsigned int)accumulators[cur_acc] < static_cast<const re_repeat*>(ptr)->min)
+               {
+                  // the repeat was null, and we haven't gone round min times yet,
+                  // since all subsequent repeats will be null as well, just update
+                  // our repeat count and skip out.
+                  accumulators[cur_acc] = static_cast<const re_repeat*>(ptr)->min;
+                  ptr = static_cast<const re_repeat*>(ptr)->alt.p;
+                  continue;
+               }
                goto failure;
             }
             // see if we can skip the repeat:
@@ -805,6 +820,15 @@ bool query_match_aux(iterator first,
             start_loop[cur_acc] = first;
             continue;
          }
+         else if((first == start_loop[cur_acc]) && accumulators[cur_acc] && ((unsigned int)accumulators[cur_acc] < static_cast<const re_repeat*>(ptr)->min))
+         {
+            // the repeat was null, and we haven't gone round min times yet,
+            // since all subsequent repeats will be null as well, just update
+            // our repeat count and skip out.
+            accumulators[cur_acc] = static_cast<const re_repeat*>(ptr)->min;
+            ptr = static_cast<const re_repeat*>(ptr)->alt.p;
+            continue;
+         }
 
          // if we get here then neither option is allowed so fail:
          goto failure;
@@ -822,7 +846,7 @@ bool query_match_aux(iterator first,
             if(flags & match_not_eob)
                goto failure;
             iterator p(first);
-            while((p != last) && traits_inst.is_separator(traits_inst.translate(*first, icase)))++p;
+            while((p != last) && traits_inst.is_separator(traits_inst.translate(*p, icase)))++p;
             if(p != last)
                goto failure;
             ptr = ptr->next.p;
@@ -954,6 +978,12 @@ bool query_match_aux(iterator first,
             goto failure;
          ptr = ptr->next.p;
          continue;
+      case syntax_element_backref:
+         if(temp_match[static_cast<const re_brace*>(ptr)->index].first
+               != temp_match[static_cast<const re_brace*>(ptr)->index].second)
+               goto failure;
+         ptr = ptr->next.p;
+         continue;
       default:
          goto failure;
       }
@@ -1225,6 +1255,7 @@ unsigned int reg_grep2(Predicate foo, I first, I last, const reg_expression<char
    I next_base;
    I base = first;
    bool need_init;
+   bool leading_match = false;
    const traits& traits_inst = e.get_traits();
    // dwa 9/13/00 suppress incorrect MSVC warning - it claims this is never
    // referenced
@@ -1258,6 +1289,7 @@ unsigned int reg_grep2(Predicate foo, I first, I last, const reg_expression<char
       if(query_match_aux(first, last, m, e, flags, pd, &restart))
       {
          ++cmatches;
+         leading_match = true;
          if(foo(m) == false)
             return cmatches;
          if(m[0].second == last)
@@ -1280,6 +1312,7 @@ unsigned int reg_grep2(Predicate foo, I first, I last, const reg_expression<char
             else
             {
                need_init = false;
+               leading_match = false;
                for(unsigned int i = 0; (restart != first) && (i < access::leading_length(e)); ++i, --restart)
                    {} // dwa 10/20/2000 - warning suppression for MWCW
                if(restart != last)
@@ -1623,6 +1656,8 @@ unsigned int reg_grep2(Predicate foo, I first, I last, const reg_expression<char
    break;
    case regbase::restart_continue:
    {
+      if(!leading_match)
+         return cmatches;
       while(first != last)
       {
          if( access::can_start(*first, _map, (unsigned char)mask_any) )
@@ -1982,3 +2017,4 @@ inline unsigned int regex_grep(bool (*foo)(const match_results<std::basic_string
 
 
 
+

include/boost/regex/v3/regex_split.hpp

@@ -36,7 +36,7 @@ namespace re_detail{
 template <class charT>
 const reg_expression<charT>& get_default_expression(charT)
 {
-   static const charT expression_text[] = { '\\', 's', '+', '\00', };
+   static const charT expression_text[4] = { '\\', 's', '+', '\00', };
    static const reg_expression<charT> e(expression_text);
    return e;
 }
@@ -149,3 +149,4 @@ inline std::size_t regex_split(OutputIterator out,
 
 #endif
 
+

include/boost/regex/v3/regex_stack.hpp

@@ -29,7 +29,7 @@
 #include <boost/regex/config.hpp>
 #endif
 #ifndef BOOST_REGEX_RAW_BUFFER_HPP
-#include <boost/regex/detail/regex_raw_buffer.hpp>
+#include <boost/regex/v3/regex_raw_buffer.hpp>
 #endif
 
 namespace boost{
@@ -224,3 +224,4 @@ jstack<T, Allocator>::~jstack()
 
 
 
+

include/boost/regex/v3/regex_traits.hpp

@@ -0,0 +1,815 @@
+/*
+ *
+ * Copyright (c) 1998-2002
+ * Dr John Maddock
+ *
+ * Permission to use, copy, modify, distribute and sell this software
+ * and its documentation for any purpose is hereby granted without fee,
+ * provided that the above copyright notice appear in all copies and
+ * that both that copyright notice and this permission notice appear
+ * in supporting documentation.  Dr John Maddock makes no representations
+ * about the suitability of this software for any purpose.  
+ * It is provided "as is" without express or implied warranty.
+ *
+ */
+ 
+ /*
+  *   LOCATION:    see http://www.boost.org for most recent version.
+  *   FILE         regex_traits.hpp
+  *   VERSION      see <boost/version.hpp>
+  *   DESCRIPTION: Declares regular expression traits classes.
+  */
+
+#ifndef BOOST_REGEX_TRAITS_HPP_INCLUDED
+#define BOOST_REGEX_TRAITS_HPP_INCLUDED
+
+#ifndef BOOST_RE_CREGEX_HPP
+#include <boost/cregex.hpp>
+#endif
+#ifndef BOOST_REGEX_CSTRING_HPP
+#include <boost/regex/v3/regex_cstring.hpp>
+#endif
+
+namespace boost{
+
+#ifdef __BORLANDC__
+   #pragma option push -a8 -b -Vx -Ve -pc
+#endif
+
+template <class charT>
+class c_regex_traits;
+
+namespace re_detail{
+
+struct mss
+{
+   unsigned int id;
+   const char* what;
+};
+
+BOOST_REGEX_DECL bool BOOST_REGEX_CALL re_lookup_def_collate_name(std::string& buf, const char* name);
+BOOST_REGEX_DECL std::size_t BOOST_REGEX_CALL re_get_default_message(char* buf, std::size_t len, std::size_t id);
+extern BOOST_REGEX_DECL const char *re_default_error_messages[];
+
+#ifndef BOOST_NO_WREGEX
+extern BOOST_REGEX_DECL wchar_t wide_lower_case_map[];
+extern BOOST_REGEX_DECL unsigned short wide_unicode_classes[];
+BOOST_REGEX_DECL bool BOOST_REGEX_CALL is_combining(wchar_t c);
+#endif
+
+
+struct BOOST_REGEX_DECL regex_traits_base
+{
+   enum char_syntax_type
+   {
+      syntax_char = 0,
+      syntax_open_bracket = 1,                  // (
+      syntax_close_bracket = 2,                 // )
+      syntax_dollar = 3,                        // $
+      syntax_caret = 4,                         // ^
+      syntax_dot = 5,                           // .
+      syntax_star = 6,                          // *
+      syntax_plus = 7,                          // +
+      syntax_question = 8,                      // ?
+      syntax_open_set = 9,                      // [
+      syntax_close_set = 10,                    // ]
+      syntax_or = 11,                           // |
+      syntax_slash = 12,                        //
+      syntax_hash = 13,                         // #
+      syntax_dash = 14,                         // -
+      syntax_open_brace = 15,                   // {
+      syntax_close_brace = 16,                  // }
+      syntax_digit = 17,                        // 0-9
+      syntax_b = 18,                            // for \b
+      syntax_B = 19,                            // for \B
+      syntax_left_word = 20,                    // for \<
+      syntax_right_word = 21,                   // for \>
+      syntax_w = 22,                            // for \w
+      syntax_W = 23,                            // for \W
+      syntax_start_buffer = 24,                 // for \`
+      syntax_end_buffer = 25,                   // for \'
+      syntax_newline = 26,                      // for newline alt
+      syntax_comma = 27,                        // for {x,y}
+
+      syntax_a = 28,                            // for \a
+      syntax_f = 29,                            // for \f
+      syntax_n = 30,                            // for \n
+      syntax_r = 31,                            // for \r
+      syntax_t = 32,                            // for \t
+      syntax_v = 33,                            // for \v
+      syntax_x = 34,                            // for \xdd
+      syntax_c = 35,                            // for \cx
+      syntax_colon = 36,                        // for [:...:]
+      syntax_equal = 37,                        // for [=...=]
+   
+      // perl ops:
+      syntax_e = 38,                            // for \e
+      syntax_l = 39,                            // for \l
+      syntax_L = 40,                            // for \L
+      syntax_u = 41,                            // for \u
+      syntax_U = 42,                            // for \U
+      syntax_s = 43,                            // for \s
+      syntax_S = 44,                            // for \S
+      syntax_d = 45,                            // for \d
+      syntax_D = 46,                            // for \D
+      syntax_E = 47,                            // for \Q\E
+      syntax_Q = 48,                            // for \Q\E
+      syntax_X = 49,                            // for \X
+      syntax_C = 50,                            // for \C
+      syntax_Z = 51,                            // for \Z
+      syntax_G = 52,                            // for \G
+
+      // new extentions:
+      syntax_not = 53,                          // for (?!...)
+
+      syntax_max = 54
+   };
+#ifdef __BORLANDC__
+private:
+   char dummy_member;
+#endif
+};
+
+struct BOOST_REGEX_DECL c_traits_base : public regex_traits_base
+{
+public:
+   enum{
+      char_class_none = 0,
+      char_class_alpha = 0x0001,
+      char_class_cntrl = 0x0002,
+      char_class_digit = 0x0004,
+      char_class_lower = 0x0008,
+      char_class_punct = 0x0010,
+      char_class_space = 0x0020,
+      char_class_upper = 0x0040,
+      char_class_xdigit = 0x0080,
+      char_class_blank = 0x0100,
+      char_class_underscore = 0x4000,
+      char_class_unicode = 0x8000,
+
+      char_class_alnum = char_class_alpha | char_class_digit,
+      char_class_graph = char_class_alpha | char_class_digit | char_class_punct | char_class_underscore,
+      char_class_print = char_class_alpha | char_class_digit | char_class_punct | char_class_underscore | char_class_blank,
+      char_class_word = char_class_alpha | char_class_digit | char_class_underscore
+   };
+   static std::string BOOST_REGEX_CALL set_message_catalogue(const std::string& s);
+protected:
+#if defined(__MWERKS__) && __MWERKS__ <= 0x6000
+   friend class c_regex_traits<char>;
+   friend class c_regex_traits<wchar_t>;
+#endif 
+
+   static char regex_message_catalogue[BOOST_REGEX_MAX_PATH];
+   enum syntax_map_size
+   {
+      map_size = UCHAR_MAX + 1
+   };
+
+   static unsigned char syntax_map[map_size];
+   static unsigned short class_map[map_size];
+   static char lower_case_map[map_size];
+
+   static boost::uint_fast32_t BOOST_REGEX_CALL do_lookup_class(const char* p);
+   static bool BOOST_REGEX_CALL do_lookup_collate(std::string& buf, const char* p);
+   static void BOOST_REGEX_CALL do_update_ctype();
+   static void BOOST_REGEX_CALL do_update_collate();
+public:
+   static std::string BOOST_REGEX_CALL error_string(unsigned id);
+   static char* BOOST_REGEX_CALL get_catalogue() { return regex_message_catalogue; }
+};
+
+} // namespace re_detail
+
+
+template<>
+class BOOST_REGEX_DECL c_regex_traits<char> : public re_detail::c_traits_base
+{
+   typedef re_detail::c_traits_base base_type;
+public:
+   typedef char char_type;
+   typedef unsigned char uchar_type;
+   typedef unsigned int size_type;
+   typedef std::string string_type;
+   typedef int locale_type;
+
+   static std::size_t BOOST_REGEX_CALL length(const char_type* p)
+   {
+      return std::strlen(p);
+   }
+   static unsigned int BOOST_REGEX_CALL syntax_type(size_type c)
+   {
+      return syntax_map[c];
+   }
+   static char BOOST_REGEX_CALL translate(char c, bool icase)
+   {
+      return icase ? lower_case_map[(size_type)(uchar_type)c] : c;
+   }
+   static void BOOST_REGEX_CALL transform(std::string& out, const std::string& in);
+
+   static void BOOST_REGEX_CALL transform_primary(std::string& out, const std::string& in);
+
+   static bool BOOST_REGEX_CALL is_separator(char c)
+   {
+      return BOOST_REGEX_MAKE_BOOL((c == '\n') || (c == '\r'));
+   }
+
+   static bool BOOST_REGEX_CALL is_combining(char)
+   {
+      return false;
+   }
+   
+   static bool BOOST_REGEX_CALL is_class(char c, boost::uint_fast32_t f)
+   {
+      return BOOST_REGEX_MAKE_BOOL(class_map[(size_type)(uchar_type)c] & f);
+   }
+
+   static int BOOST_REGEX_CALL toi(char c);
+   static int BOOST_REGEX_CALL toi(const char*& first, const char* last, int radix);
+
+   static boost::uint_fast32_t BOOST_REGEX_CALL lookup_classname(const char* first, const char* last)
+   {
+      std::string s(first, last);
+      return do_lookup_class(s.c_str());
+   }
+
+   static bool BOOST_REGEX_CALL lookup_collatename(std::string& buf, const char* first, const char* last)
+   {
+      std::string s(first, last);
+      return do_lookup_collate(buf, s.c_str());
+   }
+
+   static locale_type BOOST_REGEX_CALL imbue(locale_type l){ return l; }
+   locale_type BOOST_REGEX_CALL getloc()const{ return locale_type(); }
+
+   c_regex_traits()
+   {
+      init();
+   }
+   ~c_regex_traits()
+   {
+      m_free();
+   }
+   struct sentry
+   {
+      sentry(const c_regex_traits<char>&)
+      { c_regex_traits<char>::update(); }
+      operator void*() { return this; }
+   };
+   static void BOOST_REGEX_CALL update();
+private:
+   static void BOOST_REGEX_CALL init();
+   static void BOOST_REGEX_CALL m_free();
+   static c_regex_traits<char> i;
+
+   static unsigned sort_type;
+   static char sort_delim;
+};
+
+#ifndef BOOST_NO_WREGEX
+template<>
+class BOOST_REGEX_DECL c_regex_traits<wchar_t> : public re_detail::c_traits_base
+{
+   typedef re_detail::c_traits_base base_type;
+public:
+   typedef wchar_t char_type;
+   typedef unsigned short uchar_type;
+   typedef unsigned int size_type;
+   typedef std::basic_string<wchar_t> string_type;
+   typedef int locale_type; 
+   static std::size_t BOOST_REGEX_CALL length(const char_type* p)
+   {
+      return std::wcslen(p);
+   }
+   static unsigned int BOOST_REGEX_CALL syntax_type(size_type c);
+   static wchar_t BOOST_REGEX_CALL translate(wchar_t c, bool icase)
+   {
+      return icase ? ((c < 256) ? re_detail::wide_lower_case_map[(uchar_type)c] : std::towlower(c)) : c;
+   }
+
+   static void BOOST_REGEX_CALL transform(std::basic_string<wchar_t>& out, const std::basic_string<wchar_t>& in);
+
+   static void BOOST_REGEX_CALL transform_primary(std::basic_string<wchar_t>& out, const std::basic_string<wchar_t>& in);
+
+   static bool BOOST_REGEX_CALL is_separator(wchar_t c)
+   {
+      return BOOST_REGEX_MAKE_BOOL((c == L'\n') || (c == L'\r') || (c == (wchar_t)0x2028) || (c == (wchar_t)0x2029));
+   }
+
+   static bool BOOST_REGEX_CALL is_combining(wchar_t c)
+   { return re_detail::is_combining(c); }
+   
+   static bool BOOST_REGEX_CALL is_class(wchar_t c, boost::uint_fast32_t f)
+   {
+      return BOOST_REGEX_MAKE_BOOL(((uchar_type)c < 256) ? (re_detail::wide_unicode_classes[(size_type)(uchar_type)c] & f) : do_iswclass(c, f));
+   }
+
+   static int BOOST_REGEX_CALL toi(wchar_t c);
+   static int BOOST_REGEX_CALL toi(const wchar_t*& first, const wchar_t* last, int radix);
+
+   static boost::uint_fast32_t BOOST_REGEX_CALL lookup_classname(const wchar_t* first, const wchar_t* last);
+
+   static bool BOOST_REGEX_CALL lookup_collatename(std::basic_string<wchar_t>& s, const wchar_t* first, const wchar_t* last);
+
+   static locale_type BOOST_REGEX_CALL imbue(locale_type l){ return l; }
+   locale_type BOOST_REGEX_CALL getloc()const{ return locale_type(); }
+   c_regex_traits<wchar_t>()
+   { init(); }
+   ~c_regex_traits<wchar_t>()
+   { m_free(); }
+   struct sentry
+   {
+      sentry(const c_regex_traits<wchar_t>&)
+      { c_regex_traits<wchar_t>::update(); }
+      operator void*() { return this; }
+   };
+   static void BOOST_REGEX_CALL update();
+   static std::size_t BOOST_REGEX_CALL strnarrow(char *s1, std::size_t len, const wchar_t *s2);
+   static std::size_t BOOST_REGEX_CALL strwiden(wchar_t *s1, std::size_t len, const char *s2);
+private:
+   static bool BOOST_REGEX_CALL do_iswclass(wchar_t c, boost::uint_fast32_t f);
+   static void BOOST_REGEX_CALL m_free();
+   static void BOOST_REGEX_CALL init();
+   static bool BOOST_REGEX_CALL do_lookup_collate(std::basic_string<wchar_t>& out, const wchar_t* first, const wchar_t* last);
+   static c_regex_traits<wchar_t> init_;
+
+   static unsigned sort_type;
+   static wchar_t sort_delim;
+};
+#endif
+
+#if defined(_WIN32) && !defined(BOOST_REGEX_NO_W32)
+
+namespace re_detail{
+
+struct BOOST_REGEX_DECL w32_traits_base : public regex_traits_base
+{
+   enum{
+   char_class_none = 0,
+   char_class_alnum = C1_ALPHA | C1_DIGIT,
+   char_class_alpha = C1_ALPHA,
+   char_class_cntrl = C1_CNTRL,
+   char_class_digit = C1_DIGIT,
+   char_class_graph = C1_UPPER | C1_LOWER | C1_DIGIT | C1_PUNCT | C1_ALPHA,
+   char_class_lower = C1_LOWER,
+   char_class_print = C1_UPPER | C1_LOWER | C1_DIGIT | C1_PUNCT | C1_BLANK | C1_ALPHA,
+   char_class_punct = C1_PUNCT,
+   char_class_space = C1_SPACE,
+   char_class_upper = C1_UPPER,
+   char_class_xdigit = C1_XDIGIT,
+   char_class_blank = C1_BLANK,
+   char_class_underscore = 0x4000,
+   char_class_word = C1_ALPHA | C1_DIGIT | char_class_underscore,
+   char_class_unicode = 0x8000,
+   char_class_win = 0x01FF
+   };
+
+
+public:
+   static std::string BOOST_REGEX_CALL set_message_catalogue(const std::string& s);
+protected:
+   static char regex_message_catalogue[BOOST_REGEX_MAX_PATH];
+   enum syntax_map_size
+   {
+      map_size = UCHAR_MAX + 1
+   };
+
+   static unsigned char syntax_map[map_size];
+   static unsigned short class_map[map_size];
+   static char lower_case_map[map_size];
+
+   static boost::uint_fast32_t BOOST_REGEX_CALL do_lookup_class(const char* p);
+   static bool BOOST_REGEX_CALL do_lookup_collate(std::string& buf, const char* p);
+   static void BOOST_REGEX_CALL do_free();
+   static void BOOST_REGEX_CALL do_init();
+public:
+   static std::string BOOST_REGEX_CALL error_string(unsigned id);
+   static char* BOOST_REGEX_CALL get_catalogue() { return regex_message_catalogue; }
+};
+
+
+} // namespace re_detail
+
+template<class charT>
+class w32_regex_traits;
+
+template<>
+class BOOST_REGEX_DECL w32_regex_traits<char> : public re_detail::w32_traits_base
+{
+   typedef re_detail::w32_traits_base base_type;
+public:
+   typedef char char_type;
+   typedef unsigned char uchar_type;
+   typedef unsigned int size_type;
+   typedef std::string string_type;
+   typedef int locale_type;
+
+   static std::size_t BOOST_REGEX_CALL length(const char_type* p)
+   {
+      return std::strlen(p);
+   }
+   static unsigned int BOOST_REGEX_CALL syntax_type(size_type c)
+   {
+      return syntax_map[c];
+   }
+   static char BOOST_REGEX_CALL translate(char c, bool icase)
+   {
+      return icase ? lower_case_map[(size_type)(uchar_type)c] : c;
+   }
+   static void BOOST_REGEX_CALL transform(std::string& out, const std::string& in);
+
+   static void BOOST_REGEX_CALL transform_primary(std::string& out, const std::string& in);
+
+   static bool BOOST_REGEX_CALL is_separator(char c)
+   {
+      return BOOST_REGEX_MAKE_BOOL((c == '\n') || (c == '\r'));
+   }
+
+   static bool BOOST_REGEX_CALL is_combining(char)
+   {
+      return false;
+   }
+   
+   static bool BOOST_REGEX_CALL is_class(char c, boost::uint_fast32_t f)
+   {
+      return BOOST_REGEX_MAKE_BOOL(class_map[(size_type)(uchar_type)c] & f);
+   }
+
+   static int BOOST_REGEX_CALL toi(char c);
+   static int BOOST_REGEX_CALL toi(const char*& first, const char* last, int radix);
+
+   static boost::uint_fast32_t BOOST_REGEX_CALL lookup_classname(const char* first, const char* last)
+   {
+      std::string s(first, last);
+      return do_lookup_class(s.c_str());
+   }
+
+   static bool BOOST_REGEX_CALL lookup_collatename(std::string& buf, const char* first, const char* last)
+   {
+      std::string s(first, last);
+      return do_lookup_collate(buf, s.c_str());
+   }
+
+   static locale_type BOOST_REGEX_CALL imbue(locale_type l){ return l; }
+   locale_type BOOST_REGEX_CALL getloc()const{ return locale_type(); }
+
+   struct sentry
+   {
+      sentry(const w32_regex_traits<char>&)
+      { w32_regex_traits<char>::update(); }
+      ~sentry(){}
+      operator void*() { return this; }
+   };
+   static void BOOST_REGEX_CALL update();
+   w32_regex_traits();
+   ~w32_regex_traits();
+private:
+   static w32_regex_traits<char> i;
+};
+
+#ifndef BOOST_NO_WREGEX
+template<>
+class BOOST_REGEX_DECL w32_regex_traits<wchar_t> : public re_detail::w32_traits_base
+{
+   typedef re_detail::w32_traits_base base_type;
+public:
+   typedef wchar_t char_type;
+   typedef unsigned short uchar_type;
+   typedef unsigned int size_type;
+   typedef std::basic_string<wchar_t> string_type;
+   typedef int locale_type; 
+   static std::size_t BOOST_REGEX_CALL length(const char_type* p)
+   {
+      return std::wcslen(p);
+   }
+   static unsigned int BOOST_REGEX_CALL syntax_type(size_type c);
+   static wchar_t BOOST_REGEX_CALL translate(wchar_t c, bool icase)
+   {
+      return icase ? ((c < 256) ? re_detail::wide_lower_case_map[(uchar_type)c] : wtolower(c)) : c;
+   }
+
+   static void BOOST_REGEX_CALL transform(std::basic_string<wchar_t>& out, const std::basic_string<wchar_t>& in);
+
+   static void BOOST_REGEX_CALL transform_primary(std::basic_string<wchar_t>& out, const std::basic_string<wchar_t>& in);
+
+   static bool BOOST_REGEX_CALL is_separator(wchar_t c)
+   {
+      return BOOST_REGEX_MAKE_BOOL((c == L'\n') || (c == L'\r') || (c == (wchar_t)0x2028) || (c == (wchar_t)0x2029));
+   }
+
+   static bool BOOST_REGEX_CALL is_combining(wchar_t c)
+   { return re_detail::is_combining(c); }
+   
+   static bool BOOST_REGEX_CALL is_class(wchar_t c, boost::uint_fast32_t f)
+   {
+      return BOOST_REGEX_MAKE_BOOL(((uchar_type)c < 256) ? (wide_unicode_classes[(size_type)(uchar_type)c] & f) : do_iswclass(c, f));
+   }
+
+   static int BOOST_REGEX_CALL toi(wchar_t c);
+   static int BOOST_REGEX_CALL toi(const wchar_t*& first, const wchar_t* last, int radix);
+
+   static boost::uint_fast32_t BOOST_REGEX_CALL lookup_classname(const wchar_t* first, const wchar_t* last);
+
+   static bool BOOST_REGEX_CALL lookup_collatename(std::basic_string<wchar_t>& s, const wchar_t* first, const wchar_t* last);
+
+   static locale_type BOOST_REGEX_CALL imbue(locale_type l){ return l; }
+   locale_type BOOST_REGEX_CALL getloc()const{ return locale_type(); }
+
+   struct sentry
+   {
+      sentry(const w32_regex_traits<wchar_t>&)
+      { w32_regex_traits<wchar_t>::update(); }
+      ~sentry(){}
+      operator void*() { return this; }
+   };
+   static void BOOST_REGEX_CALL update();
+   w32_regex_traits();
+   ~w32_regex_traits();
+   static std::size_t BOOST_REGEX_CALL strnarrow(char *s1, std::size_t len, const wchar_t *s2);
+   static std::size_t BOOST_REGEX_CALL strwiden(wchar_t *s1, std::size_t len, const char *s2);
+
+private:
+   static bool BOOST_REGEX_CALL do_iswclass(wchar_t c, boost::uint_fast32_t f);
+   static bool BOOST_REGEX_CALL do_lookup_collate(std::basic_string<wchar_t>& out, const wchar_t* first, const wchar_t* last);
+   static w32_regex_traits<wchar_t> init_;
+   static wchar_t BOOST_REGEX_CALL wtolower(wchar_t c);
+   static unsigned short wide_unicode_classes[];
+};
+#endif // Wide strings
+#endif // Win32
+
+#if !defined(BOOST_NO_STD_LOCALE) && !defined(BOOST_NO_STD_WSTREAMBUF)
+
+} // namspace boost
+
+#ifdef __BORLANDC__
+  #pragma option pop
+#endif
+#include <locale>
+#ifdef __BORLANDC__
+   #pragma option push -a4 -b -Ve -pc
+#endif
+
+namespace boost{
+
+namespace re_detail
+{
+
+template <class charT>
+struct message_data;
+
+template <>
+struct message_data<char>;
+
+template <>
+struct message_data<wchar_t>;
+
+struct BOOST_REGEX_DECL cpp_regex_traits_base : public regex_traits_base
+{
+   enum char_class_type
+   {
+      char_class_none = 0,
+      char_class_alnum = std::ctype_base::alnum,
+      char_class_alpha = std::ctype_base::alpha,
+      char_class_cntrl = std::ctype_base::cntrl,
+      char_class_digit = std::ctype_base::digit,
+      char_class_graph = std::ctype_base::graph,
+      char_class_lower = std::ctype_base::lower,
+      char_class_print = std::ctype_base::print,
+      char_class_punct = std::ctype_base::punct,
+      char_class_space = std::ctype_base::space,
+      char_class_upper = std::ctype_base::upper,
+      char_class_xdigit = std::ctype_base::xdigit,
+      char_class_blank = 1<<12,
+      char_class_underscore = 1<<13,
+      char_class_word = std::ctype_base::alnum | char_class_underscore,
+      char_class_unicode = 1<<14,
+      char_class_all_base = char_class_alnum | char_class_alpha | char_class_cntrl
+                         | char_class_digit | char_class_graph | char_class_lower
+                         | char_class_print | char_class_punct | char_class_space
+                         | char_class_upper | char_class_xdigit
+   };
+
+   static std::string BOOST_REGEX_CALL set_message_catalogue(const std::string& s);
+protected:
+   static char regex_message_cat[BOOST_REGEX_MAX_PATH];
+};
+
+} // namespace re_detail
+
+template <class charT>
+class cpp_regex_traits;
+
+template<>
+class BOOST_REGEX_DECL cpp_regex_traits<char> : public re_detail::cpp_regex_traits_base
+{
+   typedef re_detail::cpp_regex_traits_base base_type;
+private:
+   re_detail::message_data<char>* pmd;
+   const unsigned char* psyntax;
+   char* lower_map;
+   const std::ctype<char>* pctype;
+   const std::collate<char>* pcollate;
+   std::locale locale_inst;
+   unsigned sort_type;
+   char sort_delim;
+
+   cpp_regex_traits(const cpp_regex_traits&);
+   cpp_regex_traits& operator=(const cpp_regex_traits&);
+
+public:
+   typedef char char_type;
+   typedef unsigned char uchar_type;
+   typedef unsigned int size_type;
+   typedef std::string string_type;
+   typedef std::locale locale_type;
+
+   cpp_regex_traits();
+   ~cpp_regex_traits();
+
+   static std::size_t BOOST_REGEX_CALL length(const char_type* p)
+   {
+      return std::strlen(p);
+   }
+   unsigned int BOOST_REGEX_CALL syntax_type(size_type c)const
+   {
+      return psyntax[c];
+   }
+   char BOOST_REGEX_CALL translate(char c, bool icase)const
+   {
+      return icase ? lower_map[(size_type)(uchar_type)c] : c;
+   }
+   void BOOST_REGEX_CALL transform(std::string& out, const std::string& in)const
+   {
+      out = pcollate->transform(in.c_str(), in.c_str() + in.size()).c_str();
+   }
+
+   void BOOST_REGEX_CALL transform_primary(std::string& out, const std::string& in)const;
+
+   static bool BOOST_REGEX_CALL is_separator(char c)
+   {
+      return BOOST_REGEX_MAKE_BOOL((c == '\n') || (c == '\r'));
+   }
+
+   static bool BOOST_REGEX_CALL is_combining(char)
+   {
+      return false;
+   }
+   
+   bool BOOST_REGEX_CALL is_class(char c, boost::uint_fast32_t f)const
+   {
+      if(pctype->is((std::ctype<char>::mask)(f & char_class_all_base), c))
+         return true;
+      if((f & char_class_underscore) && (c == '_'))
+         return true;
+      if((f & char_class_blank) && ((c == ' ') || (c == '\t')))
+         return true;
+      return false;
+   }
+
+   int BOOST_REGEX_CALL toi(char c)const;
+   int BOOST_REGEX_CALL toi(const char*& first, const char* last, int radix)const;
+
+   boost::uint_fast32_t BOOST_REGEX_CALL lookup_classname(const char* first, const char* last)const;
+   bool BOOST_REGEX_CALL lookup_collatename(std::string& s, const char* first, const char* last)const;
+
+   std::string BOOST_REGEX_CALL error_string(unsigned id)const;
+   locale_type BOOST_REGEX_CALL imbue(locale_type l);
+   locale_type BOOST_REGEX_CALL getloc()const{ return locale_inst; }
+
+   struct sentry
+   {
+      sentry(const cpp_regex_traits<char>&){}
+      operator void*() { return this; }
+   };
+};
+
+#ifndef BOOST_NO_WREGEX
+template<>
+class BOOST_REGEX_DECL cpp_regex_traits<wchar_t> : public re_detail::cpp_regex_traits_base
+{
+   typedef re_detail::cpp_regex_traits_base base_type;
+public:
+   typedef wchar_t char_type;
+   typedef unsigned short uchar_type;
+   typedef unsigned int size_type;
+   typedef std::basic_string<wchar_t> string_type;
+   typedef std::locale locale_type;
+
+private:
+   re_detail::message_data<wchar_t>* pmd;
+   const unsigned char* psyntax;
+   wchar_t* lower_map;
+   const std::ctype<wchar_t>* pctype;
+   const std::collate<wchar_t>* pcollate;
+   const std::codecvt<wchar_t, char, std::mbstate_t>* pcdv;
+   std::locale locale_inst;
+   unsigned int BOOST_REGEX_CALL do_syntax_type(size_type c)const;
+   unsigned sort_type;
+   wchar_t sort_delim;
+
+   cpp_regex_traits(const cpp_regex_traits&);
+   cpp_regex_traits& operator=(const cpp_regex_traits&);
+
+public:
+
+   static std::size_t BOOST_REGEX_CALL length(const char_type* p)
+   {
+      return std::wcslen(p);
+   }
+   unsigned int BOOST_REGEX_CALL syntax_type(size_type c)const
+   {
+      return (c < UCHAR_MAX) ? psyntax[c] : do_syntax_type(c);
+   }
+   wchar_t BOOST_REGEX_CALL translate(wchar_t c, bool icase)const
+   {
+      return icase ? (((uchar_type)c) <= UCHAR_MAX) ? lower_map[c] : pctype->tolower(c) : c;
+   }
+   void BOOST_REGEX_CALL transform(std::basic_string<wchar_t>& out, const std::basic_string<wchar_t>& in)const
+   {
+      out = pcollate->transform(in.c_str(), in.c_str() + in.size());
+   }
+
+   void BOOST_REGEX_CALL transform_primary(std::basic_string<wchar_t>& out, const std::basic_string<wchar_t>& in)const;
+
+   static bool BOOST_REGEX_CALL is_separator(wchar_t c)
+   {
+      return BOOST_REGEX_MAKE_BOOL((c == L'\n') || (c == L'\r') || (c == (wchar_t)0x2028) || (c == (wchar_t)0x2029));
+   }
+
+   static bool BOOST_REGEX_CALL is_combining(wchar_t c)
+   { return re_detail::is_combining(c); }
+   
+   bool BOOST_REGEX_CALL is_class(wchar_t c, boost::uint_fast32_t f)const
+   {
+      if(pctype->is((std::ctype<wchar_t>::mask)(f & char_class_all_base), c))
+         return true;
+      if((f & char_class_underscore) && (c == '_'))
+         return true;
+      if((f & char_class_blank) && ((c == ' ') || (c == '\t')))
+         return true;
+      if((f & char_class_unicode) && ((uchar_type)c > (uchar_type)255))
+         return true;
+      return false;
+   }
+
+   int BOOST_REGEX_CALL toi(wchar_t c)const;
+   int BOOST_REGEX_CALL toi(const wchar_t*& first, const wchar_t* last, int radix)const;
+
+   boost::uint_fast32_t BOOST_REGEX_CALL lookup_classname(const wchar_t* first, const wchar_t* last)const;
+   bool BOOST_REGEX_CALL lookup_collatename(std::basic_string<wchar_t>& s, const wchar_t* first, const wchar_t* last)const;
+
+   std::string BOOST_REGEX_CALL error_string(unsigned id)const;
+   cpp_regex_traits();
+   ~cpp_regex_traits();
+   locale_type BOOST_REGEX_CALL imbue(locale_type l);
+   locale_type BOOST_REGEX_CALL getloc()const{ return locale_inst; }
+   std::size_t BOOST_REGEX_CALL strwiden(wchar_t *s1, std::size_t len, const char *s2)const;
+
+   struct sentry
+   {
+      sentry(const cpp_regex_traits<wchar_t>&){}
+      operator void*() { return this; }
+   };
+};
+#endif // BOOST_NO_WREGEX
+
+#endif // BOOST_NO_STD_LOCALE
+
+#ifdef BOOST_REGEX_USE_WIN32_LOCALE
+
+template <class charT>
+class regex_traits : public w32_regex_traits<charT>
+{
+};
+
+#elif defined(BOOST_REGEX_USE_C_LOCALE)
+
+template <class charT>
+class regex_traits : public c_regex_traits<charT>
+{
+};
+
+#elif defined(BOOST_REGEX_USE_CPP_LOCALE)
+
+template <class charT>
+class regex_traits : public cpp_regex_traits<charT>
+{
+};
+
+#else
+#error No default localisation model defined
+#endif
+
+#ifdef __BORLANDC__
+  #pragma option pop
+#endif
+
+} // namespace boost
+
+#endif // include
+
+
+
+
+
+

include/boost/regex_fwd.hpp

@@ -14,7 +14,7 @@
  */
 
  /*
-  *   LOCATION:    see http://www.boost.org for most recent version.
+  *   LOCATION:    see http://www.boost.org/libs/regex for documentation.
   *   FILE         regex_fwd.cpp
   *   VERSION      see <boost/version.hpp>
   *   DESCRIPTION: Forward declares boost::reg_expression<> and
@@ -24,44 +24,9 @@
 #ifndef BOOST_REGEX_FWD_HPP
 #define BOOST_REGEX_FWD_HPP
 
-#include <boost/config.hpp>
-#include <boost/detail/allocator.hpp>
-
-//
-// define BOOST_REGEX_NO_FWD if this
-// header doesn't work!
-//
-#ifdef BOOST_REGEX_NO_FWD
-#  ifndef BOOST_RE_REGEX_HPP
-#     include <boost/regex.hpp>
-#  endif
-#else
-
-//
-// If there isn't good enough wide character support then there will
-// be no wide character regular expressions:
-//
-#if (defined(BOOST_NO_CWCHAR) || defined(BOOST_NO_CWCTYPE) || defined(BOOST_NO_STD_WSTRING)) && !defined(BOOST_NO_WREGEX)
-#  define BOOST_NO_WREGEX
-#endif
-
-namespace boost{
-
-template <class charT>
-class regex_traits;
-
-template <class charT, class traits = regex_traits<charT>, class Allocator = BOOST_DEFAULT_ALLOCATOR(charT) >
-class reg_expression;
-
-typedef reg_expression<char, regex_traits<char>, BOOST_DEFAULT_ALLOCATOR(char) > regex;
-#ifndef BOOST_NO_WREGEX
-typedef reg_expression<wchar_t, regex_traits<wchar_t>, BOOST_DEFAULT_ALLOCATOR(wchar_t) > wregex;
-#endif
-
-} // namespace boost
-
-#endif  // BOOST_REGEX_NO_FWD
+#include <boost/regex/v3/regex_fwd.hpp>
 
 #endif
 
 
+

index.htm

@@ -1,150 +0,0 @@
-<html>
-
-<head>
-<meta http-equiv="Content-Type"
-content="text/html; charset=iso-8859-1">
-<meta name="keywords"
-content="regex++, regular expressions, regular expression library, C++">
-<meta name="Template"
-content="C:\PROGRAM FILES\MICROSOFT OFFICE\OFFICE\html.dot">
-<meta name="GENERATOR" content="Microsoft FrontPage Express 2.0">
-<title>regex++, Index</title>
-</head>
-
-<body bgcolor="#FFFFFF" link="#0000FF" vlink="#800080">
-
-<p>&nbsp; </p>
-
-<table border="0" cellpadding="7" cellspacing="0" width="100%">
-    <tr>
-        <td valign="top"><h3><img src="../../c++boost.gif"
-        alt="C++ Boost" width="277" height="86"></h3>
-        </td>
-        <td valign="top"><h3 align="center">Regex++, Index.</h3>
-        <p align="left"><i>(Version 3.31, 16th Dec 2001)</i>&nbsp;
-        </p>
-        <p align="left"><i>Copyright (c) 1998-2001 </i></p>
-        <p align="left"><i>Dr John Maddock</i></p>
-        <p align="left"><i>Permission to use, copy, modify,
-        distribute and sell this software and its documentation
-        for any purpose is hereby granted without fee, provided
-        that the above copyright notice appear in all copies and
-        that both that copyright notice and this permission
-        notice appear in supporting documentation. Dr John
-        Maddock makes no representations about the suitability of
-        this software for any purpose. It is provided &quot;as is&quot;
-        without express or implied warranty.</i></p>
-        </td>
-    </tr>
-</table>
-
-<hr>
-
-<h3 align="center">Contents</h3>
-
-<ul>
-    <li><a href="introduction.htm#intro">Introduction</a></li>
-    <li><a href="introduction.htm#Installation">Installation and
-        Configuration</a> </li>
-    <li><a href="template_class_ref.htm#regbase">Template Class
-        and Algorithm Reference</a> <ul>
-            <li>Class <a href="template_class_ref.htm#regbase">regbase</a></li>
-            <li>Class <a
-                href="template_class_ref.htm#bad_expression">bad_expression</a>
-            </li>
-            <li>Class <a
-                href="template_class_ref.htm#reg_expression">reg_expression</a>
-            </li>
-            <li>Class <a
-                href="template_class_ref.htm#regex_char_traits">char_regex_traits</a></li>
-            <li>Class <a href="template_class_ref.htm#reg_match">match_results</a>
-            </li>
-            <li>Algorithm <a
-                href="template_class_ref.htm#query_match">regex_match</a>
-            </li>
-            <li>Algorithm <a
-                href="template_class_ref.htm#reg_search">regex_search</a>
-            </li>
-            <li>Algorithm <a
-                href="template_class_ref.htm#reg_grep">regex_grep</a></li>
-            <li>Algorithm <a
-                href="template_class_ref.htm#reg_format">regex_format</a>
-            </li>
-            <li>Algorithm <a
-                href="template_class_ref.htm#reg_merge">regex_merge</a></li>
-            <li>Algorithm <a
-                href="template_class_ref.htm#regex_split">regex_split</a>
-            </li>
-            <li><a href="template_class_ref.htm#partial_matches">Partial
-                regular expression matches</a></li>
-        </ul>
-    </li>
-    <li>Class <a href="hl_ref.htm#RegEx">RegEx</a> reference</li>
-    <li><a href="posix_ref.htm#posix">POSIX Compatibility
-        Functions</a></li>
-    <li><a href="syntax.htm#syntax">Regular Expression Syntax</a></li>
-    <li><a href="format_string.htm#format_string">Format String
-        Syntax</a></li>
-    <li><a href="appendix.htm#implementation">Appendices</a> <ul>
-            <li><a href="appendix.htm#implementation">Implementation
-                notes</a></li>
-            <li><a href="appendix.htm#threads">Thread safety</a></li>
-            <li><a href="appendix.htm#localisation">Localization</a></li>
-            <li><a href="appendix.htm#demos">Example Applications</a>
-                <ul>
-                    <li><a
-                        href="example/snippets/regex_match_example.cpp">regex_match_example.cpp</a>:
-                        ftp based regex_match example.</li>
-                    <li><a
-                        href="example/snippets/regex_search_example.cpp">regex_search_example.cpp</a>:
-                        regex_search example: searches a cpp file
-                        for class definitions.</li>
-                    <li><a
-                        href="example/snippets/regex_grep_example_1.cpp">regex_grep_example_1.cpp</a>:
-                        regex_grep example 1: searches a cpp file
-                        for class definitions.</li>
-                    <li><a
-                        href="example/snippets/regex_merge_example.cpp">regex_merge_example.cpp</a>:
-                        regex_merge example: converts a C++ file
-                        to syntax highlighted HTML.</li>
-                    <li><a
-                        href="example/snippets/regex_grep_example_2.cpp">regex_grep_example_2.cpp</a>:
-                        regex_grep example 2: searches a cpp file
-                        for class definitions, using a global
-                        callback function. </li>
-                    <li><a
-                        href="example/snippets/regex_grep_example_3.cpp">regex_grep_example_3.cpp</a>:
-                        regex_grep example 2: searches a cpp file
-                        for class definitions, using a bound
-                        member function callback.</li>
-                    <li><a
-                        href="example/snippets/regex_grep_example_4.cpp">regex_grep_example_4.cpp</a>:
-                        regex_grep example 2: searches a cpp file
-                        for class definitions, using a C++
-                        Builder closure as a callback.</li>
-                    <li><a
-                        href="example/snippets/regex_split_example_1.cpp">regex_split_example_1.cpp</a>:
-                        regex_split example: split a string into
-                        tokens.</li>
-                    <li><a
-                        href="example/snippets/regex_split_example_2.cpp">regex_split_example_2.cpp</a>:
-                        regex_split example: spit out linked
-                        URL's.</li>
-                </ul>
-            </li>
-            <li><a href="appendix.htm#headers">Header Files.</a></li>
-            <li><a href="appendix.htm#redist">Redistributables</a></li>
-            <li><a href="appendix.htm#upgrade">Note for upgraders</a></li>
-        </ul>
-    </li>
-    <li><a href="appendix.htm#furtherInfo">Further Information (Contacts
-        and Acknowledgements)</a></li>
-    <li><a href="faq.htm">FAQ</a></li>
-</ul>
-
-<hr>
-
-<p><i>Copyright </i><a href="mailto:John_Maddock@compuserve.com"><i>Dr
-John Maddock</i></a><i> 1998-2001 all rights reserved.</i> </p>
-</body>
-</html>

introduction.htm

@@ -1,476 +0,0 @@
-<html>
-
-<head>
-<meta http-equiv="Content-Type"
-content="text/html; charset=iso-8859-1">
-<meta name="keywords"
-content="regex++, regular expressions, regular expression library, C++">
-<meta name="Template"
-content="C:\PROGRAM FILES\MICROSOFT OFFICE\OFFICE\html.dot">
-<meta name="GENERATOR" content="Microsoft FrontPage Express 2.0">
-<title>regex++, Introduction</title>
-</head>
-
-<body bgcolor="#FFFFFF" link="#0000FF" vlink="#800080">
-
-<p>&nbsp; </p>
-
-<table border="0" cellpadding="7" cellspacing="0" width="100%">
-    <tr>
-        <td valign="top"><h3><img src="../../c++boost.gif"
-        alt="C++ Boost" width="276" height="86"></h3>
-        </td>
-        <td valign="top"><h3 align="center">Regex++, Introduction.</h3>
-        <p align="left"><i>Copyright (c) 1998-2001 </i></p>
-        <p align="left"><i>Dr John Maddock</i></p>
-        <p align="left"><i>Permission to use, copy, modify,
-        distribute and sell this software and its documentation
-        for any purpose is hereby granted without fee, provided
-        that the above copyright notice appear in all copies and
-        that both that copyright notice and this permission
-        notice appear in supporting documentation. Dr John
-        Maddock makes no representations about the suitability of
-        this software for any purpose. It is provided &quot;as is&quot;
-        without express or implied warranty.</i></p>
-        </td>
-    </tr>
-</table>
-
-<hr>
-
-<h3><a name="intro"></a><i>Introduction</i></h3>
-
-<p>Regular expressions are a form of pattern-matching that are
-often used in text processing; many users will be familiar with
-the Unix utilities <i>grep</i>, <i>sed</i> and <i>awk</i>, and
-the programming language <i>perl</i>, each of which make
-extensive use of regular expressions. Traditionally C++ users
-have been limited to the POSIX C API's for manipulating regular
-expressions, and while regex++ does provide these API's, they do
-not represent the best way to use the library. For example regex++
-can cope with wide character strings, or search and replace
-operations (in a manner analogous to either sed or perl),
-something that traditional C libraries can not do.</p>
-
-<p>The class <a href="template_class_ref.htm#reg_expression">boost::reg_expression</a>
-is the key class in this library; it represents a &quot;machine
-readable&quot; regular expression, and is very closely modelled
-on std::basic_string, think of it as a string plus the actual
-state-machine required by the regular expression algorithms. Like
-std::basic_string there are two typedefs that are almost always
-the means by which this class is referenced:</p>
-
-<pre><b>namespace </b>boost{
-
-<b>template</b> &lt;<b>class</b> charT, 
-<b>          class</b> traits = regex_traits&lt;charT&gt;, 
-          <b>class</b> Allocator = std::allocator&lt;charT&gt; &gt;
-<b>class</b> reg_expression;
-
-<b>typedef</b> reg_expression&lt;<b>char</b>&gt; regex;
-<b>typedef</b> reg_expression&lt;<b>wchar_t&gt;</b> wregex;
-
-}</pre>
-
-<p>To see how this library can be used, imagine that we are
-writing a credit card processing application. Credit card numbers
-generally come as a string of 16-digits, separated into groups of
-4-digits, and separated by either a space or a hyphen. Before
-storing a credit card number in a database (not necessarily
-something your customers will appreciate!), we may want to verify
-that the number is in the correct format. To match any digit we
-could use the regular expression [0-9], however ranges of
-characters like this are actually locale dependent. Instead we
-should use the POSIX standard form [[:digit:]], or the regex++
-and perl shorthand for this \d (note that many older libraries
-tended to be hard-coded to the C-locale, consequently this was
-not an issue for them). That leaves us with the following regular
-expression to validate credit card number formats:</p>
-
-<p>(\d{4}[- ]){3}\d{4}</p>
-
-<p>Here the parenthesis act to group (and mark for future
-reference) sub-expressions, and the {4} means &quot;repeat
-exactly 4 times&quot;. This is an example of the extended regular
-expression syntax used by perl, awk and egrep. Regex++ also
-supports the older &quot;basic&quot; syntax used by sed and grep,
-but this is generally less useful, unless you already have some
-basic regular expressions that you need to reuse.</p>
-
-<p>Now lets take that expression and place it in some C++ code to
-validate the format of a credit card number:</p>
-
-<pre><b>bool</b> validate_card_format(<b>const</b> std::string s)
-{
-   <b>static</b> <b>const</b> <a
-href="template_class_ref.htm#reg_expression">boost::regex</a> e(&quot;(\\d{4}[- ]){3}\\d{4}&quot;);
-   <b>return</b> <a href="template_class_ref.htm#query_match">regex_match</a>(s, e);
-}</pre>
-
-<p>Note how we had to add some extra escapes to the expression:
-remember that the escape is seen once by the C++ compiler, before
-it gets to be seen by the regular expression engine, consequently
-escapes in regular expressions have to be doubled up when
-embedding them in C/C++ code. Also note that all the examples
-assume that your compiler supports Koenig lookup, if yours
-doesn't (for example VC6), then you will have to add some boost::
-prefixes to some of the function calls in the examples.</p>
-
-<p>Those of you who are familiar with credit card processing,
-will have realised that while the format used above is suitable
-for human readable card numbers, it does not represent the format
-required by online credit card systems; these require the number
-as a string of 16 (or possibly 15) digits, without any
-intervening spaces. What we need is a means to convert easily
-between the two formats, and this is where search and replace
-comes in. Those who are familiar with the utilities <i>sed</i>
-and <i>perl</i> will already be ahead here; we need two strings -
-one a regular expression - the other a &quot;<a
-href="format_string.htm">format string</a>&quot; that provides a
-description of the text to replace the match with. In regex++
-this search and replace operation is performed with the algorithm
-regex_merge, for our credit card example we can write two
-algorithms like this to provide the format conversions:</p>
-
-<pre>
-<i>// match any format with the regular expression:
-</i><b>const</b> boost::regex e(&quot;\\A(\\d{3,4})[- ]?(\\d{4})[- ]?(\\d{4})[- ]?(\\d{4})\\z&quot;);
-<b>const</b> std::string machine_format(&quot;\\1\\2\\3\\4&quot;);
-<b>const</b> std::string human_format(&quot;\\1-\\2-\\3-\\4&quot;);
-
-std::string machine_readable_card_number(<b>const</b> std::string s)
-{
-   <b>return</b> <a href="template_class_ref.htm#reg_merge">regex_merge</a>(s, e, machine_format, boost::match_default | boost::format_sed);
-}
-
-std::string human_readable_card_number(<b>const</b> std::string s)
-{
-   <b>return</b> <a href="template_class_ref.htm#reg_merge">regex_merge</a>(s, e, human_format, boost::match_default | boost::format_sed);
-}</pre>
-
-<p>Here we've used marked sub-expressions in the regular
-expression to split out the four parts of the card number as
-separate fields, the format string then uses the sed-like syntax
-to replace the matched text with the reformatted version.</p>
-
-<p>In the examples above, we haven't directly manipulated the
-results of a regular expression match, however in general the
-result of a match contains a number of sub-expression matches in
-addition to the overall match. When the library needs to report a
-regular expression match it does so using an instance of the
-class <a href="template_class_ref.htm#reg_match">match_results</a>,
-as before there are typedefs of this class for the most common
-cases: </p>
-
-<pre><b>namespace </b>boost{
-<b>typedef</b> match_results&lt;<b>const</b> <b>char</b>*&gt; cmatch;
-<b>typedef</b> match_results&lt;<b>const</b> <b>wchar_t</b>*&gt; wcmatch;
-<strong>typedef</strong> match_results&lt;std::string::const_iterator&gt; smatch;
-<strong>typedef</strong> match_results&lt;std::wstring::const_iterator&gt; wsmatch; 
-}</pre>
-
-<p>The algorithms <a href="template_class_ref.htm#reg_search">regex_search</a>
-and <a href="template_class_ref.htm#reg_grep">regex_grep</a> (i.e.
-finding all matches in a string) make use of match_results to
-report what matched.</p>
-
-<p>Note that these algorithms are not restricted to searching
-regular C-strings, any bidirectional iterator type can be
-searched, allowing for the possibility of seamlessly searching
-almost any kind of data. </p>
-
-<p>For search and replace operations in addition to the algorithm
-<a href="template_class_ref.htm#reg_merge">regex_merge</a> that
-we have already seen, the algorithm <a
-href="template_class_ref.htm#reg_format">regex_format</a> takes
-the result of a match and a format string, and produces a new
-string by merging the two.</p>
-
-<p>For those that dislike templates, there is a high level
-wrapper class RegEx that is an encapsulation of the lower level
-template code - it provides a simplified interface for those that
-don't need the full power of the library, and supports only
-narrow characters, and the &quot;extended&quot; regular
-expression syntax. </p>
-
-<p>The <a href="posix_ref.htm#posix">POSIX API</a> functions:
-regcomp, regexec, regfree and regerror, are available in both
-narrow character and Unicode versions, and are provided for those
-who need compatibility with these API's. </p>
-
-<p>Finally, note that the library now has run-time <a
-href="appendix.htm#localisation">localization</a> support, and
-recognizes the full POSIX regular expression syntax - including
-advanced features like multi-character collating elements and
-equivalence classes - as well as providing compatibility with
-other regular expression libraries including GNU and BSD4 regex
-packages, and to a more limited extent perl 5. </p>
-
-<h3><a name="Installation"></a><i>Installation and Configuration
-Options</i> </h3>
-
-<p><em>[ </em><strong><i>Important</i></strong><em>: If you are
-upgrading from the 2.x version of this library then you will find
-a number of changes to the documented header names and library
-interfaces, existing code should still compile unchanged however
-- see </em><a href="appendix.htm#upgrade"><font color="#0000FF"><em>Note
-for Upgraders</em></font></a><em>. ]</em></p>
-
-<p>When you extract the library from its zip file, you must
-preserve its internal directory structure (for example by using
-the -d option when extracting). If you didn't do that when
-extracting, then you'd better stop reading this, delete the files
-you just extracted, and try again! </p>
-
-<p>This library should not need configuring before use; most
-popular compilers/standard libraries/platforms are already
-supported &quot;as is&quot;. If you do experience configuration
-problems, or just want to test the configuration with your
-compiler, then the process is the same as for all of boost; see
-the <a href="../config/config.htm">configuration library
-documentation</a>.</p>
-
-<p>The library will encase all code inside namespace boost. </p>
-
-<p>Unlike some other template libraries, this library consists of
-a mixture of template code (in the headers) and static code and
-data (in cpp files). Consequently it is necessary to build the
-library's support code into a library or archive file before you
-can use it, instructions for specific platforms are as follows: </p>
-
-<p><b>Borland C++ Builder:</b> </p>
-
-<ul>
-    <li>Open up a console window and change to the
-        &lt;boost&gt;\libs\regex\build directory. </li>
-    <li>Select the appropriate makefile (bcb4.mak for C++ Builder
-        4, bcb5.mak for C++ Builder 5, and bcb6.mak for C++
-        Builder 6). </li>
-    <li>Invoke the makefile (pass the full path to your version
-        of make if you have more than one version installed, the
-        makefile relies on the path to make to obtain your C++
-        Builder installation directory and tools) for example: </li>
-</ul>
-
-<pre>make -fbcb5.mak</pre>
-
-<p>The build process will build a variety of .lib and .dll files
-(the exact number depends upon the version of Borland's tools you
-are using) the .lib and dll files will be in a sub-directory
-called bcb4 or bcb5 depending upon the makefile used. To install
-the libraries into your development system use:</p>
-
-<p>make -fbcb5.mak install</p>
-
-<p>library files will be copied to &lt;BCROOT&gt;/lib and the
-dll's to &lt;BCROOT&gt;/bin, where &lt;BCROOT&gt; corresponds to
-the install path of your Borland C++ tools. </p>
-
-<p>You may also remove temporary files created during the build
-process (excluding lib and dll files) by using:</p>
-
-<p>make -fbcb5.mak clean</p>
-
-<p>Finally when you use regex++ it is only necessary for you to
-add the &lt;boost&gt; root director to your list of include
-directories for that project. It is not necessary for you to
-manually add a .lib file to the project; the headers will
-automatically select the correct .lib file for your build mode
-and tell the linker to include it. There is one caveat however:
-the library can not tell the difference between VCL and non-VCL
-enabled builds when building a GUI application from the command
-line, if you build from the command line with the 5.5 command
-line tools then you must define the pre-processor symbol _NO_VCL
-in order to ensure that the correct link libraries are selected:
-the C++ Builder IDE normally sets this automatically. Hint, users
-of the 5.5 command line tools may want to add a -D_NO_VCL to bcc32.cfg
-in order to set this option permanently. </p>
-
-<p>If you would prefer to do a static link to the regex libraries
-even when using the dll runtime then define
-BOOST_REGEX_STATIC_LINK, and if you want to suppress automatic
-linking altogether (and supply your own custom build of the lib)
-then define BOOST_REGEX_NO_LIB.</p>
-
-<p>If you are building with C++ Builder 6, you will find that
-&lt;boost/regex.hpp&gt; can not be used in a pre-compiled header
-(the actual problem is in &lt;locale&gt; which gets included by
-&lt;boost/regex.hpp&gt;), if this causes problems for you, then
-try defining BOOST_NO_STD_LOCALE when building, this will disable
-some features throughout boost, but may save you a lot in compile
-times!</p>
-
-<p><b>Microsoft Visual C++ 6</b><strong> and 7</strong></p>
-
-<p>You need version 6 of MSVC to build this library. If you are
-using VC5 then you may want to look at one of the previous
-releases of this <a
-href="http://ourworld.compuserve.com/homepages/john_maddock/regexpp.htm">library</a>
-</p>
-
-<p>Open up a command prompt, which has the necessary MSVC
-environment variables defined (for example by using the batch
-file Vcvars32.bat installed by the Visual Studio installation),
-and change to the &lt;boost&gt;\libs\regex\build directory. </p>
-
-<p>Select the correct makefile - vc6.mak for &quot;vanilla&quot;
-Visual C++ 6 or vc6-stlport.mak if you are using STLPort.</p>
-
-<p>Invoke the makefile like this:</p>
-
-<p>nmake -fvc6.mak</p>
-
-<p>You will now have a collection of lib and dll files in a
-&quot;vc6&quot; subdirectory, to install these into your
-development system use:</p>
-
-<p>nmake -fvc6.mak install</p>
-
-<p>The lib files will be copied to your &lt;VC6&gt;\lib directory
-and the dll files to &lt;VC6&gt;\bin, where &lt;VC6&gt; is the
-root of your Visual C++ 6 installation.</p>
-
-<p>You can delete all the temporary files created during the
-build (excluding lib and dll files) using:</p>
-
-<p>nmake -fvc6.mak clean </p>
-
-<p>Finally when you use regex++ it is only necessary for you to
-add the &lt;boost&gt; root directory to your list of include
-directories for that project. It is not necessary for you to
-manually add a .lib file to the project; the headers will
-automatically select the correct .lib file for your build mode
-and tell the linker to include it. </p>
-
-<p>Note that if you want to statically link to the regex library
-when using the dynamic C++ runtime, define
-BOOST_REGEX_STATIC_LINK when building your project (this only has
-an effect for release builds). If you want to add the source
-directly to your project then define BOOST_REGEX_NO_LIB to
-disable automatic library selection.</p>
-
-<p><strong><i>Important</i></strong><em>: there have been some
-reports of compiler-optimisation bugs affecting this library, (particularly
-with VC6 versions prior to service patch 5) the workaround is to
-build the library using /Oityb1 rather than /O2. That is to use
-all optimisation settings except /Oa. This problem is reported to
-affect some standard library code as well (in fact I'm not sure
-if the problem is with the regex code or the underlying standard
-library), so it's probably worthwhile applying this workaround in
-normal practice in any case.</em></p>
-
-<p>Note: if you have replaced the C++ standard library that comes
-with VC6, then when you build the library you must ensure that
-the environment variables &quot;INCLUDE&quot; and &quot;LIB&quot;
-have been updated to reflect the include and library paths for
-the new library - see vcvars32.bat (part of your Visual Studio
-installation) for more details. Alternatively if STLPort is in c:/stlport
-then you could use:</p>
-
-<p>nmake INCLUDES=&quot;-Ic:/stlport/stlport&quot; XLFLAGS=&quot;/LIBPATH:c:/stlport/lib&quot;
--fvc6-stlport.mak</p>
-
-<p>If you are building with the full STLPort v4.x, then use the
-vc6-stlport.mak file provided and set the environment variable
-STLPORT_PATH to point to the location of your STLport
-installation (Note that the full STLPort libraries appear not to
-support single-thread static builds). <br>
-&nbsp; <br>
-&nbsp; </p>
-
-<p><b>GCC(2.95)</b> </p>
-
-<p>There is a conservative makefile for the g++ compiler. From
-the command prompt change to the &lt;boost&gt;/libs/regex/build
-directory and type: </p>
-
-<p>make -fgcc.mak </p>
-
-<p>At the end of the build process you should have a gcc sub-directory
-containing release and debug versions of the library (libboost_regex.a
-and libboost_regex_debug.a). When you build projects that use
-regex++, you will need to add the boost install directory to your
-list of include paths and add &lt;boost&gt;/libs/regex/build/gcc/libboost_regex.a
-to your list of library files. </p>
-
-<p>There is also a makefile to build the library as a shared
-library:</p>
-
-<p>make -fgcc-shared.mak</p>
-
-<p>which will build libboost_regex.so and libboost_regex_debug.so.</p>
-
-<p>Both of the these makefiles support the following environment
-variables:</p>
-
-<p>CXXFLAGS: extra compiler options - note that this applies to
-both the debug and release builds.</p>
-
-<p>INCLUDES: additional include directories.</p>
-
-<p>LDFLAGS: additional linker options.</p>
-
-<p>LIBS: additional library files.</p>
-
-<p>For the more adventurous there is a configure script in
-&lt;boost&gt;/libs/config; see the <a href="../config/config.htm">config
-library documentation</a>.</p>
-
-<p><b>Sun Workshop 6.1</b></p>
-
-<p>There is a makefile for the sun (6.1) compiler (C++ version 3.12).
-From the command prompt change to the &lt;boost&gt;/libs/regex/build
-directory and type: </p>
-
-<p>dmake -f sunpro.mak </p>
-
-<p>At the end of the build process you should have a sunpro sub-directory
-containing single and multithread versions of the library (libboost_regex.a,
-libboost_regex.so, libboost_regex_mt.a and libboost_regex_mt.so).
-When you build projects that use regex++, you will need to add
-the boost install directory to your list of include paths and add
-&lt;boost&gt;/libs/regex/build/sunpro/ to your library search
-path. </p>
-
-<p>Both of the these makefiles support the following environment
-variables:</p>
-
-<p>CXXFLAGS: extra compiler options - note that this applies to
-both the single and multithreaded builds.</p>
-
-<p>INCLUDES: additional include directories.</p>
-
-<p>LDFLAGS: additional linker options.</p>
-
-<p>LIBS: additional library files.</p>
-
-<p>LIBSUFFIX: a suffix to mangle the library name with (defaults
-to nothing).</p>
-
-<p>This makefile does not set any architecture specific options
-like -xarch=v9, you can set these by defining the appropriate
-macros, for example:</p>
-
-<p>dmake CXXFLAGS=&quot;-xarch=v9&quot; LDFLAGS=&quot;-xarch=v9&quot;
-LIBSUFFIX=&quot;_v9&quot; -f sunpro.mak</p>
-
-<p>will build v9 variants of the regex library named
-libboost_regex_v9.a etc.</p>
-
-<p><b>Other compilers:</b> </p>
-
-<p>There is a generic makefile (<a href="build/generic.mak">generic.mak</a>)
-provided in &lt;boost-root&gt;/libs/regex/build - see that
-makefile for details of environment variables that need to be set
-before use. Alternatively you can using the <a
-href="../../tools/build/index.html">Jam based build system</a>.
-If you need to configure the library for your platform, then
-refer to the <a href="../config/config.htm">config library
-documentation</a>.</p>
-
-<hr>
-
-<p><i>Copyright </i><a href="mailto:John_Maddock@compuserve.com"><i>Dr
-John Maddock</i></a><i> 1998-2001 all rights reserved.</i> </p>
-</body>
-</html>

old_include/fileiter.h

@@ -16,7 +16,7 @@
 #ifndef BOOST_FILEITER_H
 #define BOOST_FILEITER_H
 
-#include <boost/regex/detail/fileiter.hpp>
+#include <boost/regex/v3/fileiter.hpp>
 
 using boost::re_detail::directory_iterator;
 using boost::re_detail::file_iterator;

old_include/regex.h

@@ -68,16 +68,7 @@ public:
 template <class iterator, class Allocator, class charT, class traits, class Allocator2>
 bool query_match(iterator first, iterator last, boost::match_results<iterator, Allocator>& m, const reg_expression<charT, traits, Allocator2>& e, unsigned flags = match_default)
 {
-   // prepare m for failure:
-   if((flags & match_init) == 0)
-   {
-      m.set_size(e.mark_count(), first, last);
-      m.set_base(first);
-      m.set_line(1, first);
-   }
-   boost::re_detail::_priv_match_data<iterator, Allocator> pd(m);
-   iterator restart;
-   return boost::re_detail::query_match_aux(first, last, m, e, flags, pd, &restart);
+   return regex_search(first, last, m, e, flags | match_continuous);
 }
 
 //
@@ -144,13 +135,7 @@ inline bool query_match(const std::basic_string<wchar_t>& s,
 template <class iterator, class Allocator, class charT, class traits, class Allocator2>
 bool reg_search(iterator first, iterator last, boost::match_results<iterator, Allocator>& m, const reg_expression<charT, traits, Allocator2>& e, unsigned flags = match_default)
 {
-   if(e.flags() & regbase::failbit)
-      return false;
-
-   typedef typename traits::size_type traits_size_type;
-   typedef typename traits::uchar_type traits_uchar_type;
-
-   return boost::re_detail::reg_grep2(boost::re_detail::grep_search_predicate<iterator, Allocator>(&m), first, last, e, flags, m.allocator());
+   return boost::regex_search(first, last, m, e, flags);
 }
 
 //
@@ -226,7 +211,7 @@ inline bool reg_search(const std::basic_string<wchar_t>& s,
 template <class Predicate, class iterator, class charT, class traits, class Allocator>
 inline unsigned int reg_grep(Predicate foo, iterator first, iterator last, const reg_expression<charT, traits, Allocator>& e, unsigned flags = match_default)
 {
-   return boost::re_detail::reg_grep2(foo, first, last, e, flags, e.allocator());
+   return boost::regex_grep(foo, first, last, e, flags);
 }
 
 //
@@ -345,7 +330,7 @@ struct grep_adaptor
 template <class Out, class iterator, class charT, class traits, class Allocator>
 inline unsigned int reg_grep_old(Out oi, iterator first, iterator last, const reg_expression<charT, traits, Allocator>& e, unsigned flags = match_default)
 {
-   return boost::re_detail::reg_grep2(re_detail::grep_adaptor<Out, iterator, Allocator>(oi, e.allocator()), first, last, e, flags, e.allocator());
+   return boost::regex_grep(re_detail::grep_adaptor<Out, iterator, Allocator>(oi, e.allocator()), first, last, e, flags);
 }
 
 template <class OutputIterator, class iterator, class Allocator, class charT>
@@ -407,9 +392,9 @@ using deprecated::reg_search;
 using deprecated::reg_grep;
 using deprecated::reg_format;
 using deprecated::reg_merge;
-using re_detail::jm_def_alloc;
+//using re_detail::jm_def_alloc;
 using deprecated::char_regex_traits_i;
-using re_detail::re_alloc_binder;
+//using re_detail::re_alloc_binder;
 using re_detail::padding_size;
 
 
@@ -440,7 +425,7 @@ using boost::deprecated::reg_search;
 using boost::deprecated::reg_grep;
 using boost::deprecated::reg_format;
 using boost::deprecated::reg_merge;
-using boost::re_detail::jm_def_alloc;
+//using boost::re_detail::jm_def_alloc;
 
 #endif
 

old_include/tests/snip1.cpp

@@ -1,3 +1,18 @@
+/*
+ *
+ * Copyright (c) 1998-2000
+ * Dr John Maddock
+ *
+ * Permission to use, copy, modify, distribute and sell this software
+ * and its documentation for any purpose is hereby granted without fee,
+ * provided that the above copyright notice appear in all copies and
+ * that both that copyright notice and this permission notice appear
+ * in supporting documentation.  Dr John Maddock makes no representations
+ * about the suitability of this software for any purpose.
+ * It is provided "as is" without express or implied warranty.
+ *
+ */
+
 #include <stdlib.h>
 #include <string>
 #include <iostream>

old_include/tests/snip2.cpp

@@ -1,3 +1,18 @@
+/*
+ *
+ * Copyright (c) 1998-2000
+ * Dr John Maddock
+ *
+ * Permission to use, copy, modify, distribute and sell this software
+ * and its documentation for any purpose is hereby granted without fee,
+ * provided that the above copyright notice appear in all copies and
+ * that both that copyright notice and this permission notice appear
+ * in supporting documentation.  Dr John Maddock makes no representations
+ * about the suitability of this software for any purpose.
+ * It is provided "as is" without express or implied warranty.
+ *
+ */
+
 #include <string>
 #include <map>
 #include <regex>

old_include/tests/snip3.cpp

@@ -1,3 +1,18 @@
+/*
+ *
+ * Copyright (c) 1998-2000
+ * Dr John Maddock
+ *
+ * Permission to use, copy, modify, distribute and sell this software
+ * and its documentation for any purpose is hereby granted without fee,
+ * provided that the above copyright notice appear in all copies and
+ * that both that copyright notice and this permission notice appear
+ * in supporting documentation.  Dr John Maddock makes no representations
+ * about the suitability of this software for any purpose.
+ * It is provided "as is" without express or implied warranty.
+ *
+ */
+
 #include <string>
 #include <map>
 #include <regex>

old_include/tests/snip4.cpp

@@ -1,3 +1,18 @@
+/*
+ *
+ * Copyright (c) 1998-2000
+ * Dr John Maddock
+ *
+ * Permission to use, copy, modify, distribute and sell this software
+ * and its documentation for any purpose is hereby granted without fee,
+ * provided that the above copyright notice appear in all copies and
+ * that both that copyright notice and this permission notice appear
+ * in supporting documentation.  Dr John Maddock makes no representations
+ * about the suitability of this software for any purpose.
+ * It is provided "as is" without express or implied warranty.
+ *
+ */
+
 #include <iostream>
 #include <fstream>
 #include <sstream>

old_include/tests/snip5.cpp

@@ -1,3 +1,18 @@
+/*
+ *
+ * Copyright (c) 1998-2000
+ * Dr John Maddock
+ *
+ * Permission to use, copy, modify, distribute and sell this software
+ * and its documentation for any purpose is hereby granted without fee,
+ * provided that the above copyright notice appear in all copies and
+ * that both that copyright notice and this permission notice appear
+ * in supporting documentation.  Dr John Maddock makes no representations
+ * about the suitability of this software for any purpose.
+ * It is provided "as is" without express or implied warranty.
+ *
+ */
+
 #include <string>
 #include <map>
 #include <regex>

old_include/tests/snip6.cpp

@@ -1,3 +1,18 @@
+/*
+ *
+ * Copyright (c) 1998-2000
+ * Dr John Maddock
+ *
+ * Permission to use, copy, modify, distribute and sell this software
+ * and its documentation for any purpose is hereby granted without fee,
+ * provided that the above copyright notice appear in all copies and
+ * that both that copyright notice and this permission notice appear
+ * in supporting documentation.  Dr John Maddock makes no representations
+ * about the suitability of this software for any purpose.
+ * It is provided "as is" without express or implied warranty.
+ *
+ */
+
 #include <string>
 #include <map>
 #include <regex>

old_include/tests/snip7.cpp

@@ -1,3 +1,18 @@
+/*
+ *
+ * Copyright (c) 1998-2000
+ * Dr John Maddock
+ *
+ * Permission to use, copy, modify, distribute and sell this software
+ * and its documentation for any purpose is hereby granted without fee,
+ * provided that the above copyright notice appear in all copies and
+ * that both that copyright notice and this permission notice appear
+ * in supporting documentation.  Dr John Maddock makes no representations
+ * about the suitability of this software for any purpose.
+ * It is provided "as is" without express or implied warranty.
+ *
+ */
+
 #include <string>
 #include <map>
 #include <regex>

posix_ref.htm

@@ -1,314 +0,0 @@
-<html>
-
-<head>
-<meta http-equiv="Content-Type"
-content="text/html; charset=iso-8859-1">
-<meta name="Template"
-content="C:\PROGRAM FILES\MICROSOFT OFFICE\OFFICE\html.dot">
-<meta name="GENERATOR" content="Microsoft FrontPage Express 2.0">
-<title>Regex++, POSIX API Reference</title>
-</head>
-
-<body bgcolor="#FFFFFF" link="#0000FF" vlink="#800080">
-
-<p>&nbsp; </p>
-
-<table border="0" cellpadding="7" cellspacing="0" width="100%">
-    <tr>
-        <td valign="top"><h3><img src="../../c++boost.gif"
-        alt="C++ Boost" width="276" height="86"></h3>
-        </td>
-        <td valign="top"><h3 align="center">Regex++, POSIX API
-        Reference. </h3>
-        <p align="left"><i>Copyright (c) 1998-2001 </i></p>
-        <p align="left"><i>Dr John Maddock</i></p>
-        <p align="left"><i>Permission to use, copy, modify,
-        distribute and sell this software and its documentation
-        for any purpose is hereby granted without fee, provided
-        that the above copyright notice appear in all copies and
-        that both that copyright notice and this permission
-        notice appear in supporting documentation. Dr John
-        Maddock makes no representations about the suitability of
-        this software for any purpose. It is provided &quot;as is&quot;
-        without express or implied warranty.</i></p>
-        </td>
-    </tr>
-</table>
-
-<hr>
-
-<h3><a name="posix"></a><i>POSIX compatibility library</i></h3>
-
-<pre>#include &lt;boost/cregex.hpp&gt;
-<i>or</i>:
-#include &lt;boost/regex.h&gt;</pre>
-
-<p>The following functions are available for users who need a
-POSIX compatible C library, they are available in both Unicode
-and narrow character versions, the standard POSIX API names are
-macros that expand to one version or the other depending upon
-whether UNICODE is defined or not. </p>
-
-<p><b>Important</b>: Note that all the symbols defined here are
-enclosed inside namespace <i>boost</i> when used in C++ programs,
-unless you use #include &lt;boost/regex.h&gt; instead - in which
-case the symbols are still defined in namespace boost, but are
-made available in the global namespace as well.</p>
-
-<p>The functions are defined as: </p>
-
-<pre>extern &quot;C&quot; {
-<b>int</b> regcompA(regex_tA*, <b>const</b> <b>char</b>*, <b>int</b>);
-<b>unsigned</b> <b>int</b> regerrorA(<b>int</b>, <b>const</b> regex_tA*, <b>char</b>*, <b>unsigned</b> <b>int</b>);
-<b>int</b> regexecA(<b>const</b> regex_tA*, <b>const</b> <b>char</b>*, <b>unsigned</b> <b>int</b>, regmatch_t*, <b>int</b>);
-<b>void</b> regfreeA(regex_tA*);
-
-<b>int</b> regcompW(regex_tW*, <b>const</b> <b>wchar_t</b>*, <b>int</b>);
-<b>unsigned</b> <b>int</b> regerrorW(<b>int</b>, <b>const</b> regex_tW*, <b>wchar_t</b>*, <b>unsigned</b> <b>int</b>);
-<b>int</b> regexecW(<b>const</b> regex_tW*, <b>const</b> <b>wchar_t</b>*, <b>unsigned</b> <b>int</b>, regmatch_t*, <b>int</b>);
-<b>void</b> regfreeW(regex_tW*);
-
-#ifdef UNICODE
-#define regcomp regcompW
-#define regerror regerrorW
-#define regexec regexecW
-#define regfree regfreeW
-#define regex_t regex_tW
-#else
-#define regcomp regcompA
-#define regerror regerrorA
-#define regexec regexecA
-#define regfree regfreeA
-#define regex_t regex_tA
-#endif
-}</pre>
-
-<p>All the functions operate on structure <b>regex_t</b>, which
-exposes two public members: </p>
-
-<p><b>unsigned int re_nsub</b> this is filled in by <b>regcomp</b>
-and indicates the number of sub-expressions contained in the
-regular expression. </p>
-
-<p><b>const TCHAR* re_endp</b> points to the end of the
-expression to compile when the flag REG_PEND is set. </p>
-
-<p><i>Footnote: regex_t is actually a #define - it is either
-regex_tA or regex_tW depending upon whether UNICODE is defined or
-not, TCHAR is either char or wchar_t again depending upon the
-macro UNICODE.</i> </p>
-
-<p><b>regcomp</b> takes a pointer to a <b>regex_t</b>, a pointer
-to the expression to compile and a flags parameter which can be a
-combination of: <br>
-&nbsp; </p>
-
-<table border="0" cellpadding="7" cellspacing="0" width="100%">
-    <tr>
-        <td width="5%">&nbsp;</td>
-        <td valign="top" width="45%">REG_EXTENDED</td>
-        <td valign="top" width="45%">Compiles modern regular
-        expressions. Equivalent to regbase::char_classes |
-        regbase::intervals | regbase::bk_refs.</td>
-        <td width="5%">&nbsp;</td>
-    </tr>
-    <tr>
-        <td width="5%">&nbsp;</td>
-        <td valign="top" width="45%">REG_BASIC</td>
-        <td valign="top" width="45%">Compiles basic (obsolete)
-        regular expression syntax. Equivalent to regbase::char_classes
-        | regbase::intervals | regbase::limited_ops | regbase::bk_braces
-        | regbase::bk_parens | regbase::bk_refs.</td>
-        <td width="5%">&nbsp;</td>
-    </tr>
-    <tr>
-        <td width="5%">&nbsp;</td>
-        <td valign="top" width="45%">REG_NOSPEC</td>
-        <td valign="top" width="45%">All characters are ordinary,
-        the expression is a literal string.</td>
-        <td width="5%">&nbsp;</td>
-    </tr>
-    <tr>
-        <td width="5%">&nbsp;</td>
-        <td valign="top" width="45%">REG_ICASE</td>
-        <td valign="top" width="45%">Compiles for matching that
-        ignores character case.</td>
-        <td width="5%">&nbsp;</td>
-    </tr>
-    <tr>
-        <td width="5%">&nbsp;</td>
-        <td valign="top" width="45%">REG_NOSUB</td>
-        <td valign="top" width="45%">Has no effect in this
-        library.</td>
-        <td width="5%">&nbsp;</td>
-    </tr>
-    <tr>
-        <td width="5%">&nbsp;</td>
-        <td valign="top" width="45%">REG_NEWLINE</td>
-        <td valign="top" width="45%">When this flag is set a dot
-        does not match the newline character.</td>
-        <td width="5%">&nbsp;</td>
-    </tr>
-    <tr>
-        <td width="5%">&nbsp;</td>
-        <td valign="top" width="45%">REG_PEND</td>
-        <td valign="top" width="45%">When this flag is set the
-        re_endp parameter of the regex_t structure must point to
-        the end of the regular expression to compile.</td>
-        <td width="5%">&nbsp;</td>
-    </tr>
-    <tr>
-        <td width="5%">&nbsp;</td>
-        <td valign="top" width="45%">REG_NOCOLLATE</td>
-        <td valign="top" width="45%">When this flag is set then
-        locale dependent collation for character ranges is turned
-        off.</td>
-        <td width="5%">&nbsp;</td>
-    </tr>
-    <tr>
-        <td width="5%">&nbsp;</td>
-        <td valign="top" width="45%">REG_ESCAPE_IN_LISTS<br>
-        , , , </td>
-        <td valign="top" width="45%">When this flag is set, then
-        escape sequences are permitted in bracket expressions (character
-        sets).</td>
-        <td width="5%">&nbsp;</td>
-    </tr>
-    <tr>
-        <td width="5%">&nbsp;</td>
-        <td valign="top" width="45%">REG_NEWLINE_ALT&nbsp;</td>
-        <td valign="top" width="45%">When this flag is set then
-        the newline character is equivalent to the alternation
-        operator |.</td>
-        <td width="5%">&nbsp;</td>
-    </tr>
-    <tr>
-        <td width="5%">&nbsp;</td>
-        <td valign="top" width="45%">REG_PERL&nbsp;</td>
-        <td valign="top" width="45%">&nbsp;A shortcut for perl-like
-        behavior: REG_EXTENDED | REG_NOCOLLATE |
-        REG_ESCAPE_IN_LISTS</td>
-        <td width="5%">&nbsp;</td>
-    </tr>
-    <tr>
-        <td width="5%">&nbsp;</td>
-        <td valign="top" width="45%">REG_AWK</td>
-        <td valign="top" width="45%">A shortcut for awk-like
-        behavior: REG_EXTENDED | REG_ESCAPE_IN_LISTS</td>
-        <td width="5%">&nbsp;</td>
-    </tr>
-    <tr>
-        <td width="5%">&nbsp;</td>
-        <td valign="top" width="45%">REG_GREP</td>
-        <td valign="top" width="45%">A shortcut for grep like
-        behavior: REG_BASIC | REG_NEWLINE_ALT</td>
-        <td width="5%">&nbsp;</td>
-    </tr>
-    <tr>
-        <td width="5%">&nbsp;</td>
-        <td valign="top" width="45%">REG_EGREP</td>
-        <td valign="top" width="45%">&nbsp;A shortcut for egrep
-        like behavior: REG_EXTENDED | REG_NEWLINE_ALT</td>
-        <td width="5%">&nbsp;</td>
-    </tr>
-</table>
-
-<p><br>
-&nbsp; </p>
-
-<p><b>regerror</b> takes the following parameters, it maps an
-error code to a human readable string: <br>
-&nbsp; </p>
-
-<table border="0" cellpadding="7" cellspacing="0" width="100%">
-    <tr>
-        <td width="5%">&nbsp;</td>
-        <td valign="top" width="50%">int code</td>
-        <td valign="top" width="50%">The error code.</td>
-        <td width="5%">&nbsp;</td>
-    </tr>
-    <tr>
-        <td>&nbsp;</td>
-        <td valign="top" width="50%">const regex_t* e</td>
-        <td valign="top" width="50%">The regular expression (can
-        be null).</td>
-        <td>&nbsp;</td>
-    </tr>
-    <tr>
-        <td>&nbsp;</td>
-        <td valign="top" width="50%">char* buf</td>
-        <td valign="top" width="50%">The buffer to fill in with
-        the error message.</td>
-        <td>&nbsp;</td>
-    </tr>
-    <tr>
-        <td>&nbsp;</td>
-        <td valign="top" width="50%">unsigned int buf_size</td>
-        <td valign="top" width="50%">The length of buf.</td>
-        <td>&nbsp;</td>
-    </tr>
-</table>
-
-<p>If the error code is OR'ed with REG_ITOA then the message that
-results is the printable name of the code rather than a message,
-for example &quot;REG_BADPAT&quot;. If the code is REG_ATIO then <b>e</b>
-must not be null and <b>e-&gt;re_pend</b> must point to the
-printable name of an error code, the return value is then the
-value of the error code. For any other value of <b>code</b>, the
-return value is the number of characters in the error message, if
-the return value is greater than or equal to <b>buf_size</b> then
-<b>regerror</b> will have to be called again with a larger buffer.</p>
-
-<p><b>regexec</b> finds the first occurrence of expression <b>e</b>
-within string <b>buf</b>. If <b>len</b> is non-zero then *<b>m</b>
-is filled in with what matched the regular expression, <b>m[0]</b>
-contains what matched the whole string, <b>m[1] </b>the first sub-expression
-etc, see <b>regmatch_t</b> in the header file declaration for
-more details. The <b>eflags</b> parameter can be a combination of:
-<br>
-&nbsp; </p>
-
-<table border="0" cellpadding="7" cellspacing="0" width="100%">
-    <tr>
-        <td width="5%">&nbsp;</td>
-        <td valign="top" width="50%">REG_NOTBOL</td>
-        <td valign="top" width="50%">Parameter <b>buf </b>does
-        not represent the start of a line.</td>
-        <td width="5%">&nbsp;</td>
-    </tr>
-    <tr>
-        <td>&nbsp;</td>
-        <td valign="top" width="50%">REG_NOTEOL</td>
-        <td valign="top" width="50%">Parameter <b>buf</b> does
-        not terminate at the end of a line.</td>
-        <td>&nbsp;</td>
-    </tr>
-    <tr>
-        <td>&nbsp;</td>
-        <td valign="top" width="50%">REG_STARTEND</td>
-        <td valign="top" width="50%">The string searched starts
-        at buf + pmatch[0].rm_so and ends at buf + pmatch[0].rm_eo.</td>
-        <td>&nbsp;</td>
-    </tr>
-</table>
-
-<p><br>
-&nbsp; </p>
-
-<p>Finally <b>regfree</b> frees all the memory that was allocated
-by regcomp. </p>
-
-<p><i>Footnote: this is an abridged reference to the POSIX API
-functions, it is provided for compatibility with other libraries,
-rather than an API to be used in new code (unless you need access
-from a language other than C++). This version of these functions
-should also happily coexist with other versions, as the names
-used are macros that expand to the actual function names.</i> <br>
-</p>
-
-<hr>
-
-<p><i>Copyright </i><a href="mailto:John_Maddock@compuserve.com"><i>Dr
-John Maddock</i></a><i> 1998-2000 all rights reserved.</i> </p>
-</body>
-</html>

src/c_regex_traits.cpp

@@ -35,8 +35,8 @@
 #include <cstdio>
 #include <boost/cregex.hpp>
 #include <boost/regex/regex_traits.hpp>
-#include <boost/regex/detail/regex_synch.hpp>
-#include <boost/regex/detail/regex_cstring.hpp>
+#include <boost/regex/v3/regex_synch.hpp>
+#include <boost/regex/v3/regex_cstring.hpp>
 #include <boost/scoped_array.hpp>
 
 #include "primary_transform.hpp"
@@ -54,6 +54,17 @@ void c_regex_adopted_no_longer_needed_loop_shutter_upper() { }
 
 namespace{
 
+//
+// helper function to get the locale name,
+// works around possibly broken setlocale implementations:
+//
+const char* getlocale(int id)
+{
+   static const char* def = "Unknown";
+   const char* pl = std::setlocale(id, 0);
+   return pl ? pl : def;
+}
+
 //
 // character classes:
 //
@@ -237,9 +248,9 @@ void BOOST_REGEX_CALL re_free_classes()
 void BOOST_REGEX_CALL re_update_classes()
 {
    BOOST_RE_GUARD_STACK
-   if(*re_cls_name != std::setlocale(LC_CTYPE, 0))
+   if(*re_cls_name != getlocale(LC_CTYPE))
    {
-      *re_cls_name = std::setlocale(LC_CTYPE, 0);
+      *re_cls_name = getlocale(LC_CTYPE);
       char buf[256];
       unsigned int i;
       for(i = 0; i < re_classes_max; ++i)
@@ -286,9 +297,9 @@ void BOOST_REGEX_CALL re_free_collate()
 void BOOST_REGEX_CALL re_update_collate()
 {
    BOOST_RE_GUARD_STACK
-   if(*re_coll_name != std::setlocale(LC_COLLATE, 0))
+   if(*re_coll_name != getlocale(LC_COLLATE))
    {
-      *re_coll_name = std::setlocale(LC_COLLATE, 0);
+      *re_coll_name = getlocale(LC_COLLATE);
       char buf[256];
       unsigned int i = 400;
       re_get_message(buf, 256, i);
@@ -350,7 +361,7 @@ void BOOST_REGEX_CALL re_message_update()
    //
    // called whenever the global locale changes:
    //
-   std::string l(std::setlocale(LC_MESSAGES, 0));
+   std::string l(getlocale(LC_MESSAGES));
    if(*mess_locale != l)
    {
       *mess_locale = l;
@@ -503,9 +514,9 @@ void BOOST_REGEX_CALL c_traits_base::do_update_ctype()
       if(std::isxdigit(i))
          class_map[i] |= char_class_xdigit;
    }
-   class_map['_'] |= char_class_underscore;
-   class_map[' '] |= char_class_blank;
-   class_map['\t'] |= char_class_blank;
+   class_map[(unsigned char)'_'] |= char_class_underscore;
+   class_map[(unsigned char)' '] |= char_class_blank;
+   class_map[(unsigned char)'\t'] |= char_class_blank;
    for(i = 0; i < map_size; ++i)
    {
       lower_case_map[i] = (char)std::tolower(i);
@@ -641,15 +652,15 @@ void BOOST_REGEX_CALL c_regex_traits<char>::update()
    re_detail::cs_guard g(*re_detail::p_re_lock);
    #endif
    re_message_update();
-   if(*collate_name != std::setlocale(LC_COLLATE, 0))
+   if(*collate_name != getlocale(LC_COLLATE))
    {
       do_update_collate();
-      *collate_name = std::setlocale(LC_COLLATE, 0);
+      *collate_name = getlocale(LC_COLLATE);
    }
-   if(*ctype_name != std::setlocale(LC_CTYPE, 0))
+   if(*ctype_name != getlocale(LC_CTYPE))
    {
       do_update_ctype();
-      *ctype_name = std::setlocale(LC_CTYPE, 0);
+      *ctype_name = getlocale(LC_CTYPE);
    }
    sort_type = re_detail::find_sort_syntax(&i, &sort_delim);
 }
@@ -838,7 +849,7 @@ void BOOST_REGEX_CALL c_regex_traits<wchar_t>::update()
    re_message_update();
    re_update_classes();
    re_update_collate();
-   std::string l(std::setlocale(LC_CTYPE, 0));
+   std::string l(getlocale(LC_CTYPE));
    if(*wlocale_name != l)
    {
       *wlocale_name = l;
@@ -1059,3 +1070,4 @@ std::size_t BOOST_REGEX_CALL c_regex_traits<wchar_t>::strwiden(wchar_t *s1, std:
 } // namespace boost
 
 
+

src/c_regex_traits_common.cpp

@@ -29,7 +29,7 @@
 #include <list>
 #include <cctype>
 #include <boost/regex/regex_traits.hpp>
-#include <boost/regex/detail/regex_synch.hpp>
+#include <boost/regex/v3/regex_synch.hpp>
 
 
 namespace boost{
@@ -554,3 +554,4 @@ BOOST_REGEX_DECL wchar_t wide_lower_case_map[] = {
    } // namespace re_detail
 } // namespace boost
 
+

src/cpp_regex_traits.cpp

@@ -241,7 +241,7 @@ message_data<char>::message_data(const std::locale& l, const std::string& regex_
 #endif
       for(std::size_t j = 0; j < s.size(); ++j)
       {
-         syntax_map[s[j]] = (unsigned char)(i);
+         syntax_map[(unsigned char)s[j]] = (unsigned char)(i);
       }
    }
 

src/cregex.cpp

@@ -28,7 +28,7 @@
 #if !defined(BOOST_NO_STD_STRING)
 #include <map>
 #include <list>
-#include <boost/regex/detail/fileiter.hpp>
+#include <boost/regex/v3/fileiter.hpp>
 #include <cstdio>
 
 namespace boost{
@@ -655,3 +655,4 @@ basic_string<char>::replace<const char*>(char* f1, char* f2, const char* i1, con
 
 
 
+

src/fileiter.cpp

@@ -25,7 +25,7 @@
 
 #include <climits>
 #include <stdexcept>
-#include <boost/regex/detail/fileiter.hpp>
+#include <boost/regex/v3/fileiter.hpp>
 
 #ifndef BOOST_REGEX_NO_FILEITER
 
@@ -900,3 +900,4 @@ bool _fi_FindClose(_fi_find_handle dat)
 
 
 
+

src/regex_debug.cpp

@@ -31,7 +31,7 @@
 #include <crtdbg.h>
 #endif
 
-#include <boost/regex/detail/regex_raw_buffer.hpp>
+#include <boost/regex/v3/regex_raw_buffer.hpp>
 #include <boost/regex.hpp>
 
 #ifndef BOOST_RE_OLD_IOSTREAM
@@ -216,3 +216,4 @@ debug_guard::~debug_guard()
 
 
 
+

src/regex_synch.cpp

@@ -24,7 +24,7 @@
 
 #define BOOST_REGEX_SOURCE
 
-#include <boost/regex/detail/regex_synch.hpp>
+#include <boost/regex/v3/regex_synch.hpp>
 
 namespace boost{
    namespace re_detail{
@@ -67,3 +67,4 @@ BOOST_REGEX_DECL unsigned int re_lock_count = 0;
 } // namespace boost
 
 
+

src/w32_regex_traits.cpp

@@ -27,13 +27,13 @@
 #include <list>
 #include <cctype>
 #include <cstdio>
-#include <boost/cregex.hpp>
 #include <boost/regex/regex_traits.hpp>
-#include <boost/regex/detail/regex_synch.hpp>
-#include <boost/regex/detail/regex_cstring.hpp>
+#if defined(_WIN32) && !defined(BOOST_REGEX_NO_W32)
+#include <boost/cregex.hpp>
+#include <boost/regex/v3/regex_synch.hpp>
+#include <boost/regex/v3/regex_cstring.hpp>
 #include <boost/scoped_array.hpp>
 
-#if defined(_WIN32) && !defined(BOOST_REGEX_NO_W32)
 
 //
 // VC6 needs to link to user32.lib, as do all compilers that
@@ -1101,3 +1101,4 @@ unsigned short w32_regex_traits<wchar_t>::wide_unicode_classes[] = {
 
 
 
+

syntax.htm

@@ -1,742 +0,0 @@
-<html>
-
-<head>
-<meta http-equiv="Content-Type"
-content="text/html; charset=iso-8859-1">
-<meta name="Template"
-content="C:\PROGRAM FILES\MICROSOFT OFFICE\OFFICE\html.dot">
-<meta name="GENERATOR" content="Microsoft FrontPage Express 2.0">
-<title>Regex++, Regular Expression Syntax</title>
-</head>
-
-<body bgcolor="#FFFFFF" link="#0000FF" vlink="#800080">
-
-<p>&nbsp; </p>
-
-<table border="0" cellpadding="7" cellspacing="0" width="100%">
-    <tr>
-        <td valign="top"><h3><img src="../../c++boost.gif"
-        alt="C++ Boost" width="276" height="86"></h3>
-        </td>
-        <td valign="top"><h3 align="center">Regex++, Regular
-        Expression Syntax.</h3>
-        <p align="left"><i>Copyright (c) 1998-2001 </i></p>
-        <p align="left"><i>Dr John Maddock</i></p>
-        <p align="left"><i>Permission to use, copy, modify,
-        distribute and sell this software and its documentation
-        for any purpose is hereby granted without fee, provided
-        that the above copyright notice appear in all copies and
-        that both that copyright notice and this permission
-        notice appear in supporting documentation. Dr John
-        Maddock makes no representations about the suitability of
-        this software for any purpose. It is provided &quot;as is&quot;
-        without express or implied warranty.</i></p>
-        </td>
-    </tr>
-</table>
-
-<hr>
-
-<h3><a name="syntax"></a><i>Regular expression syntax</i></h3>
-
-<p>This section covers the regular expression syntax used by this
-library, this is a programmers guide, the actual syntax presented
-to your program's users will depend upon the flags used during
-expression compilation. </p>
-
-<p><i>Literals</i> </p>
-
-<p>All characters are literals except: &quot;.&quot;, &quot;|&quot;,
-&quot;*&quot;, &quot;?&quot;, &quot;+&quot;, &quot;(&quot;,
-&quot;)&quot;, &quot;{&quot;, &quot;}&quot;, &quot;[&quot;,
-&quot;]&quot;, &quot;^&quot;, &quot;$&quot; and &quot;\&quot;.
-These characters are literals when preceded by a &quot;\&quot;. A
-literal is a character that matches itself, or matches the result
-of traits_type::translate(), where traits_type is the traits
-template parameter to class reg_expression. <br>
-&nbsp; <br>
-&nbsp; </p>
-
-<p><i>Wildcard</i> </p>
-
-<p>The dot character &quot;.&quot; matches any single character
-except : when <i>match_not_dot_null</i> is passed to the matching
-algorithms, the dot does not match a null character; when <i>match_not_dot_newline</i>
-is passed to the matching algorithms, then the dot does not match
-a newline character. <br>
-&nbsp; <br>
-&nbsp; </p>
-
-<p><i>Repeats</i> </p>
-
-<p>A repeat is an expression that is repeated an arbitrary number
-of times. An expression followed by &quot;*&quot; can be repeated
-any number of times including zero. An expression followed by
-&quot;+&quot; can be repeated any number of times, but at least
-once, if the expression is compiled with the flag regbase::bk_plus_qm
-then &quot;+&quot; is an ordinary character and &quot;\+&quot;
-represents a repeat of once or more. An expression followed by
-&quot;?&quot; may be repeated zero or one times only, if the
-expression is compiled with the flag regbase::bk_plus_qm then
-&quot;?&quot; is an ordinary character and &quot;\?&quot;
-represents the repeat zero or once operator. When it is necessary
-to specify the minimum and maximum number of repeats explicitly,
-the bounds operator &quot;{}&quot; may be used, thus &quot;a{2}&quot;
-is the letter &quot;a&quot; repeated exactly twice, &quot;a{2,4}&quot;
-represents the letter &quot;a&quot; repeated between 2 and 4
-times, and &quot;a{2,}&quot; represents the letter &quot;a&quot;
-repeated at least twice with no upper limit. Note that there must
-be no white-space inside the {}, and there is no upper limit on
-the values of the lower and upper bounds. When the expression is
-compiled with the flag regbase::bk_braces then &quot;{&quot; and
-&quot;}&quot; are ordinary characters and &quot;\{&quot; and
-&quot;\}&quot; are used to delimit bounds instead. All repeat
-expressions refer to the shortest possible previous sub-expression:
-a single character; a character set, or a sub-expression grouped
-with &quot;()&quot; for example. </p>
-
-<p>Examples: </p>
-
-<p>&quot;ba*&quot; will match all of &quot;b&quot;, &quot;ba&quot;,
-&quot;baaa&quot; etc. </p>
-
-<p>&quot;ba+&quot; will match &quot;ba&quot; or &quot;baaaa&quot;
-for example but not &quot;b&quot;. </p>
-
-<p>&quot;ba?&quot; will match &quot;b&quot; or &quot;ba&quot;. </p>
-
-<p>&quot;ba{2,4}&quot; will match &quot;baa&quot;, &quot;baaa&quot;
-and &quot;baaaa&quot;. </p>
-
-<p><i>Non-greedy repeats</i> </p>
-
-<p>Whenever the &quot;extended&quot; regular expression syntax is
-in use (the default) then non-greedy repeats are possible by
-appending a '?' after the repeat; a non-greedy repeat is one
-which will match the <i>shortest</i> possible string. </p>
-
-<p>For example to match html tag pairs one could use something
-like: </p>
-
-<p>&quot;&lt;\s*tagname[^&gt;]*&gt;(.*?)&lt;\s*/tagname\s*&gt;&quot;
-</p>
-
-<p>In this case $1 will contain the text between the tag pairs,
-and will be the shortest possible matching string. <br>
-&nbsp; <br>
-&nbsp; </p>
-
-<p><i>Parenthesis</i> </p>
-
-<p>Parentheses serve two purposes, to group items together into a
-sub-expression, and to mark what generated the match. For example
-the expression &quot;(ab)*&quot; would match all of the string
-&quot;ababab&quot;. The matching algorithms <a
-href="template_class_ref.htm#query_match">regex_match</a> and <a
-href="template_class_ref.htm#reg_search">regex_search</a> each
-take an instance of <a href="template_class_ref.htm#reg_match">match_results</a>
-that reports what caused the match, on exit from these functions
-the <a href="template_class_ref.htm#reg_match">match_results</a>
-contains information both on what the whole expression matched
-and on what each sub-expression matched. In the example above
-match_results[1] would contain a pair of iterators denoting the
-final &quot;ab&quot; of the matching string. It is permissible
-for sub-expressions to match null strings. If a sub-expression
-takes no part in a match - for example if it is part of an
-alternative that is not taken - then both of the iterators that
-are returned for that sub-expression point to the end of the
-input string, and the <i>matched</i> parameter for that sub-expression
-is <i>false</i>. Sub-expressions are indexed from left to right
-starting from 1, sub-expression 0 is the whole expression. </p>
-
-<p><i>Non-Marking Parenthesis</i> </p>
-
-<p>Sometimes you need to group sub-expressions with parenthesis,
-but don't want the parenthesis to spit out another marked sub-expression,
-in this case a non-marking parenthesis (?:expression) can be used.
-For example the following expression creates no sub-expressions: </p>
-
-<p>&quot;(?:abc)*&quot;</p>
-
-<p><em>Forward Lookahead Asserts</em>&nbsp; </p>
-
-<p>There are two forms of these; one for positive forward
-lookahead asserts, and one for negative lookahead asserts:</p>
-
-<p>&quot;(?=abc)&quot; matches zero characters only if they are
-followed by the expression &quot;abc&quot;.</p>
-
-<p>&quot;(?!abc)&quot; matches zero characters only if they are
-not followed by the expression &quot;abc&quot;.</p>
-
-<p><i>Alternatives</i> </p>
-
-<p>Alternatives occur when the expression can match either one
-sub-expression or another, each alternative is separated by a
-&quot;|&quot;, or a &quot;\|&quot; if the flag regbase::bk_vbar
-is set, or by a newline character if the flag regbase::newline_alt
-is set. Each alternative is the largest possible previous sub-expression;
-this is the opposite behaviour from repetition operators. </p>
-
-<p>Examples: </p>
-
-<p>&quot;a(b|c)&quot; could match &quot;ab&quot; or &quot;ac&quot;.
-</p>
-
-<p>&quot;abc|def&quot; could match &quot;abc&quot; or &quot;def&quot;.
-<br>
-&nbsp; <br>
-&nbsp; </p>
-
-<p><i>Sets</i> </p>
-
-<p>A set is a set of characters that can match any single
-character that is a member of the set. Sets are delimited by
-&quot;[&quot; and &quot;]&quot; and can contain literals,
-character ranges, character classes, collating elements and
-equivalence classes. Set declarations that start with &quot;^&quot;
-contain the compliment of the elements that follow. </p>
-
-<p>Examples: </p>
-
-<p>Character literals: </p>
-
-<p>&quot;[abc]&quot; will match either of &quot;a&quot;, &quot;b&quot;,
-or &quot;c&quot;. </p>
-
-<p>&quot;[^abc] will match any character other than &quot;a&quot;,
-&quot;b&quot;, or &quot;c&quot;. </p>
-
-<p>Character ranges: </p>
-
-<p>&quot;[a-z]&quot; will match any character in the range &quot;a&quot;
-to &quot;z&quot;. </p>
-
-<p>&quot;[^A-Z]&quot; will match any character other than those
-in the range &quot;A&quot; to &quot;Z&quot;. </p>
-
-<p>Note that character ranges are highly locale dependent: they
-match any character that collates between the endpoints of the
-range, ranges will only behave according to ASCII rules when the
-default &quot;C&quot; locale is in effect. For example if the
-library is compiled with the Win32 localization model, then [a-z]
-will match the ASCII characters a-z, and also 'A', 'B' etc, but
-not 'Z' which collates just after 'z'. This locale specific
-behaviour can be disabled by specifying regbase::nocollate when
-compiling, this is the default behaviour when using regbase::normal,
-and forces ranges to collate according to ASCII character code.
-Likewise, if you use the POSIX C API functions then setting
-REG_NOCOLLATE turns off locale dependent collation. </p>
-
-<p>Character classes are denoted using the syntax &quot;[:classname:]&quot;
-within a set declaration, for example &quot;[[:space:]]&quot; is
-the set of all whitespace characters. Character classes are only
-available if the flag regbase::char_classes is set. The available
-character classes are: <br>
-&nbsp; </p>
-
-<table border="0" cellpadding="7" cellspacing="0" width="100%">
-    <tr>
-        <td width="5%">&nbsp;</td>
-        <td valign="top" width="50%">alnum</td>
-        <td valign="top" width="50%">Any alpha numeric character.</td>
-        <td width="5%">&nbsp;</td>
-    </tr>
-    <tr>
-        <td>&nbsp;</td>
-        <td valign="top" width="50%">alpha</td>
-        <td valign="top" width="50%">Any alphabetical character a-z
-        and A-Z. Other characters may also be included depending
-        upon the locale.</td>
-        <td>&nbsp;</td>
-    </tr>
-    <tr>
-        <td>&nbsp;</td>
-        <td valign="top" width="50%">blank</td>
-        <td valign="top" width="50%">Any blank character, either
-        a space or a tab.</td>
-        <td>&nbsp;</td>
-    </tr>
-    <tr>
-        <td>&nbsp;</td>
-        <td valign="top" width="50%">cntrl</td>
-        <td valign="top" width="50%">Any control character.</td>
-        <td>&nbsp;</td>
-    </tr>
-    <tr>
-        <td>&nbsp;</td>
-        <td valign="top" width="50%">digit</td>
-        <td valign="top" width="50%">Any digit 0-9.</td>
-        <td>&nbsp;</td>
-    </tr>
-    <tr>
-        <td>&nbsp;</td>
-        <td valign="top" width="50%">graph</td>
-        <td valign="top" width="50%">Any graphical character.</td>
-        <td>&nbsp;</td>
-    </tr>
-    <tr>
-        <td>&nbsp;</td>
-        <td valign="top" width="50%">lower</td>
-        <td valign="top" width="50%">Any lower case character a-z.
-        Other characters may also be included depending upon the
-        locale.</td>
-        <td>&nbsp;</td>
-    </tr>
-    <tr>
-        <td>&nbsp;</td>
-        <td valign="top" width="50%">print</td>
-        <td valign="top" width="50%">Any printable character.</td>
-        <td>&nbsp;</td>
-    </tr>
-    <tr>
-        <td>&nbsp;</td>
-        <td valign="top" width="50%">punct</td>
-        <td valign="top" width="50%">Any punctuation character.</td>
-        <td>&nbsp;</td>
-    </tr>
-    <tr>
-        <td>&nbsp;</td>
-        <td valign="top" width="50%">space</td>
-        <td valign="top" width="50%">Any whitespace character.</td>
-        <td>&nbsp;</td>
-    </tr>
-    <tr>
-        <td>&nbsp;</td>
-        <td valign="top" width="50%">upper</td>
-        <td valign="top" width="50%">Any upper case character A-Z.
-        Other characters may also be included depending upon the
-        locale.</td>
-        <td>&nbsp;</td>
-    </tr>
-    <tr>
-        <td>&nbsp;</td>
-        <td valign="top" width="50%">xdigit</td>
-        <td valign="top" width="50%">Any hexadecimal digit
-        character, 0-9, a-f and A-F.</td>
-        <td>&nbsp;</td>
-    </tr>
-    <tr>
-        <td>&nbsp;</td>
-        <td valign="top" width="50%">word</td>
-        <td valign="top" width="50%">Any word character - all
-        alphanumeric characters plus the underscore.</td>
-        <td>&nbsp;</td>
-    </tr>
-    <tr>
-        <td>&nbsp;</td>
-        <td valign="top" width="50%">unicode</td>
-        <td valign="top" width="50%">Any character whose code is
-        greater than 255, this applies to the wide character
-        traits classes only.</td>
-        <td>&nbsp;</td>
-    </tr>
-</table>
-
-<p>There are some shortcuts that can be used in place of the
-character classes, provided the flag regbase::escape_in_lists is
-set then you can use: </p>
-
-<p>\w in place of [:word:] </p>
-
-<p>\s in place of [:space:] </p>
-
-<p>\d in place of [:digit:] </p>
-
-<p>\l in place of [:lower:] </p>
-
-<p>\u in place of [:upper:] <br>
-&nbsp; <br>
-&nbsp; </p>
-
-<p>Collating elements take the general form [.tagname.] inside a
-set declaration, where <i>tagname</i> is either a single
-character, or a name of a collating element, for example [[.a.]]
-is equivalent to [a], and [[.comma.]] is equivalent to [,]. The
-library supports all the standard POSIX collating element names,
-and in addition the following digraphs: &quot;ae&quot;, &quot;ch&quot;,
-&quot;ll&quot;, &quot;ss&quot;, &quot;nj&quot;, &quot;dz&quot;,
-&quot;lj&quot;, each in lower, upper and title case variations.
-Multi-character collating elements can result in the set matching
-more than one character, for example [[.ae.]] would match two
-characters, but note that [^[.ae.]] would only match one
-character. <br>
-&nbsp; <br>
-&nbsp; </p>
-
-<p>Equivalence classes take the general form [=tagname=] inside a
-set declaration, where <i>tagname</i> is either a single
-character, or a name of a collating element, and matches any
-character that is a member of the same primary equivalence class
-as the collating element [.tagname.]. An equivalence class is a
-set of characters that collate the same, a primary equivalence
-class is a set of characters whose primary sort key are all the
-same (for example strings are typically collated by character,
-then by accent, and then by case; the primary sort key then
-relates to the character, the secondary to the accentation, and
-the tertiary to the case). If there is no equivalence class
-corresponding to <i>tagname</i>, then [=tagname=] is exactly the
-same as [.tagname.]. Unfortunately there is no locale independent
-method of obtaining the primary sort key for a character, except
-under Win32. For other operating systems the library will &quot;guess&quot;
-the primary sort key from the full sort key (obtained from <i>strxfrm</i>),
-so equivalence classes are probably best considered broken under
-any operating system other than Win32. <br>
-&nbsp; <br>
-&nbsp; </p>
-
-<p>To include a literal &quot;-&quot; in a set declaration then:
-make it the first character after the opening &quot;[&quot; or
-&quot;[^&quot;, the endpoint of a range, a collating element, or
-if the flag regbase::escape_in_lists is set then precede with an
-escape character as in &quot;[\-]&quot;. To include a literal
-&quot;[&quot; or &quot;]&quot; or &quot;^&quot; in a set then
-make them the endpoint of a range, a collating element, or
-precede with an escape character if the flag regbase::escape_in_lists
-is set. <br>
-&nbsp; <br>
-&nbsp; </p>
-
-<p><i>Line anchors</i> </p>
-
-<p>An anchor is something that matches the null string at the
-start or end of a line: &quot;^&quot; matches the null string at
-the start of a line, &quot;$&quot; matches the null string at the
-end of a line. <br>
-&nbsp; <br>
-&nbsp; </p>
-
-<p><i>Back references</i> </p>
-
-<p>A back reference is a reference to a previous sub-expression
-that has already been matched, the reference is to what the sub-expression
-matched, not to the expression itself. A back reference consists
-of the escape character &quot;\&quot; followed by a digit &quot;1&quot;
-to &quot;9&quot;, &quot;\1&quot; refers to the first sub-expression,
-&quot;\2&quot; to the second etc. For example the expression
-&quot;(.*)\1&quot; matches any string that is repeated about its
-mid-point for example &quot;abcabc&quot; or &quot;xyzxyz&quot;. A
-back reference to a sub-expression that did not participate in
-any match, matches the null string: NB this is different to some
-other regular expression matchers. Back references are only
-available if the expression is compiled with the flag regbase::bk_refs
-set. <br>
-&nbsp; <br>
-&nbsp; </p>
-
-<p><i>Characters by code</i> </p>
-
-<p>This is an extension to the algorithm that is not available in
-other libraries, it consists of the escape character followed by
-the digit &quot;0&quot; followed by the octal character code. For
-example &quot;\023&quot; represents the character whose octal
-code is 23. Where ambiguity could occur use parentheses to break
-the expression up: &quot;\0103&quot; represents the character
-whose code is 103, &quot;(\010)3 represents the character 10
-followed by &quot;3&quot;. To match characters by their
-hexadecimal code, use \x followed by a string of hexadecimal
-digits, optionally enclosed inside {}, for example \xf0 or
-\x{aff}, notice the latter example is a Unicode character. <br>
-&nbsp; <br>
-&nbsp; </p>
-
-<p><i>Word operators</i> </p>
-
-<p>The following operators are provided for compatibility with
-the GNU regular expression library. </p>
-
-<p>&quot;\w&quot; matches any single character that is a member
-of the &quot;word&quot; character class, this is identical to the
-expression &quot;[[:word:]]&quot;. </p>
-
-<p>&quot;\W&quot; matches any single character that is not a
-member of the &quot;word&quot; character class, this is identical
-to the expression &quot;[^[:word:]]&quot;. </p>
-
-<p>&quot;\&lt;&quot; matches the null string at the start of a
-word. </p>
-
-<p>&quot;\&gt;&quot; matches the null string at the end of the
-word. </p>
-
-<p>&quot;\b&quot; matches the null string at either the start or
-the end of a word. </p>
-
-<p>&quot;\B&quot; matches a null string within a word. </p>
-
-<p>The start of the sequence passed to the matching algorithms is
-considered to be a potential start of a word unless the flag
-match_not_bow is set. The end of the sequence passed to the
-matching algorithms is considered to be a potential end of a word
-unless the flag match_not_eow is set. <br>
-&nbsp; <br>
-&nbsp; </p>
-
-<p><i>Buffer operators</i> </p>
-
-<p>The following operators are provide for compatibility with the
-GNU regular expression library, and Perl regular expressions: </p>
-
-<p>&quot;\`&quot; matches the start of a buffer. </p>
-
-<p>&quot;\A&quot; matches the start of the buffer. </p>
-
-<p>&quot;\'&quot; matches the end of a buffer. </p>
-
-<p>&quot;\z&quot; matches the end of a buffer. </p>
-
-<p>&quot;\Z&quot; matches the end of a buffer, or possibly one or
-more new line characters followed by the end of the buffer. </p>
-
-<p>A buffer is considered to consist of the whole sequence passed
-to the matching algorithms, unless the flags match_not_bob or
-match_not_eob are set. <br>
-&nbsp; <br>
-&nbsp; </p>
-
-<p><i>Escape operator</i> </p>
-
-<p>The escape character &quot;\&quot; has several meanings. </p>
-
-<p>Inside a set declaration the escape character is a normal
-character unless the flag regbase::escape_in_lists is set in
-which case whatever follows the escape is a literal character
-regardless of its normal meaning. </p>
-
-<p>The escape operator may introduce an operator for example:
-back references, or a word operator. </p>
-
-<p>The escape operator may make the following character normal,
-for example &quot;\*&quot; represents a literal &quot;*&quot;
-rather than the repeat operator. <br>
-&nbsp; <br>
-&nbsp; </p>
-
-<p><i>Single character escape sequences</i> </p>
-
-<p>The following escape sequences are aliases for single
-characters: <br>
-&nbsp; </p>
-
-<table border="0" cellpadding="7" cellspacing="0" width="100%">
-    <tr>
-        <td width="5%">&nbsp;</td>
-        <td valign="top" width="33%">Escape sequence </td>
-        <td valign="top" width="33%">Character code </td>
-        <td valign="top" width="33%">Meaning </td>
-        <td width="5%">&nbsp;</td>
-    </tr>
-    <tr>
-        <td>&nbsp;</td>
-        <td valign="top" width="33%">\a </td>
-        <td valign="top" width="33%">0x07 </td>
-        <td valign="top" width="33%">Bell character. </td>
-        <td>&nbsp;</td>
-    </tr>
-    <tr>
-        <td>&nbsp;</td>
-        <td valign="top" width="33%">\f </td>
-        <td valign="top" width="33%">0x0C </td>
-        <td valign="top" width="33%">Form feed. </td>
-        <td>&nbsp;</td>
-    </tr>
-    <tr>
-        <td>&nbsp;</td>
-        <td valign="top" width="33%">\n </td>
-        <td valign="top" width="33%">0x0A </td>
-        <td valign="top" width="33%">Newline character. </td>
-        <td>&nbsp;</td>
-    </tr>
-    <tr>
-        <td>&nbsp;</td>
-        <td valign="top" width="33%">\r </td>
-        <td valign="top" width="33%">0x0D </td>
-        <td valign="top" width="33%">Carriage return. </td>
-        <td>&nbsp;</td>
-    </tr>
-    <tr>
-        <td>&nbsp;</td>
-        <td valign="top" width="33%">\t </td>
-        <td valign="top" width="33%">0x09 </td>
-        <td valign="top" width="33%">Tab character. </td>
-        <td>&nbsp;</td>
-    </tr>
-    <tr>
-        <td>&nbsp;</td>
-        <td valign="top" width="33%">\v </td>
-        <td valign="top" width="33%">0x0B </td>
-        <td valign="top" width="33%">Vertical tab. </td>
-        <td>&nbsp;</td>
-    </tr>
-    <tr>
-        <td>&nbsp;</td>
-        <td valign="top" width="33%">\e </td>
-        <td valign="top" width="33%">0x1B </td>
-        <td valign="top" width="33%">ASCII Escape character. </td>
-        <td>&nbsp;</td>
-    </tr>
-    <tr>
-        <td>&nbsp;</td>
-        <td valign="top" width="33%">\0dd </td>
-        <td valign="top" width="33%">0dd </td>
-        <td valign="top" width="33%">An octal character code,
-        where <i>dd</i> is one or more octal digits. </td>
-        <td>&nbsp;</td>
-    </tr>
-    <tr>
-        <td>&nbsp;</td>
-        <td valign="top" width="33%">\xXX </td>
-        <td valign="top" width="33%">0xXX </td>
-        <td valign="top" width="33%">A hexadecimal character
-        code, where XX is one or more hexadecimal digits. </td>
-        <td>&nbsp;</td>
-    </tr>
-    <tr>
-        <td>&nbsp;</td>
-        <td valign="top" width="33%">\x{XX} </td>
-        <td valign="top" width="33%">0xXX </td>
-        <td valign="top" width="33%">A hexadecimal character
-        code, where XX is one or more hexadecimal digits,
-        optionally a unicode character. </td>
-        <td>&nbsp;</td>
-    </tr>
-    <tr>
-        <td>&nbsp;</td>
-        <td valign="top" width="33%">\cZ </td>
-        <td valign="top" width="33%">z-@ </td>
-        <td valign="top" width="33%">An ASCII escape sequence
-        control-Z, where Z is any ASCII character greater than or
-        equal to the character code for '@'. </td>
-        <td>&nbsp;</td>
-    </tr>
-</table>
-
-<p><br>
-&nbsp; </p>
-
-<p><i>Miscellaneous escape sequences:</i> </p>
-
-<p>The following are provided mostly for perl compatibility, but
-note that there are some differences in the meanings of \l \L \u
-and \U: <br>
-&nbsp; </p>
-
-<table border="0" cellpadding="6" cellspacing="0" width="100%">
-    <tr>
-        <td width="5%">&nbsp;</td>
-        <td valign="top" width="45%">\w </td>
-        <td valign="top" width="45%">Equivalent to [[:word:]]. </td>
-        <td width="5%">&nbsp;</td>
-    </tr>
-    <tr>
-        <td width="5%">&nbsp;</td>
-        <td valign="top" width="45%">\W </td>
-        <td valign="top" width="45%">Equivalent to [^[:word:]]. </td>
-        <td width="5%">&nbsp;</td>
-    </tr>
-    <tr>
-        <td width="5%">&nbsp;</td>
-        <td valign="top" width="45%">\s </td>
-        <td valign="top" width="45%">Equivalent to [[:space:]]. </td>
-        <td width="5%">&nbsp;</td>
-    </tr>
-    <tr>
-        <td width="5%">&nbsp;</td>
-        <td valign="top" width="45%">\S </td>
-        <td valign="top" width="45%">Equivalent to [^[:space:]]. </td>
-        <td width="5%">&nbsp;</td>
-    </tr>
-    <tr>
-        <td width="5%">&nbsp;</td>
-        <td valign="top" width="45%">\d </td>
-        <td valign="top" width="45%">Equivalent to [[:digit:]]. </td>
-        <td width="5%">&nbsp;</td>
-    </tr>
-    <tr>
-        <td width="5%">&nbsp;</td>
-        <td valign="top" width="45%">\D </td>
-        <td valign="top" width="45%">Equivalent to [^[:digit:]]. </td>
-        <td width="5%">&nbsp;</td>
-    </tr>
-    <tr>
-        <td width="5%">&nbsp;</td>
-        <td valign="top" width="45%">\l </td>
-        <td valign="top" width="45%">Equivalent to [[:lower:]]. </td>
-        <td width="5%">&nbsp;</td>
-    </tr>
-    <tr>
-        <td width="5%">&nbsp;</td>
-        <td valign="top" width="45%">\L </td>
-        <td valign="top" width="45%">Equivalent to [^[:lower:]]. </td>
-        <td width="5%">&nbsp;</td>
-    </tr>
-    <tr>
-        <td width="5%">&nbsp;</td>
-        <td valign="top" width="45%">\u </td>
-        <td valign="top" width="45%">Equivalent to [[:upper:]]. </td>
-        <td width="5%">&nbsp;</td>
-    </tr>
-    <tr>
-        <td width="5%">&nbsp;</td>
-        <td valign="top" width="45%">\U </td>
-        <td valign="top" width="45%">Equivalent to [^[:upper:]]. </td>
-        <td width="5%">&nbsp;</td>
-    </tr>
-    <tr>
-        <td width="5%">&nbsp;</td>
-        <td valign="top" width="45%">\C </td>
-        <td valign="top" width="45%">Any single character,
-        equivalent to '.'. </td>
-        <td width="5%">&nbsp;</td>
-    </tr>
-    <tr>
-        <td width="5%">&nbsp;</td>
-        <td valign="top" width="45%">\X </td>
-        <td valign="top" width="45%">Match any Unicode combining
-        character sequence, for example &quot;a\x 0301&quot; (a
-        letter a with an acute). </td>
-        <td width="5%">&nbsp;</td>
-    </tr>
-    <tr>
-        <td width="5%">&nbsp;</td>
-        <td valign="top" width="45%">\Q </td>
-        <td valign="top" width="45%">The begin quote operator,
-        everything that follows is treated as a literal character
-        until a \E end quote operator is found. </td>
-        <td width="5%">&nbsp;</td>
-    </tr>
-    <tr>
-        <td width="5%">&nbsp;</td>
-        <td valign="top" width="45%">\E </td>
-        <td valign="top" width="45%">The end quote operator,
-        terminates a sequence begun with \Q. </td>
-        <td width="5%">&nbsp;</td>
-    </tr>
-</table>
-
-<p><br>
-&nbsp; </p>
-
-<p><i>What gets matched?</i> </p>
-
-<p>The regular expression library will match the first possible
-matching string, if more than one string starting at a given
-location can match then it matches the longest possible string,
-unless the flag match_any is set, in which case the first match
-encountered is returned. Use of the match_any option can reduce
-the time taken to find the match - but is only useful if the user
-is less concerned about what matched - for example it would not
-be suitable for search and replace operations. In cases where
-their are multiple possible matches all starting at the same
-location, and all of the same length, then the match chosen is
-the one with the longest first sub-expression, if that is the
-same for two or more matches, then the second sub-expression will
-be examined and so on. <br>
-</p>
-
-<hr>
-
-<p><i>Copyright </i><a href="mailto:John_Maddock@compuserve.com"><i>Dr
-John Maddock</i></a><i> 1998-2000 all rights reserved.</i> </p>
-</body>
-</html>

test/Jamfile

@@ -1,88 +1,63 @@
 subproject libs/regex/test ;
 
-local test-dir = $(BOOST_ROOT)$(SLASH)libs$(SLASH)regex$(SLASH)test$(SLASH)regress$(SLASH) ;
+# bring in the rules for testing
+SEARCH on testing.jam = $(BOOST_BUILD_PATH) ;
+include testing.jam ;
 
-local test-files = $(test-dir)tests.txt
-  # dwa -- not sure if this is generally applicable
-  #  $(test-dir)test1252.txt
+template test 
+  : <lib>../build/boost_regex           # sources
+  : <define>BOOST_REGEX_NO_LIB=1        # requirements
+    <define>BOOST_REGEX_STATIC_LINK=1
+    <threading>multi
   ;
+ 
+template regression
+    : <template>test                    # sources
+      regress/parse.cpp
+      regress/regress.cpp 
+      regress/tests.cpp
+      <lib>../../test/build/boost_prg_exec_monitor
+    ;
 
-unit-test regress : regress/parse.cpp regress/regress.cpp regress/tests.cpp
-   <lib>../build/boost_regex$(SUFLIB) <lib>../../test/build/prg_exec_monitor
-	: 
-		<sysinclude>../../../
-		<define>BOOST_REGEX_NO_LIB=1
-		<define>BOOST_REGEX_STATIC_LINK=1
-	: 
-		debug
-        : 
-                $(test-files)
-	;
-
-unit-test wregress : regress/parse.cpp regress/regress.cpp regress/tests.cpp
-   <lib>../build/boost_regex$(SUFLIB)  <lib>../../test/build/prg_exec_monitor
-	: 
-		<sysinclude>../../../
-		<define>BOOST_REGEX_NO_LIB=1
-		<define>TEST_UNICODE=1
-		<define>BOOST_REGEX_STATIC_LINK=1
-	: 
-		debug
-        : 
-                $(test-files)
-	;
-
-unit-test posix_api_check_c : c_compiler_checks/posix_api_check.c
-   <lib>../build/boost_regex$(SUFLIB)  <lib>../../test/build/prg_exec_monitor
-	: 
-		<sysinclude>../../../
-		<define>BOOST_REGEX_NO_LIB=1
-		<define>BOOST_REGEX_STATIC_LINK=1
-	: 
-		debug
-        : 
-	;
-
-unit-test wide_posix_api_check_c : c_compiler_checks/wide_posix_api_check.c
-   <lib>../build/boost_regex$(SUFLIB)  <lib>../../test/build/prg_exec_monitor
-	: 
-		<sysinclude>../../../
-		<define>BOOST_REGEX_NO_LIB=1
-		<define>BOOST_REGEX_STATIC_LINK=1
-	: 
-		debug
-        : 
-	;
-
-unit-test posix_api_check : c_compiler_checks/posix_api_check.cpp
-   <lib>../build/boost_regex$(SUFLIB)  <lib>../../test/build/prg_exec_monitor
-	: 
-		<sysinclude>../../../
-		<define>BOOST_REGEX_NO_LIB=1
-		<define>BOOST_REGEX_STATIC_LINK=1
-	: 
-		debug
-        : 
-	;
-
-unit-test wide_posix_api_check : c_compiler_checks/wide_posix_api_check.cpp
-   <lib>../build/boost_regex$(SUFLIB)  <lib>../../test/build/prg_exec_monitor
-	: 
-		<sysinclude>../../../
-		<define>BOOST_REGEX_NO_LIB=1
-		<define>BOOST_REGEX_STATIC_LINK=1
-	: 
-		debug
-        : 
-	;
-
-
-
-
+rule regex-test ( name : sources + : requirements * : input-files * )
+{
+    return [ run $(sources) : : $(input-files) : $(requirements) : $(name) ] ;
+}
 
+test-suite regex
+      : 
+      [ regex-test regress
+          : <template>regression     # sources
+          :                          # requirements
+          : regress/tests.txt        # input files
+      ]
 
+      [ regex-test wregress
+          : <template>regression     # sources
+          : <define>TEST_UNICODE=1   # requirements
+          : regress/tests.txt        # input files
+      ]
 
+      [ regex-test posix_api_check_c
+          : <template>test                      # sources
+            c_compiler_checks/posix_api_check.c
+      ]
 
+      [ regex-test wide_posix_api_check_c
+          : <template>test                      # sources
+            c_compiler_checks/wide_posix_api_check.c
+      ]
 
+      [ regex-test posix_api_check
+          : <template>test                      # sources
+            c_compiler_checks/posix_api_check.cpp
+      ]
+
+      [ regex-test wide_posix_api_check
+          : <template>test                      # sources
+            c_compiler_checks/wide_posix_api_check.cpp
+      ]
+
+;
 
 

test/c_compiler_checks/wide_posix_api_check.c

@@ -44,27 +44,40 @@ int main()
 {
    regex_t re;
    int result;
+   wchar_t buf[256];
+   char nbuf[256];
+   int i;
    result = regcomp(&re, expression, REG_AWK);
    if(result > REG_NOERROR)
    {
-      wchar_t buf[256];
       regerror(result, &re, buf, sizeof(buf));
-      wprintf(buf);
+      for(i = 0; i < 256; ++i)
+         nbuf[i] = buf[i];
+      printf(nbuf);
       return result;
    }
-   assert(re.re_nsub == 0);
+   if(re.re_nsub != 0)
+   {
+      regfree(&re);
+      exit(-1);
+   }
    matches[0].rm_so = 0;
    matches[0].rm_eo = wcslen(text);
    result = regexec(&re, text, 1, matches, REG_NOTBOL | REG_NOTEOL | REG_STARTEND);
    if(result > REG_NOERROR)
    {
-      wchar_t buf[256];
       regerror(result, &re, buf, sizeof(buf));
-      wprintf(buf);
+      for(i = 0; i < 256; ++i)
+         nbuf[i] = buf[i];
+      printf(nbuf);
       regfree(&re);
       return result;
    }
-   assert(matches[0].rm_so == matches[0].rm_eo == 1);
+   if((matches[0].rm_so != matches[0].rm_eo) || (matches[0].rm_eo != 1))
+   {
+      regfree(&re);
+      exit(-1);
+   }
    regfree(&re);
    printf("no errors found\n");
    return 0;
@@ -74,3 +87,5 @@ int main()
 #  error "This library has not been configured for wide character support"
 #endif
 
+
+

test/c_compiler_checks/wide_posix_api_check.cpp

@@ -49,10 +49,17 @@ int main()
    {
       wchar_t buf[256];
       regerror(result, &re, buf, sizeof(buf));
-      wprintf(buf);
+      char nbuf[256];
+      for(int i = 0; i < 256; ++i)
+         nbuf[i] = buf[i];
+      printf(nbuf);
       return result;
    }
-   assert(re.re_nsub == 0);
+   if(re.re_nsub != 0)
+   {
+      regfree(&re);
+      exit(-1);
+   }
    matches[0].rm_so = 0;
    matches[0].rm_eo = wcslen(text);
    result = regexec(&re, text, 1, matches, REG_NOTBOL | REG_NOTEOL | REG_STARTEND);
@@ -60,11 +67,18 @@ int main()
    {
       wchar_t buf[256];
       regerror(result, &re, buf, sizeof(buf));
-      wprintf(buf);
+      char nbuf[256];
+      for(int i = 0; i < 256; ++i)
+         nbuf[i] = buf[i];
+      printf(nbuf);
       regfree(&re);
       return result;
    }
-   assert(matches[0].rm_so == matches[0].rm_eo == 1);
+   if((matches[0].rm_so != matches[0].rm_eo) || (matches[0].rm_eo != 1))
+   {
+      regfree(&re);
+      exit(-1);
+   }
    regfree(&re);
    printf("no errors found\n");
    return 0;
@@ -75,3 +89,4 @@ int main()
 #endif
 
 
+