nobody — Thu, 06 Sep 2001 10:27:45 GMT

Logged In: NO
Thanks for the report: however I've been unable to
reproduce the problem - here's the test program I used:
#include<iostream>
#ifdef _MSC_VER
#include <crtdbg.h>
#endif
#include "boost\regex.hpp"
using namespace std;
using namespace boost;
static const unsigned long FLAGS = regbase::normal |
regbase::icase;
const char* mSubsystemFilter = "Logger";
const char* mEventFilter = ".*";
bool
foo(const char * subsystem, const char * name, const char *
detail)
{
    using namespace std;
    using namespace boost;
    bool rc = false;
    if (regex_match(string(subsystem), regex
(mSubsystemFilter)) &&
        regex_match(string(name), regex(mEventFilter)))
    {
        //rc = WriteMessage(EVENT, subsystem, name, detail);
       cout << "match" << endl;
    }
    return rc;
}
int main()
{
#ifdef _MSC_VER
   int tmpFlag = _CrtSetDbgFlag(_CRTDBG_REPORT_FLAG);
   tmpFlag |= _CRTDBG_LEAK_CHECK_DF;
   _CrtSetDbgFlag(tmpFlag);
#endif
   foo("System", "foo", "");
   new char; // verify leak checking is working
   return 0;
}
regards,
John Maddock

evansls — Fri, 07 Sep 2001 12:53:46 GMT

Logged In: YES
user_id=316449
Strange! The test program still leaks on my machine. I've
attached my leaktest build directory to this report. Here's
the Visual Studio debugger output...
Loaded 'C:\WINNT\System32\ntdll.dll', no matching symbolic
information found.
Loaded 'C:\WINNT\system32\KERNEL32.DLL', no matching
symbolic information found.
Loaded 'C:\WINNT\system32\USER32.DLL', no matching symbolic
information found.
Loaded 'C:\WINNT\system32\GDI32.DLL', no matching symbolic
information found.
Loaded 'C:\WINNT\system32\ADVAPI32.DLL', no matching
symbolic information found.
Loaded 'C:\WINNT\system32\RPCRT4.DLL', no matching symbolic
information found.
Detected memory leaks!
Dumping objects ->
{181} normal block at 0x00820200, 1 bytes long.
 Data: < > CD
{178} normal block at 0x00821F90, 33 bytes long.
 Data: < System         > 00 53 79 73 74 65 6D 00 CD CD CD
CD CD CD CD CD
{177} normal block at 0x00821C40, 51 bytes long.
 Data: <3       l       > 33 00 00 00 06 00 00 00 6C 1C 82
00 FF FF FF FF
{175} normal block at 0x00822D60, 16 bytes long.
 Data: <0    -  G   4   > 30 02 82 00 A0 2D 82 00 47 00 CC
CC 34 00 00 00
{173} normal block at 0x00822DA0, 16 bytes long.
 Data: <`-   -  Z   3   > 60 2D 82 00 E0 2D 82 00 5A 00 CC
CC 33 00 00 00
{171} normal block at 0x00822DE0, 16 bytes long.
 Data: < -   .  C   2   > A0 2D 82 00 20 2E 82 00 43 00 CC
CC 32 00 00 00
{169} normal block at 0x00822E20, 16 bytes long.
 Data: < -  `.  X   1   > E0 2D 82 00 60 2E 82 00 58 00 CC
CC 31 00 00 00
{167} normal block at 0x00822E60, 16 bytes long.
 Data: < .   .  Q   0   > 20 2E 82 00 A0 2E 82 00 51 00 CC
CC 30 00 00 00
{165} normal block at 0x00822EA0, 16 bytes long.
 Data: <`.   .  E   /   > 60 2E 82 00 E0 2E 82 00 45 00 CC
CC 2F 00 00 00
{163} normal block at 0x00822EE0, 16 bytes long.
 Data: < .   /  D   .   > A0 2E 82 00 20 2F 82 00 44 00 CC
CC 2E 00 00 00
{161} normal block at 0x00822F20, 16 bytes long.
 Data: < .  `/  d   -   > E0 2E 82 00 60 2F 82 00 64 00 CC
CC 2D 00 00 00
{159} normal block at 0x00822F60, 16 bytes long.
 Data: < /   /  S   ,   > 20 2F 82 00 A0 2F 82 00 53 00 CC
CC 2C 00 00 00
{157} normal block at 0x00822FA0, 16 bytes long.
 Data: <`/   /  s   +   > 60 2F 82 00 E0 2F 82 00 73 00 CC
CC 2B 00 00 00
{155} normal block at 0x00822FE0, 16 bytes long.
 Data: < /  0   U   *   > A0 2F 82 00 30 10 82 00 55 00 CC
CC 2A 00 00 00
{153} normal block at 0x00821030, 16 bytes long.
 Data: < /  p   u   )   > E0 2F 82 00 70 10 82 00 75 00 CC
CC 29 00 00 00
{151} normal block at 0x00821070, 16 bytes long.
 Data: <0       L   (   > 30 10 82 00 B0 10 82 00 4C 00 CC
CC 28 00 00 00
{149} normal block at 0x008210B0, 16 bytes long.
 Data: <p       l   '   > 70 10 82 00 F0 10 82 00 6C 00 CC
CC 27 00 00 00
{147} normal block at 0x008210F0, 16 bytes long.
 Data: <    0   e   &   > B0 10 82 00 30 11 82 00 65 00 CC
CC 26 00 00 00
{145} normal block at 0x00821130, 16 bytes long.
 Data: <    p   =   %   > F0 10 82 00 70 11 82 00 3D 00 CC
CC 25 00 00 00
{143} normal block at 0x00821170, 16 bytes long.
 Data: <0       :   $   > 30 11 82 00 B0 11 82 00 3A 00 CC
CC 24 00 00 00
{141} normal block at 0x008211B0, 16 bytes long.
 Data: <p       c   #   > 70 11 82 00 F0 11 82 00 63 00 CC
CC 23 00 00 00
{139} normal block at 0x008211F0, 16 bytes long.
 Data: <    0   x   "   > B0 11 82 00 30 12 82 00 78 00 CC
CC 22 00 00 00
{137} normal block at 0x00821230, 16 bytes long.
 Data: <    p   v   !   > F0 11 82 00 70 12 82 00 76 00 CC
CC 21 00 00 00
{135} normal block at 0x00821270, 16 bytes long.
 Data: <0       t       > 30 12 82 00 B0 12 82 00 74 00 CC
CC 20 00 00 00
{133} normal block at 0x008212B0, 16 bytes long.
 Data: <p       r       > 70 12 82 00 F0 12 82 00 72 00 CC
CC 1F 00 00 00
{131} normal block at 0x008212F0, 16 bytes long.
 Data: <    0   n       > B0 12 82 00 30 13 82 00 6E 00 CC
CC 1E 00 00 00
{129} normal block at 0x00821330, 16 bytes long.
 Data: <    p   f       > F0 12 82 00 70 13 82 00 66 00 CC
CC 1D 00 00 00
{127} normal block at 0x00821370, 16 bytes long.
 Data: <0       a       > 30 13 82 00 B0 13 82 00 61 00 CC
CC 1C 00 00 00
{125} normal block at 0x008213B0, 16 bytes long.
 Data: <p       ,       > 70 13 82 00 F0 13 82 00 2C 00 CC
CC 1B 00 00 00
{123} normal block at 0x008213F0, 16 bytes long.
 Data: <    0           > B0 13 82 00 30 14 82 00 0A 00 CC
CC 1A 00 00 00
{121} normal block at 0x00821430, 16 bytes long.
 Data: <    p   z       > F0 13 82 00 70 14 82 00 7A 00 CC
CC 19 00 00 00
{120} normal block at 0x00821470, 16 bytes long.
 Data: <0       '       > 30 14 82 00 B0 14 82 00 27 00 CC
CC 19 00 00 00
{118} normal block at 0x008214B0, 16 bytes long.
 Data: <p       A       > 70 14 82 00 F0 14 82 00 41 00 CC
CC 18 00 00 00
{117} normal block at 0x008214F0, 16 bytes long.
 Data: <    0   `       > B0 14 82 00 30 15 82 00 60 00 CC
CC 18 00 00 00
{115} normal block at 0x00821530, 16 bytes long.
 Data: <    p   W       > F0 14 82 00 70 15 82 00 57 00 CC
CC 17 00 00 00
{113} normal block at 0x00821570, 16 bytes long.
 Data: <0       w       > 30 15 82 00 B0 15 82 00 77 00 CC
CC 16 00 00 00
{111} normal block at 0x008215B0, 16 bytes long.
 Data: <p       >       > 70 15 82 00 F0 15 82 00 3E 00 CC
CC 15 00 00 00
{109} normal block at 0x008215F0, 16 bytes long.
 Data: <    0   <       > B0 15 82 00 30 16 82 00 3C 00 CC
CC 14 00 00 00
{107} normal block at 0x00821630, 16 bytes long.
 Data: <    p   B       > F0 15 82 00 70 16 82 00 42 00 CC
CC 13 00 00 00
{105} normal block at 0x00821670, 16 bytes long.
 Data: <0       b       > 30 16 82 00 B0 16 82 00 62 00 CC
CC 12 00 00 00
{103} normal block at 0x008216B0, 16 bytes long.
 Data: <p       9       > 70 16 82 00 F0 16 82 00 39 00 CC
CC 11 00 00 00
{102} normal block at 0x008216F0, 16 bytes long.
 Data: <    0   8       > B0 16 82 00 30 17 82 00 38 00 CC
CC 11 00 00 00
{101} normal block at 0x00821730, 16 bytes long.
 Data: <    p   7       > F0 16 82 00 70 17 82 00 37 00 CC
CC 11 00 00 00
{100} normal block at 0x00821770, 16 bytes long.
 Data: <0       6       > 30 17 82 00 B0 17 82 00 36 00 CC
CC 11 00 00 00
{99} normal block at 0x008217B0, 16 bytes long.
 Data: <p       5       > 70 17 82 00 F0 17 82 00 35 00 CC
CC 11 00 00 00
{98} normal block at 0x008217F0, 16 bytes long.
 Data: <    0   4       > B0 17 82 00 30 18 82 00 34 00 CC
CC 11 00 00 00
{97} normal block at 0x00821830, 16 bytes long.
 Data: <    p   3       > F0 17 82 00 70 18 82 00 33 00 CC
CC 11 00 00 00
{96} normal block at 0x00821870, 16 bytes long.
 Data: <0       2       > 30 18 82 00 B0 18 82 00 32 00 CC
CC 11 00 00 00
{95} normal block at 0x008218B0, 16 bytes long.
 Data: <p       1       > 70 18 82 00 F0 18 82 00 31 00 CC
CC 11 00 00 00
{94} normal block at 0x008218F0, 16 bytes long.
 Data: <    0   0       > B0 18 82 00 30 19 82 00 30 00 CC
CC 11 00 00 00
{92} normal block at 0x00821930, 16 bytes long.
 Data: <    p   }       > F0 18 82 00 70 19 82 00 7D 00 CC
CC 10 00 00 00
{90} normal block at 0x00821970, 16 bytes long.
 Data: <0       {       > 30 19 82 00 B0 19 82 00 7B 00 CC
CC 0F 00 00 00
{88} normal block at 0x008219B0, 16 bytes long.
 Data: <p       -       > 70 19 82 00 F0 19 82 00 2D 00 CC
CC 0E 00 00 00
{86} normal block at 0x008219F0, 16 bytes long.
 Data: <    0   #       > B0 19 82 00 30 1A 82 00 23 00 CC
CC 0D 00 00 00
{84} normal block at 0x00821A30, 16 bytes long.
 Data: <    p   \       > F0 19 82 00 70 1A 82 00 5C 00 CC
CC 0C 00 00 00
{82} normal block at 0x00821A70, 16 bytes long.
 Data: <0       |       > 30 1A 82 00 B0 1A 82 00 7C 00 CC
CC 0B 00 00 00
{80} normal block at 0x00821AB0, 16 bytes long.
 Data: <p       ]       > 70 1A 82 00 F0 1A 82 00 5D 00 CC
CC 0A 00 00 00
{78} normal block at 0x00821AF0, 16 bytes long.
 Data: <    0   [       > B0 1A 82 00 30 1B 82 00 5B 00 CC
CC 09 00 00 00
{76} normal block at 0x00821B30, 16 bytes long.
 Data: <    p   ?       > F0 1A 82 00 70 1B 82 00 3F 00 CC
CC 08 00 00 00
{74} normal block at 0x00821B70, 16 bytes long.
 Data: <0       +       > 30 1B 82 00 B0 1B 82 00 2B 00 CC
CC 07 00 00 00
{72} normal block at 0x00821BB0, 16 bytes long.
 Data: <p       *       > 70 1B 82 00 F0 1B 82 00 2A 00 CC
CC 06 00 00 00
{70} normal block at 0x00821BF0, 16 bytes long.
 Data: <        .       > B0 1B 82 00 A0 1C 82 00 2E 00 CC
CC 05 00 00 00
{68} normal block at 0x00821CA0, 16 bytes long.
 Data: <        ^       > F0 1B 82 00 E0 1C 82 00 5E 00 CC
CC 04 00 00 00
{66} normal block at 0x00821CE0, 16 bytes long.
 Data: <        $       > A0 1C 82 00 20 1D 82 00 24 00 CC
CC 03 00 00 00
{64} normal block at 0x00821D20, 16 bytes long.
 Data: <        )       > E0 1C 82 00 E0 1F 82 00 29 00 CC
CC 02 00 00 00
{62} normal block at 0x00821FE0, 16 bytes long.
 Data: <    0   (       > 20 1D 82 00 30 02 82 00 28 00 CC
CC 01 00 00 00
{50} normal block at 0x008200B0, 40 bytes long.
 Data: <                > B0 00 82 00 B0 00 82 00 CD CD CD
CD CD CD CD CD
{49} normal block at 0x00820110, 12 bytes long.
 Data: <            > CC CD CD CD B0 00 82 00 00 00 00 00
{48} normal block at 0x00821D60, 228 bytes long.
 Data: <                > 0E 00 00 00 CC CD CD CD 00 00 00
00 00 00 00 00
{47} normal block at 0x00820230, 16 bytes long.
 Data: <    `-          > E0 1F 82 00 60 2D 82 00 CD CD CD
CD CD CD CD CD
{46} normal block at 0x00820270, 12 bytes long.
 Data: <    0   ?   > CC CD CD CD 30 02 82 00 3F 00 00 00
{45} normal block at 0x00816E38, 1024 bytes long.
 Data: <    Pn          > 02 00 00 00 50 6E 81 00 00 00 00
00 06 00 00 00
{42} normal block at 0x00820040, 24 bytes long.
 Data: <py w            > 70 79 FA 77 FF FF FF FF 00 00 00
00 00 00 00 00
Object dump complete.
The thread 0x140 has exited with code 0 (0x0).
The program 'D:\downloads\boost\boost_1_24_0
\SteveTest\leaktest\leaktest\Debug\leaktest.exe' has exited
with code 0 (0x0).
Many thanks for the fast response!
Steve

John Maddock — Sun, 09 Sep 2001 11:14:02 GMT

Logged In: YES
user_id=14804
OK, I see the leaks if I run your executable, but if I
rebuild it then I don't!
two questions:
Have you replaced your standard lib with something
(STLport, updated dinkum lib)?
Have you updated boost recently, but not rebuild *and
installed* the regex libs?  Try double checking by doing a:
nmake -fvc6.mak install
from the libs/regex/build directory.

evansls — Mon, 10 Sep 2001 09:22:29 GMT

Logged In: YES
user_id=316449
Morning John!
My standard lib is still the MSVC standard (at least I've never knowingly installed anything else).
I downloaded boost for the first time less than 2 weeks ago. At first I integrated regex into my own app (BOOST_RE_NO_LIB and all that). When I encountered the leak I assumed it was the fault of my build setup, so I went back to the boost directory and ran nmake -fvc6.mak, followed by nmake -fvc6.mak install. That's the setup I used to compile your test app.
I'll try downloading boost again, and rebuild...
Steve

evansls — Mon, 10 Sep 2001 12:42:52 GMT

Logged In: YES
user_id=316449
Deleted boost (plus the libs in the MSVC lib directory), re-downloaded, re-installed, created a new, clean project for your test prog... still it leaks. :-(
I also tried replacing the regex section of boost with the version I downloaded from your own homepages (it wouldn't build on its own - it needed boost/cregex.hpp). Still no joy. I'll try reinstalling MSVC.

evansls — Mon, 10 Sep 2001 14:35:18 GMT

Logged In: YES
user_id=316449
Complete uninstall/reinstall of Visual Studio 6.0 Enterprise Edition failed to cure the leak. I'll have a look on MSDN for any MSVC++ 6.0 patches to do with memory leaks in the STL.

evansls — Mon, 10 Sep 2001 17:12:13 GMT

Logged In: YES
user_id=316449
Eureka! I applied Service Pack 5 to MSVC 6.0 and the memory leak disappeared. I don't know what SP level I was running before (if any), but it evidently wasn't recent enough!

status changed

John Maddock — Tue, 11 Sep 2001 11:20:29 GMT

status assigned → closed

Logged In: YES
user_id=14804
Steve,
Thanks for taking the time to get to the bottom of that -
I'm glad you got there in the end!
John Maddock

Boost C++ Libraries: Ticket #949: Memory leak in regex_match() with MSVC

status changed