>>>>>C:\Program Files\Microsoft Visual C++ Toolkit 2003\include\memory:498: fatal error C1067: compiler limit : debug information module size exceeded
So, how do I expand the module size please?
<<<<<<
mmmm...................I do not think that you can, but then I am not sure, and all I know is not to Build the File on Debug Setting but only use the Final Release version setting to build the file.
Afterall, there may be something in the Help File for the Platform SDK, but I think in the end, that without having the Professional version of Visual Studio .NET 2003 complete version handy, you may not find out anything.
Debug versions of any compiled programming will include all the debug information, but when you only build the Release version (or in this case because of Codeblocks - the Final Release version) then all that info is left out and the build is smaller, plus the fact that there are separate Libraries for a Debug version vs. the Library files for a Release version of any computer software programming.
Perhaps maybe in the end, most programming is done over a Network of computers when finalized, it is all put together into the Final Release of a programming project or game -- it may be just that Debug versions are each separate kind of file to find the problems first, and then the Debug version file would not be so big in the first place.
Whatever it is, I am sure it would be mentioned somewhere in the Help Files of the Professional version of Visual Studio .NET 2003, but again, you are only using the compiler given with a free version which does not include the IDE of the full version and again, it may be that the Debug version file including all that info is limited in size, and whether or not it can be increased - there probably is no help given with what you have, and the only other way to look up anything about it may be at the Microsoft.com website for the MSDN Library - if, they have decided to include it because Visual Studio .NET 2005 has been released already due to Microsoft changing Security around since they (and probably helped with the Feds) have decided that all their Security because of the Internet was not enough and holes used my Hackers are in the software of the OS in the first place and all those Critical Updates come along to Update your OS - from Windows Update.
The closest I can come with Visual Studio .NET 2001 is actually nothing is mentioned so far as how to increase file size but here is some of it:
Debug Versions of Heap Functions
The Debug versions of the heap functions call the standard or base versions used in Release builds. When you request a memory block, the debug heap manager allocates from the base heap a slightly larger block of memory than requested and returns a pointer to your portion of that block. For example, suppose your application contains the call: malloc( 10 ). In a Release build, malloc would call the base heap allocation routine requesting an allocation of 10 bytes. In a Debug build, however, malloc would call _malloc_dbg, which would then call the base heap allocation routine requesting an allocation of 10 bytes plus approximately 36 bytes of additional memory. All the resulting memory blocks in the debug heap are connected in a single linked list, ordered according to when they were allocated.
Memory Allocation on the Debug Heap
The additional memory allocated by the debug heap routines is used for bookkeeping information, for pointers that link debug memory blocks together, and for small buffers on either side of your data to catch overwrites of the allocated region.
Currently, the block header structure used to store the debug heap's bookkeeping information is declared as follows in the DBGINT.H header file:
typedef struct _CrtMemBlockHeader
{
// Pointer to the block allocated just before this one:
struct _CrtMemBlockHeader *pBlockHeaderNext;
// Pointer to the block allocated just after this one:
struct _CrtMemBlockHeader *pBlockHeaderPrev;
char *szFileName; // File name
int nLine; // Line number
size_t nDataSize; // Size of user block
int nBlockUse; // Type of block
long lRequest; // Allocation number
// Buffer just before (lower than) the user's memory:
unsigned char gap[nNoMansLandSize];
} _CrtMemBlockHeader;
/* In an actual memory block in the debug heap,
* this structure is followed by:
* unsigned char data[nDataSize];
* unsigned char anotherGap[nNoMansLandSize];
*/
The NoMansLand buffers on either side of the user data area of the block are currently 4 bytes in size, and are filled with a known byte value used by the debug heap routines to verify that the limits of the user's memory block have not been overwritten. The debug heap also fills new memory blocks with a known value. If you elect to keep freed blocks in the heap's linked list as explained below, these freed blocks are also filled with a known value. Currently, the actual byte values used are as follows:
NoMansLand (0xFD)
The "NoMansLand" buffers on either side of the memory used by an application are currently filled with 0xFD.
Freed blocks (0xDD)
The freed blocks kept unused in the debug heap's linked list when the _CRTDBG_DELAY_FREE_MEM_DF flag is set are currently filled with 0xDD.
New objects (0xCD)
New objects are filled with 0xCD when they are allocated.
See Also
The CRT Debug Heap
You see this is only one page of the Help File from Visual Studio .NET 2001 version, but as yet, there is nothing else that decides how big of a file is allowed for the debug file and knowing exactly what to do may depend on Heap Size and Memory Allocated for Debugging any program in the first place.
There is a default setting in the first place or I guess otherwise other things have to be included and done to allow all the Debugging to take place somehow.
