STL

2009 Update!!! TGEA and I expect Torque3D work out the box with STL now, so this nastiness should be a thing of the past thankfully :)

<a href="/static/pg/resource/0.stl_fix.h">Download Code File</a>

STL fix
The STL is a massive collection of classes that all use a pattern called allocators for all memory allocation stuff. The particular type of macros used by the Torque engine memory managment system cause most (certainly the windows and linux standard versions) STL allocators to not compile.
One 'solution' is to disable the torque memory manager completely but the torque memory manager does lots of good things, especially in the realms of debugging. It will save your arse at least once before you ship your game, so disabling it is BAD.
So a better fix is while keeping the existing torque memory manager replace the provided STL allocators with ones that work 'nicely' with torque.

This proves to be a path of darkness and true system level hackery as in there infinite wisdom, the C++ standards commitee have proved no way of replacing the default allocator (you can provide optionally different allocators, which is useful for pooled allocation but not replace the default allocator).
The problem is that each platform and compiler use different implementation of std::allocator so I needed to figure out how to get rid of each one in turn.

This major addition is stl_fix.h, its needs including before any stl header is included and then is just works... As new platform, compilers etc. come in stl_fix.h will need updating but I think I've covered the current windows side of things and probably Linux. Mac I don't know as I don't have access to one.

Well it almost "just works", you see the macro form of new that torque uses still upsets some of the more obscure parts of some implementations of STL. The only solution is to patch torque, the actual patch is no more than a few lines and loses no functionality.
I tried for a long time to come up with a solution that didn't require a torque patch but in the end I had to fallback to a patch.

How to get it worked

Thomus Lund's excellent GameSWG resource needed to use stl_fix, so helped sort out a few bugs and he also wrote up the instructions for how to use it. As Thomus's explaniation is so good, I've basically copied his instructions into this seperate resource.

Attached to this resource is stl_fix.h this should be copied to your engine/core directory. Include this before any stl headers.

Open up platform/platform.h
Find this in Line 396

extern void* FN_CDECL operator new(dsize_t size, const char*, const U32);
extern void* FN_CDECL operator new[](dsize_t size, const char*, const U32);
extern void  FN_CDECL operator delete(void* ptr);
extern void  FN_CDECL operator delete[](void* ptr);
#define new new(__FILE__, __LINE__)

and change to this

extern void* FN_CDECL operator new(dsize_t size);
extern void* FN_CDECL operator new[](dsize_t size);
extern void  FN_CDECL operator delete(void* ptr);
extern void  FN_CDECL operator delete[](void* ptr);
extern void dPopMemManFileLine( const char*&, U32& );
extern int dPushMemManFileLine( const char*, const U32 );
#define new dPushMemManFileLine( __FILE__, __LINE__ ) ? 0 : new

Open the file platform/platformMemory.cc

Find this in line 1080

#if !defined(TORQUE_DISABLE_MEMORY_MANAGER)

// Manage our own memory, add overloaded memory operators and functions

void* FN_CDECL operator new(dsize_t size, const char* fileName, const U32 line)
{
   return Memory::alloc(size, false, fileName, line);
}

void* FN_CDECL operator new[](dsize_t size, const char* fileName, const U32 line)
{
   return Memory::alloc(size, true, fileName, line);
}

void* FN_CDECL operator new(dsize_t size)
{
   return Memory::alloc(size, false, NULL, 0);
}

void* FN_CDECL operator new[](dsize_t size)
{
   return Memory::alloc(size, true, NULL, 0);
}

and change to this

#if !defined(TORQUE_DISABLE_MEMORY_MANAGER)

static const int NUM_NEW_STACK_SIZE = 256;
static struct { const char* filename; U32 line;}

g_NewStackMemDebug[NUM_NEW_STACK_SIZE];
static int g_CurStack = -1;

int dPushMemManFileLine( const char* filename, U32 line )
{
   if(g_CurStack >= NUM_NEW_STACK_SIZE )
       return 0;
 
    g_CurStack++;
    g_NewStackMemDebug[g_CurStack].filename = filename;
    g_NewStackMemDebug[g_CurStack].line = line;
 
    return 0; // needed for the new passthrough trick

}

void dPopMemManFileLine( const char*& filename, U32& line )
{
   if( g_CurStack < 0 )
    {
       filename = 0;
       line = 0;
       return;
    } else
    {
       filename = g_NewStackMemDebug[g_CurStack].filename;
       line = g_NewStackMemDebug[g_CurStack].line;
       g_CurStack--;
    }
}

// Manage our own memory, add overloaded memory operators and functions

void* FN_CDECL operator new(dsize_t size)
{
   const char* fileName = 0;
    U32 line;
    dPopMemManFileLine( fileName, line );
     return Memory::alloc(size, false, fileName, line);
}

void* FN_CDECL operator new[](dsize_t size)
{
   const char* fileName = 0;
    U32 line;
    dPopMemManFileLine( fileName, line );
    return Memory::alloc(size, true, fileName, line);
}

open platformWin32/winMemory.cc
Find this at Line 41

void* FN_CDECL operator new(dsize_t, void* ptr)
{
   return (ptr);
}

and change to this

void* FN_CDECL operator new(dsize_t, void* ptr)
{
    const char* fileName = 0;
    U32 line;
    // dummy does nothing except keep the stack  in order   
    dPopMemManFileLine( fileName, line ); 
    return (ptr);
}

You will also have to patch the linux and mac platform specific new functions in a similar manner the winMemory.cc mod.

Enjoy
Thats it, use STL to your hearts content (or at least until performance makes you look at pooled allocators and the rest of the 'fun' for using the STL in a game :-) )

Note:
I originally wrote it for some work using TSE, while I haven't tested it recently I see no reason why it shouldn't work out of the box on TSE as well.