Compare commits

..

207 Commits

Author SHA1 Message Date
2c41e9d1d5 This commit was manufactured by cvs2svn to create branch 'mpl_v2_2'.
[SVN r18675]
2003-06-05 05:15:05 +00:00
2f9da388c1 Added fix for IBM C++
[SVN r18586]
2003-05-28 11:38:00 +00:00
f50f35d1fc Added <ios> include for KCC
[SVN r18536]
2003-05-25 11:16:14 +00:00
df4b8e696f Added patch for gcc 2.95 and get_line under cygwin
[SVN r18535]
2003-05-25 10:58:24 +00:00
3673a0a888 Added support for BOOST_DEDUCED_TYPENAME
[SVN r18534]
2003-05-25 10:54:03 +00:00
a69678c3c6 stripped tabs from files
[SVN r18526]
2003-05-24 11:14:53 +00:00
8fb69853fc Fixed broken links, added copyright declarations, renamed some long file names
[SVN r18525]
2003-05-24 11:13:26 +00:00
70199360d3 Use the recently added BOOST_INTEL macro
[SVN r18511]
2003-05-23 11:53:49 +00:00
9aa18a159d Added como warning suppression.
[SVN r18508]
2003-05-23 11:31:00 +00:00
4122e8f08d Fixed VC warning
[SVN r18506]
2003-05-23 10:57:04 +00:00
922322b644 Updated install docs.
[SVN r18494]
2003-05-22 11:20:26 +00:00
89d445c1b6 Tweaked dll selection code,
Fixed various errors detected by MWCW and Como


[SVN r18493]
2003-05-22 11:19:58 +00:00
31d1dc1182 Removed external templates for unknown compilers.
Fixed std conformance bugs in v4 code (shown up by metrowerks compiler).


[SVN r18467]
2003-05-20 11:28:47 +00:00
8bb6861595 Updated Jamfile to use simplified naming scheme on Unix platforms.
Updated build docs.


[SVN r18466]
2003-05-20 11:27:29 +00:00
11ddff601b Added new makefile
[SVN r18444]
2003-05-19 11:57:32 +00:00
088b492987 changed lib names, minor gcc3.3 warning patches
[SVN r18443]
2003-05-19 11:56:17 +00:00
535e1b05cc Updated library names, minor fixes for gcc2.95
[SVN r18442]
2003-05-19 11:55:23 +00:00
1f15026060 Merged regex-4 branch.
[SVN r18431]
2003-05-17 11:55:51 +00:00
f0f32bdda1 Merged regex-4 branch.
[SVN r18430]
2003-05-17 11:45:48 +00:00
a81a1ea30f restore from disk crash
[SVN r18353]
2003-05-08 02:19:10 +00:00
640f633395 Patched boost-base.jam to allow rules in stage target requirements
Fixed grammar in build_system.htm
Added vc7.1-tools.jam/.html for msvc 7.1
Updated the regex lib Jamfile to build correctly-named libraries


[SVN r18319]
2003-04-27 14:10:52 +00:00
0ed72c37e4 Fixed nasty typo
[SVN r18133]
2003-03-30 10:30:16 +00:00
5cf85df857 Changed name of getlocale proc to avoid HP OS clash.
[SVN r18079]
2003-03-25 11:43:57 +00:00
3819294ac1 Added check to verify that we have something to clean up before calling do_free
[SVN r18075]
2003-03-24 12:36:55 +00:00
ea96eafacc Fixed bug that effect some searches
[SVN r18003]
2003-03-19 12:19:14 +00:00
a31ae14cf8 added extra tests to test new fixes
[SVN r17891]
2003-03-13 13:45:44 +00:00
158c26d85c Misc. new fixes:
Better support for BOOST_NO_WREGEX
Fixed bug in trailing null backrefs
Fixed bug in null repeat code
Fixed bug in negative forward lookahead assert when used as a prefix.


[SVN r17889]
2003-03-13 12:50:54 +00:00
86e5251979 Fix for broken std::setlocale implementations (MacOS X ?)
[SVN r17575]
2003-02-21 12:43:49 +00:00
cebaf09b5d cleanup
[SVN r17531]
2003-02-19 13:56:27 +00:00
d0ba00a2e7 Fixed bug in match_continuous code
[SVN r17276]
2003-02-08 12:30:57 +00:00
75293e9854 Fixed by adding BOOST_REGEX_NO_EXTERNAL_TEMPLATES define and extra error checks.
[SVN r17264]
2003-02-07 12:16:40 +00:00
45e593c4fe Added copyright statement
[SVN r17196]
2003-02-04 12:24:06 +00:00
251099c828 OpenBSD fixes
[SVN r16990]
2003-01-22 12:38:54 +00:00
5705d52e84 Added threading build options.
[SVN r16972]
2003-01-21 12:21:35 +00:00
88a0f9d75a Added multithreaded build options.
[SVN r16971]
2003-01-21 12:20:20 +00:00
fbb087dec9 fix misspelled dir name
[SVN r16948]
2003-01-19 20:21:36 +00:00
c84ebf1c5b Update V2 Jamfile for Boost.
[SVN r16882]
2003-01-13 10:05:01 +00:00
1eec12f177 Modified regression program arguments, so they work when called from some other path.
[SVN r16877]
2003-01-12 12:29:49 +00:00
82ad27c468 Modified Jamfile to use testing.jam
[SVN r16868]
2003-01-11 11:52:19 +00:00
897c33be2a Updated test lib names
[SVN r16714]
2002-12-28 12:51:48 +00:00
2ecd905fb2 add or update See www.boost.org comments
[SVN r16708]
2002-12-27 16:51:53 +00:00
abef9c7249 removed calls to wprintf: Linux doesn't have that API.
removed calls to assert: MWCW can't cope with it when UNICODE is defined.


[SVN r16392]
2002-11-24 11:48:36 +00:00
0e37a76df0 Fix for MWCW which doesn't like incomplete array type.
[SVN r16375]
2002-11-23 11:30:36 +00:00
adc4ee41e3 Fixed using declarations (some types are no longer in the library).
[SVN r16340]
2002-11-20 12:08:43 +00:00
9a4e5d29c1 tentative fix for VC7
[SVN r16252]
2002-11-15 11:50:41 +00:00
ff4890b2e2 Changed detail/ to v3/ in dependency list.
[SVN r16194]
2002-11-11 12:15:04 +00:00
3a5f4775f7 changed boost/regex/detail to boost/regex/v3
[SVN r16185]
2002-11-10 11:37:08 +00:00
5a65397974 Changed boost/regex/detail to boost/regex/v3
[SVN r16184]
2002-11-10 11:35:53 +00:00
e5d9c95456 Fixed header include after recent changes
[SVN r16159]
2002-11-08 11:55:49 +00:00
b6a13dd215 Added check for BOOST_NO_STD_DISTANCE
[SVN r16144]
2002-11-07 12:59:57 +00:00
cf285ed3e5 Changes made in preparation for new regex version.
[SVN r16141]
2002-11-07 12:50:29 +00:00
66ddab7fae Fixes for Intel C++
[SVN r16029]
2002-10-31 12:13:56 +00:00
09bfc7f853 Merged changes from the RC_1_29_0 branch.
[SVN r15959]
2002-10-21 11:03:05 +00:00
13df8a293b Add missing typename
[SVN r15905]
2002-10-11 20:46:12 +00:00
40ab965ee9 Added V2 Jamfile.
[SVN r15778]
2002-10-07 16:45:38 +00:00
0fec291b28 changes to use boost test system
[SVN r15403]
2002-09-17 10:58:25 +00:00
6ee955be5f Tweeked number of states that cause a throw to occur during search.
[SVN r15402]
2002-09-17 10:57:26 +00:00
eeae9a0762 Added try catch block to catch runtime errors thrown from matching algorithms
[SVN r15374]
2002-09-16 11:55:23 +00:00
c7c8400efa VACPP fix
[SVN r15373]
2002-09-16 11:54:41 +00:00
a7f8f56d92 Added throw if the number of searched states grows too large.
[SVN r15372]
2002-09-16 11:54:00 +00:00
66ac67533c VACPP fixes (second try)
[SVN r15371]
2002-09-16 11:53:07 +00:00
d9694bbc1f Fixed regex makefiles to work nice with the new boost.test lib.
Added tentative VACPP fix.


[SVN r15300]
2002-09-13 11:52:11 +00:00
f81bdae7f1 Fixed forward declarations, added tentative IBM C++ fix
[SVN r15298]
2002-09-13 11:41:21 +00:00
aebf86bbe5 removed MSVC warning suppression - it causes the compiler to ICE under some conditions
[SVN r15195]
2002-09-07 10:47:06 +00:00
de9ecb7407 Fixed MSVC warnings
[SVN r15140]
2002-09-03 10:14:30 +00:00
fa43c7ab1d Misc Kylix fixes
[SVN r15086]
2002-08-25 11:57:37 +00:00
5f0f6fa8f1 Updated Jamfile to use new test suite.
Updated docs to reflect recent changes.


[SVN r15081]
2002-08-24 11:57:10 +00:00
81f404ec69 Disabled automatic lib selection on non-windows platforms for Borland
[SVN r15080]
2002-08-24 11:56:11 +00:00
38b55d0db8 Added missing break statements
[SVN r15078]
2002-08-24 11:25:01 +00:00
bed785ad19 Added GCC warning suppression
[SVN r15022]
2002-08-21 11:05:30 +00:00
bb711db956 Added new state information for forthcomming new algorithms
[SVN r14889]
2002-08-15 11:30:08 +00:00
13f9af564d Added some new state information for forthcomming new algorithms.
[SVN r14808]
2002-08-13 11:47:41 +00:00
43cf48f61e Boost.Test V2 fix
[SVN r14787]
2002-08-12 14:23:28 +00:00
2767f7f6ba Tentative MWCW fixes
[SVN r14662]
2002-08-02 11:59:22 +00:00
035e752ed2 Added minor doc fixes
[SVN r14653]
2002-07-31 11:24:41 +00:00
753a3d6584 Removed duplicate declaration.
[SVN r14635]
2002-07-29 11:04:14 +00:00
ab0051399e Added como and metrowerks to list of compilers that can't handle the template specialisations used in instances.hpp.
[SVN r14624]
2002-07-27 11:42:04 +00:00
61ea1b566a Added workaround for gcc2.91 bug
[SVN r14513]
2002-07-18 11:07:46 +00:00
1ad6328d33 Added BOOST_NO_STD_WSTREAMBUF guard
[SVN r14491]
2002-07-17 11:39:15 +00:00
e6a371c6d6 Added MSVC version check.
[SVN r14475]
2002-07-16 11:15:30 +00:00
ee59983ea9 Oops, messed up previous commit.
[SVN r14445]
2002-07-14 10:56:58 +00:00
ad769fcfdb Added needed Como options
[SVN r14432]
2002-07-13 10:58:11 +00:00
2468d450f2 Added -Ve and -Vx options to bcb makefiles.
[SVN r14319]
2002-07-07 10:28:32 +00:00
d47f20f147 Added | to the list of characters that are not literals.
[SVN r14139]
2002-06-13 11:27:56 +00:00
0575e50ddb Changed template function overload to wchar_t overload.
[SVN r14138]
2002-06-13 10:30:46 +00:00
de40dac5d1 Fixed test program after changes to regex_match code.
[SVN r14111]
2002-06-08 10:37:47 +00:00
b2c4abc9cf Fixed partial match bug:
The following program demonstrates what we believe is a bug in regex partial
match algorithm:

    int main()
    {
    //  boost::regex const re("(ab)?c"); // ok
        boost::regex const re("(ab)?"); // fails in the assert below

        boost::cmatch what;
        assert(boost::regex_match( "a", what, re, boost::match_default |
boost::match_partial ));
    }


[SVN r14110]
2002-06-08 10:36:54 +00:00
b856079e74 Added C++ Builder 6 binary compatibilty fixes,
Updated gcc makefiles to build archive index.


[SVN r14088]
2002-06-06 11:33:46 +00:00
293b945785 Added fixes for C++ Builder 6 alignment (binary compatibility) issues.
[SVN r14087]
2002-06-06 11:32:45 +00:00
998f94ffe9 vc7 warning suppression.
[SVN r14064]
2002-05-30 11:07:55 +00:00
53de3c4ae6 Fixed more warnings, rolled back some regex changes that seem to be causing problems on 64-bit platforms.
[SVN r14063]
2002-05-30 11:07:05 +00:00
bbbd65c2e4 Hopefully fixed some minor bugs:
added missing typesnames.
	Changed iterator to Iterator to hopefully keep aCC happy.


[SVN r14020]
2002-05-23 11:43:27 +00:00
129cf61f65 respect <sysinclude>
[SVN r13995]
2002-05-21 16:24:07 +00:00
992eb043af Config updates/patches
[SVN r13973]
2002-05-18 11:33:30 +00:00
084af757b4 Misc. fixes and new config options.
[SVN r13971]
2002-05-18 11:30:49 +00:00
1035f25b65 Disabled template specialisations on AIX with IBM Visual Age
[SVN r13850]
2002-05-14 10:44:21 +00:00
eacf31772b Fixed Mingw32 build
[SVN r13804]
2002-05-10 11:37:32 +00:00
8d8a209d8b Added user-config macro BOOST_DISABLE_WIN32
(also set in the compiler 's strict mode).
Modified Boost source not to use Win32 specific
extentions in the presence of BOOST_DISABLE_WIN32.


[SVN r13771]
2002-05-09 11:40:52 +00:00
6b75e3962d Fixed test programs (disabled separate file template instantiation for single file builds).
[SVN r13661]
2002-05-04 11:00:48 +00:00
1826080071 Fixed erroneous functio signature
[SVN r13660]
2002-05-04 10:55:51 +00:00
2ee6dec715 Fixed broken links.
[SVN r13574]
2002-04-27 11:05:49 +00:00
298651b2f6 Turned off external templates for MWCW
[SVN r13573]
2002-04-27 10:45:12 +00:00
752c43f9d4 Bug fix: changed int to std::ptrdiff_t
[SVN r13572]
2002-04-27 10:38:47 +00:00
976fb02a1b Moved some key template instances into the lib and out of user code.
Updated makefiles:
	renamed lib files with new more systematic naming convention.
	Added bcb6 support.
	Rewritten automatic lib selection.
Updated copyright declarations.


[SVN r13557]
2002-04-24 10:50:23 +00:00
d67a843d5a add newline at end of file
[SVN r13553]
2002-04-23 19:51:36 +00:00
3e3752e992 Added BOOST_NO_WREGEX guard.
[SVN r13357]
2002-04-03 11:04:46 +00:00
7c42b3aca6 Moved is_combining inside BOOST_NO_WREGEX guard.
[SVN r13356]
2002-04-03 11:03:13 +00:00
bb89bbb29a Added regex_fwd.hpp support.
[SVN r13334]
2002-04-01 11:47:30 +00:00
2035a49533 Added support for regex_fwd.hpp
[SVN r13333]
2002-04-01 11:46:04 +00:00
6e82619133 Added needed #ifdef
[SVN r13295]
2002-03-28 12:47:47 +00:00
1d560fae85 Minor doc typo fixes.
Fixed IA64 portability warnings from VC7


[SVN r13225]
2002-03-19 11:31:52 +00:00
b4cf815f7d Fixed IA64 compatibility warnings from VC7, mainly changed unsigned int's to size_t and int's to ptrdiff_t.
[SVN r13223]
2002-03-19 11:29:50 +00:00
1d3653812a Fixed broken link.
[SVN r12993]
2002-03-01 12:26:01 +00:00
9ef4719dff Modified jamfiles to work with new updated build system
[SVN r12952]
2002-02-27 12:37:28 +00:00
e18c474222 Updated regression tests with more non-marking parenthesis examples
[SVN r12912]
2002-02-23 12:58:45 +00:00
7f6be58d92 Fixed Borland C++ config workarounds - so that _RWSTD_COMPILE_INSTANTIATE gets defined before any std lib includes
[SVN r12871]
2002-02-21 11:31:48 +00:00
11accf4a8b Added more error checking for no-eh builds.
[SVN r12870]
2002-02-21 11:30:41 +00:00
b55cce9a42 Fixed behaviour on Embedded VC++
[SVN r12868]
2002-02-20 11:20:17 +00:00
6f9658fa6c Fixed VCL setup to come before lib selection
[SVN r12847]
2002-02-17 12:05:59 +00:00
936e0cfd99 Added note about Koenig Lookup required for examples to compile
[SVN r12802]
2002-02-14 12:56:37 +00:00
290270440e Updated the basic Jamfiles for the new Boost.Build changes.
[SVN r12798]
2002-02-14 04:08:20 +00:00
76c85c7c34 Fixed regex example expression typo.
[SVN r12792]
2002-02-13 12:30:22 +00:00
44d33b20d5 Can't declare a variable in a for-loop with the same name as a variable declared in the for loop initialization
[SVN r12775]
2002-02-09 16:37:56 +00:00
98377b57aa Strange workaround for Comeau 4.2.45.2 so that it does get into an
instantiation loop


[SVN r12773]
2002-02-09 15:49:04 +00:00
43df21bca1 Fixed incorrect iterator use - assumed random access iterator in one place rather than bidirectional.
[SVN r12768]
2002-02-09 12:07:53 +00:00
c8e9df8fa2 Added support for compilers with no exception handling support.
[SVN r12758]
2002-02-08 12:44:43 +00:00
a5d1526fbb Added docs for forward lookahead asserts.
[SVN r12757]
2002-02-08 12:43:59 +00:00
f79497c625 Handle standard libraries that do not support std::iterator
[SVN r12686]
2002-02-04 12:54:17 +00:00
a108657449 Make string_out_iterator a full-fledged output iterator
[SVN r12671]
2002-02-03 17:30:13 +00:00
9225fa8531 Removed unnecessary template parameter from ostream_iterator so that it works with gcc2.9x now.
[SVN r12666]
2002-02-03 11:44:37 +00:00
07c20c1926 Modified code that determines how long to loop for, with upper limit of 1s.
[SVN r12665]
2002-02-03 11:43:23 +00:00
d227059666 New smart pointer documentation. Related clean-up of the smart pointer
library. Changing includes to include the new individual smart pointer
headers. Replacing old smart pointer library with an include of the new
smart pointer headers. Simplify ifdefs that involve the member templates
macros now that BOOST_MSVC6_MEMBER_TEMPLATES is also guaranteed to bet
set for platforms that have full member templates.


[SVN r12647]
2002-02-02 18:36:12 +00:00
f5082341c0 changed all pointer casts to explicit static_cast or reinterpret_cast.
Added more tests for forward lookahead asserts.


[SVN r12575]
2002-01-30 12:17:51 +00:00
5613d77433 Changed all pointer casts to either static_cast or reinterpret_cast as appropriate.
[SVN r12574]
2002-01-30 12:16:28 +00:00
6463dcfb07 regex_timer.cpp:
- Head off some infinite looping on some platforms


[SVN r12550]
2002-01-29 13:38:30 +00:00
c07c4e0a11 Added support for forward lookahead asserts.
[SVN r12455]
2002-01-23 12:42:31 +00:00
e993619390 Stripped tabs from source
[SVN r12351]
2002-01-19 12:38:14 +00:00
e22aaa9d20 Fixed copy self assignment bug
[SVN r12248]
2002-01-08 13:00:08 +00:00
52dbd281ca Added checks to message loading code.
Added extra members to RegEx class.
Updated docs accordingly.


[SVN r12244]
2002-01-07 13:03:50 +00:00
e4138b5bdc Added members RegEx::Match and RegEx::npos.
[SVN r12243]
2002-01-07 13:02:37 +00:00
534f6273c0 No longer throws on copy-construct
asserts when applying fixups (invariant checks) added


[SVN r12242]
2002-01-07 13:01:31 +00:00
b2dd7877da Updated regex examples and Jamfiles so that they are run as tests.
[SVN r12149]
2001-12-26 11:21:24 +00:00
0cda8c8a2e Initial checkin
[SVN r12122]
2001-12-19 11:57:20 +00:00
04282b5d0a Updated version numbers in docs.
[SVN r12081]
2001-12-17 12:44:26 +00:00
554832217c Updated regex examples and Jamfiles so that most now run as tests.
[SVN r12067]
2001-12-16 11:33:27 +00:00
63130c1ef5 Updated Jamfiles and tests so that they actually work now!
[SVN r11985]
2001-12-09 12:50:46 +00:00
edbc68df6c Updated to reflect changes in STLport-4.5
[SVN r11970]
2001-12-07 12:14:56 +00:00
372a07902e Made string_compare functions inline (they should have been all along).
[SVN r11952]
2001-12-06 12:39:31 +00:00
4ae95dae74 removed unneeded #if block
[SVN r11906]
2001-12-04 12:23:28 +00:00
277ca851c8 Metrowerks needs BOOST_NO_STD_LOCALE in config to be able to compile regex
regex test Jamfile updates so that some tests will actually run
warning suppression for condition.cpp

unit-test rule now accepts input files
updated metrowerks and borland to properly set up path for running tests

----------------------------------------------------------------------
Modified Files:
	boost/config/compiler/metrowerks.hpp
	libs/python/src/gen_function.py libs/regex/test/Jamfile
 Tag: thread-initial
	libs/thread/src/condition.cpp
 No tag
	tools/build/boost-base.jam tools/build/borland-tools.jam
	tools/build/metrowerks-tools.jam
----------------------------------------------------------------------


[SVN r11853]
2001-12-02 17:43:45 +00:00
f0d62fb2c0 Updated changes log
[SVN r11830]
2001-11-30 12:00:31 +00:00
7104418bd5 * Changed BOOST_RE_THREADS to BOOST_HAS_THREADS,
* Updated allocator code to use SGI node based allocator when available.


[SVN r11829]
2001-11-30 11:58:04 +00:00
0bd54d3821 Added optional code to time how long the test takes.
[SVN r11828]
2001-11-30 11:56:35 +00:00
c167b1f183 changed BOOST_RE_THREADS to BOOST_HAS_THREADS
[SVN r11827]
2001-11-30 11:56:02 +00:00
52920ff98f Added \ as a non-literal character (oversight).
[SVN r11717]
2001-11-16 12:25:17 +00:00
72c3b4ed13 Fix for broken split (doesn't spit out all sub expressions).
[SVN r11716]
2001-11-16 12:24:40 +00:00
6cc5cf41d5 Trivial fix for signed/unsigned comparison
[SVN r11715]
2001-11-16 12:24:01 +00:00
a7984bb149 Updated Jamfiles with forced dynamic linking removed.
[SVN r11647]
2001-11-10 12:12:38 +00:00
876ff39307 remove redundant <runtime-link>dynamic from default-BUILD section
[SVN r11644]
2001-11-09 15:30:45 +00:00
79f80ad09d Updated list of helpers
[SVN r11449]
2001-10-26 11:58:59 +00:00
19d8e96cf5 Added workaround for Rogue Wave lib bug.
[SVN r11391]
2001-10-16 11:36:47 +00:00
e047b2b509 Updated examples with better comment on expressions. Updated test program to test for apparent Rogur Wave bug (and it's workaround).
[SVN r11390]
2001-10-16 11:36:00 +00:00
28968bd2b6 renamed "free" member functions to avoid conflicts with system macros.
[SVN r11384]
2001-10-13 10:26:34 +00:00
c4b295684b Added docs for smatch and wsmatch typedefs, added warnings about using temporaries with regex_search/regex_match.
[SVN r11383]
2001-10-13 10:24:55 +00:00
33b6eb0637 Renamed member functions "free" to prevent conflict with system macro.
[SVN r11380]
2001-10-13 10:19:01 +00:00
de9ad8df74 Fix spelling error: "occurances" -> "occurrences".
[SVN r11376]
2001-10-11 17:26:04 +00:00
a042a0b6de Removed spurious MSVC pragma
[SVN r11369]
2001-10-09 11:25:43 +00:00
f16f300347 Fixed inclusion of windows.h
[SVN r11356]
2001-10-08 11:32:22 +00:00
a543dce5e3 regex, threads, and python will all build from the top level. If you build the 'test' target from the top level, it will run all regressions.
Jamfile:
  subincludes for thread, python libs, and status for regression tests

Jamrules:
  Use the new path-global rule to establish BOOST_ROOT correctly for all subprojects

libs/regex/build/Jamfile
  Take advantage of correct BOOST_ROOT setting

libs/python/build/Jamfile
  Search for python executable; don't try to build anything if it can't be found.
  don't build tests by default
  improved comments, organization, and naming.

status/Jamfile
  Fixed references to config test files
  Failed tests now leave their stdout results in <testname>.error instead of removing it
  No test targets are dependencies of 'all' anymore
  Added comments
  Reorganized

tools/build/Jambase
  Meant to check this in long ago.

tools/build/allyourbase.jam
  Fixed SHELL_EXPORT setting, added SHELL_SET
  removed 'test' from the dependencies of 'all'; tests no longer run by default.
  Fixed the direction of slashes for Windows when ALL_LOCATE_TARGET is used.
  Added path-global rule for declaring path variables which may be relative
  rule in-invocation-subdir returns true if the current subproject is the one
     from which Jam was invoked
  rule protect-subdir is now used to protect subproject variables
  rule tokens-to-simple-path converts path tokens to a simplified path.

tools/build/boost-base.jam
  Fixed bugs

tools/build/jam_src/makedebugjam.bat
  Fixed a bug which prevented a final debug build

tools/build/jam_src/search.c
  Fixed a bug of mine which caused LOCATE to be ignored (!).


[SVN r11348]
2001-10-06 18:19:15 +00:00
fe45d5bf4a Tweeked regex version number to reference <boost/version.hpp>
[SVN r11309]
2001-09-30 10:30:14 +00:00
4dd87c299f Fixed iterator definition
[SVN r11299]
2001-09-28 11:33:25 +00:00
3d3f591516 Fixed partial ordering macro names
[SVN r11298]
2001-09-28 11:08:33 +00:00
5b5d4c3145 Fixed typo - \f is \x0C not \x08
[SVN r11297]
2001-09-28 11:07:41 +00:00
1c45c7a48d updated makefiles to generate error if MSVCDIR not set
[SVN r11296]
2001-09-28 11:06:57 +00:00
4922ae784f Fixed messed up c_regex_traits from previous commit, fixed Koenig lookup bug caused by presence of boost::re_detail::destroy
[SVN r11249]
2001-09-25 11:48:21 +00:00
007c0da3b2 Add a workaround for platforms where <ctype.h> has macros only.
[SVN r11235]
2001-09-24 19:34:15 +00:00
3fb0375da4 Another attempt to fix the WinXP character class problems
[SVN r11216]
2001-09-23 12:02:28 +00:00
0cef054b31 change missed occasion of BOOST_RE_NO_SWPRINTF -> BOOST_NO_SWPRINTF
[SVN r11205]
2001-09-22 15:24:10 +00:00
7218f9847a fix typo: omission of parameter names
[SVN r11203]
2001-09-22 14:53:00 +00:00
2bc1f9c998 More fixes resulting from the new config
[SVN r11182]
2001-09-21 11:35:54 +00:00
9edaddab6f Updated docs to match new config
[SVN r11181]
2001-09-21 10:35:16 +00:00
1647dd908e Added missing typename qualifier
[SVN r11165]
2001-09-20 11:45:48 +00:00
187208adf5 First round of config fixes
[SVN r11146]
2001-09-19 11:48:51 +00:00
30e9920147 remove stray \r
[SVN r11143]
2001-09-18 21:53:41 +00:00
1d473147fd commit of split-config, including any changes required to existing libraries (mainly regex).
[SVN r11138]
2001-09-18 11:13:39 +00:00
1be8e9241b Previous update broke non-win32 support, now fixed.
[SVN r11094]
2001-09-11 11:06:44 +00:00
e60414a5e7 Added regression tests
[SVN r11072]
2001-09-08 12:04:25 +00:00
7bd8e2a14d Fixed to work with _UNICODE on Win32
[SVN r11071]
2001-09-08 12:03:55 +00:00
b2396011f9 Fixed path to work from root directory
[SVN r11070]
2001-09-08 12:02:47 +00:00
b9628e449d Fixed do that code compiles on Win32 with _UNICODE defined
[SVN r11069]
2001-09-08 12:01:30 +00:00
139a2f60fb Updated build system (more or less works now)
[SVN r10890]
2001-08-18 11:50:48 +00:00
a4912a834e Fixed initialisation order warnings (gcc)
[SVN r10887]
2001-08-18 10:22:53 +00:00
014b66b2f4 Removed non-functioning msvc link command from Jamfile, added user32.lib forced link to w32_regex_traits.cpp
[SVN r10886]
2001-08-18 10:22:10 +00:00
b2ea26705d Added (as yet non-functional msvc library support)
[SVN r10876]
2001-08-16 11:43:22 +00:00
432f59cde7 Updated Jamfile (it works now!)
[SVN r10850]
2001-08-13 11:34:37 +00:00
846da064e0 Added Jamfile
[SVN r10843]
2001-08-12 11:55:51 +00:00
88a6779e8b Fixed WinXP problems
[SVN r10842]
2001-08-11 11:50:34 +00:00
5749937f26 Fixed some WinXP problems
[SVN r10841]
2001-08-11 11:49:19 +00:00
e1492c79ce updated jamfile, fixed Windows XP problems
[SVN r10840]
2001-08-11 11:47:12 +00:00
a06c964cab Spell things consistently. Add some bits of Mac stuff to the tests.
Use std::size_t where needed.


[SVN r10800]
2001-08-07 17:22:02 +00:00
77f76889f8 Minor purify error fixes
[SVN r10713]
2001-07-28 11:23:09 +00:00
50c4d1e6ca Fixed some purify errors (unitialised reads)
[SVN r10712]
2001-07-28 11:22:28 +00:00
7079ba0424 tweeked docs - added credits + iterator categories.
[SVN r10701]
2001-07-25 10:20:47 +00:00
e7b8b5712d Fixed nasty bug, where some invalid expressions caused access violations.
[SVN r10688]
2001-07-22 10:26:54 +00:00
f5f309be54 Initial checkin. Needs tweaks for various compilers.
[SVN r10683]
2001-07-21 13:06:09 +00:00
890dc95e0d fixed relative link
[SVN r10610]
2001-07-14 10:54:55 +00:00
517d3e9256 Change absolute URL's to relative
[SVN r10594]
2001-07-12 15:31:15 +00:00
124 changed files with 61 additions and 39866 deletions

File diff suppressed because it is too large Load Diff

View File

@ -1,355 +0,0 @@
#
# auto generated makefile for C++ Builder
#
# usage:
# make
# brings libraries up to date
# make install
# brings libraries up to date and copies binaries to your C++ Builder /lib and /bin directories (recomended)
# make clean
# removes all temporary files.
#
# Add additional compiler options here:
#
CXXFLAGS=
#
# Add additional include directories here:
#
INCLUDES=
#
# add additional linker flags here:
#
XLFLAGS=
#
# add additional libraries to link to here:
#
LIBS=
#
# add additional static-library creation flags here:
#
XSFLAGS=
!ifndef BCROOT
BCROOT=$(MAKEDIR)\..
!endif
ALL_HEADER=../../../boost/cregex.hpp ../../../boost/regex/pattern_except.hpp ../../../boost/regex.hpp ../../../boost/regex/regex_traits.hpp ../../../boost/regex/detail/fileiter.hpp ../../../boost/regex/detail/regex_compile.hpp ../../../boost/regex/detail/regex_config.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_options.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 : bcb5 bcb5\bcb5re300 bcb5\bcb5re300.lib bcb5\bcb5re300m bcb5\bcb5re300m.lib bcb5\bcb5re300lm bcb5\bcb5re300lm.lib bcb5\bcb5re300l bcb5\bcb5re300l.lib
clean : bcb5re300_clean bcb5re300m_clean bcb5re300lm_clean bcb5re300l_clean
install : all
copy bcb5\bcb5re300.lib $(BCROOT)\lib
copy bcb5\bcb5re300m.lib $(BCROOT)\lib
copy bcb5\bcb5re300lm.lib $(BCROOT)\lib
copy bcb5\bcb5re300lm.dll $(BCROOT)\bin
copy bcb5\bcb5re300l.lib $(BCROOT)\lib
copy bcb5\bcb5re300l.dll $(BCROOT)\bin
bcb5 :
-mkdir bcb5
########################################################
#
# section for bcb5re300.lib
#
########################################################
bcb5\bcb5re300\c_regex_traits.obj: ../src/c_regex_traits.cpp $(ALL_HEADER)
bcc32 @&&|
-c $(INCLUDES) -tWM- -D_NO_VCL -O2 -w-inl -w-aus -w-rch -w-8012 -w-8037 -w-8057 -DSTRICT; -I$(BCROOT)\include;../../../ $(CXXFLAGS) -obcb5\bcb5re300\c_regex_traits.obj ../src/c_regex_traits.cpp
|
bcb5\bcb5re300\c_regex_traits_common.obj: ../src/c_regex_traits_common.cpp $(ALL_HEADER)
bcc32 @&&|
-c $(INCLUDES) -tWM- -D_NO_VCL -O2 -w-inl -w-aus -w-rch -w-8012 -w-8037 -w-8057 -DSTRICT; -I$(BCROOT)\include;../../../ $(CXXFLAGS) -obcb5\bcb5re300\c_regex_traits_common.obj ../src/c_regex_traits_common.cpp
|
bcb5\bcb5re300\cpp_regex_traits.obj: ../src/cpp_regex_traits.cpp $(ALL_HEADER)
bcc32 @&&|
-c $(INCLUDES) -tWM- -D_NO_VCL -O2 -w-inl -w-aus -w-rch -w-8012 -w-8037 -w-8057 -DSTRICT; -I$(BCROOT)\include;../../../ $(CXXFLAGS) -obcb5\bcb5re300\cpp_regex_traits.obj ../src/cpp_regex_traits.cpp
|
bcb5\bcb5re300\cregex.obj: ../src/cregex.cpp $(ALL_HEADER)
bcc32 @&&|
-c $(INCLUDES) -tWM- -D_NO_VCL -O2 -w-inl -w-aus -w-rch -w-8012 -w-8037 -w-8057 -DSTRICT; -I$(BCROOT)\include;../../../ $(CXXFLAGS) -obcb5\bcb5re300\cregex.obj ../src/cregex.cpp
|
bcb5\bcb5re300\fileiter.obj: ../src/fileiter.cpp $(ALL_HEADER)
bcc32 @&&|
-c $(INCLUDES) -tWM- -D_NO_VCL -O2 -w-inl -w-aus -w-rch -w-8012 -w-8037 -w-8057 -DSTRICT; -I$(BCROOT)\include;../../../ $(CXXFLAGS) -obcb5\bcb5re300\fileiter.obj ../src/fileiter.cpp
|
bcb5\bcb5re300\posix_api.obj: ../src/posix_api.cpp $(ALL_HEADER)
bcc32 @&&|
-c $(INCLUDES) -tWM- -D_NO_VCL -O2 -w-inl -w-aus -w-rch -w-8012 -w-8037 -w-8057 -DSTRICT; -I$(BCROOT)\include;../../../ $(CXXFLAGS) -obcb5\bcb5re300\posix_api.obj ../src/posix_api.cpp
|
bcb5\bcb5re300\regex.obj: ../src/regex.cpp $(ALL_HEADER)
bcc32 @&&|
-c $(INCLUDES) -tWM- -D_NO_VCL -O2 -w-inl -w-aus -w-rch -w-8012 -w-8037 -w-8057 -DSTRICT; -I$(BCROOT)\include;../../../ $(CXXFLAGS) -obcb5\bcb5re300\regex.obj ../src/regex.cpp
|
bcb5\bcb5re300\regex_debug.obj: ../src/regex_debug.cpp $(ALL_HEADER)
bcc32 @&&|
-c $(INCLUDES) -tWM- -D_NO_VCL -O2 -w-inl -w-aus -w-rch -w-8012 -w-8037 -w-8057 -DSTRICT; -I$(BCROOT)\include;../../../ $(CXXFLAGS) -obcb5\bcb5re300\regex_debug.obj ../src/regex_debug.cpp
|
bcb5\bcb5re300\regex_synch.obj: ../src/regex_synch.cpp $(ALL_HEADER)
bcc32 @&&|
-c $(INCLUDES) -tWM- -D_NO_VCL -O2 -w-inl -w-aus -w-rch -w-8012 -w-8037 -w-8057 -DSTRICT; -I$(BCROOT)\include;../../../ $(CXXFLAGS) -obcb5\bcb5re300\regex_synch.obj ../src/regex_synch.cpp
|
bcb5\bcb5re300\w32_regex_traits.obj: ../src/w32_regex_traits.cpp $(ALL_HEADER)
bcc32 @&&|
-c $(INCLUDES) -tWM- -D_NO_VCL -O2 -w-inl -w-aus -w-rch -w-8012 -w-8037 -w-8057 -DSTRICT; -I$(BCROOT)\include;../../../ $(CXXFLAGS) -obcb5\bcb5re300\w32_regex_traits.obj ../src/w32_regex_traits.cpp
|
bcb5\bcb5re300\wide_posix_api.obj: ../src/wide_posix_api.cpp $(ALL_HEADER)
bcc32 @&&|
-c $(INCLUDES) -tWM- -D_NO_VCL -O2 -w-inl -w-aus -w-rch -w-8012 -w-8037 -w-8057 -DSTRICT; -I$(BCROOT)\include;../../../ $(CXXFLAGS) -obcb5\bcb5re300\wide_posix_api.obj ../src/wide_posix_api.cpp
|
bcb5\bcb5re300 :
-mkdir bcb5\bcb5re300
bcb5re300_clean :
del bcb5\bcb5re300\*.obj
del bcb5\bcb5re300\*.il?
del bcb5\bcb5re300\*.csm
del bcb5\bcb5re300\*.tds
bcb5\bcb5re300.lib : bcb5\bcb5re300\c_regex_traits.obj bcb5\bcb5re300\c_regex_traits_common.obj bcb5\bcb5re300\cpp_regex_traits.obj bcb5\bcb5re300\cregex.obj bcb5\bcb5re300\fileiter.obj bcb5\bcb5re300\posix_api.obj bcb5\bcb5re300\regex.obj bcb5\bcb5re300\regex_debug.obj bcb5\bcb5re300\regex_synch.obj bcb5\bcb5re300\w32_regex_traits.obj bcb5\bcb5re300\wide_posix_api.obj
tlib @&&|
/P32 /C /u /a $(XSFLAGS) bcb5\bcb5re300.lib +bcb5\bcb5re300\c_regex_traits.obj +bcb5\bcb5re300\c_regex_traits_common.obj +bcb5\bcb5re300\cpp_regex_traits.obj +bcb5\bcb5re300\cregex.obj +bcb5\bcb5re300\fileiter.obj +bcb5\bcb5re300\posix_api.obj +bcb5\bcb5re300\regex.obj +bcb5\bcb5re300\regex_debug.obj +bcb5\bcb5re300\regex_synch.obj +bcb5\bcb5re300\w32_regex_traits.obj +bcb5\bcb5re300\wide_posix_api.obj
|
########################################################
#
# section for bcb5re300m.lib
#
########################################################
bcb5\bcb5re300m\c_regex_traits.obj: ../src/c_regex_traits.cpp $(ALL_HEADER)
bcc32 @&&|
-c $(INCLUDES) -tWM -D_NO_VCL -O2 -w-inl -w-aus -w-rch -w-8012 -w-8057 -w-8037 -DSTRICT; -I$(BCROOT)\include;../../../ $(CXXFLAGS) -obcb5\bcb5re300m\c_regex_traits.obj ../src/c_regex_traits.cpp
|
bcb5\bcb5re300m\c_regex_traits_common.obj: ../src/c_regex_traits_common.cpp $(ALL_HEADER)
bcc32 @&&|
-c $(INCLUDES) -tWM -D_NO_VCL -O2 -w-inl -w-aus -w-rch -w-8012 -w-8057 -w-8037 -DSTRICT; -I$(BCROOT)\include;../../../ $(CXXFLAGS) -obcb5\bcb5re300m\c_regex_traits_common.obj ../src/c_regex_traits_common.cpp
|
bcb5\bcb5re300m\cpp_regex_traits.obj: ../src/cpp_regex_traits.cpp $(ALL_HEADER)
bcc32 @&&|
-c $(INCLUDES) -tWM -D_NO_VCL -O2 -w-inl -w-aus -w-rch -w-8012 -w-8057 -w-8037 -DSTRICT; -I$(BCROOT)\include;../../../ $(CXXFLAGS) -obcb5\bcb5re300m\cpp_regex_traits.obj ../src/cpp_regex_traits.cpp
|
bcb5\bcb5re300m\cregex.obj: ../src/cregex.cpp $(ALL_HEADER)
bcc32 @&&|
-c $(INCLUDES) -tWM -D_NO_VCL -O2 -w-inl -w-aus -w-rch -w-8012 -w-8057 -w-8037 -DSTRICT; -I$(BCROOT)\include;../../../ $(CXXFLAGS) -obcb5\bcb5re300m\cregex.obj ../src/cregex.cpp
|
bcb5\bcb5re300m\fileiter.obj: ../src/fileiter.cpp $(ALL_HEADER)
bcc32 @&&|
-c $(INCLUDES) -tWM -D_NO_VCL -O2 -w-inl -w-aus -w-rch -w-8012 -w-8057 -w-8037 -DSTRICT; -I$(BCROOT)\include;../../../ $(CXXFLAGS) -obcb5\bcb5re300m\fileiter.obj ../src/fileiter.cpp
|
bcb5\bcb5re300m\posix_api.obj: ../src/posix_api.cpp $(ALL_HEADER)
bcc32 @&&|
-c $(INCLUDES) -tWM -D_NO_VCL -O2 -w-inl -w-aus -w-rch -w-8012 -w-8057 -w-8037 -DSTRICT; -I$(BCROOT)\include;../../../ $(CXXFLAGS) -obcb5\bcb5re300m\posix_api.obj ../src/posix_api.cpp
|
bcb5\bcb5re300m\regex.obj: ../src/regex.cpp $(ALL_HEADER)
bcc32 @&&|
-c $(INCLUDES) -tWM -D_NO_VCL -O2 -w-inl -w-aus -w-rch -w-8012 -w-8057 -w-8037 -DSTRICT; -I$(BCROOT)\include;../../../ $(CXXFLAGS) -obcb5\bcb5re300m\regex.obj ../src/regex.cpp
|
bcb5\bcb5re300m\regex_debug.obj: ../src/regex_debug.cpp $(ALL_HEADER)
bcc32 @&&|
-c $(INCLUDES) -tWM -D_NO_VCL -O2 -w-inl -w-aus -w-rch -w-8012 -w-8057 -w-8037 -DSTRICT; -I$(BCROOT)\include;../../../ $(CXXFLAGS) -obcb5\bcb5re300m\regex_debug.obj ../src/regex_debug.cpp
|
bcb5\bcb5re300m\regex_synch.obj: ../src/regex_synch.cpp $(ALL_HEADER)
bcc32 @&&|
-c $(INCLUDES) -tWM -D_NO_VCL -O2 -w-inl -w-aus -w-rch -w-8012 -w-8057 -w-8037 -DSTRICT; -I$(BCROOT)\include;../../../ $(CXXFLAGS) -obcb5\bcb5re300m\regex_synch.obj ../src/regex_synch.cpp
|
bcb5\bcb5re300m\w32_regex_traits.obj: ../src/w32_regex_traits.cpp $(ALL_HEADER)
bcc32 @&&|
-c $(INCLUDES) -tWM -D_NO_VCL -O2 -w-inl -w-aus -w-rch -w-8012 -w-8057 -w-8037 -DSTRICT; -I$(BCROOT)\include;../../../ $(CXXFLAGS) -obcb5\bcb5re300m\w32_regex_traits.obj ../src/w32_regex_traits.cpp
|
bcb5\bcb5re300m\wide_posix_api.obj: ../src/wide_posix_api.cpp $(ALL_HEADER)
bcc32 @&&|
-c $(INCLUDES) -tWM -D_NO_VCL -O2 -w-inl -w-aus -w-rch -w-8012 -w-8057 -w-8037 -DSTRICT; -I$(BCROOT)\include;../../../ $(CXXFLAGS) -obcb5\bcb5re300m\wide_posix_api.obj ../src/wide_posix_api.cpp
|
bcb5\bcb5re300m :
-mkdir bcb5\bcb5re300m
bcb5re300m_clean :
del bcb5\bcb5re300m\*.obj
del bcb5\bcb5re300m\*.il?
del bcb5\bcb5re300m\*.csm
del bcb5\bcb5re300m\*.tds
bcb5\bcb5re300m.lib : bcb5\bcb5re300m\c_regex_traits.obj bcb5\bcb5re300m\c_regex_traits_common.obj bcb5\bcb5re300m\cpp_regex_traits.obj bcb5\bcb5re300m\cregex.obj bcb5\bcb5re300m\fileiter.obj bcb5\bcb5re300m\posix_api.obj bcb5\bcb5re300m\regex.obj bcb5\bcb5re300m\regex_debug.obj bcb5\bcb5re300m\regex_synch.obj bcb5\bcb5re300m\w32_regex_traits.obj bcb5\bcb5re300m\wide_posix_api.obj
tlib @&&|
/P32 /C /u /a $(XSFLAGS) bcb5\bcb5re300m.lib +bcb5\bcb5re300m\c_regex_traits.obj +bcb5\bcb5re300m\c_regex_traits_common.obj +bcb5\bcb5re300m\cpp_regex_traits.obj +bcb5\bcb5re300m\cregex.obj +bcb5\bcb5re300m\fileiter.obj +bcb5\bcb5re300m\posix_api.obj +bcb5\bcb5re300m\regex.obj +bcb5\bcb5re300m\regex_debug.obj +bcb5\bcb5re300m\regex_synch.obj +bcb5\bcb5re300m\w32_regex_traits.obj +bcb5\bcb5re300m\wide_posix_api.obj
|
########################################################
#
# section for bcb5re300lm.lib
#
########################################################
bcb5\bcb5re300lm\c_regex_traits.obj: ../src/c_regex_traits.cpp $(ALL_HEADER)
bcc32 @&&|
-c $(INCLUDES) -DBOOST_RE_BUILD_DLL -tWD -tWM -tWR -D_NO_VCL -D_RTLDLL -O2 -w-inl -w-aus -w-rch -w-8012 -w-8057 -w-8037 -DSTRICT; -I$(BCROOT)\include;../../../ -L$(BCROOT)\lib;$(BCROOT)\lib\release; $(CXXFLAGS) -obcb5\bcb5re300lm\c_regex_traits.obj ../src/c_regex_traits.cpp
|
bcb5\bcb5re300lm\c_regex_traits_common.obj: ../src/c_regex_traits_common.cpp $(ALL_HEADER)
bcc32 @&&|
-c $(INCLUDES) -DBOOST_RE_BUILD_DLL -tWD -tWM -tWR -D_NO_VCL -D_RTLDLL -O2 -w-inl -w-aus -w-rch -w-8012 -w-8057 -w-8037 -DSTRICT; -I$(BCROOT)\include;../../../ -L$(BCROOT)\lib;$(BCROOT)\lib\release; $(CXXFLAGS) -obcb5\bcb5re300lm\c_regex_traits_common.obj ../src/c_regex_traits_common.cpp
|
bcb5\bcb5re300lm\cpp_regex_traits.obj: ../src/cpp_regex_traits.cpp $(ALL_HEADER)
bcc32 @&&|
-c $(INCLUDES) -DBOOST_RE_BUILD_DLL -tWD -tWM -tWR -D_NO_VCL -D_RTLDLL -O2 -w-inl -w-aus -w-rch -w-8012 -w-8057 -w-8037 -DSTRICT; -I$(BCROOT)\include;../../../ -L$(BCROOT)\lib;$(BCROOT)\lib\release; $(CXXFLAGS) -obcb5\bcb5re300lm\cpp_regex_traits.obj ../src/cpp_regex_traits.cpp
|
bcb5\bcb5re300lm\cregex.obj: ../src/cregex.cpp $(ALL_HEADER)
bcc32 @&&|
-c $(INCLUDES) -DBOOST_RE_BUILD_DLL -tWD -tWM -tWR -D_NO_VCL -D_RTLDLL -O2 -w-inl -w-aus -w-rch -w-8012 -w-8057 -w-8037 -DSTRICT; -I$(BCROOT)\include;../../../ -L$(BCROOT)\lib;$(BCROOT)\lib\release; $(CXXFLAGS) -obcb5\bcb5re300lm\cregex.obj ../src/cregex.cpp
|
bcb5\bcb5re300lm\fileiter.obj: ../src/fileiter.cpp $(ALL_HEADER)
bcc32 @&&|
-c $(INCLUDES) -DBOOST_RE_BUILD_DLL -tWD -tWM -tWR -D_NO_VCL -D_RTLDLL -O2 -w-inl -w-aus -w-rch -w-8012 -w-8057 -w-8037 -DSTRICT; -I$(BCROOT)\include;../../../ -L$(BCROOT)\lib;$(BCROOT)\lib\release; $(CXXFLAGS) -obcb5\bcb5re300lm\fileiter.obj ../src/fileiter.cpp
|
bcb5\bcb5re300lm\posix_api.obj: ../src/posix_api.cpp $(ALL_HEADER)
bcc32 @&&|
-c $(INCLUDES) -DBOOST_RE_BUILD_DLL -tWD -tWM -tWR -D_NO_VCL -D_RTLDLL -O2 -w-inl -w-aus -w-rch -w-8012 -w-8057 -w-8037 -DSTRICT; -I$(BCROOT)\include;../../../ -L$(BCROOT)\lib;$(BCROOT)\lib\release; $(CXXFLAGS) -obcb5\bcb5re300lm\posix_api.obj ../src/posix_api.cpp
|
bcb5\bcb5re300lm\regex.obj: ../src/regex.cpp $(ALL_HEADER)
bcc32 @&&|
-c $(INCLUDES) -DBOOST_RE_BUILD_DLL -tWD -tWM -tWR -D_NO_VCL -D_RTLDLL -O2 -w-inl -w-aus -w-rch -w-8012 -w-8057 -w-8037 -DSTRICT; -I$(BCROOT)\include;../../../ -L$(BCROOT)\lib;$(BCROOT)\lib\release; $(CXXFLAGS) -obcb5\bcb5re300lm\regex.obj ../src/regex.cpp
|
bcb5\bcb5re300lm\regex_debug.obj: ../src/regex_debug.cpp $(ALL_HEADER)
bcc32 @&&|
-c $(INCLUDES) -DBOOST_RE_BUILD_DLL -tWD -tWM -tWR -D_NO_VCL -D_RTLDLL -O2 -w-inl -w-aus -w-rch -w-8012 -w-8057 -w-8037 -DSTRICT; -I$(BCROOT)\include;../../../ -L$(BCROOT)\lib;$(BCROOT)\lib\release; $(CXXFLAGS) -obcb5\bcb5re300lm\regex_debug.obj ../src/regex_debug.cpp
|
bcb5\bcb5re300lm\regex_synch.obj: ../src/regex_synch.cpp $(ALL_HEADER)
bcc32 @&&|
-c $(INCLUDES) -DBOOST_RE_BUILD_DLL -tWD -tWM -tWR -D_NO_VCL -D_RTLDLL -O2 -w-inl -w-aus -w-rch -w-8012 -w-8057 -w-8037 -DSTRICT; -I$(BCROOT)\include;../../../ -L$(BCROOT)\lib;$(BCROOT)\lib\release; $(CXXFLAGS) -obcb5\bcb5re300lm\regex_synch.obj ../src/regex_synch.cpp
|
bcb5\bcb5re300lm\w32_regex_traits.obj: ../src/w32_regex_traits.cpp $(ALL_HEADER)
bcc32 @&&|
-c $(INCLUDES) -DBOOST_RE_BUILD_DLL -tWD -tWM -tWR -D_NO_VCL -D_RTLDLL -O2 -w-inl -w-aus -w-rch -w-8012 -w-8057 -w-8037 -DSTRICT; -I$(BCROOT)\include;../../../ -L$(BCROOT)\lib;$(BCROOT)\lib\release; $(CXXFLAGS) -obcb5\bcb5re300lm\w32_regex_traits.obj ../src/w32_regex_traits.cpp
|
bcb5\bcb5re300lm\wide_posix_api.obj: ../src/wide_posix_api.cpp $(ALL_HEADER)
bcc32 @&&|
-c $(INCLUDES) -DBOOST_RE_BUILD_DLL -tWD -tWM -tWR -D_NO_VCL -D_RTLDLL -O2 -w-inl -w-aus -w-rch -w-8012 -w-8057 -w-8037 -DSTRICT; -I$(BCROOT)\include;../../../ -L$(BCROOT)\lib;$(BCROOT)\lib\release; $(CXXFLAGS) -obcb5\bcb5re300lm\wide_posix_api.obj ../src/wide_posix_api.cpp
|
bcb5\bcb5re300lm :
-mkdir bcb5\bcb5re300lm
bcb5re300lm_clean :
del bcb5\bcb5re300lm\*.obj
del bcb5\bcb5re300lm\*.il?
del bcb5\bcb5re300lm\*.csm
del bcb5\bcb5re300lm\*.tds
del bcb5\*.tds
bcb5\bcb5re300lm.lib : bcb5\bcb5re300lm\c_regex_traits.obj bcb5\bcb5re300lm\c_regex_traits_common.obj bcb5\bcb5re300lm\cpp_regex_traits.obj bcb5\bcb5re300lm\cregex.obj bcb5\bcb5re300lm\fileiter.obj bcb5\bcb5re300lm\posix_api.obj bcb5\bcb5re300lm\regex.obj bcb5\bcb5re300lm\regex_debug.obj bcb5\bcb5re300lm\regex_synch.obj bcb5\bcb5re300lm\w32_regex_traits.obj bcb5\bcb5re300lm\wide_posix_api.obj
bcc32 @&&|
-DBOOST_RE_BUILD_DLL -tWD -tWM -tWR -D_NO_VCL -D_RTLDLL -O2 -w-inl -w-aus -w-rch -w-8012 -w-8057 -w-8037 -DSTRICT; -I$(BCROOT)\include;../../../ -L$(BCROOT)\lib;$(BCROOT)\lib\release; -ebcb5\bcb5re300lm.dll $(XLFLAGS) bcb5\bcb5re300lm\c_regex_traits.obj bcb5\bcb5re300lm\c_regex_traits_common.obj bcb5\bcb5re300lm\cpp_regex_traits.obj bcb5\bcb5re300lm\cregex.obj bcb5\bcb5re300lm\fileiter.obj bcb5\bcb5re300lm\posix_api.obj bcb5\bcb5re300lm\regex.obj bcb5\bcb5re300lm\regex_debug.obj bcb5\bcb5re300lm\regex_synch.obj bcb5\bcb5re300lm\w32_regex_traits.obj bcb5\bcb5re300lm\wide_posix_api.obj $(LIBS)
|
implib -c bcb5\bcb5re300lm.lib bcb5\bcb5re300lm.dll
########################################################
#
# section for bcb5re300l.lib
#
########################################################
bcb5\bcb5re300l\c_regex_traits.obj: ../src/c_regex_traits.cpp $(ALL_HEADER)
bcc32 @&&|
-c $(INCLUDES) -DBOOST_RE_BUILD_DLL -tWD -tWR -tWM- -D_NO_VCL -D_RTLDLL -O2 -w-inl -w-aus -w-rch -w-8012 -w-8057 -w-8037 -DSTRICT; -I$(BCROOT)\include;../../../ -L$(BCROOT)\lib;$(BCROOT)\lib\release; $(CXXFLAGS) -obcb5\bcb5re300l\c_regex_traits.obj ../src/c_regex_traits.cpp
|
bcb5\bcb5re300l\c_regex_traits_common.obj: ../src/c_regex_traits_common.cpp $(ALL_HEADER)
bcc32 @&&|
-c $(INCLUDES) -DBOOST_RE_BUILD_DLL -tWD -tWR -tWM- -D_NO_VCL -D_RTLDLL -O2 -w-inl -w-aus -w-rch -w-8012 -w-8057 -w-8037 -DSTRICT; -I$(BCROOT)\include;../../../ -L$(BCROOT)\lib;$(BCROOT)\lib\release; $(CXXFLAGS) -obcb5\bcb5re300l\c_regex_traits_common.obj ../src/c_regex_traits_common.cpp
|
bcb5\bcb5re300l\cpp_regex_traits.obj: ../src/cpp_regex_traits.cpp $(ALL_HEADER)
bcc32 @&&|
-c $(INCLUDES) -DBOOST_RE_BUILD_DLL -tWD -tWR -tWM- -D_NO_VCL -D_RTLDLL -O2 -w-inl -w-aus -w-rch -w-8012 -w-8057 -w-8037 -DSTRICT; -I$(BCROOT)\include;../../../ -L$(BCROOT)\lib;$(BCROOT)\lib\release; $(CXXFLAGS) -obcb5\bcb5re300l\cpp_regex_traits.obj ../src/cpp_regex_traits.cpp
|
bcb5\bcb5re300l\cregex.obj: ../src/cregex.cpp $(ALL_HEADER)
bcc32 @&&|
-c $(INCLUDES) -DBOOST_RE_BUILD_DLL -tWD -tWR -tWM- -D_NO_VCL -D_RTLDLL -O2 -w-inl -w-aus -w-rch -w-8012 -w-8057 -w-8037 -DSTRICT; -I$(BCROOT)\include;../../../ -L$(BCROOT)\lib;$(BCROOT)\lib\release; $(CXXFLAGS) -obcb5\bcb5re300l\cregex.obj ../src/cregex.cpp
|
bcb5\bcb5re300l\fileiter.obj: ../src/fileiter.cpp $(ALL_HEADER)
bcc32 @&&|
-c $(INCLUDES) -DBOOST_RE_BUILD_DLL -tWD -tWR -tWM- -D_NO_VCL -D_RTLDLL -O2 -w-inl -w-aus -w-rch -w-8012 -w-8057 -w-8037 -DSTRICT; -I$(BCROOT)\include;../../../ -L$(BCROOT)\lib;$(BCROOT)\lib\release; $(CXXFLAGS) -obcb5\bcb5re300l\fileiter.obj ../src/fileiter.cpp
|
bcb5\bcb5re300l\posix_api.obj: ../src/posix_api.cpp $(ALL_HEADER)
bcc32 @&&|
-c $(INCLUDES) -DBOOST_RE_BUILD_DLL -tWD -tWR -tWM- -D_NO_VCL -D_RTLDLL -O2 -w-inl -w-aus -w-rch -w-8012 -w-8057 -w-8037 -DSTRICT; -I$(BCROOT)\include;../../../ -L$(BCROOT)\lib;$(BCROOT)\lib\release; $(CXXFLAGS) -obcb5\bcb5re300l\posix_api.obj ../src/posix_api.cpp
|
bcb5\bcb5re300l\regex.obj: ../src/regex.cpp $(ALL_HEADER)
bcc32 @&&|
-c $(INCLUDES) -DBOOST_RE_BUILD_DLL -tWD -tWR -tWM- -D_NO_VCL -D_RTLDLL -O2 -w-inl -w-aus -w-rch -w-8012 -w-8057 -w-8037 -DSTRICT; -I$(BCROOT)\include;../../../ -L$(BCROOT)\lib;$(BCROOT)\lib\release; $(CXXFLAGS) -obcb5\bcb5re300l\regex.obj ../src/regex.cpp
|
bcb5\bcb5re300l\regex_debug.obj: ../src/regex_debug.cpp $(ALL_HEADER)
bcc32 @&&|
-c $(INCLUDES) -DBOOST_RE_BUILD_DLL -tWD -tWR -tWM- -D_NO_VCL -D_RTLDLL -O2 -w-inl -w-aus -w-rch -w-8012 -w-8057 -w-8037 -DSTRICT; -I$(BCROOT)\include;../../../ -L$(BCROOT)\lib;$(BCROOT)\lib\release; $(CXXFLAGS) -obcb5\bcb5re300l\regex_debug.obj ../src/regex_debug.cpp
|
bcb5\bcb5re300l\regex_synch.obj: ../src/regex_synch.cpp $(ALL_HEADER)
bcc32 @&&|
-c $(INCLUDES) -DBOOST_RE_BUILD_DLL -tWD -tWR -tWM- -D_NO_VCL -D_RTLDLL -O2 -w-inl -w-aus -w-rch -w-8012 -w-8057 -w-8037 -DSTRICT; -I$(BCROOT)\include;../../../ -L$(BCROOT)\lib;$(BCROOT)\lib\release; $(CXXFLAGS) -obcb5\bcb5re300l\regex_synch.obj ../src/regex_synch.cpp
|
bcb5\bcb5re300l\w32_regex_traits.obj: ../src/w32_regex_traits.cpp $(ALL_HEADER)
bcc32 @&&|
-c $(INCLUDES) -DBOOST_RE_BUILD_DLL -tWD -tWR -tWM- -D_NO_VCL -D_RTLDLL -O2 -w-inl -w-aus -w-rch -w-8012 -w-8057 -w-8037 -DSTRICT; -I$(BCROOT)\include;../../../ -L$(BCROOT)\lib;$(BCROOT)\lib\release; $(CXXFLAGS) -obcb5\bcb5re300l\w32_regex_traits.obj ../src/w32_regex_traits.cpp
|
bcb5\bcb5re300l\wide_posix_api.obj: ../src/wide_posix_api.cpp $(ALL_HEADER)
bcc32 @&&|
-c $(INCLUDES) -DBOOST_RE_BUILD_DLL -tWD -tWR -tWM- -D_NO_VCL -D_RTLDLL -O2 -w-inl -w-aus -w-rch -w-8012 -w-8057 -w-8037 -DSTRICT; -I$(BCROOT)\include;../../../ -L$(BCROOT)\lib;$(BCROOT)\lib\release; $(CXXFLAGS) -obcb5\bcb5re300l\wide_posix_api.obj ../src/wide_posix_api.cpp
|
bcb5\bcb5re300l :
-mkdir bcb5\bcb5re300l
bcb5re300l_clean :
del bcb5\bcb5re300l\*.obj
del bcb5\bcb5re300l\*.il?
del bcb5\bcb5re300l\*.csm
del bcb5\bcb5re300l\*.tds
del bcb5\*.tds
bcb5\bcb5re300l.lib : bcb5\bcb5re300l\c_regex_traits.obj bcb5\bcb5re300l\c_regex_traits_common.obj bcb5\bcb5re300l\cpp_regex_traits.obj bcb5\bcb5re300l\cregex.obj bcb5\bcb5re300l\fileiter.obj bcb5\bcb5re300l\posix_api.obj bcb5\bcb5re300l\regex.obj bcb5\bcb5re300l\regex_debug.obj bcb5\bcb5re300l\regex_synch.obj bcb5\bcb5re300l\w32_regex_traits.obj bcb5\bcb5re300l\wide_posix_api.obj
bcc32 @&&|
-DBOOST_RE_BUILD_DLL -tWD -tWR -tWM- -D_NO_VCL -D_RTLDLL -O2 -w-inl -w-aus -w-rch -w-8012 -w-8057 -w-8037 -DSTRICT; -I$(BCROOT)\include;../../../ -L$(BCROOT)\lib;$(BCROOT)\lib\release; -ebcb5\bcb5re300l.dll $(XLFLAGS) bcb5\bcb5re300l\c_regex_traits.obj bcb5\bcb5re300l\c_regex_traits_common.obj bcb5\bcb5re300l\cpp_regex_traits.obj bcb5\bcb5re300l\cregex.obj bcb5\bcb5re300l\fileiter.obj bcb5\bcb5re300l\posix_api.obj bcb5\bcb5re300l\regex.obj bcb5\bcb5re300l\regex_debug.obj bcb5\bcb5re300l\regex_synch.obj bcb5\bcb5re300l\w32_regex_traits.obj bcb5\bcb5re300l\wide_posix_api.obj $(LIBS)
|
implib -c bcb5\bcb5re300l.lib bcb5\bcb5re300l.dll

View File

@ -1,508 +0,0 @@
#
# auto generated makefile for C++ Builder
#
# usage:
# make
# brings libraries up to date
# make install
# brings libraries up to date and copies binaries to your C++ Builder /lib and /bin directories (recomended)
# make clean
# removes all temporary files.
#
# Add additional compiler options here:
#
CXXFLAGS=
#
# Add additional include directories here:
#
INCLUDES=
#
# add additional linker flags here:
#
XLFLAGS=
#
# add additional libraries to link to here:
#
LIBS=
#
# add additional static-library creation flags here:
#
XSFLAGS=
!ifndef BCROOT
BCROOT=$(MAKEDIR)\..
!endif
ALL_HEADER=../../../boost/cregex.hpp ../../../boost/regex/pattern_except.hpp ../../../boost/regex.hpp ../../../boost/regex/regex_traits.hpp ../../../boost/regex/detail/fileiter.hpp ../../../boost/regex/detail/regex_compile.hpp ../../../boost/regex/detail/regex_config.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_options.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 : bcb4 bcb4\bcb4re300 bcb4\bcb4re300.lib bcb4\bcb4re300m bcb4\bcb4re300m.lib bcb4\bcb4re300v bcb4\bcb4re300v.lib bcb4\bcb4re300lv bcb4\bcb4re300lv.lib bcb4\bcb4re300lm bcb4\bcb4re300lm.lib bcb4\bcb4re300l bcb4\bcb4re300l.lib
clean : bcb4re300_clean bcb4re300m_clean bcb4re300v_clean bcb4re300lv_clean bcb4re300lm_clean bcb4re300l_clean
install : all
copy bcb4\bcb4re300.lib $(BCROOT)\lib
copy bcb4\bcb4re300m.lib $(BCROOT)\lib
copy bcb4\bcb4re300v.lib $(BCROOT)\lib
copy bcb4\bcb4re300lv.lib $(BCROOT)\lib
copy bcb4\bcb4re300lv.dll $(BCROOT)\bin
copy bcb4\bcb4re300lm.lib $(BCROOT)\lib
copy bcb4\bcb4re300lm.dll $(BCROOT)\bin
copy bcb4\bcb4re300l.lib $(BCROOT)\lib
copy bcb4\bcb4re300l.dll $(BCROOT)\bin
bcb4 :
-mkdir bcb4
########################################################
#
# section for bcb4re300.lib
#
########################################################
bcb4\bcb4re300\c_regex_traits.obj: ../src/c_regex_traits.cpp $(ALL_HEADER)
bcc32 @&&|
-c $(INCLUDES) -tWM- -D_NO_VCL -O2 -w-inl -w-aus -w-rch -w-8012 -w-8037 -w-8057 -DSTRICT; -I$(BCROOT)\include;../../../ $(CXXFLAGS) -obcb4\bcb4re300\c_regex_traits.obj ../src/c_regex_traits.cpp
|
bcb4\bcb4re300\c_regex_traits_common.obj: ../src/c_regex_traits_common.cpp $(ALL_HEADER)
bcc32 @&&|
-c $(INCLUDES) -tWM- -D_NO_VCL -O2 -w-inl -w-aus -w-rch -w-8012 -w-8037 -w-8057 -DSTRICT; -I$(BCROOT)\include;../../../ $(CXXFLAGS) -obcb4\bcb4re300\c_regex_traits_common.obj ../src/c_regex_traits_common.cpp
|
bcb4\bcb4re300\cpp_regex_traits.obj: ../src/cpp_regex_traits.cpp $(ALL_HEADER)
bcc32 @&&|
-c $(INCLUDES) -tWM- -D_NO_VCL -O2 -w-inl -w-aus -w-rch -w-8012 -w-8037 -w-8057 -DSTRICT; -I$(BCROOT)\include;../../../ $(CXXFLAGS) -obcb4\bcb4re300\cpp_regex_traits.obj ../src/cpp_regex_traits.cpp
|
bcb4\bcb4re300\cregex.obj: ../src/cregex.cpp $(ALL_HEADER)
bcc32 @&&|
-c $(INCLUDES) -tWM- -D_NO_VCL -O2 -w-inl -w-aus -w-rch -w-8012 -w-8037 -w-8057 -DSTRICT; -I$(BCROOT)\include;../../../ $(CXXFLAGS) -obcb4\bcb4re300\cregex.obj ../src/cregex.cpp
|
bcb4\bcb4re300\fileiter.obj: ../src/fileiter.cpp $(ALL_HEADER)
bcc32 @&&|
-c $(INCLUDES) -tWM- -D_NO_VCL -O2 -w-inl -w-aus -w-rch -w-8012 -w-8037 -w-8057 -DSTRICT; -I$(BCROOT)\include;../../../ $(CXXFLAGS) -obcb4\bcb4re300\fileiter.obj ../src/fileiter.cpp
|
bcb4\bcb4re300\posix_api.obj: ../src/posix_api.cpp $(ALL_HEADER)
bcc32 @&&|
-c $(INCLUDES) -tWM- -D_NO_VCL -O2 -w-inl -w-aus -w-rch -w-8012 -w-8037 -w-8057 -DSTRICT; -I$(BCROOT)\include;../../../ $(CXXFLAGS) -obcb4\bcb4re300\posix_api.obj ../src/posix_api.cpp
|
bcb4\bcb4re300\regex.obj: ../src/regex.cpp $(ALL_HEADER)
bcc32 @&&|
-c $(INCLUDES) -tWM- -D_NO_VCL -O2 -w-inl -w-aus -w-rch -w-8012 -w-8037 -w-8057 -DSTRICT; -I$(BCROOT)\include;../../../ $(CXXFLAGS) -obcb4\bcb4re300\regex.obj ../src/regex.cpp
|
bcb4\bcb4re300\regex_debug.obj: ../src/regex_debug.cpp $(ALL_HEADER)
bcc32 @&&|
-c $(INCLUDES) -tWM- -D_NO_VCL -O2 -w-inl -w-aus -w-rch -w-8012 -w-8037 -w-8057 -DSTRICT; -I$(BCROOT)\include;../../../ $(CXXFLAGS) -obcb4\bcb4re300\regex_debug.obj ../src/regex_debug.cpp
|
bcb4\bcb4re300\regex_synch.obj: ../src/regex_synch.cpp $(ALL_HEADER)
bcc32 @&&|
-c $(INCLUDES) -tWM- -D_NO_VCL -O2 -w-inl -w-aus -w-rch -w-8012 -w-8037 -w-8057 -DSTRICT; -I$(BCROOT)\include;../../../ $(CXXFLAGS) -obcb4\bcb4re300\regex_synch.obj ../src/regex_synch.cpp
|
bcb4\bcb4re300\w32_regex_traits.obj: ../src/w32_regex_traits.cpp $(ALL_HEADER)
bcc32 @&&|
-c $(INCLUDES) -tWM- -D_NO_VCL -O2 -w-inl -w-aus -w-rch -w-8012 -w-8037 -w-8057 -DSTRICT; -I$(BCROOT)\include;../../../ $(CXXFLAGS) -obcb4\bcb4re300\w32_regex_traits.obj ../src/w32_regex_traits.cpp
|
bcb4\bcb4re300\wide_posix_api.obj: ../src/wide_posix_api.cpp $(ALL_HEADER)
bcc32 @&&|
-c $(INCLUDES) -tWM- -D_NO_VCL -O2 -w-inl -w-aus -w-rch -w-8012 -w-8037 -w-8057 -DSTRICT; -I$(BCROOT)\include;../../../ $(CXXFLAGS) -obcb4\bcb4re300\wide_posix_api.obj ../src/wide_posix_api.cpp
|
bcb4\bcb4re300 :
-mkdir bcb4\bcb4re300
bcb4re300_clean :
del bcb4\bcb4re300\*.obj
del bcb4\bcb4re300\*.il?
del bcb4\bcb4re300\*.csm
del bcb4\bcb4re300\*.tds
bcb4\bcb4re300.lib : bcb4\bcb4re300\c_regex_traits.obj bcb4\bcb4re300\c_regex_traits_common.obj bcb4\bcb4re300\cpp_regex_traits.obj bcb4\bcb4re300\cregex.obj bcb4\bcb4re300\fileiter.obj bcb4\bcb4re300\posix_api.obj bcb4\bcb4re300\regex.obj bcb4\bcb4re300\regex_debug.obj bcb4\bcb4re300\regex_synch.obj bcb4\bcb4re300\w32_regex_traits.obj bcb4\bcb4re300\wide_posix_api.obj
tlib @&&|
/P32 /C /u /a $(XSFLAGS) bcb4\bcb4re300.lib +bcb4\bcb4re300\c_regex_traits.obj +bcb4\bcb4re300\c_regex_traits_common.obj +bcb4\bcb4re300\cpp_regex_traits.obj +bcb4\bcb4re300\cregex.obj +bcb4\bcb4re300\fileiter.obj +bcb4\bcb4re300\posix_api.obj +bcb4\bcb4re300\regex.obj +bcb4\bcb4re300\regex_debug.obj +bcb4\bcb4re300\regex_synch.obj +bcb4\bcb4re300\w32_regex_traits.obj +bcb4\bcb4re300\wide_posix_api.obj
|
########################################################
#
# section for bcb4re300m.lib
#
########################################################
bcb4\bcb4re300m\c_regex_traits.obj: ../src/c_regex_traits.cpp $(ALL_HEADER)
bcc32 @&&|
-c $(INCLUDES) -tWM -D_NO_VCL -O2 -w-inl -w-aus -w-rch -w-8012 -w-8057 -w-8037 -DSTRICT; -I$(BCROOT)\include;../../../ $(CXXFLAGS) -obcb4\bcb4re300m\c_regex_traits.obj ../src/c_regex_traits.cpp
|
bcb4\bcb4re300m\c_regex_traits_common.obj: ../src/c_regex_traits_common.cpp $(ALL_HEADER)
bcc32 @&&|
-c $(INCLUDES) -tWM -D_NO_VCL -O2 -w-inl -w-aus -w-rch -w-8012 -w-8057 -w-8037 -DSTRICT; -I$(BCROOT)\include;../../../ $(CXXFLAGS) -obcb4\bcb4re300m\c_regex_traits_common.obj ../src/c_regex_traits_common.cpp
|
bcb4\bcb4re300m\cpp_regex_traits.obj: ../src/cpp_regex_traits.cpp $(ALL_HEADER)
bcc32 @&&|
-c $(INCLUDES) -tWM -D_NO_VCL -O2 -w-inl -w-aus -w-rch -w-8012 -w-8057 -w-8037 -DSTRICT; -I$(BCROOT)\include;../../../ $(CXXFLAGS) -obcb4\bcb4re300m\cpp_regex_traits.obj ../src/cpp_regex_traits.cpp
|
bcb4\bcb4re300m\cregex.obj: ../src/cregex.cpp $(ALL_HEADER)
bcc32 @&&|
-c $(INCLUDES) -tWM -D_NO_VCL -O2 -w-inl -w-aus -w-rch -w-8012 -w-8057 -w-8037 -DSTRICT; -I$(BCROOT)\include;../../../ $(CXXFLAGS) -obcb4\bcb4re300m\cregex.obj ../src/cregex.cpp
|
bcb4\bcb4re300m\fileiter.obj: ../src/fileiter.cpp $(ALL_HEADER)
bcc32 @&&|
-c $(INCLUDES) -tWM -D_NO_VCL -O2 -w-inl -w-aus -w-rch -w-8012 -w-8057 -w-8037 -DSTRICT; -I$(BCROOT)\include;../../../ $(CXXFLAGS) -obcb4\bcb4re300m\fileiter.obj ../src/fileiter.cpp
|
bcb4\bcb4re300m\posix_api.obj: ../src/posix_api.cpp $(ALL_HEADER)
bcc32 @&&|
-c $(INCLUDES) -tWM -D_NO_VCL -O2 -w-inl -w-aus -w-rch -w-8012 -w-8057 -w-8037 -DSTRICT; -I$(BCROOT)\include;../../../ $(CXXFLAGS) -obcb4\bcb4re300m\posix_api.obj ../src/posix_api.cpp
|
bcb4\bcb4re300m\regex.obj: ../src/regex.cpp $(ALL_HEADER)
bcc32 @&&|
-c $(INCLUDES) -tWM -D_NO_VCL -O2 -w-inl -w-aus -w-rch -w-8012 -w-8057 -w-8037 -DSTRICT; -I$(BCROOT)\include;../../../ $(CXXFLAGS) -obcb4\bcb4re300m\regex.obj ../src/regex.cpp
|
bcb4\bcb4re300m\regex_debug.obj: ../src/regex_debug.cpp $(ALL_HEADER)
bcc32 @&&|
-c $(INCLUDES) -tWM -D_NO_VCL -O2 -w-inl -w-aus -w-rch -w-8012 -w-8057 -w-8037 -DSTRICT; -I$(BCROOT)\include;../../../ $(CXXFLAGS) -obcb4\bcb4re300m\regex_debug.obj ../src/regex_debug.cpp
|
bcb4\bcb4re300m\regex_synch.obj: ../src/regex_synch.cpp $(ALL_HEADER)
bcc32 @&&|
-c $(INCLUDES) -tWM -D_NO_VCL -O2 -w-inl -w-aus -w-rch -w-8012 -w-8057 -w-8037 -DSTRICT; -I$(BCROOT)\include;../../../ $(CXXFLAGS) -obcb4\bcb4re300m\regex_synch.obj ../src/regex_synch.cpp
|
bcb4\bcb4re300m\w32_regex_traits.obj: ../src/w32_regex_traits.cpp $(ALL_HEADER)
bcc32 @&&|
-c $(INCLUDES) -tWM -D_NO_VCL -O2 -w-inl -w-aus -w-rch -w-8012 -w-8057 -w-8037 -DSTRICT; -I$(BCROOT)\include;../../../ $(CXXFLAGS) -obcb4\bcb4re300m\w32_regex_traits.obj ../src/w32_regex_traits.cpp
|
bcb4\bcb4re300m\wide_posix_api.obj: ../src/wide_posix_api.cpp $(ALL_HEADER)
bcc32 @&&|
-c $(INCLUDES) -tWM -D_NO_VCL -O2 -w-inl -w-aus -w-rch -w-8012 -w-8057 -w-8037 -DSTRICT; -I$(BCROOT)\include;../../../ $(CXXFLAGS) -obcb4\bcb4re300m\wide_posix_api.obj ../src/wide_posix_api.cpp
|
bcb4\bcb4re300m :
-mkdir bcb4\bcb4re300m
bcb4re300m_clean :
del bcb4\bcb4re300m\*.obj
del bcb4\bcb4re300m\*.il?
del bcb4\bcb4re300m\*.csm
del bcb4\bcb4re300m\*.tds
bcb4\bcb4re300m.lib : bcb4\bcb4re300m\c_regex_traits.obj bcb4\bcb4re300m\c_regex_traits_common.obj bcb4\bcb4re300m\cpp_regex_traits.obj bcb4\bcb4re300m\cregex.obj bcb4\bcb4re300m\fileiter.obj bcb4\bcb4re300m\posix_api.obj bcb4\bcb4re300m\regex.obj bcb4\bcb4re300m\regex_debug.obj bcb4\bcb4re300m\regex_synch.obj bcb4\bcb4re300m\w32_regex_traits.obj bcb4\bcb4re300m\wide_posix_api.obj
tlib @&&|
/P32 /C /u /a $(XSFLAGS) bcb4\bcb4re300m.lib +bcb4\bcb4re300m\c_regex_traits.obj +bcb4\bcb4re300m\c_regex_traits_common.obj +bcb4\bcb4re300m\cpp_regex_traits.obj +bcb4\bcb4re300m\cregex.obj +bcb4\bcb4re300m\fileiter.obj +bcb4\bcb4re300m\posix_api.obj +bcb4\bcb4re300m\regex.obj +bcb4\bcb4re300m\regex_debug.obj +bcb4\bcb4re300m\regex_synch.obj +bcb4\bcb4re300m\w32_regex_traits.obj +bcb4\bcb4re300m\wide_posix_api.obj
|
########################################################
#
# section for bcb4re300v.lib
#
########################################################
bcb4\bcb4re300v\c_regex_traits.obj: ../src/c_regex_traits.cpp $(ALL_HEADER)
bcc32 @&&|
-c $(INCLUDES) -tWM -tWV -DJM_USE_VCL -O2 -w-inl -w-aus -w-rch -w-8012 -w-8037 -w-8057 -DSTRICT; -I$(BCROOT)\include;../../../ $(CXXFLAGS) -obcb4\bcb4re300v\c_regex_traits.obj ../src/c_regex_traits.cpp
|
bcb4\bcb4re300v\c_regex_traits_common.obj: ../src/c_regex_traits_common.cpp $(ALL_HEADER)
bcc32 @&&|
-c $(INCLUDES) -tWM -tWV -DJM_USE_VCL -O2 -w-inl -w-aus -w-rch -w-8012 -w-8037 -w-8057 -DSTRICT; -I$(BCROOT)\include;../../../ $(CXXFLAGS) -obcb4\bcb4re300v\c_regex_traits_common.obj ../src/c_regex_traits_common.cpp
|
bcb4\bcb4re300v\cpp_regex_traits.obj: ../src/cpp_regex_traits.cpp $(ALL_HEADER)
bcc32 @&&|
-c $(INCLUDES) -tWM -tWV -DJM_USE_VCL -O2 -w-inl -w-aus -w-rch -w-8012 -w-8037 -w-8057 -DSTRICT; -I$(BCROOT)\include;../../../ $(CXXFLAGS) -obcb4\bcb4re300v\cpp_regex_traits.obj ../src/cpp_regex_traits.cpp
|
bcb4\bcb4re300v\cregex.obj: ../src/cregex.cpp $(ALL_HEADER)
bcc32 @&&|
-c $(INCLUDES) -tWM -tWV -DJM_USE_VCL -O2 -w-inl -w-aus -w-rch -w-8012 -w-8037 -w-8057 -DSTRICT; -I$(BCROOT)\include;../../../ $(CXXFLAGS) -obcb4\bcb4re300v\cregex.obj ../src/cregex.cpp
|
bcb4\bcb4re300v\fileiter.obj: ../src/fileiter.cpp $(ALL_HEADER)
bcc32 @&&|
-c $(INCLUDES) -tWM -tWV -DJM_USE_VCL -O2 -w-inl -w-aus -w-rch -w-8012 -w-8037 -w-8057 -DSTRICT; -I$(BCROOT)\include;../../../ $(CXXFLAGS) -obcb4\bcb4re300v\fileiter.obj ../src/fileiter.cpp
|
bcb4\bcb4re300v\posix_api.obj: ../src/posix_api.cpp $(ALL_HEADER)
bcc32 @&&|
-c $(INCLUDES) -tWM -tWV -DJM_USE_VCL -O2 -w-inl -w-aus -w-rch -w-8012 -w-8037 -w-8057 -DSTRICT; -I$(BCROOT)\include;../../../ $(CXXFLAGS) -obcb4\bcb4re300v\posix_api.obj ../src/posix_api.cpp
|
bcb4\bcb4re300v\regex.obj: ../src/regex.cpp $(ALL_HEADER)
bcc32 @&&|
-c $(INCLUDES) -tWM -tWV -DJM_USE_VCL -O2 -w-inl -w-aus -w-rch -w-8012 -w-8037 -w-8057 -DSTRICT; -I$(BCROOT)\include;../../../ $(CXXFLAGS) -obcb4\bcb4re300v\regex.obj ../src/regex.cpp
|
bcb4\bcb4re300v\regex_debug.obj: ../src/regex_debug.cpp $(ALL_HEADER)
bcc32 @&&|
-c $(INCLUDES) -tWM -tWV -DJM_USE_VCL -O2 -w-inl -w-aus -w-rch -w-8012 -w-8037 -w-8057 -DSTRICT; -I$(BCROOT)\include;../../../ $(CXXFLAGS) -obcb4\bcb4re300v\regex_debug.obj ../src/regex_debug.cpp
|
bcb4\bcb4re300v\regex_synch.obj: ../src/regex_synch.cpp $(ALL_HEADER)
bcc32 @&&|
-c $(INCLUDES) -tWM -tWV -DJM_USE_VCL -O2 -w-inl -w-aus -w-rch -w-8012 -w-8037 -w-8057 -DSTRICT; -I$(BCROOT)\include;../../../ $(CXXFLAGS) -obcb4\bcb4re300v\regex_synch.obj ../src/regex_synch.cpp
|
bcb4\bcb4re300v\w32_regex_traits.obj: ../src/w32_regex_traits.cpp $(ALL_HEADER)
bcc32 @&&|
-c $(INCLUDES) -tWM -tWV -DJM_USE_VCL -O2 -w-inl -w-aus -w-rch -w-8012 -w-8037 -w-8057 -DSTRICT; -I$(BCROOT)\include;../../../ $(CXXFLAGS) -obcb4\bcb4re300v\w32_regex_traits.obj ../src/w32_regex_traits.cpp
|
bcb4\bcb4re300v\wide_posix_api.obj: ../src/wide_posix_api.cpp $(ALL_HEADER)
bcc32 @&&|
-c $(INCLUDES) -tWM -tWV -DJM_USE_VCL -O2 -w-inl -w-aus -w-rch -w-8012 -w-8037 -w-8057 -DSTRICT; -I$(BCROOT)\include;../../../ $(CXXFLAGS) -obcb4\bcb4re300v\wide_posix_api.obj ../src/wide_posix_api.cpp
|
bcb4\bcb4re300v :
-mkdir bcb4\bcb4re300v
bcb4re300v_clean :
del bcb4\bcb4re300v\*.obj
del bcb4\bcb4re300v\*.il?
del bcb4\bcb4re300v\*.csm
del bcb4\bcb4re300v\*.tds
bcb4\bcb4re300v.lib : bcb4\bcb4re300v\c_regex_traits.obj bcb4\bcb4re300v\c_regex_traits_common.obj bcb4\bcb4re300v\cpp_regex_traits.obj bcb4\bcb4re300v\cregex.obj bcb4\bcb4re300v\fileiter.obj bcb4\bcb4re300v\posix_api.obj bcb4\bcb4re300v\regex.obj bcb4\bcb4re300v\regex_debug.obj bcb4\bcb4re300v\regex_synch.obj bcb4\bcb4re300v\w32_regex_traits.obj bcb4\bcb4re300v\wide_posix_api.obj
tlib @&&|
/P32 /C /u /a $(XSFLAGS) bcb4\bcb4re300v.lib +bcb4\bcb4re300v\c_regex_traits.obj +bcb4\bcb4re300v\c_regex_traits_common.obj +bcb4\bcb4re300v\cpp_regex_traits.obj +bcb4\bcb4re300v\cregex.obj +bcb4\bcb4re300v\fileiter.obj +bcb4\bcb4re300v\posix_api.obj +bcb4\bcb4re300v\regex.obj +bcb4\bcb4re300v\regex_debug.obj +bcb4\bcb4re300v\regex_synch.obj +bcb4\bcb4re300v\w32_regex_traits.obj +bcb4\bcb4re300v\wide_posix_api.obj
|
########################################################
#
# section for bcb4re300lv.lib
#
########################################################
bcb4\bcb4re300lv\c_regex_traits.obj: ../src/c_regex_traits.cpp $(ALL_HEADER)
bcc32 @&&|
-c $(INCLUDES) -DBOOST_RE_BUILD_DLL -tWD -tWM -tWR -tWV -DJM_USE_VCL -D_RTLDLL -O2 -w-inl -w-aus -w-rch -w-8012 -w-8037 -w-8057 -DSTRICT; -I$(BCROOT)\include;../../../ -L$(BCROOT)\lib;$(BCROOT)\lib\release; $(CXXFLAGS) -obcb4\bcb4re300lv\c_regex_traits.obj ../src/c_regex_traits.cpp
|
bcb4\bcb4re300lv\c_regex_traits_common.obj: ../src/c_regex_traits_common.cpp $(ALL_HEADER)
bcc32 @&&|
-c $(INCLUDES) -DBOOST_RE_BUILD_DLL -tWD -tWM -tWR -tWV -DJM_USE_VCL -D_RTLDLL -O2 -w-inl -w-aus -w-rch -w-8012 -w-8037 -w-8057 -DSTRICT; -I$(BCROOT)\include;../../../ -L$(BCROOT)\lib;$(BCROOT)\lib\release; $(CXXFLAGS) -obcb4\bcb4re300lv\c_regex_traits_common.obj ../src/c_regex_traits_common.cpp
|
bcb4\bcb4re300lv\cpp_regex_traits.obj: ../src/cpp_regex_traits.cpp $(ALL_HEADER)
bcc32 @&&|
-c $(INCLUDES) -DBOOST_RE_BUILD_DLL -tWD -tWM -tWR -tWV -DJM_USE_VCL -D_RTLDLL -O2 -w-inl -w-aus -w-rch -w-8012 -w-8037 -w-8057 -DSTRICT; -I$(BCROOT)\include;../../../ -L$(BCROOT)\lib;$(BCROOT)\lib\release; $(CXXFLAGS) -obcb4\bcb4re300lv\cpp_regex_traits.obj ../src/cpp_regex_traits.cpp
|
bcb4\bcb4re300lv\cregex.obj: ../src/cregex.cpp $(ALL_HEADER)
bcc32 @&&|
-c $(INCLUDES) -DBOOST_RE_BUILD_DLL -tWD -tWM -tWR -tWV -DJM_USE_VCL -D_RTLDLL -O2 -w-inl -w-aus -w-rch -w-8012 -w-8037 -w-8057 -DSTRICT; -I$(BCROOT)\include;../../../ -L$(BCROOT)\lib;$(BCROOT)\lib\release; $(CXXFLAGS) -obcb4\bcb4re300lv\cregex.obj ../src/cregex.cpp
|
bcb4\bcb4re300lv\fileiter.obj: ../src/fileiter.cpp $(ALL_HEADER)
bcc32 @&&|
-c $(INCLUDES) -DBOOST_RE_BUILD_DLL -tWD -tWM -tWR -tWV -DJM_USE_VCL -D_RTLDLL -O2 -w-inl -w-aus -w-rch -w-8012 -w-8037 -w-8057 -DSTRICT; -I$(BCROOT)\include;../../../ -L$(BCROOT)\lib;$(BCROOT)\lib\release; $(CXXFLAGS) -obcb4\bcb4re300lv\fileiter.obj ../src/fileiter.cpp
|
bcb4\bcb4re300lv\posix_api.obj: ../src/posix_api.cpp $(ALL_HEADER)
bcc32 @&&|
-c $(INCLUDES) -DBOOST_RE_BUILD_DLL -tWD -tWM -tWR -tWV -DJM_USE_VCL -D_RTLDLL -O2 -w-inl -w-aus -w-rch -w-8012 -w-8037 -w-8057 -DSTRICT; -I$(BCROOT)\include;../../../ -L$(BCROOT)\lib;$(BCROOT)\lib\release; $(CXXFLAGS) -obcb4\bcb4re300lv\posix_api.obj ../src/posix_api.cpp
|
bcb4\bcb4re300lv\regex.obj: ../src/regex.cpp $(ALL_HEADER)
bcc32 @&&|
-c $(INCLUDES) -DBOOST_RE_BUILD_DLL -tWD -tWM -tWR -tWV -DJM_USE_VCL -D_RTLDLL -O2 -w-inl -w-aus -w-rch -w-8012 -w-8037 -w-8057 -DSTRICT; -I$(BCROOT)\include;../../../ -L$(BCROOT)\lib;$(BCROOT)\lib\release; $(CXXFLAGS) -obcb4\bcb4re300lv\regex.obj ../src/regex.cpp
|
bcb4\bcb4re300lv\regex_debug.obj: ../src/regex_debug.cpp $(ALL_HEADER)
bcc32 @&&|
-c $(INCLUDES) -DBOOST_RE_BUILD_DLL -tWD -tWM -tWR -tWV -DJM_USE_VCL -D_RTLDLL -O2 -w-inl -w-aus -w-rch -w-8012 -w-8037 -w-8057 -DSTRICT; -I$(BCROOT)\include;../../../ -L$(BCROOT)\lib;$(BCROOT)\lib\release; $(CXXFLAGS) -obcb4\bcb4re300lv\regex_debug.obj ../src/regex_debug.cpp
|
bcb4\bcb4re300lv\regex_synch.obj: ../src/regex_synch.cpp $(ALL_HEADER)
bcc32 @&&|
-c $(INCLUDES) -DBOOST_RE_BUILD_DLL -tWD -tWM -tWR -tWV -DJM_USE_VCL -D_RTLDLL -O2 -w-inl -w-aus -w-rch -w-8012 -w-8037 -w-8057 -DSTRICT; -I$(BCROOT)\include;../../../ -L$(BCROOT)\lib;$(BCROOT)\lib\release; $(CXXFLAGS) -obcb4\bcb4re300lv\regex_synch.obj ../src/regex_synch.cpp
|
bcb4\bcb4re300lv\w32_regex_traits.obj: ../src/w32_regex_traits.cpp $(ALL_HEADER)
bcc32 @&&|
-c $(INCLUDES) -DBOOST_RE_BUILD_DLL -tWD -tWM -tWR -tWV -DJM_USE_VCL -D_RTLDLL -O2 -w-inl -w-aus -w-rch -w-8012 -w-8037 -w-8057 -DSTRICT; -I$(BCROOT)\include;../../../ -L$(BCROOT)\lib;$(BCROOT)\lib\release; $(CXXFLAGS) -obcb4\bcb4re300lv\w32_regex_traits.obj ../src/w32_regex_traits.cpp
|
bcb4\bcb4re300lv\wide_posix_api.obj: ../src/wide_posix_api.cpp $(ALL_HEADER)
bcc32 @&&|
-c $(INCLUDES) -DBOOST_RE_BUILD_DLL -tWD -tWM -tWR -tWV -DJM_USE_VCL -D_RTLDLL -O2 -w-inl -w-aus -w-rch -w-8012 -w-8037 -w-8057 -DSTRICT; -I$(BCROOT)\include;../../../ -L$(BCROOT)\lib;$(BCROOT)\lib\release; $(CXXFLAGS) -obcb4\bcb4re300lv\wide_posix_api.obj ../src/wide_posix_api.cpp
|
bcb4\bcb4re300lv :
-mkdir bcb4\bcb4re300lv
bcb4re300lv_clean :
del bcb4\bcb4re300lv\*.obj
del bcb4\bcb4re300lv\*.il?
del bcb4\bcb4re300lv\*.csm
del bcb4\bcb4re300lv\*.tds
del bcb4\*.tds
bcb4\bcb4re300lv.lib : bcb4\bcb4re300lv\c_regex_traits.obj bcb4\bcb4re300lv\c_regex_traits_common.obj bcb4\bcb4re300lv\cpp_regex_traits.obj bcb4\bcb4re300lv\cregex.obj bcb4\bcb4re300lv\fileiter.obj bcb4\bcb4re300lv\posix_api.obj bcb4\bcb4re300lv\regex.obj bcb4\bcb4re300lv\regex_debug.obj bcb4\bcb4re300lv\regex_synch.obj bcb4\bcb4re300lv\w32_regex_traits.obj bcb4\bcb4re300lv\wide_posix_api.obj
bcc32 @&&|
-DBOOST_RE_BUILD_DLL -tWD -tWM -tWR -tWV -DJM_USE_VCL -D_RTLDLL -O2 -w-inl -w-aus -w-rch -w-8012 -w-8037 -w-8057 -DSTRICT; -I$(BCROOT)\include;../../../ -L$(BCROOT)\lib;$(BCROOT)\lib\release; -ebcb4\bcb4re300lv.dll $(XLFLAGS) bcb4\bcb4re300lv\c_regex_traits.obj bcb4\bcb4re300lv\c_regex_traits_common.obj bcb4\bcb4re300lv\cpp_regex_traits.obj bcb4\bcb4re300lv\cregex.obj bcb4\bcb4re300lv\fileiter.obj bcb4\bcb4re300lv\posix_api.obj bcb4\bcb4re300lv\regex.obj bcb4\bcb4re300lv\regex_debug.obj bcb4\bcb4re300lv\regex_synch.obj bcb4\bcb4re300lv\w32_regex_traits.obj bcb4\bcb4re300lv\wide_posix_api.obj $(LIBS)
|
implib -c bcb4\bcb4re300lv.lib bcb4\bcb4re300lv.dll
########################################################
#
# section for bcb4re300lm.lib
#
########################################################
bcb4\bcb4re300lm\c_regex_traits.obj: ../src/c_regex_traits.cpp $(ALL_HEADER)
bcc32 @&&|
-c $(INCLUDES) -DBOOST_RE_BUILD_DLL -tWD -tWM -tWR -D_NO_VCL -D_RTLDLL -O2 -w-inl -w-aus -w-rch -w-8012 -w-8057 -w-8037 -DSTRICT; -I$(BCROOT)\include;../../../ -L$(BCROOT)\lib;$(BCROOT)\lib\release; $(CXXFLAGS) -obcb4\bcb4re300lm\c_regex_traits.obj ../src/c_regex_traits.cpp
|
bcb4\bcb4re300lm\c_regex_traits_common.obj: ../src/c_regex_traits_common.cpp $(ALL_HEADER)
bcc32 @&&|
-c $(INCLUDES) -DBOOST_RE_BUILD_DLL -tWD -tWM -tWR -D_NO_VCL -D_RTLDLL -O2 -w-inl -w-aus -w-rch -w-8012 -w-8057 -w-8037 -DSTRICT; -I$(BCROOT)\include;../../../ -L$(BCROOT)\lib;$(BCROOT)\lib\release; $(CXXFLAGS) -obcb4\bcb4re300lm\c_regex_traits_common.obj ../src/c_regex_traits_common.cpp
|
bcb4\bcb4re300lm\cpp_regex_traits.obj: ../src/cpp_regex_traits.cpp $(ALL_HEADER)
bcc32 @&&|
-c $(INCLUDES) -DBOOST_RE_BUILD_DLL -tWD -tWM -tWR -D_NO_VCL -D_RTLDLL -O2 -w-inl -w-aus -w-rch -w-8012 -w-8057 -w-8037 -DSTRICT; -I$(BCROOT)\include;../../../ -L$(BCROOT)\lib;$(BCROOT)\lib\release; $(CXXFLAGS) -obcb4\bcb4re300lm\cpp_regex_traits.obj ../src/cpp_regex_traits.cpp
|
bcb4\bcb4re300lm\cregex.obj: ../src/cregex.cpp $(ALL_HEADER)
bcc32 @&&|
-c $(INCLUDES) -DBOOST_RE_BUILD_DLL -tWD -tWM -tWR -D_NO_VCL -D_RTLDLL -O2 -w-inl -w-aus -w-rch -w-8012 -w-8057 -w-8037 -DSTRICT; -I$(BCROOT)\include;../../../ -L$(BCROOT)\lib;$(BCROOT)\lib\release; $(CXXFLAGS) -obcb4\bcb4re300lm\cregex.obj ../src/cregex.cpp
|
bcb4\bcb4re300lm\fileiter.obj: ../src/fileiter.cpp $(ALL_HEADER)
bcc32 @&&|
-c $(INCLUDES) -DBOOST_RE_BUILD_DLL -tWD -tWM -tWR -D_NO_VCL -D_RTLDLL -O2 -w-inl -w-aus -w-rch -w-8012 -w-8057 -w-8037 -DSTRICT; -I$(BCROOT)\include;../../../ -L$(BCROOT)\lib;$(BCROOT)\lib\release; $(CXXFLAGS) -obcb4\bcb4re300lm\fileiter.obj ../src/fileiter.cpp
|
bcb4\bcb4re300lm\posix_api.obj: ../src/posix_api.cpp $(ALL_HEADER)
bcc32 @&&|
-c $(INCLUDES) -DBOOST_RE_BUILD_DLL -tWD -tWM -tWR -D_NO_VCL -D_RTLDLL -O2 -w-inl -w-aus -w-rch -w-8012 -w-8057 -w-8037 -DSTRICT; -I$(BCROOT)\include;../../../ -L$(BCROOT)\lib;$(BCROOT)\lib\release; $(CXXFLAGS) -obcb4\bcb4re300lm\posix_api.obj ../src/posix_api.cpp
|
bcb4\bcb4re300lm\regex.obj: ../src/regex.cpp $(ALL_HEADER)
bcc32 @&&|
-c $(INCLUDES) -DBOOST_RE_BUILD_DLL -tWD -tWM -tWR -D_NO_VCL -D_RTLDLL -O2 -w-inl -w-aus -w-rch -w-8012 -w-8057 -w-8037 -DSTRICT; -I$(BCROOT)\include;../../../ -L$(BCROOT)\lib;$(BCROOT)\lib\release; $(CXXFLAGS) -obcb4\bcb4re300lm\regex.obj ../src/regex.cpp
|
bcb4\bcb4re300lm\regex_debug.obj: ../src/regex_debug.cpp $(ALL_HEADER)
bcc32 @&&|
-c $(INCLUDES) -DBOOST_RE_BUILD_DLL -tWD -tWM -tWR -D_NO_VCL -D_RTLDLL -O2 -w-inl -w-aus -w-rch -w-8012 -w-8057 -w-8037 -DSTRICT; -I$(BCROOT)\include;../../../ -L$(BCROOT)\lib;$(BCROOT)\lib\release; $(CXXFLAGS) -obcb4\bcb4re300lm\regex_debug.obj ../src/regex_debug.cpp
|
bcb4\bcb4re300lm\regex_synch.obj: ../src/regex_synch.cpp $(ALL_HEADER)
bcc32 @&&|
-c $(INCLUDES) -DBOOST_RE_BUILD_DLL -tWD -tWM -tWR -D_NO_VCL -D_RTLDLL -O2 -w-inl -w-aus -w-rch -w-8012 -w-8057 -w-8037 -DSTRICT; -I$(BCROOT)\include;../../../ -L$(BCROOT)\lib;$(BCROOT)\lib\release; $(CXXFLAGS) -obcb4\bcb4re300lm\regex_synch.obj ../src/regex_synch.cpp
|
bcb4\bcb4re300lm\w32_regex_traits.obj: ../src/w32_regex_traits.cpp $(ALL_HEADER)
bcc32 @&&|
-c $(INCLUDES) -DBOOST_RE_BUILD_DLL -tWD -tWM -tWR -D_NO_VCL -D_RTLDLL -O2 -w-inl -w-aus -w-rch -w-8012 -w-8057 -w-8037 -DSTRICT; -I$(BCROOT)\include;../../../ -L$(BCROOT)\lib;$(BCROOT)\lib\release; $(CXXFLAGS) -obcb4\bcb4re300lm\w32_regex_traits.obj ../src/w32_regex_traits.cpp
|
bcb4\bcb4re300lm\wide_posix_api.obj: ../src/wide_posix_api.cpp $(ALL_HEADER)
bcc32 @&&|
-c $(INCLUDES) -DBOOST_RE_BUILD_DLL -tWD -tWM -tWR -D_NO_VCL -D_RTLDLL -O2 -w-inl -w-aus -w-rch -w-8012 -w-8057 -w-8037 -DSTRICT; -I$(BCROOT)\include;../../../ -L$(BCROOT)\lib;$(BCROOT)\lib\release; $(CXXFLAGS) -obcb4\bcb4re300lm\wide_posix_api.obj ../src/wide_posix_api.cpp
|
bcb4\bcb4re300lm :
-mkdir bcb4\bcb4re300lm
bcb4re300lm_clean :
del bcb4\bcb4re300lm\*.obj
del bcb4\bcb4re300lm\*.il?
del bcb4\bcb4re300lm\*.csm
del bcb4\bcb4re300lm\*.tds
del bcb4\*.tds
bcb4\bcb4re300lm.lib : bcb4\bcb4re300lm\c_regex_traits.obj bcb4\bcb4re300lm\c_regex_traits_common.obj bcb4\bcb4re300lm\cpp_regex_traits.obj bcb4\bcb4re300lm\cregex.obj bcb4\bcb4re300lm\fileiter.obj bcb4\bcb4re300lm\posix_api.obj bcb4\bcb4re300lm\regex.obj bcb4\bcb4re300lm\regex_debug.obj bcb4\bcb4re300lm\regex_synch.obj bcb4\bcb4re300lm\w32_regex_traits.obj bcb4\bcb4re300lm\wide_posix_api.obj
bcc32 @&&|
-DBOOST_RE_BUILD_DLL -tWD -tWM -tWR -D_NO_VCL -D_RTLDLL -O2 -w-inl -w-aus -w-rch -w-8012 -w-8057 -w-8037 -DSTRICT; -I$(BCROOT)\include;../../../ -L$(BCROOT)\lib;$(BCROOT)\lib\release; -ebcb4\bcb4re300lm.dll $(XLFLAGS) bcb4\bcb4re300lm\c_regex_traits.obj bcb4\bcb4re300lm\c_regex_traits_common.obj bcb4\bcb4re300lm\cpp_regex_traits.obj bcb4\bcb4re300lm\cregex.obj bcb4\bcb4re300lm\fileiter.obj bcb4\bcb4re300lm\posix_api.obj bcb4\bcb4re300lm\regex.obj bcb4\bcb4re300lm\regex_debug.obj bcb4\bcb4re300lm\regex_synch.obj bcb4\bcb4re300lm\w32_regex_traits.obj bcb4\bcb4re300lm\wide_posix_api.obj $(LIBS)
|
implib -c bcb4\bcb4re300lm.lib bcb4\bcb4re300lm.dll
########################################################
#
# section for bcb4re300l.lib
#
########################################################
bcb4\bcb4re300l\c_regex_traits.obj: ../src/c_regex_traits.cpp $(ALL_HEADER)
bcc32 @&&|
-c $(INCLUDES) -DBOOST_RE_BUILD_DLL -tWD -tWR -tWM- -D_NO_VCL -D_RTLDLL -O2 -w-inl -w-aus -w-rch -w-8012 -w-8057 -w-8037 -DSTRICT; -I$(BCROOT)\include;../../../ -L$(BCROOT)\lib;$(BCROOT)\lib\release; $(CXXFLAGS) -obcb4\bcb4re300l\c_regex_traits.obj ../src/c_regex_traits.cpp
|
bcb4\bcb4re300l\c_regex_traits_common.obj: ../src/c_regex_traits_common.cpp $(ALL_HEADER)
bcc32 @&&|
-c $(INCLUDES) -DBOOST_RE_BUILD_DLL -tWD -tWR -tWM- -D_NO_VCL -D_RTLDLL -O2 -w-inl -w-aus -w-rch -w-8012 -w-8057 -w-8037 -DSTRICT; -I$(BCROOT)\include;../../../ -L$(BCROOT)\lib;$(BCROOT)\lib\release; $(CXXFLAGS) -obcb4\bcb4re300l\c_regex_traits_common.obj ../src/c_regex_traits_common.cpp
|
bcb4\bcb4re300l\cpp_regex_traits.obj: ../src/cpp_regex_traits.cpp $(ALL_HEADER)
bcc32 @&&|
-c $(INCLUDES) -DBOOST_RE_BUILD_DLL -tWD -tWR -tWM- -D_NO_VCL -D_RTLDLL -O2 -w-inl -w-aus -w-rch -w-8012 -w-8057 -w-8037 -DSTRICT; -I$(BCROOT)\include;../../../ -L$(BCROOT)\lib;$(BCROOT)\lib\release; $(CXXFLAGS) -obcb4\bcb4re300l\cpp_regex_traits.obj ../src/cpp_regex_traits.cpp
|
bcb4\bcb4re300l\cregex.obj: ../src/cregex.cpp $(ALL_HEADER)
bcc32 @&&|
-c $(INCLUDES) -DBOOST_RE_BUILD_DLL -tWD -tWR -tWM- -D_NO_VCL -D_RTLDLL -O2 -w-inl -w-aus -w-rch -w-8012 -w-8057 -w-8037 -DSTRICT; -I$(BCROOT)\include;../../../ -L$(BCROOT)\lib;$(BCROOT)\lib\release; $(CXXFLAGS) -obcb4\bcb4re300l\cregex.obj ../src/cregex.cpp
|
bcb4\bcb4re300l\fileiter.obj: ../src/fileiter.cpp $(ALL_HEADER)
bcc32 @&&|
-c $(INCLUDES) -DBOOST_RE_BUILD_DLL -tWD -tWR -tWM- -D_NO_VCL -D_RTLDLL -O2 -w-inl -w-aus -w-rch -w-8012 -w-8057 -w-8037 -DSTRICT; -I$(BCROOT)\include;../../../ -L$(BCROOT)\lib;$(BCROOT)\lib\release; $(CXXFLAGS) -obcb4\bcb4re300l\fileiter.obj ../src/fileiter.cpp
|
bcb4\bcb4re300l\posix_api.obj: ../src/posix_api.cpp $(ALL_HEADER)
bcc32 @&&|
-c $(INCLUDES) -DBOOST_RE_BUILD_DLL -tWD -tWR -tWM- -D_NO_VCL -D_RTLDLL -O2 -w-inl -w-aus -w-rch -w-8012 -w-8057 -w-8037 -DSTRICT; -I$(BCROOT)\include;../../../ -L$(BCROOT)\lib;$(BCROOT)\lib\release; $(CXXFLAGS) -obcb4\bcb4re300l\posix_api.obj ../src/posix_api.cpp
|
bcb4\bcb4re300l\regex.obj: ../src/regex.cpp $(ALL_HEADER)
bcc32 @&&|
-c $(INCLUDES) -DBOOST_RE_BUILD_DLL -tWD -tWR -tWM- -D_NO_VCL -D_RTLDLL -O2 -w-inl -w-aus -w-rch -w-8012 -w-8057 -w-8037 -DSTRICT; -I$(BCROOT)\include;../../../ -L$(BCROOT)\lib;$(BCROOT)\lib\release; $(CXXFLAGS) -obcb4\bcb4re300l\regex.obj ../src/regex.cpp
|
bcb4\bcb4re300l\regex_debug.obj: ../src/regex_debug.cpp $(ALL_HEADER)
bcc32 @&&|
-c $(INCLUDES) -DBOOST_RE_BUILD_DLL -tWD -tWR -tWM- -D_NO_VCL -D_RTLDLL -O2 -w-inl -w-aus -w-rch -w-8012 -w-8057 -w-8037 -DSTRICT; -I$(BCROOT)\include;../../../ -L$(BCROOT)\lib;$(BCROOT)\lib\release; $(CXXFLAGS) -obcb4\bcb4re300l\regex_debug.obj ../src/regex_debug.cpp
|
bcb4\bcb4re300l\regex_synch.obj: ../src/regex_synch.cpp $(ALL_HEADER)
bcc32 @&&|
-c $(INCLUDES) -DBOOST_RE_BUILD_DLL -tWD -tWR -tWM- -D_NO_VCL -D_RTLDLL -O2 -w-inl -w-aus -w-rch -w-8012 -w-8057 -w-8037 -DSTRICT; -I$(BCROOT)\include;../../../ -L$(BCROOT)\lib;$(BCROOT)\lib\release; $(CXXFLAGS) -obcb4\bcb4re300l\regex_synch.obj ../src/regex_synch.cpp
|
bcb4\bcb4re300l\w32_regex_traits.obj: ../src/w32_regex_traits.cpp $(ALL_HEADER)
bcc32 @&&|
-c $(INCLUDES) -DBOOST_RE_BUILD_DLL -tWD -tWR -tWM- -D_NO_VCL -D_RTLDLL -O2 -w-inl -w-aus -w-rch -w-8012 -w-8057 -w-8037 -DSTRICT; -I$(BCROOT)\include;../../../ -L$(BCROOT)\lib;$(BCROOT)\lib\release; $(CXXFLAGS) -obcb4\bcb4re300l\w32_regex_traits.obj ../src/w32_regex_traits.cpp
|
bcb4\bcb4re300l\wide_posix_api.obj: ../src/wide_posix_api.cpp $(ALL_HEADER)
bcc32 @&&|
-c $(INCLUDES) -DBOOST_RE_BUILD_DLL -tWD -tWR -tWM- -D_NO_VCL -D_RTLDLL -O2 -w-inl -w-aus -w-rch -w-8012 -w-8057 -w-8037 -DSTRICT; -I$(BCROOT)\include;../../../ -L$(BCROOT)\lib;$(BCROOT)\lib\release; $(CXXFLAGS) -obcb4\bcb4re300l\wide_posix_api.obj ../src/wide_posix_api.cpp
|
bcb4\bcb4re300l :
-mkdir bcb4\bcb4re300l
bcb4re300l_clean :
del bcb4\bcb4re300l\*.obj
del bcb4\bcb4re300l\*.il?
del bcb4\bcb4re300l\*.csm
del bcb4\bcb4re300l\*.tds
del bcb4\*.tds
bcb4\bcb4re300l.lib : bcb4\bcb4re300l\c_regex_traits.obj bcb4\bcb4re300l\c_regex_traits_common.obj bcb4\bcb4re300l\cpp_regex_traits.obj bcb4\bcb4re300l\cregex.obj bcb4\bcb4re300l\fileiter.obj bcb4\bcb4re300l\posix_api.obj bcb4\bcb4re300l\regex.obj bcb4\bcb4re300l\regex_debug.obj bcb4\bcb4re300l\regex_synch.obj bcb4\bcb4re300l\w32_regex_traits.obj bcb4\bcb4re300l\wide_posix_api.obj
bcc32 @&&|
-DBOOST_RE_BUILD_DLL -tWD -tWR -tWM- -D_NO_VCL -D_RTLDLL -O2 -w-inl -w-aus -w-rch -w-8012 -w-8057 -w-8037 -DSTRICT; -I$(BCROOT)\include;../../../ -L$(BCROOT)\lib;$(BCROOT)\lib\release; -ebcb4\bcb4re300l.dll $(XLFLAGS) bcb4\bcb4re300l\c_regex_traits.obj bcb4\bcb4re300l\c_regex_traits_common.obj bcb4\bcb4re300l\cpp_regex_traits.obj bcb4\bcb4re300l\cregex.obj bcb4\bcb4re300l\fileiter.obj bcb4\bcb4re300l\posix_api.obj bcb4\bcb4re300l\regex.obj bcb4\bcb4re300l\regex_debug.obj bcb4\bcb4re300l\regex_synch.obj bcb4\bcb4re300l\w32_regex_traits.obj bcb4\bcb4re300l\wide_posix_api.obj $(LIBS)
|
implib -c bcb4\bcb4re300l.lib bcb4\bcb4re300l.dll

View File

@ -1,508 +0,0 @@
#
# auto generated makefile for C++ Builder
#
# usage:
# make
# brings libraries up to date
# make install
# brings libraries up to date and copies binaries to your C++ Builder /lib and /bin directories (recomended)
# make clean
# removes all temporary files.
#
# Add additional compiler options here:
#
CXXFLAGS=
#
# Add additional include directories here:
#
INCLUDES=
#
# add additional linker flags here:
#
XLFLAGS=
#
# add additional libraries to link to here:
#
LIBS=
#
# add additional static-library creation flags here:
#
XSFLAGS=
!ifndef BCROOT
BCROOT=$(MAKEDIR)\..
!endif
ALL_HEADER=../../../boost/cregex.hpp ../../../boost/regex/pattern_except.hpp ../../../boost/regex.hpp ../../../boost/regex/regex_traits.hpp ../../../boost/regex/detail/fileiter.hpp ../../../boost/regex/detail/regex_compile.hpp ../../../boost/regex/detail/regex_config.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_options.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 : bcb5 bcb5\bcb5re300 bcb5\bcb5re300.lib bcb5\bcb5re300m bcb5\bcb5re300m.lib bcb5\bcb5re300v bcb5\bcb5re300v.lib bcb5\bcb5re300lv bcb5\bcb5re300lv.lib bcb5\bcb5re300lm bcb5\bcb5re300lm.lib bcb5\bcb5re300l bcb5\bcb5re300l.lib
clean : bcb5re300_clean bcb5re300m_clean bcb5re300v_clean bcb5re300lv_clean bcb5re300lm_clean bcb5re300l_clean
install : all
copy bcb5\bcb5re300.lib $(BCROOT)\lib
copy bcb5\bcb5re300m.lib $(BCROOT)\lib
copy bcb5\bcb5re300v.lib $(BCROOT)\lib
copy bcb5\bcb5re300lv.lib $(BCROOT)\lib
copy bcb5\bcb5re300lv.dll $(BCROOT)\bin
copy bcb5\bcb5re300lm.lib $(BCROOT)\lib
copy bcb5\bcb5re300lm.dll $(BCROOT)\bin
copy bcb5\bcb5re300l.lib $(BCROOT)\lib
copy bcb5\bcb5re300l.dll $(BCROOT)\bin
bcb5 :
-mkdir bcb5
########################################################
#
# section for bcb5re300.lib
#
########################################################
bcb5\bcb5re300\c_regex_traits.obj: ../src/c_regex_traits.cpp $(ALL_HEADER)
bcc32 @&&|
-c $(INCLUDES) -tWM- -D_NO_VCL -O2 -w-inl -w-aus -w-rch -w-8012 -w-8037 -w-8057 -DSTRICT; -I$(BCROOT)\include;../../../ $(CXXFLAGS) -obcb5\bcb5re300\c_regex_traits.obj ../src/c_regex_traits.cpp
|
bcb5\bcb5re300\c_regex_traits_common.obj: ../src/c_regex_traits_common.cpp $(ALL_HEADER)
bcc32 @&&|
-c $(INCLUDES) -tWM- -D_NO_VCL -O2 -w-inl -w-aus -w-rch -w-8012 -w-8037 -w-8057 -DSTRICT; -I$(BCROOT)\include;../../../ $(CXXFLAGS) -obcb5\bcb5re300\c_regex_traits_common.obj ../src/c_regex_traits_common.cpp
|
bcb5\bcb5re300\cpp_regex_traits.obj: ../src/cpp_regex_traits.cpp $(ALL_HEADER)
bcc32 @&&|
-c $(INCLUDES) -tWM- -D_NO_VCL -O2 -w-inl -w-aus -w-rch -w-8012 -w-8037 -w-8057 -DSTRICT; -I$(BCROOT)\include;../../../ $(CXXFLAGS) -obcb5\bcb5re300\cpp_regex_traits.obj ../src/cpp_regex_traits.cpp
|
bcb5\bcb5re300\cregex.obj: ../src/cregex.cpp $(ALL_HEADER)
bcc32 @&&|
-c $(INCLUDES) -tWM- -D_NO_VCL -O2 -w-inl -w-aus -w-rch -w-8012 -w-8037 -w-8057 -DSTRICT; -I$(BCROOT)\include;../../../ $(CXXFLAGS) -obcb5\bcb5re300\cregex.obj ../src/cregex.cpp
|
bcb5\bcb5re300\fileiter.obj: ../src/fileiter.cpp $(ALL_HEADER)
bcc32 @&&|
-c $(INCLUDES) -tWM- -D_NO_VCL -O2 -w-inl -w-aus -w-rch -w-8012 -w-8037 -w-8057 -DSTRICT; -I$(BCROOT)\include;../../../ $(CXXFLAGS) -obcb5\bcb5re300\fileiter.obj ../src/fileiter.cpp
|
bcb5\bcb5re300\posix_api.obj: ../src/posix_api.cpp $(ALL_HEADER)
bcc32 @&&|
-c $(INCLUDES) -tWM- -D_NO_VCL -O2 -w-inl -w-aus -w-rch -w-8012 -w-8037 -w-8057 -DSTRICT; -I$(BCROOT)\include;../../../ $(CXXFLAGS) -obcb5\bcb5re300\posix_api.obj ../src/posix_api.cpp
|
bcb5\bcb5re300\regex.obj: ../src/regex.cpp $(ALL_HEADER)
bcc32 @&&|
-c $(INCLUDES) -tWM- -D_NO_VCL -O2 -w-inl -w-aus -w-rch -w-8012 -w-8037 -w-8057 -DSTRICT; -I$(BCROOT)\include;../../../ $(CXXFLAGS) -obcb5\bcb5re300\regex.obj ../src/regex.cpp
|
bcb5\bcb5re300\regex_debug.obj: ../src/regex_debug.cpp $(ALL_HEADER)
bcc32 @&&|
-c $(INCLUDES) -tWM- -D_NO_VCL -O2 -w-inl -w-aus -w-rch -w-8012 -w-8037 -w-8057 -DSTRICT; -I$(BCROOT)\include;../../../ $(CXXFLAGS) -obcb5\bcb5re300\regex_debug.obj ../src/regex_debug.cpp
|
bcb5\bcb5re300\regex_synch.obj: ../src/regex_synch.cpp $(ALL_HEADER)
bcc32 @&&|
-c $(INCLUDES) -tWM- -D_NO_VCL -O2 -w-inl -w-aus -w-rch -w-8012 -w-8037 -w-8057 -DSTRICT; -I$(BCROOT)\include;../../../ $(CXXFLAGS) -obcb5\bcb5re300\regex_synch.obj ../src/regex_synch.cpp
|
bcb5\bcb5re300\w32_regex_traits.obj: ../src/w32_regex_traits.cpp $(ALL_HEADER)
bcc32 @&&|
-c $(INCLUDES) -tWM- -D_NO_VCL -O2 -w-inl -w-aus -w-rch -w-8012 -w-8037 -w-8057 -DSTRICT; -I$(BCROOT)\include;../../../ $(CXXFLAGS) -obcb5\bcb5re300\w32_regex_traits.obj ../src/w32_regex_traits.cpp
|
bcb5\bcb5re300\wide_posix_api.obj: ../src/wide_posix_api.cpp $(ALL_HEADER)
bcc32 @&&|
-c $(INCLUDES) -tWM- -D_NO_VCL -O2 -w-inl -w-aus -w-rch -w-8012 -w-8037 -w-8057 -DSTRICT; -I$(BCROOT)\include;../../../ $(CXXFLAGS) -obcb5\bcb5re300\wide_posix_api.obj ../src/wide_posix_api.cpp
|
bcb5\bcb5re300 :
-mkdir bcb5\bcb5re300
bcb5re300_clean :
del bcb5\bcb5re300\*.obj
del bcb5\bcb5re300\*.il?
del bcb5\bcb5re300\*.csm
del bcb5\bcb5re300\*.tds
bcb5\bcb5re300.lib : bcb5\bcb5re300\c_regex_traits.obj bcb5\bcb5re300\c_regex_traits_common.obj bcb5\bcb5re300\cpp_regex_traits.obj bcb5\bcb5re300\cregex.obj bcb5\bcb5re300\fileiter.obj bcb5\bcb5re300\posix_api.obj bcb5\bcb5re300\regex.obj bcb5\bcb5re300\regex_debug.obj bcb5\bcb5re300\regex_synch.obj bcb5\bcb5re300\w32_regex_traits.obj bcb5\bcb5re300\wide_posix_api.obj
tlib @&&|
/P32 /C /u /a $(XSFLAGS) bcb5\bcb5re300.lib +bcb5\bcb5re300\c_regex_traits.obj +bcb5\bcb5re300\c_regex_traits_common.obj +bcb5\bcb5re300\cpp_regex_traits.obj +bcb5\bcb5re300\cregex.obj +bcb5\bcb5re300\fileiter.obj +bcb5\bcb5re300\posix_api.obj +bcb5\bcb5re300\regex.obj +bcb5\bcb5re300\regex_debug.obj +bcb5\bcb5re300\regex_synch.obj +bcb5\bcb5re300\w32_regex_traits.obj +bcb5\bcb5re300\wide_posix_api.obj
|
########################################################
#
# section for bcb5re300m.lib
#
########################################################
bcb5\bcb5re300m\c_regex_traits.obj: ../src/c_regex_traits.cpp $(ALL_HEADER)
bcc32 @&&|
-c $(INCLUDES) -tWM -D_NO_VCL -O2 -w-inl -w-aus -w-rch -w-8012 -w-8057 -w-8037 -DSTRICT; -I$(BCROOT)\include;../../../ $(CXXFLAGS) -obcb5\bcb5re300m\c_regex_traits.obj ../src/c_regex_traits.cpp
|
bcb5\bcb5re300m\c_regex_traits_common.obj: ../src/c_regex_traits_common.cpp $(ALL_HEADER)
bcc32 @&&|
-c $(INCLUDES) -tWM -D_NO_VCL -O2 -w-inl -w-aus -w-rch -w-8012 -w-8057 -w-8037 -DSTRICT; -I$(BCROOT)\include;../../../ $(CXXFLAGS) -obcb5\bcb5re300m\c_regex_traits_common.obj ../src/c_regex_traits_common.cpp
|
bcb5\bcb5re300m\cpp_regex_traits.obj: ../src/cpp_regex_traits.cpp $(ALL_HEADER)
bcc32 @&&|
-c $(INCLUDES) -tWM -D_NO_VCL -O2 -w-inl -w-aus -w-rch -w-8012 -w-8057 -w-8037 -DSTRICT; -I$(BCROOT)\include;../../../ $(CXXFLAGS) -obcb5\bcb5re300m\cpp_regex_traits.obj ../src/cpp_regex_traits.cpp
|
bcb5\bcb5re300m\cregex.obj: ../src/cregex.cpp $(ALL_HEADER)
bcc32 @&&|
-c $(INCLUDES) -tWM -D_NO_VCL -O2 -w-inl -w-aus -w-rch -w-8012 -w-8057 -w-8037 -DSTRICT; -I$(BCROOT)\include;../../../ $(CXXFLAGS) -obcb5\bcb5re300m\cregex.obj ../src/cregex.cpp
|
bcb5\bcb5re300m\fileiter.obj: ../src/fileiter.cpp $(ALL_HEADER)
bcc32 @&&|
-c $(INCLUDES) -tWM -D_NO_VCL -O2 -w-inl -w-aus -w-rch -w-8012 -w-8057 -w-8037 -DSTRICT; -I$(BCROOT)\include;../../../ $(CXXFLAGS) -obcb5\bcb5re300m\fileiter.obj ../src/fileiter.cpp
|
bcb5\bcb5re300m\posix_api.obj: ../src/posix_api.cpp $(ALL_HEADER)
bcc32 @&&|
-c $(INCLUDES) -tWM -D_NO_VCL -O2 -w-inl -w-aus -w-rch -w-8012 -w-8057 -w-8037 -DSTRICT; -I$(BCROOT)\include;../../../ $(CXXFLAGS) -obcb5\bcb5re300m\posix_api.obj ../src/posix_api.cpp
|
bcb5\bcb5re300m\regex.obj: ../src/regex.cpp $(ALL_HEADER)
bcc32 @&&|
-c $(INCLUDES) -tWM -D_NO_VCL -O2 -w-inl -w-aus -w-rch -w-8012 -w-8057 -w-8037 -DSTRICT; -I$(BCROOT)\include;../../../ $(CXXFLAGS) -obcb5\bcb5re300m\regex.obj ../src/regex.cpp
|
bcb5\bcb5re300m\regex_debug.obj: ../src/regex_debug.cpp $(ALL_HEADER)
bcc32 @&&|
-c $(INCLUDES) -tWM -D_NO_VCL -O2 -w-inl -w-aus -w-rch -w-8012 -w-8057 -w-8037 -DSTRICT; -I$(BCROOT)\include;../../../ $(CXXFLAGS) -obcb5\bcb5re300m\regex_debug.obj ../src/regex_debug.cpp
|
bcb5\bcb5re300m\regex_synch.obj: ../src/regex_synch.cpp $(ALL_HEADER)
bcc32 @&&|
-c $(INCLUDES) -tWM -D_NO_VCL -O2 -w-inl -w-aus -w-rch -w-8012 -w-8057 -w-8037 -DSTRICT; -I$(BCROOT)\include;../../../ $(CXXFLAGS) -obcb5\bcb5re300m\regex_synch.obj ../src/regex_synch.cpp
|
bcb5\bcb5re300m\w32_regex_traits.obj: ../src/w32_regex_traits.cpp $(ALL_HEADER)
bcc32 @&&|
-c $(INCLUDES) -tWM -D_NO_VCL -O2 -w-inl -w-aus -w-rch -w-8012 -w-8057 -w-8037 -DSTRICT; -I$(BCROOT)\include;../../../ $(CXXFLAGS) -obcb5\bcb5re300m\w32_regex_traits.obj ../src/w32_regex_traits.cpp
|
bcb5\bcb5re300m\wide_posix_api.obj: ../src/wide_posix_api.cpp $(ALL_HEADER)
bcc32 @&&|
-c $(INCLUDES) -tWM -D_NO_VCL -O2 -w-inl -w-aus -w-rch -w-8012 -w-8057 -w-8037 -DSTRICT; -I$(BCROOT)\include;../../../ $(CXXFLAGS) -obcb5\bcb5re300m\wide_posix_api.obj ../src/wide_posix_api.cpp
|
bcb5\bcb5re300m :
-mkdir bcb5\bcb5re300m
bcb5re300m_clean :
del bcb5\bcb5re300m\*.obj
del bcb5\bcb5re300m\*.il?
del bcb5\bcb5re300m\*.csm
del bcb5\bcb5re300m\*.tds
bcb5\bcb5re300m.lib : bcb5\bcb5re300m\c_regex_traits.obj bcb5\bcb5re300m\c_regex_traits_common.obj bcb5\bcb5re300m\cpp_regex_traits.obj bcb5\bcb5re300m\cregex.obj bcb5\bcb5re300m\fileiter.obj bcb5\bcb5re300m\posix_api.obj bcb5\bcb5re300m\regex.obj bcb5\bcb5re300m\regex_debug.obj bcb5\bcb5re300m\regex_synch.obj bcb5\bcb5re300m\w32_regex_traits.obj bcb5\bcb5re300m\wide_posix_api.obj
tlib @&&|
/P32 /C /u /a $(XSFLAGS) bcb5\bcb5re300m.lib +bcb5\bcb5re300m\c_regex_traits.obj +bcb5\bcb5re300m\c_regex_traits_common.obj +bcb5\bcb5re300m\cpp_regex_traits.obj +bcb5\bcb5re300m\cregex.obj +bcb5\bcb5re300m\fileiter.obj +bcb5\bcb5re300m\posix_api.obj +bcb5\bcb5re300m\regex.obj +bcb5\bcb5re300m\regex_debug.obj +bcb5\bcb5re300m\regex_synch.obj +bcb5\bcb5re300m\w32_regex_traits.obj +bcb5\bcb5re300m\wide_posix_api.obj
|
########################################################
#
# section for bcb5re300v.lib
#
########################################################
bcb5\bcb5re300v\c_regex_traits.obj: ../src/c_regex_traits.cpp $(ALL_HEADER)
bcc32 @&&|
-c $(INCLUDES) -tWM -tWV -DJM_USE_VCL -O2 -w-inl -w-aus -w-rch -w-8012 -w-8037 -w-8057 -DSTRICT; -I$(BCROOT)\include;../../../ $(CXXFLAGS) -obcb5\bcb5re300v\c_regex_traits.obj ../src/c_regex_traits.cpp
|
bcb5\bcb5re300v\c_regex_traits_common.obj: ../src/c_regex_traits_common.cpp $(ALL_HEADER)
bcc32 @&&|
-c $(INCLUDES) -tWM -tWV -DJM_USE_VCL -O2 -w-inl -w-aus -w-rch -w-8012 -w-8037 -w-8057 -DSTRICT; -I$(BCROOT)\include;../../../ $(CXXFLAGS) -obcb5\bcb5re300v\c_regex_traits_common.obj ../src/c_regex_traits_common.cpp
|
bcb5\bcb5re300v\cpp_regex_traits.obj: ../src/cpp_regex_traits.cpp $(ALL_HEADER)
bcc32 @&&|
-c $(INCLUDES) -tWM -tWV -DJM_USE_VCL -O2 -w-inl -w-aus -w-rch -w-8012 -w-8037 -w-8057 -DSTRICT; -I$(BCROOT)\include;../../../ $(CXXFLAGS) -obcb5\bcb5re300v\cpp_regex_traits.obj ../src/cpp_regex_traits.cpp
|
bcb5\bcb5re300v\cregex.obj: ../src/cregex.cpp $(ALL_HEADER)
bcc32 @&&|
-c $(INCLUDES) -tWM -tWV -DJM_USE_VCL -O2 -w-inl -w-aus -w-rch -w-8012 -w-8037 -w-8057 -DSTRICT; -I$(BCROOT)\include;../../../ $(CXXFLAGS) -obcb5\bcb5re300v\cregex.obj ../src/cregex.cpp
|
bcb5\bcb5re300v\fileiter.obj: ../src/fileiter.cpp $(ALL_HEADER)
bcc32 @&&|
-c $(INCLUDES) -tWM -tWV -DJM_USE_VCL -O2 -w-inl -w-aus -w-rch -w-8012 -w-8037 -w-8057 -DSTRICT; -I$(BCROOT)\include;../../../ $(CXXFLAGS) -obcb5\bcb5re300v\fileiter.obj ../src/fileiter.cpp
|
bcb5\bcb5re300v\posix_api.obj: ../src/posix_api.cpp $(ALL_HEADER)
bcc32 @&&|
-c $(INCLUDES) -tWM -tWV -DJM_USE_VCL -O2 -w-inl -w-aus -w-rch -w-8012 -w-8037 -w-8057 -DSTRICT; -I$(BCROOT)\include;../../../ $(CXXFLAGS) -obcb5\bcb5re300v\posix_api.obj ../src/posix_api.cpp
|
bcb5\bcb5re300v\regex.obj: ../src/regex.cpp $(ALL_HEADER)
bcc32 @&&|
-c $(INCLUDES) -tWM -tWV -DJM_USE_VCL -O2 -w-inl -w-aus -w-rch -w-8012 -w-8037 -w-8057 -DSTRICT; -I$(BCROOT)\include;../../../ $(CXXFLAGS) -obcb5\bcb5re300v\regex.obj ../src/regex.cpp
|
bcb5\bcb5re300v\regex_debug.obj: ../src/regex_debug.cpp $(ALL_HEADER)
bcc32 @&&|
-c $(INCLUDES) -tWM -tWV -DJM_USE_VCL -O2 -w-inl -w-aus -w-rch -w-8012 -w-8037 -w-8057 -DSTRICT; -I$(BCROOT)\include;../../../ $(CXXFLAGS) -obcb5\bcb5re300v\regex_debug.obj ../src/regex_debug.cpp
|
bcb5\bcb5re300v\regex_synch.obj: ../src/regex_synch.cpp $(ALL_HEADER)
bcc32 @&&|
-c $(INCLUDES) -tWM -tWV -DJM_USE_VCL -O2 -w-inl -w-aus -w-rch -w-8012 -w-8037 -w-8057 -DSTRICT; -I$(BCROOT)\include;../../../ $(CXXFLAGS) -obcb5\bcb5re300v\regex_synch.obj ../src/regex_synch.cpp
|
bcb5\bcb5re300v\w32_regex_traits.obj: ../src/w32_regex_traits.cpp $(ALL_HEADER)
bcc32 @&&|
-c $(INCLUDES) -tWM -tWV -DJM_USE_VCL -O2 -w-inl -w-aus -w-rch -w-8012 -w-8037 -w-8057 -DSTRICT; -I$(BCROOT)\include;../../../ $(CXXFLAGS) -obcb5\bcb5re300v\w32_regex_traits.obj ../src/w32_regex_traits.cpp
|
bcb5\bcb5re300v\wide_posix_api.obj: ../src/wide_posix_api.cpp $(ALL_HEADER)
bcc32 @&&|
-c $(INCLUDES) -tWM -tWV -DJM_USE_VCL -O2 -w-inl -w-aus -w-rch -w-8012 -w-8037 -w-8057 -DSTRICT; -I$(BCROOT)\include;../../../ $(CXXFLAGS) -obcb5\bcb5re300v\wide_posix_api.obj ../src/wide_posix_api.cpp
|
bcb5\bcb5re300v :
-mkdir bcb5\bcb5re300v
bcb5re300v_clean :
del bcb5\bcb5re300v\*.obj
del bcb5\bcb5re300v\*.il?
del bcb5\bcb5re300v\*.csm
del bcb5\bcb5re300v\*.tds
bcb5\bcb5re300v.lib : bcb5\bcb5re300v\c_regex_traits.obj bcb5\bcb5re300v\c_regex_traits_common.obj bcb5\bcb5re300v\cpp_regex_traits.obj bcb5\bcb5re300v\cregex.obj bcb5\bcb5re300v\fileiter.obj bcb5\bcb5re300v\posix_api.obj bcb5\bcb5re300v\regex.obj bcb5\bcb5re300v\regex_debug.obj bcb5\bcb5re300v\regex_synch.obj bcb5\bcb5re300v\w32_regex_traits.obj bcb5\bcb5re300v\wide_posix_api.obj
tlib @&&|
/P32 /C /u /a $(XSFLAGS) bcb5\bcb5re300v.lib +bcb5\bcb5re300v\c_regex_traits.obj +bcb5\bcb5re300v\c_regex_traits_common.obj +bcb5\bcb5re300v\cpp_regex_traits.obj +bcb5\bcb5re300v\cregex.obj +bcb5\bcb5re300v\fileiter.obj +bcb5\bcb5re300v\posix_api.obj +bcb5\bcb5re300v\regex.obj +bcb5\bcb5re300v\regex_debug.obj +bcb5\bcb5re300v\regex_synch.obj +bcb5\bcb5re300v\w32_regex_traits.obj +bcb5\bcb5re300v\wide_posix_api.obj
|
########################################################
#
# section for bcb5re300lv.lib
#
########################################################
bcb5\bcb5re300lv\c_regex_traits.obj: ../src/c_regex_traits.cpp $(ALL_HEADER)
bcc32 @&&|
-c $(INCLUDES) -DBOOST_RE_BUILD_DLL -tWD -tWM -tWR -tWV -DJM_USE_VCL -D_RTLDLL -O2 -w-inl -w-aus -w-rch -w-8012 -w-8037 -w-8057 -DSTRICT; -I$(BCROOT)\include;../../../ -L$(BCROOT)\lib;$(BCROOT)\lib\release; $(CXXFLAGS) -obcb5\bcb5re300lv\c_regex_traits.obj ../src/c_regex_traits.cpp
|
bcb5\bcb5re300lv\c_regex_traits_common.obj: ../src/c_regex_traits_common.cpp $(ALL_HEADER)
bcc32 @&&|
-c $(INCLUDES) -DBOOST_RE_BUILD_DLL -tWD -tWM -tWR -tWV -DJM_USE_VCL -D_RTLDLL -O2 -w-inl -w-aus -w-rch -w-8012 -w-8037 -w-8057 -DSTRICT; -I$(BCROOT)\include;../../../ -L$(BCROOT)\lib;$(BCROOT)\lib\release; $(CXXFLAGS) -obcb5\bcb5re300lv\c_regex_traits_common.obj ../src/c_regex_traits_common.cpp
|
bcb5\bcb5re300lv\cpp_regex_traits.obj: ../src/cpp_regex_traits.cpp $(ALL_HEADER)
bcc32 @&&|
-c $(INCLUDES) -DBOOST_RE_BUILD_DLL -tWD -tWM -tWR -tWV -DJM_USE_VCL -D_RTLDLL -O2 -w-inl -w-aus -w-rch -w-8012 -w-8037 -w-8057 -DSTRICT; -I$(BCROOT)\include;../../../ -L$(BCROOT)\lib;$(BCROOT)\lib\release; $(CXXFLAGS) -obcb5\bcb5re300lv\cpp_regex_traits.obj ../src/cpp_regex_traits.cpp
|
bcb5\bcb5re300lv\cregex.obj: ../src/cregex.cpp $(ALL_HEADER)
bcc32 @&&|
-c $(INCLUDES) -DBOOST_RE_BUILD_DLL -tWD -tWM -tWR -tWV -DJM_USE_VCL -D_RTLDLL -O2 -w-inl -w-aus -w-rch -w-8012 -w-8037 -w-8057 -DSTRICT; -I$(BCROOT)\include;../../../ -L$(BCROOT)\lib;$(BCROOT)\lib\release; $(CXXFLAGS) -obcb5\bcb5re300lv\cregex.obj ../src/cregex.cpp
|
bcb5\bcb5re300lv\fileiter.obj: ../src/fileiter.cpp $(ALL_HEADER)
bcc32 @&&|
-c $(INCLUDES) -DBOOST_RE_BUILD_DLL -tWD -tWM -tWR -tWV -DJM_USE_VCL -D_RTLDLL -O2 -w-inl -w-aus -w-rch -w-8012 -w-8037 -w-8057 -DSTRICT; -I$(BCROOT)\include;../../../ -L$(BCROOT)\lib;$(BCROOT)\lib\release; $(CXXFLAGS) -obcb5\bcb5re300lv\fileiter.obj ../src/fileiter.cpp
|
bcb5\bcb5re300lv\posix_api.obj: ../src/posix_api.cpp $(ALL_HEADER)
bcc32 @&&|
-c $(INCLUDES) -DBOOST_RE_BUILD_DLL -tWD -tWM -tWR -tWV -DJM_USE_VCL -D_RTLDLL -O2 -w-inl -w-aus -w-rch -w-8012 -w-8037 -w-8057 -DSTRICT; -I$(BCROOT)\include;../../../ -L$(BCROOT)\lib;$(BCROOT)\lib\release; $(CXXFLAGS) -obcb5\bcb5re300lv\posix_api.obj ../src/posix_api.cpp
|
bcb5\bcb5re300lv\regex.obj: ../src/regex.cpp $(ALL_HEADER)
bcc32 @&&|
-c $(INCLUDES) -DBOOST_RE_BUILD_DLL -tWD -tWM -tWR -tWV -DJM_USE_VCL -D_RTLDLL -O2 -w-inl -w-aus -w-rch -w-8012 -w-8037 -w-8057 -DSTRICT; -I$(BCROOT)\include;../../../ -L$(BCROOT)\lib;$(BCROOT)\lib\release; $(CXXFLAGS) -obcb5\bcb5re300lv\regex.obj ../src/regex.cpp
|
bcb5\bcb5re300lv\regex_debug.obj: ../src/regex_debug.cpp $(ALL_HEADER)
bcc32 @&&|
-c $(INCLUDES) -DBOOST_RE_BUILD_DLL -tWD -tWM -tWR -tWV -DJM_USE_VCL -D_RTLDLL -O2 -w-inl -w-aus -w-rch -w-8012 -w-8037 -w-8057 -DSTRICT; -I$(BCROOT)\include;../../../ -L$(BCROOT)\lib;$(BCROOT)\lib\release; $(CXXFLAGS) -obcb5\bcb5re300lv\regex_debug.obj ../src/regex_debug.cpp
|
bcb5\bcb5re300lv\regex_synch.obj: ../src/regex_synch.cpp $(ALL_HEADER)
bcc32 @&&|
-c $(INCLUDES) -DBOOST_RE_BUILD_DLL -tWD -tWM -tWR -tWV -DJM_USE_VCL -D_RTLDLL -O2 -w-inl -w-aus -w-rch -w-8012 -w-8037 -w-8057 -DSTRICT; -I$(BCROOT)\include;../../../ -L$(BCROOT)\lib;$(BCROOT)\lib\release; $(CXXFLAGS) -obcb5\bcb5re300lv\regex_synch.obj ../src/regex_synch.cpp
|
bcb5\bcb5re300lv\w32_regex_traits.obj: ../src/w32_regex_traits.cpp $(ALL_HEADER)
bcc32 @&&|
-c $(INCLUDES) -DBOOST_RE_BUILD_DLL -tWD -tWM -tWR -tWV -DJM_USE_VCL -D_RTLDLL -O2 -w-inl -w-aus -w-rch -w-8012 -w-8037 -w-8057 -DSTRICT; -I$(BCROOT)\include;../../../ -L$(BCROOT)\lib;$(BCROOT)\lib\release; $(CXXFLAGS) -obcb5\bcb5re300lv\w32_regex_traits.obj ../src/w32_regex_traits.cpp
|
bcb5\bcb5re300lv\wide_posix_api.obj: ../src/wide_posix_api.cpp $(ALL_HEADER)
bcc32 @&&|
-c $(INCLUDES) -DBOOST_RE_BUILD_DLL -tWD -tWM -tWR -tWV -DJM_USE_VCL -D_RTLDLL -O2 -w-inl -w-aus -w-rch -w-8012 -w-8037 -w-8057 -DSTRICT; -I$(BCROOT)\include;../../../ -L$(BCROOT)\lib;$(BCROOT)\lib\release; $(CXXFLAGS) -obcb5\bcb5re300lv\wide_posix_api.obj ../src/wide_posix_api.cpp
|
bcb5\bcb5re300lv :
-mkdir bcb5\bcb5re300lv
bcb5re300lv_clean :
del bcb5\bcb5re300lv\*.obj
del bcb5\bcb5re300lv\*.il?
del bcb5\bcb5re300lv\*.csm
del bcb5\bcb5re300lv\*.tds
del bcb5\*.tds
bcb5\bcb5re300lv.lib : bcb5\bcb5re300lv\c_regex_traits.obj bcb5\bcb5re300lv\c_regex_traits_common.obj bcb5\bcb5re300lv\cpp_regex_traits.obj bcb5\bcb5re300lv\cregex.obj bcb5\bcb5re300lv\fileiter.obj bcb5\bcb5re300lv\posix_api.obj bcb5\bcb5re300lv\regex.obj bcb5\bcb5re300lv\regex_debug.obj bcb5\bcb5re300lv\regex_synch.obj bcb5\bcb5re300lv\w32_regex_traits.obj bcb5\bcb5re300lv\wide_posix_api.obj
bcc32 @&&|
-DBOOST_RE_BUILD_DLL -tWD -tWM -tWR -tWV -DJM_USE_VCL -D_RTLDLL -O2 -w-inl -w-aus -w-rch -w-8012 -w-8037 -w-8057 -DSTRICT; -I$(BCROOT)\include;../../../ -L$(BCROOT)\lib;$(BCROOT)\lib\release; -ebcb5\bcb5re300lv.dll $(XLFLAGS) bcb5\bcb5re300lv\c_regex_traits.obj bcb5\bcb5re300lv\c_regex_traits_common.obj bcb5\bcb5re300lv\cpp_regex_traits.obj bcb5\bcb5re300lv\cregex.obj bcb5\bcb5re300lv\fileiter.obj bcb5\bcb5re300lv\posix_api.obj bcb5\bcb5re300lv\regex.obj bcb5\bcb5re300lv\regex_debug.obj bcb5\bcb5re300lv\regex_synch.obj bcb5\bcb5re300lv\w32_regex_traits.obj bcb5\bcb5re300lv\wide_posix_api.obj $(LIBS)
|
implib -c bcb5\bcb5re300lv.lib bcb5\bcb5re300lv.dll
########################################################
#
# section for bcb5re300lm.lib
#
########################################################
bcb5\bcb5re300lm\c_regex_traits.obj: ../src/c_regex_traits.cpp $(ALL_HEADER)
bcc32 @&&|
-c $(INCLUDES) -DBOOST_RE_BUILD_DLL -tWD -tWM -tWR -D_NO_VCL -D_RTLDLL -O2 -w-inl -w-aus -w-rch -w-8012 -w-8057 -w-8037 -DSTRICT; -I$(BCROOT)\include;../../../ -L$(BCROOT)\lib;$(BCROOT)\lib\release; $(CXXFLAGS) -obcb5\bcb5re300lm\c_regex_traits.obj ../src/c_regex_traits.cpp
|
bcb5\bcb5re300lm\c_regex_traits_common.obj: ../src/c_regex_traits_common.cpp $(ALL_HEADER)
bcc32 @&&|
-c $(INCLUDES) -DBOOST_RE_BUILD_DLL -tWD -tWM -tWR -D_NO_VCL -D_RTLDLL -O2 -w-inl -w-aus -w-rch -w-8012 -w-8057 -w-8037 -DSTRICT; -I$(BCROOT)\include;../../../ -L$(BCROOT)\lib;$(BCROOT)\lib\release; $(CXXFLAGS) -obcb5\bcb5re300lm\c_regex_traits_common.obj ../src/c_regex_traits_common.cpp
|
bcb5\bcb5re300lm\cpp_regex_traits.obj: ../src/cpp_regex_traits.cpp $(ALL_HEADER)
bcc32 @&&|
-c $(INCLUDES) -DBOOST_RE_BUILD_DLL -tWD -tWM -tWR -D_NO_VCL -D_RTLDLL -O2 -w-inl -w-aus -w-rch -w-8012 -w-8057 -w-8037 -DSTRICT; -I$(BCROOT)\include;../../../ -L$(BCROOT)\lib;$(BCROOT)\lib\release; $(CXXFLAGS) -obcb5\bcb5re300lm\cpp_regex_traits.obj ../src/cpp_regex_traits.cpp
|
bcb5\bcb5re300lm\cregex.obj: ../src/cregex.cpp $(ALL_HEADER)
bcc32 @&&|
-c $(INCLUDES) -DBOOST_RE_BUILD_DLL -tWD -tWM -tWR -D_NO_VCL -D_RTLDLL -O2 -w-inl -w-aus -w-rch -w-8012 -w-8057 -w-8037 -DSTRICT; -I$(BCROOT)\include;../../../ -L$(BCROOT)\lib;$(BCROOT)\lib\release; $(CXXFLAGS) -obcb5\bcb5re300lm\cregex.obj ../src/cregex.cpp
|
bcb5\bcb5re300lm\fileiter.obj: ../src/fileiter.cpp $(ALL_HEADER)
bcc32 @&&|
-c $(INCLUDES) -DBOOST_RE_BUILD_DLL -tWD -tWM -tWR -D_NO_VCL -D_RTLDLL -O2 -w-inl -w-aus -w-rch -w-8012 -w-8057 -w-8037 -DSTRICT; -I$(BCROOT)\include;../../../ -L$(BCROOT)\lib;$(BCROOT)\lib\release; $(CXXFLAGS) -obcb5\bcb5re300lm\fileiter.obj ../src/fileiter.cpp
|
bcb5\bcb5re300lm\posix_api.obj: ../src/posix_api.cpp $(ALL_HEADER)
bcc32 @&&|
-c $(INCLUDES) -DBOOST_RE_BUILD_DLL -tWD -tWM -tWR -D_NO_VCL -D_RTLDLL -O2 -w-inl -w-aus -w-rch -w-8012 -w-8057 -w-8037 -DSTRICT; -I$(BCROOT)\include;../../../ -L$(BCROOT)\lib;$(BCROOT)\lib\release; $(CXXFLAGS) -obcb5\bcb5re300lm\posix_api.obj ../src/posix_api.cpp
|
bcb5\bcb5re300lm\regex.obj: ../src/regex.cpp $(ALL_HEADER)
bcc32 @&&|
-c $(INCLUDES) -DBOOST_RE_BUILD_DLL -tWD -tWM -tWR -D_NO_VCL -D_RTLDLL -O2 -w-inl -w-aus -w-rch -w-8012 -w-8057 -w-8037 -DSTRICT; -I$(BCROOT)\include;../../../ -L$(BCROOT)\lib;$(BCROOT)\lib\release; $(CXXFLAGS) -obcb5\bcb5re300lm\regex.obj ../src/regex.cpp
|
bcb5\bcb5re300lm\regex_debug.obj: ../src/regex_debug.cpp $(ALL_HEADER)
bcc32 @&&|
-c $(INCLUDES) -DBOOST_RE_BUILD_DLL -tWD -tWM -tWR -D_NO_VCL -D_RTLDLL -O2 -w-inl -w-aus -w-rch -w-8012 -w-8057 -w-8037 -DSTRICT; -I$(BCROOT)\include;../../../ -L$(BCROOT)\lib;$(BCROOT)\lib\release; $(CXXFLAGS) -obcb5\bcb5re300lm\regex_debug.obj ../src/regex_debug.cpp
|
bcb5\bcb5re300lm\regex_synch.obj: ../src/regex_synch.cpp $(ALL_HEADER)
bcc32 @&&|
-c $(INCLUDES) -DBOOST_RE_BUILD_DLL -tWD -tWM -tWR -D_NO_VCL -D_RTLDLL -O2 -w-inl -w-aus -w-rch -w-8012 -w-8057 -w-8037 -DSTRICT; -I$(BCROOT)\include;../../../ -L$(BCROOT)\lib;$(BCROOT)\lib\release; $(CXXFLAGS) -obcb5\bcb5re300lm\regex_synch.obj ../src/regex_synch.cpp
|
bcb5\bcb5re300lm\w32_regex_traits.obj: ../src/w32_regex_traits.cpp $(ALL_HEADER)
bcc32 @&&|
-c $(INCLUDES) -DBOOST_RE_BUILD_DLL -tWD -tWM -tWR -D_NO_VCL -D_RTLDLL -O2 -w-inl -w-aus -w-rch -w-8012 -w-8057 -w-8037 -DSTRICT; -I$(BCROOT)\include;../../../ -L$(BCROOT)\lib;$(BCROOT)\lib\release; $(CXXFLAGS) -obcb5\bcb5re300lm\w32_regex_traits.obj ../src/w32_regex_traits.cpp
|
bcb5\bcb5re300lm\wide_posix_api.obj: ../src/wide_posix_api.cpp $(ALL_HEADER)
bcc32 @&&|
-c $(INCLUDES) -DBOOST_RE_BUILD_DLL -tWD -tWM -tWR -D_NO_VCL -D_RTLDLL -O2 -w-inl -w-aus -w-rch -w-8012 -w-8057 -w-8037 -DSTRICT; -I$(BCROOT)\include;../../../ -L$(BCROOT)\lib;$(BCROOT)\lib\release; $(CXXFLAGS) -obcb5\bcb5re300lm\wide_posix_api.obj ../src/wide_posix_api.cpp
|
bcb5\bcb5re300lm :
-mkdir bcb5\bcb5re300lm
bcb5re300lm_clean :
del bcb5\bcb5re300lm\*.obj
del bcb5\bcb5re300lm\*.il?
del bcb5\bcb5re300lm\*.csm
del bcb5\bcb5re300lm\*.tds
del bcb5\*.tds
bcb5\bcb5re300lm.lib : bcb5\bcb5re300lm\c_regex_traits.obj bcb5\bcb5re300lm\c_regex_traits_common.obj bcb5\bcb5re300lm\cpp_regex_traits.obj bcb5\bcb5re300lm\cregex.obj bcb5\bcb5re300lm\fileiter.obj bcb5\bcb5re300lm\posix_api.obj bcb5\bcb5re300lm\regex.obj bcb5\bcb5re300lm\regex_debug.obj bcb5\bcb5re300lm\regex_synch.obj bcb5\bcb5re300lm\w32_regex_traits.obj bcb5\bcb5re300lm\wide_posix_api.obj
bcc32 @&&|
-DBOOST_RE_BUILD_DLL -tWD -tWM -tWR -D_NO_VCL -D_RTLDLL -O2 -w-inl -w-aus -w-rch -w-8012 -w-8057 -w-8037 -DSTRICT; -I$(BCROOT)\include;../../../ -L$(BCROOT)\lib;$(BCROOT)\lib\release; -ebcb5\bcb5re300lm.dll $(XLFLAGS) bcb5\bcb5re300lm\c_regex_traits.obj bcb5\bcb5re300lm\c_regex_traits_common.obj bcb5\bcb5re300lm\cpp_regex_traits.obj bcb5\bcb5re300lm\cregex.obj bcb5\bcb5re300lm\fileiter.obj bcb5\bcb5re300lm\posix_api.obj bcb5\bcb5re300lm\regex.obj bcb5\bcb5re300lm\regex_debug.obj bcb5\bcb5re300lm\regex_synch.obj bcb5\bcb5re300lm\w32_regex_traits.obj bcb5\bcb5re300lm\wide_posix_api.obj $(LIBS)
|
implib -c bcb5\bcb5re300lm.lib bcb5\bcb5re300lm.dll
########################################################
#
# section for bcb5re300l.lib
#
########################################################
bcb5\bcb5re300l\c_regex_traits.obj: ../src/c_regex_traits.cpp $(ALL_HEADER)
bcc32 @&&|
-c $(INCLUDES) -DBOOST_RE_BUILD_DLL -tWD -tWR -tWM- -D_NO_VCL -D_RTLDLL -O2 -w-inl -w-aus -w-rch -w-8012 -w-8057 -w-8037 -DSTRICT; -I$(BCROOT)\include;../../../ -L$(BCROOT)\lib;$(BCROOT)\lib\release; $(CXXFLAGS) -obcb5\bcb5re300l\c_regex_traits.obj ../src/c_regex_traits.cpp
|
bcb5\bcb5re300l\c_regex_traits_common.obj: ../src/c_regex_traits_common.cpp $(ALL_HEADER)
bcc32 @&&|
-c $(INCLUDES) -DBOOST_RE_BUILD_DLL -tWD -tWR -tWM- -D_NO_VCL -D_RTLDLL -O2 -w-inl -w-aus -w-rch -w-8012 -w-8057 -w-8037 -DSTRICT; -I$(BCROOT)\include;../../../ -L$(BCROOT)\lib;$(BCROOT)\lib\release; $(CXXFLAGS) -obcb5\bcb5re300l\c_regex_traits_common.obj ../src/c_regex_traits_common.cpp
|
bcb5\bcb5re300l\cpp_regex_traits.obj: ../src/cpp_regex_traits.cpp $(ALL_HEADER)
bcc32 @&&|
-c $(INCLUDES) -DBOOST_RE_BUILD_DLL -tWD -tWR -tWM- -D_NO_VCL -D_RTLDLL -O2 -w-inl -w-aus -w-rch -w-8012 -w-8057 -w-8037 -DSTRICT; -I$(BCROOT)\include;../../../ -L$(BCROOT)\lib;$(BCROOT)\lib\release; $(CXXFLAGS) -obcb5\bcb5re300l\cpp_regex_traits.obj ../src/cpp_regex_traits.cpp
|
bcb5\bcb5re300l\cregex.obj: ../src/cregex.cpp $(ALL_HEADER)
bcc32 @&&|
-c $(INCLUDES) -DBOOST_RE_BUILD_DLL -tWD -tWR -tWM- -D_NO_VCL -D_RTLDLL -O2 -w-inl -w-aus -w-rch -w-8012 -w-8057 -w-8037 -DSTRICT; -I$(BCROOT)\include;../../../ -L$(BCROOT)\lib;$(BCROOT)\lib\release; $(CXXFLAGS) -obcb5\bcb5re300l\cregex.obj ../src/cregex.cpp
|
bcb5\bcb5re300l\fileiter.obj: ../src/fileiter.cpp $(ALL_HEADER)
bcc32 @&&|
-c $(INCLUDES) -DBOOST_RE_BUILD_DLL -tWD -tWR -tWM- -D_NO_VCL -D_RTLDLL -O2 -w-inl -w-aus -w-rch -w-8012 -w-8057 -w-8037 -DSTRICT; -I$(BCROOT)\include;../../../ -L$(BCROOT)\lib;$(BCROOT)\lib\release; $(CXXFLAGS) -obcb5\bcb5re300l\fileiter.obj ../src/fileiter.cpp
|
bcb5\bcb5re300l\posix_api.obj: ../src/posix_api.cpp $(ALL_HEADER)
bcc32 @&&|
-c $(INCLUDES) -DBOOST_RE_BUILD_DLL -tWD -tWR -tWM- -D_NO_VCL -D_RTLDLL -O2 -w-inl -w-aus -w-rch -w-8012 -w-8057 -w-8037 -DSTRICT; -I$(BCROOT)\include;../../../ -L$(BCROOT)\lib;$(BCROOT)\lib\release; $(CXXFLAGS) -obcb5\bcb5re300l\posix_api.obj ../src/posix_api.cpp
|
bcb5\bcb5re300l\regex.obj: ../src/regex.cpp $(ALL_HEADER)
bcc32 @&&|
-c $(INCLUDES) -DBOOST_RE_BUILD_DLL -tWD -tWR -tWM- -D_NO_VCL -D_RTLDLL -O2 -w-inl -w-aus -w-rch -w-8012 -w-8057 -w-8037 -DSTRICT; -I$(BCROOT)\include;../../../ -L$(BCROOT)\lib;$(BCROOT)\lib\release; $(CXXFLAGS) -obcb5\bcb5re300l\regex.obj ../src/regex.cpp
|
bcb5\bcb5re300l\regex_debug.obj: ../src/regex_debug.cpp $(ALL_HEADER)
bcc32 @&&|
-c $(INCLUDES) -DBOOST_RE_BUILD_DLL -tWD -tWR -tWM- -D_NO_VCL -D_RTLDLL -O2 -w-inl -w-aus -w-rch -w-8012 -w-8057 -w-8037 -DSTRICT; -I$(BCROOT)\include;../../../ -L$(BCROOT)\lib;$(BCROOT)\lib\release; $(CXXFLAGS) -obcb5\bcb5re300l\regex_debug.obj ../src/regex_debug.cpp
|
bcb5\bcb5re300l\regex_synch.obj: ../src/regex_synch.cpp $(ALL_HEADER)
bcc32 @&&|
-c $(INCLUDES) -DBOOST_RE_BUILD_DLL -tWD -tWR -tWM- -D_NO_VCL -D_RTLDLL -O2 -w-inl -w-aus -w-rch -w-8012 -w-8057 -w-8037 -DSTRICT; -I$(BCROOT)\include;../../../ -L$(BCROOT)\lib;$(BCROOT)\lib\release; $(CXXFLAGS) -obcb5\bcb5re300l\regex_synch.obj ../src/regex_synch.cpp
|
bcb5\bcb5re300l\w32_regex_traits.obj: ../src/w32_regex_traits.cpp $(ALL_HEADER)
bcc32 @&&|
-c $(INCLUDES) -DBOOST_RE_BUILD_DLL -tWD -tWR -tWM- -D_NO_VCL -D_RTLDLL -O2 -w-inl -w-aus -w-rch -w-8012 -w-8057 -w-8037 -DSTRICT; -I$(BCROOT)\include;../../../ -L$(BCROOT)\lib;$(BCROOT)\lib\release; $(CXXFLAGS) -obcb5\bcb5re300l\w32_regex_traits.obj ../src/w32_regex_traits.cpp
|
bcb5\bcb5re300l\wide_posix_api.obj: ../src/wide_posix_api.cpp $(ALL_HEADER)
bcc32 @&&|
-c $(INCLUDES) -DBOOST_RE_BUILD_DLL -tWD -tWR -tWM- -D_NO_VCL -D_RTLDLL -O2 -w-inl -w-aus -w-rch -w-8012 -w-8057 -w-8037 -DSTRICT; -I$(BCROOT)\include;../../../ -L$(BCROOT)\lib;$(BCROOT)\lib\release; $(CXXFLAGS) -obcb5\bcb5re300l\wide_posix_api.obj ../src/wide_posix_api.cpp
|
bcb5\bcb5re300l :
-mkdir bcb5\bcb5re300l
bcb5re300l_clean :
del bcb5\bcb5re300l\*.obj
del bcb5\bcb5re300l\*.il?
del bcb5\bcb5re300l\*.csm
del bcb5\bcb5re300l\*.tds
del bcb5\*.tds
bcb5\bcb5re300l.lib : bcb5\bcb5re300l\c_regex_traits.obj bcb5\bcb5re300l\c_regex_traits_common.obj bcb5\bcb5re300l\cpp_regex_traits.obj bcb5\bcb5re300l\cregex.obj bcb5\bcb5re300l\fileiter.obj bcb5\bcb5re300l\posix_api.obj bcb5\bcb5re300l\regex.obj bcb5\bcb5re300l\regex_debug.obj bcb5\bcb5re300l\regex_synch.obj bcb5\bcb5re300l\w32_regex_traits.obj bcb5\bcb5re300l\wide_posix_api.obj
bcc32 @&&|
-DBOOST_RE_BUILD_DLL -tWD -tWR -tWM- -D_NO_VCL -D_RTLDLL -O2 -w-inl -w-aus -w-rch -w-8012 -w-8057 -w-8037 -DSTRICT; -I$(BCROOT)\include;../../../ -L$(BCROOT)\lib;$(BCROOT)\lib\release; -ebcb5\bcb5re300l.dll $(XLFLAGS) bcb5\bcb5re300l\c_regex_traits.obj bcb5\bcb5re300l\c_regex_traits_common.obj bcb5\bcb5re300l\cpp_regex_traits.obj bcb5\bcb5re300l\cregex.obj bcb5\bcb5re300l\fileiter.obj bcb5\bcb5re300l\posix_api.obj bcb5\bcb5re300l\regex.obj bcb5\bcb5re300l\regex_debug.obj bcb5\bcb5re300l\regex_synch.obj bcb5\bcb5re300l\w32_regex_traits.obj bcb5\bcb5re300l\wide_posix_api.obj $(LIBS)
|
implib -c bcb5\bcb5re300l.lib bcb5\bcb5re300l.dll

View File

@ -1,138 +0,0 @@
#
# auto generated makefile for gcc compiler
#
# usage:
# make
# brings libraries up to date
# make clean
# deletes temporary object files (but not archives).
#
#
# the following environment variables are recognised:
# CXXFLAGS= extra compiler options - note applies to all build variants
# INCLUDES= additional include directories
# LDFLAGS= additional linker options
# LIBS= additional library files
# compiler:
CXX=g++
LINKER=g++ -shared
#
# compiler options for release build:
#
C1=-c -O2 -I../../../ -fPIC
#
# compiler options for debug build:
#
C2=-c -g -I../../../ -fPIC
ALL_HEADER=../../../boost/cregex.hpp ../../../boost/regex/pattern_except.hpp ../../../boost/regex.hpp ../../../boost/regex/regex_traits.hpp ../../../boost/regex/detail/fileiter.hpp ../../../boost/regex/detail/regex_compile.hpp ../../../boost/regex/detail/regex_config.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_options.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 : gcc gcc gcc/boost_regex_shared ./gcc/libboost_regex.so gcc gcc/boost_regex_debug_shared ./gcc/libboost_regex_debug.so
gcc :
mkdir -p gcc
clean : boost_regex_clean boost_regex_debug_clean
install : all
########################################################
#
# section for libboost_regex.a
#
########################################################
gcc/boost_regex_shared/c_regex_traits.o: ../src/c_regex_traits.cpp $(ALL_HEADER)
$(CXX) $(INCLUDES) -o gcc/boost_regex_shared/c_regex_traits.o $(C1) $(CXXFLAGS) ../src/c_regex_traits.cpp
gcc/boost_regex_shared/c_regex_traits_common.o: ../src/c_regex_traits_common.cpp $(ALL_HEADER)
$(CXX) $(INCLUDES) -o gcc/boost_regex_shared/c_regex_traits_common.o $(C1) $(CXXFLAGS) ../src/c_regex_traits_common.cpp
gcc/boost_regex_shared/cpp_regex_traits.o: ../src/cpp_regex_traits.cpp $(ALL_HEADER)
$(CXX) $(INCLUDES) -o gcc/boost_regex_shared/cpp_regex_traits.o $(C1) $(CXXFLAGS) ../src/cpp_regex_traits.cpp
gcc/boost_regex_shared/cregex.o: ../src/cregex.cpp $(ALL_HEADER)
$(CXX) $(INCLUDES) -o gcc/boost_regex_shared/cregex.o $(C1) $(CXXFLAGS) ../src/cregex.cpp
gcc/boost_regex_shared/fileiter.o: ../src/fileiter.cpp $(ALL_HEADER)
$(CXX) $(INCLUDES) -o gcc/boost_regex_shared/fileiter.o $(C1) $(CXXFLAGS) ../src/fileiter.cpp
gcc/boost_regex_shared/posix_api.o: ../src/posix_api.cpp $(ALL_HEADER)
$(CXX) $(INCLUDES) -o gcc/boost_regex_shared/posix_api.o $(C1) $(CXXFLAGS) ../src/posix_api.cpp
gcc/boost_regex_shared/regex.o: ../src/regex.cpp $(ALL_HEADER)
$(CXX) $(INCLUDES) -o gcc/boost_regex_shared/regex.o $(C1) $(CXXFLAGS) ../src/regex.cpp
gcc/boost_regex_shared/regex_debug.o: ../src/regex_debug.cpp $(ALL_HEADER)
$(CXX) $(INCLUDES) -o gcc/boost_regex_shared/regex_debug.o $(C1) $(CXXFLAGS) ../src/regex_debug.cpp
gcc/boost_regex_shared/regex_synch.o: ../src/regex_synch.cpp $(ALL_HEADER)
$(CXX) $(INCLUDES) -o gcc/boost_regex_shared/regex_synch.o $(C1) $(CXXFLAGS) ../src/regex_synch.cpp
gcc/boost_regex_shared/w32_regex_traits.o: ../src/w32_regex_traits.cpp $(ALL_HEADER)
$(CXX) $(INCLUDES) -o gcc/boost_regex_shared/w32_regex_traits.o $(C1) $(CXXFLAGS) ../src/w32_regex_traits.cpp
gcc/boost_regex_shared/wide_posix_api.o: ../src/wide_posix_api.cpp $(ALL_HEADER)
$(CXX) $(INCLUDES) -o gcc/boost_regex_shared/wide_posix_api.o $(C1) $(CXXFLAGS) ../src/wide_posix_api.cpp
gcc/boost_regex_shared :
mkdir -p gcc/boost_regex_shared
boost_regex_clean :
rm -f gcc/boost_regex_shared/*.o
./gcc/libboost_regex.so : gcc/boost_regex_shared/c_regex_traits.o gcc/boost_regex_shared/c_regex_traits_common.o gcc/boost_regex_shared/cpp_regex_traits.o gcc/boost_regex_shared/cregex.o gcc/boost_regex_shared/fileiter.o gcc/boost_regex_shared/posix_api.o gcc/boost_regex_shared/regex.o gcc/boost_regex_shared/regex_debug.o gcc/boost_regex_shared/regex_synch.o gcc/boost_regex_shared/w32_regex_traits.o gcc/boost_regex_shared/wide_posix_api.o
$(LINKER) -o gcc/libboost_regex.so $(LDFLAGS) gcc/boost_regex_shared/c_regex_traits.o gcc/boost_regex_shared/c_regex_traits_common.o gcc/boost_regex_shared/cpp_regex_traits.o gcc/boost_regex_shared/cregex.o gcc/boost_regex_shared/fileiter.o gcc/boost_regex_shared/posix_api.o gcc/boost_regex_shared/regex.o gcc/boost_regex_shared/regex_debug.o gcc/boost_regex_shared/regex_synch.o gcc/boost_regex_shared/w32_regex_traits.o gcc/boost_regex_shared/wide_posix_api.o $(LIBS)
########################################################
#
# section for libboost_regex_debug.a
#
########################################################
gcc/boost_regex_debug_shared/c_regex_traits.o: ../src/c_regex_traits.cpp $(ALL_HEADER)
$(CXX) $(INCLUDES) -o gcc/boost_regex_debug_shared/c_regex_traits.o $(C2) $(CXXFLAGS) ../src/c_regex_traits.cpp
gcc/boost_regex_debug_shared/c_regex_traits_common.o: ../src/c_regex_traits_common.cpp $(ALL_HEADER)
$(CXX) $(INCLUDES) -o gcc/boost_regex_debug_shared/c_regex_traits_common.o $(C2) $(CXXFLAGS) ../src/c_regex_traits_common.cpp
gcc/boost_regex_debug_shared/cpp_regex_traits.o: ../src/cpp_regex_traits.cpp $(ALL_HEADER)
$(CXX) $(INCLUDES) -o gcc/boost_regex_debug_shared/cpp_regex_traits.o $(C2) $(CXXFLAGS) ../src/cpp_regex_traits.cpp
gcc/boost_regex_debug_shared/cregex.o: ../src/cregex.cpp $(ALL_HEADER)
$(CXX) $(INCLUDES) -o gcc/boost_regex_debug_shared/cregex.o $(C2) $(CXXFLAGS) ../src/cregex.cpp
gcc/boost_regex_debug_shared/fileiter.o: ../src/fileiter.cpp $(ALL_HEADER)
$(CXX) $(INCLUDES) -o gcc/boost_regex_debug_shared/fileiter.o $(C2) $(CXXFLAGS) ../src/fileiter.cpp
gcc/boost_regex_debug_shared/posix_api.o: ../src/posix_api.cpp $(ALL_HEADER)
$(CXX) $(INCLUDES) -o gcc/boost_regex_debug_shared/posix_api.o $(C2) $(CXXFLAGS) ../src/posix_api.cpp
gcc/boost_regex_debug_shared/regex.o: ../src/regex.cpp $(ALL_HEADER)
$(CXX) $(INCLUDES) -o gcc/boost_regex_debug_shared/regex.o $(C2) $(CXXFLAGS) ../src/regex.cpp
gcc/boost_regex_debug_shared/regex_debug.o: ../src/regex_debug.cpp $(ALL_HEADER)
$(CXX) $(INCLUDES) -o gcc/boost_regex_debug_shared/regex_debug.o $(C2) $(CXXFLAGS) ../src/regex_debug.cpp
gcc/boost_regex_debug_shared/regex_synch.o: ../src/regex_synch.cpp $(ALL_HEADER)
$(CXX) $(INCLUDES) -o gcc/boost_regex_debug_shared/regex_synch.o $(C2) $(CXXFLAGS) ../src/regex_synch.cpp
gcc/boost_regex_debug_shared/w32_regex_traits.o: ../src/w32_regex_traits.cpp $(ALL_HEADER)
$(CXX) $(INCLUDES) -o gcc/boost_regex_debug_shared/w32_regex_traits.o $(C2) $(CXXFLAGS) ../src/w32_regex_traits.cpp
gcc/boost_regex_debug_shared/wide_posix_api.o: ../src/wide_posix_api.cpp $(ALL_HEADER)
$(CXX) $(INCLUDES) -o gcc/boost_regex_debug_shared/wide_posix_api.o $(C2) $(CXXFLAGS) ../src/wide_posix_api.cpp
gcc/boost_regex_debug_shared :
mkdir -p gcc/boost_regex_debug_shared
boost_regex_debug_clean :
rm -f gcc/boost_regex_debug_shared/*.o
./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/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
$(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/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 $(LIBS)

View File

@ -1,139 +0,0 @@
#
# auto generated makefile for gcc compiler
#
# usage:
# make
# brings libraries up to date
# make clean
# deletes temporary object files (but not archives).
#
#
# the following environment variables are recognised:
# CXXFLAGS= extra compiler options - note applies to all build variants
# INCLUDES= additional include directories
# LDFLAGS= additional linker options
# LIBS= additional library files
# compiler:
CXX=g++
LINKER=g++ -shared
#
# compiler options for release build:
#
C1=-c -O2 -I../../../
#
# compiler options for debug build:
#
C2=-c -g -I../../../
ALL_HEADER=../../../boost/cregex.hpp ../../../boost/regex/pattern_except.hpp ../../../boost/regex.hpp ../../../boost/regex/regex_traits.hpp ../../../boost/regex/detail/fileiter.hpp ../../../boost/regex/detail/regex_compile.hpp ../../../boost/regex/detail/regex_config.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_options.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 : gcc gcc gcc/boost_regex ./gcc/libboost_regex.a gcc gcc/boost_regex_debug ./gcc/libboost_regex_debug.a
gcc :
mkdir -p gcc
clean : boost_regex_clean boost_regex_debug_clean
install : all
########################################################
#
# section for libboost_regex.a
#
########################################################
gcc/boost_regex/c_regex_traits.o: ../src/c_regex_traits.cpp $(ALL_HEADER)
$(CXX) $(INCLUDES) -o gcc/boost_regex/c_regex_traits.o $(C1) $(CXXFLAGS) ../src/c_regex_traits.cpp
gcc/boost_regex/c_regex_traits_common.o: ../src/c_regex_traits_common.cpp $(ALL_HEADER)
$(CXX) $(INCLUDES) -o gcc/boost_regex/c_regex_traits_common.o $(C1) $(CXXFLAGS) ../src/c_regex_traits_common.cpp
gcc/boost_regex/cpp_regex_traits.o: ../src/cpp_regex_traits.cpp $(ALL_HEADER)
$(CXX) $(INCLUDES) -o gcc/boost_regex/cpp_regex_traits.o $(C1) $(CXXFLAGS) ../src/cpp_regex_traits.cpp
gcc/boost_regex/cregex.o: ../src/cregex.cpp $(ALL_HEADER)
$(CXX) $(INCLUDES) -o gcc/boost_regex/cregex.o $(C1) $(CXXFLAGS) ../src/cregex.cpp
gcc/boost_regex/fileiter.o: ../src/fileiter.cpp $(ALL_HEADER)
$(CXX) $(INCLUDES) -o gcc/boost_regex/fileiter.o $(C1) $(CXXFLAGS) ../src/fileiter.cpp
gcc/boost_regex/posix_api.o: ../src/posix_api.cpp $(ALL_HEADER)
$(CXX) $(INCLUDES) -o gcc/boost_regex/posix_api.o $(C1) $(CXXFLAGS) ../src/posix_api.cpp
gcc/boost_regex/regex.o: ../src/regex.cpp $(ALL_HEADER)
$(CXX) $(INCLUDES) -o gcc/boost_regex/regex.o $(C1) $(CXXFLAGS) ../src/regex.cpp
gcc/boost_regex/regex_debug.o: ../src/regex_debug.cpp $(ALL_HEADER)
$(CXX) $(INCLUDES) -o gcc/boost_regex/regex_debug.o $(C1) $(CXXFLAGS) ../src/regex_debug.cpp
gcc/boost_regex/regex_synch.o: ../src/regex_synch.cpp $(ALL_HEADER)
$(CXX) $(INCLUDES) -o gcc/boost_regex/regex_synch.o $(C1) $(CXXFLAGS) ../src/regex_synch.cpp
gcc/boost_regex/w32_regex_traits.o: ../src/w32_regex_traits.cpp $(ALL_HEADER)
$(CXX) $(INCLUDES) -o gcc/boost_regex/w32_regex_traits.o $(C1) $(CXXFLAGS) ../src/w32_regex_traits.cpp
gcc/boost_regex/wide_posix_api.o: ../src/wide_posix_api.cpp $(ALL_HEADER)
$(CXX) $(INCLUDES) -o gcc/boost_regex/wide_posix_api.o $(C1) $(CXXFLAGS) ../src/wide_posix_api.cpp
gcc/boost_regex :
mkdir -p gcc/boost_regex
boost_regex_clean :
rm -f gcc/boost_regex/*.o
./gcc/libboost_regex.a : gcc/boost_regex/c_regex_traits.o gcc/boost_regex/c_regex_traits_common.o gcc/boost_regex/cpp_regex_traits.o gcc/boost_regex/cregex.o gcc/boost_regex/fileiter.o gcc/boost_regex/posix_api.o gcc/boost_regex/regex.o gcc/boost_regex/regex_debug.o gcc/boost_regex/regex_synch.o gcc/boost_regex/w32_regex_traits.o gcc/boost_regex/wide_posix_api.o
ar -r gcc/libboost_regex.a gcc/boost_regex/c_regex_traits.o gcc/boost_regex/c_regex_traits_common.o gcc/boost_regex/cpp_regex_traits.o gcc/boost_regex/cregex.o gcc/boost_regex/fileiter.o gcc/boost_regex/posix_api.o gcc/boost_regex/regex.o gcc/boost_regex/regex_debug.o gcc/boost_regex/regex_synch.o gcc/boost_regex/w32_regex_traits.o gcc/boost_regex/wide_posix_api.o
########################################################
#
# section for libboost_regex_debug.a
#
########################################################
gcc/boost_regex_debug/c_regex_traits.o: ../src/c_regex_traits.cpp $(ALL_HEADER)
$(CXX) $(INCLUDES) -o gcc/boost_regex_debug/c_regex_traits.o $(C2) $(CXXFLAGS) ../src/c_regex_traits.cpp
gcc/boost_regex_debug/c_regex_traits_common.o: ../src/c_regex_traits_common.cpp $(ALL_HEADER)
$(CXX) $(INCLUDES) -o gcc/boost_regex_debug/c_regex_traits_common.o $(C2) $(CXXFLAGS) ../src/c_regex_traits_common.cpp
gcc/boost_regex_debug/cpp_regex_traits.o: ../src/cpp_regex_traits.cpp $(ALL_HEADER)
$(CXX) $(INCLUDES) -o gcc/boost_regex_debug/cpp_regex_traits.o $(C2) $(CXXFLAGS) ../src/cpp_regex_traits.cpp
gcc/boost_regex_debug/cregex.o: ../src/cregex.cpp $(ALL_HEADER)
$(CXX) $(INCLUDES) -o gcc/boost_regex_debug/cregex.o $(C2) $(CXXFLAGS) ../src/cregex.cpp
gcc/boost_regex_debug/fileiter.o: ../src/fileiter.cpp $(ALL_HEADER)
$(CXX) $(INCLUDES) -o gcc/boost_regex_debug/fileiter.o $(C2) $(CXXFLAGS) ../src/fileiter.cpp
gcc/boost_regex_debug/posix_api.o: ../src/posix_api.cpp $(ALL_HEADER)
$(CXX) $(INCLUDES) -o gcc/boost_regex_debug/posix_api.o $(C2) $(CXXFLAGS) ../src/posix_api.cpp
gcc/boost_regex_debug/regex.o: ../src/regex.cpp $(ALL_HEADER)
$(CXX) $(INCLUDES) -o gcc/boost_regex_debug/regex.o $(C2) $(CXXFLAGS) ../src/regex.cpp
gcc/boost_regex_debug/regex_debug.o: ../src/regex_debug.cpp $(ALL_HEADER)
$(CXX) $(INCLUDES) -o gcc/boost_regex_debug/regex_debug.o $(C2) $(CXXFLAGS) ../src/regex_debug.cpp
gcc/boost_regex_debug/regex_synch.o: ../src/regex_synch.cpp $(ALL_HEADER)
$(CXX) $(INCLUDES) -o gcc/boost_regex_debug/regex_synch.o $(C2) $(CXXFLAGS) ../src/regex_synch.cpp
gcc/boost_regex_debug/w32_regex_traits.o: ../src/w32_regex_traits.cpp $(ALL_HEADER)
$(CXX) $(INCLUDES) -o gcc/boost_regex_debug/w32_regex_traits.o $(C2) $(CXXFLAGS) ../src/w32_regex_traits.cpp
gcc/boost_regex_debug/wide_posix_api.o: ../src/wide_posix_api.cpp $(ALL_HEADER)
$(CXX) $(INCLUDES) -o gcc/boost_regex_debug/wide_posix_api.o $(C2) $(CXXFLAGS) ../src/wide_posix_api.cpp
gcc/boost_regex_debug :
mkdir -p gcc/boost_regex_debug
boost_regex_debug_clean :
rm -f gcc/boost_regex_debug/*.o
./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/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
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/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

View File

@ -1,88 +0,0 @@
#
# auto generated makefile for generic compiler
#
# usage:
# make
# brings libraries up to date
# make clean
# deletes temporary object files (but not archives).
#
#
# the following environment variables are recognised:
# CXXFLAGS= extra compiler options - note applies to all build variants
# INCLUDES= additional include directories
# LDFLAGS= additional linker options
# LIBS= additional library files
# CXX= compiler to use
# LINKER= linker/archiver to use
# name of subdirectory to use for object/archive files:
DIRNAME=generic
#
# default compiler options for release build:
#
C1=-c -O2 -I../../../
ALL_HEADER=../../../boost/cregex.hpp ../../../boost/regex/pattern_except.hpp ../../../boost/regex.hpp ../../../boost/regex/regex_traits.hpp ../../../boost/regex/detail/fileiter.hpp ../../../boost/regex/detail/regex_compile.hpp ../../../boost/regex/detail/regex_config.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_options.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 : $(DIRNAME) $(DIRNAME) $(DIRNAME)/boost_regex ./$(DIRNAME)/libboost_regex.so
$(DIRNAME) :
mkdir -p $(DIRNAME)
clean : boost_regex_clean
install : all
########################################################
#
# section for libboost_regex.so
#
########################################################
$(DIRNAME)/boost_regex/c_regex_traits.o: ../src/c_regex_traits.cpp $(ALL_HEADER)
$(CXX) $(INCLUDES) -o $(DIRNAME)/boost_regex/c_regex_traits.o $(C1) $(CXXFLAGS) ../src/c_regex_traits.cpp
$(DIRNAME)/boost_regex/c_regex_traits_common.o: ../src/c_regex_traits_common.cpp $(ALL_HEADER)
$(CXX) $(INCLUDES) -o $(DIRNAME)/boost_regex/c_regex_traits_common.o $(C1) $(CXXFLAGS) ../src/c_regex_traits_common.cpp
$(DIRNAME)/boost_regex/cpp_regex_traits.o: ../src/cpp_regex_traits.cpp $(ALL_HEADER)
$(CXX) $(INCLUDES) -o $(DIRNAME)/boost_regex/cpp_regex_traits.o $(C1) $(CXXFLAGS) ../src/cpp_regex_traits.cpp
$(DIRNAME)/boost_regex/cregex.o: ../src/cregex.cpp $(ALL_HEADER)
$(CXX) $(INCLUDES) -o $(DIRNAME)/boost_regex/cregex.o $(C1) $(CXXFLAGS) ../src/cregex.cpp
$(DIRNAME)/boost_regex/fileiter.o: ../src/fileiter.cpp $(ALL_HEADER)
$(CXX) $(INCLUDES) -o $(DIRNAME)/boost_regex/fileiter.o $(C1) $(CXXFLAGS) ../src/fileiter.cpp
$(DIRNAME)/boost_regex/posix_api.o: ../src/posix_api.cpp $(ALL_HEADER)
$(CXX) $(INCLUDES) -o $(DIRNAME)/boost_regex/posix_api.o $(C1) $(CXXFLAGS) ../src/posix_api.cpp
$(DIRNAME)/boost_regex/regex.o: ../src/regex.cpp $(ALL_HEADER)
$(CXX) $(INCLUDES) -o $(DIRNAME)/boost_regex/regex.o $(C1) $(CXXFLAGS) ../src/regex.cpp
$(DIRNAME)/boost_regex/regex_debug.o: ../src/regex_debug.cpp $(ALL_HEADER)
$(CXX) $(INCLUDES) -o $(DIRNAME)/boost_regex/regex_debug.o $(C1) $(CXXFLAGS) ../src/regex_debug.cpp
$(DIRNAME)/boost_regex/regex_synch.o: ../src/regex_synch.cpp $(ALL_HEADER)
$(CXX) $(INCLUDES) -o $(DIRNAME)/boost_regex/regex_synch.o $(C1) $(CXXFLAGS) ../src/regex_synch.cpp
$(DIRNAME)/boost_regex/w32_regex_traits.o: ../src/w32_regex_traits.cpp $(ALL_HEADER)
$(CXX) $(INCLUDES) -o $(DIRNAME)/boost_regex/w32_regex_traits.o $(C1) $(CXXFLAGS) ../src/w32_regex_traits.cpp
$(DIRNAME)/boost_regex/wide_posix_api.o: ../src/wide_posix_api.cpp $(ALL_HEADER)
$(CXX) $(INCLUDES) -o $(DIRNAME)/boost_regex/wide_posix_api.o $(C1) $(CXXFLAGS) ../src/wide_posix_api.cpp
$(DIRNAME)/boost_regex :
mkdir -p $(DIRNAME)/boost_regex
boost_regex_clean :
rm -f $(DIRNAME)/boost_regex/*.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/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
$(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/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 $(LIBS)

View File

@ -1,74 +0,0 @@
LIBNAME=boost_regex
CPP=@CXX@
AR=ar
CPP_PROJ=@CXXFLAGS@ -I../../../ -c
ALL_O=@ac_all_o@
ALL_H=@ac_all_h@
lib$(LIBNAME).a : $(ALL_O)
c_regex_traits.o: $(ALL_H) ../src/c_regex_traits.cpp
$(CPP) $(CPP_PROJ) ../src/c_regex_traits.cpp
$(AR) -rc lib$(LIBNAME).a c_regex_traits.o
c_regex_traits_common.o: $(ALL_H) ../src/c_regex_traits_common.cpp
$(CPP) $(CPP_PROJ) ../src/c_regex_traits_common.cpp
$(AR) -rc lib$(LIBNAME).a c_regex_traits_common.o
cpp_regex_traits.o: $(ALL_H) ../src/cpp_regex_traits.cpp
$(CPP) $(CPP_PROJ) ../src/cpp_regex_traits.cpp
$(AR) -rc lib$(LIBNAME).a cpp_regex_traits.o
cregex.o: $(ALL_H) ../src/cregex.cpp
$(CPP) $(CPP_PROJ) ../src/cregex.cpp
$(AR) -rc lib$(LIBNAME).a cregex.o
fileiter.o: $(ALL_H) ../src/fileiter.cpp
$(CPP) $(CPP_PROJ) ../src/fileiter.cpp
$(AR) -rc lib$(LIBNAME).a fileiter.o
posix_api.o: $(ALL_H) ../src/posix_api.cpp
$(CPP) $(CPP_PROJ) ../src/posix_api.cpp
$(AR) -rc lib$(LIBNAME).a posix_api.o
regex.o: $(ALL_H) ../src/regex.cpp
$(CPP) $(CPP_PROJ) ../src/regex.cpp
$(AR) -rc lib$(LIBNAME).a regex.o
regex_debug.o: $(ALL_H) ../src/regex_debug.cpp
$(CPP) $(CPP_PROJ) ../src/regex_debug.cpp
$(AR) -rc lib$(LIBNAME).a regex_debug.o
regex_synch.o: $(ALL_H) ../src/regex_synch.cpp
$(CPP) $(CPP_PROJ) ../src/regex_synch.cpp
$(AR) -rc lib$(LIBNAME).a regex_synch.o
w32_regex_traits.o: $(ALL_H) ../src/w32_regex_traits.cpp
$(CPP) $(CPP_PROJ) ../src/w32_regex_traits.cpp
$(AR) -rc lib$(LIBNAME).a w32_regex_traits.o
wide_posix_api.o: $(ALL_H) ../src/wide_posix_api.cpp
$(CPP) $(CPP_PROJ) ../src/wide_posix_api.cpp
$(AR) -rc lib$(LIBNAME).a wide_posix_api.o

View File

@ -1,19 +0,0 @@
LIBNAME=boost_regex
CPP=@CXX@
AR=ar
CPP_PROJ=@CXXFLAGS@ -I../../../ -c
ALL_O=@ac_all_o@
ALL_H=@ac_all_h@
lib$(LIBNAME).a : $(ALL_O)

View File

@ -1,240 +0,0 @@
#
# auto generated makefile for Sun Forte 6.1
#
# usage:
# make
# brings libraries up to date
# make clean
# removes all temporary files.
#
# Add additional compiler options here:
#
CXXFLAGS=
#
# Add additional include directories here:
#
INCLUDES=
#
# add additional linker flags here:
#
LDFLAGS=
#
# add additional libraries to link to here:
#
LIBS=
#
# lib suffix string:
#
LIBSUFFIX=
#
# template cache path:
#
SUNWS_CACHE_NAME=SunWS_cache
ALL_HEADER=../../../boost/cregex.hpp ../../../boost/regex/pattern_except.hpp ../../../boost/regex.hpp ../../../boost/regex/regex_traits.hpp ../../../boost/regex/detail/fileiter.hpp ../../../boost/regex/detail/regex_compile.hpp ../../../boost/regex/detail/regex_config.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_options.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 : 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
clean : libboost_regex$(LIBSUFFIX)_clean libboost_regex_mt$(LIBSUFFIX)_clean libboost_regex$(LIBSUFFIX)_clean_shared libboost_regex_mt$(LIBSUFFIX)_clean_shared
install : all
sunpro :
mkdir -p sunpro
########################################################
#
# section for libboost_regex$(LIBSUFFIX).a
#
########################################################
sunpro/libboost_regex$(LIBSUFFIX)/c_regex_traits.o: ../src/c_regex_traits.cpp $(ALL_HEADER)
CC -c $(INCLUDES) -O2 -I../../../ $(CXXFLAGS) -o sunpro/libboost_regex$(LIBSUFFIX)/c_regex_traits.o ../src/c_regex_traits.cpp
sunpro/libboost_regex$(LIBSUFFIX)/c_regex_traits_common.o: ../src/c_regex_traits_common.cpp $(ALL_HEADER)
CC -c $(INCLUDES) -O2 -I../../../ $(CXXFLAGS) -o sunpro/libboost_regex$(LIBSUFFIX)/c_regex_traits_common.o ../src/c_regex_traits_common.cpp
sunpro/libboost_regex$(LIBSUFFIX)/cpp_regex_traits.o: ../src/cpp_regex_traits.cpp $(ALL_HEADER)
CC -c $(INCLUDES) -O2 -I../../../ $(CXXFLAGS) -o sunpro/libboost_regex$(LIBSUFFIX)/cpp_regex_traits.o ../src/cpp_regex_traits.cpp
sunpro/libboost_regex$(LIBSUFFIX)/cregex.o: ../src/cregex.cpp $(ALL_HEADER)
CC -c $(INCLUDES) -O2 -I../../../ $(CXXFLAGS) -o sunpro/libboost_regex$(LIBSUFFIX)/cregex.o ../src/cregex.cpp
sunpro/libboost_regex$(LIBSUFFIX)/fileiter.o: ../src/fileiter.cpp $(ALL_HEADER)
CC -c $(INCLUDES) -O2 -I../../../ $(CXXFLAGS) -o sunpro/libboost_regex$(LIBSUFFIX)/fileiter.o ../src/fileiter.cpp
sunpro/libboost_regex$(LIBSUFFIX)/posix_api.o: ../src/posix_api.cpp $(ALL_HEADER)
CC -c $(INCLUDES) -O2 -I../../../ $(CXXFLAGS) -o sunpro/libboost_regex$(LIBSUFFIX)/posix_api.o ../src/posix_api.cpp
sunpro/libboost_regex$(LIBSUFFIX)/regex.o: ../src/regex.cpp $(ALL_HEADER)
CC -c $(INCLUDES) -O2 -I../../../ $(CXXFLAGS) -o sunpro/libboost_regex$(LIBSUFFIX)/regex.o ../src/regex.cpp
sunpro/libboost_regex$(LIBSUFFIX)/regex_debug.o: ../src/regex_debug.cpp $(ALL_HEADER)
CC -c $(INCLUDES) -O2 -I../../../ $(CXXFLAGS) -o sunpro/libboost_regex$(LIBSUFFIX)/regex_debug.o ../src/regex_debug.cpp
sunpro/libboost_regex$(LIBSUFFIX)/regex_synch.o: ../src/regex_synch.cpp $(ALL_HEADER)
CC -c $(INCLUDES) -O2 -I../../../ $(CXXFLAGS) -o sunpro/libboost_regex$(LIBSUFFIX)/regex_synch.o ../src/regex_synch.cpp
sunpro/libboost_regex$(LIBSUFFIX)/w32_regex_traits.o: ../src/w32_regex_traits.cpp $(ALL_HEADER)
CC -c $(INCLUDES) -O2 -I../../../ $(CXXFLAGS) -o sunpro/libboost_regex$(LIBSUFFIX)/w32_regex_traits.o ../src/w32_regex_traits.cpp
sunpro/libboost_regex$(LIBSUFFIX)/wide_posix_api.o: ../src/wide_posix_api.cpp $(ALL_HEADER)
CC -c $(INCLUDES) -O2 -I../../../ $(CXXFLAGS) -o sunpro/libboost_regex$(LIBSUFFIX)/wide_posix_api.o ../src/wide_posix_api.cpp
sunpro/libboost_regex$(LIBSUFFIX) :
mkdir -p sunpro/libboost_regex$(LIBSUFFIX)
libboost_regex$(LIBSUFFIX)_clean :
rm -f sunpro/libboost_regex$(LIBSUFFIX)/*.o
rm -fr sunpro/libboost_regex$(LIBSUFFIX)/$(SUNWS_CACHE_NAME)
sunpro/libboost_regex$(LIBSUFFIX).a : sunpro/libboost_regex$(LIBSUFFIX)/c_regex_traits.o sunpro/libboost_regex$(LIBSUFFIX)/c_regex_traits_common.o sunpro/libboost_regex$(LIBSUFFIX)/cpp_regex_traits.o sunpro/libboost_regex$(LIBSUFFIX)/cregex.o sunpro/libboost_regex$(LIBSUFFIX)/fileiter.o sunpro/libboost_regex$(LIBSUFFIX)/posix_api.o sunpro/libboost_regex$(LIBSUFFIX)/regex.o sunpro/libboost_regex$(LIBSUFFIX)/regex_debug.o sunpro/libboost_regex$(LIBSUFFIX)/regex_synch.o sunpro/libboost_regex$(LIBSUFFIX)/w32_regex_traits.o sunpro/libboost_regex$(LIBSUFFIX)/wide_posix_api.o
CC -xar $(CXXFLAGS) $(LDFLAGS) -o sunpro/libboost_regex$(LIBSUFFIX).a sunpro/libboost_regex$(LIBSUFFIX)/c_regex_traits.o sunpro/libboost_regex$(LIBSUFFIX)/c_regex_traits_common.o sunpro/libboost_regex$(LIBSUFFIX)/cpp_regex_traits.o sunpro/libboost_regex$(LIBSUFFIX)/cregex.o sunpro/libboost_regex$(LIBSUFFIX)/fileiter.o sunpro/libboost_regex$(LIBSUFFIX)/posix_api.o sunpro/libboost_regex$(LIBSUFFIX)/regex.o sunpro/libboost_regex$(LIBSUFFIX)/regex_debug.o sunpro/libboost_regex$(LIBSUFFIX)/regex_synch.o sunpro/libboost_regex$(LIBSUFFIX)/w32_regex_traits.o sunpro/libboost_regex$(LIBSUFFIX)/wide_posix_api.o
########################################################
#
# section for libboost_regex_mt$(LIBSUFFIX).a
#
########################################################
sunpro/libboost_regex_mt$(LIBSUFFIX)/c_regex_traits.o: ../src/c_regex_traits.cpp $(ALL_HEADER)
CC -c $(INCLUDES) -O2 -mt -I../../../ $(CXXFLAGS) -o sunpro/libboost_regex_mt$(LIBSUFFIX)/c_regex_traits.o ../src/c_regex_traits.cpp
sunpro/libboost_regex_mt$(LIBSUFFIX)/c_regex_traits_common.o: ../src/c_regex_traits_common.cpp $(ALL_HEADER)
CC -c $(INCLUDES) -O2 -mt -I../../../ $(CXXFLAGS) -o sunpro/libboost_regex_mt$(LIBSUFFIX)/c_regex_traits_common.o ../src/c_regex_traits_common.cpp
sunpro/libboost_regex_mt$(LIBSUFFIX)/cpp_regex_traits.o: ../src/cpp_regex_traits.cpp $(ALL_HEADER)
CC -c $(INCLUDES) -O2 -mt -I../../../ $(CXXFLAGS) -o sunpro/libboost_regex_mt$(LIBSUFFIX)/cpp_regex_traits.o ../src/cpp_regex_traits.cpp
sunpro/libboost_regex_mt$(LIBSUFFIX)/cregex.o: ../src/cregex.cpp $(ALL_HEADER)
CC -c $(INCLUDES) -O2 -mt -I../../../ $(CXXFLAGS) -o sunpro/libboost_regex_mt$(LIBSUFFIX)/cregex.o ../src/cregex.cpp
sunpro/libboost_regex_mt$(LIBSUFFIX)/fileiter.o: ../src/fileiter.cpp $(ALL_HEADER)
CC -c $(INCLUDES) -O2 -mt -I../../../ $(CXXFLAGS) -o sunpro/libboost_regex_mt$(LIBSUFFIX)/fileiter.o ../src/fileiter.cpp
sunpro/libboost_regex_mt$(LIBSUFFIX)/posix_api.o: ../src/posix_api.cpp $(ALL_HEADER)
CC -c $(INCLUDES) -O2 -mt -I../../../ $(CXXFLAGS) -o sunpro/libboost_regex_mt$(LIBSUFFIX)/posix_api.o ../src/posix_api.cpp
sunpro/libboost_regex_mt$(LIBSUFFIX)/regex.o: ../src/regex.cpp $(ALL_HEADER)
CC -c $(INCLUDES) -O2 -mt -I../../../ $(CXXFLAGS) -o sunpro/libboost_regex_mt$(LIBSUFFIX)/regex.o ../src/regex.cpp
sunpro/libboost_regex_mt$(LIBSUFFIX)/regex_debug.o: ../src/regex_debug.cpp $(ALL_HEADER)
CC -c $(INCLUDES) -O2 -mt -I../../../ $(CXXFLAGS) -o sunpro/libboost_regex_mt$(LIBSUFFIX)/regex_debug.o ../src/regex_debug.cpp
sunpro/libboost_regex_mt$(LIBSUFFIX)/regex_synch.o: ../src/regex_synch.cpp $(ALL_HEADER)
CC -c $(INCLUDES) -O2 -mt -I../../../ $(CXXFLAGS) -o sunpro/libboost_regex_mt$(LIBSUFFIX)/regex_synch.o ../src/regex_synch.cpp
sunpro/libboost_regex_mt$(LIBSUFFIX)/w32_regex_traits.o: ../src/w32_regex_traits.cpp $(ALL_HEADER)
CC -c $(INCLUDES) -O2 -mt -I../../../ $(CXXFLAGS) -o sunpro/libboost_regex_mt$(LIBSUFFIX)/w32_regex_traits.o ../src/w32_regex_traits.cpp
sunpro/libboost_regex_mt$(LIBSUFFIX)/wide_posix_api.o: ../src/wide_posix_api.cpp $(ALL_HEADER)
CC -c $(INCLUDES) -O2 -mt -I../../../ $(CXXFLAGS) -o sunpro/libboost_regex_mt$(LIBSUFFIX)/wide_posix_api.o ../src/wide_posix_api.cpp
sunpro/libboost_regex_mt$(LIBSUFFIX) :
mkdir -p sunpro/libboost_regex_mt$(LIBSUFFIX)
libboost_regex_mt$(LIBSUFFIX)_clean :
rm -f sunpro/libboost_regex_mt$(LIBSUFFIX)/*.o
rm -fr sunpro/libboost_regex_mt$(LIBSUFFIX)/$(SUNWS_CACHE_NAME)
sunpro/libboost_regex_mt$(LIBSUFFIX).a : sunpro/libboost_regex_mt$(LIBSUFFIX)/c_regex_traits.o sunpro/libboost_regex_mt$(LIBSUFFIX)/c_regex_traits_common.o sunpro/libboost_regex_mt$(LIBSUFFIX)/cpp_regex_traits.o sunpro/libboost_regex_mt$(LIBSUFFIX)/cregex.o sunpro/libboost_regex_mt$(LIBSUFFIX)/fileiter.o sunpro/libboost_regex_mt$(LIBSUFFIX)/posix_api.o sunpro/libboost_regex_mt$(LIBSUFFIX)/regex.o sunpro/libboost_regex_mt$(LIBSUFFIX)/regex_debug.o sunpro/libboost_regex_mt$(LIBSUFFIX)/regex_synch.o sunpro/libboost_regex_mt$(LIBSUFFIX)/w32_regex_traits.o sunpro/libboost_regex_mt$(LIBSUFFIX)/wide_posix_api.o
CC -xar $(CXXFLAGS) $(LDFLAGS) -o sunpro/libboost_regex_mt$(LIBSUFFIX).a sunpro/libboost_regex_mt$(LIBSUFFIX)/c_regex_traits.o sunpro/libboost_regex_mt$(LIBSUFFIX)/c_regex_traits_common.o sunpro/libboost_regex_mt$(LIBSUFFIX)/cpp_regex_traits.o sunpro/libboost_regex_mt$(LIBSUFFIX)/cregex.o sunpro/libboost_regex_mt$(LIBSUFFIX)/fileiter.o sunpro/libboost_regex_mt$(LIBSUFFIX)/posix_api.o sunpro/libboost_regex_mt$(LIBSUFFIX)/regex.o sunpro/libboost_regex_mt$(LIBSUFFIX)/regex_debug.o sunpro/libboost_regex_mt$(LIBSUFFIX)/regex_synch.o sunpro/libboost_regex_mt$(LIBSUFFIX)/w32_regex_traits.o sunpro/libboost_regex_mt$(LIBSUFFIX)/wide_posix_api.o
########################################################
#
# section for libboost_regex$(LIBSUFFIX).so
#
########################################################
sunpro/shared_libboost_regex$(LIBSUFFIX)/c_regex_traits.o: ../src/c_regex_traits.cpp $(ALL_HEADER)
CC -c $(INCLUDES) -KPIC -O2 -I../../../ $(CXXFLAGS) -o sunpro/shared_libboost_regex$(LIBSUFFIX)/c_regex_traits.o ../src/c_regex_traits.cpp
sunpro/shared_libboost_regex$(LIBSUFFIX)/c_regex_traits_common.o: ../src/c_regex_traits_common.cpp $(ALL_HEADER)
CC -c $(INCLUDES) -KPIC -O2 -I../../../ $(CXXFLAGS) -o sunpro/shared_libboost_regex$(LIBSUFFIX)/c_regex_traits_common.o ../src/c_regex_traits_common.cpp
sunpro/shared_libboost_regex$(LIBSUFFIX)/cpp_regex_traits.o: ../src/cpp_regex_traits.cpp $(ALL_HEADER)
CC -c $(INCLUDES) -KPIC -O2 -I../../../ $(CXXFLAGS) -o sunpro/shared_libboost_regex$(LIBSUFFIX)/cpp_regex_traits.o ../src/cpp_regex_traits.cpp
sunpro/shared_libboost_regex$(LIBSUFFIX)/cregex.o: ../src/cregex.cpp $(ALL_HEADER)
CC -c $(INCLUDES) -KPIC -O2 -I../../../ $(CXXFLAGS) -o sunpro/shared_libboost_regex$(LIBSUFFIX)/cregex.o ../src/cregex.cpp
sunpro/shared_libboost_regex$(LIBSUFFIX)/fileiter.o: ../src/fileiter.cpp $(ALL_HEADER)
CC -c $(INCLUDES) -KPIC -O2 -I../../../ $(CXXFLAGS) -o sunpro/shared_libboost_regex$(LIBSUFFIX)/fileiter.o ../src/fileiter.cpp
sunpro/shared_libboost_regex$(LIBSUFFIX)/posix_api.o: ../src/posix_api.cpp $(ALL_HEADER)
CC -c $(INCLUDES) -KPIC -O2 -I../../../ $(CXXFLAGS) -o sunpro/shared_libboost_regex$(LIBSUFFIX)/posix_api.o ../src/posix_api.cpp
sunpro/shared_libboost_regex$(LIBSUFFIX)/regex.o: ../src/regex.cpp $(ALL_HEADER)
CC -c $(INCLUDES) -KPIC -O2 -I../../../ $(CXXFLAGS) -o sunpro/shared_libboost_regex$(LIBSUFFIX)/regex.o ../src/regex.cpp
sunpro/shared_libboost_regex$(LIBSUFFIX)/regex_debug.o: ../src/regex_debug.cpp $(ALL_HEADER)
CC -c $(INCLUDES) -KPIC -O2 -I../../../ $(CXXFLAGS) -o sunpro/shared_libboost_regex$(LIBSUFFIX)/regex_debug.o ../src/regex_debug.cpp
sunpro/shared_libboost_regex$(LIBSUFFIX)/regex_synch.o: ../src/regex_synch.cpp $(ALL_HEADER)
CC -c $(INCLUDES) -KPIC -O2 -I../../../ $(CXXFLAGS) -o sunpro/shared_libboost_regex$(LIBSUFFIX)/regex_synch.o ../src/regex_synch.cpp
sunpro/shared_libboost_regex$(LIBSUFFIX)/w32_regex_traits.o: ../src/w32_regex_traits.cpp $(ALL_HEADER)
CC -c $(INCLUDES) -KPIC -O2 -I../../../ $(CXXFLAGS) -o sunpro/shared_libboost_regex$(LIBSUFFIX)/w32_regex_traits.o ../src/w32_regex_traits.cpp
sunpro/shared_libboost_regex$(LIBSUFFIX)/wide_posix_api.o: ../src/wide_posix_api.cpp $(ALL_HEADER)
CC -c $(INCLUDES) -KPIC -O2 -I../../../ $(CXXFLAGS) -o sunpro/shared_libboost_regex$(LIBSUFFIX)/wide_posix_api.o ../src/wide_posix_api.cpp
sunpro/shared_libboost_regex$(LIBSUFFIX) :
mkdir -p sunpro/shared_libboost_regex$(LIBSUFFIX)
libboost_regex$(LIBSUFFIX)_clean_shared :
rm -f sunpro/shared_libboost_regex$(LIBSUFFIX)/*.o
rm -fr sunpro/shared_libboost_regex$(LIBSUFFIX)/$(SUNWS_CACHE_NAME)
sunpro/libboost_regex$(LIBSUFFIX).so : sunpro/shared_libboost_regex$(LIBSUFFIX)/c_regex_traits.o sunpro/shared_libboost_regex$(LIBSUFFIX)/c_regex_traits_common.o sunpro/shared_libboost_regex$(LIBSUFFIX)/cpp_regex_traits.o sunpro/shared_libboost_regex$(LIBSUFFIX)/cregex.o sunpro/shared_libboost_regex$(LIBSUFFIX)/fileiter.o sunpro/shared_libboost_regex$(LIBSUFFIX)/posix_api.o sunpro/shared_libboost_regex$(LIBSUFFIX)/regex.o sunpro/shared_libboost_regex$(LIBSUFFIX)/regex_debug.o sunpro/shared_libboost_regex$(LIBSUFFIX)/regex_synch.o sunpro/shared_libboost_regex$(LIBSUFFIX)/w32_regex_traits.o sunpro/shared_libboost_regex$(LIBSUFFIX)/wide_posix_api.o
CC -KPIC -O2 -I../../../ -G -o sunpro/libboost_regex$(LIBSUFFIX).so $(LDFLAGS) sunpro/shared_libboost_regex$(LIBSUFFIX)/c_regex_traits.o sunpro/shared_libboost_regex$(LIBSUFFIX)/c_regex_traits_common.o sunpro/shared_libboost_regex$(LIBSUFFIX)/cpp_regex_traits.o sunpro/shared_libboost_regex$(LIBSUFFIX)/cregex.o sunpro/shared_libboost_regex$(LIBSUFFIX)/fileiter.o sunpro/shared_libboost_regex$(LIBSUFFIX)/posix_api.o sunpro/shared_libboost_regex$(LIBSUFFIX)/regex.o sunpro/shared_libboost_regex$(LIBSUFFIX)/regex_debug.o sunpro/shared_libboost_regex$(LIBSUFFIX)/regex_synch.o sunpro/shared_libboost_regex$(LIBSUFFIX)/w32_regex_traits.o sunpro/shared_libboost_regex$(LIBSUFFIX)/wide_posix_api.o $(LIBS)
########################################################
#
# section for libboost_regex_mt$(LIBSUFFIX).so
#
########################################################
sunpro/shared_libboost_regex_mt$(LIBSUFFIX)/c_regex_traits.o: ../src/c_regex_traits.cpp $(ALL_HEADER)
CC -c $(INCLUDES) -KPIC -O2 -mt -I../../../ $(CXXFLAGS) -o sunpro/shared_libboost_regex_mt$(LIBSUFFIX)/c_regex_traits.o ../src/c_regex_traits.cpp
sunpro/shared_libboost_regex_mt$(LIBSUFFIX)/c_regex_traits_common.o: ../src/c_regex_traits_common.cpp $(ALL_HEADER)
CC -c $(INCLUDES) -KPIC -O2 -mt -I../../../ $(CXXFLAGS) -o sunpro/shared_libboost_regex_mt$(LIBSUFFIX)/c_regex_traits_common.o ../src/c_regex_traits_common.cpp
sunpro/shared_libboost_regex_mt$(LIBSUFFIX)/cpp_regex_traits.o: ../src/cpp_regex_traits.cpp $(ALL_HEADER)
CC -c $(INCLUDES) -KPIC -O2 -mt -I../../../ $(CXXFLAGS) -o sunpro/shared_libboost_regex_mt$(LIBSUFFIX)/cpp_regex_traits.o ../src/cpp_regex_traits.cpp
sunpro/shared_libboost_regex_mt$(LIBSUFFIX)/cregex.o: ../src/cregex.cpp $(ALL_HEADER)
CC -c $(INCLUDES) -KPIC -O2 -mt -I../../../ $(CXXFLAGS) -o sunpro/shared_libboost_regex_mt$(LIBSUFFIX)/cregex.o ../src/cregex.cpp
sunpro/shared_libboost_regex_mt$(LIBSUFFIX)/fileiter.o: ../src/fileiter.cpp $(ALL_HEADER)
CC -c $(INCLUDES) -KPIC -O2 -mt -I../../../ $(CXXFLAGS) -o sunpro/shared_libboost_regex_mt$(LIBSUFFIX)/fileiter.o ../src/fileiter.cpp
sunpro/shared_libboost_regex_mt$(LIBSUFFIX)/posix_api.o: ../src/posix_api.cpp $(ALL_HEADER)
CC -c $(INCLUDES) -KPIC -O2 -mt -I../../../ $(CXXFLAGS) -o sunpro/shared_libboost_regex_mt$(LIBSUFFIX)/posix_api.o ../src/posix_api.cpp
sunpro/shared_libboost_regex_mt$(LIBSUFFIX)/regex.o: ../src/regex.cpp $(ALL_HEADER)
CC -c $(INCLUDES) -KPIC -O2 -mt -I../../../ $(CXXFLAGS) -o sunpro/shared_libboost_regex_mt$(LIBSUFFIX)/regex.o ../src/regex.cpp
sunpro/shared_libboost_regex_mt$(LIBSUFFIX)/regex_debug.o: ../src/regex_debug.cpp $(ALL_HEADER)
CC -c $(INCLUDES) -KPIC -O2 -mt -I../../../ $(CXXFLAGS) -o sunpro/shared_libboost_regex_mt$(LIBSUFFIX)/regex_debug.o ../src/regex_debug.cpp
sunpro/shared_libboost_regex_mt$(LIBSUFFIX)/regex_synch.o: ../src/regex_synch.cpp $(ALL_HEADER)
CC -c $(INCLUDES) -KPIC -O2 -mt -I../../../ $(CXXFLAGS) -o sunpro/shared_libboost_regex_mt$(LIBSUFFIX)/regex_synch.o ../src/regex_synch.cpp
sunpro/shared_libboost_regex_mt$(LIBSUFFIX)/w32_regex_traits.o: ../src/w32_regex_traits.cpp $(ALL_HEADER)
CC -c $(INCLUDES) -KPIC -O2 -mt -I../../../ $(CXXFLAGS) -o sunpro/shared_libboost_regex_mt$(LIBSUFFIX)/w32_regex_traits.o ../src/w32_regex_traits.cpp
sunpro/shared_libboost_regex_mt$(LIBSUFFIX)/wide_posix_api.o: ../src/wide_posix_api.cpp $(ALL_HEADER)
CC -c $(INCLUDES) -KPIC -O2 -mt -I../../../ $(CXXFLAGS) -o sunpro/shared_libboost_regex_mt$(LIBSUFFIX)/wide_posix_api.o ../src/wide_posix_api.cpp
sunpro/shared_libboost_regex_mt$(LIBSUFFIX) :
mkdir -p sunpro/shared_libboost_regex_mt$(LIBSUFFIX)
libboost_regex_mt$(LIBSUFFIX)_clean_shared :
rm -f sunpro/shared_libboost_regex_mt$(LIBSUFFIX)/*.o
rm -fr sunpro/shared_libboost_regex_mt$(LIBSUFFIX)/$(SUNWS_CACHE_NAME)
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)/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
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)/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 $(LIBS)

View File

@ -1,414 +0,0 @@
#
# auto generated makefile for VC6 compiler
#
# usage:
# make
# brings libraries up to date
# make install
# brings libraries up to date and copies binaries to your VC6 /lib and /bin directories (recomended)
#
#
# Add additional compiler options here:
#
CXXFLAGS=
#
# Add additional include directories here:
#
INCLUDES=
#
# add additional linker flags here:
#
XLFLAGS=
#
# add additional static-library creation flags here:
#
XSFLAGS=
!IF "$(OS)" == "Windows_NT"
NULL=
!ELSE
NULL=nul
!ENDIF
ALL_HEADER=../../../boost/cregex.hpp ../../../boost/regex/pattern_except.hpp ../../../boost/regex.hpp ../../../boost/regex/regex_traits.hpp ../../../boost/regex/detail/fileiter.hpp ../../../boost/regex/detail/regex_compile.hpp ../../../boost/regex/detail/regex_config.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_options.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 : main_dir vc6-stlport-re300m_dir ./vc6-stlport/vc6-stlport-re300m.lib vc6-stlport-re300dm_dir ./vc6-stlport/vc6-stlport-re300dm.lib vc6-stlport-re300dl_dir ./vc6-stlport/vc6-stlport-re300dl.lib vc6-stlport-re300l_dir ./vc6-stlport/vc6-stlport-re300l.lib vc6-stlport-re300ls_dir ./vc6-stlport/vc6-stlport-re300ls.lib vc6-stlport-re300ddl_dir ./vc6-stlport/vc6-stlport-re300ddl.lib vc6-stlport-re300ddm_dir ./vc6-stlport/vc6-stlport-re300ddm.lib
clean : vc6-stlport-re300m_clean vc6-stlport-re300dm_clean vc6-stlport-re300dl_clean vc6-stlport-re300l_clean vc6-stlport-re300ls_clean vc6-stlport-re300ddl_clean vc6-stlport-re300ddm_clean
install : all
copy vc6-stlport\vc6-stlport-re300m.lib "$(MSVCDIR)\lib"
copy vc6-stlport\vc6-stlport-re300dm.lib "$(MSVCDIR)\lib"
copy vc6-stlport\vc6-stlport-re300dl.lib "$(MSVCDIR)\lib"
copy vc6-stlport\vc6-stlport-re300dl.dll "$(MSVCDIR)\bin"
copy vc6-stlport\vc6-stlport-re300l.lib "$(MSVCDIR)\lib"
copy vc6-stlport\vc6-stlport-re300l.dll "$(MSVCDIR)\bin"
copy vc6-stlport\vc6-stlport-re300ls.lib "$(MSVCDIR)\lib"
copy vc6-stlport\vc6-stlport-re300ddl.lib "$(MSVCDIR)\lib"
copy vc6-stlport\vc6-stlport-re300ddl.dll "$(MSVCDIR)\bin"
copy vc6-stlport\vc6-stlport-re300ddl.pdb "$(MSVCDIR)\lib"
copy vc6-stlport\vc6-stlport-re300ddm.lib "$(MSVCDIR)\lib"
copy vc6-stlport\vc6-stlport-re300ddm.pdb "$(MSVCDIR)\lib"
main_dir :
if not exist "vc6-stlport\$(NULL)" mkdir vc6-stlport
########################################################
#
# section for vc6-stlport-re300m.lib
#
########################################################
vc6-stlport/vc6-stlport-re300m/c_regex_traits.obj: ../src/c_regex_traits.cpp $(ALL_HEADER)
cl $(INCLUDES) /nologo /MT /W3 /GX /Oityb1 /GF /Gy /I..\..\..\ /D_MT /DWIN32 /DNDEBUG /D_MBCS /D_LIB /YX /FD /c $(CXXFLAGS) -Fpvc6-stlport/vc6-stlport-re300m/vc6-stlport-re300m.pch -Fo./vc6-stlport/vc6-stlport-re300m/ -Fdvc6-stlport/vc6-stlport-re300m.pdb ../src/c_regex_traits.cpp
vc6-stlport/vc6-stlport-re300m/c_regex_traits_common.obj: ../src/c_regex_traits_common.cpp $(ALL_HEADER)
cl $(INCLUDES) /nologo /MT /W3 /GX /Oityb1 /GF /Gy /I..\..\..\ /D_MT /DWIN32 /DNDEBUG /D_MBCS /D_LIB /YX /FD /c $(CXXFLAGS) -Fpvc6-stlport/vc6-stlport-re300m/vc6-stlport-re300m.pch -Fo./vc6-stlport/vc6-stlport-re300m/ -Fdvc6-stlport/vc6-stlport-re300m.pdb ../src/c_regex_traits_common.cpp
vc6-stlport/vc6-stlport-re300m/cpp_regex_traits.obj: ../src/cpp_regex_traits.cpp $(ALL_HEADER)
cl $(INCLUDES) /nologo /MT /W3 /GX /Oityb1 /GF /Gy /I..\..\..\ /D_MT /DWIN32 /DNDEBUG /D_MBCS /D_LIB /YX /FD /c $(CXXFLAGS) -Fpvc6-stlport/vc6-stlport-re300m/vc6-stlport-re300m.pch -Fo./vc6-stlport/vc6-stlport-re300m/ -Fdvc6-stlport/vc6-stlport-re300m.pdb ../src/cpp_regex_traits.cpp
vc6-stlport/vc6-stlport-re300m/cregex.obj: ../src/cregex.cpp $(ALL_HEADER)
cl $(INCLUDES) /nologo /MT /W3 /GX /Oityb1 /GF /Gy /I..\..\..\ /D_MT /DWIN32 /DNDEBUG /D_MBCS /D_LIB /YX /FD /c $(CXXFLAGS) -Fpvc6-stlport/vc6-stlport-re300m/vc6-stlport-re300m.pch -Fo./vc6-stlport/vc6-stlport-re300m/ -Fdvc6-stlport/vc6-stlport-re300m.pdb ../src/cregex.cpp
vc6-stlport/vc6-stlport-re300m/fileiter.obj: ../src/fileiter.cpp $(ALL_HEADER)
cl $(INCLUDES) /nologo /MT /W3 /GX /Oityb1 /GF /Gy /I..\..\..\ /D_MT /DWIN32 /DNDEBUG /D_MBCS /D_LIB /YX /FD /c $(CXXFLAGS) -Fpvc6-stlport/vc6-stlport-re300m/vc6-stlport-re300m.pch -Fo./vc6-stlport/vc6-stlport-re300m/ -Fdvc6-stlport/vc6-stlport-re300m.pdb ../src/fileiter.cpp
vc6-stlport/vc6-stlport-re300m/posix_api.obj: ../src/posix_api.cpp $(ALL_HEADER)
cl $(INCLUDES) /nologo /MT /W3 /GX /Oityb1 /GF /Gy /I..\..\..\ /D_MT /DWIN32 /DNDEBUG /D_MBCS /D_LIB /YX /FD /c $(CXXFLAGS) -Fpvc6-stlport/vc6-stlport-re300m/vc6-stlport-re300m.pch -Fo./vc6-stlport/vc6-stlport-re300m/ -Fdvc6-stlport/vc6-stlport-re300m.pdb ../src/posix_api.cpp
vc6-stlport/vc6-stlport-re300m/regex.obj: ../src/regex.cpp $(ALL_HEADER)
cl $(INCLUDES) /nologo /MT /W3 /GX /Oityb1 /GF /Gy /I..\..\..\ /D_MT /DWIN32 /DNDEBUG /D_MBCS /D_LIB /YX /FD /c $(CXXFLAGS) -Fpvc6-stlport/vc6-stlport-re300m/vc6-stlport-re300m.pch -Fo./vc6-stlport/vc6-stlport-re300m/ -Fdvc6-stlport/vc6-stlport-re300m.pdb ../src/regex.cpp
vc6-stlport/vc6-stlport-re300m/regex_debug.obj: ../src/regex_debug.cpp $(ALL_HEADER)
cl $(INCLUDES) /nologo /MT /W3 /GX /Oityb1 /GF /Gy /I..\..\..\ /D_MT /DWIN32 /DNDEBUG /D_MBCS /D_LIB /YX /FD /c $(CXXFLAGS) -Fpvc6-stlport/vc6-stlport-re300m/vc6-stlport-re300m.pch -Fo./vc6-stlport/vc6-stlport-re300m/ -Fdvc6-stlport/vc6-stlport-re300m.pdb ../src/regex_debug.cpp
vc6-stlport/vc6-stlport-re300m/regex_synch.obj: ../src/regex_synch.cpp $(ALL_HEADER)
cl $(INCLUDES) /nologo /MT /W3 /GX /Oityb1 /GF /Gy /I..\..\..\ /D_MT /DWIN32 /DNDEBUG /D_MBCS /D_LIB /YX /FD /c $(CXXFLAGS) -Fpvc6-stlport/vc6-stlport-re300m/vc6-stlport-re300m.pch -Fo./vc6-stlport/vc6-stlport-re300m/ -Fdvc6-stlport/vc6-stlport-re300m.pdb ../src/regex_synch.cpp
vc6-stlport/vc6-stlport-re300m/w32_regex_traits.obj: ../src/w32_regex_traits.cpp $(ALL_HEADER)
cl $(INCLUDES) /nologo /MT /W3 /GX /Oityb1 /GF /Gy /I..\..\..\ /D_MT /DWIN32 /DNDEBUG /D_MBCS /D_LIB /YX /FD /c $(CXXFLAGS) -Fpvc6-stlport/vc6-stlport-re300m/vc6-stlport-re300m.pch -Fo./vc6-stlport/vc6-stlport-re300m/ -Fdvc6-stlport/vc6-stlport-re300m.pdb ../src/w32_regex_traits.cpp
vc6-stlport/vc6-stlport-re300m/wide_posix_api.obj: ../src/wide_posix_api.cpp $(ALL_HEADER)
cl $(INCLUDES) /nologo /MT /W3 /GX /Oityb1 /GF /Gy /I..\..\..\ /D_MT /DWIN32 /DNDEBUG /D_MBCS /D_LIB /YX /FD /c $(CXXFLAGS) -Fpvc6-stlport/vc6-stlport-re300m/vc6-stlport-re300m.pch -Fo./vc6-stlport/vc6-stlport-re300m/ -Fdvc6-stlport/vc6-stlport-re300m.pdb ../src/wide_posix_api.cpp
vc6-stlport-re300m_dir :
if not exist "vc6-stlport\vc6-stlport-re300m\$(NULL)" mkdir vc6-stlport\vc6-stlport-re300m
vc6-stlport-re300m_clean :
del vc6-stlport\vc6-stlport-re300m\*.obj
del vc6-stlport\vc6-stlport-re300m\*.idb
del vc6-stlport\vc6-stlport-re300m\*.exp
del vc6-stlport\vc6-stlport-re300m\*.pch
./vc6-stlport/vc6-stlport-re300m.lib : vc6-stlport/vc6-stlport-re300m/c_regex_traits.obj vc6-stlport/vc6-stlport-re300m/c_regex_traits_common.obj vc6-stlport/vc6-stlport-re300m/cpp_regex_traits.obj vc6-stlport/vc6-stlport-re300m/cregex.obj vc6-stlport/vc6-stlport-re300m/fileiter.obj vc6-stlport/vc6-stlport-re300m/posix_api.obj vc6-stlport/vc6-stlport-re300m/regex.obj vc6-stlport/vc6-stlport-re300m/regex_debug.obj vc6-stlport/vc6-stlport-re300m/regex_synch.obj vc6-stlport/vc6-stlport-re300m/w32_regex_traits.obj vc6-stlport/vc6-stlport-re300m/wide_posix_api.obj
link -lib /nologo /out:vc6-stlport/vc6-stlport-re300m.lib $(XSFLAGS) vc6-stlport/vc6-stlport-re300m/c_regex_traits.obj vc6-stlport/vc6-stlport-re300m/c_regex_traits_common.obj vc6-stlport/vc6-stlport-re300m/cpp_regex_traits.obj vc6-stlport/vc6-stlport-re300m/cregex.obj vc6-stlport/vc6-stlport-re300m/fileiter.obj vc6-stlport/vc6-stlport-re300m/posix_api.obj vc6-stlport/vc6-stlport-re300m/regex.obj vc6-stlport/vc6-stlport-re300m/regex_debug.obj vc6-stlport/vc6-stlport-re300m/regex_synch.obj vc6-stlport/vc6-stlport-re300m/w32_regex_traits.obj vc6-stlport/vc6-stlport-re300m/wide_posix_api.obj
########################################################
#
# section for vc6-stlport-re300dm.lib
#
########################################################
vc6-stlport/vc6-stlport-re300dm/c_regex_traits.obj: ../src/c_regex_traits.cpp $(ALL_HEADER)
cl $(INCLUDES) /nologo /MTd /W3 /Gm /GX /Zi /Od /I..\..\..\ /DWIN32 /D_MT /D_DEBUG /D_MBCS /D_LIB /YX /FD /GZ /c $(CXXFLAGS) -Fpvc6-stlport/vc6-stlport-re300dm/vc6-stlport-re300dm.pch -Fo./vc6-stlport/vc6-stlport-re300dm/ -Fdvc6-stlport/vc6-stlport-re300dm.pdb ../src/c_regex_traits.cpp
vc6-stlport/vc6-stlport-re300dm/c_regex_traits_common.obj: ../src/c_regex_traits_common.cpp $(ALL_HEADER)
cl $(INCLUDES) /nologo /MTd /W3 /Gm /GX /Zi /Od /I..\..\..\ /DWIN32 /D_MT /D_DEBUG /D_MBCS /D_LIB /YX /FD /GZ /c $(CXXFLAGS) -Fpvc6-stlport/vc6-stlport-re300dm/vc6-stlport-re300dm.pch -Fo./vc6-stlport/vc6-stlport-re300dm/ -Fdvc6-stlport/vc6-stlport-re300dm.pdb ../src/c_regex_traits_common.cpp
vc6-stlport/vc6-stlport-re300dm/cpp_regex_traits.obj: ../src/cpp_regex_traits.cpp $(ALL_HEADER)
cl $(INCLUDES) /nologo /MTd /W3 /Gm /GX /Zi /Od /I..\..\..\ /DWIN32 /D_MT /D_DEBUG /D_MBCS /D_LIB /YX /FD /GZ /c $(CXXFLAGS) -Fpvc6-stlport/vc6-stlport-re300dm/vc6-stlport-re300dm.pch -Fo./vc6-stlport/vc6-stlport-re300dm/ -Fdvc6-stlport/vc6-stlport-re300dm.pdb ../src/cpp_regex_traits.cpp
vc6-stlport/vc6-stlport-re300dm/cregex.obj: ../src/cregex.cpp $(ALL_HEADER)
cl $(INCLUDES) /nologo /MTd /W3 /Gm /GX /Zi /Od /I..\..\..\ /DWIN32 /D_MT /D_DEBUG /D_MBCS /D_LIB /YX /FD /GZ /c $(CXXFLAGS) -Fpvc6-stlport/vc6-stlport-re300dm/vc6-stlport-re300dm.pch -Fo./vc6-stlport/vc6-stlport-re300dm/ -Fdvc6-stlport/vc6-stlport-re300dm.pdb ../src/cregex.cpp
vc6-stlport/vc6-stlport-re300dm/fileiter.obj: ../src/fileiter.cpp $(ALL_HEADER)
cl $(INCLUDES) /nologo /MTd /W3 /Gm /GX /Zi /Od /I..\..\..\ /DWIN32 /D_MT /D_DEBUG /D_MBCS /D_LIB /YX /FD /GZ /c $(CXXFLAGS) -Fpvc6-stlport/vc6-stlport-re300dm/vc6-stlport-re300dm.pch -Fo./vc6-stlport/vc6-stlport-re300dm/ -Fdvc6-stlport/vc6-stlport-re300dm.pdb ../src/fileiter.cpp
vc6-stlport/vc6-stlport-re300dm/posix_api.obj: ../src/posix_api.cpp $(ALL_HEADER)
cl $(INCLUDES) /nologo /MTd /W3 /Gm /GX /Zi /Od /I..\..\..\ /DWIN32 /D_MT /D_DEBUG /D_MBCS /D_LIB /YX /FD /GZ /c $(CXXFLAGS) -Fpvc6-stlport/vc6-stlport-re300dm/vc6-stlport-re300dm.pch -Fo./vc6-stlport/vc6-stlport-re300dm/ -Fdvc6-stlport/vc6-stlport-re300dm.pdb ../src/posix_api.cpp
vc6-stlport/vc6-stlport-re300dm/regex.obj: ../src/regex.cpp $(ALL_HEADER)
cl $(INCLUDES) /nologo /MTd /W3 /Gm /GX /Zi /Od /I..\..\..\ /DWIN32 /D_MT /D_DEBUG /D_MBCS /D_LIB /YX /FD /GZ /c $(CXXFLAGS) -Fpvc6-stlport/vc6-stlport-re300dm/vc6-stlport-re300dm.pch -Fo./vc6-stlport/vc6-stlport-re300dm/ -Fdvc6-stlport/vc6-stlport-re300dm.pdb ../src/regex.cpp
vc6-stlport/vc6-stlport-re300dm/regex_debug.obj: ../src/regex_debug.cpp $(ALL_HEADER)
cl $(INCLUDES) /nologo /MTd /W3 /Gm /GX /Zi /Od /I..\..\..\ /DWIN32 /D_MT /D_DEBUG /D_MBCS /D_LIB /YX /FD /GZ /c $(CXXFLAGS) -Fpvc6-stlport/vc6-stlport-re300dm/vc6-stlport-re300dm.pch -Fo./vc6-stlport/vc6-stlport-re300dm/ -Fdvc6-stlport/vc6-stlport-re300dm.pdb ../src/regex_debug.cpp
vc6-stlport/vc6-stlport-re300dm/regex_synch.obj: ../src/regex_synch.cpp $(ALL_HEADER)
cl $(INCLUDES) /nologo /MTd /W3 /Gm /GX /Zi /Od /I..\..\..\ /DWIN32 /D_MT /D_DEBUG /D_MBCS /D_LIB /YX /FD /GZ /c $(CXXFLAGS) -Fpvc6-stlport/vc6-stlport-re300dm/vc6-stlport-re300dm.pch -Fo./vc6-stlport/vc6-stlport-re300dm/ -Fdvc6-stlport/vc6-stlport-re300dm.pdb ../src/regex_synch.cpp
vc6-stlport/vc6-stlport-re300dm/w32_regex_traits.obj: ../src/w32_regex_traits.cpp $(ALL_HEADER)
cl $(INCLUDES) /nologo /MTd /W3 /Gm /GX /Zi /Od /I..\..\..\ /DWIN32 /D_MT /D_DEBUG /D_MBCS /D_LIB /YX /FD /GZ /c $(CXXFLAGS) -Fpvc6-stlport/vc6-stlport-re300dm/vc6-stlport-re300dm.pch -Fo./vc6-stlport/vc6-stlport-re300dm/ -Fdvc6-stlport/vc6-stlport-re300dm.pdb ../src/w32_regex_traits.cpp
vc6-stlport/vc6-stlport-re300dm/wide_posix_api.obj: ../src/wide_posix_api.cpp $(ALL_HEADER)
cl $(INCLUDES) /nologo /MTd /W3 /Gm /GX /Zi /Od /I..\..\..\ /DWIN32 /D_MT /D_DEBUG /D_MBCS /D_LIB /YX /FD /GZ /c $(CXXFLAGS) -Fpvc6-stlport/vc6-stlport-re300dm/vc6-stlport-re300dm.pch -Fo./vc6-stlport/vc6-stlport-re300dm/ -Fdvc6-stlport/vc6-stlport-re300dm.pdb ../src/wide_posix_api.cpp
vc6-stlport-re300dm_dir :
if not exist "vc6-stlport\vc6-stlport-re300dm\$(NULL)" mkdir vc6-stlport\vc6-stlport-re300dm
vc6-stlport-re300dm_clean :
del vc6-stlport\vc6-stlport-re300dm\*.obj
del vc6-stlport\vc6-stlport-re300dm\*.idb
del vc6-stlport\vc6-stlport-re300dm\*.exp
del vc6-stlport\vc6-stlport-re300dm\*.pch
./vc6-stlport/vc6-stlport-re300dm.lib : vc6-stlport/vc6-stlport-re300dm/c_regex_traits.obj vc6-stlport/vc6-stlport-re300dm/c_regex_traits_common.obj vc6-stlport/vc6-stlport-re300dm/cpp_regex_traits.obj vc6-stlport/vc6-stlport-re300dm/cregex.obj vc6-stlport/vc6-stlport-re300dm/fileiter.obj vc6-stlport/vc6-stlport-re300dm/posix_api.obj vc6-stlport/vc6-stlport-re300dm/regex.obj vc6-stlport/vc6-stlport-re300dm/regex_debug.obj vc6-stlport/vc6-stlport-re300dm/regex_synch.obj vc6-stlport/vc6-stlport-re300dm/w32_regex_traits.obj vc6-stlport/vc6-stlport-re300dm/wide_posix_api.obj
link -lib /nologo /out:vc6-stlport/vc6-stlport-re300dm.lib $(XSFLAGS) vc6-stlport/vc6-stlport-re300dm/c_regex_traits.obj vc6-stlport/vc6-stlport-re300dm/c_regex_traits_common.obj vc6-stlport/vc6-stlport-re300dm/cpp_regex_traits.obj vc6-stlport/vc6-stlport-re300dm/cregex.obj vc6-stlport/vc6-stlport-re300dm/fileiter.obj vc6-stlport/vc6-stlport-re300dm/posix_api.obj vc6-stlport/vc6-stlport-re300dm/regex.obj vc6-stlport/vc6-stlport-re300dm/regex_debug.obj vc6-stlport/vc6-stlport-re300dm/regex_synch.obj vc6-stlport/vc6-stlport-re300dm/w32_regex_traits.obj vc6-stlport/vc6-stlport-re300dm/wide_posix_api.obj
########################################################
#
# section for vc6-stlport-re300dl.lib
#
########################################################
vc6-stlport/vc6-stlport-re300dl/c_regex_traits.obj: ../src/c_regex_traits.cpp $(ALL_HEADER)
cl $(INCLUDES) /nologo /MDd /W3 /Gm /GX /Zi /Od /I../../../ /D_DEBUG /DWIN32 /D_WINDOWS /D_MBCS /DUSRDLL /DBOOST_RE_DLL_EXPORTS /DBOOST_RE_BUILD_DLL /YX /FD /GZ /c $(CXXFLAGS) -Fpvc6-stlport/vc6-stlport-re300dl/vc6-stlport-re300dl.pch -Fo./vc6-stlport/vc6-stlport-re300dl/ -Fdvc6-stlport/vc6-stlport-re300dl.pdb ../src/c_regex_traits.cpp
vc6-stlport/vc6-stlport-re300dl/c_regex_traits_common.obj: ../src/c_regex_traits_common.cpp $(ALL_HEADER)
cl $(INCLUDES) /nologo /MDd /W3 /Gm /GX /Zi /Od /I../../../ /D_DEBUG /DWIN32 /D_WINDOWS /D_MBCS /DUSRDLL /DBOOST_RE_DLL_EXPORTS /DBOOST_RE_BUILD_DLL /YX /FD /GZ /c $(CXXFLAGS) -Fpvc6-stlport/vc6-stlport-re300dl/vc6-stlport-re300dl.pch -Fo./vc6-stlport/vc6-stlport-re300dl/ -Fdvc6-stlport/vc6-stlport-re300dl.pdb ../src/c_regex_traits_common.cpp
vc6-stlport/vc6-stlport-re300dl/cpp_regex_traits.obj: ../src/cpp_regex_traits.cpp $(ALL_HEADER)
cl $(INCLUDES) /nologo /MDd /W3 /Gm /GX /Zi /Od /I../../../ /D_DEBUG /DWIN32 /D_WINDOWS /D_MBCS /DUSRDLL /DBOOST_RE_DLL_EXPORTS /DBOOST_RE_BUILD_DLL /YX /FD /GZ /c $(CXXFLAGS) -Fpvc6-stlport/vc6-stlport-re300dl/vc6-stlport-re300dl.pch -Fo./vc6-stlport/vc6-stlport-re300dl/ -Fdvc6-stlport/vc6-stlport-re300dl.pdb ../src/cpp_regex_traits.cpp
vc6-stlport/vc6-stlport-re300dl/cregex.obj: ../src/cregex.cpp $(ALL_HEADER)
cl $(INCLUDES) /nologo /MDd /W3 /Gm /GX /Zi /Od /I../../../ /D_DEBUG /DWIN32 /D_WINDOWS /D_MBCS /DUSRDLL /DBOOST_RE_DLL_EXPORTS /DBOOST_RE_BUILD_DLL /YX /FD /GZ /c $(CXXFLAGS) -Fpvc6-stlport/vc6-stlport-re300dl/vc6-stlport-re300dl.pch -Fo./vc6-stlport/vc6-stlport-re300dl/ -Fdvc6-stlport/vc6-stlport-re300dl.pdb ../src/cregex.cpp
vc6-stlport/vc6-stlport-re300dl/fileiter.obj: ../src/fileiter.cpp $(ALL_HEADER)
cl $(INCLUDES) /nologo /MDd /W3 /Gm /GX /Zi /Od /I../../../ /D_DEBUG /DWIN32 /D_WINDOWS /D_MBCS /DUSRDLL /DBOOST_RE_DLL_EXPORTS /DBOOST_RE_BUILD_DLL /YX /FD /GZ /c $(CXXFLAGS) -Fpvc6-stlport/vc6-stlport-re300dl/vc6-stlport-re300dl.pch -Fo./vc6-stlport/vc6-stlport-re300dl/ -Fdvc6-stlport/vc6-stlport-re300dl.pdb ../src/fileiter.cpp
vc6-stlport/vc6-stlport-re300dl/posix_api.obj: ../src/posix_api.cpp $(ALL_HEADER)
cl $(INCLUDES) /nologo /MDd /W3 /Gm /GX /Zi /Od /I../../../ /D_DEBUG /DWIN32 /D_WINDOWS /D_MBCS /DUSRDLL /DBOOST_RE_DLL_EXPORTS /DBOOST_RE_BUILD_DLL /YX /FD /GZ /c $(CXXFLAGS) -Fpvc6-stlport/vc6-stlport-re300dl/vc6-stlport-re300dl.pch -Fo./vc6-stlport/vc6-stlport-re300dl/ -Fdvc6-stlport/vc6-stlport-re300dl.pdb ../src/posix_api.cpp
vc6-stlport/vc6-stlport-re300dl/regex.obj: ../src/regex.cpp $(ALL_HEADER)
cl $(INCLUDES) /nologo /MDd /W3 /Gm /GX /Zi /Od /I../../../ /D_DEBUG /DWIN32 /D_WINDOWS /D_MBCS /DUSRDLL /DBOOST_RE_DLL_EXPORTS /DBOOST_RE_BUILD_DLL /YX /FD /GZ /c $(CXXFLAGS) -Fpvc6-stlport/vc6-stlport-re300dl/vc6-stlport-re300dl.pch -Fo./vc6-stlport/vc6-stlport-re300dl/ -Fdvc6-stlport/vc6-stlport-re300dl.pdb ../src/regex.cpp
vc6-stlport/vc6-stlport-re300dl/regex_debug.obj: ../src/regex_debug.cpp $(ALL_HEADER)
cl $(INCLUDES) /nologo /MDd /W3 /Gm /GX /Zi /Od /I../../../ /D_DEBUG /DWIN32 /D_WINDOWS /D_MBCS /DUSRDLL /DBOOST_RE_DLL_EXPORTS /DBOOST_RE_BUILD_DLL /YX /FD /GZ /c $(CXXFLAGS) -Fpvc6-stlport/vc6-stlport-re300dl/vc6-stlport-re300dl.pch -Fo./vc6-stlport/vc6-stlport-re300dl/ -Fdvc6-stlport/vc6-stlport-re300dl.pdb ../src/regex_debug.cpp
vc6-stlport/vc6-stlport-re300dl/regex_synch.obj: ../src/regex_synch.cpp $(ALL_HEADER)
cl $(INCLUDES) /nologo /MDd /W3 /Gm /GX /Zi /Od /I../../../ /D_DEBUG /DWIN32 /D_WINDOWS /D_MBCS /DUSRDLL /DBOOST_RE_DLL_EXPORTS /DBOOST_RE_BUILD_DLL /YX /FD /GZ /c $(CXXFLAGS) -Fpvc6-stlport/vc6-stlport-re300dl/vc6-stlport-re300dl.pch -Fo./vc6-stlport/vc6-stlport-re300dl/ -Fdvc6-stlport/vc6-stlport-re300dl.pdb ../src/regex_synch.cpp
vc6-stlport/vc6-stlport-re300dl/w32_regex_traits.obj: ../src/w32_regex_traits.cpp $(ALL_HEADER)
cl $(INCLUDES) /nologo /MDd /W3 /Gm /GX /Zi /Od /I../../../ /D_DEBUG /DWIN32 /D_WINDOWS /D_MBCS /DUSRDLL /DBOOST_RE_DLL_EXPORTS /DBOOST_RE_BUILD_DLL /YX /FD /GZ /c $(CXXFLAGS) -Fpvc6-stlport/vc6-stlport-re300dl/vc6-stlport-re300dl.pch -Fo./vc6-stlport/vc6-stlport-re300dl/ -Fdvc6-stlport/vc6-stlport-re300dl.pdb ../src/w32_regex_traits.cpp
vc6-stlport/vc6-stlport-re300dl/wide_posix_api.obj: ../src/wide_posix_api.cpp $(ALL_HEADER)
cl $(INCLUDES) /nologo /MDd /W3 /Gm /GX /Zi /Od /I../../../ /D_DEBUG /DWIN32 /D_WINDOWS /D_MBCS /DUSRDLL /DBOOST_RE_DLL_EXPORTS /DBOOST_RE_BUILD_DLL /YX /FD /GZ /c $(CXXFLAGS) -Fpvc6-stlport/vc6-stlport-re300dl/vc6-stlport-re300dl.pch -Fo./vc6-stlport/vc6-stlport-re300dl/ -Fdvc6-stlport/vc6-stlport-re300dl.pdb ../src/wide_posix_api.cpp
vc6-stlport-re300dl_dir :
if not exist "vc6-stlport\vc6-stlport-re300dl\$(NULL)" mkdir vc6-stlport\vc6-stlport-re300dl
vc6-stlport-re300dl_clean :
del vc6-stlport\vc6-stlport-re300dl\*.obj
del vc6-stlport\vc6-stlport-re300dl\*.idb
del vc6-stlport\vc6-stlport-re300dl\*.exp
del vc6-stlport\vc6-stlport-re300dl\*.pch
./vc6-stlport/vc6-stlport-re300dl.lib : vc6-stlport/vc6-stlport-re300dl/c_regex_traits.obj vc6-stlport/vc6-stlport-re300dl/c_regex_traits_common.obj vc6-stlport/vc6-stlport-re300dl/cpp_regex_traits.obj vc6-stlport/vc6-stlport-re300dl/cregex.obj vc6-stlport/vc6-stlport-re300dl/fileiter.obj vc6-stlport/vc6-stlport-re300dl/posix_api.obj vc6-stlport/vc6-stlport-re300dl/regex.obj vc6-stlport/vc6-stlport-re300dl/regex_debug.obj vc6-stlport/vc6-stlport-re300dl/regex_synch.obj vc6-stlport/vc6-stlport-re300dl/w32_regex_traits.obj vc6-stlport/vc6-stlport-re300dl/wide_posix_api.obj
link @<<
kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib /nologo /dll /incremental:yes /pdb:"vc6-stlport/vc6-stlport-re300dl.pdb" /debug /machine:I386 /out:"vc6-stlport/vc6-stlport-re300dl.dll" /implib:"vc6-stlport/vc6-stlport-re300dl.lib" /pdbtype:sept $(XLFLAGS) vc6-stlport/vc6-stlport-re300dl/c_regex_traits.obj vc6-stlport/vc6-stlport-re300dl/c_regex_traits_common.obj vc6-stlport/vc6-stlport-re300dl/cpp_regex_traits.obj vc6-stlport/vc6-stlport-re300dl/cregex.obj vc6-stlport/vc6-stlport-re300dl/fileiter.obj vc6-stlport/vc6-stlport-re300dl/posix_api.obj vc6-stlport/vc6-stlport-re300dl/regex.obj vc6-stlport/vc6-stlport-re300dl/regex_debug.obj vc6-stlport/vc6-stlport-re300dl/regex_synch.obj vc6-stlport/vc6-stlport-re300dl/w32_regex_traits.obj vc6-stlport/vc6-stlport-re300dl/wide_posix_api.obj
<<
########################################################
#
# section for vc6-stlport-re300l.lib
#
########################################################
vc6-stlport/vc6-stlport-re300l/c_regex_traits.obj: ../src/c_regex_traits.cpp $(ALL_HEADER)
cl $(INCLUDES) /nologo /MD /W3 /GX /Oityb1 /GF /Gy /I../../../ /DNDEBUG /DWIN32 /D_WINDOWS /D_MBCS /D_USRDLL /DBOOST_RE_DLL_EXPORTS /DBOOST_RE_BUILD_DLL /YX /FD /c $(CXXFLAGS) -Fpvc6-stlport/vc6-stlport-re300l/vc6-stlport-re300l.pch -Fo./vc6-stlport/vc6-stlport-re300l/ -Fdvc6-stlport/vc6-stlport-re300l.pdb ../src/c_regex_traits.cpp
vc6-stlport/vc6-stlport-re300l/c_regex_traits_common.obj: ../src/c_regex_traits_common.cpp $(ALL_HEADER)
cl $(INCLUDES) /nologo /MD /W3 /GX /Oityb1 /GF /Gy /I../../../ /DNDEBUG /DWIN32 /D_WINDOWS /D_MBCS /D_USRDLL /DBOOST_RE_DLL_EXPORTS /DBOOST_RE_BUILD_DLL /YX /FD /c $(CXXFLAGS) -Fpvc6-stlport/vc6-stlport-re300l/vc6-stlport-re300l.pch -Fo./vc6-stlport/vc6-stlport-re300l/ -Fdvc6-stlport/vc6-stlport-re300l.pdb ../src/c_regex_traits_common.cpp
vc6-stlport/vc6-stlport-re300l/cpp_regex_traits.obj: ../src/cpp_regex_traits.cpp $(ALL_HEADER)
cl $(INCLUDES) /nologo /MD /W3 /GX /Oityb1 /GF /Gy /I../../../ /DNDEBUG /DWIN32 /D_WINDOWS /D_MBCS /D_USRDLL /DBOOST_RE_DLL_EXPORTS /DBOOST_RE_BUILD_DLL /YX /FD /c $(CXXFLAGS) -Fpvc6-stlport/vc6-stlport-re300l/vc6-stlport-re300l.pch -Fo./vc6-stlport/vc6-stlport-re300l/ -Fdvc6-stlport/vc6-stlport-re300l.pdb ../src/cpp_regex_traits.cpp
vc6-stlport/vc6-stlport-re300l/cregex.obj: ../src/cregex.cpp $(ALL_HEADER)
cl $(INCLUDES) /nologo /MD /W3 /GX /Oityb1 /GF /Gy /I../../../ /DNDEBUG /DWIN32 /D_WINDOWS /D_MBCS /D_USRDLL /DBOOST_RE_DLL_EXPORTS /DBOOST_RE_BUILD_DLL /YX /FD /c $(CXXFLAGS) -Fpvc6-stlport/vc6-stlport-re300l/vc6-stlport-re300l.pch -Fo./vc6-stlport/vc6-stlport-re300l/ -Fdvc6-stlport/vc6-stlport-re300l.pdb ../src/cregex.cpp
vc6-stlport/vc6-stlport-re300l/fileiter.obj: ../src/fileiter.cpp $(ALL_HEADER)
cl $(INCLUDES) /nologo /MD /W3 /GX /Oityb1 /GF /Gy /I../../../ /DNDEBUG /DWIN32 /D_WINDOWS /D_MBCS /D_USRDLL /DBOOST_RE_DLL_EXPORTS /DBOOST_RE_BUILD_DLL /YX /FD /c $(CXXFLAGS) -Fpvc6-stlport/vc6-stlport-re300l/vc6-stlport-re300l.pch -Fo./vc6-stlport/vc6-stlport-re300l/ -Fdvc6-stlport/vc6-stlport-re300l.pdb ../src/fileiter.cpp
vc6-stlport/vc6-stlport-re300l/posix_api.obj: ../src/posix_api.cpp $(ALL_HEADER)
cl $(INCLUDES) /nologo /MD /W3 /GX /Oityb1 /GF /Gy /I../../../ /DNDEBUG /DWIN32 /D_WINDOWS /D_MBCS /D_USRDLL /DBOOST_RE_DLL_EXPORTS /DBOOST_RE_BUILD_DLL /YX /FD /c $(CXXFLAGS) -Fpvc6-stlport/vc6-stlport-re300l/vc6-stlport-re300l.pch -Fo./vc6-stlport/vc6-stlport-re300l/ -Fdvc6-stlport/vc6-stlport-re300l.pdb ../src/posix_api.cpp
vc6-stlport/vc6-stlport-re300l/regex.obj: ../src/regex.cpp $(ALL_HEADER)
cl $(INCLUDES) /nologo /MD /W3 /GX /Oityb1 /GF /Gy /I../../../ /DNDEBUG /DWIN32 /D_WINDOWS /D_MBCS /D_USRDLL /DBOOST_RE_DLL_EXPORTS /DBOOST_RE_BUILD_DLL /YX /FD /c $(CXXFLAGS) -Fpvc6-stlport/vc6-stlport-re300l/vc6-stlport-re300l.pch -Fo./vc6-stlport/vc6-stlport-re300l/ -Fdvc6-stlport/vc6-stlport-re300l.pdb ../src/regex.cpp
vc6-stlport/vc6-stlport-re300l/regex_debug.obj: ../src/regex_debug.cpp $(ALL_HEADER)
cl $(INCLUDES) /nologo /MD /W3 /GX /Oityb1 /GF /Gy /I../../../ /DNDEBUG /DWIN32 /D_WINDOWS /D_MBCS /D_USRDLL /DBOOST_RE_DLL_EXPORTS /DBOOST_RE_BUILD_DLL /YX /FD /c $(CXXFLAGS) -Fpvc6-stlport/vc6-stlport-re300l/vc6-stlport-re300l.pch -Fo./vc6-stlport/vc6-stlport-re300l/ -Fdvc6-stlport/vc6-stlport-re300l.pdb ../src/regex_debug.cpp
vc6-stlport/vc6-stlport-re300l/regex_synch.obj: ../src/regex_synch.cpp $(ALL_HEADER)
cl $(INCLUDES) /nologo /MD /W3 /GX /Oityb1 /GF /Gy /I../../../ /DNDEBUG /DWIN32 /D_WINDOWS /D_MBCS /D_USRDLL /DBOOST_RE_DLL_EXPORTS /DBOOST_RE_BUILD_DLL /YX /FD /c $(CXXFLAGS) -Fpvc6-stlport/vc6-stlport-re300l/vc6-stlport-re300l.pch -Fo./vc6-stlport/vc6-stlport-re300l/ -Fdvc6-stlport/vc6-stlport-re300l.pdb ../src/regex_synch.cpp
vc6-stlport/vc6-stlport-re300l/w32_regex_traits.obj: ../src/w32_regex_traits.cpp $(ALL_HEADER)
cl $(INCLUDES) /nologo /MD /W3 /GX /Oityb1 /GF /Gy /I../../../ /DNDEBUG /DWIN32 /D_WINDOWS /D_MBCS /D_USRDLL /DBOOST_RE_DLL_EXPORTS /DBOOST_RE_BUILD_DLL /YX /FD /c $(CXXFLAGS) -Fpvc6-stlport/vc6-stlport-re300l/vc6-stlport-re300l.pch -Fo./vc6-stlport/vc6-stlport-re300l/ -Fdvc6-stlport/vc6-stlport-re300l.pdb ../src/w32_regex_traits.cpp
vc6-stlport/vc6-stlport-re300l/wide_posix_api.obj: ../src/wide_posix_api.cpp $(ALL_HEADER)
cl $(INCLUDES) /nologo /MD /W3 /GX /Oityb1 /GF /Gy /I../../../ /DNDEBUG /DWIN32 /D_WINDOWS /D_MBCS /D_USRDLL /DBOOST_RE_DLL_EXPORTS /DBOOST_RE_BUILD_DLL /YX /FD /c $(CXXFLAGS) -Fpvc6-stlport/vc6-stlport-re300l/vc6-stlport-re300l.pch -Fo./vc6-stlport/vc6-stlport-re300l/ -Fdvc6-stlport/vc6-stlport-re300l.pdb ../src/wide_posix_api.cpp
vc6-stlport-re300l_dir :
if not exist "vc6-stlport\vc6-stlport-re300l\$(NULL)" mkdir vc6-stlport\vc6-stlport-re300l
vc6-stlport-re300l_clean :
del vc6-stlport\vc6-stlport-re300l\*.obj
del vc6-stlport\vc6-stlport-re300l\*.idb
del vc6-stlport\vc6-stlport-re300l\*.exp
del vc6-stlport\vc6-stlport-re300l\*.pch
./vc6-stlport/vc6-stlport-re300l.lib : vc6-stlport/vc6-stlport-re300l/c_regex_traits.obj vc6-stlport/vc6-stlport-re300l/c_regex_traits_common.obj vc6-stlport/vc6-stlport-re300l/cpp_regex_traits.obj vc6-stlport/vc6-stlport-re300l/cregex.obj vc6-stlport/vc6-stlport-re300l/fileiter.obj vc6-stlport/vc6-stlport-re300l/posix_api.obj vc6-stlport/vc6-stlport-re300l/regex.obj vc6-stlport/vc6-stlport-re300l/regex_debug.obj vc6-stlport/vc6-stlport-re300l/regex_synch.obj vc6-stlport/vc6-stlport-re300l/w32_regex_traits.obj vc6-stlport/vc6-stlport-re300l/wide_posix_api.obj
link @<<
kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib /nologo /dll /incremental:yes /pdb:"vc6-stlport/vc6-stlport-re300l.pdb" /debug /machine:I386 /out:"vc6-stlport/vc6-stlport-re300l.dll" /implib:"vc6-stlport/vc6-stlport-re300l.lib" /pdbtype:sept $(XLFLAGS) vc6-stlport/vc6-stlport-re300l/c_regex_traits.obj vc6-stlport/vc6-stlport-re300l/c_regex_traits_common.obj vc6-stlport/vc6-stlport-re300l/cpp_regex_traits.obj vc6-stlport/vc6-stlport-re300l/cregex.obj vc6-stlport/vc6-stlport-re300l/fileiter.obj vc6-stlport/vc6-stlport-re300l/posix_api.obj vc6-stlport/vc6-stlport-re300l/regex.obj vc6-stlport/vc6-stlport-re300l/regex_debug.obj vc6-stlport/vc6-stlport-re300l/regex_synch.obj vc6-stlport/vc6-stlport-re300l/w32_regex_traits.obj vc6-stlport/vc6-stlport-re300l/wide_posix_api.obj
<<
########################################################
#
# section for vc6-stlport-re300ls.lib
#
########################################################
vc6-stlport/vc6-stlport-re300ls/c_regex_traits.obj: ../src/c_regex_traits.cpp $(ALL_HEADER)
cl $(INCLUDES) /nologo /MD /W3 /GX /Oityb1 /GF /Gy /I../../../ /DNDEBUG /DWIN32 /D_WINDOWS /D_MBCS /D_USRDLL /DBOOST_RE_STATIC_LIB /YX /FD /c $(CXXFLAGS) -Fpvc6-stlport/vc6-stlport-re300ls/vc6-stlport-re300ls.pch -Fo./vc6-stlport/vc6-stlport-re300ls/ -Fdvc6-stlport/vc6-stlport-re300ls.pdb ../src/c_regex_traits.cpp
vc6-stlport/vc6-stlport-re300ls/c_regex_traits_common.obj: ../src/c_regex_traits_common.cpp $(ALL_HEADER)
cl $(INCLUDES) /nologo /MD /W3 /GX /Oityb1 /GF /Gy /I../../../ /DNDEBUG /DWIN32 /D_WINDOWS /D_MBCS /D_USRDLL /DBOOST_RE_STATIC_LIB /YX /FD /c $(CXXFLAGS) -Fpvc6-stlport/vc6-stlport-re300ls/vc6-stlport-re300ls.pch -Fo./vc6-stlport/vc6-stlport-re300ls/ -Fdvc6-stlport/vc6-stlport-re300ls.pdb ../src/c_regex_traits_common.cpp
vc6-stlport/vc6-stlport-re300ls/cpp_regex_traits.obj: ../src/cpp_regex_traits.cpp $(ALL_HEADER)
cl $(INCLUDES) /nologo /MD /W3 /GX /Oityb1 /GF /Gy /I../../../ /DNDEBUG /DWIN32 /D_WINDOWS /D_MBCS /D_USRDLL /DBOOST_RE_STATIC_LIB /YX /FD /c $(CXXFLAGS) -Fpvc6-stlport/vc6-stlport-re300ls/vc6-stlport-re300ls.pch -Fo./vc6-stlport/vc6-stlport-re300ls/ -Fdvc6-stlport/vc6-stlport-re300ls.pdb ../src/cpp_regex_traits.cpp
vc6-stlport/vc6-stlport-re300ls/cregex.obj: ../src/cregex.cpp $(ALL_HEADER)
cl $(INCLUDES) /nologo /MD /W3 /GX /Oityb1 /GF /Gy /I../../../ /DNDEBUG /DWIN32 /D_WINDOWS /D_MBCS /D_USRDLL /DBOOST_RE_STATIC_LIB /YX /FD /c $(CXXFLAGS) -Fpvc6-stlport/vc6-stlport-re300ls/vc6-stlport-re300ls.pch -Fo./vc6-stlport/vc6-stlport-re300ls/ -Fdvc6-stlport/vc6-stlport-re300ls.pdb ../src/cregex.cpp
vc6-stlport/vc6-stlport-re300ls/fileiter.obj: ../src/fileiter.cpp $(ALL_HEADER)
cl $(INCLUDES) /nologo /MD /W3 /GX /Oityb1 /GF /Gy /I../../../ /DNDEBUG /DWIN32 /D_WINDOWS /D_MBCS /D_USRDLL /DBOOST_RE_STATIC_LIB /YX /FD /c $(CXXFLAGS) -Fpvc6-stlport/vc6-stlport-re300ls/vc6-stlport-re300ls.pch -Fo./vc6-stlport/vc6-stlport-re300ls/ -Fdvc6-stlport/vc6-stlport-re300ls.pdb ../src/fileiter.cpp
vc6-stlport/vc6-stlport-re300ls/posix_api.obj: ../src/posix_api.cpp $(ALL_HEADER)
cl $(INCLUDES) /nologo /MD /W3 /GX /Oityb1 /GF /Gy /I../../../ /DNDEBUG /DWIN32 /D_WINDOWS /D_MBCS /D_USRDLL /DBOOST_RE_STATIC_LIB /YX /FD /c $(CXXFLAGS) -Fpvc6-stlport/vc6-stlport-re300ls/vc6-stlport-re300ls.pch -Fo./vc6-stlport/vc6-stlport-re300ls/ -Fdvc6-stlport/vc6-stlport-re300ls.pdb ../src/posix_api.cpp
vc6-stlport/vc6-stlport-re300ls/regex.obj: ../src/regex.cpp $(ALL_HEADER)
cl $(INCLUDES) /nologo /MD /W3 /GX /Oityb1 /GF /Gy /I../../../ /DNDEBUG /DWIN32 /D_WINDOWS /D_MBCS /D_USRDLL /DBOOST_RE_STATIC_LIB /YX /FD /c $(CXXFLAGS) -Fpvc6-stlport/vc6-stlport-re300ls/vc6-stlport-re300ls.pch -Fo./vc6-stlport/vc6-stlport-re300ls/ -Fdvc6-stlport/vc6-stlport-re300ls.pdb ../src/regex.cpp
vc6-stlport/vc6-stlport-re300ls/regex_debug.obj: ../src/regex_debug.cpp $(ALL_HEADER)
cl $(INCLUDES) /nologo /MD /W3 /GX /Oityb1 /GF /Gy /I../../../ /DNDEBUG /DWIN32 /D_WINDOWS /D_MBCS /D_USRDLL /DBOOST_RE_STATIC_LIB /YX /FD /c $(CXXFLAGS) -Fpvc6-stlport/vc6-stlport-re300ls/vc6-stlport-re300ls.pch -Fo./vc6-stlport/vc6-stlport-re300ls/ -Fdvc6-stlport/vc6-stlport-re300ls.pdb ../src/regex_debug.cpp
vc6-stlport/vc6-stlport-re300ls/regex_synch.obj: ../src/regex_synch.cpp $(ALL_HEADER)
cl $(INCLUDES) /nologo /MD /W3 /GX /Oityb1 /GF /Gy /I../../../ /DNDEBUG /DWIN32 /D_WINDOWS /D_MBCS /D_USRDLL /DBOOST_RE_STATIC_LIB /YX /FD /c $(CXXFLAGS) -Fpvc6-stlport/vc6-stlport-re300ls/vc6-stlport-re300ls.pch -Fo./vc6-stlport/vc6-stlport-re300ls/ -Fdvc6-stlport/vc6-stlport-re300ls.pdb ../src/regex_synch.cpp
vc6-stlport/vc6-stlport-re300ls/w32_regex_traits.obj: ../src/w32_regex_traits.cpp $(ALL_HEADER)
cl $(INCLUDES) /nologo /MD /W3 /GX /Oityb1 /GF /Gy /I../../../ /DNDEBUG /DWIN32 /D_WINDOWS /D_MBCS /D_USRDLL /DBOOST_RE_STATIC_LIB /YX /FD /c $(CXXFLAGS) -Fpvc6-stlport/vc6-stlport-re300ls/vc6-stlport-re300ls.pch -Fo./vc6-stlport/vc6-stlport-re300ls/ -Fdvc6-stlport/vc6-stlport-re300ls.pdb ../src/w32_regex_traits.cpp
vc6-stlport/vc6-stlport-re300ls/wide_posix_api.obj: ../src/wide_posix_api.cpp $(ALL_HEADER)
cl $(INCLUDES) /nologo /MD /W3 /GX /Oityb1 /GF /Gy /I../../../ /DNDEBUG /DWIN32 /D_WINDOWS /D_MBCS /D_USRDLL /DBOOST_RE_STATIC_LIB /YX /FD /c $(CXXFLAGS) -Fpvc6-stlport/vc6-stlport-re300ls/vc6-stlport-re300ls.pch -Fo./vc6-stlport/vc6-stlport-re300ls/ -Fdvc6-stlport/vc6-stlport-re300ls.pdb ../src/wide_posix_api.cpp
vc6-stlport-re300ls_dir :
if not exist "vc6-stlport\vc6-stlport-re300ls\$(NULL)" mkdir vc6-stlport\vc6-stlport-re300ls
vc6-stlport-re300ls_clean :
del vc6-stlport\vc6-stlport-re300ls\*.obj
del vc6-stlport\vc6-stlport-re300ls\*.idb
del vc6-stlport\vc6-stlport-re300ls\*.exp
del vc6-stlport\vc6-stlport-re300ls\*.pch
./vc6-stlport/vc6-stlport-re300ls.lib : vc6-stlport/vc6-stlport-re300ls/c_regex_traits.obj vc6-stlport/vc6-stlport-re300ls/c_regex_traits_common.obj vc6-stlport/vc6-stlport-re300ls/cpp_regex_traits.obj vc6-stlport/vc6-stlport-re300ls/cregex.obj vc6-stlport/vc6-stlport-re300ls/fileiter.obj vc6-stlport/vc6-stlport-re300ls/posix_api.obj vc6-stlport/vc6-stlport-re300ls/regex.obj vc6-stlport/vc6-stlport-re300ls/regex_debug.obj vc6-stlport/vc6-stlport-re300ls/regex_synch.obj vc6-stlport/vc6-stlport-re300ls/w32_regex_traits.obj vc6-stlport/vc6-stlport-re300ls/wide_posix_api.obj
link -lib /nologo /out:vc6-stlport/vc6-stlport-re300ls.lib $(XSFLAGS) vc6-stlport/vc6-stlport-re300ls/c_regex_traits.obj vc6-stlport/vc6-stlport-re300ls/c_regex_traits_common.obj vc6-stlport/vc6-stlport-re300ls/cpp_regex_traits.obj vc6-stlport/vc6-stlport-re300ls/cregex.obj vc6-stlport/vc6-stlport-re300ls/fileiter.obj vc6-stlport/vc6-stlport-re300ls/posix_api.obj vc6-stlport/vc6-stlport-re300ls/regex.obj vc6-stlport/vc6-stlport-re300ls/regex_debug.obj vc6-stlport/vc6-stlport-re300ls/regex_synch.obj vc6-stlport/vc6-stlport-re300ls/w32_regex_traits.obj vc6-stlport/vc6-stlport-re300ls/wide_posix_api.obj
########################################################
#
# section for vc6-stlport-re300ddl.lib
#
########################################################
vc6-stlport/vc6-stlport-re300ddl/c_regex_traits.obj: ../src/c_regex_traits.cpp $(ALL_HEADER)
cl $(INCLUDES) /nologo /MDd /W3 /Gm /GX /Zi /Od /I../../../ /D__STL_DEBUG /D_DEBUG /DWIN32 /D_WINDOWS /D_MBCS /DUSRDLL /DBOOST_RE_DLL_EXPORTS /DBOOST_RE_BUILD_DLL /YX /FD /GZ /c $(CXXFLAGS) -Fpvc6-stlport/vc6-stlport-re300ddl/vc6-stlport-re300ddl.pch -Fo./vc6-stlport/vc6-stlport-re300ddl/ -Fdvc6-stlport/vc6-stlport-re300ddl.pdb ../src/c_regex_traits.cpp
vc6-stlport/vc6-stlport-re300ddl/c_regex_traits_common.obj: ../src/c_regex_traits_common.cpp $(ALL_HEADER)
cl $(INCLUDES) /nologo /MDd /W3 /Gm /GX /Zi /Od /I../../../ /D__STL_DEBUG /D_DEBUG /DWIN32 /D_WINDOWS /D_MBCS /DUSRDLL /DBOOST_RE_DLL_EXPORTS /DBOOST_RE_BUILD_DLL /YX /FD /GZ /c $(CXXFLAGS) -Fpvc6-stlport/vc6-stlport-re300ddl/vc6-stlport-re300ddl.pch -Fo./vc6-stlport/vc6-stlport-re300ddl/ -Fdvc6-stlport/vc6-stlport-re300ddl.pdb ../src/c_regex_traits_common.cpp
vc6-stlport/vc6-stlport-re300ddl/cpp_regex_traits.obj: ../src/cpp_regex_traits.cpp $(ALL_HEADER)
cl $(INCLUDES) /nologo /MDd /W3 /Gm /GX /Zi /Od /I../../../ /D__STL_DEBUG /D_DEBUG /DWIN32 /D_WINDOWS /D_MBCS /DUSRDLL /DBOOST_RE_DLL_EXPORTS /DBOOST_RE_BUILD_DLL /YX /FD /GZ /c $(CXXFLAGS) -Fpvc6-stlport/vc6-stlport-re300ddl/vc6-stlport-re300ddl.pch -Fo./vc6-stlport/vc6-stlport-re300ddl/ -Fdvc6-stlport/vc6-stlport-re300ddl.pdb ../src/cpp_regex_traits.cpp
vc6-stlport/vc6-stlport-re300ddl/cregex.obj: ../src/cregex.cpp $(ALL_HEADER)
cl $(INCLUDES) /nologo /MDd /W3 /Gm /GX /Zi /Od /I../../../ /D__STL_DEBUG /D_DEBUG /DWIN32 /D_WINDOWS /D_MBCS /DUSRDLL /DBOOST_RE_DLL_EXPORTS /DBOOST_RE_BUILD_DLL /YX /FD /GZ /c $(CXXFLAGS) -Fpvc6-stlport/vc6-stlport-re300ddl/vc6-stlport-re300ddl.pch -Fo./vc6-stlport/vc6-stlport-re300ddl/ -Fdvc6-stlport/vc6-stlport-re300ddl.pdb ../src/cregex.cpp
vc6-stlport/vc6-stlport-re300ddl/fileiter.obj: ../src/fileiter.cpp $(ALL_HEADER)
cl $(INCLUDES) /nologo /MDd /W3 /Gm /GX /Zi /Od /I../../../ /D__STL_DEBUG /D_DEBUG /DWIN32 /D_WINDOWS /D_MBCS /DUSRDLL /DBOOST_RE_DLL_EXPORTS /DBOOST_RE_BUILD_DLL /YX /FD /GZ /c $(CXXFLAGS) -Fpvc6-stlport/vc6-stlport-re300ddl/vc6-stlport-re300ddl.pch -Fo./vc6-stlport/vc6-stlport-re300ddl/ -Fdvc6-stlport/vc6-stlport-re300ddl.pdb ../src/fileiter.cpp
vc6-stlport/vc6-stlport-re300ddl/posix_api.obj: ../src/posix_api.cpp $(ALL_HEADER)
cl $(INCLUDES) /nologo /MDd /W3 /Gm /GX /Zi /Od /I../../../ /D__STL_DEBUG /D_DEBUG /DWIN32 /D_WINDOWS /D_MBCS /DUSRDLL /DBOOST_RE_DLL_EXPORTS /DBOOST_RE_BUILD_DLL /YX /FD /GZ /c $(CXXFLAGS) -Fpvc6-stlport/vc6-stlport-re300ddl/vc6-stlport-re300ddl.pch -Fo./vc6-stlport/vc6-stlport-re300ddl/ -Fdvc6-stlport/vc6-stlport-re300ddl.pdb ../src/posix_api.cpp
vc6-stlport/vc6-stlport-re300ddl/regex.obj: ../src/regex.cpp $(ALL_HEADER)
cl $(INCLUDES) /nologo /MDd /W3 /Gm /GX /Zi /Od /I../../../ /D__STL_DEBUG /D_DEBUG /DWIN32 /D_WINDOWS /D_MBCS /DUSRDLL /DBOOST_RE_DLL_EXPORTS /DBOOST_RE_BUILD_DLL /YX /FD /GZ /c $(CXXFLAGS) -Fpvc6-stlport/vc6-stlport-re300ddl/vc6-stlport-re300ddl.pch -Fo./vc6-stlport/vc6-stlport-re300ddl/ -Fdvc6-stlport/vc6-stlport-re300ddl.pdb ../src/regex.cpp
vc6-stlport/vc6-stlport-re300ddl/regex_debug.obj: ../src/regex_debug.cpp $(ALL_HEADER)
cl $(INCLUDES) /nologo /MDd /W3 /Gm /GX /Zi /Od /I../../../ /D__STL_DEBUG /D_DEBUG /DWIN32 /D_WINDOWS /D_MBCS /DUSRDLL /DBOOST_RE_DLL_EXPORTS /DBOOST_RE_BUILD_DLL /YX /FD /GZ /c $(CXXFLAGS) -Fpvc6-stlport/vc6-stlport-re300ddl/vc6-stlport-re300ddl.pch -Fo./vc6-stlport/vc6-stlport-re300ddl/ -Fdvc6-stlport/vc6-stlport-re300ddl.pdb ../src/regex_debug.cpp
vc6-stlport/vc6-stlport-re300ddl/regex_synch.obj: ../src/regex_synch.cpp $(ALL_HEADER)
cl $(INCLUDES) /nologo /MDd /W3 /Gm /GX /Zi /Od /I../../../ /D__STL_DEBUG /D_DEBUG /DWIN32 /D_WINDOWS /D_MBCS /DUSRDLL /DBOOST_RE_DLL_EXPORTS /DBOOST_RE_BUILD_DLL /YX /FD /GZ /c $(CXXFLAGS) -Fpvc6-stlport/vc6-stlport-re300ddl/vc6-stlport-re300ddl.pch -Fo./vc6-stlport/vc6-stlport-re300ddl/ -Fdvc6-stlport/vc6-stlport-re300ddl.pdb ../src/regex_synch.cpp
vc6-stlport/vc6-stlport-re300ddl/w32_regex_traits.obj: ../src/w32_regex_traits.cpp $(ALL_HEADER)
cl $(INCLUDES) /nologo /MDd /W3 /Gm /GX /Zi /Od /I../../../ /D__STL_DEBUG /D_DEBUG /DWIN32 /D_WINDOWS /D_MBCS /DUSRDLL /DBOOST_RE_DLL_EXPORTS /DBOOST_RE_BUILD_DLL /YX /FD /GZ /c $(CXXFLAGS) -Fpvc6-stlport/vc6-stlport-re300ddl/vc6-stlport-re300ddl.pch -Fo./vc6-stlport/vc6-stlport-re300ddl/ -Fdvc6-stlport/vc6-stlport-re300ddl.pdb ../src/w32_regex_traits.cpp
vc6-stlport/vc6-stlport-re300ddl/wide_posix_api.obj: ../src/wide_posix_api.cpp $(ALL_HEADER)
cl $(INCLUDES) /nologo /MDd /W3 /Gm /GX /Zi /Od /I../../../ /D__STL_DEBUG /D_DEBUG /DWIN32 /D_WINDOWS /D_MBCS /DUSRDLL /DBOOST_RE_DLL_EXPORTS /DBOOST_RE_BUILD_DLL /YX /FD /GZ /c $(CXXFLAGS) -Fpvc6-stlport/vc6-stlport-re300ddl/vc6-stlport-re300ddl.pch -Fo./vc6-stlport/vc6-stlport-re300ddl/ -Fdvc6-stlport/vc6-stlport-re300ddl.pdb ../src/wide_posix_api.cpp
vc6-stlport-re300ddl_dir :
if not exist "vc6-stlport\vc6-stlport-re300ddl\$(NULL)" mkdir vc6-stlport\vc6-stlport-re300ddl
vc6-stlport-re300ddl_clean :
del vc6-stlport\vc6-stlport-re300ddl\*.obj
del vc6-stlport\vc6-stlport-re300ddl\*.idb
del vc6-stlport\vc6-stlport-re300ddl\*.exp
del vc6-stlport\vc6-stlport-re300ddl\*.pch
./vc6-stlport/vc6-stlport-re300ddl.lib : vc6-stlport/vc6-stlport-re300ddl/c_regex_traits.obj vc6-stlport/vc6-stlport-re300ddl/c_regex_traits_common.obj vc6-stlport/vc6-stlport-re300ddl/cpp_regex_traits.obj vc6-stlport/vc6-stlport-re300ddl/cregex.obj vc6-stlport/vc6-stlport-re300ddl/fileiter.obj vc6-stlport/vc6-stlport-re300ddl/posix_api.obj vc6-stlport/vc6-stlport-re300ddl/regex.obj vc6-stlport/vc6-stlport-re300ddl/regex_debug.obj vc6-stlport/vc6-stlport-re300ddl/regex_synch.obj vc6-stlport/vc6-stlport-re300ddl/w32_regex_traits.obj vc6-stlport/vc6-stlport-re300ddl/wide_posix_api.obj
link @<<
kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib /nologo /dll /incremental:yes /pdb:"vc6-stlport/vc6-stlport-re300ddl.pdb" /debug /machine:I386 /out:"vc6-stlport/vc6-stlport-re300ddl.dll" /implib:"vc6-stlport/vc6-stlport-re300ddl.lib" /pdbtype:sept $(XLFLAGS) vc6-stlport/vc6-stlport-re300ddl/c_regex_traits.obj vc6-stlport/vc6-stlport-re300ddl/c_regex_traits_common.obj vc6-stlport/vc6-stlport-re300ddl/cpp_regex_traits.obj vc6-stlport/vc6-stlport-re300ddl/cregex.obj vc6-stlport/vc6-stlport-re300ddl/fileiter.obj vc6-stlport/vc6-stlport-re300ddl/posix_api.obj vc6-stlport/vc6-stlport-re300ddl/regex.obj vc6-stlport/vc6-stlport-re300ddl/regex_debug.obj vc6-stlport/vc6-stlport-re300ddl/regex_synch.obj vc6-stlport/vc6-stlport-re300ddl/w32_regex_traits.obj vc6-stlport/vc6-stlport-re300ddl/wide_posix_api.obj
<<
########################################################
#
# section for vc6-stlport-re300ddm.lib
#
########################################################
vc6-stlport/vc6-stlport-re300ddm/c_regex_traits.obj: ../src/c_regex_traits.cpp $(ALL_HEADER)
cl $(INCLUDES) /nologo /MTd /W3 /Gm /GX /Zi /Od /I..\..\..\ /D__STL_DEBUG /DWIN32 /D_MT /D_DEBUG /D_MBCS /D_LIB /YX /FD /GZ /c $(CXXFLAGS) -Fpvc6-stlport/vc6-stlport-re300ddm/vc6-stlport-re300ddm.pch -Fo./vc6-stlport/vc6-stlport-re300ddm/ -Fdvc6-stlport/vc6-stlport-re300ddm.pdb ../src/c_regex_traits.cpp
vc6-stlport/vc6-stlport-re300ddm/c_regex_traits_common.obj: ../src/c_regex_traits_common.cpp $(ALL_HEADER)
cl $(INCLUDES) /nologo /MTd /W3 /Gm /GX /Zi /Od /I..\..\..\ /D__STL_DEBUG /DWIN32 /D_MT /D_DEBUG /D_MBCS /D_LIB /YX /FD /GZ /c $(CXXFLAGS) -Fpvc6-stlport/vc6-stlport-re300ddm/vc6-stlport-re300ddm.pch -Fo./vc6-stlport/vc6-stlport-re300ddm/ -Fdvc6-stlport/vc6-stlport-re300ddm.pdb ../src/c_regex_traits_common.cpp
vc6-stlport/vc6-stlport-re300ddm/cpp_regex_traits.obj: ../src/cpp_regex_traits.cpp $(ALL_HEADER)
cl $(INCLUDES) /nologo /MTd /W3 /Gm /GX /Zi /Od /I..\..\..\ /D__STL_DEBUG /DWIN32 /D_MT /D_DEBUG /D_MBCS /D_LIB /YX /FD /GZ /c $(CXXFLAGS) -Fpvc6-stlport/vc6-stlport-re300ddm/vc6-stlport-re300ddm.pch -Fo./vc6-stlport/vc6-stlport-re300ddm/ -Fdvc6-stlport/vc6-stlport-re300ddm.pdb ../src/cpp_regex_traits.cpp
vc6-stlport/vc6-stlport-re300ddm/cregex.obj: ../src/cregex.cpp $(ALL_HEADER)
cl $(INCLUDES) /nologo /MTd /W3 /Gm /GX /Zi /Od /I..\..\..\ /D__STL_DEBUG /DWIN32 /D_MT /D_DEBUG /D_MBCS /D_LIB /YX /FD /GZ /c $(CXXFLAGS) -Fpvc6-stlport/vc6-stlport-re300ddm/vc6-stlport-re300ddm.pch -Fo./vc6-stlport/vc6-stlport-re300ddm/ -Fdvc6-stlport/vc6-stlport-re300ddm.pdb ../src/cregex.cpp
vc6-stlport/vc6-stlport-re300ddm/fileiter.obj: ../src/fileiter.cpp $(ALL_HEADER)
cl $(INCLUDES) /nologo /MTd /W3 /Gm /GX /Zi /Od /I..\..\..\ /D__STL_DEBUG /DWIN32 /D_MT /D_DEBUG /D_MBCS /D_LIB /YX /FD /GZ /c $(CXXFLAGS) -Fpvc6-stlport/vc6-stlport-re300ddm/vc6-stlport-re300ddm.pch -Fo./vc6-stlport/vc6-stlport-re300ddm/ -Fdvc6-stlport/vc6-stlport-re300ddm.pdb ../src/fileiter.cpp
vc6-stlport/vc6-stlport-re300ddm/posix_api.obj: ../src/posix_api.cpp $(ALL_HEADER)
cl $(INCLUDES) /nologo /MTd /W3 /Gm /GX /Zi /Od /I..\..\..\ /D__STL_DEBUG /DWIN32 /D_MT /D_DEBUG /D_MBCS /D_LIB /YX /FD /GZ /c $(CXXFLAGS) -Fpvc6-stlport/vc6-stlport-re300ddm/vc6-stlport-re300ddm.pch -Fo./vc6-stlport/vc6-stlport-re300ddm/ -Fdvc6-stlport/vc6-stlport-re300ddm.pdb ../src/posix_api.cpp
vc6-stlport/vc6-stlport-re300ddm/regex.obj: ../src/regex.cpp $(ALL_HEADER)
cl $(INCLUDES) /nologo /MTd /W3 /Gm /GX /Zi /Od /I..\..\..\ /D__STL_DEBUG /DWIN32 /D_MT /D_DEBUG /D_MBCS /D_LIB /YX /FD /GZ /c $(CXXFLAGS) -Fpvc6-stlport/vc6-stlport-re300ddm/vc6-stlport-re300ddm.pch -Fo./vc6-stlport/vc6-stlport-re300ddm/ -Fdvc6-stlport/vc6-stlport-re300ddm.pdb ../src/regex.cpp
vc6-stlport/vc6-stlport-re300ddm/regex_debug.obj: ../src/regex_debug.cpp $(ALL_HEADER)
cl $(INCLUDES) /nologo /MTd /W3 /Gm /GX /Zi /Od /I..\..\..\ /D__STL_DEBUG /DWIN32 /D_MT /D_DEBUG /D_MBCS /D_LIB /YX /FD /GZ /c $(CXXFLAGS) -Fpvc6-stlport/vc6-stlport-re300ddm/vc6-stlport-re300ddm.pch -Fo./vc6-stlport/vc6-stlport-re300ddm/ -Fdvc6-stlport/vc6-stlport-re300ddm.pdb ../src/regex_debug.cpp
vc6-stlport/vc6-stlport-re300ddm/regex_synch.obj: ../src/regex_synch.cpp $(ALL_HEADER)
cl $(INCLUDES) /nologo /MTd /W3 /Gm /GX /Zi /Od /I..\..\..\ /D__STL_DEBUG /DWIN32 /D_MT /D_DEBUG /D_MBCS /D_LIB /YX /FD /GZ /c $(CXXFLAGS) -Fpvc6-stlport/vc6-stlport-re300ddm/vc6-stlport-re300ddm.pch -Fo./vc6-stlport/vc6-stlport-re300ddm/ -Fdvc6-stlport/vc6-stlport-re300ddm.pdb ../src/regex_synch.cpp
vc6-stlport/vc6-stlport-re300ddm/w32_regex_traits.obj: ../src/w32_regex_traits.cpp $(ALL_HEADER)
cl $(INCLUDES) /nologo /MTd /W3 /Gm /GX /Zi /Od /I..\..\..\ /D__STL_DEBUG /DWIN32 /D_MT /D_DEBUG /D_MBCS /D_LIB /YX /FD /GZ /c $(CXXFLAGS) -Fpvc6-stlport/vc6-stlport-re300ddm/vc6-stlport-re300ddm.pch -Fo./vc6-stlport/vc6-stlport-re300ddm/ -Fdvc6-stlport/vc6-stlport-re300ddm.pdb ../src/w32_regex_traits.cpp
vc6-stlport/vc6-stlport-re300ddm/wide_posix_api.obj: ../src/wide_posix_api.cpp $(ALL_HEADER)
cl $(INCLUDES) /nologo /MTd /W3 /Gm /GX /Zi /Od /I..\..\..\ /D__STL_DEBUG /DWIN32 /D_MT /D_DEBUG /D_MBCS /D_LIB /YX /FD /GZ /c $(CXXFLAGS) -Fpvc6-stlport/vc6-stlport-re300ddm/vc6-stlport-re300ddm.pch -Fo./vc6-stlport/vc6-stlport-re300ddm/ -Fdvc6-stlport/vc6-stlport-re300ddm.pdb ../src/wide_posix_api.cpp
vc6-stlport-re300ddm_dir :
if not exist "vc6-stlport\vc6-stlport-re300ddm\$(NULL)" mkdir vc6-stlport\vc6-stlport-re300ddm
vc6-stlport-re300ddm_clean :
del vc6-stlport\vc6-stlport-re300ddm\*.obj
del vc6-stlport\vc6-stlport-re300ddm\*.idb
del vc6-stlport\vc6-stlport-re300ddm\*.exp
del vc6-stlport\vc6-stlport-re300ddm\*.pch
./vc6-stlport/vc6-stlport-re300ddm.lib : vc6-stlport/vc6-stlport-re300ddm/c_regex_traits.obj vc6-stlport/vc6-stlport-re300ddm/c_regex_traits_common.obj vc6-stlport/vc6-stlport-re300ddm/cpp_regex_traits.obj vc6-stlport/vc6-stlport-re300ddm/cregex.obj vc6-stlport/vc6-stlport-re300ddm/fileiter.obj vc6-stlport/vc6-stlport-re300ddm/posix_api.obj vc6-stlport/vc6-stlport-re300ddm/regex.obj vc6-stlport/vc6-stlport-re300ddm/regex_debug.obj vc6-stlport/vc6-stlport-re300ddm/regex_synch.obj vc6-stlport/vc6-stlport-re300ddm/w32_regex_traits.obj vc6-stlport/vc6-stlport-re300ddm/wide_posix_api.obj
link -lib /nologo /out:vc6-stlport/vc6-stlport-re300ddm.lib $(XSFLAGS) vc6-stlport/vc6-stlport-re300ddm/c_regex_traits.obj vc6-stlport/vc6-stlport-re300ddm/c_regex_traits_common.obj vc6-stlport/vc6-stlport-re300ddm/cpp_regex_traits.obj vc6-stlport/vc6-stlport-re300ddm/cregex.obj vc6-stlport/vc6-stlport-re300ddm/fileiter.obj vc6-stlport/vc6-stlport-re300ddm/posix_api.obj vc6-stlport/vc6-stlport-re300ddm/regex.obj vc6-stlport/vc6-stlport-re300ddm/regex_debug.obj vc6-stlport/vc6-stlport-re300ddm/regex_synch.obj vc6-stlport/vc6-stlport-re300ddm/w32_regex_traits.obj vc6-stlport/vc6-stlport-re300ddm/wide_posix_api.obj

View File

@ -1,412 +0,0 @@
#
# auto generated makefile for VC6 compiler
#
# usage:
# make
# brings libraries up to date
# make install
# brings libraries up to date and copies binaries to your VC6 /lib and /bin directories (recomended)
#
#
# Add additional compiler options here:
#
CXXFLAGS=
#
# Add additional include directories here:
#
INCLUDES=
#
# add additional linker flags here:
#
XLFLAGS=
#
# add additional static-library creation flags here:
#
XSFLAGS=
!IF "$(OS)" == "Windows_NT"
NULL=
!ELSE
NULL=nul
!ENDIF
ALL_HEADER=../../../boost/cregex.hpp ../../../boost/regex/pattern_except.hpp ../../../boost/regex.hpp ../../../boost/regex/regex_traits.hpp ../../../boost/regex/detail/fileiter.hpp ../../../boost/regex/detail/regex_compile.hpp ../../../boost/regex/detail/regex_config.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_options.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 : main_dir vc6-re300_dir ./vc6/vc6-re300.lib vc6-re300m_dir ./vc6/vc6-re300m.lib vc6-re300d_dir ./vc6/vc6-re300d.lib vc6-re300dm_dir ./vc6/vc6-re300dm.lib vc6-re300dl_dir ./vc6/vc6-re300dl.lib vc6-re300l_dir ./vc6/vc6-re300l.lib vc6-re300ls_dir ./vc6/vc6-re300ls.lib
clean : vc6-re300_clean vc6-re300m_clean vc6-re300d_clean vc6-re300dm_clean vc6-re300dl_clean vc6-re300l_clean vc6-re300ls_clean
install : all
copy vc6\vc6-re300.lib "$(MSVCDIR)\lib"
copy vc6\vc6-re300m.lib "$(MSVCDIR)\lib"
copy vc6\vc6-re300d.lib "$(MSVCDIR)\lib"
copy vc6\vc6-re300d.pdb "$(MSVCDIR)\lib"
copy vc6\vc6-re300dm.lib "$(MSVCDIR)\lib"
copy vc6\vc6-re300dm.pdb "$(MSVCDIR)\lib"
copy vc6\vc6-re300dl.lib "$(MSVCDIR)\lib"
copy vc6\vc6-re300dl.dll "$(MSVCDIR)\bin"
copy vc6\vc6-re300dl.pdb "$(MSVCDIR)\lib"
copy vc6\vc6-re300l.lib "$(MSVCDIR)\lib"
copy vc6\vc6-re300l.dll "$(MSVCDIR)\bin"
copy vc6\vc6-re300ls.lib "$(MSVCDIR)\lib"
main_dir :
if not exist "vc6\$(NULL)" mkdir vc6
########################################################
#
# section for vc6-re300.lib
#
########################################################
vc6/vc6-re300/c_regex_traits.obj: ../src/c_regex_traits.cpp $(ALL_HEADER)
cl $(INCLUDES) /c /nologo /ML /W3 /GX /Oityb1 /GF /Gy /I..\..\..\ /DWIN32 /DNDEBUG /D_MBCS /D_LIB /YX /FD $(CXXFLAGS) -Fpvc6/vc6-re300/vc6-re300.pch -Fo./vc6/vc6-re300/ -Fdvc6/vc6-re300.pdb ../src/c_regex_traits.cpp
vc6/vc6-re300/c_regex_traits_common.obj: ../src/c_regex_traits_common.cpp $(ALL_HEADER)
cl $(INCLUDES) /c /nologo /ML /W3 /GX /Oityb1 /GF /Gy /I..\..\..\ /DWIN32 /DNDEBUG /D_MBCS /D_LIB /YX /FD $(CXXFLAGS) -Fpvc6/vc6-re300/vc6-re300.pch -Fo./vc6/vc6-re300/ -Fdvc6/vc6-re300.pdb ../src/c_regex_traits_common.cpp
vc6/vc6-re300/cpp_regex_traits.obj: ../src/cpp_regex_traits.cpp $(ALL_HEADER)
cl $(INCLUDES) /c /nologo /ML /W3 /GX /Oityb1 /GF /Gy /I..\..\..\ /DWIN32 /DNDEBUG /D_MBCS /D_LIB /YX /FD $(CXXFLAGS) -Fpvc6/vc6-re300/vc6-re300.pch -Fo./vc6/vc6-re300/ -Fdvc6/vc6-re300.pdb ../src/cpp_regex_traits.cpp
vc6/vc6-re300/cregex.obj: ../src/cregex.cpp $(ALL_HEADER)
cl $(INCLUDES) /c /nologo /ML /W3 /GX /Oityb1 /GF /Gy /I..\..\..\ /DWIN32 /DNDEBUG /D_MBCS /D_LIB /YX /FD $(CXXFLAGS) -Fpvc6/vc6-re300/vc6-re300.pch -Fo./vc6/vc6-re300/ -Fdvc6/vc6-re300.pdb ../src/cregex.cpp
vc6/vc6-re300/fileiter.obj: ../src/fileiter.cpp $(ALL_HEADER)
cl $(INCLUDES) /c /nologo /ML /W3 /GX /Oityb1 /GF /Gy /I..\..\..\ /DWIN32 /DNDEBUG /D_MBCS /D_LIB /YX /FD $(CXXFLAGS) -Fpvc6/vc6-re300/vc6-re300.pch -Fo./vc6/vc6-re300/ -Fdvc6/vc6-re300.pdb ../src/fileiter.cpp
vc6/vc6-re300/posix_api.obj: ../src/posix_api.cpp $(ALL_HEADER)
cl $(INCLUDES) /c /nologo /ML /W3 /GX /Oityb1 /GF /Gy /I..\..\..\ /DWIN32 /DNDEBUG /D_MBCS /D_LIB /YX /FD $(CXXFLAGS) -Fpvc6/vc6-re300/vc6-re300.pch -Fo./vc6/vc6-re300/ -Fdvc6/vc6-re300.pdb ../src/posix_api.cpp
vc6/vc6-re300/regex.obj: ../src/regex.cpp $(ALL_HEADER)
cl $(INCLUDES) /c /nologo /ML /W3 /GX /Oityb1 /GF /Gy /I..\..\..\ /DWIN32 /DNDEBUG /D_MBCS /D_LIB /YX /FD $(CXXFLAGS) -Fpvc6/vc6-re300/vc6-re300.pch -Fo./vc6/vc6-re300/ -Fdvc6/vc6-re300.pdb ../src/regex.cpp
vc6/vc6-re300/regex_debug.obj: ../src/regex_debug.cpp $(ALL_HEADER)
cl $(INCLUDES) /c /nologo /ML /W3 /GX /Oityb1 /GF /Gy /I..\..\..\ /DWIN32 /DNDEBUG /D_MBCS /D_LIB /YX /FD $(CXXFLAGS) -Fpvc6/vc6-re300/vc6-re300.pch -Fo./vc6/vc6-re300/ -Fdvc6/vc6-re300.pdb ../src/regex_debug.cpp
vc6/vc6-re300/regex_synch.obj: ../src/regex_synch.cpp $(ALL_HEADER)
cl $(INCLUDES) /c /nologo /ML /W3 /GX /Oityb1 /GF /Gy /I..\..\..\ /DWIN32 /DNDEBUG /D_MBCS /D_LIB /YX /FD $(CXXFLAGS) -Fpvc6/vc6-re300/vc6-re300.pch -Fo./vc6/vc6-re300/ -Fdvc6/vc6-re300.pdb ../src/regex_synch.cpp
vc6/vc6-re300/w32_regex_traits.obj: ../src/w32_regex_traits.cpp $(ALL_HEADER)
cl $(INCLUDES) /c /nologo /ML /W3 /GX /Oityb1 /GF /Gy /I..\..\..\ /DWIN32 /DNDEBUG /D_MBCS /D_LIB /YX /FD $(CXXFLAGS) -Fpvc6/vc6-re300/vc6-re300.pch -Fo./vc6/vc6-re300/ -Fdvc6/vc6-re300.pdb ../src/w32_regex_traits.cpp
vc6/vc6-re300/wide_posix_api.obj: ../src/wide_posix_api.cpp $(ALL_HEADER)
cl $(INCLUDES) /c /nologo /ML /W3 /GX /Oityb1 /GF /Gy /I..\..\..\ /DWIN32 /DNDEBUG /D_MBCS /D_LIB /YX /FD $(CXXFLAGS) -Fpvc6/vc6-re300/vc6-re300.pch -Fo./vc6/vc6-re300/ -Fdvc6/vc6-re300.pdb ../src/wide_posix_api.cpp
vc6-re300_dir :
if not exist "vc6\vc6-re300\$(NULL)" mkdir vc6\vc6-re300
vc6-re300_clean :
del vc6\vc6-re300\*.obj
del vc6\vc6-re300\*.idb
del vc6\vc6-re300\*.exp
del vc6\vc6-re300\*.pch
./vc6/vc6-re300.lib : vc6/vc6-re300/c_regex_traits.obj vc6/vc6-re300/c_regex_traits_common.obj vc6/vc6-re300/cpp_regex_traits.obj vc6/vc6-re300/cregex.obj vc6/vc6-re300/fileiter.obj vc6/vc6-re300/posix_api.obj vc6/vc6-re300/regex.obj vc6/vc6-re300/regex_debug.obj vc6/vc6-re300/regex_synch.obj vc6/vc6-re300/w32_regex_traits.obj vc6/vc6-re300/wide_posix_api.obj
link -lib /nologo /out:vc6/vc6-re300.lib $(XSFLAGS) vc6/vc6-re300/c_regex_traits.obj vc6/vc6-re300/c_regex_traits_common.obj vc6/vc6-re300/cpp_regex_traits.obj vc6/vc6-re300/cregex.obj vc6/vc6-re300/fileiter.obj vc6/vc6-re300/posix_api.obj vc6/vc6-re300/regex.obj vc6/vc6-re300/regex_debug.obj vc6/vc6-re300/regex_synch.obj vc6/vc6-re300/w32_regex_traits.obj vc6/vc6-re300/wide_posix_api.obj
########################################################
#
# section for vc6-re300m.lib
#
########################################################
vc6/vc6-re300m/c_regex_traits.obj: ../src/c_regex_traits.cpp $(ALL_HEADER)
cl $(INCLUDES) /nologo /MT /W3 /GX /Oityb1 /GF /Gy /I..\..\..\ /D_MT /DWIN32 /DNDEBUG /D_MBCS /D_LIB /YX /FD /c $(CXXFLAGS) -Fpvc6/vc6-re300m/vc6-re300m.pch -Fo./vc6/vc6-re300m/ -Fdvc6/vc6-re300m.pdb ../src/c_regex_traits.cpp
vc6/vc6-re300m/c_regex_traits_common.obj: ../src/c_regex_traits_common.cpp $(ALL_HEADER)
cl $(INCLUDES) /nologo /MT /W3 /GX /Oityb1 /GF /Gy /I..\..\..\ /D_MT /DWIN32 /DNDEBUG /D_MBCS /D_LIB /YX /FD /c $(CXXFLAGS) -Fpvc6/vc6-re300m/vc6-re300m.pch -Fo./vc6/vc6-re300m/ -Fdvc6/vc6-re300m.pdb ../src/c_regex_traits_common.cpp
vc6/vc6-re300m/cpp_regex_traits.obj: ../src/cpp_regex_traits.cpp $(ALL_HEADER)
cl $(INCLUDES) /nologo /MT /W3 /GX /Oityb1 /GF /Gy /I..\..\..\ /D_MT /DWIN32 /DNDEBUG /D_MBCS /D_LIB /YX /FD /c $(CXXFLAGS) -Fpvc6/vc6-re300m/vc6-re300m.pch -Fo./vc6/vc6-re300m/ -Fdvc6/vc6-re300m.pdb ../src/cpp_regex_traits.cpp
vc6/vc6-re300m/cregex.obj: ../src/cregex.cpp $(ALL_HEADER)
cl $(INCLUDES) /nologo /MT /W3 /GX /Oityb1 /GF /Gy /I..\..\..\ /D_MT /DWIN32 /DNDEBUG /D_MBCS /D_LIB /YX /FD /c $(CXXFLAGS) -Fpvc6/vc6-re300m/vc6-re300m.pch -Fo./vc6/vc6-re300m/ -Fdvc6/vc6-re300m.pdb ../src/cregex.cpp
vc6/vc6-re300m/fileiter.obj: ../src/fileiter.cpp $(ALL_HEADER)
cl $(INCLUDES) /nologo /MT /W3 /GX /Oityb1 /GF /Gy /I..\..\..\ /D_MT /DWIN32 /DNDEBUG /D_MBCS /D_LIB /YX /FD /c $(CXXFLAGS) -Fpvc6/vc6-re300m/vc6-re300m.pch -Fo./vc6/vc6-re300m/ -Fdvc6/vc6-re300m.pdb ../src/fileiter.cpp
vc6/vc6-re300m/posix_api.obj: ../src/posix_api.cpp $(ALL_HEADER)
cl $(INCLUDES) /nologo /MT /W3 /GX /Oityb1 /GF /Gy /I..\..\..\ /D_MT /DWIN32 /DNDEBUG /D_MBCS /D_LIB /YX /FD /c $(CXXFLAGS) -Fpvc6/vc6-re300m/vc6-re300m.pch -Fo./vc6/vc6-re300m/ -Fdvc6/vc6-re300m.pdb ../src/posix_api.cpp
vc6/vc6-re300m/regex.obj: ../src/regex.cpp $(ALL_HEADER)
cl $(INCLUDES) /nologo /MT /W3 /GX /Oityb1 /GF /Gy /I..\..\..\ /D_MT /DWIN32 /DNDEBUG /D_MBCS /D_LIB /YX /FD /c $(CXXFLAGS) -Fpvc6/vc6-re300m/vc6-re300m.pch -Fo./vc6/vc6-re300m/ -Fdvc6/vc6-re300m.pdb ../src/regex.cpp
vc6/vc6-re300m/regex_debug.obj: ../src/regex_debug.cpp $(ALL_HEADER)
cl $(INCLUDES) /nologo /MT /W3 /GX /Oityb1 /GF /Gy /I..\..\..\ /D_MT /DWIN32 /DNDEBUG /D_MBCS /D_LIB /YX /FD /c $(CXXFLAGS) -Fpvc6/vc6-re300m/vc6-re300m.pch -Fo./vc6/vc6-re300m/ -Fdvc6/vc6-re300m.pdb ../src/regex_debug.cpp
vc6/vc6-re300m/regex_synch.obj: ../src/regex_synch.cpp $(ALL_HEADER)
cl $(INCLUDES) /nologo /MT /W3 /GX /Oityb1 /GF /Gy /I..\..\..\ /D_MT /DWIN32 /DNDEBUG /D_MBCS /D_LIB /YX /FD /c $(CXXFLAGS) -Fpvc6/vc6-re300m/vc6-re300m.pch -Fo./vc6/vc6-re300m/ -Fdvc6/vc6-re300m.pdb ../src/regex_synch.cpp
vc6/vc6-re300m/w32_regex_traits.obj: ../src/w32_regex_traits.cpp $(ALL_HEADER)
cl $(INCLUDES) /nologo /MT /W3 /GX /Oityb1 /GF /Gy /I..\..\..\ /D_MT /DWIN32 /DNDEBUG /D_MBCS /D_LIB /YX /FD /c $(CXXFLAGS) -Fpvc6/vc6-re300m/vc6-re300m.pch -Fo./vc6/vc6-re300m/ -Fdvc6/vc6-re300m.pdb ../src/w32_regex_traits.cpp
vc6/vc6-re300m/wide_posix_api.obj: ../src/wide_posix_api.cpp $(ALL_HEADER)
cl $(INCLUDES) /nologo /MT /W3 /GX /Oityb1 /GF /Gy /I..\..\..\ /D_MT /DWIN32 /DNDEBUG /D_MBCS /D_LIB /YX /FD /c $(CXXFLAGS) -Fpvc6/vc6-re300m/vc6-re300m.pch -Fo./vc6/vc6-re300m/ -Fdvc6/vc6-re300m.pdb ../src/wide_posix_api.cpp
vc6-re300m_dir :
if not exist "vc6\vc6-re300m\$(NULL)" mkdir vc6\vc6-re300m
vc6-re300m_clean :
del vc6\vc6-re300m\*.obj
del vc6\vc6-re300m\*.idb
del vc6\vc6-re300m\*.exp
del vc6\vc6-re300m\*.pch
./vc6/vc6-re300m.lib : vc6/vc6-re300m/c_regex_traits.obj vc6/vc6-re300m/c_regex_traits_common.obj vc6/vc6-re300m/cpp_regex_traits.obj vc6/vc6-re300m/cregex.obj vc6/vc6-re300m/fileiter.obj vc6/vc6-re300m/posix_api.obj vc6/vc6-re300m/regex.obj vc6/vc6-re300m/regex_debug.obj vc6/vc6-re300m/regex_synch.obj vc6/vc6-re300m/w32_regex_traits.obj vc6/vc6-re300m/wide_posix_api.obj
link -lib /nologo /out:vc6/vc6-re300m.lib $(XSFLAGS) vc6/vc6-re300m/c_regex_traits.obj vc6/vc6-re300m/c_regex_traits_common.obj vc6/vc6-re300m/cpp_regex_traits.obj vc6/vc6-re300m/cregex.obj vc6/vc6-re300m/fileiter.obj vc6/vc6-re300m/posix_api.obj vc6/vc6-re300m/regex.obj vc6/vc6-re300m/regex_debug.obj vc6/vc6-re300m/regex_synch.obj vc6/vc6-re300m/w32_regex_traits.obj vc6/vc6-re300m/wide_posix_api.obj
########################################################
#
# section for vc6-re300d.lib
#
########################################################
vc6/vc6-re300d/c_regex_traits.obj: ../src/c_regex_traits.cpp $(ALL_HEADER)
cl $(INCLUDES) /nologo /MLd /W3 /Gm /GX /Zi /Od /I..\..\..\ /DWIN32 /D_DEBUG /D_MBCS /D_LIB /YX /FD /GZ /c $(CXXFLAGS) -Fpvc6/vc6-re300d/vc6-re300d.pch -Fo./vc6/vc6-re300d/ -Fdvc6/vc6-re300d.pdb ../src/c_regex_traits.cpp
vc6/vc6-re300d/c_regex_traits_common.obj: ../src/c_regex_traits_common.cpp $(ALL_HEADER)
cl $(INCLUDES) /nologo /MLd /W3 /Gm /GX /Zi /Od /I..\..\..\ /DWIN32 /D_DEBUG /D_MBCS /D_LIB /YX /FD /GZ /c $(CXXFLAGS) -Fpvc6/vc6-re300d/vc6-re300d.pch -Fo./vc6/vc6-re300d/ -Fdvc6/vc6-re300d.pdb ../src/c_regex_traits_common.cpp
vc6/vc6-re300d/cpp_regex_traits.obj: ../src/cpp_regex_traits.cpp $(ALL_HEADER)
cl $(INCLUDES) /nologo /MLd /W3 /Gm /GX /Zi /Od /I..\..\..\ /DWIN32 /D_DEBUG /D_MBCS /D_LIB /YX /FD /GZ /c $(CXXFLAGS) -Fpvc6/vc6-re300d/vc6-re300d.pch -Fo./vc6/vc6-re300d/ -Fdvc6/vc6-re300d.pdb ../src/cpp_regex_traits.cpp
vc6/vc6-re300d/cregex.obj: ../src/cregex.cpp $(ALL_HEADER)
cl $(INCLUDES) /nologo /MLd /W3 /Gm /GX /Zi /Od /I..\..\..\ /DWIN32 /D_DEBUG /D_MBCS /D_LIB /YX /FD /GZ /c $(CXXFLAGS) -Fpvc6/vc6-re300d/vc6-re300d.pch -Fo./vc6/vc6-re300d/ -Fdvc6/vc6-re300d.pdb ../src/cregex.cpp
vc6/vc6-re300d/fileiter.obj: ../src/fileiter.cpp $(ALL_HEADER)
cl $(INCLUDES) /nologo /MLd /W3 /Gm /GX /Zi /Od /I..\..\..\ /DWIN32 /D_DEBUG /D_MBCS /D_LIB /YX /FD /GZ /c $(CXXFLAGS) -Fpvc6/vc6-re300d/vc6-re300d.pch -Fo./vc6/vc6-re300d/ -Fdvc6/vc6-re300d.pdb ../src/fileiter.cpp
vc6/vc6-re300d/posix_api.obj: ../src/posix_api.cpp $(ALL_HEADER)
cl $(INCLUDES) /nologo /MLd /W3 /Gm /GX /Zi /Od /I..\..\..\ /DWIN32 /D_DEBUG /D_MBCS /D_LIB /YX /FD /GZ /c $(CXXFLAGS) -Fpvc6/vc6-re300d/vc6-re300d.pch -Fo./vc6/vc6-re300d/ -Fdvc6/vc6-re300d.pdb ../src/posix_api.cpp
vc6/vc6-re300d/regex.obj: ../src/regex.cpp $(ALL_HEADER)
cl $(INCLUDES) /nologo /MLd /W3 /Gm /GX /Zi /Od /I..\..\..\ /DWIN32 /D_DEBUG /D_MBCS /D_LIB /YX /FD /GZ /c $(CXXFLAGS) -Fpvc6/vc6-re300d/vc6-re300d.pch -Fo./vc6/vc6-re300d/ -Fdvc6/vc6-re300d.pdb ../src/regex.cpp
vc6/vc6-re300d/regex_debug.obj: ../src/regex_debug.cpp $(ALL_HEADER)
cl $(INCLUDES) /nologo /MLd /W3 /Gm /GX /Zi /Od /I..\..\..\ /DWIN32 /D_DEBUG /D_MBCS /D_LIB /YX /FD /GZ /c $(CXXFLAGS) -Fpvc6/vc6-re300d/vc6-re300d.pch -Fo./vc6/vc6-re300d/ -Fdvc6/vc6-re300d.pdb ../src/regex_debug.cpp
vc6/vc6-re300d/regex_synch.obj: ../src/regex_synch.cpp $(ALL_HEADER)
cl $(INCLUDES) /nologo /MLd /W3 /Gm /GX /Zi /Od /I..\..\..\ /DWIN32 /D_DEBUG /D_MBCS /D_LIB /YX /FD /GZ /c $(CXXFLAGS) -Fpvc6/vc6-re300d/vc6-re300d.pch -Fo./vc6/vc6-re300d/ -Fdvc6/vc6-re300d.pdb ../src/regex_synch.cpp
vc6/vc6-re300d/w32_regex_traits.obj: ../src/w32_regex_traits.cpp $(ALL_HEADER)
cl $(INCLUDES) /nologo /MLd /W3 /Gm /GX /Zi /Od /I..\..\..\ /DWIN32 /D_DEBUG /D_MBCS /D_LIB /YX /FD /GZ /c $(CXXFLAGS) -Fpvc6/vc6-re300d/vc6-re300d.pch -Fo./vc6/vc6-re300d/ -Fdvc6/vc6-re300d.pdb ../src/w32_regex_traits.cpp
vc6/vc6-re300d/wide_posix_api.obj: ../src/wide_posix_api.cpp $(ALL_HEADER)
cl $(INCLUDES) /nologo /MLd /W3 /Gm /GX /Zi /Od /I..\..\..\ /DWIN32 /D_DEBUG /D_MBCS /D_LIB /YX /FD /GZ /c $(CXXFLAGS) -Fpvc6/vc6-re300d/vc6-re300d.pch -Fo./vc6/vc6-re300d/ -Fdvc6/vc6-re300d.pdb ../src/wide_posix_api.cpp
vc6-re300d_dir :
if not exist "vc6\vc6-re300d\$(NULL)" mkdir vc6\vc6-re300d
vc6-re300d_clean :
del vc6\vc6-re300d\*.obj
del vc6\vc6-re300d\*.idb
del vc6\vc6-re300d\*.exp
del vc6\vc6-re300d\*.pch
./vc6/vc6-re300d.lib : vc6/vc6-re300d/c_regex_traits.obj vc6/vc6-re300d/c_regex_traits_common.obj vc6/vc6-re300d/cpp_regex_traits.obj vc6/vc6-re300d/cregex.obj vc6/vc6-re300d/fileiter.obj vc6/vc6-re300d/posix_api.obj vc6/vc6-re300d/regex.obj vc6/vc6-re300d/regex_debug.obj vc6/vc6-re300d/regex_synch.obj vc6/vc6-re300d/w32_regex_traits.obj vc6/vc6-re300d/wide_posix_api.obj
link -lib /nologo /out:vc6/vc6-re300d.lib $(XSFLAGS) vc6/vc6-re300d/c_regex_traits.obj vc6/vc6-re300d/c_regex_traits_common.obj vc6/vc6-re300d/cpp_regex_traits.obj vc6/vc6-re300d/cregex.obj vc6/vc6-re300d/fileiter.obj vc6/vc6-re300d/posix_api.obj vc6/vc6-re300d/regex.obj vc6/vc6-re300d/regex_debug.obj vc6/vc6-re300d/regex_synch.obj vc6/vc6-re300d/w32_regex_traits.obj vc6/vc6-re300d/wide_posix_api.obj
########################################################
#
# section for vc6-re300dm.lib
#
########################################################
vc6/vc6-re300dm/c_regex_traits.obj: ../src/c_regex_traits.cpp $(ALL_HEADER)
cl $(INCLUDES) /nologo /MTd /W3 /Gm /GX /Zi /Od /I..\..\..\ /DWIN32 /D_MT /D_DEBUG /D_MBCS /D_LIB /YX /FD /GZ /c $(CXXFLAGS) -Fpvc6/vc6-re300dm/vc6-re300dm.pch -Fo./vc6/vc6-re300dm/ -Fdvc6/vc6-re300dm.pdb ../src/c_regex_traits.cpp
vc6/vc6-re300dm/c_regex_traits_common.obj: ../src/c_regex_traits_common.cpp $(ALL_HEADER)
cl $(INCLUDES) /nologo /MTd /W3 /Gm /GX /Zi /Od /I..\..\..\ /DWIN32 /D_MT /D_DEBUG /D_MBCS /D_LIB /YX /FD /GZ /c $(CXXFLAGS) -Fpvc6/vc6-re300dm/vc6-re300dm.pch -Fo./vc6/vc6-re300dm/ -Fdvc6/vc6-re300dm.pdb ../src/c_regex_traits_common.cpp
vc6/vc6-re300dm/cpp_regex_traits.obj: ../src/cpp_regex_traits.cpp $(ALL_HEADER)
cl $(INCLUDES) /nologo /MTd /W3 /Gm /GX /Zi /Od /I..\..\..\ /DWIN32 /D_MT /D_DEBUG /D_MBCS /D_LIB /YX /FD /GZ /c $(CXXFLAGS) -Fpvc6/vc6-re300dm/vc6-re300dm.pch -Fo./vc6/vc6-re300dm/ -Fdvc6/vc6-re300dm.pdb ../src/cpp_regex_traits.cpp
vc6/vc6-re300dm/cregex.obj: ../src/cregex.cpp $(ALL_HEADER)
cl $(INCLUDES) /nologo /MTd /W3 /Gm /GX /Zi /Od /I..\..\..\ /DWIN32 /D_MT /D_DEBUG /D_MBCS /D_LIB /YX /FD /GZ /c $(CXXFLAGS) -Fpvc6/vc6-re300dm/vc6-re300dm.pch -Fo./vc6/vc6-re300dm/ -Fdvc6/vc6-re300dm.pdb ../src/cregex.cpp
vc6/vc6-re300dm/fileiter.obj: ../src/fileiter.cpp $(ALL_HEADER)
cl $(INCLUDES) /nologo /MTd /W3 /Gm /GX /Zi /Od /I..\..\..\ /DWIN32 /D_MT /D_DEBUG /D_MBCS /D_LIB /YX /FD /GZ /c $(CXXFLAGS) -Fpvc6/vc6-re300dm/vc6-re300dm.pch -Fo./vc6/vc6-re300dm/ -Fdvc6/vc6-re300dm.pdb ../src/fileiter.cpp
vc6/vc6-re300dm/posix_api.obj: ../src/posix_api.cpp $(ALL_HEADER)
cl $(INCLUDES) /nologo /MTd /W3 /Gm /GX /Zi /Od /I..\..\..\ /DWIN32 /D_MT /D_DEBUG /D_MBCS /D_LIB /YX /FD /GZ /c $(CXXFLAGS) -Fpvc6/vc6-re300dm/vc6-re300dm.pch -Fo./vc6/vc6-re300dm/ -Fdvc6/vc6-re300dm.pdb ../src/posix_api.cpp
vc6/vc6-re300dm/regex.obj: ../src/regex.cpp $(ALL_HEADER)
cl $(INCLUDES) /nologo /MTd /W3 /Gm /GX /Zi /Od /I..\..\..\ /DWIN32 /D_MT /D_DEBUG /D_MBCS /D_LIB /YX /FD /GZ /c $(CXXFLAGS) -Fpvc6/vc6-re300dm/vc6-re300dm.pch -Fo./vc6/vc6-re300dm/ -Fdvc6/vc6-re300dm.pdb ../src/regex.cpp
vc6/vc6-re300dm/regex_debug.obj: ../src/regex_debug.cpp $(ALL_HEADER)
cl $(INCLUDES) /nologo /MTd /W3 /Gm /GX /Zi /Od /I..\..\..\ /DWIN32 /D_MT /D_DEBUG /D_MBCS /D_LIB /YX /FD /GZ /c $(CXXFLAGS) -Fpvc6/vc6-re300dm/vc6-re300dm.pch -Fo./vc6/vc6-re300dm/ -Fdvc6/vc6-re300dm.pdb ../src/regex_debug.cpp
vc6/vc6-re300dm/regex_synch.obj: ../src/regex_synch.cpp $(ALL_HEADER)
cl $(INCLUDES) /nologo /MTd /W3 /Gm /GX /Zi /Od /I..\..\..\ /DWIN32 /D_MT /D_DEBUG /D_MBCS /D_LIB /YX /FD /GZ /c $(CXXFLAGS) -Fpvc6/vc6-re300dm/vc6-re300dm.pch -Fo./vc6/vc6-re300dm/ -Fdvc6/vc6-re300dm.pdb ../src/regex_synch.cpp
vc6/vc6-re300dm/w32_regex_traits.obj: ../src/w32_regex_traits.cpp $(ALL_HEADER)
cl $(INCLUDES) /nologo /MTd /W3 /Gm /GX /Zi /Od /I..\..\..\ /DWIN32 /D_MT /D_DEBUG /D_MBCS /D_LIB /YX /FD /GZ /c $(CXXFLAGS) -Fpvc6/vc6-re300dm/vc6-re300dm.pch -Fo./vc6/vc6-re300dm/ -Fdvc6/vc6-re300dm.pdb ../src/w32_regex_traits.cpp
vc6/vc6-re300dm/wide_posix_api.obj: ../src/wide_posix_api.cpp $(ALL_HEADER)
cl $(INCLUDES) /nologo /MTd /W3 /Gm /GX /Zi /Od /I..\..\..\ /DWIN32 /D_MT /D_DEBUG /D_MBCS /D_LIB /YX /FD /GZ /c $(CXXFLAGS) -Fpvc6/vc6-re300dm/vc6-re300dm.pch -Fo./vc6/vc6-re300dm/ -Fdvc6/vc6-re300dm.pdb ../src/wide_posix_api.cpp
vc6-re300dm_dir :
if not exist "vc6\vc6-re300dm\$(NULL)" mkdir vc6\vc6-re300dm
vc6-re300dm_clean :
del vc6\vc6-re300dm\*.obj
del vc6\vc6-re300dm\*.idb
del vc6\vc6-re300dm\*.exp
del vc6\vc6-re300dm\*.pch
./vc6/vc6-re300dm.lib : vc6/vc6-re300dm/c_regex_traits.obj vc6/vc6-re300dm/c_regex_traits_common.obj vc6/vc6-re300dm/cpp_regex_traits.obj vc6/vc6-re300dm/cregex.obj vc6/vc6-re300dm/fileiter.obj vc6/vc6-re300dm/posix_api.obj vc6/vc6-re300dm/regex.obj vc6/vc6-re300dm/regex_debug.obj vc6/vc6-re300dm/regex_synch.obj vc6/vc6-re300dm/w32_regex_traits.obj vc6/vc6-re300dm/wide_posix_api.obj
link -lib /nologo /out:vc6/vc6-re300dm.lib $(XSFLAGS) vc6/vc6-re300dm/c_regex_traits.obj vc6/vc6-re300dm/c_regex_traits_common.obj vc6/vc6-re300dm/cpp_regex_traits.obj vc6/vc6-re300dm/cregex.obj vc6/vc6-re300dm/fileiter.obj vc6/vc6-re300dm/posix_api.obj vc6/vc6-re300dm/regex.obj vc6/vc6-re300dm/regex_debug.obj vc6/vc6-re300dm/regex_synch.obj vc6/vc6-re300dm/w32_regex_traits.obj vc6/vc6-re300dm/wide_posix_api.obj
########################################################
#
# section for vc6-re300dl.lib
#
########################################################
vc6/vc6-re300dl/c_regex_traits.obj: ../src/c_regex_traits.cpp $(ALL_HEADER)
cl $(INCLUDES) /nologo /MDd /W3 /Gm /GX /Zi /Od /I../../../ /D_DEBUG /DWIN32 /D_WINDOWS /D_MBCS /DUSRDLL /DBOOST_RE_DLL_EXPORTS /DBOOST_RE_BUILD_DLL /YX /FD /GZ /c $(CXXFLAGS) -Fpvc6/vc6-re300dl/vc6-re300dl.pch -Fo./vc6/vc6-re300dl/ -Fdvc6/vc6-re300dl.pdb ../src/c_regex_traits.cpp
vc6/vc6-re300dl/c_regex_traits_common.obj: ../src/c_regex_traits_common.cpp $(ALL_HEADER)
cl $(INCLUDES) /nologo /MDd /W3 /Gm /GX /Zi /Od /I../../../ /D_DEBUG /DWIN32 /D_WINDOWS /D_MBCS /DUSRDLL /DBOOST_RE_DLL_EXPORTS /DBOOST_RE_BUILD_DLL /YX /FD /GZ /c $(CXXFLAGS) -Fpvc6/vc6-re300dl/vc6-re300dl.pch -Fo./vc6/vc6-re300dl/ -Fdvc6/vc6-re300dl.pdb ../src/c_regex_traits_common.cpp
vc6/vc6-re300dl/cpp_regex_traits.obj: ../src/cpp_regex_traits.cpp $(ALL_HEADER)
cl $(INCLUDES) /nologo /MDd /W3 /Gm /GX /Zi /Od /I../../../ /D_DEBUG /DWIN32 /D_WINDOWS /D_MBCS /DUSRDLL /DBOOST_RE_DLL_EXPORTS /DBOOST_RE_BUILD_DLL /YX /FD /GZ /c $(CXXFLAGS) -Fpvc6/vc6-re300dl/vc6-re300dl.pch -Fo./vc6/vc6-re300dl/ -Fdvc6/vc6-re300dl.pdb ../src/cpp_regex_traits.cpp
vc6/vc6-re300dl/cregex.obj: ../src/cregex.cpp $(ALL_HEADER)
cl $(INCLUDES) /nologo /MDd /W3 /Gm /GX /Zi /Od /I../../../ /D_DEBUG /DWIN32 /D_WINDOWS /D_MBCS /DUSRDLL /DBOOST_RE_DLL_EXPORTS /DBOOST_RE_BUILD_DLL /YX /FD /GZ /c $(CXXFLAGS) -Fpvc6/vc6-re300dl/vc6-re300dl.pch -Fo./vc6/vc6-re300dl/ -Fdvc6/vc6-re300dl.pdb ../src/cregex.cpp
vc6/vc6-re300dl/fileiter.obj: ../src/fileiter.cpp $(ALL_HEADER)
cl $(INCLUDES) /nologo /MDd /W3 /Gm /GX /Zi /Od /I../../../ /D_DEBUG /DWIN32 /D_WINDOWS /D_MBCS /DUSRDLL /DBOOST_RE_DLL_EXPORTS /DBOOST_RE_BUILD_DLL /YX /FD /GZ /c $(CXXFLAGS) -Fpvc6/vc6-re300dl/vc6-re300dl.pch -Fo./vc6/vc6-re300dl/ -Fdvc6/vc6-re300dl.pdb ../src/fileiter.cpp
vc6/vc6-re300dl/posix_api.obj: ../src/posix_api.cpp $(ALL_HEADER)
cl $(INCLUDES) /nologo /MDd /W3 /Gm /GX /Zi /Od /I../../../ /D_DEBUG /DWIN32 /D_WINDOWS /D_MBCS /DUSRDLL /DBOOST_RE_DLL_EXPORTS /DBOOST_RE_BUILD_DLL /YX /FD /GZ /c $(CXXFLAGS) -Fpvc6/vc6-re300dl/vc6-re300dl.pch -Fo./vc6/vc6-re300dl/ -Fdvc6/vc6-re300dl.pdb ../src/posix_api.cpp
vc6/vc6-re300dl/regex.obj: ../src/regex.cpp $(ALL_HEADER)
cl $(INCLUDES) /nologo /MDd /W3 /Gm /GX /Zi /Od /I../../../ /D_DEBUG /DWIN32 /D_WINDOWS /D_MBCS /DUSRDLL /DBOOST_RE_DLL_EXPORTS /DBOOST_RE_BUILD_DLL /YX /FD /GZ /c $(CXXFLAGS) -Fpvc6/vc6-re300dl/vc6-re300dl.pch -Fo./vc6/vc6-re300dl/ -Fdvc6/vc6-re300dl.pdb ../src/regex.cpp
vc6/vc6-re300dl/regex_debug.obj: ../src/regex_debug.cpp $(ALL_HEADER)
cl $(INCLUDES) /nologo /MDd /W3 /Gm /GX /Zi /Od /I../../../ /D_DEBUG /DWIN32 /D_WINDOWS /D_MBCS /DUSRDLL /DBOOST_RE_DLL_EXPORTS /DBOOST_RE_BUILD_DLL /YX /FD /GZ /c $(CXXFLAGS) -Fpvc6/vc6-re300dl/vc6-re300dl.pch -Fo./vc6/vc6-re300dl/ -Fdvc6/vc6-re300dl.pdb ../src/regex_debug.cpp
vc6/vc6-re300dl/regex_synch.obj: ../src/regex_synch.cpp $(ALL_HEADER)
cl $(INCLUDES) /nologo /MDd /W3 /Gm /GX /Zi /Od /I../../../ /D_DEBUG /DWIN32 /D_WINDOWS /D_MBCS /DUSRDLL /DBOOST_RE_DLL_EXPORTS /DBOOST_RE_BUILD_DLL /YX /FD /GZ /c $(CXXFLAGS) -Fpvc6/vc6-re300dl/vc6-re300dl.pch -Fo./vc6/vc6-re300dl/ -Fdvc6/vc6-re300dl.pdb ../src/regex_synch.cpp
vc6/vc6-re300dl/w32_regex_traits.obj: ../src/w32_regex_traits.cpp $(ALL_HEADER)
cl $(INCLUDES) /nologo /MDd /W3 /Gm /GX /Zi /Od /I../../../ /D_DEBUG /DWIN32 /D_WINDOWS /D_MBCS /DUSRDLL /DBOOST_RE_DLL_EXPORTS /DBOOST_RE_BUILD_DLL /YX /FD /GZ /c $(CXXFLAGS) -Fpvc6/vc6-re300dl/vc6-re300dl.pch -Fo./vc6/vc6-re300dl/ -Fdvc6/vc6-re300dl.pdb ../src/w32_regex_traits.cpp
vc6/vc6-re300dl/wide_posix_api.obj: ../src/wide_posix_api.cpp $(ALL_HEADER)
cl $(INCLUDES) /nologo /MDd /W3 /Gm /GX /Zi /Od /I../../../ /D_DEBUG /DWIN32 /D_WINDOWS /D_MBCS /DUSRDLL /DBOOST_RE_DLL_EXPORTS /DBOOST_RE_BUILD_DLL /YX /FD /GZ /c $(CXXFLAGS) -Fpvc6/vc6-re300dl/vc6-re300dl.pch -Fo./vc6/vc6-re300dl/ -Fdvc6/vc6-re300dl.pdb ../src/wide_posix_api.cpp
vc6-re300dl_dir :
if not exist "vc6\vc6-re300dl\$(NULL)" mkdir vc6\vc6-re300dl
vc6-re300dl_clean :
del vc6\vc6-re300dl\*.obj
del vc6\vc6-re300dl\*.idb
del vc6\vc6-re300dl\*.exp
del vc6\vc6-re300dl\*.pch
./vc6/vc6-re300dl.lib : vc6/vc6-re300dl/c_regex_traits.obj vc6/vc6-re300dl/c_regex_traits_common.obj vc6/vc6-re300dl/cpp_regex_traits.obj vc6/vc6-re300dl/cregex.obj vc6/vc6-re300dl/fileiter.obj vc6/vc6-re300dl/posix_api.obj vc6/vc6-re300dl/regex.obj vc6/vc6-re300dl/regex_debug.obj vc6/vc6-re300dl/regex_synch.obj vc6/vc6-re300dl/w32_regex_traits.obj vc6/vc6-re300dl/wide_posix_api.obj
link @<<
kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib /nologo /dll /incremental:yes /pdb:"vc6/vc6-re300dl.pdb" /debug /machine:I386 /out:"vc6/vc6-re300dl.dll" /implib:"vc6/vc6-re300dl.lib" /pdbtype:sept $(XLFLAGS) vc6/vc6-re300dl/c_regex_traits.obj vc6/vc6-re300dl/c_regex_traits_common.obj vc6/vc6-re300dl/cpp_regex_traits.obj vc6/vc6-re300dl/cregex.obj vc6/vc6-re300dl/fileiter.obj vc6/vc6-re300dl/posix_api.obj vc6/vc6-re300dl/regex.obj vc6/vc6-re300dl/regex_debug.obj vc6/vc6-re300dl/regex_synch.obj vc6/vc6-re300dl/w32_regex_traits.obj vc6/vc6-re300dl/wide_posix_api.obj
<<
########################################################
#
# section for vc6-re300l.lib
#
########################################################
vc6/vc6-re300l/c_regex_traits.obj: ../src/c_regex_traits.cpp $(ALL_HEADER)
cl $(INCLUDES) /nologo /MD /W3 /GX /Oityb1 /GF /Gy /I../../../ /DNDEBUG /DWIN32 /D_WINDOWS /D_MBCS /D_USRDLL /DBOOST_RE_DLL_EXPORTS /DBOOST_RE_BUILD_DLL /YX /FD /c $(CXXFLAGS) -Fpvc6/vc6-re300l/vc6-re300l.pch -Fo./vc6/vc6-re300l/ -Fdvc6/vc6-re300l.pdb ../src/c_regex_traits.cpp
vc6/vc6-re300l/c_regex_traits_common.obj: ../src/c_regex_traits_common.cpp $(ALL_HEADER)
cl $(INCLUDES) /nologo /MD /W3 /GX /Oityb1 /GF /Gy /I../../../ /DNDEBUG /DWIN32 /D_WINDOWS /D_MBCS /D_USRDLL /DBOOST_RE_DLL_EXPORTS /DBOOST_RE_BUILD_DLL /YX /FD /c $(CXXFLAGS) -Fpvc6/vc6-re300l/vc6-re300l.pch -Fo./vc6/vc6-re300l/ -Fdvc6/vc6-re300l.pdb ../src/c_regex_traits_common.cpp
vc6/vc6-re300l/cpp_regex_traits.obj: ../src/cpp_regex_traits.cpp $(ALL_HEADER)
cl $(INCLUDES) /nologo /MD /W3 /GX /Oityb1 /GF /Gy /I../../../ /DNDEBUG /DWIN32 /D_WINDOWS /D_MBCS /D_USRDLL /DBOOST_RE_DLL_EXPORTS /DBOOST_RE_BUILD_DLL /YX /FD /c $(CXXFLAGS) -Fpvc6/vc6-re300l/vc6-re300l.pch -Fo./vc6/vc6-re300l/ -Fdvc6/vc6-re300l.pdb ../src/cpp_regex_traits.cpp
vc6/vc6-re300l/cregex.obj: ../src/cregex.cpp $(ALL_HEADER)
cl $(INCLUDES) /nologo /MD /W3 /GX /Oityb1 /GF /Gy /I../../../ /DNDEBUG /DWIN32 /D_WINDOWS /D_MBCS /D_USRDLL /DBOOST_RE_DLL_EXPORTS /DBOOST_RE_BUILD_DLL /YX /FD /c $(CXXFLAGS) -Fpvc6/vc6-re300l/vc6-re300l.pch -Fo./vc6/vc6-re300l/ -Fdvc6/vc6-re300l.pdb ../src/cregex.cpp
vc6/vc6-re300l/fileiter.obj: ../src/fileiter.cpp $(ALL_HEADER)
cl $(INCLUDES) /nologo /MD /W3 /GX /Oityb1 /GF /Gy /I../../../ /DNDEBUG /DWIN32 /D_WINDOWS /D_MBCS /D_USRDLL /DBOOST_RE_DLL_EXPORTS /DBOOST_RE_BUILD_DLL /YX /FD /c $(CXXFLAGS) -Fpvc6/vc6-re300l/vc6-re300l.pch -Fo./vc6/vc6-re300l/ -Fdvc6/vc6-re300l.pdb ../src/fileiter.cpp
vc6/vc6-re300l/posix_api.obj: ../src/posix_api.cpp $(ALL_HEADER)
cl $(INCLUDES) /nologo /MD /W3 /GX /Oityb1 /GF /Gy /I../../../ /DNDEBUG /DWIN32 /D_WINDOWS /D_MBCS /D_USRDLL /DBOOST_RE_DLL_EXPORTS /DBOOST_RE_BUILD_DLL /YX /FD /c $(CXXFLAGS) -Fpvc6/vc6-re300l/vc6-re300l.pch -Fo./vc6/vc6-re300l/ -Fdvc6/vc6-re300l.pdb ../src/posix_api.cpp
vc6/vc6-re300l/regex.obj: ../src/regex.cpp $(ALL_HEADER)
cl $(INCLUDES) /nologo /MD /W3 /GX /Oityb1 /GF /Gy /I../../../ /DNDEBUG /DWIN32 /D_WINDOWS /D_MBCS /D_USRDLL /DBOOST_RE_DLL_EXPORTS /DBOOST_RE_BUILD_DLL /YX /FD /c $(CXXFLAGS) -Fpvc6/vc6-re300l/vc6-re300l.pch -Fo./vc6/vc6-re300l/ -Fdvc6/vc6-re300l.pdb ../src/regex.cpp
vc6/vc6-re300l/regex_debug.obj: ../src/regex_debug.cpp $(ALL_HEADER)
cl $(INCLUDES) /nologo /MD /W3 /GX /Oityb1 /GF /Gy /I../../../ /DNDEBUG /DWIN32 /D_WINDOWS /D_MBCS /D_USRDLL /DBOOST_RE_DLL_EXPORTS /DBOOST_RE_BUILD_DLL /YX /FD /c $(CXXFLAGS) -Fpvc6/vc6-re300l/vc6-re300l.pch -Fo./vc6/vc6-re300l/ -Fdvc6/vc6-re300l.pdb ../src/regex_debug.cpp
vc6/vc6-re300l/regex_synch.obj: ../src/regex_synch.cpp $(ALL_HEADER)
cl $(INCLUDES) /nologo /MD /W3 /GX /Oityb1 /GF /Gy /I../../../ /DNDEBUG /DWIN32 /D_WINDOWS /D_MBCS /D_USRDLL /DBOOST_RE_DLL_EXPORTS /DBOOST_RE_BUILD_DLL /YX /FD /c $(CXXFLAGS) -Fpvc6/vc6-re300l/vc6-re300l.pch -Fo./vc6/vc6-re300l/ -Fdvc6/vc6-re300l.pdb ../src/regex_synch.cpp
vc6/vc6-re300l/w32_regex_traits.obj: ../src/w32_regex_traits.cpp $(ALL_HEADER)
cl $(INCLUDES) /nologo /MD /W3 /GX /Oityb1 /GF /Gy /I../../../ /DNDEBUG /DWIN32 /D_WINDOWS /D_MBCS /D_USRDLL /DBOOST_RE_DLL_EXPORTS /DBOOST_RE_BUILD_DLL /YX /FD /c $(CXXFLAGS) -Fpvc6/vc6-re300l/vc6-re300l.pch -Fo./vc6/vc6-re300l/ -Fdvc6/vc6-re300l.pdb ../src/w32_regex_traits.cpp
vc6/vc6-re300l/wide_posix_api.obj: ../src/wide_posix_api.cpp $(ALL_HEADER)
cl $(INCLUDES) /nologo /MD /W3 /GX /Oityb1 /GF /Gy /I../../../ /DNDEBUG /DWIN32 /D_WINDOWS /D_MBCS /D_USRDLL /DBOOST_RE_DLL_EXPORTS /DBOOST_RE_BUILD_DLL /YX /FD /c $(CXXFLAGS) -Fpvc6/vc6-re300l/vc6-re300l.pch -Fo./vc6/vc6-re300l/ -Fdvc6/vc6-re300l.pdb ../src/wide_posix_api.cpp
vc6-re300l_dir :
if not exist "vc6\vc6-re300l\$(NULL)" mkdir vc6\vc6-re300l
vc6-re300l_clean :
del vc6\vc6-re300l\*.obj
del vc6\vc6-re300l\*.idb
del vc6\vc6-re300l\*.exp
del vc6\vc6-re300l\*.pch
./vc6/vc6-re300l.lib : vc6/vc6-re300l/c_regex_traits.obj vc6/vc6-re300l/c_regex_traits_common.obj vc6/vc6-re300l/cpp_regex_traits.obj vc6/vc6-re300l/cregex.obj vc6/vc6-re300l/fileiter.obj vc6/vc6-re300l/posix_api.obj vc6/vc6-re300l/regex.obj vc6/vc6-re300l/regex_debug.obj vc6/vc6-re300l/regex_synch.obj vc6/vc6-re300l/w32_regex_traits.obj vc6/vc6-re300l/wide_posix_api.obj
link @<<
kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib /nologo /dll /incremental:yes /pdb:"vc6/vc6-re300l.pdb" /debug /machine:I386 /out:"vc6/vc6-re300l.dll" /implib:"vc6/vc6-re300l.lib" /pdbtype:sept $(XLFLAGS) vc6/vc6-re300l/c_regex_traits.obj vc6/vc6-re300l/c_regex_traits_common.obj vc6/vc6-re300l/cpp_regex_traits.obj vc6/vc6-re300l/cregex.obj vc6/vc6-re300l/fileiter.obj vc6/vc6-re300l/posix_api.obj vc6/vc6-re300l/regex.obj vc6/vc6-re300l/regex_debug.obj vc6/vc6-re300l/regex_synch.obj vc6/vc6-re300l/w32_regex_traits.obj vc6/vc6-re300l/wide_posix_api.obj
<<
########################################################
#
# section for vc6-re300ls.lib
#
########################################################
vc6/vc6-re300ls/c_regex_traits.obj: ../src/c_regex_traits.cpp $(ALL_HEADER)
cl $(INCLUDES) /nologo /MD /W3 /GX /Oityb1 /GF /Gy /I../../../ /DNDEBUG /DWIN32 /D_WINDOWS /D_MBCS /D_USRDLL /DBOOST_RE_STATIC_LIB /YX /FD /c $(CXXFLAGS) -Fpvc6/vc6-re300ls/vc6-re300ls.pch -Fo./vc6/vc6-re300ls/ -Fdvc6/vc6-re300ls.pdb ../src/c_regex_traits.cpp
vc6/vc6-re300ls/c_regex_traits_common.obj: ../src/c_regex_traits_common.cpp $(ALL_HEADER)
cl $(INCLUDES) /nologo /MD /W3 /GX /Oityb1 /GF /Gy /I../../../ /DNDEBUG /DWIN32 /D_WINDOWS /D_MBCS /D_USRDLL /DBOOST_RE_STATIC_LIB /YX /FD /c $(CXXFLAGS) -Fpvc6/vc6-re300ls/vc6-re300ls.pch -Fo./vc6/vc6-re300ls/ -Fdvc6/vc6-re300ls.pdb ../src/c_regex_traits_common.cpp
vc6/vc6-re300ls/cpp_regex_traits.obj: ../src/cpp_regex_traits.cpp $(ALL_HEADER)
cl $(INCLUDES) /nologo /MD /W3 /GX /Oityb1 /GF /Gy /I../../../ /DNDEBUG /DWIN32 /D_WINDOWS /D_MBCS /D_USRDLL /DBOOST_RE_STATIC_LIB /YX /FD /c $(CXXFLAGS) -Fpvc6/vc6-re300ls/vc6-re300ls.pch -Fo./vc6/vc6-re300ls/ -Fdvc6/vc6-re300ls.pdb ../src/cpp_regex_traits.cpp
vc6/vc6-re300ls/cregex.obj: ../src/cregex.cpp $(ALL_HEADER)
cl $(INCLUDES) /nologo /MD /W3 /GX /Oityb1 /GF /Gy /I../../../ /DNDEBUG /DWIN32 /D_WINDOWS /D_MBCS /D_USRDLL /DBOOST_RE_STATIC_LIB /YX /FD /c $(CXXFLAGS) -Fpvc6/vc6-re300ls/vc6-re300ls.pch -Fo./vc6/vc6-re300ls/ -Fdvc6/vc6-re300ls.pdb ../src/cregex.cpp
vc6/vc6-re300ls/fileiter.obj: ../src/fileiter.cpp $(ALL_HEADER)
cl $(INCLUDES) /nologo /MD /W3 /GX /Oityb1 /GF /Gy /I../../../ /DNDEBUG /DWIN32 /D_WINDOWS /D_MBCS /D_USRDLL /DBOOST_RE_STATIC_LIB /YX /FD /c $(CXXFLAGS) -Fpvc6/vc6-re300ls/vc6-re300ls.pch -Fo./vc6/vc6-re300ls/ -Fdvc6/vc6-re300ls.pdb ../src/fileiter.cpp
vc6/vc6-re300ls/posix_api.obj: ../src/posix_api.cpp $(ALL_HEADER)
cl $(INCLUDES) /nologo /MD /W3 /GX /Oityb1 /GF /Gy /I../../../ /DNDEBUG /DWIN32 /D_WINDOWS /D_MBCS /D_USRDLL /DBOOST_RE_STATIC_LIB /YX /FD /c $(CXXFLAGS) -Fpvc6/vc6-re300ls/vc6-re300ls.pch -Fo./vc6/vc6-re300ls/ -Fdvc6/vc6-re300ls.pdb ../src/posix_api.cpp
vc6/vc6-re300ls/regex.obj: ../src/regex.cpp $(ALL_HEADER)
cl $(INCLUDES) /nologo /MD /W3 /GX /Oityb1 /GF /Gy /I../../../ /DNDEBUG /DWIN32 /D_WINDOWS /D_MBCS /D_USRDLL /DBOOST_RE_STATIC_LIB /YX /FD /c $(CXXFLAGS) -Fpvc6/vc6-re300ls/vc6-re300ls.pch -Fo./vc6/vc6-re300ls/ -Fdvc6/vc6-re300ls.pdb ../src/regex.cpp
vc6/vc6-re300ls/regex_debug.obj: ../src/regex_debug.cpp $(ALL_HEADER)
cl $(INCLUDES) /nologo /MD /W3 /GX /Oityb1 /GF /Gy /I../../../ /DNDEBUG /DWIN32 /D_WINDOWS /D_MBCS /D_USRDLL /DBOOST_RE_STATIC_LIB /YX /FD /c $(CXXFLAGS) -Fpvc6/vc6-re300ls/vc6-re300ls.pch -Fo./vc6/vc6-re300ls/ -Fdvc6/vc6-re300ls.pdb ../src/regex_debug.cpp
vc6/vc6-re300ls/regex_synch.obj: ../src/regex_synch.cpp $(ALL_HEADER)
cl $(INCLUDES) /nologo /MD /W3 /GX /Oityb1 /GF /Gy /I../../../ /DNDEBUG /DWIN32 /D_WINDOWS /D_MBCS /D_USRDLL /DBOOST_RE_STATIC_LIB /YX /FD /c $(CXXFLAGS) -Fpvc6/vc6-re300ls/vc6-re300ls.pch -Fo./vc6/vc6-re300ls/ -Fdvc6/vc6-re300ls.pdb ../src/regex_synch.cpp
vc6/vc6-re300ls/w32_regex_traits.obj: ../src/w32_regex_traits.cpp $(ALL_HEADER)
cl $(INCLUDES) /nologo /MD /W3 /GX /Oityb1 /GF /Gy /I../../../ /DNDEBUG /DWIN32 /D_WINDOWS /D_MBCS /D_USRDLL /DBOOST_RE_STATIC_LIB /YX /FD /c $(CXXFLAGS) -Fpvc6/vc6-re300ls/vc6-re300ls.pch -Fo./vc6/vc6-re300ls/ -Fdvc6/vc6-re300ls.pdb ../src/w32_regex_traits.cpp
vc6/vc6-re300ls/wide_posix_api.obj: ../src/wide_posix_api.cpp $(ALL_HEADER)
cl $(INCLUDES) /nologo /MD /W3 /GX /Oityb1 /GF /Gy /I../../../ /DNDEBUG /DWIN32 /D_WINDOWS /D_MBCS /D_USRDLL /DBOOST_RE_STATIC_LIB /YX /FD /c $(CXXFLAGS) -Fpvc6/vc6-re300ls/vc6-re300ls.pch -Fo./vc6/vc6-re300ls/ -Fdvc6/vc6-re300ls.pdb ../src/wide_posix_api.cpp
vc6-re300ls_dir :
if not exist "vc6\vc6-re300ls\$(NULL)" mkdir vc6\vc6-re300ls
vc6-re300ls_clean :
del vc6\vc6-re300ls\*.obj
del vc6\vc6-re300ls\*.idb
del vc6\vc6-re300ls\*.exp
del vc6\vc6-re300ls\*.pch
./vc6/vc6-re300ls.lib : vc6/vc6-re300ls/c_regex_traits.obj vc6/vc6-re300ls/c_regex_traits_common.obj vc6/vc6-re300ls/cpp_regex_traits.obj vc6/vc6-re300ls/cregex.obj vc6/vc6-re300ls/fileiter.obj vc6/vc6-re300ls/posix_api.obj vc6/vc6-re300ls/regex.obj vc6/vc6-re300ls/regex_debug.obj vc6/vc6-re300ls/regex_synch.obj vc6/vc6-re300ls/w32_regex_traits.obj vc6/vc6-re300ls/wide_posix_api.obj
link -lib /nologo /out:vc6/vc6-re300ls.lib $(XSFLAGS) vc6/vc6-re300ls/c_regex_traits.obj vc6/vc6-re300ls/c_regex_traits_common.obj vc6/vc6-re300ls/cpp_regex_traits.obj vc6/vc6-re300ls/cregex.obj vc6/vc6-re300ls/fileiter.obj vc6/vc6-re300ls/posix_api.obj vc6/vc6-re300ls/regex.obj vc6/vc6-re300ls/regex_debug.obj vc6/vc6-re300ls/regex_synch.obj vc6/vc6-re300ls/w32_regex_traits.obj vc6/vc6-re300ls/wide_posix_api.obj

View File

@ -1,267 +0,0 @@
Version 311:
FIXED: Support for STLPort 4.1b6.
FIXED: Library calling convention for VC6 debug builds.
FIXED: Borland compiler support when using non-default calling convention.
CHANGED: Reorganised and simplified config setup.
ADDED: Support for replacing only the first occurance during a regex_merge
using the format_first_only flag.
CHANGED: Removed use of deprecated api set_expression in one of the examples.
Version 310:
ADDED: Support for static linking with VC6 + dynamic runtime.
CHANGED: Library directory structure.
Version 305:
FIXED: VC6.sp5 fix.
ADDED: Support for mixed static/dynamic linking with vc6.
ADDED: Sunpro makefiles
FIXED: SunPro 6.1 support
FIXED: Spurious extra matches at the end of input when grepping with .*
Version 304:
FIXED: Missing this-> prefix to some symbols in cpp_regex_traits.cpp
CHANGED: Error reporting for wide character tests.
FIXED: Win2K problem with [[:unicode:]]
FIXED: Signed/unsigned conversions in regex_compile.hpp and regex_format.hpp
ADDED: Forwarder functions to match_results.
FIXED: More errors from Como in strict mode.
Version 303:
FIXED: Code glitches for Como compiler in strict mode.
FIXED: Missing fixes for cstdio header.
FIXED: memory leak in underlying w32 traits classes
FIXED: vc6 clean option to remove *.pch files.
CHANGED: Build options for VC6 to avoid compiler optimisation bug.
FIXED: Missing BOOST_RE_NO_WCSTRING guard around using declaration in regex.h
FIXED: Pathological regular expressions in snip4.cpp and in docs.
FIXED: Missing std:: prefixes in some headers.
Version 302:
FIXED: STLPort debug problems.
FIXED: Compatibility with updated Dinkum libraries and VC6.
ADDED: Tentative support for partial matches (not yet documented).
Version 301:
First boost release version,
CHANGED: reg_match to match_results
CHANGED: Documentation updated to reflect changes, provided links to sources from docs.
CHANGED: RegEx(const char*) constructor to explicit.
CHANGED: Return type of RegEx::Split to unsigned int.
ADDED: Exception documentation for OS errors.
REMOVED: BOOST_RE_NO_EXCEPTIONS macro.
FIXED: mapfile::open/close to check for OS errors.
FIXED: Non-exception safe code in cpp_regex_traits.
FIXED: Removed undefined symbol INFINITE from re_thrd.hpp
FIXED: Bug in configure script thread detection code.
CHANGED: "depreciated" to "deprecated"
FIXED: Documentation error for bad_expression.
CHANGED: regbase::flag_type to unsigned int
ADDED: explicit constructors to reg_expression/match_results
ADDED: extra signatures for regex_format/regex_merge for std::string arguments.
REMOVED: bad_pattern/bad_expression::what from regex.cpp
REMOVED: Implicit conversion operators from sub_match (except for conversion to basic_string).
Version 300:
Candidate release boost version,
ADDED: Support for non-greedy repeats.
ADDED: Support for non-marking grouping.
ADDED: Auto-detection of STLPort STL versions.
CHANGED: Re-written and re-organised traits classes.
CHANGED: Regression test make files for more rigorous testing of all build versions.
Version 249:
Pre-release boost version,
CHANGED: All macro prefixes to BOOST_RE_
CHANGED: namespaces to boost
CHANGED: Header file extentions to .hpp
DEPRECIATED: Old style algorithms, replaced with more consistant naming style.
DEPRECIATED: Standard library independant compiles no longer possible, bespoke
classes replaced with standard library/boost equivalents where available.
Version 221:
ADDED: C++ Builder 3 workaround in boost/detail/jgrep.hpp
Version 220:
ADDED: Merge functions to class RegEx
Version 218:
FIXED: All known bugs prior to this version.
FIXED: Added workaround for gcc optimisation bug to jm/regmatch.h
ADDED: Cygwin mount point support.
Version 217:
BUG: configure script did not correctly identify template
friend support, or template function partial ordering support.
FIXED: All known bugs prior to this version.
Version 216:
BUG: Some RegEx::Grep variants buggy.
BUG: FileIterator leaked memory.
BUG: Memory alignment problems with gcc/sparc platform
CHANGED: RegEx callback declarations to cope with VC6 builds using
non-default calling conventions.
CHANGED: Some configuration options to try and keep Mingwin32 port
of gcc 2.95 happy.
FIXED: Bug in RegEx::What introduced in version 214 fix :-(
Version 215:
CHANGED: Added #pragma push/pop to fix C++ Builder 3 problems.
CHANGED: Wide to narrow character conversions, to be more conformant with standard.
CHANGED: Minor documentation updates.
Version 214:
FIXED All known bugs rpior to this point.
CHANGED: Minor changes to keep VC5 and GCC 2.95 happy.
Version 213:
BUG: Far eastern versions of Win32 could not compile
re_nlsw.cpp due to string literal - code page
interactions.
ADDED: Convenience conversion operators to sub_match<>.
CHANGED: Removed REG_E_MEMORY as it duplicates REG_ESPACE.
ADDED: Additional tests to regress.
CHANGED: RegEx::GrepFiles and RegEx::FindFiles previously had undefined
behaviour if the callback returned false, changed to abort
the whole search if the callback returns false.
FIXED: All known bugs prior to this release.
Version 212:
BUG: Use of catopen in re_mss.cpp causes problems on some systems.
BUG: Comparison operators for reg_expression and reg_match should be const.
BUG: Missing output iterator increment in regfmt.h.
ADDED: REG_NOCOLLATE, so that locale dependent collation can be turned off for
the POSIX C API's as well as the underlying templates.
CHANGED: Misc. documentation updates.
FIXED: Linking problem for some egcs ports.
CHANGED: Tightened up exception safety.
ADDED: Convenience interfaces to query_match, reg_search, reg_grep, reg_format and reg_merge.
ADDED: Convenience std::string overloads of reg_expression members.
FIXED: All bugs found prior to this release.
Version 211:
BUG: RegEx::GrepFiles fails to log sub-expression matches correctly.
BUG: file_iterator/directory_iterator fail to find all files when using '*'.
CHANGED: Changes required to make the code compile with HP's aCC compiler.
CHANGED: Using declarations, to hide implimentation details.
CHANGED: Behavior of ^ and $ to follow Unicode newline guidelines and account
for \r\n sequences.
Version 210:
FIXED: All known bugs prior to this point.
ADDED: configure shell script for porting to Unix style systems.
CHANGED: jm::reg_match_base::pair to jm::sub_match, for easier porting.
Version 200:
BUG: RegEx::GrepFiles buggy
BUG: RegEx::FindFiles buggy
BUG: non-portable header file usage in fileiter.h
BUG: non-portable enum declarations in headers.
BUG: non-portable use of isspace in regfacet.cpp
BUG: Missing regfac.obj from bcb makefiles.
BUG: non-portable declaration of type jm::reg_match_base::reference.
BUG: missing <wchar.h> declaration required by some systems.
BUG: Use of JM_NO_WCSTRING incomplete.
BUG: Misspelled JM_NO_EXCEPTIONS in places.
BUG: regfmt.h has typo on line 538.
BUG: reg_format and reg_merge not portable to all output iterator types.
BUG: non-portable use of typedefs.
BUG: non-portable use of friend declarations.
CHANGED: Allocator usage, to improve efficiency with instance based allocators.
CHANGED: regress.h, various fixes for various Borland C++ versions, allocators cleaned up.
ADDED: Win32 specific localisation code.
ADDED: C and C++ specific localisation code.
ADDED: collating element and equivalence class support.
CHANGED: Character class declarations.
CHANGED: Behaviour of ranges to deal with locales.
ADDED: Support for some perl escape sequences (but not yet (?...) ).
CHANGED: regbase::icase flag now turns on case insensitivity,
traits class char_regex_traits_i is now deprecated.
CHANGED: reg_grep now takes a predicate not an output iterator,
allows user code to terminate search midway through,
and to use regular callback function with grep.
CHANGED: Modified search heuristics to improve certain expression
types, especially expressions which start with a literal
string, or a single character repeat. The latter are much
less likely to become pathological now.
ADDED: High level C++ class RegEx.
Version 111:
BUG: Wouldn't compile directly on C++ Builder 4 when it was released
(not really a bug - more an incompatability)
FIXED: All bugs discovered prior to this version (below).
Version 110:
BUG: reg_match::maybe_assign could lead to pointer
overrun in certain (rare) circumstances.
FIXED: All bugs discovered prior to this version (below).
FIXED: Support for VC++, GCC, EGCS.
CHANGED: Regress.h to work around various compiler bugs.
Version 100:
BUG: Literal "," not recognised as a literal.
FIXED: All bugs discovered prior to this version (below).
ADDED: Regress.exe, regression test application.
Version 095
BUG: wide character sets that start with ^ not recognised,
for example [^[:space:]] will not find anything.
BUG: reg_grep fails if match occurs at first character.
BUG: If regcomp fails, internal data not freed.
BUG: reg_grep fails to reinitialise match after assignment
to output iterator. Line start optimised search restarts
from the wrong location if the match is longer than one line.
BUG: POSIX API functions can propagate C++ exceptions if the
default allocator can throw exceptions.
BUG: character sets don't function correctly when regbase::char_classes
is not set.

3147
configure vendored

File diff suppressed because it is too large Load Diff

File diff suppressed because it is too large Load Diff

14
dmi.sh
View File

@ -1,14 +0,0 @@
#! /bin/sh
if test "$#" != "1"; then
exit 1
fi
cd "$1"
if eval make; then
exit 0
fi
exit 1

View File

@ -1,50 +0,0 @@
# very basic makefile for jgrep.exe
#
# Borland C++ tools
#
# BCROOT defines the root directory of your bc builder install
#
!ifndef BCROOT
BCROOT=$(MAKEDIR)\..
!endif
BCC32 = $(BCROOT)\bin\Bcc32.exe
LIBPATH=..\..\build\bcb5
IDE_LinkFLAGS32 = -L$(BCROOT)\LIB
LINKOPTS= -ap -Tpe -x
COMPOPTS= -O2 -tWM- -DSTRICT; -I$(BCROOT)\include;../../../../; -D_NO_VCL
jgrep.exe : jgrep.obj main.obj
$(BCC32) $(COMPOPTS) -e$@ -L$(LIBPATH) main.obj jgrep.obj
jgrep.obj : jgrep.cpp
$(BCC32) -c @&&|
$(COMPOPTS) -o$@ jgrep.cpp
|
main.obj : main.cpp
$(BCC32) -c @&&|
$(COMPOPTS) -o$@ main.cpp
|

View File

@ -1,50 +0,0 @@
# very basic makefile for jgrep.exe
#
# Borland C++ tools
#
# BCROOT defines the root directory of your bc builder install
#
!ifndef BCROOT
BCROOT=$(MAKEDIR)\..
!endif
BCC32 = $(BCROOT)\bin\Bcc32.exe
LIBPATH="..\..\build\bcb4"
IDE_LinkFLAGS32 = -L$(BCROOT)\LIB
LINKOPTS= -ap -Tpe -x
COMPOPTS= -O2 -tWM- -DSTRICT; -I$(BCROOT)\include;../../../../; -D_NO_VCL
jgrep.exe : jgrep.obj main.obj
$(BCC32) @&&|
$(COMPOPTS) -e$@ -L$(LIBPATH) main.obj jgrep.obj
|
jgrep.obj : jgrep.cpp
$(BCC32) -c @&&|
$(COMPOPTS) -o$@ jgrep.cpp
|
main.obj : main.cpp
$(BCC32) -c @&&|
$(COMPOPTS) -o$@ main.cpp
|

View File

@ -1,49 +0,0 @@
# very basic makefile for jgrep.exe
#
# Borland C++ tools
#
# BCROOT defines the root directory of your bc builder install
#
!ifndef BCROOT
BCROOT=$(MAKEDIR)\..
!endif
BCC32 = $(BCROOT)\bin\Bcc32.exe
LIBPATH=../../build/bcb5
IDE_LinkFLAGS32 = -L$(BCROOT)\LIB
LINKOPTS= -ap -Tpe -x
COMPOPTS= -O2 -tWM- -DSTRICT; -I$(BCROOT)\include;../../../../; -D_NO_VCL
jgrep.exe : jgrep.obj main.obj
$(BCC32) $(COMPOPTS) -e$@ -L..\..\build\bcb5 main.obj jgrep.obj
jgrep.obj : jgrep.cpp
$(BCC32) -c @&&|
$(COMPOPTS) -o$@ jgrep.cpp
|
main.obj : main.cpp
$(BCC32) -c @&&|
$(COMPOPTS) -o$@ main.cpp
|

View File

@ -1,32 +0,0 @@
# very basic makefile for jgrep
#
# GNU compiler g++
#
CXX= $(INCLUDES) -O2 -I../../../../ -I./ $(CXXFLAGS) $(LDFLAGS)
jgrep : jgrep.cpp main.cpp
g++ -ojgrep $(CXX) jgrep.cpp main.cpp -L../../build/gcc -lboost_regex $(LIBS)
debug : jgrep.cpp main.cpp
g++ -ojgrep -I../../../../ -I./ -g jgrep.cpp main.cpp -L../../build/gcc -lboost_regex_debug $(LIBS)

View File

@ -1,126 +0,0 @@
/*
*
* 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.
*
*/
/*
* FILE jgrep.cpp
* VERSION 3.12
*/
#include <stdio.h>
#include <boost/regex.hpp>
#ifdef JM_OLD_IOSTREAM
#include <iostream.h>
#else
#include <iostream>
using std::cout;
using std::cin;
using std::cerr;
using std::endl;
#endif
#pragma hrdstop
#include <boost/regex/detail/fileiter.hpp>
#include "jgrep.h"
//
// class ogrep_predicate
// outputs the results of regex_grep to screen:
template <class iterator, class Allocator >
class ogrep_predicate
{
unsigned int& lines;
const char* filename;
unsigned int last_line;
iterator end_of_storage;
public:
ogrep_predicate(unsigned int& i, const char* p, iterator e) : lines(i), filename(p), last_line(-1), end_of_storage(e) {}
ogrep_predicate(const ogrep_predicate& o) : lines(o.lines), filename(o.filename), last_line(o.last_line), end_of_storage(o.end_of_storage) {}
bool operator () (const boost::match_results<iterator, Allocator>& i);
};
// ideally we'd ignor the allocator type and use a template member function
// to deel with the allocator type passed to regex_grep, unfortunately most
// compilers don't support this feature yet, so we'll have to be sure that
// the allocator passed to instances of this class match that used in our
// regular expression classes.
template <class iterator, class Allocator>
bool ogrep_predicate<iterator, Allocator>::operator()(const boost::match_results<iterator, Allocator>& i)
{
if(last_line == (unsigned int)-1)
cout << "File " << filename << ":" << endl;
if(last_line != i.line())
{
++lines;
last_line = i.line();
if(count_only == 0)
{
if(show_lines)
cout << i.line() << "\t";
iterator ptr = i.line_start();
while((ptr != end_of_storage) && (*ptr != '\n'))++ptr;
iterator pos = i.line_start();
while(pos != ptr)
{
cout.put(*pos);
++pos;
}
cout << endl;
}
}
return true;
}
void process_grep(const char* file)
{
using namespace boost;
mapfile f(file);
unsigned int count = 0;
ogrep_predicate<mapfile::iterator, allocator_type> oi(count, file, f.end());
if(files_only)
{
bool ok;
boost::match_results<mapfile::iterator, allocator_type> m;
ok = regex_search(f.begin(), f.end(), m, e, match_not_dot_newline | match_not_dot_null);
if(ok)
cout << "File " << file << endl;
}
else
{
regex_grep(oi, f.begin(), f.end(), e, match_not_dot_newline | match_not_dot_null);
if(count)
{
if(verbose || count_only)
{
cout << count << " lines match" << endl;
return;
}
}
else if(verbose)
{
cout << "File " << file << "(" << f.size() << "bytes):" << endl << "0 lines match" << endl;
}
}
}

View File

@ -1,53 +0,0 @@
/*
*
* 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.
*
*/
/*
* FILE jgrep.h
* VERSION 3.12
*/
#ifndef _JGREP_H
#define _JGREP_H
#include <boost/regex.hpp>
// case sensitive reg_expression determines our allocator type:
typedef boost::reg_expression<char> re_type;
typedef re_type::allocator_type allocator_type;
// now declare static (global) data, including an allocator
// instance which we'll pass to all instances that require an allocator.
extern allocator_type a;
extern re_type e;
// flags for output:
extern bool use_case;
extern bool show_lines;
extern bool count_only;
extern bool files_only;
extern bool recurse;
extern bool regularexs;
extern bool words_only;
extern bool verbose;
void process_grep(const char* file);
#endif

View File

@ -1,284 +0,0 @@
/*
*
* 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.
*
*/
/*
* FILE main.cpp
* VERSION 3.12
*/
#include <stdio.h>
#include <boost/regex.hpp>
#ifdef JM_OLD_IOSTREAM
#include <iostream.h>
#else
#include <iostream>
using std::cout;
using std::cin;
using std::cerr;
using std::endl;
#endif
#pragma hrdstop
#include <boost/regex/detail/fileiter.hpp>
#include "jgrep.h"
#ifndef JM_ALGO_INCLUDED
// HP and SGI STL's use <algo.h> instead
// this will have been pulled in by <jm_cfg.h>
// for std::distance
#include <algorithm>
#endif
allocator_type a;
re_type e(a);
//rei_type ei(a);
// flags for output:
bool use_case = true;
bool show_lines = false;
bool count_only = false;
bool files_only = false;
bool recurse = false;
bool regularexs = true;
bool words_only = false;
bool verbose = false;
void usage()
{
cout <<
"jgrep version 0.95\n"
"usage: jgrep [-options] expression file [files...]\n"
"\n"
"options can be one of the following:\n"
"\n"
"-c prints a count of the number of matching lines only\n"
"-d recurses through subdirectories for matching files\n"
"-i causes case to be ignored when matching\n"
"-l lists the files which contain a match only\n"
"-n displays the line numbers of matches\n"
"-r- causes the expression to be interpreted as a literal string and not\n"
" as a regular expression\n"
"-w searches for matches that are whole words only\n"
"-z verbose mode\n"
"\n"
"expression: a regular expression, or a literal string if -r- is specified\n"
"\n"
"files: one or more files to search, the names can contain the wildcard\n"
" characters ? and *\n" << endl;
}
void parse_switch(const char* flag)
{
++flag;
while(*flag)
{
switch(*flag)
{
case '-':
switch(*(flag-1))
{
case 'c':
count_only = false;
break;
case 'd':
recurse = false;
break;
case 'i':
use_case = false;
break;
case 'l':
files_only = false;
break;
case 'n':
show_lines = false;
break;
case 'r':
regularexs = false;
break;
case 'w':
words_only = false;
break;
case 'z':
verbose = false;
break;
default:
cout << "Undefined option -";
cout.put(*flag);
cout << endl;
}
// turn off prev character:
break;
case 'c':
count_only = true;
break;
case 'd':
recurse = true;
break;
case 'i':
use_case = false;
break;
case 'l':
files_only = true;
break;
case 'n':
show_lines = true;
break;
case 'r':
regularexs = true;
break;
case 'w':
words_only = true;
break;
case 'z':
verbose = true;
break;
case '?':
usage();
exit(0);
case '+':
break;
default:
cout << "Undefined option -";
cout.put(*flag);
cout << endl;
}
++flag;
}
}
void HandleFile(const char* wild)
{
using namespace boost;
jm_trace("Handling file " << wild);
file_iterator end;
file_iterator start(wild);
if(recurse)
{
// go through sub directories:
char buf[MAX_PATH];
std::strcpy(buf, start.root());
int rootlen = strlen(buf);
if(*buf == 0)
{
std::strcpy(buf, ".");
std::strcat(buf, directory_iterator::separator());
std::strcat(buf, "*");
}
else
{
std::strcat(buf, directory_iterator::separator());
std::strcat(buf, "*");
}
jm_trace("Enumerating directories: " << buf);
directory_iterator dstart(buf);
directory_iterator dend;
// now get the file mask bit of "wild":
const char* ptr = wild + rootlen;
if(*ptr) ++ptr;
jm_trace("File mask part is: " << ptr);
while(dstart != dend)
{
std::sprintf(buf, "%s%s%s", dstart.path(), directory_iterator::separator(), ptr);
HandleFile(buf);
++dstart;
}
}
std::for_each(start, end, process_grep);
}
int done = 0;
void HandleArg(const char* arg)
{
using namespace boost;
jm_trace("Handling argument: " << arg);
if(*arg == '-')
{
parse_switch(arg);
return;
}
if(done == 0)
{
// parse regular expression
if(regularexs)
{
if(words_only == 0)
{
e.set_expression(arg, use_case ? regbase::normal : regbase::normal | regbase::icase);
//ei.set_expression(arg);
}
else
{
char* buf = new char[std::strlen(arg) + 8];
std::sprintf(buf, "\\<%s\\>", arg);
e.set_expression(buf, use_case ? regbase::normal : regbase::normal | regbase::icase);
//ei.set_expression(buf);
delete[] buf;
}
}
else
{
// we need to convert text to literal:
int len2 = std::strlen(arg);
int len = len2 * 5 + 6;
char buf[8];
char* buf2 = new char[len];
*buf2 = 0;
if(words_only)
std::strcpy(buf2, "\\<");
for(int j = 0; j < len2; ++j)
{
std::sprintf(buf, "\\0%o", int(arg[j]));
std::strcat(buf2, buf);
}
if(words_only)
std::strcat(buf2, "\\>");
e.set_expression(buf2, use_case ? regbase::normal : regbase::normal | regbase::icase);
//ei.set_expression(buf2);
delete[] buf2;
}
done = 1;
return;
}
// if we get to here we have one or more file names to process:
++done;
HandleFile(arg);
}
int main(int argc, char * argv[])
{
for(int i = 1; i < argc; ++i)
HandleArg(argv[i]);
if(done < 2)
usage();
return 0;
}

View File

@ -1,42 +0,0 @@
# very basic makefile for jgrep
#
CXX=@CXX@
CXXFLAGS=@CXXFLAGS@
LIBS=@LIBS@
EXE=@ac_exe_ext@
OBJ=@ac_obj_ext@
LIBDEP=../../build/libboost_regex.a ../../../../boost/regex/detail/regex_options.hpp ../../../../boost/regex/detail/regex_config.hpp
jgrep$(EXE) : jgrep$(OBJ) main$(OBJ)
$(CXX) -o jgrep$(EXE) jgrep$(OBJ) main$(OBJ) -L../../build -lboost_regex $(LIBS)
jgrep$(OBJ) : jgrep.cpp jgrep.h $(LIBDEP)
$(CXX) -c $(CXXFLAGS) -I../../../../ -I./ jgrep.cpp
main$(OBJ) : main.cpp jgrep.h $(LIBDEP)
$(CXX) -c $(CXXFLAGS) -I../../../../ -I./ main.cpp

View File

@ -1,18 +0,0 @@
#
# very simple makefile for Visual C++ 6 + STLPort 4
#
jgrep.exe: main.cpp jgrep.cpp jgrep.h
cl -GX -GR /Oityb1 /GF /Gy -MT -I..\..\..\..\ jgrep.cpp main.cpp /link /LIBPATH:..\..\build\vc6-stlport user32.lib

View File

@ -1,17 +0,0 @@
#
# very simple makefile for Visual C++ 6
#
jgrep.exe: main.cpp jgrep.cpp jgrep.h
cl -GX -GR /Oityb1 /GF /Gy -I..\..\..\..\ jgrep.cpp main.cpp /link /LIBPATH:..\..\build\vc6 user32.lib

View File

@ -1,69 +0,0 @@
/*
*
* 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.
*
*/
/*
* LOCATION: see http://www.boost.org for most recent version.
* FILE credit_card_example.cpp
* VERSION 3.00
* DESCRIPTION: Credit card number formatting code.
*/
#include <string>
#include <boost/regex.hpp>
bool validate_card_format(const std::string& s)
{
static const boost::regex e("(\\d{4}[- ]){3}\\d{4}");
return boost::regex_match(s, e);
}
const boost::regex e("\\A(\\d{3,4})[- ]?(\\d{4})[- ]?(\\d{4})[- ]?(\\d{4})\\z");
const std::string machine_format("\\1\\2\\3\\4");
const std::string human_format("\\1-\\2-\\3-\\4");
std::string machine_readable_card_number(const std::string& s)
{
return boost::regex_merge(s, e, machine_format, boost::match_default | boost::format_sed);
}
std::string human_readable_card_number(const std::string& s)
{
return boost::regex_merge(s, e, human_format, boost::match_default | boost::format_sed);
}
#include <iostream>
using namespace std;
int main()
{
string s[4] = { "0000111122223333", "0000 1111 2222 3333",
"0000-1111-2222-3333", "000-1111-2222-3333", };
int i;
for(i = 0; i < 4; ++i)
{
cout << "validate_card_format(\"" << s[i] << "\") returned " << validate_card_format(s[i]) << endl;
}
for(i = 0; i < 4; ++i)
{
cout << "machine_readable_card_number(\"" << s[i] << "\") returned " << machine_readable_card_number(s[i]) << endl;
}
for(i = 0; i < 4; ++i)
{
cout << "human_readable_card_number(\"" << s[i] << "\") returned " << human_readable_card_number(s[i]) << endl;
}
return 0;
}

View File

@ -1,83 +0,0 @@
#include <iostream>
#include <fstream>
#include <sstream>
#include <string>
#include <boost/regex.hpp>
// match some kind of html tag:
boost::regex e("<[^>]*>");
// count how many:
unsigned int tags = 0;
// saved position of partial match:
char* next_pos = 0;
bool grep_callback(const boost::match_results<char*>& m)
{
if(m[0].matched == false)
{
// save position and return:
next_pos = m[0].first;
}
else
++tags;
return true;
}
void search(std::istream& is)
{
char buf[4096];
next_pos = buf + sizeof(buf);
bool have_more = true;
while(have_more)
{
// how much do we copy forward from last try:
unsigned leftover = (buf + sizeof(buf)) - next_pos;
// and how much is left to fill:
unsigned size = next_pos - buf;
// copy forward whatever we have left:
memmove(buf, next_pos, leftover);
// fill the rest from the stream:
unsigned read = is.readsome(buf + leftover, size);
// check to see if we've run out of text:
have_more = read == size;
// reset next_pos:
next_pos = buf + sizeof(buf);
// and then grep:
boost::regex_grep(grep_callback,
buf,
buf + read + leftover,
e,
boost::match_default | boost::match_partial);
}
}
int main(int argc, char* argv[])
{
if(argc > 1)
{
for(unsigned int i = 1; i < argc; ++i)
{
std::ifstream fs(argv[i]);
if(fs.bad()) continue;
search(fs);
}
}
else
{
std::string one("<META NAME=\"keywords\" CONTENT=\"regex++, regular expressions, regular expression library, C++\">");
std::string what;
while(what.size() < 10000)
{
what.append(one);
what.append(13, ' ');
}
std::stringstream ss;
ss.str(what);
search(ss);
}
std::cout << "total tag count was " << tags << std::endl;
return 0;
}

View File

@ -1,46 +0,0 @@
#include <string>
#include <iostream>
#include <boost/regex.hpp>
boost::regex e("(\\d{3,4})[- ]?(\\d{4})[- ]?(\\d{4})[- ]?(\\d{4})");
bool is_possible_card_number(const std::string& input)
{
//
// return false for partial match, true for full match, or throw for
// impossible match based on what we have so far...
boost::match_results<std::string::const_iterator> what;
if(0 == boost::regex_match(input, what, e, boost::match_default | boost::match_partial))
{
// the input so far could not possibly be valid so reject it:
throw std::runtime_error("Invalid data entered - this could not possibly be a valid card number");
}
// OK so far so good, but have we finished?
if(what[0].matched)
{
// excellent, we have a result:
return true;
}
// what we have so far is only a partial match...
return false;
}
int main(int argc, char* argv[])
{
try{
std::string input;
std::cin >> input;
if(is_possible_card_number(input))
{
std::cout << "Matched OK..." << std::endl;
}
else
std::cout << "Got a partial match..." << std::endl;
}
catch(const std::exception& e)
{
std::cout << e.what() << std::endl;
}
return 0;
}

View File

@ -1,107 +0,0 @@
/*
*
* 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.
*
*/
/*
* LOCATION: see http://www.boost.org for most recent version.
* FILE regex_grep_example_1.cpp
* VERSION 3.00
* DESCRIPTION: regex_grep example 1: searches a cpp file for class definitions.
*/
#include <string>
#include <map>
#include <boost/regex.hpp>
// purpose:
// takes the contents of a file in the form of a string
// and searches for all the C++ class definitions, storing
// their locations in a map of strings/int's
typedef std::map<std::string, int, std::less<std::string> > map_type;
boost::regex expression("^(template[[:space:]]*<[^;:{]+>[[:space:]]*)?(class|struct)[[:space:]]*(\\<\\w+\\>([[:blank:]]*\\([^)]*\\))?[[:space:]]*)*(\\<\\w*\\>)[[:space:]]*(<[^;:{]+>)?[[:space:]]*(\\{|:[^;\\{()]*\\{)");
class IndexClassesPred
{
map_type& m;
std::string::const_iterator base;
public:
IndexClassesPred(map_type& a, std::string::const_iterator b) : m(a), base(b) {}
bool operator()(const boost::match_results<std::string::const_iterator, boost::regex::allocator_type>& what)
{
// what[0] contains the whole string
// what[5] contains the class name.
// what[6] contains the template specialisation if any.
// add class name and position to map:
m[std::string(what[5].first, what[5].second) + std::string(what[6].first, what[6].second)] =
what[5].first - base;
return true;
}
};
void IndexClasses(map_type& m, const std::string& file)
{
std::string::const_iterator start, end;
start = file.begin();
end = file.end();
boost::regex_grep(IndexClassesPred(m, start), start, end, expression);
}
#include <fstream>
#include <iostream>
using namespace std;
void load_file(std::string& s, std::istream& is)
{
s.erase();
s.reserve(is.rdbuf()->in_avail());
char c;
while(is.get(c))
{
if(s.capacity() == s.size())
s.reserve(s.capacity() * 3);
s.append(1, c);
}
}
int main(int argc, const char** argv)
{
std::string text;
for(int i = 1; i < argc; ++i)
{
cout << "Processing file " << argv[i] << endl;
map_type m;
std::ifstream fs(argv[i]);
load_file(text, fs);
IndexClasses(m, text);
cout << m.size() << " matches found" << endl;
map_type::iterator c, d;
c = m.begin();
d = m.end();
while(c != d)
{
cout << "class \"" << (*c).first << "\" found at index: " << (*c).second << endl;
++c;
}
}
return 0;
}

View File

@ -1,99 +0,0 @@
/*
*
* 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.
*
*/
/*
* LOCATION: see http://www.boost.org for most recent version.
* FILE regex_grep_example_2.cpp
* VERSION 3.00
* DESCRIPTION: regex_grep example 2: searches a cpp file for class definitions,
* using a global callback function.
*/
#include <string>
#include <map>
#include <boost/regex.hpp>
// purpose:
// takes the contents of a file in the form of a string
// and searches for all the C++ class definitions, storing
// their locations in a map of strings/int's
typedef std::map<std::string, int, std::less<std::string> > map_type;
boost::regex expression("^(template[[:space:]]*<[^;:{]+>[[:space:]]*)?(class|struct)[[:space:]]*(\\<\\w+\\>([[:blank:]]*\\([^)]*\\))?[[:space:]]*)*(\\<\\w*\\>)[[:space:]]*(<[^;:{]+>)?[[:space:]]*(\\{|:[^;\\{()]*\\{)");
map_type class_index;
std::string::const_iterator base;
bool grep_callback(const boost::match_results<std::string::const_iterator, boost::regex::allocator_type>& what)
{
// what[0] contains the whole string
// what[5] contains the class name.
// what[6] contains the template specialisation if any.
// add class name and position to map:
class_index[std::string(what[5].first, what[5].second) + std::string(what[6].first, what[6].second)] =
what[5].first - base;
return true;
}
void IndexClasses(const std::string& file)
{
std::string::const_iterator start, end;
start = file.begin();
end = file.end();
base = start;
boost::regex_grep(grep_callback, start, end, expression);
}
#include <fstream>
#include <iostream>
using namespace std;
void load_file(std::string& s, std::istream& is)
{
s.erase();
s.reserve(is.rdbuf()->in_avail());
char c;
while(is.get(c))
{
if(s.capacity() == s.size())
s.reserve(s.capacity() * 3);
s.append(1, c);
}
}
int main(int argc, const char** argv)
{
std::string text;
for(int i = 1; i < argc; ++i)
{
cout << "Processing file " << argv[i] << endl;
std::ifstream fs(argv[i]);
load_file(text, fs);
IndexClasses(text);
cout << class_index.size() << " matches found" << endl;
map_type::iterator c, d;
c = class_index.begin();
d = class_index.end();
while(c != d)
{
cout << "class \"" << (*c).first << "\" found at index: " << (*c).second << endl;
++c;
}
class_index.erase(class_index.begin(), class_index.end());
}
return 0;
}

View File

@ -1,118 +0,0 @@
/*
*
* 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.
*
*/
/*
* LOCATION: see http://www.boost.org for most recent version.
* FILE regex_grep_example_3.cpp
* VERSION 3.00
* DESCRIPTION: regex_grep example 3: searches a cpp file for class definitions,
* using a bound member function callback.
*/
#include <string>
#include <map>
#include <boost/regex.hpp>
#include <functional>
// purpose:
// takes the contents of a file in the form of a string
// and searches for all the C++ class definitions, storing
// their locations in a map of strings/int's
typedef std::map<std::string, int, std::less<std::string> > map_type;
class class_index
{
boost::regex expression;
map_type index;
std::string::const_iterator base;
bool grep_callback(boost::match_results<std::string::const_iterator, boost::regex::allocator_type> what);
public:
map_type& get_map() { return index; }
void IndexClasses(const std::string& file);
class_index()
: index(),
expression("^(template[[:space:]]*<[^;:{]+>[[:space:]]*)?(class|struct)[[:space:]]*(\\<\\w+\\>([[:blank:]]*\\([^)]*\\))?[[:space:]]*)*(\\<\\w*\\>)[[:space:]]*(<[^;:{]+>)?[[:space:]]*(\\{|:[^;\\{()]*\\{)")
{}
};
bool class_index::grep_callback(boost::match_results<std::string::const_iterator, boost::regex::allocator_type> what)
{
// what[0] contains the whole string
// what[5] contains the class name.
// what[6] contains the template specialisation if any.
// add class name and position to map:
index[std::string(what[5].first, what[5].second) + std::string(what[6].first, what[6].second)] =
what[5].first - base;
return true;
}
void class_index::IndexClasses(const std::string& file)
{
std::string::const_iterator start, end;
start = file.begin();
end = file.end();
base = start;
boost::regex_grep(std::bind1st(std::mem_fun(&class_index::grep_callback), this),
start,
end,
expression);
}
#include <fstream>
#include <iostream>
using namespace std;
void load_file(std::string& s, std::istream& is)
{
s.erase();
s.reserve(is.rdbuf()->in_avail());
char c;
while(is.get(c))
{
if(s.capacity() == s.size())
s.reserve(s.capacity() * 3);
s.append(1, c);
}
}
int main(int argc, const char** argv)
{
std::string text;
for(int i = 1; i < argc; ++i)
{
cout << "Processing file " << argv[i] << endl;
std::ifstream fs(argv[i]);
load_file(text, fs);
class_index i;
i.IndexClasses(text);
cout << i.get_map().size() << " matches found" << endl;
map_type::iterator c, d;
c = i.get_map().begin();
d = i.get_map().end();
while(c != d)
{
cout << "class \"" << (*c).first << "\" found at index: " << (*c).second << endl;
++c;
}
}
return 0;
}

View File

@ -1,121 +0,0 @@
/*
*
* 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.
*
*/
/*
* LOCATION: see http://www.boost.org for most recent version.
* FILE regex_grep_example_4.cpp
* VERSION 3.00
* DESCRIPTION: regex_grep example 4: searches a cpp file for class definitions,
* using a C++ Builder closure as a callback.
*/
#include <string>
#include <map>
#include <boost/regex.hpp>
#include <functional>
// purpose:
// takes the contents of a file in the form of a string
// and searches for all the C++ class definitions, storing
// their locations in a map of strings/int's
typedef std::map<std::string, int, std::less<std::string> > map_type;
class class_index
{
boost::regex expression;
map_type index;
std::string::const_iterator base;
typedef boost::match_results<std::string::const_iterator, boost::regex::allocator_type> arg_type;
bool grep_callback(const boost::match_results<std::string::const_iterator, boost::regex::allocator_type>& what);
public:
map_type& get_map() { return index; }
typedef bool (__closure* grep_callback_type)(const arg_type&);
void IndexClasses(const std::string& file);
class_index()
: index(),
expression("^(template[[:space:]]*<[^;:{]+>[[:space:]]*)?(class|struct)[[:space:]]*(\\<\\w+\\>([[:blank:]]*\\([^)]*\\))?[[:space:]]*)*(\\<\\w*\\>)[[:space:]]*(<[^;:{]+>)?[[:space:]]*(\\{|:[^;\\{()]*\\{)")
{}
};
bool class_index::grep_callback(const boost::match_results<std::string::const_iterator, boost::regex::allocator_type>& what)
{
// what[0] contains the whole string
// what[5] contains the class name.
// what[6] contains the template specialisation if any.
// add class name and position to map:
index[std::string(what[5].first, what[5].second) + std::string(what[6].first, what[6].second)] =
what[5].first - base;
return true;
}
void class_index::IndexClasses(const std::string& file)
{
std::string::const_iterator start, end;
start = file.begin();
end = file.end();
base = start;
class_index::grep_callback_type cl = &(this->grep_callback);
boost::regex_grep(cl,
start,
end,
expression);
}
#include <fstream>
#include <iostream>
using namespace std;
void load_file(std::string& s, std::istream& is)
{
s.erase();
s.reserve(is.rdbuf()->in_avail());
char c;
while(is.get(c))
{
if(s.capacity() == s.size())
s.reserve(s.capacity() * 3);
s.append(1, c);
}
}
int main(int argc, const char** argv)
{
std::string text;
for(int i = 1; i < argc; ++i)
{
cout << "Processing file " << argv[i] << endl;
std::ifstream fs(argv[i]);
load_file(text, fs);
class_index i;
i.IndexClasses(text);
cout << i.get_map().size() << " matches found" << endl;
map_type::iterator c, d;
c = i.get_map().begin();
d = i.get_map().end();
while(c != d)
{
cout << "class \"" << (*c).first << "\" found at index: " << (*c).second << endl;
++c;
}
}
return 0;
}

View File

@ -1,100 +0,0 @@
/*
*
* 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.
*
*/
/*
* LOCATION: see http://www.boost.org for most recent version.
* FILE regex_match_example.cpp
* VERSION 3.00
* DESCRIPTION: ftp based regex_match example.
*/
#include <cstdlib>
#include <boost/regex.hpp>
#include <string>
#include <iostream>
using namespace std;
using namespace boost;
regex expression("^([0-9]+)(\\-| |$)(.*)$");
// process_ftp:
// on success returns the ftp response code, and fills
// msg with the ftp response message.
int process_ftp(const char* response, std::string* msg)
{
cmatch what;
if(regex_match(response, what, expression))
{
// what[0] contains the whole string
// what[1] contains the response code
// what[2] contains the separator character
// what[3] contains the text message.
if(msg)
msg->assign(what[3].first, what[3].second);
return atoi(what[1].first);
}
// failure did not match
if(msg)
msg->erase();
return -1;
}
#if defined(BOOST_MSVC) || (defined(__BORLANDC__) && (__BORLANDC__ == 0x550))
//
// problem with std::getline under MSVC6sp3
istream& getline(istream& is, std::string& s)
{
s.erase();
char c = is.get();
while(c != '\n')
{
s.append(1, c);
c = is.get();
}
return is;
}
#endif
int main()
{
std::string in, out;
while(true)
{
cout << "enter test string" << endl;
getline(cin, in);
if(in == "quit")
break;
int result;
result = process_ftp(in.c_str(), &out);
if(result != -1)
{
cout << "Match found:" << endl;
cout << "Response code: " << result << endl;
cout << "Message text: " << out << endl;
}
else
{
cout << "Match not found" << endl;
}
cout << endl;
}
return 0;
}

View File

@ -1,136 +0,0 @@
/*
*
* 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.
*
*/
/*
* LOCATION: see http://www.boost.org for most recent version.
* FILE regex_merge_example.cpp
* VERSION 3.00
* DESCRIPTION: regex_merge example:
* converts a C++ file to syntax highlighted HTML.
*/
#include <iostream>
#include <fstream>
#include <sstream>
#include <string>
#include <iterator>
#include <boost/regex.hpp>
#include <fstream>
#include <iostream>
// purpose:
// takes the contents of a file and transform to
// syntax highlighted code in html format
boost::regex e1, e2;
extern const char* expression_text;
extern const char* format_string;
extern const char* pre_expression;
extern const char* pre_format;
extern const char* header_text;
extern const char* footer_text;
void load_file(std::string& s, std::istream& is)
{
s.erase();
s.reserve(is.rdbuf()->in_avail());
char c;
while(is.get(c))
{
if(s.capacity() == s.size())
s.reserve(s.capacity() * 3);
s.append(1, c);
}
}
int main(int argc, const char** argv)
{
try{
e1.assign(expression_text);
e2.assign(pre_expression);
for(int i = 1; i < argc; ++i)
{
std::cout << "Processing file " << argv[i] << std::endl;
std::ifstream fs(argv[i]);
std::string in;
load_file(in, fs);
std::string out_name = std::string(argv[i]) + std::string(".htm");
std::ofstream os(out_name.c_str());
os << header_text;
// strip '<' and '>' first by outputting to a
// temporary string stream
std::ostringstream t(std::ios::out | std::ios::binary);
std::ostream_iterator<char, char> oi(t);
boost::regex_merge(oi, in.begin(), in.end(), e2, pre_format);
// then output to final output stream
// adding syntax highlighting:
std::string s(t.str());
std::ostream_iterator<char, char> out(os);
boost::regex_merge(out, s.begin(), s.end(), e1, format_string);
os << footer_text;
}
}
catch(...)
{ return -1; }
return 0;
}
extern const char* pre_expression = "(<)|(>)|\\r";
extern const char* pre_format = "(?1&lt;)(?2&gt;)";
const char* expression_text = // preprocessor directives: index 1
"(^[[:blank:]]*#(?:[^\\\\\\n]|\\\\[^\\n[:punct:][:word:]]*[\\n[:punct:][:word:]])*)|"
// comment: index 2
"(//[^\\n]*|/\\*.*?\\*/)|"
// literals: index 3
"\\<([+-]?(?:(?:0x[[:xdigit:]]+)|(?:(?:[[:digit:]]*\\.)?[[:digit:]]+(?:[eE][+-]?[[:digit:]]+)?))u?(?:(?:int(?:8|16|32|64))|L)?)\\>|"
// string literals: index 4
"('(?:[^\\\\']|\\\\.)*'|\"(?:[^\\\\\"]|\\\\.)*\")|"
// keywords: index 5
"\\<(__asm|__cdecl|__declspec|__export|__far16|__fastcall|__fortran|__import"
"|__pascal|__rtti|__stdcall|_asm|_cdecl|__except|_export|_far16|_fastcall"
"|__finally|_fortran|_import|_pascal|_stdcall|__thread|__try|asm|auto|bool"
"|break|case|catch|cdecl|char|class|const|const_cast|continue|default|delete"
"|do|double|dynamic_cast|else|enum|explicit|extern|false|float|for|friend|goto"
"|if|inline|int|long|mutable|namespace|new|operator|pascal|private|protected"
"|public|register|reinterpret_cast|return|short|signed|sizeof|static|static_cast"
"|struct|switch|template|this|throw|true|try|typedef|typeid|typename|union|unsigned"
"|using|virtual|void|volatile|wchar_t|while)\\>"
;
const char* format_string = "(?1<font color=\"#008040\">$&</font>)"
"(?2<I><font color=\"#000080\">$&</font></I>)"
"(?3<font color=\"#0000A0\">$&</font>)"
"(?4<font color=\"#0000FF\">$&</font>)"
"(?5<B>$&</B>)";
const char* header_text = "<HTML>\n<HEAD>\n"
"<TITLE>Auto-generated html formated source</TITLE>\n"
"<META HTTP-EQUIV=\"Content-Type\" CONTENT=\"text/html; charset=windows-1252\">\n"
"</HEAD>\n"
"<BODY LINK=\"#0000ff\" VLINK=\"#800080\" BGCOLOR=\"#ffffff\">\n"
"<P> </P>\n<PRE>";
const char* footer_text = "</PRE>\n</BODY>\n\n";

View File

@ -1,106 +0,0 @@
/*
*
* 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.
*
*/
/*
* LOCATION: see http://www.boost.org for most recent version.
* FILE regex_search_example.cpp
* VERSION 3.00
* DESCRIPTION: regex_search example: searches a cpp file for class definitions.
*/
#include <string>
#include <map>
#include <boost/regex.hpp>
// purpose:
// takes the contents of a file in the form of a string
// and searches for all the C++ class definitions, storing
// their locations in a map of strings/int's
typedef std::map<std::string, int, std::less<std::string> > map_type;
boost::regex expression("^(template[[:space:]]*<[^;:{]+>[[:space:]]*)?(class|struct)[[:space:]]*(\\<\\w+\\>([[:blank:]]*\\([^)]*\\))?[[:space:]]*)*(\\<\\w*\\>)[[:space:]]*(<[^;:{]+>)?[[:space:]]*(\\{|:[^;\\{()]*\\{)");
void IndexClasses(map_type& m, const std::string& file)
{
std::string::const_iterator start, end;
start = file.begin();
end = file.end();
boost::match_results<std::string::const_iterator> what;
unsigned int flags = boost::match_default;
while(boost::regex_search(start, end, what, expression, flags))
{
// what[0] contains the whole string
// what[5] contains the class name.
// what[6] contains the template specialisation if any.
// add class name and position to map:
m[std::string(what[5].first, what[5].second) + std::string(what[6].first, what[6].second)] =
what[5].first - file.begin();
// update search position:
start = what[0].second;
// update flags:
flags |= boost::match_prev_avail;
flags |= boost::match_not_bob;
}
}
#include <iostream>
#include <fstream>
using namespace std;
void load_file(std::string& s, std::istream& is)
{
s.erase();
s.reserve(is.rdbuf()->in_avail());
char c;
while(is.get(c))
{
if(s.capacity() == s.size())
s.reserve(s.capacity() * 3);
s.append(1, c);
}
}
int main(int argc, const char** argv)
{
std::string text;
for(int i = 1; i < argc; ++i)
{
cout << "Processing file " << argv[i] << endl;
map_type m;
std::ifstream fs(argv[i]);
load_file(text, fs);
IndexClasses(m, text);
cout << m.size() << " matches found" << endl;
map_type::iterator c, d;
c = m.begin();
d = m.end();
while(c != d)
{
cout << "class \"" << (*c).first << "\" found at index: " << (*c).second << endl;
++c;
}
}
return 0;
}

View File

@ -1,73 +0,0 @@
/*
*
* 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.
*
*/
/*
* LOCATION: see http://www.boost.org for most recent version.
* FILE regex_split_example_1.cpp
* VERSION 3.00
* DESCRIPTION: regex_split example: split a string into tokens.
*/
#include <list>
#include <boost/regex.hpp>
unsigned tokenise(std::list<std::string>& l, std::string& s)
{
return boost::regex_split(std::back_inserter(l), s);
}
#include <iostream>
using namespace std;
#if defined(BOOST_MSVC) || (defined(__BORLANDC__) && (__BORLANDC__ == 0x550))
//
// problem with std::getline under MSVC6sp3
istream& getline(istream& is, std::string& s)
{
s.erase();
char c = is.get();
while(c != '\n')
{
s.append(1, c);
c = is.get();
}
return is;
}
#endif
int main()
{
string s;
list<string> l;
do{
cout << "Enter text to split (or \"quit\" to exit): ";
getline(cin, s);
if(s == "quit") break;
unsigned result = tokenise(l, s);
cout << result << " tokens found" << endl;
cout << "The remaining text is: \"" << s << "\"" << endl;
while(l.size())
{
s = *(l.begin());
l.pop_front();
cout << s << endl;
}
}while(true);
return 0;
}

View File

@ -1,85 +0,0 @@
/*
*
* 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.
*
*/
/*
* LOCATION: see http://www.boost.org for most recent version.
* FILE regex_split_example_2.cpp
* VERSION 3.00
* DESCRIPTION: regex_split example: spit out linked URL's.
*/
#include <list>
#include <fstream>
#include <iostream>
#include <boost/regex.hpp>
boost::regex e("<\\s*A\\s+[^>]*href\\s*=\\s*\"([^\"]*)\"",
boost::regbase::normal | boost::regbase::icase);
void load_file(std::string& s, std::istream& is)
{
s.erase();
//
// attempt to grow string buffer to match file size,
// this doesn't always work...
s.reserve(is.rdbuf()->in_avail());
char c;
while(is.get(c))
{
// use logarithmic growth stategy, in case
// in_avail (above) returned zero:
if(s.capacity() == s.size())
s.reserve(s.capacity() * 3);
s.append(1, c);
}
}
int main(int argc, char** argv)
{
std::string s;
std::list<std::string> l;
int i;
for(i = 1; i < argc; ++i)
{
std::cout << "Findings URL's in " << argv[i] << ":" << std::endl;
s.erase();
std::ifstream is(argv[i]);
load_file(s, is);
boost::regex_split(std::back_inserter(l), s, e);
while(l.size())
{
s = *(l.begin());
l.pop_front();
std::cout << s << std::endl;
}
}
//
// alternative method:
// split one match at a time and output direct to
// cout via ostream_iterator<std::string>....
//
for(i = 1; i < argc; ++i)
{
std::cout << "Findings URL's in " << argv[i] << ":" << std::endl;
s.erase();
std::ifstream is(argv[i]);
load_file(s, is);
while(boost::regex_split(std::ostream_iterator<std::string>(std::cout), s, e, boost::match_default, 1)) std::cout << std::endl;
}
return 0;
}

View File

@ -1,45 +0,0 @@
# very basic makefile for timer.exe
#
# Borland C++ tools
#
# BCROOT defines the root directory of your bc builder install
#
!ifndef BCROOT
BCROOT=$(MAKEDIR)\..
!endif
BCC32 = $(BCROOT)\bin\Bcc32.exe
IDE_LinkFLAGS32 = -L$(BCROOT)\LIB
COMPOPTS= -O2 -tWC -tWM- -D_NO_VCL; -I../../../../; -L..\..\build\bcb5
timer.exe : regex_timer.cpp
$(BCC32) @&&|
$(COMPOPTS) -e$@ regex_timer.cpp
|

View File

@ -1,45 +0,0 @@
# very basic makefile for timer.exe
#
# Borland C++ tools
#
# BCROOT defines the root directory of your bc builder install
#
!ifndef BCROOT
BCROOT=$(MAKEDIR)\..
!endif
BCC32 = $(BCROOT)\bin\Bcc32.exe
IDE_LinkFLAGS32 = -L$(BCROOT)\LIB
COMPOPTS= -O2 -tWC -tWM- -D_NO_VCL; -I../../../../; -L..\..\build\bcb4
timer.exe : regex_timer.cpp
$(BCC32) @&&|
$(COMPOPTS) -e$@ regex_timer.cpp
|

View File

@ -1,45 +0,0 @@
# very basic makefile for timer.exe
#
# Borland C++ tools
#
# BCROOT defines the root directory of your bc builder install
#
!ifndef BCROOT
BCROOT=$(MAKEDIR)\..
!endif
BCC32 = $(BCROOT)\bin\Bcc32.exe
IDE_LinkFLAGS32 = -L$(BCROOT)\LIB
COMPOPTS= -O2 -tWC -tWM- -D_NO_VCL; -I../../../../; -L..\..\build\bcb5
timer.exe : regex_timer.cpp
$(BCC32) @&&|
$(COMPOPTS) -e$@ regex_timer.cpp
|

View File

@ -1,33 +0,0 @@
# very basic makefile for timer.exe
#
# GNU compiler GCC
#
CXX= $(INCLUDES) -I../../../../ -I./ $(CXXFLAGS)
timer : regex_timer.cpp
g++ $(CXX) -O2 -o timer regex_timer.cpp -L../../build/gcc $(LDFLAGS) -lboost_regex $(LIBS)
debug : regex_timer.cpp timer.cpp
g++ $(CXX) -g -o timer regex_timer.cpp -L../../build/gcc $(LDFLAGS) -lboost_regex_debug $(LIBS)

View File

@ -1,39 +0,0 @@
# very basic makefile for timer
#
CXX=@CXX@
CXXFLAGS=@CXXFLAGS@
LIBS=@LIBS@
EXE=@ac_exe_ext@
OBJ=@ac_obj_ext@
LIBDEP=../../build/libboost_regex.a ../../../../boost/regex/detail/regex_options.hpp ../../../../boost/regex/detail/regex_config.hpp
regex_timer$(EXE) : regex_timer$(OBJ)
$(CXX) -o timer$(EXE) regex_timer$(OBJ) -L../../build -lboost_regex $(LIBS)
regex_timer$(OBJ) : regex_timer.cpp $(LIBDEP)
$(CXX) -c $(CXXFLAGS) -DSTRICT -I../../../../ -I./ regex_timer.cpp
timer$(OBJ) : ../../../timer/timer.cpp $(LIBDEP)
$(CXX) -c $(CXXFLAGS) -DSTRICT -I../../../../ -I./ ../../../timer/timer.cpp

View File

@ -1,322 +0,0 @@
/*
*
* 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.
*
*/
#ifdef BOOST_RE_OLD_IOSTREAM
#include <iostream.h>
#else
#include <iostream>
using std::cout;
using std::cin;
using std::cerr;
using std::istream;
using std::ostream;
using std::endl;
#endif
#include <algorithm>
#include <string>
#include <deque>
#include <boost/regex.hpp>
#include <boost/timer.hpp>
#include <boost/smart_ptr.hpp>
#ifdef BOOST_MSVC
// no Koenig lookup, use using declaration instead:
using namespace boost;
#endif
#ifndef BOOST_RE_NO_WCSTRING
ostream& operator << (ostream& os, const std::wstring& s)
{
std::wstring::const_iterator i, j;
i = s.begin();
j = s.end();
while(i != j)
{
os.put(*i);
++i;
}
return os;
}
#endif
template <class S>
class string_out_iterator
{
S* out;
public:
string_out_iterator(S& s) : out(&s) {}
string_out_iterator& operator++() { return *this; }
string_out_iterator& operator++(int) { return *this; }
string_out_iterator& operator*() { return *this; }
string_out_iterator& operator=(typename S::value_type v)
{
out->append(1, v);
return *this;
}
};
#if defined(BOOST_MSVC) || (defined(__BORLANDC__) && (__BORLANDC__ == 0x550)) || defined(__SGI_STL_PORT)
//
// problem with std::getline under MSVC6sp3
// and C++ Builder 5.5, is this really that hard?
istream& getline(istream& is, std::string& s)
{
s.erase();
char c = is.get();
while(c != '\n')
{
s.append(1, c);
c = is.get();
}
return is;
}
#endif
int main()
{
boost::regex ex;
boost::match_results<std::string::const_iterator> sm;
#ifndef BOOST_RE_NO_WCSTRING
std::wstring ws1, ws2;
boost::wregex wex;
boost::match_results<std::wstring::const_iterator> wsm;
#endif
boost::match_results<std::deque<char>::iterator> dm;
std::string s1, s2, ts;
std::deque<char> ds;
boost::regex_t r;
boost::scoped_array<boost::regmatch_t> matches;
size_t nsubs;
boost::timer t;
double tim;
bool result;
int iters = 100;
while(true)
{
cout << "Enter expression (or \"quit\" to exit): ";
getline(cin, s1);
if(s1 == "quit")
break;
#ifndef BOOST_RE_NO_WCSTRING
ws1.erase();
std::copy(s1.begin(), s1.end(), string_out_iterator<std::wstring>(ws1));
#endif
try{
ex.assign(s1.begin(), s1.end());
#ifndef BOOST_RE_NO_WCSTRING
wex.assign(ws1.begin(), ws1.end());
#endif
}
catch(std::exception& e)
{
cout << "Error in expression: \"" << e.what() << "\"" << endl;
continue;
}
int code = regcomp(&r, s1.c_str(), boost::REG_PERL);
if(code != 0)
{
char buf[256];
regerror(code, &r, buf, 256);
cout << "regcomp error: \"" << buf << "\"" << endl;
continue;
}
nsubs = r.re_nsub + 1;
matches.reset(new boost::regmatch_t[nsubs]);
while(true)
{
cout << "Enter string to search (or \"quit\" to exit): ";
getline(cin, s2);
if(s2 == "quit")
break;
#ifndef BOOST_RE_NO_WCSTRING
ws2.erase();
std::copy(s2.begin(), s2.end(), string_out_iterator<std::wstring>(ws2));
#endif
ds.erase(ds.begin(), ds.end());
std::copy(s2.begin(), s2.end(), std::back_inserter(ds));
int i;
iters = 10;
tim = 1.1;
#if defined(_WIN32) && defined(BOOST_RE_LOCALE_W32)
MSG msg;
PeekMessage(&msg, 0, 0, 0, 0);
Sleep(0);
#endif
// cache load:
regex_search(s2, sm, ex);
// measure time interval for reg_expression<char>
do{
iters *= (tim > 0.001) ? (1.1/tim) : 100;
t.restart();
for(i =0; i < iters; ++i)
{
result = regex_search(s2, sm, ex);
}
tim = t.elapsed();
}while((tim < t.elapsed_min() * 1000) || (tim < 1));
cout << "regex time: " << (tim * 1000000 / iters) << "us" << endl;
if(result)
{
for(i = 0; i < sm.size(); ++i)
{
ts = sm[i];
cout << "\tmatch " << i << ": \"";
cout << ts;
cout << "\" (matched=" << sm[i].matched << ")" << endl;
}
cout << "\tmatch $`: \"";
cout << std::string(sm[-1]);
cout << "\" (matched=" << sm[-1].matched << ")" << endl;
cout << "\tmatch $': \"";
cout << std::string(sm[-2]);
cout << "\" (matched=" << sm[-2].matched << ")" << endl << endl;
}
#ifndef BOOST_RE_NO_WCSTRING
// measure time interval for boost::wregex
iters = 10;
tim = 1.1;
// cache load:
regex_search(ws2, wsm, wex);
do{
iters *= (tim > 0.001) ? (1.1/tim) : 100;
t.restart();
for(i = 0; i < iters; ++i)
{
result = regex_search(ws2, wsm, wex);
}
tim = t.elapsed();
}while((tim < t.elapsed_min() * 1000) || (tim < 1));
cout << "wregex time: " << (tim * 1000000 / iters) << "us" << endl;
if(result)
{
std::wstring tw;
for(i = 0; i < wsm.size(); ++i)
{
tw.erase();
std::copy(wsm[i].first, wsm[i].second, string_out_iterator<std::wstring>(tw));
cout << "\tmatch " << i << ": \"" << tw;
cout << "\" (matched=" << sm[i].matched << ")" << endl;
}
cout << "\tmatch $`: \"";
tw.erase();
std::copy(wsm[-1].first, wsm[-1].second, string_out_iterator<std::wstring>(tw));
cout << tw;
cout << "\" (matched=" << sm[-1].matched << ")" << endl;
cout << "\tmatch $': \"";
tw.erase();
std::copy(wsm[-2].first, wsm[-2].second, string_out_iterator<std::wstring>(tw));
cout << tw;
cout << "\" (matched=" << sm[-2].matched << ")" << endl << endl;
}
#endif
// measure time interval for reg_expression<char> using a deque
iters = 10;
tim = 1.1;
// cache load:
regex_search(ds.begin(), ds.end(), dm, ex);
do{
iters *= (tim > 0.001) ? (1.1/tim) : 100;
t.restart();
for(i = 0; i < iters; ++i)
{
result = regex_search(ds.begin(), ds.end(), dm, ex);
}
tim = t.elapsed();
}while((tim < t.elapsed_min() * 1000) || (tim < 1));
cout << "regex time (search over std::deque<char>): " << (tim * 1000000 / iters) << "us" << endl;
if(result)
{
for(i = 0; i < dm.size(); ++i)
{
ts.erase();
std::copy(dm[i].first, dm[i].second, string_out_iterator<std::string>(ts));
cout << "\tmatch " << i << ": \"" << ts;
cout << "\" (matched=" << sm[i].matched << ")" << endl;
}
cout << "\tmatch $`: \"";
ts.erase();
std::copy(dm[-1].first, dm[-1].second, string_out_iterator<std::string>(ts));
cout << ts;
cout << "\" (matched=" << sm[-1].matched << ")" << endl;
cout << "\tmatch $': \"";
ts.erase();
std::copy(dm[-2].first, dm[-2].second, string_out_iterator<std::string>(ts));
cout << ts;
cout << "\" (matched=" << sm[-2].matched << ")" << endl << endl;
}
// measure time interval for POSIX matcher:
iters = 10;
tim = 1.1;
// cache load:
regexec(&r, s2.c_str(), nsubs, matches.get(), 0);
do{
iters *= (tim > 0.001) ? (1.1/tim) : 100;
t.restart();
for(i = 0; i < iters; ++i)
{
result = regexec(&r, s2.c_str(), nsubs, matches.get(), 0);
}
tim = t.elapsed();
}while((tim < t.elapsed_min() * 1000) || (tim < 1));
cout << "POSIX regexec time: " << (tim * 1000000 / iters) << "us" << endl;
if(result == 0)
{
for(i = 0; i < nsubs; ++i)
{
if(matches[i].rm_so >= 0)
{
ts.assign(s2.begin() + matches[i].rm_so, s2.begin() + matches[i].rm_eo);
cout << "\tmatch " << i << ": \"" << ts << "\" (matched=" << (matches[i].rm_so != -1) << ")"<< endl;
}
else
cout << "\tmatch " << i << ": \"\" (matched=" << (matches[i].rm_so != -1) << ")" << endl; // no match
}
cout << "\tmatch $`: \"";
ts.erase();
ts.assign(s2.begin(), s2.begin() + matches[0].rm_so);
cout << ts;
cout << "\" (matched=" << (matches[0].rm_so != 0) << ")" << endl;
cout << "\tmatch $': \"";
ts.erase();
ts.assign(s2.begin() + matches[0].rm_eo, s2.end());
cout << ts;
cout << "\" (matched=" << (matches[0].rm_eo != s2.size()) << ")" << endl << endl;
}
}
regfree(&r);
}
return 0;
}

View File

@ -1,34 +0,0 @@
#
# very basic VC6 makefile for timer
#
CXX=cl
CXXFLAGS=/Oityb1 /GF /Gy -MT -GX -DSTRICT -I../../../../ -I./
LIBS=/link /LIBPATH:..\..\build\vc6-stlport kernel32.lib user32.lib
EXE=.exe
OBJ=.obj
LIBDEP= ../../../../boost/regex/detail/regex_options.hpp ../../../../boost/regex/detail/regex_config.hpp
regex_timer$(EXE) : regex_timer$(OBJ)
$(CXX) -o timer$(EXE) regex_timer$(OBJ) $(LIBS)
regex_timer$(OBJ) : regex_timer.cpp $(LIBDEP)
$(CXX) -c $(CXXFLAGS) regex_timer.cpp
timer$(OBJ) : ../../../timer/timer.cpp $(LIBDEP)
$(CXX) -c $(CXXFLAGS) ../../../timer/timer.cpp

View File

@ -1,33 +0,0 @@
#
# very basic VC6 makefile for timer
#
CXX=cl
CXXFLAGS=/Oityb1 /GF /Gy -GX -DSTRICT -I../../../../ -I./
LIBS=/link /LIBPATH:..\..\build\vc6 kernel32.lib user32.lib
EXE=.exe
OBJ=.obj
LIBDEP= ../../../../boost/regex/detail/regex_options.hpp ../../../../boost/regex/detail/regex_config.hpp
regex_timer$(EXE) : regex_timer$(OBJ)
$(CXX) -o timer$(EXE) regex_timer$(OBJ) $(LIBS)
regex_timer$(OBJ) : regex_timer.cpp $(LIBDEP)
$(CXX) -c $(CXXFLAGS) regex_timer.cpp
timer$(OBJ) : ../../../timer/timer.cpp $(LIBDEP)
$(CXX) -c $(CXXFLAGS) ../../../timer/timer.cpp

71
faq.htm
View File

@ -1,71 +0,0 @@
<HTML>
<HEAD>
<META HTTP-EQUIV="Content-Type" CONTENT="text/html; charset=windows-1252">
<META NAME="Generator" CONTENT="Microsoft Word 97">
<TITLE>Regex++ - FAQ</TITLE>
<META NAME="Template" CONTENT="C:\PROGRAM FILES\MICROSOFT OFFICE\OFFICE\html.dot">
</HEAD>
<BODY LINK="#0000ff" VLINK="#800080" BGCOLOR="#ffffff">
<P><!DOCTYPE HTML PUBLIC "-//w3c//dtd html 4.0 transitional//en">&nbsp; </P>
<TABLE CELLSPACING=0 BORDER=0 CELLPADDING=7 WIDTH=624>
<TR><TD WIDTH="50%" VALIGN="TOP">
<H3><IMG SRC="../../c++boost.gif" WIDTH=276 HEIGHT=86 ALT="C++ Boost"></H3></TD>
<TD WIDTH="50%" VALIGN="TOP">
<H3 ALIGN="CENTER">Regex++, FAQ.</H3>
<I><P ALIGN="CENTER">(version 3.12, 18 April 2000)</I> </P>
<I><PRE>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.&nbsp; Dr John Maddock makes no representations
about the suitability of this software for any purpose.&nbsp;&nbsp;
It is provided "as is" without express or implied warranty.</PRE></I></TD>
</TR>
</TABLE>
<FONT COLOR="#ff0000"><P>Q. Why does using parenthesis in a regular expression change the result of a match?</P>
</FONT><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>"(0*)([0-9]*)" against "00123" would produce
$1 = "00"
$2 = "123"</PRE>
<P>where as</P>
<PRE>"0*([0-9)*" against "00123" would produce
$1 = "00123"</PRE>
<P>If you think about it, had $1 only matched the "123", this would be "less good" than the match "00123" which is both further to the left and longer. If you want $1 to match only the "123" part, then you need to use something like:</P>
<PRE>"0*([1-9][0-9]*)"</PRE>
<P>as the expression.</P>
<FONT COLOR="#ff0000"><P>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>
<FONT COLOR="#ff0000"><P>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>
<FONT COLOR="#ff0000"><P>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 "problem" 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 jm_opt.h so that BOOST_RE_NO_TEMPLATE_SWITCH_MERGE is no longer defined. </P>
<FONT COLOR="#ff0000"><P>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 "\\d+" in your code. Likewise to match a literal backslash you will need to embed "\\\\" in your code. </P>
<FONT COLOR="#ff0000"><P>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 "C" or "POSIX", [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 "as if" the LC_COLLATE locale category were always "C", regardless of what its actually set to - end note</I>]. </P>
<FONT COLOR="#ff0000"><P>&nbsp;Q. Why can't I use the "convenience" 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>
<FONT COLOR="#ff0000"><P>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; boost::bad_pattern can be thrown by the class sub_match's conversion operators; finally std::bad_alloc can be thrown by just about any of the functions in this library. </P>
<P><HR></P>
<I><P>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>

View File

@ -1,202 +0,0 @@
<!DOCTYPE HTML PUBLIC "-//w3c//dtd html 4.0 transitional//en">
<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="Mozilla/4.5 [en] (Win98; I) [Netscape]">
<TITLE>Regex++, Format String Reference</TITLE>
</HEAD>
<BODY BGCOLOR="#FFFFFF" LINK="#0000FF" VLINK="#800080">
&nbsp; <TABLE BORDER="0" CELLSPACING="0" CELLPADDING="7" WIDTH="100%">
<TR>
<TD VALIGN="TOP" WIDTH="50%"> <H3>
<IMG SRC="../../c++boost.gif" HEIGHT="86" WIDTH="276" ALT="C++ Boost"></H3>
</TD>
<TD VALIGN="TOP" WIDTH="50%"> <CENTER>
<H3> Regex++, Format String Reference.</H3>
</CENTER>
<CENTER>
<I>(version 3.12, 18 April 2000)</I>
</CENTER>
<PRE><I>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.&nbsp; Dr John Maddock makes no representations
about the suitability of this software for any purpose.&nbsp;&nbsp;
It is provided &quot;as is&quot; without express or implied warranty.</I></PRE>
</TD>
</TR>
</TABLE>
<HR>
<H3> <A NAME="format_string"></A>Format String Syntax</H3>
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>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" CELLSPACING="0" CELLPADDING="7" 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>
<BR>
&nbsp; <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" CELLSPACING="0" CELLPADDING="7" 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>
<BR>
&nbsp; <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 <A HREF="mailto:John_Maddock@compuserve.com">Dr John
Maddock</A> 1998-2000 all rights reserved.</I> </P>
</BODY>
</HTML>

View File

@ -1,562 +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" width="50%"><h3><img
src="../../c++boost.gif" alt="C++ Boost" width="276"
height="86"></h3>
</td>
<td valign="top" width="50%"><h3 align="center">Regex++,
RegEx Class Reference. </h3>
<p><i>(version 3.12, 18 April 2000)</i> </p>
<pre><i>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.&nbsp; Dr John Maddock makes no representations
about the suitability of this software for any purpose.&nbsp;&nbsp;
It is provided &quot;as is&quot; without express or implied warranty.</i></pre>
</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>;
&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> ;
}; &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 -1 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 -1 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>
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 (unsigned)-1.</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>

View File

@ -1,6 +1,6 @@
/*
*
* Copyright (c) 1998-2000
* Copyright (c) 1998-2002
* Dr John Maddock
*
* Permission to use, copy, modify, distribute and sell this software
@ -14,9 +14,9 @@
*/
/*
* 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 3.12
* VERSION see <boost/version.hpp>
* DESCRIPTION: Declares POSIX API functions
* + boost::RegEx high level wrapper.
*/
@ -24,270 +24,14 @@
#ifndef BOOST_RE_CREGEX_HPP
#define BOOST_RE_CREGEX_HPP
#include <boost/regex/detail/regex_config.hpp>
#ifdef __BORLANDC__
#pragma option push -a4 -b -Ve -pc
#ifndef BOOST_REGEX_CONFIG_HPP
#include <boost/regex/config.hpp>
#endif
/* include these defs only for POSIX compatablity */
#ifdef __cplusplus
namespace boost{
extern "C" {
#endif
typedef int regoff_t;
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_RE_NO_WCSTRING
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_RE_IX_DECL int BOOST_RE_CCALL regcompA(regex_tA*, const char*, int);
BOOST_RE_IX_DECL unsigned int BOOST_RE_CCALL regerrorA(int, const regex_tA*, char*, unsigned int);
BOOST_RE_IX_DECL int BOOST_RE_CCALL regexecA(const regex_tA*, const char*, unsigned int, regmatch_t*, int);
BOOST_RE_IX_DECL void BOOST_RE_CCALL regfreeA(regex_tA*);
#ifndef BOOST_RE_NO_WCSTRING
BOOST_RE_IX_DECL int BOOST_RE_CCALL regcompW(regex_tW*, const wchar_t*, int);
BOOST_RE_IX_DECL unsigned int BOOST_RE_CCALL regerrorW(int, const regex_tW*, wchar_t*, unsigned int);
BOOST_RE_IX_DECL int BOOST_RE_CCALL regexecW(const regex_tW*, const wchar_t*, unsigned int, regmatch_t*, int);
BOOST_RE_IX_DECL void BOOST_RE_CCALL regfreeW(regex_tW*);
#endif
#ifdef UNICODE
#define regcomp regcompW
#define regerror regerrorW
#define regexec regexecW
#define regfree regfreeW
#define regex_t regex_tW
#ifdef BOOST_REGEX_V3
#include <boost/regex/v3/cregex.hpp>
#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) && !defined(BOOST_RE_NO_STRING_H)
#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_RE_IX_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;
//
// 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<unsigned int>& v, const char* p, unsigned int flags = match_default);
unsigned int Grep(std::vector<unsigned int>& v, const std::string& s, unsigned int flags = match_default) { return Grep(v, s.c_str(), flags); }
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); }
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);
unsigned int 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:
//
unsigned int Position(int i = 0)const;
unsigned int Length(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); }
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
#include <boost/regex/v4/cregex.hpp>
#endif
#endif // include guard
@ -297,3 +41,5 @@ public:

View File

@ -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
@ -65,7 +65,7 @@ using boost::regerrorA;
using boost::regexecA;
using boost::regfreeA;
#ifndef BOOST_RE_NO_WCSTRING
#ifndef BOOST_NO_WREGEX
using boost::regcompW;
using boost::regerrorW;
using boost::regexecW;

File diff suppressed because it is too large Load Diff

View File

@ -1,446 +0,0 @@
/*
*
* 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.
*
*/
/*
* LOCATION: see http://www.boost.org for most recent version.
* FILE fileiter.hpp
* VERSION 3.12
* DESCRIPTION: Declares various platform independent file and
* directory iterators, plus binary file input in
* the form of class map_file.
*/
#ifndef BOOST_RE_FILEITER_HPP
#define BOOST_RE_FILEITER_HPP
#include <boost/regex/detail/regex_config.hpp>
#if (defined(__CYGWIN__) || defined(__CYGWIN32__)) && !defined(BOOST_RE_NO_W32)
#error "Sorry, can't mix <windows.h> with STL code and gcc compiler: if you ran configure, try again with configure --disable-ms-windows"
#define FI_WIN32_MAP
#define FI_POSIX_DIR
#elif (defined(__WIN32__) || defined(_WIN32) || defined(WIN32)) && !defined(BOOST_RE_NO_W32)
#define FI_WIN32_MAP
#define FI_WIN32_DIR
#else
#define FI_POSIX_MAP
#define FI_POSIX_DIR
#endif
#if defined(FI_WIN32_MAP)||defined(FI_WIN32_DIR)
#include <windows.h>
#endif
#if defined(FI_WIN32_DIR)
namespace boost{
namespace re_detail{
typedef WIN32_FIND_DATA _fi_find_data;
typedef HANDLE _fi_find_handle;
} // namespace re_detail
} // namespace boost
#define _fi_invalid_handle INVALID_HANDLE_VALUE
#define _fi_dir FILE_ATTRIBUTE_DIRECTORY
#elif defined(FI_POSIX_DIR)
#include <cstdio>
#include <cctype>
#include <iterator>
#include <list>
#include <cassert>
#include <dirent.h>
#if defined(__SUNPRO_CC)
using std::list;
#endif
#ifndef MAX_PATH
#define MAX_PATH 256
#endif
namespace boost{
namespace re_detail{
#ifdef __BORLANDC__
#pragma option push -a4 -b -Ve -pc
#endif
struct _fi_find_data
{
unsigned dwFileAttributes;
char cFileName[MAX_PATH];
};
struct _fi_priv_data;
typedef _fi_priv_data* _fi_find_handle;
#define _fi_invalid_handle 0
#define _fi_dir 1
_fi_find_handle _fi_FindFirstFile(const char* lpFileName, _fi_find_data* lpFindFileData);
bool _fi_FindNextFile(_fi_find_handle hFindFile, _fi_find_data* lpFindFileData);
bool _fi_FindClose(_fi_find_handle hFindFile);
#ifdef __BORLANDC__
#if __BORLANDC__ > 0x520
#pragma option pop
#endif
#endif
} // namespace re_detail
} // namespace boost
#ifdef FindFirstFile
#undef FindFirstFile
#endif
#ifdef FindNextFile
#undef FindNextFile
#endif
#ifdef FindClose
#undef FindClose
#endif
#define FindFirstFile _fi_FindFirstFile
#define FindNextFile _fi_FindNextFile
#define FindClose _fi_FindClose
#endif
namespace boost{
namespace re_detail{
#ifdef __BORLANDC__
#if __BORLANDC__ == 0x530
#pragma option push -a4 -b
#elif __BORLANDC__ > 0x530
#pragma option push -a8 -b
#endif
#endif
#ifdef FI_WIN32_MAP // win32 mapfile
class BOOST_RE_IX_DECL mapfile
{
HANDLE hfile;
HANDLE hmap;
const char* _first;
const char* _last;
public:
typedef const char* iterator;
mapfile(){ hfile = hmap = 0; _first = _last = 0; }
mapfile(const char* file){ hfile = hmap = 0; _first = _last = 0; open(file); }
~mapfile(){ close(); }
void open(const char* file);
void close();
const char* begin(){ return _first; }
const char* end(){ return _last; }
size_t size(){ return _last - _first; }
bool valid(){ return (hfile != 0) && (hfile != INVALID_HANDLE_VALUE); }
};
#elif !defined(BOOST_RE_NO_STL) // use C API to emulate the memory map:
class BOOST_RE_IX_DECL mapfile_iterator;
class BOOST_RE_IX_DECL mapfile
{
typedef char* pointer;
std::FILE* hfile;
long int _size;
pointer* _first;
pointer* _last;
mutable std::list<pointer*> condemed;
enum sizes
{
buf_size = 4096
};
void lock(pointer* node)const;
void unlock(pointer* node)const;
public:
typedef mapfile_iterator iterator;
mapfile(){ hfile = 0; _size = 0; _first = _last = 0; }
mapfile(const char* file){ hfile = 0; _size = 0; _first = _last = 0; open(file); }
~mapfile(){ close(); }
void open(const char* file);
void close();
iterator begin()const;
iterator end()const;
unsigned long size()const{ return _size; }
bool valid()const{ return hfile != 0; }
friend class mapfile_iterator;
};
class BOOST_RE_IX_DECL mapfile_iterator
{
typedef mapfile::pointer internal_pointer;
internal_pointer* node;
const mapfile* file;
unsigned long offset;
long position()const
{
return file ? ((node - file->_first) * mapfile::buf_size + offset) : 0;
}
void position(long pos)
{
if(file)
{
node = file->_first + (pos / mapfile::buf_size);
offset = pos % mapfile::buf_size;
}
}
public:
typedef std::ptrdiff_t difference_type;
typedef char value_type;
typedef const char* pointer;
typedef const char& reference;
typedef std::random_access_iterator_tag iterator_category;
mapfile_iterator() { node = 0; file = 0; offset = 0; }
mapfile_iterator(const mapfile* f, long position)
{
file = f;
node = f->_first + position / mapfile::buf_size;
offset = position % mapfile::buf_size;
if(file)
file->lock(node);
}
mapfile_iterator(const mapfile_iterator& i)
{
file = i.file;
node = i.node;
offset = i.offset;
if(file)
file->lock(node);
}
~mapfile_iterator()
{
if(file && node)
file->unlock(node);
}
mapfile_iterator& operator = (const mapfile_iterator& i);
char operator* ()const
{
assert(node >= file->_first);
assert(node < file->_last);
return file ? *(*node + sizeof(int) + offset) : char(0);
}
char operator[] (long off)const
{
mapfile_iterator tmp(*this);
tmp += off;
return *tmp;
}
mapfile_iterator& operator++ ();
mapfile_iterator operator++ (int);
mapfile_iterator& operator-- ();
mapfile_iterator operator-- (int);
mapfile_iterator& operator += (long off)
{
position(position() + off);
return *this;
}
mapfile_iterator& operator -= (long off)
{
position(position() - off);
return *this;
}
friend inline bool operator==(const mapfile_iterator& i, const mapfile_iterator& j)
{
return (i.file == j.file) && (i.node == j.node) && (i.offset == j.offset);
}
#ifndef BOOST_RE_NO_NOT_EQUAL
friend inline bool operator!=(const mapfile_iterator& i, const mapfile_iterator& j)
{
return !(i == j);
}
#endif
friend inline bool operator<(const mapfile_iterator& i, const mapfile_iterator& j)
{
return i.position() < j.position();
}
friend inline bool operator>(const mapfile_iterator& i, const mapfile_iterator& j)
{
return i.position() > j.position();
}
friend inline bool operator<=(const mapfile_iterator& i, const mapfile_iterator& j)
{
return i.position() <= j.position();
}
friend inline bool operator>=(const mapfile_iterator& i, const mapfile_iterator& j)
{
return i.position() >= j.position();
}
friend mapfile_iterator operator + (const mapfile_iterator& i, long off);
friend mapfile_iterator operator + (long off, const mapfile_iterator& i)
{
mapfile_iterator tmp(i);
return tmp += off;
}
friend mapfile_iterator operator - (const mapfile_iterator& i, long off);
friend inline long operator - (const mapfile_iterator& i, const mapfile_iterator& j)
{
return i.position() - j.position();
}
};
#endif
// _fi_sep determines the directory separator, either '\\' or '/'
BOOST_RE_IX_DECL extern const char* _fi_sep;
struct file_iterator_ref
{
_fi_find_handle hf;
_fi_find_data _data;
long count;
};
class BOOST_RE_IX_DECL file_iterator
{
char* _root;
char* _path;
char* ptr;
file_iterator_ref* ref;
public:
typedef std::ptrdiff_t difference_type;
typedef const char* value_type;
typedef const char** pointer;
typedef const char*& reference;
typedef std::input_iterator_tag iterator_category;
file_iterator();
file_iterator(const char* wild);
~file_iterator();
file_iterator(const file_iterator&);
file_iterator& operator=(const file_iterator&);
const char* root()const { return _root; }
const char* path()const { return _path; }
const char* name()const { return ptr; }
_fi_find_data* data() { return &(ref->_data); }
void next();
file_iterator& operator++() { next(); return *this; }
file_iterator operator++(int);
const char* operator*() { return path(); }
friend inline bool operator == (const file_iterator& f1, const file_iterator& f2)
{
return ((f1.ref->hf == _fi_invalid_handle) && (f2.ref->hf == _fi_invalid_handle));
}
#ifndef BOOST_RE_NO_NOT_EQUAL
friend inline bool operator != (const file_iterator& f1, const file_iterator& f2)
{
return !(f1 == f2);
}
#endif
};
// dwa 9/13/00 - suppress unused parameter warning
inline bool operator < (const file_iterator&, const file_iterator&)
{
return false;
}
class BOOST_RE_IX_DECL directory_iterator
{
char* _root;
char* _path;
char* ptr;
file_iterator_ref* ref;
public:
typedef std::ptrdiff_t difference_type;
typedef const char* value_type;
typedef const char** pointer;
typedef const char*& reference;
typedef std::input_iterator_tag iterator_category;
directory_iterator();
directory_iterator(const char* wild);
~directory_iterator();
directory_iterator(const directory_iterator& other);
directory_iterator& operator=(const directory_iterator& other);
const char* root()const { return _root; }
const char* path()const { return _path; }
const char* name()const { return ptr; }
_fi_find_data* data() { return &(ref->_data); }
void next();
directory_iterator& operator++() { next(); return *this; }
directory_iterator operator++(int);
const char* operator*() { return path(); }
static const char* separator() { return _fi_sep; }
friend inline bool operator == (const directory_iterator& f1, const directory_iterator& f2)
{
return ((f1.ref->hf == _fi_invalid_handle) && (f2.ref->hf == _fi_invalid_handle));
}
#ifndef BOOST_RE_NO_NOT_EQUAL
friend inline bool operator != (const directory_iterator& f1, const directory_iterator& f2)
{
return !(f1 == f2);
}
#endif
};
inline bool operator < (const directory_iterator&, const directory_iterator&)
{
return false;
}
#ifdef __BORLANDC__
#pragma option pop
#endif
} // namespace re_detail
using boost::re_detail::directory_iterator;
using boost::re_detail::file_iterator;
using boost::re_detail::mapfile;
} // namespace boost
#endif // _FILEITER_H

File diff suppressed because it is too large Load Diff

File diff suppressed because it is too large Load Diff

View File

@ -1,133 +0,0 @@
/*
*
* 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.
*
*/
/*
* LOCATION: see http://www.boost.org for most recent version.
* FILE regex_cstring.hpp
* VERSION 3.12
* DESCRIPTION: This is an internal header file, do not include directly.
* String support and helper functions, for regular
* expression library.
*/
#ifndef BOOST_REGEX_CSTRING_HPP
#define BOOST_REGEX_CSTRING_HPP
#ifndef BOOST_REGEX_CONFIG_HPP
#include <boost/regex/detail/regex_config.hpp>
#endif
#include <cstring>
namespace boost{
namespace re_detail{
#ifdef __BORLANDC__
#pragma option push -a4 -b -Ve -pc
#endif
//
// start by defining some template function aliases for C API functions:
//
template <class charT>
std::size_t BOOST_RE_CALL re_strlen(const charT *s)
{
std::size_t len = 0;
while(*s)
{
++s;
++len;
}
return len;
}
inline std::size_t BOOST_RE_CALL re_strlen(const char *s)
{
return std::strlen(s);
}
#ifndef BOOST_RE_NO_WCSTRING
inline std::size_t BOOST_RE_CALL re_strlen(const wchar_t *s)
{
return std::wcslen(s);
}
#endif
#ifndef BOOST_RE_NO_WCSTRING
BOOST_RE_IX_DECL void BOOST_RE_CALL re_transform(std::basic_string<wchar_t>& out, const std::basic_string<wchar_t>& in);
#endif
BOOST_RE_IX_DECL void BOOST_RE_CALL re_transform(std::string& out, const std::string& in);
template <class charT>
void BOOST_RE_CALL re_trunc_primary(std::basic_string<charT>& s)
{
for(unsigned int i = 0; i < s.size(); ++i)
{
if(s[i] <= 1)
{
s.erase(i);
break;
}
}
}
inline char* BOOST_RE_CALL re_strcpy(char *s1, const char *s2)
{
#if defined(__BORLANDC__) && defined(strcpy)
return ::strcpy(s1, s2);
#else
return std::strcpy(s1, s2);
#endif
}
#ifndef BOOST_RE_NO_WCSTRING
inline wchar_t* BOOST_RE_CALL re_strcpy(wchar_t *s1, const wchar_t *s2)
{
return std::wcscpy(s1, s2);
}
#endif
template <class charT>
charT* BOOST_RE_CALL re_strdup(const charT* p)
{
charT* buf = new charT[re_strlen(p) + 1];
re_strcpy(buf, p);
return buf;
}
template <class charT>
inline void BOOST_RE_CALL re_strfree(charT* p)
{
delete[] p;
}
#ifdef __BORLANDC__
#pragma option pop
#endif
} // namespace re_detail
} // namespace boost
#endif // BOOST_REGEX_CSTRING_HPP

View File

@ -1,578 +0,0 @@
/*
*
* 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.
*
*/
/*
* LOCATION: see http://www.boost.org for most recent version.
* FILE regex_format.hpp
* VERSION 3.12
* DESCRIPTION: Provides formatting output routines for search and replace
* operations. Note this is an internal header file included
* by regex.hpp, do not include on its own.
*/
#ifndef BOOST_REGEX_FORMAT_HPP
#define BOOST_REGEX_FORMAT_HPP
namespace boost{
enum format_flags_t{
format_all = 0, // enable all extentions to sytax
format_sed = match_max << 1, // sed style replacement.
format_perl = format_sed << 1, // perl style replacement.
format_no_copy = format_perl << 1, // don't copy non-matching segments.
format_first_only = format_no_copy << 1, // Only replace first occurance.
format_is_if = format_first_only << 1 // internal use only.
};
namespace re_detail{
#ifdef __BORLANDC__
#pragma option push -a4 -b -Ve -pc
#endif
template <class O, class I>
O BOOST_RE_CALL re_copy_out(O out, I first, I last)
{
while(first != last)
{
*out = *first;
++out;
++first;
}
return out;
}
template <class charT, class traits_type>
void BOOST_RE_CALL re_skip_format(const charT*& fmt, const traits_type& traits_inst)
{
// dwa 9/13/00 - suppress incorrect unused parameter warning for MSVC
(void)traits_inst;
typedef typename traits_type::size_type traits_size_type;
typedef typename traits_type::uchar_type traits_uchar_type;
typedef typename traits_type::string_type traits_string_type;
unsigned int parens = 0;
unsigned int c;
while(*fmt)
{
c = traits_inst.syntax_type((traits_size_type)(traits_uchar_type)(*fmt));
if((c == traits_type::syntax_colon) && (parens == 0))
{
++fmt;
return;
}
else if(c == traits_type::syntax_close_bracket)
{
if(parens == 0)
{
++fmt;
return;
}
--parens;
}
else if(c == traits_type::syntax_open_bracket)
++parens;
else if(c == traits_type::syntax_slash)
{
++fmt;
if(*fmt == 0)
return;
}
++fmt;
}
}
#ifdef BOOST_RE_NO_OI_ASSIGN
//
// ugly hack for buggy output iterators
template <class T>
inline void oi_assign(T* p, T v)
{
jm_destroy(p);
jm_construct(p, v);
}
#else
template <class T>
inline void oi_assign(T* p, T v)
{
//
// if you get a compile time error in here then you either
// need to rewrite your output iterator to make it assignable
// (as is required by the standard), or define BOOST_RE_NO_OI_ASSIGN
// to use the ugly hack above
*p = v;
}
#endif
#if defined(BOOST_RE_NO_TEMPLATE_SWITCH_MERGE) && !defined(BOOST_RE_NO_NAMESPACES)
//
// Ugly ugly hack,
// template don't merge if they contain switch statements so declare these
// templates in unnamed namespace (ie with internal linkage), each translation
// unit then gets its own local copy, it works seemlessly but bloats the app.
namespace{
#endif
//
// algorithm reg_format:
// takes the result of a match and a format string
// and merges them to produce a new string which
// is sent to an OutputIterator,
// _reg_format_aux does the actual work:
//
template <class OutputIterator, class iterator, class Allocator, class charT, class traits_type>
OutputIterator BOOST_RE_CALL _reg_format_aux(OutputIterator out,
const match_results<iterator, Allocator>& m,
const charT*& fmt,
unsigned flags, const traits_type& traits_inst)
{
const charT* fmt_end = fmt;
while(*fmt_end) ++ fmt_end;
typedef typename traits_type::size_type traits_size_type;
typedef typename traits_type::uchar_type traits_uchar_type;
typedef typename traits_type::string_type traits_string_type;
while(*fmt)
{
switch(traits_inst.syntax_type((traits_size_type)(traits_uchar_type)(*fmt)))
{
case traits_type::syntax_dollar:
if(flags & format_sed)
{
// no perl style replacement,
// $ is an ordinary character:
goto default_opt;
}
++fmt;
if(*fmt == 0) // oops trailing $
{
--fmt;
*out = *fmt;
++out;
return out;
}
switch(traits_inst.syntax_type((traits_size_type)(traits_uchar_type)(*fmt)))
{
case traits_type::syntax_start_buffer:
oi_assign(&out, re_copy_out(out, iterator(m[-1].first), iterator(m[-1].second)));
++fmt;
continue;
case traits_type::syntax_end_buffer:
oi_assign(&out, re_copy_out(out, iterator(m[-2].first), iterator(m[-2].second)));
++fmt;
continue;
case traits_type::syntax_digit:
{
expand_sub:
unsigned int index = traits_inst.toi(fmt, fmt_end, 10);
oi_assign(&out, re_copy_out(out, iterator(m[index].first), iterator(m[index].second)));
continue;
}
}
// anything else:
if(*fmt == '&')
{
oi_assign(&out, re_copy_out(out, iterator(m[0].first), iterator(m[0].second)));
++fmt;
}
else
{
// probably an error, treat as a literal '$'
--fmt;
*out = *fmt;
++out;
++fmt;
}
continue;
case traits_type::syntax_slash:
{
// escape sequence:
++fmt;
charT c(*fmt);
if(*fmt == 0)
{
--fmt;
*out = *fmt;
++out;
++fmt;
return out;
}
switch(traits_inst.syntax_type((traits_size_type)(traits_uchar_type)(*fmt)))
{
case traits_type::syntax_a:
c = '\a';
++fmt;
break;
case traits_type::syntax_f:
c = '\f';
++fmt;
break;
case traits_type::syntax_n:
c = '\n';
++fmt;
break;
case traits_type::syntax_r:
c = '\r';
++fmt;
break;
case traits_type::syntax_t:
c = '\t';
++fmt;
break;
case traits_type::syntax_v:
c = '\v';
++fmt;
break;
case traits_type::syntax_x:
++fmt;
if(fmt == fmt_end)
{
*out = *--fmt;
++out;
return out;
}
// maybe have \x{ddd}
if(traits_inst.syntax_type((traits_size_type)(traits_uchar_type)(*fmt)) == traits_type::syntax_open_brace)
{
++fmt;
if(fmt == fmt_end)
{
fmt -= 2;
*out = *fmt;
++out;
++fmt;
continue;
}
if(traits_inst.is_class(*fmt, traits_type::char_class_xdigit) == false)
{
fmt -= 2;
*out = *fmt;
++out;
++fmt;
continue;
}
c = (charT)traits_inst.toi(fmt, fmt_end, -16);
if(traits_inst.syntax_type((traits_size_type)(traits_uchar_type)(*fmt)) != traits_type::syntax_close_brace)
{
while(traits_inst.syntax_type((traits_size_type)(traits_uchar_type)(*fmt)) != traits_type::syntax_slash)
--fmt;
++fmt;
*out = *fmt;
++out;
++fmt;
continue;
}
++fmt;
break;
}
else
{
if(traits_inst.is_class(*fmt, traits_type::char_class_xdigit) == false)
{
--fmt;
*out = *fmt;
++out;
++fmt;
continue;
}
c = (charT)traits_inst.toi(fmt, fmt_end, -16);
}
break;
case traits_type::syntax_c:
++fmt;
if(fmt == fmt_end)
{
--fmt;
*out = *fmt;
++out;
return out;
}
if(((typename traits_type::uchar_type)(*fmt) < (typename traits_type::uchar_type)'@')
|| ((typename traits_type::uchar_type)(*fmt) > (typename traits_type::uchar_type)127) )
{
--fmt;
*out = *fmt;
++out;
++fmt;
break;
}
c = (charT)((typename traits_type::uchar_type)(*fmt) - (typename traits_type::uchar_type)'@');
++fmt;
break;
case traits_type::syntax_e:
c = (charT)27;
++fmt;
break;
case traits_type::syntax_digit:
if(flags & format_sed)
goto expand_sub;
else
c = (charT)traits_inst.toi(fmt, fmt_end, -8);
break;
default:
//c = *fmt;
++fmt;
}
*out = c;
++out;
continue;
}
case traits_type::syntax_open_bracket:
if(flags & (format_sed|format_perl))
{
*out = *fmt;
++out;
++fmt;
continue;
}
else
{
++fmt; // recurse
oi_assign(&out, _reg_format_aux(out, m, fmt, flags, traits_inst));
continue;
}
case traits_type::syntax_close_bracket:
if(flags & (format_sed|format_perl))
{
*out = *fmt;
++out;
++fmt;
continue;
}
else
{
++fmt; // return from recursion
return out;
}
case traits_type::syntax_colon:
if(flags & format_is_if)
{
++fmt;
return out;
}
*out = *fmt;
++out;
++fmt;
continue;
case traits_type::syntax_question:
{
if(flags & (format_sed|format_perl))
{
*out = *fmt;
++out;
++fmt;
continue;
}
else
{
++fmt;
if(*fmt == 0)
{
--fmt;
*out = *fmt;
++out;
++fmt;
return out;
}
unsigned int id = traits_inst.toi(fmt, fmt_end, 10);
if(m[id].matched)
{
oi_assign(&out, _reg_format_aux(out, m, fmt, flags | format_is_if, traits_inst));
if(traits_inst.syntax_type((traits_size_type)(traits_uchar_type)(*(fmt-1))) == traits_type::syntax_colon)
re_skip_format(fmt, traits_inst);
}
else
{
re_skip_format(fmt, traits_inst);
if(traits_inst.syntax_type((traits_size_type)(traits_uchar_type)(*(fmt-1))) == traits_type::syntax_colon)
oi_assign(&out, _reg_format_aux(out, m, fmt, flags | format_is_if, traits_inst));
}
return out;
}
}
default:
default_opt:
if((flags & format_sed) && (*fmt == '&'))
{
oi_assign(&out, re_copy_out(out, iterator(m[0].first), iterator(m[0].second)));
++fmt;
continue;
}
*out = *fmt;
++out;
++fmt;
}
}
return out;
}
#if defined(BOOST_RE_NO_TEMPLATE_SWITCH_MERGE) && !defined(BOOST_RE_NO_NAMESPACES)
} // namespace
#endif
template <class S>
class string_out_iterator
{
S* out;
public:
string_out_iterator(S& s) : out(&s) {}
string_out_iterator& operator++() { return *this; }
string_out_iterator& operator++(int) { return *this; }
string_out_iterator& operator*() { return *this; }
string_out_iterator& operator=(typename S::value_type v)
{
out->append(1, v);
return *this;
}
};
template <class OutputIterator, class iterator, class charT, class Allocator, class traits_type>
class merge_out_predicate
{
OutputIterator* out;
iterator* last;
const charT* fmt;
unsigned flags;
const traits_type* pt;
public:
merge_out_predicate(OutputIterator& o, iterator& pi, const charT* f, unsigned format_flags, const traits_type& p)
: out(&o), last(&pi), fmt(f), flags(format_flags), pt(&p){}
~merge_out_predicate() {}
bool BOOST_RE_CALL operator()(const boost::match_results<iterator, Allocator>& m)
{
const charT* f = fmt;
if(0 == (flags & format_no_copy))
oi_assign(out, re_copy_out(*out, iterator(m[-1].first), iterator(m[-1].second)));
oi_assign(out, _reg_format_aux(*out, m, f, flags, *pt));
*last = m[-2].first;
return flags & format_first_only ? false : true;
}
};
} // namespace re_detail
template <class OutputIterator, class iterator, class Allocator, class charT>
OutputIterator regex_format(OutputIterator out,
const match_results<iterator, Allocator>& m,
const charT* fmt,
unsigned flags = 0
)
{
regex_traits<charT> t;
return re_detail::_reg_format_aux(out, m, fmt, flags, t);
}
template <class OutputIterator, class iterator, class Allocator, class charT>
OutputIterator regex_format(OutputIterator out,
const match_results<iterator, Allocator>& m,
const std::basic_string<charT>& fmt,
unsigned flags = 0
)
{
regex_traits<charT> t;
const charT* start = fmt.c_str();
return re_detail::_reg_format_aux(out, m, start, flags, t);
}
template <class iterator, class Allocator, class charT>
std::basic_string<charT> regex_format(const match_results<iterator, Allocator>& m, const charT* fmt, unsigned flags = 0)
{
std::basic_string<charT> result;
re_detail::string_out_iterator<std::basic_string<charT> > i(result);
regex_format(i, m, fmt, flags);
return result;
}
template <class iterator, class Allocator, class charT>
std::basic_string<charT> regex_format(const match_results<iterator, Allocator>& m, const std::basic_string<charT>& fmt, unsigned flags = 0)
{
std::basic_string<charT> result;
re_detail::string_out_iterator<std::basic_string<charT> > i(result);
regex_format(i, m, fmt.c_str(), flags);
return result;
}
template <class OutputIterator, class iterator, class traits, class Allocator, class charT>
OutputIterator regex_merge(OutputIterator out,
iterator first,
iterator last,
const reg_expression<charT, traits, Allocator>& e,
const charT* fmt,
unsigned int flags = match_default)
{
iterator l = first;
re_detail::merge_out_predicate<OutputIterator, iterator, charT, Allocator, traits> oi(out, l, fmt, flags, e.get_traits());
regex_grep(oi, first, last, e, flags);
return (flags & format_no_copy) ? out : re_detail::re_copy_out(out, l, last);
}
template <class OutputIterator, class iterator, class traits, class Allocator, class charT>
inline OutputIterator regex_merge(OutputIterator out,
iterator first,
iterator last,
const reg_expression<charT, traits, Allocator>& e,
const std::basic_string<charT>& fmt,
unsigned int flags = match_default)
{
return regex_merge(out, first, last, e, fmt.c_str(), flags);
}
template <class traits, class Allocator, class charT>
std::basic_string<charT> regex_merge(const std::basic_string<charT>& s,
const reg_expression<charT, traits, Allocator>& e,
const charT* fmt,
unsigned int flags = match_default)
{
std::basic_string<charT> result;
re_detail::string_out_iterator<std::basic_string<charT> > i(result);
regex_merge(i, s.begin(), s.end(), e, fmt, flags);
return result;
}
template <class traits, class Allocator, class charT>
std::basic_string<charT> regex_merge(const std::basic_string<charT>& s,
const reg_expression<charT, traits, Allocator>& e,
const std::basic_string<charT>& fmt,
unsigned int flags = match_default)
{
std::basic_string<charT> result;
re_detail::string_out_iterator<std::basic_string<charT> > i(result);
regex_merge(i, s.begin(), s.end(), e, fmt.c_str(), flags);
return result;
}
#ifdef __BORLANDC__
#pragma option pop
#endif
} // namespace boost
#endif // BOOST_REGEX_FORMAT_HPP

View File

@ -1,112 +0,0 @@
/*
*
* 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.
*
*/
/*
* LOCATION: see http://www.boost.org for most recent version.
* FILE regex_kmp.hpp
* VERSION 3.12
* DESCRIPTION: Provides Knuth Morris Pratt search operations.
* Note this is an internal header file included
* by regex.hpp, do not include on its own.
*/
#ifndef BOOST_REGEX_KMP_HPP
#define BOOST_REGEX_KMP_HPP
#ifdef BOOST_REGEX_CONFIG_HPP
#include <boost/regex/detail/regex_config.hpp>
#endif
namespace boost{
namespace re_detail{
#ifdef __BORLANDC__
#pragma option push -a4 -b -Ve -pc
#endif
template <class charT>
struct kmp_info
{
unsigned int size;
unsigned int len;
const charT* pstr;
int kmp_next[1];
};
template <class charT, class Allocator>
void kmp_free(kmp_info<charT>* pinfo, const Allocator& a)
{
typedef typename boost::re_detail::rebind_allocator<char, Allocator>::type atype;
atype(a).deallocate((char*)pinfo, pinfo->size);
}
template <class iterator, class charT, class Trans, class Allocator>
kmp_info<charT>* kmp_compile(iterator first, iterator last, charT, Trans translate, const Allocator& a)
{
typedef typename boost::re_detail::rebind_allocator<char, Allocator>::type atype;
int i, j, m;
i = 0;
m = boost::re_detail::distance(first, last);
++m;
unsigned int size = sizeof(kmp_info<charT>) + sizeof(int)*m + sizeof(charT)*m;
--m;
//
// allocate struct and fill it in:
//
kmp_info<charT>* pinfo = (kmp_info<charT>*)atype(a).allocate(size);
pinfo->size = size;
pinfo->len = m;
charT* p = (charT*)((char*)pinfo + sizeof(kmp_info<charT>) + sizeof(int)*(m+1));
pinfo->pstr = p;
while(first != last)
{
*p = translate(*first);
++first;
++p;
}
*p = 0;
//
// finally do regular kmp compile:
//
j = pinfo->kmp_next[0] = -1;
while (i < m)
{
while ((j > -1) && (pinfo->pstr[i] != pinfo->pstr[j]))
j = pinfo->kmp_next[j];
++i;
++j;
if (pinfo->pstr[i] == pinfo->pstr[j])
pinfo->kmp_next[i] = pinfo->kmp_next[j];
else
pinfo->kmp_next[i] = j;
}
return pinfo;
}
#ifdef __BORLANDC__
#pragma option pop
#endif
} // namepsace re_detail
} // namespace boost
#endif // BOOST_REGEX_KMP_HPP

View File

@ -1,156 +0,0 @@
/*
*
* 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.
*
*/
/*
* LOCATION: see http://www.boost.org for most recent version.
* FILE regex_libary_include.hpp
* VERSION 3.12
* DESCRIPTION: Automatic library inclusion for Borland/Microsoft compilers.
* Note this is an internal header file included
* by regex.hpp, do not include on its own.
*/
#ifndef BOOST_REGEX_LIBRARY_INCLUDE_HPP
#define BOOST_REGEX_LIBRARY_INCLUDE_HPP
#ifndef BOOST_RE_NO_LIB
#if defined(BOOST_MSVC) && !defined(BOOST_RE_BUILD_DLL)
#ifdef __SGI_STL_PORT
#ifdef _DLL
// All these are multithreaded:
#if defined(_DEBUG) && defined(__STL_DEBUG)
#pragma comment(lib, "vc6-stlport-re300ddl.lib")
#elif defined(_DEBUG)
#pragma comment(lib, "vc6-stlport-re300dl.lib")
#elif defined(BOOST_RE_STATIC_LIB)
// static regex lib, dll runtime
#pragma comment(lib, "vc6-stlport-re300ls.lib")
#else // DEBUG
#pragma comment(lib, "vc6-stlport-re300l.lib")
#endif // _DEBUG
#else // _DLL
#ifdef _MT
#if defined(_DEBUG) && defined(__STL_DEBUG)
#pragma comment(lib, "vc6-stlport-re300ddm.lib")
#elif defined(_DEBUG)
#pragma comment(lib, "vc6-stlport-re300dm.lib")
#else //_DEBUG
#pragma comment(lib, "vc6-stlport-re300m.lib")
#endif //_DEBUG
#else //_MT
// STLPort does not support single threaded builds:
#error STLPort does not support single threaded builds
#endif //_MT
#endif //_DLL
#else
#ifdef _DLL
// All these are multithreaded:
#ifdef _DEBUG
#pragma comment(lib, "vc6-re300dl.lib")
#elif defined(BOOST_RE_STATIC_LIB)
// static regex lib, dll runtime
#pragma comment(lib, "vc6-re300ls.lib")
#else // DEBUG
#pragma comment(lib, "vc6-re300l.lib")
#endif // _DEBUG
#else // _DLL
#ifdef _MT
#ifdef _DEBUG
#pragma comment(lib, "vc6-re300dm.lib")
#else //_DEBUG
#pragma comment(lib, "vc6-re300m.lib")
#endif //_DEBUG
#else //_MT
#ifdef _DEBUG
#pragma comment(lib, "vc6-re300d.lib")
#else //_DEBUG
#pragma comment(lib, "vc6-re300.lib")
#endif //_DEBUG
#endif //_MT
#endif //_DLL
#endif // __SGI_STL_PORT
#endif //BOOST_MSVC
#if defined(__BORLANDC__) && !defined(BOOST_RE_BUILD_DLL)
#if __BORLANDC__ < 0x550
#ifdef BOOST_RE_USE_VCL
#ifdef _RTLDLL
#pragma comment(lib, "bcb4re300lv.lib")
#else
#pragma comment(lib, "bcb4re300v.lib")
#endif
#else // VCL
#ifdef _RTLDLL
#ifdef __MT__
#pragma comment(lib, "bcb4re300lm.lib")
#else // __MT__
#pragma comment(lib, "bcb4re300l.lib")
#endif // __MT__
#else //_RTLDLL
#ifdef __MT__
#pragma comment(lib, "bcb4re300m.lib")
#else // __MT__
#pragma comment(lib, "bcb4re300.lib")
#endif // __MT__
#endif // _RTLDLL
#endif // VCL
#else // C++ Builder 5:
#ifdef BOOST_RE_USE_VCL
#ifdef _RTLDLL
#pragma comment(lib, "bcb5re300lv.lib")
#else
#pragma comment(lib, "bcb5re300v.lib")
#endif
#else // VCL
#ifdef _RTLDLL
#ifdef __MT__
#pragma comment(lib, "bcb5re300lm.lib")
#else // __MT__
#pragma comment(lib, "bcb5re300l.lib")
#endif // __MT__
#else //_RTLDLL
#ifdef __MT__
#pragma comment(lib, "bcb5re300m.lib")
#else // __MT__
#pragma comment(lib, "bcb5re300.lib")
#endif // __MT__
#endif // _RTLDLL
#endif // VCL
#endif
#endif //__BORLANDC__
#endif //BOOST_RE_NO_LIB
#endif // BOOST_REGEX_LIBRARY_INCLUDE_HPP

File diff suppressed because it is too large Load Diff

View File

@ -1,146 +0,0 @@
#ifndef BOOST_RE_OPT_H
#define BOOST_RE_OPT_H
/* #define BOOST_RE_AUTO_CONFIGURE */
#ifdef BOOST_RE_AUTO_CONFIGURE
/* Compiler options: */
/* BOOST_NO_STDC_NAMESPACE C library not in namespace std */
/* #define BOOST_NO_STDC_NAMESPACE */
/* BOOST_RE_PLATFORM_W32 Platform is MS Win32 */
/* #define BOOST_RE_PLATFORM_W32 */
/* BOOST_RE_NO_W32 Disable Win32 support even when present */
/* #define BOOST_RE_NO_W32 */
/* BOOST_RE_NO_BOOL If bool is not a distict type. */
/* #define BOOST_RE_NO_BOOL */
/* BOOST_RE_NO_WCHAR_H If there is no <wchar.h> */
/* #define BOOST_RE_NO_WCHAR_H */
/* BOOST_RE_NO_WCTYPE_H If there is no <wctype.h> */
/* #define BOOST_RE_NO_WCTYPE_H */
/* BOOST_RE_NO_WCSTRING If there are no wcslen and wcsncmp functions available. */
/* #define BOOST_RE_NO_WCSTRING */
/* BOOST_RE_NO_SWPRINTF If there is no swprintf available. */
/* #define BOOST_RE_NO_SWPRINTF */
/* BOOST_RE_NO_WSPRINTF If there is no wsprintf available. */
/* #define BOOST_RE_NO_WSPRINTF */
/* BOOST_NO_MEMBER_TEMPLATES If member function templates or nested template classes are not allowed. */
/* #define BOOST_NO_MEMBER_TEMPLATES */
/* BOOST_RE_NO_TEMPLATE_RETURNS If template functions based on return type are not supported. */
/* #define BOOST_RE_NO_TEMPLATE_RETURNS */
/* BOOST_RE_NO_PARTIAL_FUNC_SPEC If partial template function specialisation is not supported */
/* #define BOOST_RE_NO_PARTIAL_FUNC_SPEC */
/* BOOST_RE_NO_CAT Define if the compiler does not support POSIX style
message categories (catopen catgets catclose). */
/* #define BOOST_RE_NO_CAT */
/* BOOST_RE_THREADS Define if the compiler supports multiple threads in
the current translation mode. */
/* #define BOOST_RE_THREADS */
/* BOOST_RE_NO_TEMPLATE_MERGE If template in separate translation units don't merge at link time */
/* #define BOOST_RE_NO_TEMPLATE_MERGE */
/* BOOST_RE_NO_TEMPLATE_MERGE_A If template merging from library archives is not supported */
/* #define BOOST_RE_NO_TEMPLATE_MERGE_A */
/* BOOST_RE_NO_TEMPLATE_SWITCH_MERGE If merging of templates containing switch statements is not supported */
/* #define BOOST_RE_NO_TEMPLATE_SWITCH_MERGE */
/* BOOST_RE_CALL Optionally define a calling convention for C++ functions */
/* #define BOOST_RE_CALL */
/* BOOST_RE_CCALL Optionally define a calling convention for C functions */
/* #define BOOST_RE_CCALL */
/* BOOST_RE_SIZEOF_SHORT sizeof(short) */
/* #define BOOST_RE_SIZEOF_SHORT */
/* BOOST_RE_SIZEOF_INT sizeof(int) */
/* #define BOOST_RE_SIZEOF_INT */
/* BOOST_RE_SIZEOF_LONG sizeof(long) */
/* #define BOOST_RE_SIZEOF_LONG */
/* BOOST_RE_SIZEOF_WCHAR_T sizeof(wchar_t) */
/* #define BOOST_RE_SIZEOF_WCHAR_T */
/* STL options: */
/* BOOST_RE_NO_ITERATOR_H Define if you do not have a version of <iterator>. */
/* #define BOOST_RE_NO_ITERATOR_H */
/* BOOST_NO_STD_ALLOCATOR Define if <memory> does not fully comply with the
latest standard, and is not auto-recognised,
that means nested template classes
which hardly any compilers support at present. */
/* #define BOOST_NO_STD_ALLOCATOR */
/* BOOST_RE_NO_LOCALE_H Define if there is no verion of the standard
<locale> header available. */
/* #define BOOST_RE_NO_LOCALE_H */
/* BOOST_RE_NO_STL Disables the use of any supporting STL code. */
/* #define BOOST_RE_NO_STL */
/* BOOST_RE_NO_NOT_EQUAL Disables the generation of operator!= if this
clashes with the STL version. */
/* BOOST_RE_NO_STRING_DEF_ARGS Define if std::basic_string<charT> not allowed - in
other words if the template is missing its required
default arguments. */
/* #define BOOST_RE_NO_STRING_DEF_ARGS */
/* BOOST_RE_USE_ALGO If <algo.h> not <algorithm> is present */
/* #define BOOST_RE_USE_ALGO */
/* BOOST_RE_OLD_IOSTREAM If the new iostreamm classes are not available */
/* #define BOOST_RE_OLD_IOSTREAM */
/* BOOST_NO_STD_DISTANCE If there is no std::distance. */
/* #define BOOST_NO_STD_DISTANCE */
/* BOOST_RE_NO_OI_ASSIGN If output iterators ostream_iterator<>, back_insert_iterator<> and
front_insert_iterator<> do not have assignment operators */
/* #define BOOST_RE_NO_OI_ASSIGN */
#include <stdexcept>
#ifndef BOOST_RE_NO_ITERATOR_H
#include <iterator>
#ifdef BOOST_RE_USE_ALGO
#include <algo.h>
#else
#include <algorithm>
#endif
#endif
#endif // BOOST_RE_AUTO_CONFIGURE
#endif /* BOOST_RE_OPT_H */

View File

@ -1,245 +0,0 @@
/*
*
* 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.
*
*/
/*
* LOCATION: see http://www.boost.org for most recent version.
* FILE regex_raw_buffer.hpp
* VERSION 3.12
* DESCRIPTION: Raw character buffer for regex code.
* Note this is an internal header file included
* by regex.hpp, do not include on its own.
*/
#ifndef BOOST_REGEX_RAW_BUFFER_HPP
#define BOOST_REGEX_RAW_BUFFER_HPP
#ifndef BOOST_REGEX_CONFIG_HPP
#include <boost/regex/detail/regex_config.hpp>
#endif
namespace boost{
namespace re_detail{
#ifdef __BORLANDC__
#pragma option push -a4 -b -Ve -pc
#endif
struct empty_padding{};
union padding
{
void* p;
unsigned int i;
};
template <int N>
struct padding3
{
enum{
padding_size = 8,
padding_mask = 7
};
};
template<>
struct padding3<2>
{
enum{
padding_size = 2,
padding_mask = 1
};
};
template<>
struct padding3<4>
{
enum{
padding_size = 4,
padding_mask = 3
};
};
template<>
struct padding3<8>
{
enum{
padding_size = 8,
padding_mask = 7
};
};
template<>
struct padding3<16>
{
enum{
padding_size = 16,
padding_mask = 15
};
};
enum{
padding_size = padding3<sizeof(padding)>::padding_size,
padding_mask = padding3<sizeof(padding)>::padding_mask
};
//
// class raw_storage
// basically this is a simplified vector<unsigned char>
// this is used by reg_expression for expression storage
//
template <class Allocator>
class raw_storage
{
public:
typedef Allocator allocator_type;
typedef typename boost::re_detail::rebind_allocator<unsigned char, allocator_type>::type alloc_inst_type;
typedef typename alloc_inst_type::size_type size_type;
typedef typename alloc_inst_type::pointer pointer;
private:
//
// empty member optimisation:
struct alloc_data : public alloc_inst_type
{
typename alloc_inst_type::pointer last;
alloc_data(const Allocator& a) : alloc_inst_type(a){}
} alloc_inst;
pointer start, end;
public:
raw_storage(const Allocator& a = Allocator());
raw_storage(size_type n, const Allocator& a = Allocator());
~raw_storage()
{
alloc_inst.deallocate(start, (alloc_inst.last - start));
}
void BOOST_RE_CALL resize(size_type n);
void* BOOST_RE_CALL extend(size_type n)
{
if(size_type(alloc_inst.last - end) < n)
resize(n + (end - start));
register void* result = end;
end += n;
return result;
}
void* BOOST_RE_CALL insert(size_type pos, size_type n);
size_type BOOST_RE_CALL size()
{
return end - start;
}
size_type BOOST_RE_CALL capacity()
{
return alloc_inst.last - start;
}
void* BOOST_RE_CALL data()const
{
return start;
}
size_type BOOST_RE_CALL index(void* ptr)
{
return (unsigned char*)ptr - (unsigned char*)data();
}
void BOOST_RE_CALL clear()
{
end = start;
}
void BOOST_RE_CALL align()
{
// move end up to a boundary:
end = (unsigned char*)start + ((((unsigned char*)end - (unsigned char*)start) + padding_mask) & ~padding_mask);
}
Allocator BOOST_RE_CALL allocator()const;
};
template <class Allocator>
CONSTRUCTOR_INLINE raw_storage<Allocator>::raw_storage(const Allocator& a)
: alloc_inst(a)
{
start = end = alloc_inst.allocate(1024);
alloc_inst.last = start + 1024;
}
template <class Allocator>
CONSTRUCTOR_INLINE raw_storage<Allocator>::raw_storage(size_type n, const Allocator& a)
: alloc_inst(a)
{
start = end = alloc_inst.allocate(n);
alloc_inst.last = start + n;
}
template <class Allocator>
Allocator BOOST_RE_CALL raw_storage<Allocator>::allocator()const
{
return alloc_inst;
}
template <class Allocator>
void BOOST_RE_CALL raw_storage<Allocator>::resize(size_type n)
{
register size_type newsize = (alloc_inst.last - start) * 2;
register size_type datasize = end - start;
if(newsize < n)
newsize = n;
// extend newsize to WORD/DWORD boundary:
newsize = (newsize + padding_mask) & ~(padding_mask);
// allocate and copy data:
register unsigned char* ptr = alloc_inst.allocate(newsize);
std::memcpy(ptr, start, datasize);
// get rid of old buffer:
alloc_inst.deallocate(start, (alloc_inst.last - start));
// and set up pointers:
start = ptr;
end = ptr + datasize;
alloc_inst.last = ptr + newsize;
}
template <class Allocator>
void* BOOST_RE_CALL raw_storage<Allocator>::insert(size_type pos, size_type n)
{
jm_assert(pos <= size_type(end - start));
if(size_type(alloc_inst.last - end) < n)
resize(n + (end - start));
register void* result = start + pos;
std::memmove(start + pos + n, start + pos, (end - start) - pos);
end += n;
return result;
}
#ifdef __BORLANDC__
#pragma option pop
#endif
} // namespace re_detail
} // namespace boost
#endif

View File

@ -1,149 +0,0 @@
/*
*
* 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.
*
*/
/*
* LOCATION: see http://www.boost.org for most recent version.
* FILE regex_split.hpp
* VERSION 3.12
* DESCRIPTION: Implements regex_split and associated functions.
* Note this is an internal header file included
* by regex.hpp, do not include on its own.
*/
#ifndef BOOST_REGEX_SPLIT_HPP
#define BOOST_REGEX_SPLIT_HPP
namespace boost{
#ifdef __BORLANDC__
#pragma option push -a4 -b -Ve -pc
#endif
namespace re_detail{
template <class charT>
const reg_expression<charT>& get_default_expression(charT)
{
static const charT expression_text[] = { '\\', 's', '+', '\00', };
static const reg_expression<charT> e(expression_text);
return e;
}
template <class OutputIterator, class charT, class Traits1, class Alloc1, class Alloc2>
class split_pred
{
typedef std::basic_string<charT, Traits1, Alloc1> string_type;
typedef typename string_type::const_iterator iterator_type;
iterator_type* p_last;
OutputIterator* p_out;
std::size_t* p_max;
std::size_t initial_max;
public:
split_pred(iterator_type* a, OutputIterator* b, std::size_t* c)
: p_last(a), p_out(b), p_max(c), initial_max(*c) {}
bool operator()(const match_results<iterator_type, Alloc2>& what);
};
template <class OutputIterator, class charT, class Traits1, class Alloc1, class Alloc2>
bool split_pred<OutputIterator, charT, Traits1, Alloc1, Alloc2>::operator()
(const match_results<iterator_type, Alloc2>& what)
{
*p_last = what[0].second;
if(what.size() > 1)
{
// output sub-expressions only:
for(unsigned i = 1; i < what.size(); ++i)
{
*(*p_out) = static_cast<string_type>(what[i]);
++(*p_out);
return --*p_max;
}
}
else
{
// output $` only if it's not-null or not at the start of the input:
const sub_match<iterator_type>& sub = what[-1];
if((sub.first != sub.second) || (*p_max != initial_max))
{
*(*p_out) = static_cast<string_type>(sub);
++(*p_out);
return --*p_max;
}
}
//
// initial null, do nothing:
return true;
}
} // namespace re_detail
template <class OutputIterator, class charT, class Traits1, class Alloc1, class Traits2, class Alloc2>
std::size_t regex_split(OutputIterator out,
std::basic_string<charT, Traits1, Alloc1>& s,
const reg_expression<charT, Traits2, Alloc2>& e,
unsigned flags,
std::size_t max_split)
{
typedef typename std::basic_string<charT, Traits1, Alloc1>::const_iterator ci_t;
ci_t last = s.begin();
std::size_t init_size = max_split;
re_detail::split_pred<OutputIterator, charT, Traits1, Alloc1, Alloc2> pred(&last, &out, &max_split);
ci_t i, j;
i = s.begin();
j = s.end();
regex_grep(pred, i, j, e, flags);
//
// if there is still input left, do a final push as long as max_split
// is not exhausted, and we're not splitting sub-expressions rather
// than whitespace:
if(max_split && (last != s.end()) && (e.mark_count() == 1))
{
*out = std::basic_string<charT, Traits1, Alloc1>((ci_t)last, (ci_t)s.end());
++out;
last = s.end();
--max_split;
}
//
// delete from the string everything that has been processed so far:
s.erase(0, last - s.begin());
//
// return the number of new records pushed:
return init_size - max_split;
}
template <class OutputIterator, class charT, class Traits1, class Alloc1, class Traits2, class Alloc2>
inline std::size_t regex_split(OutputIterator out,
std::basic_string<charT, Traits1, Alloc1>& s,
const reg_expression<charT, Traits2, Alloc2>& e,
unsigned flags = match_default)
{
return regex_split(out, s, e, flags, UINT_MAX);
}
template <class OutputIterator, class charT, class Traits1, class Alloc1>
inline std::size_t regex_split(OutputIterator out,
std::basic_string<charT, Traits1, Alloc1>& s)
{
return regex_split(out, s, re_detail::get_default_expression(charT(0)), match_default, UINT_MAX);
}
#ifdef __BORLANDC__
#pragma option pop
#endif
} // namespace boost
#endif

View File

@ -1,224 +0,0 @@
/*
*
* 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.
*
*/
/*
* LOCATION: see http://www.boost.org for most recent version.
* FILE regex_stack.hpp
* VERSION 3.12
* DESCRIPTION: Implements customised internal regex stacks.
* Note this is an internal header file included
* by regex.hpp, do not include on its own.
*/
#ifndef BOOST_REGEX_STACK_HPP
#define BOOST_REGEX_STACK_HPP
#ifndef BOOST_REGEX_CONFIG_HPP
#include <boost/regex/detail/regex_config.hpp>
#endif
#ifndef BOOST_REGEX_RAW_BUFFER_HPP
#include <boost/regex/detail/regex_raw_buffer.hpp>
#endif
namespace boost{
namespace re_detail{
#ifdef __BORLANDC__
#pragma option push -a4 -b -Ve -pc
#endif
//
// class jstack
// simplified stack optimised for push/peek/pop
// operations, we could use std::stack<std::vector<T>> instead...
//
template <class T, class Allocator BOOST_RE_DEF_ALLOC_PARAM(T) >
class jstack
{
private:
typedef typename boost::re_detail::rebind_allocator<unsigned char, Allocator>::type allocator_type;
typedef typename boost::re_detail::rebind_allocator<T, Allocator>::type T_alloc_type;
typedef typename T_alloc_type::size_type size_type;
typedef T value_type;
struct node
{
node* next;
T* start; // first item
T* end; // last item
T* last; // end of storage
};
//
// empty base member optimisation:
struct data : public allocator_type
{
padding buf[(sizeof(T) * 16 + sizeof(padding) - 1) / sizeof(padding)];
data(const Allocator& a) : allocator_type(a){}
};
data alloc_inst;
mutable node* m_stack;
mutable node* unused;
node base;
size_type block_size;
void BOOST_RE_CALL pop_aux()const;
void BOOST_RE_CALL push_aux();
public:
jstack(size_type n = 64, const Allocator& a = Allocator());
~jstack();
node* BOOST_RE_CALL get_node()
{
node* new_stack = (node*)alloc_inst.allocate(sizeof(node) + sizeof(T) * block_size);
new_stack->last = (T*)(new_stack+1);
new_stack->start = new_stack->end = new_stack->last + block_size;
new_stack->next = 0;
return new_stack;
}
bool BOOST_RE_CALL empty()
{
return (m_stack->start == m_stack->end) && (m_stack->next == 0);
}
bool BOOST_RE_CALL good()
{
return (m_stack->start != m_stack->end) || (m_stack->next != 0);
}
T& BOOST_RE_CALL peek()
{
if(m_stack->start == m_stack->end)
pop_aux();
return *m_stack->end;
}
const T& BOOST_RE_CALL peek()const
{
if(m_stack->start == m_stack->end)
pop_aux();
return *m_stack->end;
}
void BOOST_RE_CALL pop()
{
if(m_stack->start == m_stack->end)
pop_aux();
jm_destroy(m_stack->end);
++(m_stack->end);
}
void BOOST_RE_CALL pop(T& t)
{
if(m_stack->start == m_stack->end)
pop_aux();
t = *m_stack->end;
jm_destroy(m_stack->end);
++(m_stack->end);
}
void BOOST_RE_CALL push(const T& t)
{
if(m_stack->end == m_stack->last)
push_aux();
--(m_stack->end);
jm_construct(m_stack->end, t);
}
};
template <class T, class Allocator>
jstack<T, Allocator>::jstack(size_type n, const Allocator& a)
: alloc_inst(a)
{
unused = 0;
block_size = n;
m_stack = &base;
base.last = reinterpret_cast<T*>(alloc_inst.buf);
base.end = base.start = base.last + 16;
base.next = 0;
}
template <class T, class Allocator>
void BOOST_RE_CALL jstack<T, Allocator>::push_aux()
{
// make sure we have spare space on TOS:
register node* new_node;
if(unused)
{
new_node = unused;
unused = new_node->next;
new_node->next = m_stack;
m_stack = new_node;
}
else
{
new_node = get_node();
new_node->next = m_stack;
m_stack = new_node;
}
}
template <class T, class Allocator>
void BOOST_RE_CALL jstack<T, Allocator>::pop_aux()const
{
// make sure that we have a valid item
// on TOS:
jm_assert(m_stack->next);
register node* p = m_stack;
m_stack = p->next;
p->next = unused;
unused = p;
}
template <class T, class Allocator>
jstack<T, Allocator>::~jstack()
{
node* condemned;
while(good())
pop();
while(unused)
{
condemned = unused;
unused = unused->next;
alloc_inst.deallocate((unsigned char*)condemned, sizeof(node) + sizeof(T) * block_size);
}
while(m_stack != &base)
{
condemned = m_stack;
m_stack = m_stack->next;
alloc_inst.deallocate((unsigned char*)condemned, sizeof(node) + sizeof(T) * block_size);
}
}
#ifdef __BORLANDC__
#pragma option pop
#endif
} // namespace re_detail
} // namespace boost
#endif

View File

@ -1,211 +0,0 @@
/*
*
* 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.
*
*/
/*
* LOCATION: see http://www.boost.org for most recent version.
* FILE regex_synch.hpp
* VERSION 3.12
* DESCRIPTION: Thread synchronisation for regex code.
* Note this is an internal header file included
* by regex.hpp, do not include on its own.
*/
#ifndef BOOST_REGEX_SYNCH_HPP
#define BOOST_REGEX_SYNCH_HPP
#ifndef BOOST_REGEX_CONFIG_HPP
#include <boost/regex/detail/regex_config.hpp>
#endif
#if defined(BOOST_RE_PLATFORM_W32) && defined(BOOST_RE_THREADS)
#include <windows.h>
#endif
#if !defined(BOOST_RE_PLATFORM_W32) && defined(BOOST_RE_THREADS)
#if defined(__BEOS__)
#include <OS.h>
#include <cassert>
#else
#include <pthread.h>
#endif
#endif
namespace boost{
namespace re_detail{
#ifdef __BORLANDC__
#pragma option push -a4 -b -Ve -pc
#endif
void BOOST_RE_CALL re_init_threads();
void BOOST_RE_CALL re_free_threads();
#ifdef BOOST_RE_THREADS
#ifndef BOOST_RE_PLATFORM_W32
#ifdef __BEOS__
typedef sem_id CRITICAL_SECTION;
inline void BOOST_RE_CALL InitializeCriticalSection(CRITICAL_SECTION* ps)
{
*ps = create_sem(1, "regex++");
assert(*ps > 0);
}
inline void BOOST_RE_CALL DeleteCriticalSection(CRITICAL_SECTION* ps)
{
int t = delete_sem(*ps);
assert(t == B_NO_ERROR);
}
inline void BOOST_RE_CALL EnterCriticalSection(CRITICAL_SECTION* ps)
{
status_t t = acquire_sem(*ps);
assert(t == B_NO_ERROR);
}
inline void BOOST_RE_CALL LeaveCriticalSection(CRITICAL_SECTION* ps)
{
status_t t = release_sem(*ps);
assert(t == B_NO_ERROR);
}
#else // __BEOS__
typedef pthread_mutex_t CRITICAL_SECTION;
inline void BOOST_RE_CALL InitializeCriticalSection(CRITICAL_SECTION* ps)
{
pthread_mutex_init(ps, 0);
}
inline void BOOST_RE_CALL DeleteCriticalSection(CRITICAL_SECTION* ps)
{
pthread_mutex_destroy(ps);
}
inline void BOOST_RE_CALL EnterCriticalSection(CRITICAL_SECTION* ps)
{
pthread_mutex_lock(ps);
}
inline void BOOST_RE_CALL LeaveCriticalSection(CRITICAL_SECTION* ps)
{
pthread_mutex_unlock(ps);
}
#endif // __BEOS__
#endif
template <class Lock>
class lock_guard
{
typedef Lock lock_type;
public:
lock_guard(lock_type& m, bool aq = true)
: mut(m), owned(false){ acquire(aq); }
~lock_guard()
{ acquire(false); }
void BOOST_RE_CALL acquire(bool aq = true)
{
if(aq && !owned)
{
mut.acquire(true);
owned = true;
}
else if(!aq && owned)
{
mut.acquire(false);
owned = false;
}
}
private:
lock_type& mut;
bool owned;
// VC6 warning suppression:
lock_guard& operator=(const lock_guard&);
};
class critical_section
{
public:
critical_section()
{ InitializeCriticalSection(&hmutex);}
critical_section(const critical_section&)
{ InitializeCriticalSection(&hmutex);}
const critical_section& BOOST_RE_CALL operator=(const critical_section&)
{return *this;}
~critical_section()
{DeleteCriticalSection(&hmutex);}
private:
void BOOST_RE_CALL acquire(bool aq)
{ if(aq) EnterCriticalSection(&hmutex);
else LeaveCriticalSection(&hmutex);
}
CRITICAL_SECTION hmutex;
public:
typedef lock_guard<critical_section> ro_guard;
typedef lock_guard<critical_section> rw_guard;
friend class lock_guard<critical_section>;
};
inline bool BOOST_RE_CALL operator==(const critical_section&, const critical_section&)
{
return false;
}
inline bool BOOST_RE_CALL operator<(const critical_section&, const critical_section&)
{
return true;
}
typedef lock_guard<critical_section> cs_guard;
BOOST_RE_IX_DECL extern critical_section* p_re_lock;
BOOST_RE_IX_DECL extern unsigned int re_lock_count;
#define BOOST_RE_GUARD(inst) boost::re_detail::critical_section::rw_guard g(inst);
#else // BOOST_RE_THREADS
#define BOOST_RE_GUARD(inst)
#endif // BOOST_RE_THREADS
#ifdef __BORLANDC__
#pragma option pop
#endif
} // namespace re_detail
} // namespace boost
#endif // sentry

View File

@ -1,55 +0,0 @@
/*
*
* 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.
*
*/
/*
* LOCATION: see http://www.boost.org for most recent version.
* FILE pattern_except.cpp
* VERSION 3.12
* DESCRIPTION: Declares pattern-matching exception classes.
*/
#ifndef BOOST_RE_PAT_EXCEPT_HPP
#define BOOST_RE_PAT_EXCEPT_HPP
#include <boost/regex/detail/regex_config.hpp>
namespace boost{
#ifdef __BORLANDC__
#pragma option push -a4 -b -Ve -pc
#endif
class BOOST_RE_IX_DECL bad_pattern : public std::runtime_error
{
public:
explicit bad_pattern(const std::string& s) : std::runtime_error(s){};
~bad_pattern() throw();
};
class BOOST_RE_IX_DECL bad_expression : public bad_pattern
{
public:
explicit bad_expression(const std::string& s) : bad_pattern(s) {}
~bad_expression() throw();
};
#ifdef __BORLANDC__
#pragma option pop
#endif
} // namespace boost
#endif

View File

@ -1,791 +0,0 @@
/*
*
* 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.
*
*/
/*
* LOCATION: see http://www.boost.org for most recent version.
* FILE regex.cpp
* VERSION 3.12
* DESCRIPTION: Declares regular expression traits classes.
*/
#ifndef BOOST_REGEX_TRAITS_HPP
#define BOOST_REGEX_TRAITS_HPP
#include <boost/cregex.hpp>
#include <boost/regex/detail/regex_cstring.hpp>
namespace boost{
#ifdef __BORLANDC__
#pragma option push -a4 -b -Ve -pc
#endif
template <class charT>
class c_regex_traits;
namespace re_detail{
struct mss
{
unsigned int id;
const char* what;
};
BOOST_RE_IX_DECL bool BOOST_RE_CALL re_lookup_def_collate_name(std::string& buf, const char* name);
BOOST_RE_IX_DECL unsigned int BOOST_RE_CALL re_get_default_message(char* buf, unsigned int len, unsigned int id);
extern BOOST_RE_IX_DECL const char *re_default_error_messages[];
BOOST_RE_IX_DECL bool BOOST_RE_CALL re_lookup_def_collate_name(std::string& buf, const char* name);
BOOST_RE_IX_DECL bool BOOST_RE_CALL is_combining(wchar_t c);
//extern BOOST_RE_IX_DECL const wchar_t combining_ranges[];
#ifndef BOOST_RE_NO_WCSTRING
extern BOOST_RE_IX_DECL wchar_t wide_lower_case_map[];
extern BOOST_RE_IX_DECL unsigned short wide_unicode_classes[];
#endif
struct BOOST_RE_IX_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
syntax_max = 53
};
};
struct BOOST_RE_IX_DECL c_traits_base : public regex_traits_base
{
public:
enum{
char_class_none = 0,
char_class_alpha = 1,
char_class_cntrl = char_class_alpha << 1,
char_class_digit = char_class_cntrl << 1,
char_class_lower = char_class_digit << 1,
char_class_punct = char_class_lower << 1,
char_class_space = char_class_punct << 1,
char_class_upper = char_class_space << 1,
char_class_xdigit = char_class_upper << 1,
char_class_blank = char_class_xdigit << 1,
char_class_unicode = char_class_blank << 1,
char_class_underscore = char_class_unicode << 1,
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_RE_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[200];
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_RE_CALL do_lookup_class(const char* p);
static bool BOOST_RE_CALL do_lookup_collate(std::string& buf, const char* p);
static void BOOST_RE_CALL do_update_ctype();
static void BOOST_RE_CALL do_update_collate();
public:
static std::string BOOST_RE_CALL error_string(unsigned id);
static char* BOOST_RE_CALL get_catalogue() { return regex_message_catalogue; }
};
} // namespace re_detail
template<>
class BOOST_RE_IX_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_RE_CALL length(const char_type* p)
{
return std::strlen(p);
}
static unsigned int BOOST_RE_CALL syntax_type(size_type c)
{
return syntax_map[c];
}
static char BOOST_RE_CALL translate(char c, bool icase)
{
return icase ? lower_case_map[(size_type)(uchar_type)c] : c;
}
static void BOOST_RE_CALL transform(std::string& out, const std::string& in);
static void BOOST_RE_CALL transform_primary(std::string& out, const std::string& in);
static bool BOOST_RE_CALL is_separator(char c)
{
return BOOST_RE_MAKE_BOOL((c == '\n') || (c == '\r'));
}
static bool BOOST_RE_CALL is_combining(char)
{
return false;
}
static bool BOOST_RE_CALL is_class(char c, boost::uint_fast32_t f)
{
return BOOST_RE_MAKE_BOOL(class_map[(size_type)(uchar_type)c] & f);
}
static int BOOST_RE_CALL toi(char c);
static int BOOST_RE_CALL toi(const char*& first, const char* last, int radix);
static boost::uint_fast32_t BOOST_RE_CALL lookup_classname(const char* first, const char* last)
{
std::string s(first, last);
return do_lookup_class(s.c_str());
}
static bool BOOST_RE_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_RE_CALL imbue(locale_type l){ return l; }
locale_type BOOST_RE_CALL getloc()const{ return locale_type(); }
c_regex_traits()
{
init();
}
~c_regex_traits()
{
free();
}
struct sentry
{
sentry(const c_regex_traits<char>&)
{ c_regex_traits<char>::update(); }
operator void*() { return this; }
};
static void BOOST_RE_CALL update();
private:
static void BOOST_RE_CALL init();
static void BOOST_RE_CALL free();
static c_regex_traits<char> i;
static unsigned sort_type;
static char sort_delim;
};
#ifndef BOOST_RE_NO_WCSTRING
template<>
class BOOST_RE_IX_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_RE_CALL length(const char_type* p)
{
return std::wcslen(p);
}
static unsigned int BOOST_RE_CALL syntax_type(size_type c);
static wchar_t BOOST_RE_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_RE_CALL transform(std::basic_string<wchar_t>& out, const std::basic_string<wchar_t>& in);
static void BOOST_RE_CALL transform_primary(std::basic_string<wchar_t>& out, const std::basic_string<wchar_t>& in);
static bool BOOST_RE_CALL is_separator(wchar_t c)
{
return BOOST_RE_MAKE_BOOL((c == L'\n') || (c == L'\r') || (c == (wchar_t)0x2028) || (c == (wchar_t)0x2029));
}
static bool BOOST_RE_CALL is_combining(wchar_t c)
{ return re_detail::is_combining(c); }
static bool BOOST_RE_CALL is_class(wchar_t c, boost::uint_fast32_t f)
{
return BOOST_RE_MAKE_BOOL(((uchar_type)c < 256) ? (re_detail::wide_unicode_classes[(size_type)(uchar_type)c] & f) : do_iswclass(c, f));
}
static int BOOST_RE_CALL toi(wchar_t c);
static int BOOST_RE_CALL toi(const wchar_t*& first, const wchar_t* last, int radix);
static boost::uint_fast32_t BOOST_RE_CALL lookup_classname(const wchar_t* first, const wchar_t* last);
static bool BOOST_RE_CALL lookup_collatename(std::basic_string<wchar_t>& s, const wchar_t* first, const wchar_t* last);
static locale_type BOOST_RE_CALL imbue(locale_type l){ return l; }
locale_type BOOST_RE_CALL getloc()const{ return locale_type(); }
c_regex_traits<wchar_t>()
{ init(); }
~c_regex_traits<wchar_t>()
{ free(); }
struct sentry
{
sentry(const c_regex_traits<wchar_t>&)
{ c_regex_traits<wchar_t>::update(); }
operator void*() { return this; }
};
static void BOOST_RE_CALL update();
static unsigned int BOOST_RE_CALL strnarrow(char *s1, unsigned int len, const wchar_t *s2);
static unsigned int BOOST_RE_CALL strwiden(wchar_t *s1, unsigned int len, const char *s2);
private:
static bool BOOST_RE_CALL do_iswclass(wchar_t c, boost::uint_fast32_t f);
static void BOOST_RE_CALL free();
static void BOOST_RE_CALL init();
static bool BOOST_RE_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_RE_NO_W32)
namespace re_detail{
struct BOOST_RE_IX_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 = 0x0200,
char_class_word = C1_ALPHA | C1_DIGIT | char_class_underscore,
char_class_unicode = 0x0400
};
public:
static std::string BOOST_RE_CALL set_message_catalogue(const std::string& s);
protected:
static char regex_message_catalogue[200];
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_RE_CALL do_lookup_class(const char* p);
static bool BOOST_RE_CALL do_lookup_collate(std::string& buf, const char* p);
static void BOOST_RE_CALL do_free();
static void BOOST_RE_CALL do_init();
public:
static std::string BOOST_RE_CALL error_string(unsigned id);
static char* BOOST_RE_CALL get_catalogue() { return regex_message_catalogue; }
};
} // namespace re_detail
template<class charT>
class w32_regex_traits;
template<>
class BOOST_RE_IX_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_RE_CALL length(const char_type* p)
{
return std::strlen(p);
}
static unsigned int BOOST_RE_CALL syntax_type(size_type c)
{
return syntax_map[c];
}
static char BOOST_RE_CALL translate(char c, bool icase)
{
return icase ? lower_case_map[(size_type)(uchar_type)c] : c;
}
static void BOOST_RE_CALL transform(std::string& out, const std::string& in);
static void BOOST_RE_CALL transform_primary(std::string& out, const std::string& in);
static bool BOOST_RE_CALL is_separator(char c)
{
return BOOST_RE_MAKE_BOOL((c == '\n') || (c == '\r'));
}
static bool BOOST_RE_CALL is_combining(char)
{
return false;
}
static bool BOOST_RE_CALL is_class(char c, boost::uint_fast32_t f)
{
return BOOST_RE_MAKE_BOOL(class_map[(size_type)(uchar_type)c] & f);
}
static int BOOST_RE_CALL toi(char c);
static int BOOST_RE_CALL toi(const char*& first, const char* last, int radix);
static boost::uint_fast32_t BOOST_RE_CALL lookup_classname(const char* first, const char* last)
{
std::string s(first, last);
return do_lookup_class(s.c_str());
}
static bool BOOST_RE_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_RE_CALL imbue(locale_type l){ return l; }
locale_type BOOST_RE_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_RE_CALL update();
w32_regex_traits();
~w32_regex_traits();
private:
static w32_regex_traits<char> i;
};
#ifndef BOOST_RE_NO_WCSTRING
template<>
class BOOST_RE_IX_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_RE_CALL length(const char_type* p)
{
return std::wcslen(p);
}
static unsigned int BOOST_RE_CALL syntax_type(size_type c);
static wchar_t BOOST_RE_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_RE_CALL transform(std::basic_string<wchar_t>& out, const std::basic_string<wchar_t>& in);
static void BOOST_RE_CALL transform_primary(std::basic_string<wchar_t>& out, const std::basic_string<wchar_t>& in);
static bool BOOST_RE_CALL is_separator(wchar_t c)
{
return BOOST_RE_MAKE_BOOL((c == L'\n') || (c == L'\r') || (c == (wchar_t)0x2028) || (c == (wchar_t)0x2029));
}
static bool BOOST_RE_CALL is_combining(wchar_t c)
{ return re_detail::is_combining(c); }
static bool BOOST_RE_CALL is_class(wchar_t c, boost::uint_fast32_t f)
{
return BOOST_RE_MAKE_BOOL(((uchar_type)c < 256) ? (wide_unicode_classes[(size_type)(uchar_type)c] & f) : do_iswclass(c, f));
}
static int BOOST_RE_CALL toi(wchar_t c);
static int BOOST_RE_CALL toi(const wchar_t*& first, const wchar_t* last, int radix);
static boost::uint_fast32_t BOOST_RE_CALL lookup_classname(const wchar_t* first, const wchar_t* last);
static bool BOOST_RE_CALL lookup_collatename(std::basic_string<wchar_t>& s, const wchar_t* first, const wchar_t* last);
static locale_type BOOST_RE_CALL imbue(locale_type l){ return l; }
locale_type BOOST_RE_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_RE_CALL update();
w32_regex_traits();
~w32_regex_traits();
static unsigned int BOOST_RE_CALL strnarrow(char *s1, unsigned int len, const wchar_t *s2);
static unsigned int BOOST_RE_CALL strwiden(wchar_t *s1, unsigned int len, const char *s2);
private:
static bool BOOST_RE_CALL do_iswclass(wchar_t c, boost::uint_fast32_t f);
static bool BOOST_RE_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_RE_CALL wtolower(wchar_t c);
static unsigned short wide_unicode_classes[];
};
#endif // Wide strings
#endif // Win32
#ifndef BOOST_RE_NO_LOCALE_H
} // namspace boost
#include <locale>
namespace boost{
namespace re_detail
{
template <class charT>
struct message_data;
template <>
struct message_data<char>;
template <>
struct message_data<wchar_t>;
struct BOOST_RE_IX_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_RE_CALL set_message_catalogue(const std::string& s);
protected:
static char regex_message_cat[200];
};
} // namespace re_detail
template <class charT>
class cpp_regex_traits;
template<>
class BOOST_RE_IX_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_RE_CALL length(const char_type* p)
{
return std::strlen(p);
}
unsigned int BOOST_RE_CALL syntax_type(size_type c)const
{
return psyntax[c];
}
char BOOST_RE_CALL translate(char c, bool icase)const
{
return icase ? lower_map[(size_type)(uchar_type)c] : c;
}
void BOOST_RE_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_RE_CALL transform_primary(std::string& out, const std::string& in)const;
static bool BOOST_RE_CALL is_separator(char c)
{
return BOOST_RE_MAKE_BOOL((c == '\n') || (c == '\r'));
}
static bool BOOST_RE_CALL is_combining(char)
{
return false;
}
bool BOOST_RE_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_RE_CALL toi(char c)const;
int BOOST_RE_CALL toi(const char*& first, const char* last, int radix)const;
boost::uint_fast32_t BOOST_RE_CALL lookup_classname(const char* first, const char* last)const;
bool BOOST_RE_CALL lookup_collatename(std::string& s, const char* first, const char* last)const;
std::string BOOST_RE_CALL error_string(unsigned id)const;
locale_type BOOST_RE_CALL imbue(locale_type l);
locale_type BOOST_RE_CALL BOOST_RE_CALL getloc()const{ return locale_inst; }
struct sentry
{
sentry(const cpp_regex_traits<char>&){}
operator void*() { return this; }
};
};
#ifndef BOOST_RE_NO_WCSTRING
template<>
class BOOST_RE_IX_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_RE_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_RE_CALL length(const char_type* p)
{
return std::wcslen(p);
}
unsigned int BOOST_RE_CALL syntax_type(size_type c)const
{
return (c < UCHAR_MAX) ? psyntax[c] : do_syntax_type(c);
}
wchar_t BOOST_RE_CALL translate(wchar_t c, bool icase)const
{
return icase ? (((uchar_type)c) <= UCHAR_MAX) ? lower_map[c] : pctype->tolower(c) : c;
}
void BOOST_RE_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_RE_CALL transform_primary(std::basic_string<wchar_t>& out, const std::basic_string<wchar_t>& in)const;
static bool BOOST_RE_CALL is_separator(wchar_t c)
{
return BOOST_RE_MAKE_BOOL((c == L'\n') || (c == L'\r') || (c == (wchar_t)0x2028) || (c == (wchar_t)0x2029));
}
static bool BOOST_RE_CALL is_combining(wchar_t c)
{ return re_detail::is_combining(c); }
bool BOOST_RE_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) && (c > (size_type)(uchar_type)255))
return true;
return false;
}
int BOOST_RE_CALL toi(wchar_t c)const;
int BOOST_RE_CALL toi(const wchar_t*& first, const wchar_t* last, int radix)const;
boost::uint_fast32_t BOOST_RE_CALL lookup_classname(const wchar_t* first, const wchar_t* last)const;
bool BOOST_RE_CALL lookup_collatename(std::basic_string<wchar_t>& s, const wchar_t* first, const wchar_t* last)const;
std::string BOOST_RE_CALL error_string(unsigned id)const;
cpp_regex_traits();
~cpp_regex_traits();
locale_type BOOST_RE_CALL imbue(locale_type l);
locale_type BOOST_RE_CALL getloc()const{ return locale_inst; }
unsigned int BOOST_RE_CALL strwiden(wchar_t *s1, unsigned int len, const char *s2)const;
struct sentry
{
sentry(const cpp_regex_traits<wchar_t>&){}
operator void*() { return this; }
};
};
#endif // BOOST_RE_NO_WCSTRING
#endif // BOOST_RE_NO_LOCALE_H
#ifdef BOOST_RE_LOCALE_W32
template <class charT>
class regex_traits : public w32_regex_traits<charT>
{
};
#elif defined(BOOST_RE_LOCALE_C)
template <class charT>
class regex_traits : public c_regex_traits<charT>
{
};
#elif defined(BOOST_RE_LOCALE_CPP)
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

View File

@ -1,48 +0,0 @@
/*
*
* 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.
*
*/
/*
* LOCATION: see http://www.boost.org for most recent version.
* FILE src.cpp
* VERSION 3.11
* 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_RE_NO_LIB, or include this file
* before any other regex header.
*/
#if !defined(BOOST_RE_NO_LIB) && defined(BOOST_REGEX_CONFIG_HPP)
#error too late you have already included a regex header - try defining BOOST_RE_NO_LIB when you build
#endif
//
// include library source files:
//
#ifdef BOOST_RE_LOCALE_W32
#include "libs/regex/src/w32_regex_traits.cpp"
#elif defined(BOOST_RE_LOCALE_C)
#include "libs/regex/src/c_regex_traits.cpp"
#else
#include "libs/regex/src/cpp_regex_traits.cpp"
#endif
#include "libs/regex/src/c_regex_traits_common.cpp"
#include "libs/regex/src/cregex.cpp"
#include "libs/regex/src/fileiter.cpp"
#include "libs/regex/src/posix_api.cpp"
#include "libs/regex/src/wide_posix_api.cpp"
#include "libs/regex/src/regex.cpp"
#include "libs/regex/src/regex_debug.cpp"
#include "libs/regex/src/regex_synch.cpp"

View File

@ -0,0 +1,40 @@
/*
*
* 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/libs/regex for documentation.
* FILE regex_fwd.cpp
* VERSION see <boost/version.hpp>
* DESCRIPTION: Forward declares boost::reg_expression<> and
* associated typedefs.
*/
#ifndef BOOST_REGEX_FWD_HPP
#define BOOST_REGEX_FWD_HPP
#ifndef BOOST_REGEX_CONFIG_HPP
#include <boost/regex/config.hpp>
#endif
#ifdef BOOST_REGEX_V3
#include <boost/regex/v3/regex_fwd.hpp>
#else
#include <boost/regex/v4/regex_fwd.hpp>
#endif
#endif

141
index.htm
View File

@ -1,141 +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" width="50%"><h3><img
src="../../c++boost.gif" alt="C++ Boost" width="277"
height="86"></h3>
</td>
<td valign="top" width="50%"><h3 align="center">Regex++,
Index.</h3>
<p><i>(version 3.12, 18 April 2000)</i> </p>
<pre><i>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.&nbsp; Dr John Maddock makes no representations
about the suitability of this software for any purpose.&nbsp;&nbsp;
It is provided &quot;as is&quot; without express or implied warranty.</i></pre>
</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>

View File

@ -1,503 +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="624">
<tr>
<td valign="top" width="50%"><h3><img
src="../../c++boost.gif" alt="C++ Boost" width="276"
height="86"></h3>
</td>
<td valign="top" width="50%"><h3 align="center">Regex++,
Introduction.</h3>
<p><i>(version 3.12, 18 April 2000)</i> </p>
<pre><i>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.&nbsp; Dr John Maddock makes no representations
about the suitability of this software for any purpose.&nbsp;&nbsp;
It is provided &quot;as is&quot; without express or implied warranty.</i></pre>
</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</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.</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 two 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;
}</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>Currently the library will automatically detect and configure
itself for Borland, Microsoft, GNU, SGI, Kai, Compaq, Sun and HP
compilers. The library will also detect the HP, SGI, Rogue Wave,
or Microsoft STL implementations. If the STL type is detected,
then the library will attempt to extract suitable compiler
configuration options from the STL used. Otherwise the library
will assume that the compiler is fully compliant with the C++
standard: unless various options are defined to depreciate
features not implemented by your compiler. These options are
documented in &lt;boost/regex/detail/regex_options.hpp&gt;, if
you want to add permanent configuration options add them to
&lt;boost/regex/detail/regex_options.hpp&gt; which is provided
for this purpose - this will allow you to keep your configuration
options between library versions by retaining &lt;boost/regex/detail/regex_options.hpp&gt;.
</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 bcc55.mak for the 5.5
command line tools). </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. <br>
&nbsp; <br>
&nbsp; </p>
<p><b>Microsoft Visual C++ 6</b> </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_RE_STATIC_LIB
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_RE_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, 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, then use the vc6-stlport.mak
file provided (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/regex, this will enable things like
multithreading/wide character/nls support if they are not enabled
by default on your platform. When the configure script completes,
run one of the makefiles described above.</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>Run configure, this will set up the headers and generate
makefiles: from the command prompt change to the &lt;boost&gt;/libs/regex
directory and type: </p>
<pre><tt>./configure
make</tt></pre>
<p>Other make options include: </p>
<p>make jgrep: builds the jgrep demo. </p>
<p>make test: builds and runs the regression tests. </p>
<p>make timer: builds the timer demo program. </p>
<p>Note that the configure generated makefiles produce only a
static library, if you would prefer to build a shared library,
then there is a generic.mak makefile in the &lt;boost&gt;/libs/regex/build
directory. To use this you will need to set up a number of
environment variables first (see the makefile for more details).
Finally if you use one of the following compilers: Kai C++, SGI
Irix C++, Compaq true64 C++, or Como C++, then you should not
need to run the configure script to get the library to build,
however doing so may enable optional features (multithreading
support, and/or nls support).</p>
<p><b>Troubleshooting:</b> </p>
<p>If make fails after running configure, you may need to
manually disable some options: configure uses simple tests to
determine what features your compiler supports, it does not
stress the compiler's internals to any degree as the actual regex++
code can do. Other compiler features may be implemented (and
therefore detected by configure) but known to be buggy, again in
this case it may be necessary to disable the feature in order to
compile regex++ to stable code. The output file from configure is
&lt;boost&gt;/boost/regex/detail/regex_options.hpp, this file
lists all the macros that can be defined to configure regex++
along with a description to illustrate their usage, experiment
changing options in regex_options.hpp one at a time until you
achieve the effect you require. If you mail me questions about
configure output, be sure to include both regex_options.hpp and
config.log with your message. </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>

146
jm_opt.in
View File

@ -1,146 +0,0 @@
#ifndef BOOST_RE_OPT_H
#define BOOST_RE_OPT_H
#undef BOOST_RE_AUTO_CONFIGURE
#ifdef BOOST_RE_AUTO_CONFIGURE
/* Compiler options: */
/* BOOST_NO_STDC_NAMESPACE C library not in namespace std */
#undef BOOST_NO_STDC_NAMESPACE
/* BOOST_RE_PLATFORM_W32 Platform is MS Win32 */
#undef BOOST_RE_PLATFORM_W32
/* BOOST_RE_NO_W32 Disable Win32 support even when present */
#undef BOOST_RE_NO_W32
/* BOOST_RE_NO_BOOL If bool is not a distict type. */
#undef BOOST_RE_NO_BOOL
/* BOOST_RE_NO_WCHAR_H If there is no <wchar.h> */
#undef BOOST_RE_NO_WCHAR_H
/* BOOST_RE_NO_WCTYPE_H If there is no <wctype.h> */
#undef BOOST_RE_NO_WCTYPE_H
/* BOOST_RE_NO_WCSTRING If there are no wcslen and wcsncmp functions available. */
#undef BOOST_RE_NO_WCSTRING
/* BOOST_RE_NO_SWPRINTF If there is no swprintf available. */
#undef BOOST_RE_NO_SWPRINTF
/* BOOST_RE_NO_WSPRINTF If there is no wsprintf available. */
#undef BOOST_RE_NO_WSPRINTF
/* BOOST_NO_MEMBER_TEMPLATES If member function templates or nested template classes are not allowed. */
#undef BOOST_NO_MEMBER_TEMPLATES
/* BOOST_RE_NO_TEMPLATE_RETURNS If template functions based on return type are not supported. */
#undef BOOST_RE_NO_TEMPLATE_RETURNS
/* BOOST_RE_NO_PARTIAL_FUNC_SPEC If partial template function specialisation is not supported */
#undef BOOST_RE_NO_PARTIAL_FUNC_SPEC
/* BOOST_RE_NO_CAT Define if the compiler does not support POSIX style
message categories (catopen catgets catclose). */
#undef BOOST_RE_NO_CAT
/* BOOST_RE_THREADS Define if the compiler supports multiple threads in
the current translation mode. */
#undef BOOST_RE_THREADS
/* BOOST_RE_NO_TEMPLATE_MERGE If template in separate translation units don't merge at link time */
#undef BOOST_RE_NO_TEMPLATE_MERGE
/* BOOST_RE_NO_TEMPLATE_MERGE_A If template merging from library archives is not supported */
#undef BOOST_RE_NO_TEMPLATE_MERGE_A
/* BOOST_RE_NO_TEMPLATE_SWITCH_MERGE If merging of templates containing switch statements is not supported */
#undef BOOST_RE_NO_TEMPLATE_SWITCH_MERGE
/* BOOST_RE_CALL Optionally define a calling convention for C++ functions */
#undef BOOST_RE_CALL
/* BOOST_RE_CCALL Optionally define a calling convention for C functions */
#undef BOOST_RE_CCALL
/* BOOST_RE_SIZEOF_SHORT sizeof(short) */
#undef BOOST_RE_SIZEOF_SHORT
/* BOOST_RE_SIZEOF_INT sizeof(int) */
#undef BOOST_RE_SIZEOF_INT
/* BOOST_RE_SIZEOF_LONG sizeof(long) */
#undef BOOST_RE_SIZEOF_LONG
/* BOOST_RE_SIZEOF_WCHAR_T sizeof(wchar_t) */
#undef BOOST_RE_SIZEOF_WCHAR_T
/* STL options: */
/* BOOST_RE_NO_ITERATOR_H Define if you do not have a version of <iterator>. */
#undef BOOST_RE_NO_ITERATOR_H
/* BOOST_NO_STD_ALLOCATOR Define if <memory> does not fully comply with the
latest standard, and is not auto-recognised,
that means nested template classes
which hardly any compilers support at present. */
#undef BOOST_NO_STD_ALLOCATOR
/* BOOST_RE_NO_LOCALE_H Define if there is no verion of the standard
<locale> header available. */
#undef BOOST_RE_NO_LOCALE_H
/* BOOST_RE_NO_STL Disables the use of any supporting STL code. */
#undef BOOST_RE_NO_STL
/* BOOST_RE_NO_NOT_EQUAL Disables the generation of operator!= if this
clashes with the STL version. */
/* BOOST_RE_NO_STRING_DEF_ARGS Define if std::basic_string<charT> not allowed - in
other words if the template is missing its required
default arguments. */
#undef BOOST_RE_NO_STRING_DEF_ARGS
/* BOOST_RE_USE_ALGO If <algo.h> not <algorithm> is present */
#undef BOOST_RE_USE_ALGO
/* BOOST_RE_OLD_IOSTREAM If the new iostreamm classes are not available */
#undef BOOST_RE_OLD_IOSTREAM
/* BOOST_NO_STD_DISTANCE If there is no std::distance. */
#undef BOOST_NO_STD_DISTANCE
/* BOOST_RE_NO_OI_ASSIGN If output iterators ostream_iterator<>, back_insert_iterator<> and
front_insert_iterator<> do not have assignment operators */
#undef BOOST_RE_NO_OI_ASSIGN
#include <stdexcept>
#ifndef BOOST_RE_NO_ITERATOR_H
#include <iterator>
#ifdef BOOST_RE_USE_ALGO
#include <algo.h>
#else
#include <algorithm>
#endif
#endif
#endif // BOOST_RE_AUTO_CONFIGURE
#endif /* BOOST_RE_OPT_H */

View File

@ -1,19 +0,0 @@
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.
Footnotes:
1) Localised versions may translate the above notice into the native
language of the version.
2) The above notice applies to source code and documentation, users
who are distributing only binary forms, need only indicate, somewhere
in their documentation or in their help|about notice that the product
uses this library and that the copyright is Dr John Maddock 1998-2000

View File

@ -1,29 +0,0 @@
ALL_DEP=@ac_all_dep@
base: ./build/libboost_regex.a
./build/libboost_regex.a: $(ALL_DEP)
sh dmi.sh build
jgrep : base
sh dmi.sh example/jgrep
test : base
sh dmi.sh test/regress
regress : test
timer : base
sh dmi.sh example/timer
install : base
echo no install option available
all : base jgrep test timer

File diff suppressed because it is too large Load Diff

View File

@ -1,3 +0,0 @@
#include <cregex.h>

View File

@ -1,129 +0,0 @@
/*
*
* 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.
*
*/
/*
* FILE cregex.h
* VERSION 2.21
* deprecated regular expression matching algorithms
*/
#ifndef BOOST_OLD_CREGEX_H
#define BOOST_OLD_CREGEX_H
#include <boost/cregex.hpp>
//
// macro defs:
#define JM_STD std
#define JM_CSTD std
#define JM jm
#ifdef BOOST_RE_OLD_IOSTREAM
#define JM_OLD_IOSTREAM
#endif
#ifdef __cplusplus
namespace jm = boost;
#if !defined(BOOST_RE_NO_USING)
using boost::regex_tA;
using boost::regex_t;
using boost::regoff_t;
using boost::regmatch_t;
using boost::regcompA;
using boost::regerrorA;
using boost::regexecA;
using boost::regfreeA;
#ifndef BOOST_RE_NO_WCSTRING
using boost::regex_tW;
using boost::regcompW;
using boost::regerrorW;
using boost::regexecW;
using boost::regfreeW;
#endif
using boost::RegEx;
using boost::GrepCallback;
using boost::GrepFileCallback;
using boost::FindFilesCallback;
using boost::match_flags;
using boost::reg_errcode_t;
using boost::REG_NOERROR;
using boost::REG_NOMATCH;
using boost::REG_BADPAT;
using boost::REG_ECOLLATE;
using boost::REG_ECTYPE;
using boost::REG_EESCAPE;
using boost::REG_ESUBREG;
using boost::REG_EBRACK;
using boost::REG_EPAREN;
using boost::REG_EBRACE;
using boost::REG_BADBR;
using boost::REG_ERANGE;
using boost::REG_ESPACE;
using boost::REG_BADRPT;
using boost::REG_EEND;
using boost::REG_ESIZE;
using boost::REG_ERPAREN;
using boost::REG_EMPTY;
using boost::REG_E_MEMORY;
using boost::REG_E_UNKNOWN;
using boost::match_default;
using boost::match_not_bol;
using boost::match_not_eol;
using boost::match_not_bob;
using boost::match_not_eob;
using boost::match_not_bow;
using boost::match_not_eow;
using boost::match_not_dot_newline;
using boost::match_not_dot_null;
using boost::match_prev_avail;
using boost::match_init;
using boost::match_any;
using boost::match_not_null;
using boost::match_continuous;
using boost::match_stop;
using boost::REG_BASIC;
using boost::REG_EXTENDED;
using boost::REG_ICASE;
using boost::REG_NOSUB;
using boost::REG_NEWLINE;
using boost::REG_NOSPEC;
using boost::REG_PEND;
using boost::REG_DUMP;
using boost::REG_NOCOLLATE;
using boost::REG_ASSERT;
using boost::REG_INVARG;
using boost::REG_ATOI;
using boost::REG_ITOA;
using boost::REG_NOTBOL;
using boost::REG_NOTEOL;
using boost::REG_STARTEND;
#endif // BOOST_RE_NO_USING
#endif // __cplusplus
#ifdef BOOST_RE_USING_HACK
using namespace boost;
#endif
#endif // include guard

View File

@ -1,25 +0,0 @@
/*
*
* 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.
*
*/
#ifndef BOOST_FILEITER_H
#define BOOST_FILEITER_H
#include <boost/regex/detail/fileiter.hpp>
using boost::re_detail::directory_iterator;
using boost::re_detail::file_iterator;
using boost::re_detail::mapfile;
#endif

View File

@ -1,3 +0,0 @@
#include <regex.h>

View File

@ -1,481 +0,0 @@
/*
*
* 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.
*
*/
/*
* FILE regex.h
* VERSION 2.21
* deprecated regular expression matching algorithms
*/
#ifndef BOOST_OLD_REGEX_H
#define BOOST_OLD_REGEX_H
#include <cregex.h>
#include <boost/regex.hpp>
namespace boost{
namespace deprecated{
//
// class reg_match:
// old name for match_results, this ones just a thin wrapper:
//
template <class iterator, class Allocator BOOST_RE_DEF_ALLOC_PARAM(typename boost::re_detail::def_alloc_param_traits<iterator>::type)>
class reg_match : public boost::match_results<iterator, Allocator>
{
typedef boost::match_results<iterator, Allocator> base_type;
typedef boost::re_detail::match_results_base<iterator, Allocator> ancestor;
public:
reg_match(const Allocator& a = Allocator())
: base_type(a){}
reg_match(const ancestor& m)
: base_type(m){}
reg_match& operator=(const ancestor& m)
{
// shallow copy
ancestor::operator=(m);
return *this;
}
reg_match(const base_type& m)
: base_type(m){}
reg_match& operator=(const base_type& m)
{
// deep copy
base_type::operator=(m);
return *this;
}
};
//
// proc query_match
// returns true if the specified regular expression matches
// at position first. Fills in what matched in m.
//
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);
}
//
// query_match convenience interfaces:
#ifndef BOOST_RE_NO_PARTIAL_FUNC_SPEC
//
// this isn't really a partial specialisation, but template function
// overloading - if the compiler doesn't support partial specialisation
// then it really won't support this either:
template <class charT, class Allocator, class traits, class Allocator2>
inline bool query_match(const charT* str,
boost::match_results<const charT*, Allocator>& m,
const reg_expression<charT, traits, Allocator2>& e,
unsigned flags = match_default)
{
return query_match(str, str + traits::length(str), m, e, flags);
}
template <class ST, class SA, class Allocator, class charT, class traits, class Allocator2>
inline bool query_match(const std::basic_string<charT, ST, SA>& s,
boost::match_results<typename std::basic_string<charT, ST, SA>::const_iterator, Allocator>& m,
const reg_expression<charT, traits, Allocator2>& e,
unsigned flags = match_default)
{
return query_match(s.begin(), s.end(), m, e, flags);
}
#else // partial ordering
inline bool query_match(const char* str,
cmatch& m,
const regex& e,
unsigned flags = match_default)
{
return query_match(str, str + regex::traits_type::length(str), m, e, flags);
}
#ifndef BOOST_RE_NO_WCSTRING
inline bool query_match(const wchar_t* str,
wcmatch& m,
const wregex& e,
unsigned flags = match_default)
{
return query_match(str, str + wregex::traits_type::length(str), m, e, flags);
}
#endif
inline bool query_match(const std::string& s,
boost::match_results<std::string::const_iterator, regex::allocator_type>& m,
const regex& e,
unsigned flags = match_default)
{
return query_match(s.begin(), s.end(), m, e, flags);
}
#if !defined(BOOST_RE_NO_WCSTRING)
inline bool query_match(const std::basic_string<wchar_t>& s,
boost::match_results<std::basic_string<wchar_t>::const_iterator, wregex::allocator_type>& m,
const wregex& e,
unsigned flags = match_default)
{
return query_match(s.begin(), s.end(), m, e, flags);
}
#endif
#endif
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());
}
//
// reg_search convenience interfaces:
#ifndef BOOST_RE_NO_PARTIAL_FUNC_SPEC
//
// this isn't really a partial specialisation, but template function
// overloading - if the compiler doesn't support partial specialisation
// then it really won't support this either:
template <class charT, class Allocator, class traits, class Allocator2>
inline bool reg_search(const charT* str,
boost::match_results<const charT*, Allocator>& m,
const reg_expression<charT, traits, Allocator2>& e,
unsigned flags = match_default)
{
return reg_search(str, str + traits::length(str), m, e, flags);
}
#ifndef BOOST_RE_NO_STRING_H
template <class ST, class SA, class Allocator, class charT, class traits, class Allocator2>
inline bool reg_search(const std::basic_string<charT, ST, SA>& s,
boost::match_results<typename std::basic_string<charT, ST, SA>::const_iterator, Allocator>& m,
const reg_expression<charT, traits, Allocator2>& e,
unsigned flags = match_default)
{
return reg_search(s.begin(), s.end(), m, e, flags);
}
#endif
#else // partial specialisation
inline bool reg_search(const char* str,
cmatch& m,
const regex& e,
unsigned flags = match_default)
{
return reg_search(str, str + regex::traits_type::length(str), m, e, flags);
}
#ifndef BOOST_RE_NO_WCSTRING
inline bool reg_search(const wchar_t* str,
wcmatch& m,
const wregex& e,
unsigned flags = match_default)
{
return reg_search(str, str + wregex::traits_type::length(str), m, e, flags);
}
#endif
#ifndef BOOST_RE_NO_STRING_H
inline bool reg_search(const std::string& s,
boost::match_results<std::string::const_iterator, regex::allocator_type>& m,
const regex& e,
unsigned flags = match_default)
{
return reg_search(s.begin(), s.end(), m, e, flags);
}
#if !defined(BOOST_RE_NO_STRING_DEF_ARGS) && !defined(BOOST_RE_NO_WCSTRING)
inline bool reg_search(const std::basic_string<wchar_t>& s,
boost::match_results<std::basic_string<wchar_t>::const_iterator, wregex::allocator_type>& m,
const wregex& e,
unsigned flags = match_default)
{
return reg_search(s.begin(), s.end(), m, e, flags);
}
#endif
#endif
#endif
//
// reg_grep:
// find all non-overlapping matches within the sequence first last:
//
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());
}
//
// reg_grep convenience interfaces:
#ifndef BOOST_RE_NO_PARTIAL_FUNC_SPEC
//
// this isn't really a partial specialisation, but template function
// overloading - if the compiler doesn't support partial specialisation
// then it really won't support this either:
template <class Predicate, class charT, class Allocator, class traits>
inline unsigned int reg_grep(Predicate foo, const charT* str,
const reg_expression<charT, traits, Allocator>& e,
unsigned flags = match_default)
{
return reg_grep(foo, str, str + traits::length(str), e, flags);
}
#ifndef BOOST_RE_NO_STRING_H
template <class Predicate, class ST, class SA, class Allocator, class charT, class traits>
inline unsigned int reg_grep(Predicate foo, const std::basic_string<charT, ST, SA>& s,
const reg_expression<charT, traits, Allocator>& e,
unsigned flags = match_default)
{
return reg_grep(foo, s.begin(), s.end(), e, flags);
}
#endif
#else // partial specialisation
inline unsigned int reg_grep(bool (*foo)(const cmatch&), const char* str,
const regex& e,
unsigned flags = match_default)
{
return reg_grep(foo, str, str + regex::traits_type::length(str), e, flags);
}
#ifndef BOOST_RE_NO_WCSTRING
inline unsigned int reg_grep(bool (*foo)(const wcmatch&), const wchar_t* str,
const wregex& e,
unsigned flags = match_default)
{
return reg_grep(foo, str, str + wregex::traits_type::length(str), e, flags);
}
#endif
#ifndef BOOST_RE_NO_STRING_H
inline unsigned int reg_grep(bool (*foo)(const boost::match_results<std::string::const_iterator, regex::allocator_type>&), const std::string& s,
const regex& e,
unsigned flags = match_default)
{
return reg_grep(foo, s.begin(), s.end(), e, flags);
}
#if !defined(BOOST_RE_NO_STRING_DEF_ARGS) && !defined(BOOST_RE_NO_WCSTRING)
inline unsigned int reg_grep(bool (*foo)(const boost::match_results<std::basic_string<wchar_t>::const_iterator, wregex::allocator_type>&),
const std::basic_string<wchar_t>& s,
const wregex& e,
unsigned flags = match_default)
{
return reg_grep(foo, s.begin(), s.end(), e, flags);
}
#endif
#endif
#endif
//
// finally for compatablity with version 1.x of the library
// we need a form of reg_grep that takes an output iterator
// as its first argument:
//
//
// struct grep_match:
// stores what matched during a reg_grep,
// the output iterator type passed to reg_grep must have an
// operator*() that returns a type with an
// operator=(const grep_match<iterator, Allocator>&);
//
template <class iterator, class Allocator>
struct grep_match
{
unsigned int line;
iterator line_start;
reg_match<iterator, Allocator> what;
grep_match(Allocator a = Allocator()) : what(a) {}
grep_match(unsigned int l, iterator p1, const boost::match_results<iterator, Allocator>& m)
: what(m) { line = l; line_start = p1; }
bool operator == (const grep_match& )
{ return false; }
bool operator < (const grep_match&)
{ return false; }
};
namespace re_detail{
template <class O, class I, class A>
struct grep_adaptor
{
O oi;
reg_match<I, A> m;
grep_adaptor(O i, A a) : m(a), oi(i) {}
bool operator()(const boost::re_detail::match_results_base<I, A>& w)
{
m.what = w;
m.line = w.line();
m.line_start = w.line_start();
*oi = m;
++oi;
return true;
}
};
} // namespace re_detail
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());
}
template <class OutputIterator, class iterator, class Allocator, class charT>
OutputIterator BOOST_RE_CALL reg_format(OutputIterator out,
const boost::match_results<iterator, Allocator>& m,
const charT* fmt)
{
//
// start by updating the locale:
//
return boost::re_detail::_reg_format_aux(out, m, fmt, 0);
}
#ifndef BOOST_RE_NO_STRING_DEF_ARGS
template <class iterator, class Allocator, class charT>
std::basic_string<charT> BOOST_RE_CALL reg_format(const boost::match_results<iterator, Allocator>& m, const charT* fmt)
{
std::basic_string<charT> result;
boost::re_detail::string_out_iterator<std::basic_string<charT> > i(result);
reg_format(i, m, fmt);
return result;
}
#elif !defined(BOOST_RE_NO_STRING_H)
template <class iterator, class Allocator>
std::string BOOST_RE_CALL reg_format(const boost::match_results<iterator, Allocator>& m, const char* fmt)
{
std::string result;
boost::re_detail::string_out_iterator<std::string> i(result);
reg_format(i, m, fmt);
return result;
}
#endif
template <class OutputIterator, class iterator, class traits, class Allocator, class charT>
OutputIterator BOOST_RE_CALL reg_merge(OutputIterator out,
iterator first,
iterator last,
const reg_expression<charT, traits, Allocator>& e,
const charT* fmt,
bool copy = true,
unsigned int flags = match_default)
{
//
// start by updating the locale:
//
iterator l = first;
if(!copy) flags |= format_no_copy;
boost::re_detail::merge_out_predicate<OutputIterator, iterator, charT, Allocator, traits> oi(out, l, fmt, flags, e.get_traits());
regex_grep(oi, first, last, e, flags);
return copy ? boost::re_detail::re_copy_out(out, l, last) : out;
}
#ifndef BOOST_RE_NO_STRING_DEF_ARGS
template <class traits, class Allocator, class charT>
std::basic_string<charT> BOOST_RE_CALL reg_merge(const std::basic_string<charT>& s,
const reg_expression<charT, traits, Allocator>& e,
const charT* fmt,
bool copy = true,
unsigned int flags = match_default)
{
std::basic_string<charT> result;
boost::re_detail::string_out_iterator<std::basic_string<charT> > i(result);
reg_merge(i, s.begin(), s.end(), e, fmt, copy, flags);
return result;
}
#elif !defined(BOOST_RE_NO_STRING_H)
template <class traits, class Allocator>
std::string BOOST_RE_CALL reg_merge(const std::string& s,
const reg_expression<char, traits, Allocator>& e,
const char* fmt,
bool copy = true,
unsigned int flags = match_default)
{
std::string result;
boost::re_detail::string_out_iterator<std::string> i(result);
reg_merge(i, s.begin(), s.end(), e, fmt, copy, flags);
return result;
}
#endif
} // namespace deprecated
using deprecated::query_match;
using deprecated::reg_search;
using deprecated::reg_grep;
using deprecated::reg_format;
using deprecated::reg_merge;
using re_detail::jm_def_alloc;
using deprecated::char_regex_traits_i;
using re_detail::re_alloc_binder;
using re_detail::padding_size;
} // namspace boost
namespace jm = boost;
#if !defined(BOOST_RE_NO_NAMESPACES) && !defined(BOOST_RE_NO_USING)
using boost::bad_expression;
template<class charT>
struct char_regex_traits : boost::regex_traits<charT>{};
using boost::deprecated::char_regex_traits_i;
using boost::regbase;
using boost::reg_expression;
using boost::deprecated::reg_match;
//using boost::reg_match_base;
using boost::sub_match;
using boost::regex;
using boost::cmatch;
#ifndef BOOST_RE_NO_WCSTRING
using boost::wregex;
using boost::wcmatch;
#endif
using boost::deprecated::reg_match;
using boost::deprecated::query_match;
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;
#endif
#ifdef BOOST_RE_USING_HACK
using namespace boost;
using namespace boost::deprecated;
#endif
#endif

View File

@ -1,62 +0,0 @@
#include <stdlib.h>
#include <string>
#include <iostream>
#include <regex>
using namespace std;
regex expression("^([0-9]+)(\\-| |$)(.*)$");
// process_ftp:
// on success returns the ftp response code, and fills
// msg with the ftp response message.
int process_ftp(const char* response, std::string* msg)
{
cmatch what;
if(query_match(response, response + strlen(response), what, expression))
{
// what[0] contains the whole string
// what[1] contains the response code
// what[2] contains the separator character
// what[3] contains the text message.
if(msg)
msg->assign(what[3].first, what[3].second);
return atoi(what[1].first);
}
// failure did not match
if(msg)
msg->erase();
return -1;
}
int main()
{
std::string in, out;
while(true)
{
cout << "enter test string" << endl;
std::getline(cin, in);
if(in == "quit")
break;
int result;
result = process_ftp(in.c_str(), &out);
if(result != -1)
{
cout << "Match found:" << endl;
cout << "Response code: " << result << endl;
cout << "Message text: " << out << endl;
}
else
{
cout << "Match not found" << endl;
}
cout << endl;
}
return 0;
}

View File

@ -1,69 +0,0 @@
#include <string>
#include <map>
#include <regex>
// purpose:
// takes the contents of a file in the form of a string
// and searches for all the C++ class definitions, storing
// their locations in a map of strings/int's
typedef std::map<std::string, int, std::less<std::string> > map_type;
regex expression("^(template[[:space:]]*<[^;:{]+>[[:space:]]*)?(class|struct)[[:space:]]*(\\<\\w+\\>([[:blank:]]*\\([^)]*\\))?[[:space:]]*)*(\\<\\w*\\>)[[:space:]]*(<[^;:{]+>[[:space:]]*)?(\\{|:[^;\\{()]*\\{)");
void IndexClasses(map_type& m, const std::string& file)
{
std::string::const_iterator start, end;
start = file.begin();
end = file.end();
reg_match<std::string::const_iterator> what;
unsigned int flags = match_default;
while(reg_search(start, end, what, expression, flags))
{
// what[0] contains the whole string
// what[5] contains the class name.
// what[6] contains the template specialisation if any.
// add class name and position to map:
m[std::string(what[5].first, what[5].second) + std::string(what[6].first, what[6].second)] =
what[5].first - file.begin();
// update search position:
start = what[0].second;
// update flags:
flags |= match_prev_avail;
flags |= ~match_not_bob;
}
}
#include <fileiter.h>
#include <iostream>
using namespace std;
int main(int argc, const char** argv)
{
for(int i = 1; i < argc; ++i)
{
cout << "Processing file " << argv[i] << endl;
map_type m;
mapfile f(argv[i]);
std::string text(f.begin(), f.end());
IndexClasses(m, text);
cout << m.size() << " matches found" << endl;
map_type::iterator c, d;
c = m.begin();
d = m.end();
while(c != d)
{
cout << "class \"" << (*c).first << "\" found at index: " << (*c).second << endl;
++c;
}
}
return 0;
}

View File

@ -1,70 +0,0 @@
#include <string>
#include <map>
#include <regex>
// purpose:
// takes the contents of a file in the form of a string
// and searches for all the C++ class definitions, storing
// their locations in a map of strings/int's
typedef std::map<std::string, int, std::less<std::string> > map_type;
regex expression("^(template[[:space:]]*<[^;:{]+>[[:space:]]*)?(class|struct)[[:space:]]*(\\<\\w+\\>([[:blank:]]*\\([^)]*\\))?[[:space:]]*)*(\\<\\w*\\>)[[:space:]]*(<[^;:{]+>[[:space:]]*)?(\\{|:[^;\\{()]*\\{)");
class IndexClassesPred
{
map_type& m;
std::string::const_iterator base;
public:
IndexClassesPred(map_type& a, std::string::const_iterator b) : m(a), base(b) {}
bool operator()(const reg_match<std::string::const_iterator, regex::alloc_type>& what)
{
// what[0] contains the whole string
// what[5] contains the class name.
// what[6] contains the template specialisation if any.
// add class name and position to map:
m[std::string(what[5].first, what[5].second) + std::string(what[6].first, what[6].second)] =
what[5].first - base;
return true;
}
};
void IndexClasses(map_type& m, const std::string& file)
{
std::string::const_iterator start, end;
start = file.begin();
end = file.end();
reg_grep(IndexClassesPred(m, start), start, end, expression, match_default);
}
#include <fileiter.h>
#include <iostream>
using namespace std;
int main(int argc, const char** argv)
{
for(int i = 1; i < argc; ++i)
{
cout << "Processing file " << argv[i] << endl;
map_type m;
mapfile f(argv[i]);
std::string text(f.begin(), f.end());
IndexClasses(m, text);
cout << m.size() << " matches found" << endl;
map_type::iterator c, d;
c = m.begin();
d = m.end();
while(c != d)
{
cout << "class \"" << (*c).first << "\" found at index: " << (*c).second << endl;
++c;
}
}
return 0;
}

View File

@ -1,90 +0,0 @@
#include <iostream>
#include <fstream>
#include <sstream>
#include <string>
#include <iterator>
#include <regex>
#include <fileiter.h>
// purpose:
// takes the contents of a file and transform to
// syntax highlighted code in html format
regex e1, e2;
extern const char* expression_text;
extern const char* format_string;
extern const char* pre_expression;
extern const char* pre_format;
extern const char* header_text;
extern const char* footer_text;
int main(int argc, const char** argv)
{
e1.set_expression(expression_text);
e2.set_expression(pre_expression);
for(int i = 1; i < argc; ++i)
{
std::cout << "Processing file " << argv[i] << std::endl;
mapfile in(argv[i]);
std::string out_name(std::string(argv[i]) + std::string(".htm"));
std::ofstream os(out_name.c_str());
os << header_text;
// strip '<' and '>' first by outputting to a
// temporary string stream
std::ostringstream t(std::ios::out | std::ios::binary);
std::ostream_iterator<char, char> oi(t);
reg_merge(oi, in.begin(), in.end(), e2, pre_format, true);
// then output to final output stream
// adding syntax highlighting:
std::string s(t.str());
std::ostream_iterator<char, char> out(os);
reg_merge(out, s.begin(), s.end(), e1, format_string, true);
os << footer_text;
}
return 0;
}
extern const char* pre_expression = "(<)|(>)|\\r";
extern const char* pre_format = "(?1&lt;)(?2&gt;)";
const char* expression_text = // preprocessor directives: index 1
"(^[[:blank:]]*#([^\\n]*\\\\[[:space:]]+)*[^\\n]*)|"
// comment: index 3
"(//[^\\n]*|/\\*([^*]|\\*+[^*/])*\\*+/)|"
// literals: index 5
"\\<([+-]?((0x[[:xdigit:]]+)|(([[:digit:]]*\\.)?[[:digit:]]+([eE][+-]?[[:digit:]]+)?))u?((int(8|16|32|64))|L)?)\\>|"
// string literals: index 14
"('([^\\\\']|\\\\.)*'|\"([^\\\\\"]|\\\\.)*\")|"
// keywords: index 17
"\\<(__asm|__cdecl|__declspec|__export|__far16|__fastcall|__fortran|__import"
"|__pascal|__rtti|__stdcall|_asm|_cdecl|__except|_export|_far16|_fastcall"
"|__finally|_fortran|_import|_pascal|_stdcall|__thread|__try|asm|auto|bool"
"|break|case|catch|cdecl|char|class|const|const_cast|continue|default|delete"
"|do|double|dynamic_cast|else|enum|explicit|extern|false|float|for|friend|goto"
"|if|inline|int|long|mutable|namespace|new|operator|pascal|private|protected"
"|public|register|reinterpret_cast|return|short|signed|sizeof|static|static_cast"
"|struct|switch|template|this|throw|true|try|typedef|typeid|typename|union|unsigned"
"|using|virtual|void|volatile|wchar_t|while)\\>"
;
const char* format_string = "(?1<font color=\"#008040\">$&</font>)"
"(?3<I><font color=\"#000080\">$&</font></I>)"
"(?5<font color=\"#0000A0\">$&</font>)"
"(?14<font color=\"#0000FF\">$&</font>)"
"(?17<B>$&</B>)";
const char* header_text = "<HTML>\n<HEAD>\n"
"<META HTTP-EQUIV=\"Content-Type\" CONTENT=\"text/html; charset=windows-1252\">\n"
"</HEAD>\n"
"<BODY LINK=\"#0000ff\" VLINK=\"#800080\" BGCOLOR=\"#ffff99\">\n"
"<PARA> </PARA>\n<PRE>";
const char* footer_text = "</PRE>\n</BODY>\n\n";

View File

@ -1,36 +0,0 @@
#include <string>
#include <map>
#include <regex>
// purpose:
// takes the contents of a file in the form of a string
// and searches for all the C++ class definitions, storing
// their locations in a map of strings/int's
typedef std::map<std::string, int, std::less<std::string> > map_type;
regex expression("^(template[[:space:]]*<[^;:{]+>[[:space:]]*)?(class|struct)[[:space:]]*(\\<\\w+\\>([[:blank:]]*\\([^)]*\\))?[[:space:]]*)*(\\<\\w*\\>)[[:space:]]*(<[^;:{]+>[[:space:]]*)?(\\{|:[^;\\{()]*\\{)");
map_type class_index;
std::string::const_iterator base;
bool grep_callback(const reg_match<std::string::const_iterator, regex::alloc_type>& what)
{
// what[0] contains the whole string
// what[5] contains the class name.
// what[6] contains the template specialisation if any.
// add class name and position to map:
class_index[std::string(what[5].first, what[5].second) + std::string(what[6].first, what[6].second)] =
what[5].first - base;
return true;
}
void IndexClasses(const std::string& file)
{
std::string::const_iterator start, end;
start = file.begin();
end = file.end();
base = start;
reg_grep(grep_callback, start, end, expression, match_default);
}

View File

@ -1,85 +0,0 @@
#include <string>
#include <map>
#include <regex>
#include <functional>
// purpose:
// takes the contents of a file in the form of a string
// and searches for all the C++ class definitions, storing
// their locations in a map of strings/int's
typedef std::map<std::string, int, std::less<std::string> > map_type;
class class_index
{
jm::regex expression;
map_type index;
std::string::const_iterator base;
bool grep_callback(reg_match<std::string::const_iterator, regex::alloc_type> what);
public:
map_type& get_map() { return index; }
void IndexClasses(const std::string& file);
class_index()
: index(),
expression("^(template[[:space:]]*<[^;:{]+>[[:space:]]*)?"
"(class|struct)[[:space:]]*(\\<\\w+\\>([[:blank:]]*\\([^)]*\\))?"
"[[:space:]]*)*(\\<\\w*\\>)[[:space:]]*(<[^;:{]+>[[:space:]]*)?"
"(\\{|:[^;\\{()]*\\{)"
){}
};
bool class_index::grep_callback(reg_match<std::string::const_iterator, regex::alloc_type> what)
{
// what[0] contains the whole string
// what[5] contains the class name.
// what[6] contains the template specialisation if any.
// add class name and position to map:
index[std::string(what[5].first, what[5].second) + std::string(what[6].first, what[6].second)] =
what[5].first - base;
return true;
}
void class_index::IndexClasses(const std::string& file)
{
std::string::const_iterator start, end;
start = file.begin();
end = file.end();
base = start;
reg_grep(std::bind1st(std::mem_fun(&class_index::grep_callback), this),
start,
end,
expression,
match_default);
}
using namespace std;
#include <fileiter.h>
#include <iostream>
int main(int argc, const char** argv)
{
for(int i = 1; i < argc; ++i)
{
cout << "Processing file " << argv[i] << endl;
mapfile f(argv[i]);
std::string text(f.begin(), f.end());
class_index i;
i.IndexClasses(text);
cout << i.get_map().size() << " matches found" << endl;
map_type::iterator c, d;
c = i.get_map().begin();
d = i.get_map().end();
while(c != d)
{
cout << "class \"" << (*c).first << "\" found at index: " << (*c).second << endl;
++c;
}
}
return 0;
}

View File

@ -1,87 +0,0 @@
#include <string>
#include <map>
#include <regex>
#include <functional>
// purpose:
// takes the contents of a file in the form of a string
// and searches for all the C++ class definitions, storing
// their locations in a map of strings/int's
typedef std::map<std::string, int, std::less<std::string> > map_type;
class class_index
{
jm::regex expression;
map_type index;
std::string::const_iterator base;
typedef reg_match<std::string::const_iterator, regex::alloc_type> arg_type;
bool grep_callback(const reg_match<std::string::const_iterator, regex::alloc_type>& what);
public:
map_type& get_map() { return index; }
typedef bool (__closure* grep_callback_type)(const arg_type&);
void IndexClasses(const std::string& file);
class_index()
: index(),
expression("^(template[[:space:]]*<[^;:{]+>[[:space:]]*)?"
"(class|struct)[[:space:]]*(\\<\\w+\\>([[:blank:]]*\\([^)]*\\))?"
"[[:space:]]*)*(\\<\\w*\\>)[[:space:]]*(<[^;:{]+>[[:space:]]*)?"
"(\\{|:[^;\\{()]*\\{)"
){}
};
bool class_index::grep_callback(const reg_match<std::string::const_iterator, regex::alloc_type>& what)
{
// what[0] contains the whole string
// what[5] contains the class name.
// what[6] contains the template specialisation if any.
// add class name and position to map:
index[std::string(what[5].first, what[5].second) + std::string(what[6].first, what[6].second)] =
what[5].first - base;
return true;
}
void class_index::IndexClasses(const std::string& file)
{
std::string::const_iterator start, end;
start = file.begin();
end = file.end();
base = start;
class_index::grep_callback_type cl = &(this->grep_callback);
reg_grep(cl,
start,
end,
expression,
match_default);
}
using namespace std;
#include <fileiter.h>
#include <iostream>
int main(int argc, const char** argv)
{
for(int i = 1; i < argc; ++i)
{
cout << "Processing file " << argv[i] << endl;
mapfile f(argv[i]);
std::string text(f.begin(), f.end());
class_index i;
i.IndexClasses(text);
cout << i.get_map().size() << " matches found" << endl;
map_type::iterator c, d;
c = i.get_map().begin();
d = i.get_map().end();
while(c != d)
{
cout << "class \"" << (*c).first << "\" found at index: " << (*c).second << endl;
++c;
}
}
return 0;
}

View File

@ -1,277 +0,0 @@
<!DOCTYPE HTML PUBLIC "-//w3c//dtd html 4.0 transitional//en">
<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="Mozilla/4.5 [en] (Win98; I) [Netscape]">
<TITLE>Regex++, POSIX API Reference</TITLE>
</HEAD>
<BODY BGCOLOR="#FFFFFF" LINK="#0000FF" VLINK="#800080">
&nbsp; <TABLE BORDER="0" CELLSPACING="0" CELLPADDING="7" WIDTH="100%">
<TR>
<TD VALIGN="TOP" WIDTH="50%"> <H3>
<IMG SRC="../../c++boost.gif" HEIGHT="86" WIDTH="276" ALT="C++ Boost"></H3>
</TD>
<TD VALIGN="TOP" WIDTH="50%"> <CENTER>
<H3> Regex++, POSIX API Reference.</H3>
</CENTER>
<CENTER>
<I>(version 3.12, 18 April 2000)</I>
</CENTER>
<PRE><I>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.&nbsp; Dr John Maddock makes no representations
about the suitability of this software for any purpose.&nbsp;&nbsp;
It is provided &quot;as is&quot; without express or implied warranty.</I></PRE>
</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>
All the functions operate on structure <B>regex_t</B>, which exposes two public
members:
<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" CELLSPACING="0" CELLPADDING="7" 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>
<BR>
&nbsp; <P><B>regerror</B> takes the following parameters, it maps an error code
to a human readable string: <BR>
&nbsp; </P>
<TABLE BORDER="0" CELLSPACING="0" CELLPADDING="7" 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" CELLSPACING="0" CELLPADDING="7" 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>
<BR>
&nbsp; <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 <A HREF="mailto:John_Maddock@compuserve.com">Dr John
Maddock</A> 1998-2000 all rights reserved.</I> </P>
</BODY>
</HTML>

View File

@ -1,24 +0,0 @@
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.
************************************************************************
Full instructions for use of this library can be accessed from
libs/regex/index.htm
Installation instructions and library overview is are in
libs/regex/introduction.htm
This library is part of boost (see www.boost.org), the latest version
of the library is available from the boost web site, or development
snapshots from the boost cvs repository at
http://sourceforge.net/project/?group_id=7586

File diff suppressed because it is too large Load Diff

View File

@ -1,550 +0,0 @@
/*
*
* 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.
*
*/
/*
* LOCATION: see http://www.boost.org for most recent version.
* FILE: c_regex_traits_common.cpp
* VERSION: 3.12
* DESCRIPTION: Implements common code and data for the
* c_regex_traits<charT> traits classes.
*/
#include <clocale>
#include <cstdio>
#include <list>
#include <cctype>
#include <boost/regex/regex_traits.hpp>
#include <boost/regex/detail/regex_synch.hpp>
namespace boost{
namespace re_detail{
//
// these are the POSIX collating names:
//
BOOST_RE_IX_DECL const char* def_coll_names[] = {
"NUL", "SOH", "STX", "ETX", "EOT", "ENQ", "ACK", "alert", "backspace", "tab", "newline",
"vertical-tab", "form-feed", "carriage-return", "SO", "SI", "DLE", "DC1", "DC2", "DC3", "DC4", "NAK",
"SYN", "ETB", "CAN", "EM", "SUB", "ESC", "IS4", "IS3", "IS2", "IS1", "space", "exclamation-mark",
"quotation-mark", "number-sign", "dollar-sign", "percent-sign", "ampersand", "apostrophe",
"left-parenthesis", "right-parenthesis", "asterisk", "plus-sign", "comma", "hyphen",
"period", "slash", "zero", "one", "two", "three", "four", "five", "six", "seven", "eight", "nine",
"colon", "semicolon", "less-than-sign", "equals-sign", "greater-than-sign",
"question-mark", "commercial-at", "A", "B", "C", "D", "E", "F", "G", "H", "I", "J", "K", "L", "M", "N", "O", "P",
"Q", "R", "S", "T", "U", "V", "W", "X", "Y", "Z", "left-square-bracket", "backslash",
"right-square-bracket", "circumflex", "underscore", "grave-accent", "a", "b", "c", "d", "e", "f",
"g", "h", "i", "j", "k", "l", "m", "n", "o", "p", "q", "r", "s", "t", "u", "v", "w", "x", "y", "z", "left-curly-bracket",
"vertical-line", "right-curly-bracket", "tilde", "DEL", "",
};
// these multi-character collating elements
// should keep most Western-European locales
// happy - we should really localise these a
// little more - but this will have to do for
// now:
BOOST_RE_IX_DECL const char* def_multi_coll[] = {
"ae",
"Ae",
"AE",
"ch",
"Ch",
"CH",
"ll",
"Ll",
"LL",
"ss",
"Ss",
"SS",
"nj",
"Nj",
"NJ",
"dz",
"Dz",
"DZ",
"lj",
"Lj",
"LJ",
"",
};
BOOST_RE_IX_DECL bool BOOST_RE_CALL re_lookup_def_collate_name(std::string& buf, const char* name)
{
BOOST_RE_GUARD_STACK
unsigned int i = 0;
while(*def_coll_names[i])
{
if(std::strcmp(def_coll_names[i], name) == 0)
{
buf = (char)i;
return true;
}
++i;
}
i = 0;
while(*def_multi_coll[i])
{
if(std::strcmp(def_multi_coll[i], name) == 0)
{
buf = def_multi_coll[i];
return true;
}
++i;
}
return false;
}
//
// messages:
BOOST_RE_IX_DECL const char * re_default_error_messages[] =
{ "Success", /* REG_NOERROR */
"No match", /* REG_NOMATCH */
"Invalid regular expression", /* REG_BADPAT */
"Invalid collation character", /* REG_ECOLLATE */
"Invalid character class name", /* REG_ECTYPE */
"Trailing backslash", /* REG_EESCAPE */
"Invalid back reference", /* REG_ESUBREG */
"Unmatched [ or [^", /* REG_EBRACK */
"Unmatched ( or \\(", /* REG_EPAREN */
"Unmatched \\{", /* REG_EBRACE */
"Invalid content of \\{\\}", /* REG_BADBR */
"Invalid range end", /* REG_ERANGE */
"Memory exhausted", /* REG_ESPACE */
"Invalid preceding regular expression", /* REG_BADRPT */
"Premature end of regular expression", /* REG_EEND */
"Regular expression too big", /* REG_ESIZE */
"Unmatched ) or \\)", /* REG_ERPAREN */
"Empty expression", /* REG_EMPTY */
"Unknown error", /* REG_E_UNKNOWN */
"",
"",
"",
};
const mss default_messages[] = {
{ 100+ c_regex_traits<char>::syntax_open_bracket, "(", },
{ 100+ c_regex_traits<char>::syntax_close_bracket, ")", },
{ 100+ c_regex_traits<char>::syntax_dollar, "$", },
{ 100+ c_regex_traits<char>::syntax_caret, "^", },
{ 100+ c_regex_traits<char>::syntax_dot, ".", },
{ 100+ c_regex_traits<char>::syntax_star, "*", },
{ 100+ c_regex_traits<char>::syntax_plus, "+", },
{ 100+ c_regex_traits<char>::syntax_question, "?", },
{ 100+ c_regex_traits<char>::syntax_open_set, "[", },
{ 100+ c_regex_traits<char>::syntax_close_set, "]", },
{ 100+ c_regex_traits<char>::syntax_or, "|", },
{ 100+ c_regex_traits<char>::syntax_slash, "\\", },
{ 100+ c_regex_traits<char>::syntax_hash, "#", },
{ 100+ c_regex_traits<char>::syntax_dash, "-", },
{ 100+ c_regex_traits<char>::syntax_open_brace, "{", },
{ 100+ c_regex_traits<char>::syntax_close_brace, "}", },
{ 100+ c_regex_traits<char>::syntax_digit, "0123456789", },
{ 100+ c_regex_traits<char>::syntax_b, "b", },
{ 100+ c_regex_traits<char>::syntax_B, "B", },
{ 100+ c_regex_traits<char>::syntax_left_word, "<", },
{ 100+ c_regex_traits<char>::syntax_right_word, ">", },
{ 100+ c_regex_traits<char>::syntax_w, "w", },
{ 100+ c_regex_traits<char>::syntax_W, "W", },
{ 100+ c_regex_traits<char>::syntax_start_buffer, "`A", },
{ 100+ c_regex_traits<char>::syntax_end_buffer, "'z", },
{ 100+ c_regex_traits<char>::syntax_newline, "\n", },
{ 100+ c_regex_traits<char>::syntax_comma, ",", },
{ 100+ c_regex_traits<char>::syntax_a, "a", },
{ 100+ c_regex_traits<char>::syntax_f, "f", },
{ 100+ c_regex_traits<char>::syntax_n, "n", },
{ 100+ c_regex_traits<char>::syntax_r, "r", },
{ 100+ c_regex_traits<char>::syntax_t, "t", },
{ 100+ c_regex_traits<char>::syntax_v, "v", },
{ 100+ c_regex_traits<char>::syntax_x, "x", },
{ 100+ c_regex_traits<char>::syntax_c, "c", },
{ 100+ c_regex_traits<char>::syntax_colon, ":", },
{ 100+ c_regex_traits<char>::syntax_equal, "=", },
{ 100 + c_regex_traits<char>::syntax_e, "e", },
{ 100 + c_regex_traits<char>::syntax_l, "l", },
{ 100 + c_regex_traits<char>::syntax_L, "L", },
{ 100 + c_regex_traits<char>::syntax_u, "u", },
{ 100 + c_regex_traits<char>::syntax_U, "U", },
{ 100 + c_regex_traits<char>::syntax_s, "s", },
{ 100 + c_regex_traits<char>::syntax_S, "S", },
{ 100 + c_regex_traits<char>::syntax_d, "d", },
{ 100 + c_regex_traits<char>::syntax_D, "D", },
{ 100 + c_regex_traits<char>::syntax_E, "E", },
{ 100 + c_regex_traits<char>::syntax_Q, "Q", },
{ 100 + c_regex_traits<char>::syntax_X, "X", },
{ 100 + c_regex_traits<char>::syntax_C, "C", },
{ 100 + c_regex_traits<char>::syntax_Z, "Z", },
{ 100 + c_regex_traits<char>::syntax_G, "G", },
{ 0, "", },
};
BOOST_RE_IX_DECL unsigned int BOOST_RE_CALL re_get_default_message(char* buf, unsigned int len, unsigned int id)
{
BOOST_RE_GUARD_STACK
const mss* pm = default_messages;
while(pm->id)
{
if(pm->id == id)
{
unsigned int size = re_strlen(pm->what) + 1;
if(size > len)
return size;
re_strcpy(buf, pm->what);
return size;
}
++pm;
}
if(buf && len)
*buf = 0;
return 1;
}
const wchar_t combining_ranges[] = { 0x0300, 0x0361,
0x0483, 0x0486,
0x0903, 0x0903,
0x093E, 0x0940,
0x0949, 0x094C,
0x0982, 0x0983,
0x09BE, 0x09C0,
0x09C7, 0x09CC,
0x09D7, 0x09D7,
0x0A3E, 0x0A40,
0x0A83, 0x0A83,
0x0ABE, 0x0AC0,
0x0AC9, 0x0ACC,
0x0B02, 0x0B03,
0x0B3E, 0x0B3E,
0x0B40, 0x0B40,
0x0B47, 0x0B4C,
0x0B57, 0x0B57,
0x0B83, 0x0B83,
0x0BBE, 0x0BBF,
0x0BC1, 0x0BCC,
0x0BD7, 0x0BD7,
0x0C01, 0x0C03,
0x0C41, 0x0C44,
0x0C82, 0x0C83,
0x0CBE, 0x0CBE,
0x0CC0, 0x0CC4,
0x0CC7, 0x0CCB,
0x0CD5, 0x0CD6,
0x0D02, 0x0D03,
0x0D3E, 0x0D40,
0x0D46, 0x0D4C,
0x0D57, 0x0D57,
0x0F7F, 0x0F7F,
0x20D0, 0x20E1,
0x3099, 0x309A,
0xFE20, 0xFE23,
0xffff, 0xffff, };
BOOST_RE_IX_DECL bool BOOST_RE_CALL is_combining(wchar_t c)
{
BOOST_RE_GUARD_STACK
const wchar_t* p = combining_ranges + 1;
while(*p < c) p += 2;
--p;
if((c >= *p) && (c <= *(p+1)))
return true;
return false;
}
BOOST_RE_IX_DECL unsigned short wide_unicode_classes[] = {
c_traits_base::char_class_cntrl, // '' 0
c_traits_base::char_class_cntrl, // '' 1
c_traits_base::char_class_cntrl, // '' 2
c_traits_base::char_class_cntrl, // '' 3
c_traits_base::char_class_cntrl, // '' 4
c_traits_base::char_class_cntrl, // '' 5
c_traits_base::char_class_cntrl, // '' 6
c_traits_base::char_class_cntrl, // '' 7
c_traits_base::char_class_cntrl, // '' 8
c_traits_base::char_class_cntrl | c_traits_base::char_class_space | c_traits_base::char_class_blank, // '' 9
c_traits_base::char_class_cntrl | c_traits_base::char_class_space, // '' 10
c_traits_base::char_class_cntrl | c_traits_base::char_class_space, // '' 11
c_traits_base::char_class_cntrl | c_traits_base::char_class_space, // '' 12
c_traits_base::char_class_cntrl | c_traits_base::char_class_space, // '' 13
c_traits_base::char_class_cntrl, // '.' 14
c_traits_base::char_class_cntrl, // '.' 15
c_traits_base::char_class_cntrl, // '.' 16
c_traits_base::char_class_cntrl, // '.' 17
c_traits_base::char_class_cntrl, // '.' 18
c_traits_base::char_class_cntrl, // '.' 19
c_traits_base::char_class_cntrl, // '.' 20
c_traits_base::char_class_cntrl, // '.' 21
c_traits_base::char_class_cntrl, // '.' 22
c_traits_base::char_class_cntrl, // '.' 23
c_traits_base::char_class_cntrl, // '.' 24
c_traits_base::char_class_cntrl, // '' 25
c_traits_base::char_class_cntrl, // '' 26
c_traits_base::char_class_cntrl, // '' 27
c_traits_base::char_class_cntrl, // '.' 28
c_traits_base::char_class_cntrl, // '.' 29
c_traits_base::char_class_cntrl, // '.' 30
c_traits_base::char_class_cntrl, // '.' 31
c_traits_base::char_class_space | c_traits_base::char_class_blank, // ' ' 32
c_traits_base::char_class_punct, // '!' 33
c_traits_base::char_class_punct, // '"' 34
c_traits_base::char_class_punct, // '#' 35
c_traits_base::char_class_punct, // '$' 36
c_traits_base::char_class_punct, // '%' 37
c_traits_base::char_class_punct, // '&' 38
c_traits_base::char_class_punct, // ''' 39
c_traits_base::char_class_punct, // '(' 40
c_traits_base::char_class_punct, // ')' 41
c_traits_base::char_class_punct, // '*' 42
c_traits_base::char_class_punct, // '+' 43
c_traits_base::char_class_punct, // ',' 44
c_traits_base::char_class_punct, // '-' 45
c_traits_base::char_class_punct, // '.' 46
c_traits_base::char_class_punct, // '/' 47
c_traits_base::char_class_digit | c_traits_base::char_class_xdigit, // '0' 48
c_traits_base::char_class_digit | c_traits_base::char_class_xdigit, // '1' 49
c_traits_base::char_class_digit | c_traits_base::char_class_xdigit, // '2' 50
c_traits_base::char_class_digit | c_traits_base::char_class_xdigit, // '3' 51
c_traits_base::char_class_digit | c_traits_base::char_class_xdigit, // '4' 52
c_traits_base::char_class_digit | c_traits_base::char_class_xdigit, // '5' 53
c_traits_base::char_class_digit | c_traits_base::char_class_xdigit, // '6' 54
c_traits_base::char_class_digit | c_traits_base::char_class_xdigit, // '7' 55
c_traits_base::char_class_digit | c_traits_base::char_class_xdigit, // '8' 56
c_traits_base::char_class_digit | c_traits_base::char_class_xdigit, // '9' 57
c_traits_base::char_class_punct, // ':' 58
c_traits_base::char_class_punct, // ';' 59
c_traits_base::char_class_punct, // '<' 60
c_traits_base::char_class_punct, // '=' 61
c_traits_base::char_class_punct, // '>' 62
c_traits_base::char_class_punct, // '?' 63
c_traits_base::char_class_punct, // '@' 64
c_traits_base::char_class_alpha | c_traits_base::char_class_upper | c_traits_base::char_class_xdigit, // 'A' 65
c_traits_base::char_class_alpha | c_traits_base::char_class_upper | c_traits_base::char_class_xdigit, // 'B' 66
c_traits_base::char_class_alpha | c_traits_base::char_class_upper | c_traits_base::char_class_xdigit, // 'C' 67
c_traits_base::char_class_alpha | c_traits_base::char_class_upper | c_traits_base::char_class_xdigit, // 'D' 68
c_traits_base::char_class_alpha | c_traits_base::char_class_upper | c_traits_base::char_class_xdigit, // 'E' 69
c_traits_base::char_class_alpha | c_traits_base::char_class_upper | c_traits_base::char_class_xdigit, // 'F' 70
c_traits_base::char_class_alpha | c_traits_base::char_class_upper, // 'G' 71
c_traits_base::char_class_alpha | c_traits_base::char_class_upper, // 'H' 72
c_traits_base::char_class_alpha | c_traits_base::char_class_upper, // 'I' 73
c_traits_base::char_class_alpha | c_traits_base::char_class_upper, // 'J' 74
c_traits_base::char_class_alpha | c_traits_base::char_class_upper, // 'K' 75
c_traits_base::char_class_alpha | c_traits_base::char_class_upper, // 'L' 76
c_traits_base::char_class_alpha | c_traits_base::char_class_upper, // 'M' 77
c_traits_base::char_class_alpha | c_traits_base::char_class_upper, // 'N' 78
c_traits_base::char_class_alpha | c_traits_base::char_class_upper, // 'O' 79
c_traits_base::char_class_alpha | c_traits_base::char_class_upper, // 'P' 80
c_traits_base::char_class_alpha | c_traits_base::char_class_upper, // 'Q' 81
c_traits_base::char_class_alpha | c_traits_base::char_class_upper, // 'R' 82
c_traits_base::char_class_alpha | c_traits_base::char_class_upper, // 'S' 83
c_traits_base::char_class_alpha | c_traits_base::char_class_upper, // 'T' 84
c_traits_base::char_class_alpha | c_traits_base::char_class_upper, // 'U' 85
c_traits_base::char_class_alpha | c_traits_base::char_class_upper, // 'V' 86
c_traits_base::char_class_alpha | c_traits_base::char_class_upper, // 'W' 87
c_traits_base::char_class_alpha | c_traits_base::char_class_upper, // 'X' 88
c_traits_base::char_class_alpha | c_traits_base::char_class_upper, // 'Y' 89
c_traits_base::char_class_alpha | c_traits_base::char_class_upper, // 'Z' 90
c_traits_base::char_class_punct, // '[' 91
c_traits_base::char_class_punct, // '\' 92
c_traits_base::char_class_punct, // ']' 93
c_traits_base::char_class_punct, // '^' 94
c_traits_base::char_class_punct | c_traits_base::char_class_underscore, // '_' 95
c_traits_base::char_class_punct, // '`' 96
c_traits_base::char_class_alpha | c_traits_base::char_class_lower | c_traits_base::char_class_xdigit, // 'a' 97
c_traits_base::char_class_alpha | c_traits_base::char_class_lower | c_traits_base::char_class_xdigit, // 'b' 98
c_traits_base::char_class_alpha | c_traits_base::char_class_lower | c_traits_base::char_class_xdigit, // 'c' 99
c_traits_base::char_class_alpha | c_traits_base::char_class_lower | c_traits_base::char_class_xdigit, // 'd' 100
c_traits_base::char_class_alpha | c_traits_base::char_class_lower | c_traits_base::char_class_xdigit, // 'e' 101
c_traits_base::char_class_alpha | c_traits_base::char_class_lower | c_traits_base::char_class_xdigit, // 'f' 102
c_traits_base::char_class_alpha | c_traits_base::char_class_lower, // 'g' 103
c_traits_base::char_class_alpha | c_traits_base::char_class_lower, // 'h' 104
c_traits_base::char_class_alpha | c_traits_base::char_class_lower, // 'i' 105
c_traits_base::char_class_alpha | c_traits_base::char_class_lower, // 'j' 106
c_traits_base::char_class_alpha | c_traits_base::char_class_lower, // 'k' 107
c_traits_base::char_class_alpha | c_traits_base::char_class_lower, // 'l' 108
c_traits_base::char_class_alpha | c_traits_base::char_class_lower, // 'm' 109
c_traits_base::char_class_alpha | c_traits_base::char_class_lower, // 'n' 110
c_traits_base::char_class_alpha | c_traits_base::char_class_lower, // 'o' 111
c_traits_base::char_class_alpha | c_traits_base::char_class_lower, // 'p' 112
c_traits_base::char_class_alpha | c_traits_base::char_class_lower, // 'q' 113
c_traits_base::char_class_alpha | c_traits_base::char_class_lower, // 'r' 114
c_traits_base::char_class_alpha | c_traits_base::char_class_lower, // 's' 115
c_traits_base::char_class_alpha | c_traits_base::char_class_lower, // 't' 116
c_traits_base::char_class_alpha | c_traits_base::char_class_lower, // 'u' 117
c_traits_base::char_class_alpha | c_traits_base::char_class_lower, // 'v' 118
c_traits_base::char_class_alpha | c_traits_base::char_class_lower, // 'w' 119
c_traits_base::char_class_alpha | c_traits_base::char_class_lower, // 'x' 120
c_traits_base::char_class_alpha | c_traits_base::char_class_lower, // 'y' 121
c_traits_base::char_class_alpha | c_traits_base::char_class_lower, // 'z' 122
c_traits_base::char_class_punct, // '{' 123
c_traits_base::char_class_punct, // '|' 124
c_traits_base::char_class_punct, // '}' 125
c_traits_base::char_class_punct, // '~' 126
c_traits_base::char_class_cntrl, // '' 127
c_traits_base::char_class_cntrl, // '<27>' 128
c_traits_base::char_class_cntrl, // '<27>' 129
c_traits_base::char_class_cntrl, // '<27>' 130
c_traits_base::char_class_cntrl, // '<27>' 131
c_traits_base::char_class_cntrl, // '<27>' 132
c_traits_base::char_class_cntrl, // '<27>' 133
c_traits_base::char_class_cntrl, // '<27>' 134
c_traits_base::char_class_cntrl, // '<27>' 135
c_traits_base::char_class_cntrl, // '<27>' 136
c_traits_base::char_class_cntrl, // '<27>' 137
c_traits_base::char_class_cntrl, // '<27>' 138
c_traits_base::char_class_cntrl, // '<27>' 139
c_traits_base::char_class_cntrl, // '<27>' 140
c_traits_base::char_class_cntrl, // '<27>' 141
c_traits_base::char_class_cntrl, // '<27>' 142
c_traits_base::char_class_cntrl, // '<27>' 143
c_traits_base::char_class_cntrl, // '<27>' 144
c_traits_base::char_class_cntrl, // '<27>' 145
c_traits_base::char_class_cntrl, // '<27>' 146
c_traits_base::char_class_cntrl, // '<27>' 147
c_traits_base::char_class_cntrl, // '<27>' 148
c_traits_base::char_class_cntrl, // '<27>' 149
c_traits_base::char_class_cntrl, // '<27>' 150
c_traits_base::char_class_cntrl, // '<27>' 151
c_traits_base::char_class_cntrl, // '<27>' 152
c_traits_base::char_class_cntrl, // '<27>' 153
c_traits_base::char_class_cntrl, // '<27>' 154
c_traits_base::char_class_cntrl, // '<27>' 155
c_traits_base::char_class_cntrl, // '<27>' 156
c_traits_base::char_class_cntrl, // '<27>' 157
c_traits_base::char_class_cntrl, // '<27>' 158
c_traits_base::char_class_cntrl, // '<27>' 159
c_traits_base::char_class_space | c_traits_base::char_class_blank, // '<27>' 160
c_traits_base::char_class_punct, // '<27>' 161
c_traits_base::char_class_punct, // '<27>' 162
c_traits_base::char_class_punct, // '<27>' 163
c_traits_base::char_class_punct, // '<27>' 164
c_traits_base::char_class_punct, // '<27>' 165
c_traits_base::char_class_punct, // '<27>' 166
c_traits_base::char_class_punct, // '<27>' 167
c_traits_base::char_class_punct, // '<27>' 168
c_traits_base::char_class_punct, // '<27>' 169
c_traits_base::char_class_punct, // '<27>' 170
c_traits_base::char_class_punct, // '<27>' 171
c_traits_base::char_class_punct, // '<27>' 172
c_traits_base::char_class_punct, // '<27>' 173
c_traits_base::char_class_punct, // '<27>' 174
c_traits_base::char_class_punct, // '<27>' 175
c_traits_base::char_class_punct, // '<27>' 176
c_traits_base::char_class_punct, // '<27>' 177
c_traits_base::char_class_punct, // '<27>' 178
c_traits_base::char_class_punct, // '<27>' 179
c_traits_base::char_class_punct, // '<27>' 180
c_traits_base::char_class_punct, // '<27>' 181
c_traits_base::char_class_punct, // '<27>' 182
c_traits_base::char_class_punct, // '<27>' 183
c_traits_base::char_class_punct, // '<27>' 184
c_traits_base::char_class_punct, // '<27>' 185
c_traits_base::char_class_punct, // '<27>' 186
c_traits_base::char_class_punct, // '<27>' 187
c_traits_base::char_class_punct, // '<27>' 188
c_traits_base::char_class_punct, // '<27>' 189
c_traits_base::char_class_punct, // '<27>' 190
c_traits_base::char_class_punct, // '<27>' 191
c_traits_base::char_class_alpha | c_traits_base::char_class_upper, // '<27>' 192
c_traits_base::char_class_alpha | c_traits_base::char_class_upper, // '<27>' 193
c_traits_base::char_class_alpha | c_traits_base::char_class_upper, // '<27>' 194
c_traits_base::char_class_alpha | c_traits_base::char_class_upper, // '<27>' 195
c_traits_base::char_class_alpha | c_traits_base::char_class_upper, // '<27>' 196
c_traits_base::char_class_alpha | c_traits_base::char_class_upper, // '<27>' 197
c_traits_base::char_class_alpha | c_traits_base::char_class_upper, // '<27>' 198
c_traits_base::char_class_alpha | c_traits_base::char_class_upper, // '<27>' 199
c_traits_base::char_class_alpha | c_traits_base::char_class_upper, // '<27>' 200
c_traits_base::char_class_alpha | c_traits_base::char_class_upper, // '<27>' 201
c_traits_base::char_class_alpha | c_traits_base::char_class_upper, // '<27>' 202
c_traits_base::char_class_alpha | c_traits_base::char_class_upper, // '<27>' 203
c_traits_base::char_class_alpha | c_traits_base::char_class_upper, // '<27>' 204
c_traits_base::char_class_alpha | c_traits_base::char_class_upper, // '<27>' 205
c_traits_base::char_class_alpha | c_traits_base::char_class_upper, // '<27>' 206
c_traits_base::char_class_alpha | c_traits_base::char_class_upper, // '<27>' 207
c_traits_base::char_class_alpha | c_traits_base::char_class_upper, // '<27>' 208
c_traits_base::char_class_alpha | c_traits_base::char_class_upper, // '<27>' 209
c_traits_base::char_class_alpha | c_traits_base::char_class_upper, // '<27>' 210
c_traits_base::char_class_alpha | c_traits_base::char_class_upper, // '<27>' 211
c_traits_base::char_class_alpha | c_traits_base::char_class_upper, // '<27>' 212
c_traits_base::char_class_alpha | c_traits_base::char_class_upper, // '<27>' 213
c_traits_base::char_class_alpha | c_traits_base::char_class_upper, // '<27>' 214
c_traits_base::char_class_punct, // '<27>' 215
c_traits_base::char_class_alpha | c_traits_base::char_class_upper, // '<27>' 216
c_traits_base::char_class_alpha | c_traits_base::char_class_upper, // '<27>' 217
c_traits_base::char_class_alpha | c_traits_base::char_class_upper, // '<27>' 218
c_traits_base::char_class_alpha | c_traits_base::char_class_upper, // '<27>' 219
c_traits_base::char_class_alpha | c_traits_base::char_class_upper, // '<27>' 220
c_traits_base::char_class_alpha | c_traits_base::char_class_upper, // '<27>' 221
c_traits_base::char_class_alpha | c_traits_base::char_class_upper, // '<27>' 222
c_traits_base::char_class_alpha | c_traits_base::char_class_lower, // '<27>' 223
c_traits_base::char_class_alpha | c_traits_base::char_class_lower, // '<27>' 224
c_traits_base::char_class_alpha | c_traits_base::char_class_lower, // '<27>' 225
c_traits_base::char_class_alpha | c_traits_base::char_class_lower, // '<27>' 226
c_traits_base::char_class_alpha | c_traits_base::char_class_lower, // '<27>' 227
c_traits_base::char_class_alpha | c_traits_base::char_class_lower, // '<27>' 228
c_traits_base::char_class_alpha | c_traits_base::char_class_lower, // '<27>' 229
c_traits_base::char_class_alpha | c_traits_base::char_class_lower, // '<27>' 230
c_traits_base::char_class_alpha | c_traits_base::char_class_lower, // '<27>' 231
c_traits_base::char_class_alpha | c_traits_base::char_class_lower, // '<27>' 232
c_traits_base::char_class_alpha | c_traits_base::char_class_lower, // '<27>' 233
c_traits_base::char_class_alpha | c_traits_base::char_class_lower, // '<27>' 234
c_traits_base::char_class_alpha | c_traits_base::char_class_lower, // '<27>' 235
c_traits_base::char_class_alpha | c_traits_base::char_class_lower, // '<27>' 236
c_traits_base::char_class_alpha | c_traits_base::char_class_lower, // '<27>' 237
c_traits_base::char_class_alpha | c_traits_base::char_class_lower, // '<27>' 238
c_traits_base::char_class_alpha | c_traits_base::char_class_lower, // '<27>' 239
c_traits_base::char_class_alpha | c_traits_base::char_class_lower, // '<27>' 240
c_traits_base::char_class_alpha | c_traits_base::char_class_lower, // '<27>' 241
c_traits_base::char_class_alpha | c_traits_base::char_class_lower, // '<27>' 242
c_traits_base::char_class_alpha | c_traits_base::char_class_lower, // '<27>' 243
c_traits_base::char_class_alpha | c_traits_base::char_class_lower, // '<27>' 244
c_traits_base::char_class_alpha | c_traits_base::char_class_lower, // '<27>' 245
c_traits_base::char_class_alpha | c_traits_base::char_class_lower, // '<27>' 246
c_traits_base::char_class_punct, // '<27>' 247
c_traits_base::char_class_alpha | c_traits_base::char_class_lower, // '<27>' 248
c_traits_base::char_class_alpha | c_traits_base::char_class_lower, // '<27>' 249
c_traits_base::char_class_alpha | c_traits_base::char_class_lower, // '<27>' 250
c_traits_base::char_class_alpha | c_traits_base::char_class_lower, // '<27>' 251
c_traits_base::char_class_alpha | c_traits_base::char_class_lower, // '<27>' 252
c_traits_base::char_class_alpha | c_traits_base::char_class_lower, // '<27>' 253
c_traits_base::char_class_alpha | c_traits_base::char_class_lower, // '<27>' 254
c_traits_base::char_class_alpha | c_traits_base::char_class_lower, // '<27>' 255
};
BOOST_RE_IX_DECL wchar_t wide_lower_case_map[] = {
0x0, 0x1, 0x2, 0x3, 0x4, 0x5, 0x6, 0x7, 0x8, 0x9, 0xa, 0xb, 0xc, 0xd, 0xe, 0xf,
0x10, 0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17, 0x18, 0x19, 0x1a, 0x1b, 0x1c, 0x1d, 0x1e, 0x1f,
0x20, 0x21, 0x22, 0x23, 0x24, 0x25, 0x26, 0x27, 0x28, 0x29, 0x2a, 0x2b, 0x2c, 0x2d, 0x2e, 0x2f,
0x30, 0x31, 0x32, 0x33, 0x34, 0x35, 0x36, 0x37, 0x38, 0x39, 0x3a, 0x3b, 0x3c, 0x3d, 0x3e, 0x3f,
0x40, 0x61, 0x62, 0x63, 0x64, 0x65, 0x66, 0x67, 0x68, 0x69, 0x6a, 0x6b, 0x6c, 0x6d, 0x6e, 0x6f,
0x70, 0x71, 0x72, 0x73, 0x74, 0x75, 0x76, 0x77, 0x78, 0x79, 0x7a, 0x5b, 0x5c, 0x5d, 0x5e, 0x5f,
0x60, 0x61, 0x62, 0x63, 0x64, 0x65, 0x66, 0x67, 0x68, 0x69, 0x6a, 0x6b, 0x6c, 0x6d, 0x6e, 0x6f,
0x70, 0x71, 0x72, 0x73, 0x74, 0x75, 0x76, 0x77, 0x78, 0x79, 0x7a, 0x7b, 0x7c, 0x7d, 0x7e, 0x7f,
0x80, 0x81, 0x82, 0x83, 0x84, 0x85, 0x86, 0x87, 0x88, 0x89, 0x8a, 0x8b, 0x8c, 0x8d, 0x8e, 0x8f,
0x90, 0x91, 0x92, 0x93, 0x94, 0x95, 0x96, 0x97, 0x98, 0x99, 0x9a, 0x9b, 0x9c, 0x9d, 0x9e, 0x9f,
0xa0, 0xa1, 0xa2, 0xa3, 0xa4, 0xa5, 0xa6, 0xa7, 0xa8, 0xa9, 0xaa, 0xab, 0xac, 0xad, 0xae, 0xaf,
0xb0, 0xb1, 0xb2, 0xb3, 0xb4, 0xb5, 0xb6, 0xb7, 0xb8, 0xb9, 0xba, 0xbb, 0xbc, 0xbd, 0xbe, 0xbf,
0xe0, 0xe1, 0xe2, 0xe3, 0xe4, 0xe5, 0xe6, 0xe7, 0xe8, 0xe9, 0xea, 0xeb, 0xec, 0xed, 0xee, 0xef,
0xf0, 0xf1, 0xf2, 0xf3, 0xf4, 0xf5, 0xf6, 0xd7, 0xf8, 0xf9, 0xfa, 0xfb, 0xfc, 0xfd, 0xfe, 0xdf,
0xe0, 0xe1, 0xe2, 0xe3, 0xe4, 0xe5, 0xe6, 0xe7, 0xe8, 0xe9, 0xea, 0xeb, 0xec, 0xed, 0xee, 0xef,
0xf0, 0xf1, 0xf2, 0xf3, 0xf4, 0xf5, 0xf6, 0xf7, 0xf8, 0xf9, 0xfa, 0xfb, 0xfc, 0xfd, 0xfe, 0xff,
};
} // namespace re_detail
} // namespace boost

View File

@ -1,816 +0,0 @@
/*
*
* 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.
*
*/
/*
* LOCATION: see http://www.boost.org for most recent version.
* FILE: c_regex_traits.cpp
* VERSION: 3.12
* DESCRIPTION: Implements the cpp_regex_traits<charT> traits class
*/
#include <clocale>
#include <cstdio>
#include <list>
#include <cctype>
#include <iostream>
#include <boost/regex/regex_traits.hpp>
#include <map>
#include <boost/cregex.hpp>
#include "primary_transform.hpp"
#ifndef BOOST_RE_NO_LOCALE_H
# ifdef BOOST_MSVC
# pragma warning(disable:4786)
# endif
namespace{
const unsigned int re_classes_max = 14;
const unsigned int char_set_size = CHAR_MAX - CHAR_MIN + 1;
boost::uint_fast32_t re_char_class_id[] = {
boost::re_detail::cpp_regex_traits_base::char_class_alnum,
boost::re_detail::cpp_regex_traits_base::char_class_alpha,
boost::re_detail::cpp_regex_traits_base::char_class_cntrl,
boost::re_detail::cpp_regex_traits_base::char_class_digit,
boost::re_detail::cpp_regex_traits_base::char_class_graph,
boost::re_detail::cpp_regex_traits_base::char_class_lower,
boost::re_detail::cpp_regex_traits_base::char_class_print,
boost::re_detail::cpp_regex_traits_base::char_class_punct,
boost::re_detail::cpp_regex_traits_base::char_class_space,
boost::re_detail::cpp_regex_traits_base::char_class_upper,
boost::re_detail::cpp_regex_traits_base::char_class_xdigit,
boost::re_detail::cpp_regex_traits_base::char_class_blank,
boost::re_detail::cpp_regex_traits_base::char_class_word,
boost::re_detail::cpp_regex_traits_base::char_class_unicode,
};
const char* re_char_class_names[] = {
"alnum",
"alpha",
"cntrl",
"digit",
"graph",
"lower",
"print",
"punct",
"space",
"upper",
"xdigit",
"blank",
"word",
"unicode",
};
template <class charT,
class traits = ::std::char_traits<charT> >
class parser_buf : public ::std::basic_streambuf<charT, traits>
{
typedef ::std::basic_streambuf<charT, traits> base_type;
typedef typename base_type::int_type int_type;
typedef typename base_type::char_type char_type;
typedef typename base_type::pos_type pos_type;
typedef ::std::streamsize streamsize;
typedef typename base_type::off_type off_type;
public:
parser_buf() : base_type() { setbuf(0, 0); }
const charT* getnext() { return this->gptr(); }
protected:
std::basic_streambuf<charT, traits>* setbuf(char_type* s, streamsize n);
typename parser_buf<charT, traits>::pos_type seekpos(pos_type sp, ::std::ios_base::openmode which);
typename parser_buf<charT, traits>::pos_type seekoff(off_type off, ::std::ios_base::seekdir way, ::std::ios_base::openmode which);
private:
parser_buf& operator=(const parser_buf&);
parser_buf(const parser_buf&);
};
template<class charT, class traits>
std::basic_streambuf<charT, traits>*
parser_buf<charT, traits>::setbuf(char_type* s, streamsize n)
{
this->setg(s, s, s + n);
return this;
}
template<class charT, class traits>
typename parser_buf<charT, traits>::pos_type
parser_buf<charT, traits>::seekoff(off_type off, ::std::ios_base::seekdir way, ::std::ios_base::openmode which)
{
if(which & ::std::ios_base::out)
return pos_type(off_type(-1));
int size = this->egptr() - this->eback();
int pos = this->gptr() - this->eback();
charT* g = this->eback();
switch(way)
{
case ::std::ios_base::beg:
if((off < 0) || (off > size))
return pos_type(off_type(-1));
else
this->setg(g, g + off, g + size);
case ::std::ios_base::end:
if((off < 0) || (off > size))
return pos_type(off_type(-1));
else
this->setg(g, g + size - off, g + size);
case ::std::ios_base::cur:
{
int newpos = pos + off;
if((newpos < 0) || (newpos > size))
return pos_type(off_type(-1));
else
this->setg(g, g + newpos, g + size);
}
}
return this->gptr() - this->eback();
}
template<class charT, class traits>
typename parser_buf<charT, traits>::pos_type
parser_buf<charT, traits>::seekpos(pos_type sp, ::std::ios_base::openmode which)
{
if(which & ::std::ios_base::out)
return pos_type(off_type(-1));
int size = this->egptr() - this->eback();
charT* g = this->eback();
if(sp <= size)
{
this->setg(g, g + ::std::streamsize(sp), g + size);
}
return pos_type(off_type(-1));
}
} // namespace
namespace boost{
namespace re_detail{
template <>
struct message_data<char>
{
unsigned char syntax_map[CHAR_MAX-CHAR_MIN];
std::map<std::string, std::string, std::less<std::string> > collating_elements;
std::map<std::string, unsigned long, std::less<std::string> > classes;
//std::string _zero;
//std::string _ten;
parser_buf<char> sbuf;
std::istream is;
std::string error_strings[boost::REG_E_UNKNOWN+1];
message_data(const std::locale& l, const std::string& regex_message_catalogue);
private:
message_data(const message_data&);
message_data& operator=(const message_data&);
};
message_data<char>::message_data(const std::locale& l, const std::string& regex_message_catalogue)
: is(&sbuf)
{
is.imbue(l);
#ifndef BOOST_RE_NO_MESSAGES
const std::messages<char>* pm = &BOOST_RE_USE_FACET(l, std::messages<char>);
std::messages<char>::catalog cat = regex_message_catalogue.size() ? pm->open(regex_message_catalogue, l) : -1;
#endif
std::memset(syntax_map, cpp_regex_traits<char>::syntax_char, 256);
unsigned int i;
scoped_array<char> a;
unsigned array_size = 0;
unsigned new_size;
for(i = 1; i < cpp_regex_traits<char>::syntax_max; ++i)
{
new_size = re_get_default_message(0, 0, i+100);
if(new_size > array_size)
{
a.reset(new char[new_size]);
array_size = new_size;
}
re_get_default_message(a.get(), array_size, i+100);
std::string s = a.get();
#ifndef BOOST_RE_NO_MESSAGES
if((int)cat >= 0)
s = pm->get(cat, 0, i+100, s);
#endif
for(unsigned int j = 0; j < s.size(); ++j)
{
syntax_map[s[j]] = (unsigned char)(i);
}
}
#ifndef BOOST_RE_NO_MESSAGES
// load any custom collate names:
std::string c1, c2;
i = 400;
if((int)cat >= 0)
c2 = pm->get(cat, 0, i, c1);
while(c2.size())
{
const char* p1, *p2, *p3, *p4;;
p1 = c2.c_str();
while(*p1 && std::isspace((char)*p1, l))++p1;
p2 = p1;
while(*p2 && !std::isspace((char)*p2, l))++p2;
p3 = p2;
while(*p3 && std::isspace((char)*p3, l))++p3;
p4 = p3;
while(*p4 && !std::isspace((char)*p4, l))++p4;
collating_elements[std::string(p1, p2)] = std::string(p3, p4);
++i;
c2 = pm->get(cat, 0, i, c1);
}
#endif
/*
std::string n("zero");
std::map<std::string, std::string, std::less<std::string > >::const_iterator pos = collating_elements.find(n);
if(pos != collating_elements.end())
_zero = *(*pos).second.c_str();
else
_zero = '0';
n = "ten";
pos = collating_elements.find(n);
if(pos != collating_elements.end())
_ten = *(*pos).second.c_str();
else
_ten = 'a';
*/
std::string m;
std::string s;
#ifndef BOOST_RE_NO_MESSAGES
if((int)cat >= 0)
{
for(i = 0; i < re_classes_max; ++i)
{
s = pm->get(cat, 0, i+300, m);
if(s.size())
classes[s] = i;
}
for(i = 0; i <= boost::REG_E_UNKNOWN ; ++i)
{
s = pm->get(cat, 0, i+200, m);
error_strings[i] = s;
}
}
if((int)cat >= 0)
pm->close(cat);
#endif
}
std::string BOOST_RE_CALL cpp_regex_traits_base::set_message_catalogue(const std::string& l)
{
if(sizeof(regex_message_cat) <= l.size())
return l;
std::string old(regex_message_cat);
std::strcpy(regex_message_cat, l.c_str());
return old;
}
char cpp_regex_traits_base::regex_message_cat[200] = {0};
} // namespace re_detail
cpp_regex_traits<char>::cpp_regex_traits()
{
pmd = new re_detail::message_data<char>(locale_inst, regex_message_cat);
psyntax = pmd->syntax_map;
try{
lower_map = new char[char_set_size];
}
catch(...)
{
delete pmd;
throw;
}
for(unsigned int i = 0; i < char_set_size; ++i)
lower_map[i] = static_cast<char>(i);
pctype = &BOOST_RE_USE_FACET(locale_inst, std::ctype<char>);
pctype->tolower(&lower_map[0], &lower_map[char_set_size]);
pcollate = &BOOST_RE_USE_FACET(locale_inst, std::collate<char>);
sort_type = re_detail::find_sort_syntax(this, &(this->sort_delim));
}
cpp_regex_traits<char>::~cpp_regex_traits()
{
delete pmd;
delete[] lower_map;
}
int BOOST_RE_CALL cpp_regex_traits<char>::toi(char c)const
{
pmd->sbuf.pubsetbuf(&c, 1);
pmd->is.clear();
pmd->is >> std::dec;
int val;
if(pmd->is >> val)
{
return val;
}
else
return 0;
}
int BOOST_RE_CALL cpp_regex_traits<char>::toi(const char*& first, const char* last, int radix)const
{
pmd->sbuf.pubsetbuf((char*)first, last-first);
pmd->is.clear();
if(std::abs(radix) == 16) pmd->is >> std::hex;
else if(std::abs(radix) == 8) pmd->is >> std::oct;
else pmd->is >> std::dec;
int val;
if(pmd->is >> val)
{
first = first + ((last - first) - pmd->sbuf.in_avail());
return val;
}
else
return 0;
}
boost::uint_fast32_t BOOST_RE_CALL cpp_regex_traits<char>::lookup_classname(const char* first, const char* last)const
{
BOOST_RE_GUARD_STACK
unsigned int i;
std::string s(first, last);
std::map<std::string, unsigned long, std::less<std::string> >::const_iterator pos = pmd->classes.find(s);
if(pos != pmd->classes.end())
return re_char_class_id[(*pos).second];
for(i = 0; i < re_classes_max; ++i)
{
if(s == re_char_class_names[i])
return re_char_class_id[i];
}
return 0;
}
bool BOOST_RE_CALL cpp_regex_traits<char>::lookup_collatename(std::string& s, const char* first, const char* last)const
{
BOOST_RE_GUARD_STACK
std::string name(first, last);
std::map<std::string, std::string, std::less<std::string > >::const_iterator pos = pmd->collating_elements.find(name);
if(pos != pmd->collating_elements.end())
{
s = (*pos).second;
return true;
}
return re_detail::re_lookup_def_collate_name(s, name.c_str());
}
void BOOST_RE_CALL cpp_regex_traits<char>::transform_primary(std::string& out, const std::string& in)const
{
transform(out, in);
switch(sort_type)
{
case re_detail::sort_C:
case re_detail::sort_unknown:
break;
case re_detail::sort_fixed:
if((unsigned)sort_delim < out.size())
out.erase((int)sort_delim);
break;
case re_detail::sort_delim:
for(unsigned int i = 0; i < out.size(); ++i)
{
if((out[i] == sort_delim) && (i+1 < out.size()))
{
out.erase(i+1);
break;
}
}
}
}
std::string BOOST_RE_CALL cpp_regex_traits<char>::error_string(unsigned id)const
{
if((id <= boost::REG_E_UNKNOWN) && (pmd->error_strings[id].size()))
return pmd->error_strings[id];
return boost::re_detail::re_default_error_messages[id];
}
cpp_regex_traits<char>::locale_type BOOST_RE_CALL cpp_regex_traits<char>::imbue(locale_type l)
{
locale_type old_l(locale_inst);
locale_inst = l;
re_detail::message_data<char>* npmd = new re_detail::message_data<char>(locale_inst, regex_message_cat);
delete pmd;
pmd = npmd;
psyntax = pmd->syntax_map;
for(unsigned int i = 0; i < char_set_size; ++i)
lower_map[i] = static_cast<char>(i);
pctype = &BOOST_RE_USE_FACET(locale_inst, std::ctype<char>);
pctype->tolower(&lower_map[0], &lower_map[char_set_size]);
pcollate = &BOOST_RE_USE_FACET(locale_inst, std::collate<char>);
sort_type = re_detail::find_sort_syntax(this, &(this->sort_delim));
return old_l;
}
#ifndef BOOST_RE_NO_WCSTRING
namespace re_detail{
std::string BOOST_RE_CALL to_narrow(const std::basic_string<wchar_t>& is, const std::codecvt<wchar_t, char, std::mbstate_t>& cvt)
{
BOOST_RE_GUARD_STACK
unsigned int bufsize = is.size() * 2;
//
// declare buffer first as VC6 workaround for internal compiler error!
char* pc = new char[bufsize];
scoped_array<char> t(pc);
//typedef std::codecvt<wchar_t, char, std::mbstate_t> cvt_type;
//const cvt_type& cvt = BOOST_RE_USE_FACET(l, cvt_type);
#ifdef BOOST_MSVC
std::mbstate_t state = 0;
#else
std::mbstate_t state = std::mbstate_t();
#endif
const wchar_t* next_in;
char* next_out;
while(true)
{
switch(cvt.out(state, is.c_str(), is.c_str() + is.size(), next_in, t.get(), t.get() + bufsize, next_out))
{
case std::codecvt_base::ok:
return std::string(t.get(), next_out);
case std::codecvt_base::partial:
bufsize *= 2;
t.reset(new char[bufsize]);
continue;
case std::codecvt_base::error:
// not much we can do here but guess:
case std::codecvt_base::noconv:
std::string out;
for(unsigned i = 0; i < is.size(); ++i)
{
out.append(1, (char)is[i]);
}
return out;
}
}
}
std::wstring BOOST_RE_CALL to_wide(const std::string& is, const std::codecvt<wchar_t, char, std::mbstate_t>& cvt)
{
BOOST_RE_GUARD_STACK
unsigned int bufsize = is.size() + 2;
unsigned int maxsize = is.size() * 100;
//
// declare buffer first as VC6 workaround for internal compiler error!
wchar_t* pc = new wchar_t[bufsize];
scoped_array<wchar_t> t(pc);
//typedef std::codecvt<wchar_t, char, std::mbstate_t> cvt_type;
//const cvt_type& cvt = BOOST_RE_USE_FACET(l, cvt_type);
#ifdef BOOST_MSVC
std::mbstate_t state = 0;
#else
std::mbstate_t state = std::mbstate_t();
#endif
wchar_t* next_out;
const char* next_in;
while(true)
{
switch(cvt.in(state, is.c_str(), is.c_str() + is.size(), next_in, t.get(), t.get() + bufsize, next_out))
{
case std::codecvt_base::ok:
return std::wstring(t.get(), next_out);
case std::codecvt_base::partial:
bufsize *= 2;
if(bufsize < maxsize)
{
t.reset(new wchar_t[bufsize]);
continue;
}
//
// error fall through:
case std::codecvt_base::error:
// not much we can do here but guess:
case std::codecvt_base::noconv:
std::wstring out;
for(unsigned i = 0; i < is.size(); ++i)
{
out.append(1, is[i]);
}
return out;
}
}
}
template <>
struct message_data<wchar_t>
{
#ifndef BOOST_RE_NO_MESSAGES
typedef std::messages<wchar_t>::string_type string_type;
#else
typedef std::wstring string_type;
#endif
string_type name;
struct syntax_map
{
wchar_t c;
unsigned int type;
};
std::list<syntax_map> syntax;
std::map<string_type, unsigned long> classes;
std::map<string_type, string_type> collating_elements;
unsigned char syntax_[CHAR_MAX-CHAR_MIN+1];
parser_buf<wchar_t> sbuf;
std::wistream is;
std::string error_strings[boost::REG_E_UNKNOWN+1];
message_data(const std::locale& l, const std::string& regex_message_catalogue);
private:
message_data(const message_data&);
message_data& operator=(const message_data&);
};
message_data<wchar_t>::message_data(const std::locale& l, const std::string& regex_message_catalogue)
: is(&sbuf)
{
is.imbue(l);
syntax_map m;
typedef std::codecvt<wchar_t, char, std::mbstate_t> cvt_type;
const cvt_type& cvt = BOOST_RE_USE_FACET(l, cvt_type);
#ifndef BOOST_RE_NO_MESSAGES
const std::messages<wchar_t>& msgs = BOOST_RE_USE_FACET(l, std::messages<wchar_t>);
std::messages<wchar_t>::catalog cat = regex_message_catalogue.size() ? msgs.open(regex_message_catalogue, l) : -1;
#endif
scoped_array<char> a;
unsigned array_size = 0;
unsigned new_size;
unsigned int i;
std::memset(syntax_, cpp_regex_traits<wchar_t>::syntax_char, sizeof(syntax_));
for(i = 1; i < cpp_regex_traits<wchar_t>::syntax_max; ++i)
{
new_size = re_get_default_message(0, 0, i+100);
if(new_size > array_size)
{
a.reset(new char[new_size]);
array_size = new_size;
}
re_get_default_message(a.get(), array_size, i+100);
std::string ns = a.get();
string_type s = to_wide(ns, cvt);
#ifndef BOOST_RE_NO_MESSAGES
if((int)cat >= 0)
s = BOOST_RE_USE_FACET(l, std::messages<wchar_t>).get(cat, 0, i+100, s);
#endif
for(unsigned int j = 0; j < s.size(); ++j)
{
if((s[j] <= UCHAR_MAX) && (s[j] >= 0))
syntax_[s[j]] = static_cast<unsigned char>(i);
else
{
m.c = s[j];
m.type = i;
syntax.push_back(m);
}
}
}
#ifndef BOOST_RE_NO_MESSAGES
// load any custom collate names:
string_type c1, c2;
i = 400;
if((int)cat >= 0)
c2 = msgs.get(cat, 0, i, c1);
while(c2.size())
{
const wchar_t* p1, *p2, *p3, *p4;;
p1 = c2.c_str();
while(*p1 && std::isspace((wchar_t)*p1, l))++p1;
p2 = p1;
while(*p2 && !std::isspace((wchar_t)*p2, l))++p2;
p3 = p2;
while(*p3 && std::isspace((wchar_t)*p3, l))++p3;
p4 = p3;
while(*p4 && !std::isspace((wchar_t)*p4, l))++p4;
collating_elements[std::basic_string<wchar_t>(p1, p2)] = std::basic_string<wchar_t>(p3, p4);
++i;
c2 = msgs.get(cat, 0, i, c1);
}
if((int)cat >= 0)
{
c2.erase();
for(i = 0; i < re_classes_max; ++i)
{
c1 = msgs.get(cat, 0, i+300, c2);
if(c1.size())
classes[c1] = i;
}
for(i = 0; i <= boost::REG_E_UNKNOWN ; ++i)
{
c1 = msgs.get(cat, 0, i+200, c2);
error_strings[i] = to_narrow(c1, cvt);
}
}
if((int)cat >= 0)
msgs.close(cat);
#endif
}
} // namespace re_detail
unsigned int BOOST_RE_CALL cpp_regex_traits<wchar_t>::do_syntax_type(size_type c)const
{
std::list<re_detail::message_data<wchar_t>::syntax_map>::const_iterator i, j;
i = pmd->syntax.begin();
j = pmd->syntax.end();
while(i != j)
{
if(((uchar_type)(*i).c) == c)
return (*i).type;
++i;
}
return 0;
}
void BOOST_RE_CALL cpp_regex_traits<wchar_t>::transform_primary(std::basic_string<wchar_t>& out, const std::basic_string<wchar_t>& in)const
{
transform(out, in);
switch(sort_type)
{
case re_detail::sort_C:
case re_detail::sort_unknown:
break;
case re_detail::sort_fixed:
if((unsigned)sort_delim < out.size())
out.erase((int)sort_delim);
break;
case re_detail::sort_delim:
for(unsigned int i = 0; i < out.size(); ++i)
{
if((out[i] == sort_delim) && (i+1 < out.size()))
{
out.erase(i+1);
break;
}
}
}
}
int BOOST_RE_CALL cpp_regex_traits<wchar_t>::toi(wchar_t c)const
{
pmd->sbuf.pubsetbuf(&c, 1);
pmd->is.clear();
pmd->is >> std::dec;
int val;
if(pmd->is >> val)
{
return val;
}
else
return 0;
}
int BOOST_RE_CALL cpp_regex_traits<wchar_t>::toi(const wchar_t*& first, const wchar_t* last, int radix)const
{
pmd->sbuf.pubsetbuf((wchar_t*)first, last-first);
pmd->is.clear();
if(std::abs(radix) == 16) pmd->is >> std::hex;
else if(std::abs(radix) == 8) pmd->is >> std::oct;
else pmd->is >> std::dec;
int val;
if(pmd->is >> val)
{
first = first + ((last - first) - pmd->sbuf.in_avail());
return val;
}
else
return 0;
}
boost::uint_fast32_t BOOST_RE_CALL cpp_regex_traits<wchar_t>::lookup_classname(const wchar_t* first, const wchar_t* last)const
{
BOOST_RE_GUARD_STACK
unsigned int i;
std::wstring s(first, last);
std::map<std::wstring, unsigned long>::const_iterator pos = pmd->classes.find(s);
if(pos != pmd->classes.end())
return re_char_class_id[(*pos).second];
std::string ns = re_detail::to_narrow(s, *pcdv);
for(i = 0; i < re_classes_max; ++i)
{
if(ns == re_char_class_names[i])
return re_char_class_id[i];
}
return 0;
}
bool BOOST_RE_CALL cpp_regex_traits<wchar_t>::lookup_collatename(std::basic_string<wchar_t>& s, const wchar_t* first, const wchar_t* last)const
{
BOOST_RE_GUARD_STACK
std::wstring name(first, last);
std::map<std::wstring, std::wstring>::const_iterator pos = pmd->collating_elements.find(name);
if(pos != pmd->collating_elements.end())
{
s = (*pos).second;
return true;
}
std::string ns = re_detail::to_narrow(name, *pcdv);
std::string ns2;
bool result = re_detail::re_lookup_def_collate_name(ns2, ns.c_str());
s = re_detail::to_wide(ns2, *pcdv);
return result;
}
std::string BOOST_RE_CALL cpp_regex_traits<wchar_t>::error_string(unsigned id)const
{
if((id <= boost::REG_E_UNKNOWN) && (pmd->error_strings[id].size()))
return pmd->error_strings[id];
return boost::re_detail::re_default_error_messages[id];
}
cpp_regex_traits<wchar_t>::cpp_regex_traits()
{
pmd = new re_detail::message_data<wchar_t>(locale_inst, std::string(regex_message_cat));
psyntax = pmd->syntax_;
try{
lower_map = new wchar_t[char_set_size];
}
catch(...)
{
delete pmd;
throw;
}
for(unsigned int i = 0; i < char_set_size; ++i)
lower_map[i] = static_cast<wchar_t>(i);
pctype = &BOOST_RE_USE_FACET(locale_inst, std::ctype<wchar_t>);
pctype->tolower(&lower_map[0], &lower_map[char_set_size]);
pcollate = &BOOST_RE_USE_FACET(locale_inst, std::collate<wchar_t>);
typedef std::codecvt<wchar_t, char, std::mbstate_t> cvt_t;
pcdv = &BOOST_RE_USE_FACET(locale_inst, cvt_t);
sort_type = re_detail::find_sort_syntax(this, &(this->sort_delim));
}
cpp_regex_traits<wchar_t>::~cpp_regex_traits()
{
delete pmd;
delete[] lower_map;
}
cpp_regex_traits<wchar_t>::locale_type BOOST_RE_CALL cpp_regex_traits<wchar_t>::imbue(locale_type l)
{
locale_type old_l(locale_inst);
locale_inst = l;
re_detail::message_data<wchar_t>* npmd = new re_detail::message_data<wchar_t>(locale_inst, std::string(regex_message_cat));
delete pmd;
pmd = npmd;
psyntax = pmd->syntax_;
for(unsigned int i = 0; i < char_set_size; ++i)
lower_map[i] = static_cast<wchar_t>(i);
pctype = &BOOST_RE_USE_FACET(locale_inst, std::ctype<wchar_t>);
pctype->tolower(&lower_map[0], &lower_map[char_set_size]);
pcollate = &BOOST_RE_USE_FACET(locale_inst, std::collate<wchar_t>);
typedef std::codecvt<wchar_t, char, std::mbstate_t> cvt_t;
pcdv = &BOOST_RE_USE_FACET(locale_inst, cvt_t);
sort_type = re_detail::find_sort_syntax(this, &(this->sort_delim));
return old_l;
}
unsigned int BOOST_RE_CALL cpp_regex_traits<wchar_t>::strwiden(wchar_t *s1, unsigned int len, const char *s2)const
{
std::string s(s2);
std::wstring ws = re_detail::to_wide(s2, *pcdv);
if(len > ws.size())
std::wcscpy(s1, ws.c_str());
return ws.size()+1;
}
#endif // BOOST_RE_NO_WCSTRING
} // namespace boost
#endif

View File

@ -1,596 +0,0 @@
/*
*
* 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.
*
*/
/*
* LOCATION: see http://www.boost.org for most recent version.
* FILE: cregex.cpp
* VERSION: 3.12
* DESCRIPTION: Implements high level class boost::RexEx
*/
#include <boost/cregex.hpp>
#include <boost/regex.hpp>
#if !defined(BOOST_RE_NO_STRING_H)
#include <map>
#include <list>
#include <boost/regex/detail/fileiter.hpp>
#include <cstdio>
namespace boost{
#ifdef __BORLANDC__
#if __BORLANDC__ < 0x530
//
// we need to instantiate the vector classes we use
// since declaring a reference to type doesn't seem to
// do the job...
std::vector<unsigned int> inst1;
std::vector<std::string> inst2;
#endif
#endif
namespace{
template <class iterator>
std::string to_string(iterator i, iterator j)
{
BOOST_RE_GUARD_STACK
std::string s;
while(i != j)
{
s.append(1, *i);
++i;
}
return s;
}
inline std::string to_string(const char* i, const char* j)
{
return std::string(i, j);
}
}
namespace re_detail{
class RegExData
{
public:
enum type
{
type_pc,
type_pf,
type_copy
};
regex e;
cmatch m;
match_results<mapfile::iterator, regex::allocator_type> fm;
type t;
const char* pbase;
unsigned line;
mapfile::iterator fbase;
std::map<int, std::string, std::less<int> > strings;
std::map<int, int, std::less<int> > positions;
void update();
void clean();
RegExData() : e(), m(), fm(), t(type_copy), pbase(0), line(0), fbase(), strings(), positions() {}
};
void RegExData::update()
{
BOOST_RE_GUARD_STACK
strings.erase(strings.begin(), strings.end());
positions.erase(positions.begin(), positions.end());
if(t == type_pc)
{
for(unsigned int i = 0; i < m.size(); ++i)
{
if(m[i].matched) strings[i] = std::string(m[i].first, m[i].second);
positions[i] = m[i].matched ? m[i].first - pbase : -1;
}
line = m.line();
}
else
{
for(unsigned int i = 0; i < fm.size(); ++i)
{
if(fm[i].matched) strings[i] = to_string(fm[i].first, fm[i].second);
positions[i] = fm[i].matched ? fm[i].first - fbase : -1;
}
line = fm.line();
}
t = type_copy;
}
void RegExData::clean()
{
BOOST_RE_GUARD_STACK
fbase = mapfile::iterator();
fm = match_results<mapfile::iterator, regex::allocator_type>();
}
} // namespace
RegEx::RegEx()
{
BOOST_RE_GUARD_STACK
pdata = new re_detail::RegExData();
}
RegEx::RegEx(const RegEx& o)
{
BOOST_RE_GUARD_STACK
pdata = new re_detail::RegExData(*(o.pdata));
}
RegEx::~RegEx()
{
BOOST_RE_GUARD_STACK
delete pdata;
}
RegEx::RegEx(const char* c, bool icase)
{
BOOST_RE_GUARD_STACK
pdata = new re_detail::RegExData();
SetExpression(c, icase);
}
RegEx::RegEx(const std::string& s, bool icase)
{
BOOST_RE_GUARD_STACK
pdata = new re_detail::RegExData();
SetExpression(s.c_str(), icase);
}
RegEx& RegEx::operator=(const RegEx& o)
{
BOOST_RE_GUARD_STACK
*pdata = *(o.pdata);
return *this;
}
RegEx& RegEx::operator=(const char* p)
{
BOOST_RE_GUARD_STACK
SetExpression(p, false);
return *this;
}
unsigned int RegEx::SetExpression(const char* p, bool icase)
{
BOOST_RE_GUARD_STACK
boost::uint_fast32_t f = icase ? regbase::normal | regbase::use_except | regbase::icase : regbase::normal | regbase::use_except;
return pdata->e.set_expression(p, f);
}
std::string RegEx::Expression()const
{
BOOST_RE_GUARD_STACK
return pdata->e.expression();
}
//
// now matching operators:
//
bool RegEx::Match(const char* p, unsigned int flags)
{
BOOST_RE_GUARD_STACK
pdata->t = re_detail::RegExData::type_pc;
pdata->pbase = p;
const char* end = p;
while(*end)++end;
if(regex_match(p, end, pdata->m, pdata->e, flags))
{
pdata->update();
return true;
}
return false;
}
bool RegEx::Search(const char* p, unsigned int flags)
{
BOOST_RE_GUARD_STACK
pdata->t = re_detail::RegExData::type_pc;
pdata->pbase = p;
const char* end = p;
while(*end)++end;
if(regex_search(p, end, pdata->m, pdata->e, flags))
{
pdata->update();
return true;
}
return false;
}
namespace re_detail{
struct pred1
{
GrepCallback cb;
RegEx* pe;
pred1(GrepCallback c, RegEx* i) : cb(c), pe(i) {}
bool operator()(const cmatch& m)
{
pe->pdata->m = m;
return cb(*pe);
}
};
}
unsigned int RegEx::Grep(GrepCallback cb, const char* p, unsigned int flags)
{
BOOST_RE_GUARD_STACK
pdata->t = re_detail::RegExData::type_pc;
pdata->pbase = p;
const char* end = p;
while(*end)++end;
unsigned int result = regex_grep(re_detail::pred1(cb, this), p, end, pdata->e, flags);
if(result)
pdata->update();
return result;
}
namespace re_detail{
struct pred2
{
std::vector<std::string>& v;
RegEx* pe;
pred2(std::vector<std::string>& o, RegEx* e) : v(o), pe(e) {}
bool operator()(const cmatch& m)
{
pe->pdata->m = m;
v.push_back(std::string(m[0].first, m[0].second));
return true;
}
private:
pred2& operator=(const pred2&);
};
}
unsigned int RegEx::Grep(std::vector<std::string>& v, const char* p, unsigned int flags)
{
BOOST_RE_GUARD_STACK
pdata->t = re_detail::RegExData::type_pc;
pdata->pbase = p;
const char* end = p;
while(*end)++end;
unsigned int result = regex_grep(re_detail::pred2(v, this), p, end, pdata->e, flags);
if(result)
pdata->update();
return result;
}
namespace re_detail{
struct pred3
{
std::vector<unsigned int>& v;
const char* base;
RegEx* pe;
pred3(std::vector<unsigned int>& o, const char* pb, RegEx* p) : v(o), base(pb), pe(p) {}
bool operator()(const cmatch& m)
{
pe->pdata->m = m;
v.push_back(m[0].first - base);
return true;
}
private:
pred3& operator=(const pred3&);
};
}
unsigned int RegEx::Grep(std::vector<unsigned int>& v, const char* p, unsigned int flags)
{
BOOST_RE_GUARD_STACK
pdata->t = re_detail::RegExData::type_pc;
pdata->pbase = p;
const char* end = p;
while(*end)++end;
unsigned int result = regex_grep(re_detail::pred3(v, p, this), p, end, pdata->e, flags);
if(result)
pdata->update();
return result;
}
namespace re_detail{
struct pred4
{
GrepFileCallback cb;
RegEx* pe;
const char* file;
bool ok;
pred4(GrepFileCallback c, RegEx* i, const char* f) : cb(c), pe(i), file(f), ok(true) {}
bool operator()(const match_results<mapfile::iterator, regex::allocator_type>& m)
{
pe->pdata->t = RegExData::type_pf;
pe->pdata->fm = m;
pe->pdata->update();
ok = cb(file, *pe);
return ok;
}
};
}
namespace{
void BuildFileList(std::list<std::string>* pl, const char* files, bool recurse)
{
BOOST_RE_GUARD_STACK
file_iterator start(files);
file_iterator end;
if(recurse)
{
// go through sub directories:
char buf[MAX_PATH];
std::strcpy(buf, start.root());
if(*buf == 0)
{
std::strcpy(buf, ".");
std::strcat(buf, directory_iterator::separator());
std::strcat(buf, "*");
}
else
{
std::strcat(buf, directory_iterator::separator());
std::strcat(buf, "*");
}
directory_iterator dstart(buf);
directory_iterator dend;
// now get the file mask bit of "files":
const char* ptr = files;
while(*ptr) ++ptr;
while((ptr != files) && (*ptr != *directory_iterator::separator()) && (*ptr != '/'))--ptr;
if(ptr != files) ++ptr;
while(dstart != dend)
{
std::sprintf(buf, "%s%s%s", dstart.path(), directory_iterator::separator(), ptr);
BuildFileList(pl, buf, recurse);
++dstart;
}
}
while(start != end)
{
pl->push_back(*start);
++start;
}
}
}
unsigned int RegEx::GrepFiles(GrepFileCallback cb, const char* files, bool recurse, unsigned int flags)
{
BOOST_RE_GUARD_STACK
unsigned int result = 0;
std::list<std::string> file_list;
BuildFileList(&file_list, files, recurse);
std::list<std::string>::iterator start, end;
start = file_list.begin();
end = file_list.end();
while(start != end)
{
mapfile map((*start).c_str());
pdata->t = re_detail::RegExData::type_pf;
pdata->fbase = map.begin();
re_detail::pred4 pred(cb, this, (*start).c_str());
int r = regex_grep(pred, map.begin(), map.end(), pdata->e, flags);
result += r;
++start;
pdata->clean();
if(pred.ok == false)
return result;
}
return result;
}
unsigned int RegEx::FindFiles(FindFilesCallback cb, const char* files, bool recurse, unsigned int flags)
{
BOOST_RE_GUARD_STACK
unsigned int result = 0;
std::list<std::string> file_list;
BuildFileList(&file_list, files, recurse);
std::list<std::string>::iterator start, end;
start = file_list.begin();
end = file_list.end();
while(start != end)
{
mapfile map((*start).c_str());
pdata->t = re_detail::RegExData::type_pf;
pdata->fbase = map.begin();
if(regex_search(map.begin(), map.end(), pdata->fm, pdata->e, flags))
{
++result;
if(false == cb((*start).c_str()))
return result;
}
//pdata->update();
++start;
//pdata->clean();
}
return result;
}
std::string RegEx::Merge(const std::string& in, const std::string& fmt,
bool copy, unsigned int flags)
{
std::string result;
re_detail::string_out_iterator<std::string> i(result);
if(!copy) flags |= format_no_copy;
regex_merge(i, in.begin(), in.end(), pdata->e, fmt.c_str(), flags);
return result;
}
std::string RegEx::Merge(const char* in, const char* fmt,
bool copy, unsigned int flags)
{
std::string result;
if(!copy) flags |= format_no_copy;
re_detail::string_out_iterator<std::string> i(result);
regex_merge(i, in, in + std::strlen(in), pdata->e, fmt, flags);
return result;
}
unsigned int RegEx::Split(std::vector<std::string>& v,
std::string& s,
unsigned flags,
unsigned max_count)
{
return regex_split(std::back_inserter(v), s, pdata->e, flags, max_count);
}
//
// now operators for returning what matched in more detail:
//
unsigned int RegEx::Position(int i)const
{
BOOST_RE_GUARD_STACK
switch(pdata->t)
{
case re_detail::RegExData::type_pc:
return pdata->m[i].matched ? pdata->m[i].first - pdata->pbase : (unsigned int)-1;
case re_detail::RegExData::type_pf:
return pdata->fm[i].matched ? pdata->fm[i].first - pdata->fbase : (unsigned int)-1;
case re_detail::RegExData::type_copy:
{
std::map<int, int, std::less<int> >::iterator pos = pdata->positions.find(i);
if(pos == pdata->positions.end())
return (unsigned int)-1;
return (*pos).second;
}
}
return (unsigned int)-1;
}
unsigned int RegEx::Line()const
{
BOOST_RE_GUARD_STACK
switch(pdata->t)
{
case re_detail::RegExData::type_pc:
return pdata->m[0].matched ? pdata->m.line() : (unsigned int)-1;
case re_detail::RegExData::type_pf:
return pdata->fm[0].matched ? pdata->fm.line() : (unsigned int)-1;
case re_detail::RegExData::type_copy:
{
return pdata->line;
}
}
return (unsigned int)-1;
}
unsigned int RegEx::Marks()const
{
BOOST_RE_GUARD_STACK
return pdata->e.mark_count();
}
unsigned int RegEx::Length(int i)const
{
BOOST_RE_GUARD_STACK
switch(pdata->t)
{
case re_detail::RegExData::type_pc:
return pdata->m[i].matched ? pdata->m[i].second - pdata->m[i].first : (unsigned)-1;
case re_detail::RegExData::type_pf:
return pdata->fm[i].matched ? pdata->fm[i].second - pdata->fm[i].first : (unsigned)-1;
case re_detail::RegExData::type_copy:
{
std::map<int, std::string, std::less<int> >::iterator pos = pdata->strings.find(i);
if(pos == pdata->strings.end())
return (unsigned)-1;
return (*pos).second.size();
}
}
return (unsigned)-1;
}
std::string RegEx::What(int i)const
{
BOOST_RE_GUARD_STACK
std::string result;
switch(pdata->t)
{
case re_detail::RegExData::type_pc:
if(pdata->m[i].matched)
result.assign(pdata->m[i].first, pdata->m[i].second);
break;
case re_detail::RegExData::type_pf:
if(pdata->m[i].matched)
result.assign(to_string(pdata->m[i].first, pdata->m[i].second));
break;
case re_detail::RegExData::type_copy:
{
std::map<int, std::string, std::less<int> >::iterator pos = pdata->strings.find(i);
if(pos != pdata->strings.end())
result = (*pos).second;
break;
}
}
return result;
}
} // namespace boost
#if defined(__BORLANDC__) && (__BORLANDC__ >= 0x550) && (__BORLANDC__ <= 0x551) && !defined(_RWSTD_COMPILE_INSTANTIATE)
//
// this is an ugly hack to work around an ugly problem:
// by default this file will produce unresolved externals during
// linking unless _RWSTD_COMPILE_INSTANTIATE is defined (Borland bug).
// However if _RWSTD_COMPILE_INSTANTIATE is defined then we get separate
// copies of basic_string's static data in the RTL and this DLL, this messes
// with basic_string's memory management and results in run-time crashes,
// Oh sweet joy of Catch 22....
//
namespace std{
template<> template<>
basic_string<char>&
basic_string<char>::replace<const char*>(char* f1, char* f2, const char* i1, const char* i2)
{
unsigned insert_pos = f1 - begin();
unsigned remove_len = f2 - f1;
unsigned insert_len = i2 - i1;
unsigned org_size = size();
if(insert_len > remove_len)
{
append(insert_len-remove_len, ' ');
std::copy_backward(begin() + insert_pos + remove_len, begin() + org_size, end());
std::copy(i1, i2, begin() + insert_pos);
}
else
{
std::copy(begin() + insert_pos + remove_len, begin() + org_size, begin() + insert_pos + insert_len);
std::copy(i1, i2, begin() + insert_pos);
erase(size() + insert_len - remove_len);
}
return *this;
}
}
#endif
#endif

View File

@ -1,832 +0,0 @@
/*
*
* 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.
*
*/
/*
* LOCATION: see http://www.boost.org for most recent version.
* FILE: fileiter.cpp
* VERSION: 3.12
* DESCRIPTION: Implements file io primitives + directory searching for class boost::RegEx.
*/
#include <climits>
#include <stdexcept>
#include <boost/regex/detail/fileiter.hpp>
#if defined(__CYGWIN__) || defined(__CYGWIN32__)
#include <sys/cygwin.h>
#endif
namespace boost{
namespace re_detail{
// start with the operating system specific stuff:
#if (defined(__BORLANDC__) || defined(FI_WIN32_DIR) || defined(BOOST_MSVC)) && !defined(BOOST_RE_NO_WIN32)
// platform is DOS or Windows
// directories are separated with '\\'
// and names are insensitive of case
const char* _fi_sep = "\\";
const char* _fi_sep_alt = "/";
#define FI_TRANSLATE(c) std::tolower(c)
#else
// platform is not DOS or Windows
// directories are separated with '/'
// and names are sensitive of case
const char* _fi_sep = "/";
const char* _fi_sep_alt = _fi_sep;
#define FI_TRANSLATE(c) c
#endif
#ifdef FI_WIN32_MAP
void mapfile::open(const char* file)
{
BOOST_RE_GUARD_STACK
#if defined(__CYGWIN__)||defined(__CYGWIN32__)
char win32file[ MAX_PATH ];
cygwin_conv_to_win32_path( file, win32file );
hfile = CreateFile(win32file, GENERIC_READ, FILE_SHARE_READ, 0, OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, 0);
#else
hfile = CreateFile(file, GENERIC_READ, FILE_SHARE_READ, 0, OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, 0);
#endif
if(hfile != INVALID_HANDLE_VALUE)
{
hmap = CreateFileMapping(hfile, 0, PAGE_READONLY, 0, 0, 0);
if(hmap == INVALID_HANDLE_VALUE)
{
CloseHandle(hfile);
hmap = 0;
hfile = 0;
throw std::runtime_error("Unable to create file mapping.");
}
_first = (const char*)MapViewOfFile(hmap, FILE_MAP_READ, 0, 0, 0);
if(_first == 0)
{
CloseHandle(hmap);
CloseHandle(hfile);
hmap = 0;
hfile = 0;
throw std::runtime_error("Unable to create file mapping.");
}
_last = _first + GetFileSize(hfile, 0);
}
else
{
hfile = 0;
throw std::runtime_error("Unable to open file.");
}
}
void mapfile::close()
{
BOOST_RE_GUARD_STACK
if(hfile != INVALID_HANDLE_VALUE)
{
UnmapViewOfFile((void*)_first);
CloseHandle(hmap);
CloseHandle(hfile);
hmap = hfile = 0;
_first = _last = 0;
}
}
#elif !defined(BOOST_RE_NO_STL)
mapfile_iterator& mapfile_iterator::operator = (const mapfile_iterator& i)
{
BOOST_RE_GUARD_STACK
if(file && node)
file->unlock(node);
file = i.file;
node = i.node;
offset = i.offset;
if(file)
file->lock(node);
return *this;
}
mapfile_iterator& mapfile_iterator::operator++ ()
{
BOOST_RE_GUARD_STACK
if((++offset == mapfile::buf_size) && file)
{
++node;
offset = 0;
file->lock(node);
file->unlock(node-1);
}
return *this;
}
mapfile_iterator mapfile_iterator::operator++ (int)
{
BOOST_RE_GUARD_STACK
mapfile_iterator temp(*this);
if((++offset == mapfile::buf_size) && file)
{
++node;
offset = 0;
file->lock(node);
file->unlock(node-1);
}
return temp;
}
mapfile_iterator& mapfile_iterator::operator-- ()
{
BOOST_RE_GUARD_STACK
if((offset == 0) && file)
{
--node;
offset = mapfile::buf_size - 1;
file->lock(node);
file->unlock(node + 1);
}
else
--offset;
return *this;
}
mapfile_iterator mapfile_iterator::operator-- (int)
{
BOOST_RE_GUARD_STACK
mapfile_iterator temp(*this);
if((offset == 0) && file)
{
--node;
offset = mapfile::buf_size - 1;
file->lock(node);
file->unlock(node + 1);
}
else
--offset;
return temp;
}
mapfile_iterator operator + (const mapfile_iterator& i, long off)
{
BOOST_RE_GUARD_STACK
mapfile_iterator temp(i);
temp += off;
return temp;
}
mapfile_iterator operator - (const mapfile_iterator& i, long off)
{
BOOST_RE_GUARD_STACK
mapfile_iterator temp(i);
temp -= off;
return temp;
}
mapfile::iterator mapfile::begin()const
{
BOOST_RE_GUARD_STACK
return mapfile_iterator(this, 0);
}
mapfile::iterator mapfile::end()const
{
BOOST_RE_GUARD_STACK
return mapfile_iterator(this, _size);
}
void mapfile::lock(pointer* node)const
{
BOOST_RE_GUARD_STACK
assert(node >= _first);
assert(node <= _last);
if(node < _last)
{
if(*node == 0)
{
if(condemed.empty())
{
*node = new char[sizeof(int) + buf_size];
*((int*)(*node)) = 1;
}
else
{
pointer* p = condemed.front();
condemed.pop_front();
*node = *p;
*p = 0;
*((int*)(*node)) = 1;
}
std::fseek(hfile, (node - _first) * buf_size, SEEK_SET);
if(node == _last - 1)
std::fread(*node + sizeof(int), _size % buf_size, 1, hfile);
else
std::fread(*node + sizeof(int), buf_size, 1, hfile);
}
else
{
if(*((int*)(*node)) == 0)
{
*((int*)(*node)) = 1;
condemed.remove(node);
}
else
++(*((int*)(*node)));
}
}
}
void mapfile::unlock(pointer* node)const
{
BOOST_RE_GUARD_STACK
assert(node >= _first);
assert(node <= _last);
if(node < _last)
{
if(--(*((int*)(*node))) == 0)
{
condemed.push_back(node);
}
}
}
long int get_file_length(std::FILE* hfile)
{
BOOST_RE_GUARD_STACK
long int result;
std::fseek(hfile, 0, SEEK_END);
result = std::ftell(hfile);
std::fseek(hfile, 0, SEEK_SET);
return result;
}
void mapfile::open(const char* file)
{
BOOST_RE_GUARD_STACK
hfile = std::fopen(file, "rb");
try{
if(hfile != 0)
{
_size = get_file_length(hfile);
long cnodes = (_size + buf_size - 1) / buf_size;
// check that number of nodes is not too high:
if(cnodes > (long)((INT_MAX) / sizeof(pointer*)))
{
std::fclose(hfile);
hfile = 0;
_size = 0;
return;
}
_first = new pointer[(int)cnodes];
_last = _first + cnodes;
std::memset(_first, 0, cnodes*sizeof(pointer));
}
else
{
throw std::runtime_error("Unable to open file.");
}
}catch(...)
{ close(); throw; }
}
void mapfile::close()
{
BOOST_RE_GUARD_STACK
if(hfile != 0)
{
pointer* p = _first;
while(p != _last)
{
if(*p)
delete[] *p;
++p;
}
delete[] _first;
_size = 0;
_first = _last = 0;
std::fclose(hfile);
hfile = 0;
condemed.erase(condemed.begin(), condemed.end());
}
}
#endif
file_iterator::file_iterator()
{
BOOST_RE_GUARD_STACK
_root = _path = 0;
ref = 0;
try{
_root = new char[MAX_PATH];
_path = new char[MAX_PATH];
ptr = _path;
*_path = 0;
*_root = 0;
ref = new file_iterator_ref();
ref->hf = _fi_invalid_handle;
ref->count = 1;
}
catch(...)
{
delete[] _root;
delete[] _path;
delete ref;
throw;
}
}
file_iterator::file_iterator(const char* wild)
{
BOOST_RE_GUARD_STACK
_root = _path = 0;
ref = 0;
try{
_root = new char[MAX_PATH];
_path = new char[MAX_PATH];
std::strcpy(_root, wild);
ptr = _root;
while(*ptr)++ptr;
while((ptr > _root) && (*ptr != *_fi_sep) && (*ptr != *_fi_sep_alt))--ptr;
#if 0
*ptr = 0;
std::strcpy(_path, _root);
if(*_path == 0)
std::strcpy(_path, ".");
std::strcat(_path, _fi_sep);
ptr = _path + std::strlen(_path);
#else
if((ptr == _root) && ( (*ptr== *_fi_sep) || (*ptr==*_fi_sep_alt) ) )
{
_root[1]='\0';
std::strcpy(_path, _root);
ptr = _path + std::strlen(_path);
}
else
{
*ptr = 0;
std::strcpy(_path, _root);
if(*_path == 0)
std::strcpy(_path, ".");
std::strcat(_path, _fi_sep);
ptr = _path + std::strlen(_path);
}
#endif
ref = new file_iterator_ref();
ref->hf = FindFirstFile(wild, &(ref->_data));
ref->count = 1;
if(ref->hf == _fi_invalid_handle)
{
*_path = 0;
ptr = _path;
}
else
{
std::strcpy(ptr, ref->_data.cFileName);
if(ref->_data.dwFileAttributes & _fi_dir)
next();
}
}
catch(...)
{
delete[] _root;
delete[] _path;
delete ref;
throw;
}
}
file_iterator::file_iterator(const file_iterator& other)
{
BOOST_RE_GUARD_STACK
_root = _path = 0;
ref = 0;
try{
_root = new char[MAX_PATH];
_path = new char[MAX_PATH];
std::strcpy(_root, other._root);
std::strcpy(_path, other._path);
ptr = _path + (other.ptr - other._path);
ref = other.ref;
}
catch(...)
{
delete[] _root;
delete[] _path;
throw;
}
++(ref->count);
}
file_iterator& file_iterator::operator=(const file_iterator& other)
{
BOOST_RE_GUARD_STACK
std::strcpy(_root, other._root);
std::strcpy(_path, other._path);
ptr = _path + (other.ptr - other._path);
if(--(ref->count) == 0)
{
if(ref->hf != _fi_invalid_handle)
FindClose(ref->hf);
delete ref;
}
ref = other.ref;
++(ref->count);
return *this;
}
file_iterator::~file_iterator()
{
BOOST_RE_GUARD_STACK
delete[] _root;
delete[] _path;
if(--(ref->count) == 0)
{
if(ref->hf != _fi_invalid_handle)
FindClose(ref->hf);
delete ref;
}
}
file_iterator file_iterator::operator++(int)
{
BOOST_RE_GUARD_STACK
file_iterator temp(*this);
next();
return temp;
}
void file_iterator::next()
{
BOOST_RE_GUARD_STACK
if(ref->hf != _fi_invalid_handle)
{
bool cont = true;
while(cont)
{
cont = FindNextFile(ref->hf, &(ref->_data));
if(cont && ((ref->_data.dwFileAttributes & _fi_dir) == 0))
break;
}
if(!cont)
{
// end of sequence
FindClose(ref->hf);
ref->hf = _fi_invalid_handle;
*_path = 0;
ptr = _path;
}
else
std::strcpy(ptr, ref->_data.cFileName);
}
}
directory_iterator::directory_iterator()
{
BOOST_RE_GUARD_STACK
_root = _path = 0;
ref = 0;
try{
_root = new char[MAX_PATH];
_path = new char[MAX_PATH];
ptr = _path;
*_path = 0;
*_root = 0;
ref = new file_iterator_ref();
ref->hf = _fi_invalid_handle;
ref->count = 1;
}
catch(...)
{
delete[] _root;
delete[] _path;
delete ref;
throw;
}
}
directory_iterator::directory_iterator(const char* wild)
{
BOOST_RE_GUARD_STACK
_root = _path = 0;
ref = 0;
try{
_root = new char[MAX_PATH];
_path = new char[MAX_PATH];
std::strcpy(_root, wild);
ptr = _root;
while(*ptr)++ptr;
while((ptr > _root) && (*ptr != *_fi_sep) && (*ptr != *_fi_sep_alt))--ptr;
#if 0
*ptr = 0;
std::strcpy(_path, _root);
if(*_path == 0)
std::strcpy(_path, ".");
std::strcat(_path, _fi_sep);
ptr = _path + std::strlen(_path);
#else
if((ptr == _root) && ( (*ptr== *_fi_sep) || (*ptr==*_fi_sep_alt) ) )
{
_root[1]='\0';
std::strcpy(_path, _root);
ptr = _path + std::strlen(_path);
}
else
{
*ptr = 0;
std::strcpy(_path, _root);
if(*_path == 0)
std::strcpy(_path, ".");
std::strcat(_path, _fi_sep);
ptr = _path + std::strlen(_path);
}
#endif
ref = new file_iterator_ref();
ref->count = 1;
ref->hf = FindFirstFile(wild, &(ref->_data));
if(ref->hf == _fi_invalid_handle)
{
*_path = 0;
ptr = _path;
}
else
{
std::strcpy(ptr, ref->_data.cFileName);
if(((ref->_data.dwFileAttributes & _fi_dir) == 0) || (std::strcmp(ref->_data.cFileName, ".") == 0) || (std::strcmp(ref->_data.cFileName, "..") == 0))
next();
}
}
catch(...)
{
delete[] _root;
delete[] _path;
delete ref;
throw;
}
}
directory_iterator::~directory_iterator()
{
BOOST_RE_GUARD_STACK
delete[] _root;
delete[] _path;
if(--(ref->count) == 0)
{
if(ref->hf != _fi_invalid_handle)
FindClose(ref->hf);
delete ref;
}
}
directory_iterator::directory_iterator(const directory_iterator& other)
{
BOOST_RE_GUARD_STACK
_root = _path = 0;
ref = 0;
try{
_root = new char[MAX_PATH];
_path = new char[MAX_PATH];
std::strcpy(_root, other._root);
std::strcpy(_path, other._path);
ptr = _path + (other.ptr - other._path);
ref = other.ref;
}
catch(...)
{
delete[] _root;
delete[] _path;
throw;
}
++(ref->count);
}
directory_iterator& directory_iterator::operator=(const directory_iterator& other)
{
BOOST_RE_GUARD_STACK
std::strcpy(_root, other._root);
std::strcpy(_path, other._path);
ptr = _path + (other.ptr - other._path);
if(--(ref->count) == 0)
{
if(ref->hf != _fi_invalid_handle)
FindClose(ref->hf);
delete ref;
}
ref = other.ref;
++(ref->count);
return *this;
}
directory_iterator directory_iterator::operator++(int)
{
BOOST_RE_GUARD_STACK
directory_iterator temp(*this);
next();
return temp;
}
void directory_iterator::next()
{
BOOST_RE_GUARD_STACK
if(ref->hf != _fi_invalid_handle)
{
bool cont = true;
while(cont)
{
cont = FindNextFile(ref->hf, &(ref->_data));
if(cont && (ref->_data.dwFileAttributes & _fi_dir))
{
if(std::strcmp(ref->_data.cFileName, ".") && std::strcmp(ref->_data.cFileName, ".."))
break;
}
}
if(!cont)
{
// end of sequence
FindClose(ref->hf);
ref->hf = _fi_invalid_handle;
*_path = 0;
ptr = _path;
}
else
std::strcpy(ptr, ref->_data.cFileName);
}
}
#ifdef FI_POSIX_DIR
struct _fi_priv_data
{
char root[MAX_PATH];
char* mask;
DIR* d;
_fi_priv_data(const char* p);
};
_fi_priv_data::_fi_priv_data(const char* p)
{
BOOST_RE_GUARD_STACK
std::strcpy(root, p);
mask = root;
while(*mask) ++mask;
while((mask > root) && (*mask != *_fi_sep) && (*mask != *_fi_sep_alt)) --mask;
if(mask == root && ((*mask== *_fi_sep) || (*mask == *_fi_sep_alt)) )
{
root[1] = '\0';
std::strcpy(root+2, p+1);
mask = root+2;
}
else if(mask == root)
{
root[0] = '.';
root[1] = '\0';
std::strcpy(root+2, p);
mask = root+2;
}
else
{
*mask = 0;
++mask;
}
}
bool iswild(const char* mask, const char* name)
{
BOOST_RE_GUARD_STACK
while(*mask && *name)
{
switch(*mask)
{
case '?':
++name;
++mask;
continue;
case '*':
++mask;
if(*mask == 0)
return true;
while(*name)
{
if(iswild(mask, name))
return true;
++name;
}
return false;
case '.':
if(0 == *name)
{
++mask;
continue;
}
// fall through:
default:
if(FI_TRANSLATE(*mask) != FI_TRANSLATE(*name))
return false;
++mask;
++name;
continue;
}
}
if(*mask != *name)
return false;
return true;
}
unsigned _fi_attributes(const char* root, const char* name)
{
BOOST_RE_GUARD_STACK
char buf[MAX_PATH];
if( ( (root[0] == *_fi_sep) || (root[0] == *_fi_sep_alt) ) && (root[1] == '\0') )
std::sprintf(buf, "%s%s", root, name);
else
std::sprintf(buf, "%s%s%s", root, _fi_sep, name);
DIR* d = opendir(buf);
if(d)
{
closedir(d);
return _fi_dir;
}
return 0;
}
_fi_find_handle _fi_FindFirstFile(const char* lpFileName, _fi_find_data* lpFindFileData)
{
BOOST_RE_GUARD_STACK
_fi_find_handle dat = new _fi_priv_data(lpFileName);
DIR* h = opendir(dat->root);
dat->d = h;
if(h != 0)
{
if(_fi_FindNextFile(dat, lpFindFileData))
return dat;
}
delete dat;
return 0;
}
bool _fi_FindNextFile(_fi_find_handle dat, _fi_find_data* lpFindFileData)
{
BOOST_RE_GUARD_STACK
dirent* d;
do
{
d = readdir(dat->d);
} while(d && !iswild(dat->mask, d->d_name));
if(d)
{
std::strcpy(lpFindFileData->cFileName, d->d_name);
lpFindFileData->dwFileAttributes = _fi_attributes(dat->root, d->d_name);
return true;
}
return false;
}
bool _fi_FindClose(_fi_find_handle dat)
{
BOOST_RE_GUARD_STACK
closedir(dat->d);
delete dat;
return true;
}
#endif
} // namespace re_detail
} // namspace boost

View File

@ -1,219 +0,0 @@
/*
*
* 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.
*
*/
/*
* LOCATION: see http://www.boost.org for most recent version.
* FILE: posix_api.cpp
* VERSION: 3.12
* DESCRIPTION: Implements the Posix API wrappers.
*/
#include <cstdio>
#include <boost/regex.hpp>
namespace boost{
namespace{
unsigned int magic_value = 25631;
const char* names[] = {"REG_NOERROR", "REG_NOMATCH", "REG_BADPAT", "REG_ECOLLATE",
"REG_ECTYPE", "REG_EESCAPE", "REG_ESUBREG", "REG_EBRACK",
"REG_EPAREN", "REG_EBRACE", "REG_BADBR", "REG_ERANGE",
"REG_ESPACE", "REG_BADRPT", "REG_EMPTY", "REG_E_UNKNOWN"};
} // namespace
BOOST_RE_IX_DECL int BOOST_RE_CCALL regcompA(regex_tA* expression, const char* ptr, int f)
{
BOOST_RE_GUARD_STACK
if(expression->re_magic != magic_value)
{
expression->guts = 0;
try{
expression->guts = new regex();
} catch(...)
{
return REG_ESPACE;
}
}
// set default flags:
boost::uint_fast32_t flags = (f & REG_EXTENDED) ? regbase::extended : regbase::basic;
expression->eflags = (f & REG_NEWLINE) ? match_not_dot_newline : 0;
// and translate those that are actually set:
if(f & REG_NOCOLLATE)
flags |= regbase::nocollate;
if(f & REG_NOSUB)
expression->eflags |= match_any;
if(f & REG_NOSPEC)
flags |= regbase::literal;
if(f & REG_ICASE)
flags |= regbase::icase;
if(f & REG_ESCAPE_IN_LISTS)
flags |= regbase::escape_in_lists;
if(f & REG_NEWLINE_ALT)
flags |= regbase::newline_alt;
const char* p2;
if(f & REG_PEND)
p2 = expression->re_endp;
else p2 = ptr + std::strlen(ptr);
int result;
try{
expression->re_magic = magic_value;
((regex*)(expression->guts))->set_expression(ptr, p2, flags);
expression->re_nsub = ((regex*)(expression->guts))->mark_count() - 1;
result = ((regex*)(expression->guts))->error_code();
} catch(...)
{
result = REG_E_UNKNOWN;
}
if(result)
regfreeA(expression);
return result;
}
BOOST_RE_IX_DECL unsigned int BOOST_RE_CCALL regerrorA(int code, const regex_tA* e, char* buf, unsigned int buf_size)
{
BOOST_RE_GUARD_STACK
unsigned int result = 0;
if(code & REG_ITOA)
{
code &= ~REG_ITOA;
if(code <= REG_E_UNKNOWN)
{
result = std::strlen(names[code]) + 1;
if(buf_size >= result)
std::strcpy(buf, names[code]);
return result;
}
return result;
}
if(code == REG_ATOI)
{
char localbuf[5];
if(e == 0)
return 0;
for(int i = 0; i <= REG_E_UNKNOWN; ++i)
{
if(std::strcmp(e->re_endp, names[i]) == 0)
{
std::sprintf(localbuf, "%d", i);
if(std::strlen(localbuf) < buf_size)
std::strcpy(buf, localbuf);
return std::strlen(localbuf) + 1;
}
}
std::sprintf(localbuf, "%d", 0);
if(std::strlen(localbuf) < buf_size)
std::strcpy(buf, localbuf);
return std::strlen(localbuf) + 1;
}
if(code <= REG_E_UNKNOWN)
{
std::string p;
if((e) && (e->re_magic == magic_value))
p = ((regex*)(e->guts))->get_traits().error_string(code);
else
{
boost::regex_traits<char> t;
p = t.error_string(code);
}
unsigned int len = p.size();
if(len < buf_size)
{
std::strcpy(buf, p.c_str());
}
return len + 1;
}
if(buf_size)
*buf = 0;
return 0;
}
BOOST_RE_IX_DECL int BOOST_RE_CCALL regexecA(const regex_tA* expression, const char* buf, unsigned int n, regmatch_t* array, int eflags)
{
BOOST_RE_GUARD_STACK
bool result = false;
boost::uint_fast32_t flags = match_default | expression->eflags;
const char* end;
const char* start;
cmatch m;
if(eflags & REG_NOTBOL)
flags |= match_not_bol;
if(eflags & REG_NOTEOL)
flags |= match_not_eol;
if(eflags & REG_STARTEND)
{
start = buf + array[0].rm_so;
end = buf + array[0].rm_eo;
}
else
{
start = buf;
end = buf + std::strlen(buf);
}
try{
if(expression->re_magic == magic_value)
{
result = regex_search(start, end, m, *(regex*)(expression->guts), flags);
}
else
return result;
} catch(...)
{
return REG_E_UNKNOWN;
}
if(result)
{
// extract what matched:
unsigned int i;
for(i = 0; (i < n) && (i < expression->re_nsub + 1); ++i)
{
array[i].rm_so = (m[i].matched == false) ? -1 : (m[i].first - buf);
array[i].rm_eo = (m[i].matched == false) ? -1 : (m[i].second - buf);
}
// and set anything else to -1:
for(i = expression->re_nsub + 1; i < n; ++i)
{
array[i].rm_so = -1;
array[i].rm_eo = -1;
}
return 0;
}
return REG_NOMATCH;
}
BOOST_RE_IX_DECL void BOOST_RE_CCALL regfreeA(regex_tA* expression)
{
BOOST_RE_GUARD_STACK
if(expression->re_magic == magic_value)
{
delete (regex*)(expression->guts);
}
expression->re_magic = 0;
}
} // namespace boost

View File

@ -1,119 +0,0 @@
/*
*
* 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.
*
*/
/*
* LOCATION: see http://www.boost.org for most recent version.
* FILE: primary_transform.hpp
* VERSION: 3.12
* DESCRIPTION: Heuristically determines the sort string format in use
* by the current locale.
*/
namespace boost{
namespace re_detail{
enum{
sort_C,
sort_fixed,
sort_delim,
sort_unknown
};
template <class S, class charT>
unsigned count_chars(const S& s, charT c)
{
unsigned int count = 0;
for(unsigned pos = 0; pos < s.size(); ++pos)
{
if(s[pos] == c) ++count;
}
return count;
}
template <class traits, class charT>
unsigned find_sort_syntax(const traits* pt, charT* delim)
{
//
// compare 'a' with 'A' to see how similar they are,
// should really use a-accute but we can't portably do that,
//
typedef typename traits::string_type string_type;
typedef typename traits::char_type char_type;
// Suppress incorrect warning for MSVC
(void)pt;
string_type a(1, (char_type)'a');
string_type sa;
pt->transform(sa, a);
if(sa == a)
{
*delim = 0;
return sort_C;
}
string_type A(1, (char_type)'A');
string_type sA;
pt->transform(sA, A);
string_type c(1, (char_type)';');
string_type sc;
pt->transform(sc, c);
int pos = 0;
while((pos <= static_cast<int>(sa.size())) && (pos <= static_cast<int>(sA.size())) && (sa[pos] == sA[pos])) ++pos;
--pos;
if(pos < 0)
{
*delim = 0;
return sort_unknown;
}
//
// at this point sa[pos] is either the end of a fixed with field
// or the character that acts as a delimiter:
//
charT maybe_delim = sa[pos];
if((pos != 0) && (count_chars(sa, maybe_delim) == count_chars(sA, maybe_delim)) && (count_chars(sa, maybe_delim) == count_chars(c, maybe_delim)))
{
*delim = maybe_delim;
return sort_delim;
}
//
// OK doen't look like a delimiter, try for fixed width field:
//
if((sa.size() == sA.size()) && (sa.size() == c.size()))
{
// note assumes that the fixed width field is less than
// numeric_limits<charT>::max(), should be true for all types
// I can't imagine 127 character fields...
*delim = static_cast<charT>(++pos);
return sort_fixed;
}
//
// don't know what it is:
//
*delim = 0;
return sort_unknown;
}
} // namespace re_detail
} // namespace boost

View File

@ -1,59 +0,0 @@
/*
*
* Copyright (c) 1998-200
* 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.cpp
* VERSION: 3.12
* DESCRIPTION: Misc boost::regbase member funnctions.
*/
#include <boost/regex.hpp>
namespace boost{
//
// fix: these are declared out of line here to ensure
// that dll builds contain the Virtual table for these
// types - this ensures that exceptions can be thrown
// from the dll and caught in an exe.
bad_pattern::~bad_pattern() throw() {}
bad_expression::~bad_expression() throw() {}
regbase::regbase()
: _flags(regbase::failbit){}
regbase::regbase(const regbase& b)
: _flags(b._flags){}
} // namespace boost
#if defined(BOOST_RE_USE_VCL) && defined(BOOST_RE_BUILD_DLL)
int WINAPI DllEntryPoint(HINSTANCE , unsigned long , void*)
{
return 1;
}
#endif

View File

@ -1,213 +0,0 @@
/*
*
* 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.
*
*/
/*
* LOCATION: see http://www.boost.org for most recent version.
* FILE: regex_debug.cpp
* VERSION: 3.12
* DESCRIPTION: Misc. debugging helpers.
*/
#include <boost/regex/detail/regex_config.hpp>
#include <boost/regex/detail/regex_raw_buffer.hpp>
#include <boost/regex.hpp>
#ifdef BOOST_MSVC
#include <crtdbg.h>
#endif
#ifdef BOOST_RE_DEBUG
#ifndef BOOST_RE_OLD_IOSTREAM
#include <ostream>
#else
#include <ostream.h>
#endif
namespace boost { namespace re_detail {
std::ostream& operator<<(std::ostream& s, syntax_element_type x)
{
return s << static_cast<unsigned long>(x);
}
}} // namespace boost::re_detail
namespace {
char b1[32] = {0,};
char guard_pattern[32]
= { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15,
16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, };
char b2[32] = {0,};
static const int guard_size = 32;
bool check_pattern(void* p)
{
return p ? memcmp(p, guard_pattern, guard_size) : 0;
}
inline unsigned maxi(unsigned i, unsigned j)
{
return i < j ? j : i;
}
unsigned int allocated = 0;
struct init
{
init();
~init();
};
init::init()
{
#ifdef BOOST_MSVC
_CrtSetDbgFlag(_CRTDBG_ALLOC_MEM_DF|_CRTDBG_DELAY_FREE_MEM_DF|_CRTDBG_LEAK_CHECK_DF);
#endif
}
init::~init()
{
}
init i;
void* get_mem(size_t n)
{
++allocated;
char* p = (char*)malloc(n + guard_size * 2 + maxi(sizeof(int) + sizeof(void*), boost::re_detail::padding_size) + boost::re_detail::padding_size);
char* base = p;
p = (char*)((std::ptrdiff_t)(p + boost::re_detail::padding_mask) & ~boost::re_detail::padding_mask);
std::memcpy(p + maxi(sizeof(int) + sizeof(void*), boost::re_detail::padding_size), guard_pattern, guard_size);
std::memcpy(p + maxi(sizeof(int) + sizeof(void*), boost::re_detail::padding_size) + guard_size + n, guard_pattern, guard_size);
*(int*)p = n;
*(void**)(p + sizeof(int)) = base;
return p + guard_size + maxi(sizeof(int) + sizeof(void*), boost::re_detail::padding_size);
}
void free_mem(void* b)
{
if(b)
{
char* p = (char*)b;
p -= (guard_size + maxi(sizeof(int) + sizeof(void*), boost::re_detail::padding_size));
if(check_pattern(p + maxi(sizeof(int) + sizeof(void*), boost::re_detail::padding_size)) || check_pattern(p + maxi(sizeof(int) + sizeof(void*), boost::re_detail::padding_size) + guard_size + *(int*)p))
{
cerr << "Error: freed memory has been written past end..." << endl;
}
free(*(void**)(p + sizeof(int)));
--allocated;
}
}
} // namespace
void* operator new(size_t n)
{
return get_mem(n);
}
void* operator new[](size_t n)
{
return get_mem(n);
}
void operator delete(void* p)
{
free_mem(p);
}
void operator delete[](void* p)
{
free_mem(p);
}
#include <set>
namespace boost{
namespace re_detail{
std::set<debug_guard*, std::less<debug_guard*> >* patterns = 0;
int pattern_count = 0;
void check_patterns(const char* f, int l)
{
if(pattern_count)
{
std::set<debug_guard*, std::less<debug_guard*> >::iterator i, j;
i = patterns->begin();
j = patterns->end();
while(i != j)
{
if(check_pattern((void*)(*i)->g1) || check_pattern((*i)->g2) || check_pattern((void*)(*i)->pc) || check_pattern((*i)->pnc))
{
cerr << "Error: static memory corruption at " << hex << *i << dec << " in " << (*i)->file << "@" << (*i)->line << " called from " << f << "@" << l << endl;
}
++i;
}
}
}
debug_guard::debug_guard(const char* f, int l, const char* p1, char* p2)
{
if(++pattern_count == 1)
patterns = new std::set<debug_guard*, std::less<debug_guard*> >;
file = f;
line = l;
std::memcpy(g1, guard_pattern, guard_size);
std::memcpy(g2, guard_pattern, guard_size);
if(p1)
{
pc = p1;
}
else
pc = 0;
if(p2)
{
pnc = p2;
std::memcpy(pnc, guard_pattern, guard_size);
}
else
pnc = 0;
patterns->insert(this);
}
debug_guard::~debug_guard()
{
check_patterns(file, line);
if(check_pattern(g1) || check_pattern(g2))
{
cerr << "Error: memory corruption " << file << "@" << line << endl;
}
patterns->erase(this);
if(--pattern_count == 0)
{
delete patterns;
patterns = 0;
}
}
} // namespace re_detail
} // namespace boost
#endif

View File

@ -1,64 +0,0 @@
/*
*
* 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.
*
*/
/*
* LOCATION: see http://www.boost.org for most recent version.
* FILE: regex_synch.cpp
* VERSION: 3.12
* DESCRIPTION: Thread synch helper functions, for regular
* expression library.
*/
#include <boost/regex/detail/regex_synch.hpp>
namespace boost{
namespace re_detail{
void BOOST_RE_CALL re_init_threads()
{
BOOST_RE_GUARD_STACK
#ifdef BOOST_RE_THREADS
if(p_re_lock == 0)
p_re_lock = new critical_section();
cs_guard g(*p_re_lock);
++re_lock_count;
#endif
}
void BOOST_RE_CALL re_free_threads()
{
BOOST_RE_GUARD_STACK
#ifdef BOOST_RE_THREADS
cs_guard g(*p_re_lock);
--re_lock_count;
if(re_lock_count == 0)
{
g.acquire(false);
delete p_re_lock;
p_re_lock = 0;
}
#endif
}
#ifdef BOOST_RE_THREADS
BOOST_RE_IX_DECL critical_section* p_re_lock = 0;
BOOST_RE_IX_DECL unsigned int re_lock_count = 0;
#endif
} // namespace re_detail
} // namespace boost

File diff suppressed because it is too large Load Diff

Some files were not shown because too many files have changed in this diff Show More