/* ##C_FILE#~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
FILE :          CpaMmg.c
 
DESCRIPTION :   this file contain all functions used to allocate memory :
		
		Initialisation of the module
		Initialisation of a static bloc
		switch between dynamic and static mode
		Allocate/ReAllocate/Free Memory
		Check function for debugging
		Destroy a static bloc
		Destroy the module
 
VERSION :       5.1.0/Pierrick Crepy/Creation
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~*/
 
 
/* ##INCLUDE#----------------------------------------------------------------------------
                          Includes Files
---------------------------------------------------------------------------------------*/
#ifdef U64
#include "ultra.h"
#endif/*U64*/
 
#ifdef WIN32
#include <string.h>
 
#include <windows.h>
#endif /*WIN32*/
 
#if defined(U64)
#include <ultra64.h> /*for Critical Section : Msg management*/
#elif defined(PSX)
#include "PSX.h"
#else
#include <Winbase.h> /*for Critical Section*/
#endif /*U64*/
 
#include "ERM.h"
 
#define __DeclareGlobalVariableErrMmg_h__
#include "MMG/ErrMmg.h"
#undef __DeclareGlobalVariableErrMmg_h__
 
#define __DeclareGlobalVariableInCpaMmg_h__
#include "MMG/CpaMmg.h"
#undef __DeclareGlobalVariableInCpaMmg_h__
 
#include "PrivMmg.h"
#include "MMG/RastMmg.h"
 
#if !defined(RETAIL) && !defined(U64)
/* This boolean tells if we must fill an allocated bloc */
/* with 0s at each allocation.*/
/* It is set by SNA when making binary datas*/
#include "acp_base.h"
ACP_tdxBool MMG_g_bResetMemOnAllocation = FALSE;
#endif
 
#ifdef WIN32
#ifdef __DEBUG_MALLOC_MODE__
#include <assert.h>
#endif /*__DEBUG_MALLOC_MODE__*/
#endif /*WIN32*/
 
/*ANNECY CT 21/1/98 {*/
/*XB*/
#if !defined(U64)
/*End XB*/
#define malloc(size)	GlobalAlloc(GMEM_FIXED,size)
#define free(ptr)		GlobalFree(ptr)
/*XB*/
#endif /* U64*/
/*End XB*/
/*ENDANNECY CT}*/
 
#ifdef U64
#include "RastMem.h"
#include "DesMem.h"
#endif /* U64 */
/*///////////// PSX //////////////*/
#ifdef PSX
 
#define malloc	malloc3
#define free	free3
#define realloc realloc3
/*To resolve a cast problem*/
#define memmove(a,b,c) memmove((unsigned char *)a, (unsigned char *)b, c)
 
/*Undefined prototypes*/
void MMG_PSX_fn_vInitLibrary();
 
#endif /*PSX*/
/*///////////// PSX //////////////*/
 
 
#ifndef M_CheckPointer
#define M_CheckPointer(a)
#endif /* M_CheckPointer */
 
 
/* ##FUNCDEF#----------------------------------------------------------------------------
                          Functions definition
---------------------------------------------------------------------------------------*/
 
void * fn_p_vDynAlloc			(unsigned long ulSize, unsigned char ucChannel);
void fn_vDynFree				(void *p_vMemBlock, unsigned char ucChannel);
void * fn_p_vDynRealloc			(void *p_vMemBlock, unsigned long ulSize, unsigned char ucChannel);
void * fn_p_vStaAlloc			(unsigned long ulSize, unsigned char ucChannel);
void fn_vStaFree				(void *p_vMemBlock, unsigned char ucChannel);
void * fn_p_vStaRealloc			(void *p_vMemBlock, unsigned long ulSize, unsigned char ucChannel);
void fn_vSortMallocInfoTable	(tdstMallocInfo * p_stMyMallocInfo, unsigned long ulSizeTable);
 
/* ##-########################### 
   ## General Management 
   ############################## */
 
/* ##F#===================================================================================
NAME :          Mmg_fn_cCheckAlignmentValidity
DESCRIPTION :   check if alignement constant are valide
=========================================================================================
CREATION : 06-11-97/Pierrick Crepy
=======================================================================================*/
void Mmg_fn_cCheckAlignmentValidity () {
#ifdef __DEBUG_MALLOC_MODE__
#ifdef __FATAL_ERR_MMG__
	assert((sizeof(unitAlloc)== C_uwAllocSize) && ((1<<C_uwShiftAllocSize)== C_uwAllocSize));/*lint !506: Constant value Boolean*/
/*
        if ((sizeof(unitAlloc)!= C_uwAllocSize)|| ((1<<C_uwShiftAllocSize)!= C_uwAllocSize) ){
                Mmg_M_UpdateLastError (E_uwMmgPbDataAlignment, NULL);
        }
*/
#endif /*__FATAL_ERR_MMG__*/
#endif /*__DEBUG_MALLOC_MODE__*/
}
 
/* ##-########################### 
   ## Management of overflow key check for a block without free
   ############################## */
 
/* ##F#===================================================================================
NAME :          Mmg_fn_vWriteOverflowCheckKey 
DESCRIPTION :   affecte the overflow key
INPUT :			target pointer
=========================================================================================
CREATION : 05-03-98/Pierrick Crepy
=======================================================================================*/
#ifdef D_CheckSystemForBlockWithoutFree 
void Mmg_fn_vWriteOverflowCheckKey (char * p_cTarget){
		char * p_cScan;
		char * p_cSource;			
		unsigned long ulOverflowCheckKey = C_ulOverflowCheckKey;
		/* I can not affect directily all the key because for ex on R3000 & co a long must be aligned on 4 bytes*/
		/* I must to affect the key byte by byte.*/
		for (p_cScan = p_cTarget, p_cSource = (char*) (&ulOverflowCheckKey);
				p_cScan < p_cTarget+sizeof (C_TypeOfOverflowCheckKeyForBlockWithoutFree);
				p_cScan++, p_cSource++){
			*p_cScan = *p_cSource;
		}
}
 
/* ##F#===================================================================================
NAME :          Mmg_fn_vTestOverflowCheckKey 
DESCRIPTION :   affecte the overflow key
INPUT :			target pointer
=========================================================================================
CREATION : 05-03-98/Pierrick Crepy
=======================================================================================*/
char Mmg_fn_b_cIsItEqualToOverflowCheckKey (char * p_cTarget){
		char * p_cScan;
		char * p_cSource;			
		unsigned long ulOverflowCheckKey = C_ulOverflowCheckKey;
		/* I can not affect directily all the key because for ex on R3000 & co a long must be aligned on 4 bytes*/
		/* I must to affect the key byte by byte.*/
		for (p_cScan = p_cTarget, p_cSource = (char*) (&ulOverflowCheckKey);
				p_cScan < p_cTarget+sizeof (C_TypeOfOverflowCheckKeyForBlockWithoutFree);
				p_cScan++, p_cSource++){
			if (*p_cScan != *p_cSource) break;
		}
		return ((char) (p_cScan == p_cTarget+sizeof (C_TypeOfOverflowCheckKeyForBlockWithoutFree)));
}
 
#endif D_CheckSystemForBlockWithoutFree 
/* ##-########################### 
   ## Management of blocks
   ############################## */
 
/* ##F#===================================================================================
NAME :          Mmg_fn_vInitSpecificBlock
DESCRIPTION :   Make the real allocation and init variables for block managing
INPUT :			Block Id
				Module Id
				Block Structure 
				Size of the block
				Max number of allocation in the block (only used for debugging)
				Alignement : C_NoAlignement or the number of bytes
				Mode : combination of C_BlockWithFreeFlag,  C_BlockWithoutFreeFlag, 
					C_FillTheBlockWithCleanKeyFlag, C_Check_AlignementFlag, C_Check_OverflowFlag
=========================================================================================
CREATION : 06-11-97/Pierrick Crepy
Modificatio: 02-03-98 Pierrick Crepy MMG V6.1.0
=======================================================================================*/
void Mmg_fn_vInitSpecificBlock (unsigned char _ucBlockId, unsigned char _ucModuleId, 
	struct tdstBlockInfoPriv_ *_p_stMyBlocksInfo, unsigned long _ulSize, unsigned long _ulMaxNbStaticMalloc,
	unsigned char _ucAlignment, unsigned char _ucMode){
 
        char * p_cBegin;
        unsigned long ulI;
        unitAlloc * p_uaPtr;
		struct tdstBlockInfoPriv_ *p_stMyBlockInfo = _p_stMyBlocksInfo+_ucBlockId;
		unsigned char ucAlignment;
#ifdef __FATAL_ERR_MMG__
#ifdef __ERROR_STRINGS__
		char szErrTxt[C_ucSizeOfErrTxt];
#else
		char * szErrTxt = NULL;
#endif /*__ERROR_STRINGS__*/
#endif /*__FATAL_ERR_MMG__*/
 
		if (!(_ucMode & C_BlockWithoutFreeFlag)){ /* C_BlockWithFreeFlag*/
			ucAlignment = C_uwAllocSize;
		}/* mode = C_BlockWithFreeFlag*/
		else { /*mode = C_BlockWithoutFreeFlag*/
#ifdef U64
			M_PrintfN64(("initBlock align = %d\n", _ucAlignment));
#endif
			ucAlignment = _ucAlignment;
#ifdef D_CheckSystemForBlockWithoutFree
			Mmg_M_BigBoundSize (_ulSize, ucAlignment);
			_ulSize+=sizeof(tdstInformationHeaderOfBolckWithoutFree);
#endif /*D_CheckSystemForBlockWithoutFree*/
		}
 
#ifdef __DEBUG_MALLOC_MODE__
#ifdef __FATAL_ERR_MMG__
		if (p_stMyBlockInfo == NULL){
#ifdef __ERROR_STRINGS__
			sprintf (szErrTxt, "You have called 'Mmg_fn_vInitBlock' function\nfor the block #%d in [", _ucBlockId);
			Erm_M_GetModuleInformation(szErrTxt+strlen(szErrTxt), _ucModuleId);
			sprintf (szErrTxt+strlen(szErrTxt), "].\nAre you sure to have well call 'Mmg_M_InitMmg' for it ?\n");
			Mmg_M_UpdateLastError(E_uwMmgPbInvalidBlock, szErrTxt);
#else /*__ERROR_STRINGS__*/
			Mmg_M_UpdateLastError(E_uwMmgPbInvalidBlock, NULL);
#endif /*__ERROR_STRINGS__*/
		}
		if (p_stMyBlockInfo->p_cBeginBlock != C_p_cBlockNotValidKey){			
#ifdef __ERROR_STRINGS__
			sprintf (szErrTxt, "You have called 'Mmg_fn_vInitBlock' function\nfor the block #%d in [", _ucBlockId);
			Erm_M_GetModuleInformation(szErrTxt+strlen(szErrTxt), _ucModuleId);
			sprintf (szErrTxt+strlen(szErrTxt), "].\nBut the 'p_cBeginBlock' field is equal to 0X%X (and not 0X%X like expected)\n",
				p_stMyBlockInfo->p_cBeginBlock, C_p_cBlockNotValidKey);
			sprintf (szErrTxt+strlen(szErrTxt), "Do you try to initialized again a block for the second time ?!\n");
#endif /*__ERROR_STRINGS__*/
			Mmg_M_UpdateLastError(E_uwMmgPbInvalidBlock, szErrTxt);
		}
#endif /*__FATAL_ERR_MMG__*/
		p_stMyBlockInfo->ulMaxNbStaticMalloc = _ulMaxNbStaticMalloc;
		p_stMyBlockInfo->d_stMallocInfo = (tdstMallocInfo *) malloc (sizeof (tdstMallocInfo)*_ulMaxNbStaticMalloc);
		if (p_stMyBlockInfo->d_stMallocInfo == NULL){
#ifdef __ERROR_STRINGS__
			sprintf (szErrTxt, "The d_stMallocInfo of the BlockInfo for the block #%d of the module #%d [", _ucBlockId, _ucModuleId);
			Erm_M_GetModuleInformation(szErrTxt+strlen(szErrTxt), _ucModuleId);
			sprintf (szErrTxt+strlen(szErrTxt), "] is not allocated");
			Mmg_M_UpdateLastError(E_uwMmgPbInInitBlock, szErrTxt);
#else /*__ERROR_STRINGS__*/
			Mmg_M_UpdateLastError(E_uwMmgPbInInitBlock, NULL);
#endif /*__ERROR_STRINGS__*/
		}
 
#endif /*__DEBUG_MALLOC_MODE__*/
 
 
		Mmg_M_BigBoundSize (_ulSize, ucAlignment);
        
 
#ifdef __ADD_PLACE_FOR_DEBUG_INFORMATION__
		if (!(_ucMode & C_BlockWithFreeFlag)){/*C_BlockWithFreeFlag*/
			ulI = (_ulMaxNbStaticMalloc*(C_ucDebugInformationLoss<<C_uwShiftAllocSize));
			Mmg_M_BigBoundSize(ulI, C_uwAllocSize);      
			_ulSize += ulI;
		}/* mode = C_BlockWithFreeFlag*/
#endif /*__ADD_PLACE_FOR_DEBUG_INFORMATION__*/
 
        
        /* allocation of the block*/
        /*-------------------------*/
        p_cBegin = (char *)malloc (_ulSize);
		/*p_cBegin = (char *)VirtualAlloc (s_p_vRegionNumber, _ulSize, MEM_RESERVE | MEM_COMMIT, PAGE_READWRITE);*/
 
#ifdef __FATAL_ERR_MMG__
        ulI = (unsigned long) p_cBegin;
 
        /* test of allocation the begining of the block must be a muliple of ucAlignment */
        Mmg_M_BigBoundSize (ulI, ucAlignment);
 
        if (p_cBegin != (char *) ulI){
#ifdef __ERROR_STRINGS__
			sprintf (szErrTxt, "Because 0X%X it's not multiple of %d", p_cBegin, ucAlignment);
#endif /*__ERROR_STRINGS__*/
/*			Mmg_M_UpdateLastErrorWithCurrentModeInfo (E_uwMmgPbAlignmentBlock, szErrTxt, ucChannel);*/
#ifdef __DEBUG_MALLOC_MODE__
			Mmg_M_UpdateLastErrorWithModuleIdAnducModeReference(_ucModuleId, _ucBlockId, E_uwMmgPbAlignmentBlock, szErrTxt);
#else
			Mmg_M_UpdateLastError (E_uwMmgPbAlignmentBlock, szErrTxt);
#endif /*__DEBUG_MALLOC_MODE__*/
        }
#endif /*__FATAL_ERR_MMG__*/
 
#ifdef __WARNING3_ERR_MMG__
        if (p_cBegin  == NULL){
/*                Mmg_M_UpdateLastErrorWithCurrentModeInfo (E_uwMmgPbAllocateBlock, NULL, ucChannel);*/
#ifdef __DEBUG_MALLOC_MODE__
				Mmg_M_UpdateLastErrorWithModuleIdAnducModeReference(_ucModuleId, _ucBlockId, E_uwMmgPbAllocateBlock, NULL);
#else
				Mmg_M_UpdateLastError (E_uwMmgPbAllocateBlock, NULL);
#endif /*__DEBUG_MALLOC_MODE__*/
 
        }
		else{/* the malloc is a sucess*/
#endif /* __WARNING3_ERR_MMG__*/
 
			/* record block infomations*/
			p_stMyBlockInfo->p_cBeginBlock = p_cBegin;
		/*osSyncPrintf("p_stMyBlockInfo->p_cEndBlock : %x ; p_stMyBlockInfo->p_cBeginBlock : %x \n", p_stMyBlockInfo->p_cEndBlock, p_stMyBlockInfo->p_cBeginBlock);*/
		/*osSyncPrintf("_ulSize : %d\n", _ulSize);*/
			p_stMyBlockInfo->p_cEndBlock = p_cBegin + _ulSize - 1;/*lint !e613 : Possible use of null pointer*/
			if (!(_ucMode & C_BlockWithoutFreeFlag)){/*C_BlockWithFreeFlag*/
				p_stMyBlockInfo->p_cFirstFree = p_cBegin;
				p_stMyBlockInfo->p_cMaxMem = p_cBegin;
 
 
				/* init the free list Information in the block.*/
				/*----------------------------------------------*/
				p_uaPtr = (unitAlloc *) p_cBegin ;
				*p_uaPtr = (unitAlloc) (_ulSize >> C_uwShiftAllocSize ); /*lint !e613 : Possible use of null pointer */ /* size of the free = size of the block*/
				*(p_uaPtr+1) = (unitAlloc) 0;/*lint !e613 : Possible use of null pointer*/ /* there is no sucessor in the free list.*/
 
 
#ifdef __DEBUG_MALLOC_MODE__
				p_stMyBlockInfo->ulCountMallocBeforeMaxMem = 0;
				p_stMyBlockInfo->ulCountFreeBeforeMaxMem = 0;
				p_stMyBlockInfo->ulNbMalloc = 0;
				p_stMyBlockInfo->ulNbTotalMalloc = 0;
				p_stMyBlockInfo->uwNbFree = 0;
				p_stMyBlockInfo->ulNbTotalFree = 0;
				p_stMyBlockInfo->ulNbTotalRealloc = 0;
			
				/* initialisation of the block with the value 0xAA. */
				/*-------------------------------------------------*/
				/*Remark the bytes of Header of the free are not affected because there are yet well set with free Information*/
				for (p_uaPtr = ((unitAlloc*) (p_cBegin)) +C_ucFreeHeaderSize , _ulSize -= (ucAlignment<<1); _ulSize > 0; _ulSize= _ulSize - ucAlignment,p_uaPtr++)/*lint !e613*/{
						*p_uaPtr = C_uaCleanKey;
				}
#else
				if (_ucMode & C_FillTheBlockWithCleanKeyFlag){
					for (p_uaPtr = ((unitAlloc*) (p_cBegin)) +C_ucFreeHeaderSize , _ulSize -= (ucAlignment<<1); _ulSize > 0; _ulSize= _ulSize - ucAlignment,p_uaPtr++)/*lint !e613*/{
							*p_uaPtr = C_uaCleanKey;
					}
				}
 
 
#endif /*__DEBUG_MALLOC_MODE__*/
			}/*C_BlockWithFreeFlag*/
 
			else{/*C_BlockWithoutFreeFlag*/
#ifdef D_CheckSystemForBlockWithoutFree
				/*YB 21 avril 1998 {*/
				unsigned long lTemporaryValue;
				/*locale variable for after*/
				tdstInformationHeaderOfBolckWithoutFree *p_stInfoBlockHeader;
				p_stMyBlockInfo->p_cMaxMem = p_cBegin+sizeof(tdstInformationHeaderOfBolckWithoutFree);
				lTemporaryValue = (unsigned long)p_stMyBlockInfo->p_cMaxMem;
				Mmg_M_BigBoundSize (lTemporaryValue, ucAlignment);
				p_stMyBlockInfo->p_cMaxMem = (char*)lTemporaryValue;
				/*YB 21 avril 1998 }*/
 
				p_stMyBlockInfo->p_cMaxMem-=1;
#else D_CheckSystemForBlockWithoutFree
				p_stMyBlockInfo->p_cMaxMem = p_cBegin-1;
#endif /*D_CheckSystemForBlockWithoutFree*/
				
				p_stMyBlockInfo->p_cFirstFree = C_FirstFreeValueForBlockWithoutFree;
 
				if (_ucMode & C_FillTheBlockWithCleanKeyFlag){
					for (p_cBegin = p_stMyBlockInfo->p_cMaxMem+1; p_cBegin <= p_stMyBlockInfo->p_cEndBlock; p_cBegin++){
							*p_cBegin = (char)C_uaCleanKeyForBlockWithoutFree;
					}
				}
 
#ifdef D_CheckSystemForBlockWithoutFree
				p_stInfoBlockHeader = (tdstInformationHeaderOfBolckWithoutFree*) p_stMyBlockInfo->p_cBeginBlock;
 
								
				ulI = sizeof(tdstInformationHeaderOfBolckWithoutFree);
				Mmg_M_BigBoundSize (ulI, ucAlignment);
				p_stInfoBlockHeader->ucBoundededHeaderSize = (unsigned char) ulI;
 
				p_stInfoBlockHeader->ucAlignment = ucAlignment;
				p_stInfoBlockHeader->ucMode = _ucMode;
 
				/*put the OverflowCheckKey*/
				if ((p_stMyBlockInfo->p_cEndBlock - p_stMyBlockInfo->p_cMaxMem)>= sizeof (C_TypeOfOverflowCheckKeyForBlockWithoutFree)){/*there is enought space to store the OverflowCheckKey*/					
					Mmg_fn_vWriteOverflowCheckKey(p_stMyBlockInfo->p_cMaxMem+1);
				}
 
#endif /*D_CheckSystemForBlockWithoutFree*/
			}/*C_BlockWithoutFreeFlag*/
 
#ifdef __WARNING3_ERR_MMG__
		}
#endif /* __WARNING3_ERR_MMG__*/
 
}/*Mmg_fn_vInitSpecificBlock */
 
/* ##F#===================================================================================
NAME :          Mmg_fn_vFreeBlock
DESCRIPTION :   Re-init bloc variables to free all allocation in the block
INPUT :			Block Id
				Module Id
				Block Structure 
=========================================================================================
CREATION : 06-11-97/Pierrick Crepy
=======================================================================================*/
void Mmg_fn_vFreeBlock (unsigned char ucBlockId, unsigned char ucModuleId, struct tdstBlockInfoPriv_ *p_stMyBlocksInfo){
        char * p_cBegin;
        unitAlloc * p_uaPtr;		
		struct tdstBlockInfoPriv_ *p_stMyBlockInfo = p_stMyBlocksInfo+ucBlockId;
 
#ifdef __DEBUG_MALLOC_MODE__
        unsigned long ulSize;
#endif /*__DEBUG_MALLOC_MODE__*/
 
        p_cBegin = p_stMyBlockInfo->p_cBeginBlock;
 
#ifdef __DEBUG_MALLOC_MODE__
#ifdef __FATAL_ERR_MMG__
		if (p_cBegin == C_p_cBlockNotValidKey){
#ifdef __ERROR_STRINGS__
			char szErrTxt[C_ucSizeOfErrTxt];
			sprintf (szErrTxt, "You have called 'Mmg_fn_vFreeBlock' function\nfor the block #%d in [", ucBlockId);
			Erm_M_GetModuleInformation(szErrTxt+strlen(szErrTxt), ucModuleId);
			sprintf (szErrTxt+strlen(szErrTxt), "].\nAre you sure to have well call 'Mmg_fn_vInitblock' for it ?\n");
			Mmg_M_UpdateLastError(E_uwMmgPbInvalidBlock, szErrTxt);
#else /*__ERROR_STRINGS__*/
			Mmg_M_UpdateLastError(E_uwMmgPbInvalidBlock, NULL);
#endif /*__ERROR_STRINGS__*/
		}
#endif /*__FATAL_ERR_MMG__*/
 
#endif /*__DEBUG_MALLOC_MODE__*/
 
		if (p_stMyBlockInfo->p_cFirstFree != C_FirstFreeValueForBlockWithoutFree){/*BlockWithFree*/
			/* init the free list Information in the block.*/
			/*----------------------------------------------*/
			p_uaPtr = (unitAlloc *) p_cBegin ;
			*p_uaPtr = (unitAlloc) (((unitAlloc)(p_stMyBlockInfo->p_cEndBlock - p_cBegin + 1))>> C_uwShiftAllocSize ); /* size of the free = size of the block*/
			p_uaPtr ++;
			*p_uaPtr = (unitAlloc) 0;/* there is no sucessor in the free list.*/
 
			/* record block infomations*/
			/*--------------------------*/
			p_stMyBlockInfo->p_cFirstFree = p_cBegin;
			p_stMyBlockInfo->p_cMaxMem = p_cBegin-1;
 
#ifdef __DEBUG_MALLOC_MODE__
			p_stMyBlockInfo->ulNbMalloc = 0;
			p_stMyBlockInfo->ulNbTotalMalloc = 0;
			p_stMyBlockInfo->uwNbFree = 0;/*added in the MMG V5.0.5*/
			p_stMyBlockInfo->ulNbTotalFree = 0;
			p_stMyBlockInfo->ulNbTotalRealloc = 0; /*added in the MMG V5.0.5*/
 
			/*Remark the first 2 group of C_uwAllocSize bytes (the size of the free & the adresse of the next free) are not affected because there are yet well set with free Information*/
			/* !! not already tested*/
			ulSize = (unsigned long) ((p_stMyBlockInfo->p_cEndBlock - p_cBegin +1) -(2<<C_uwShiftAllocSize));
			for (p_uaPtr = ((unitAlloc*) (p_cBegin)) +2; ulSize > 0; ulSize= ulSize - C_uwAllocSize,p_uaPtr++){
					*p_uaPtr = C_uaCleanKey;
			}
#endif /*__DEBUG_MALLOC_MODE__*/
		}/*BlockWithFree*/
		else/* BlockWithoutFree*/
		{
#ifdef D_CheckSystemForBlockWithoutFree
			tdstInformationHeaderOfBolckWithoutFree *p_stInfoBlockHeader;
 
			p_stInfoBlockHeader = (tdstInformationHeaderOfBolckWithoutFree*) p_cBegin;
			p_stMyBlockInfo->p_cMaxMem = p_cBegin + p_stInfoBlockHeader->ucBoundededHeaderSize-1;
 
			if (p_stInfoBlockHeader->ucMode & C_FillTheBlockWithCleanKeyFlag){
				for (p_cBegin = p_stMyBlockInfo->p_cMaxMem+1; p_cBegin <= p_stMyBlockInfo->p_cEndBlock; p_cBegin++){
						*p_cBegin = (char) C_uaCleanKeyForBlockWithoutFree;
				}
			}
			/*put the OverflowCheckKey*/
			if ((p_stInfoBlockHeader->ucMode & C_Check_OverflowFlag) &&
				(p_stMyBlockInfo->p_cEndBlock - p_stMyBlockInfo->p_cMaxMem)>= sizeof (C_TypeOfOverflowCheckKeyForBlockWithoutFree)){/*there is enought space to store the OverflowCheckKey*/					
				Mmg_fn_vWriteOverflowCheckKey(p_stMyBlockInfo->p_cMaxMem+1);
			}
 
 
#else /*D_CheckSystemForBlockWithoutFree*/
			p_stMyBlockInfo->p_cMaxMem = p_cBegin-1;
#endif /*D_CheckSystemForBlockWithoutFree*/
		}
 
}/*Mmg_fn_vFreeBlock*/
 
/* ##F#===================================================================================
NAME :          Mmg_fn_vDeleteBlock
DESCRIPTION :   Free Memory and invalidate the block
INPUT :			Block Id
				Module Id
				Block Structure 
=========================================================================================
CREATION : 06-11-97/Pierrick Crepy
=======================================================================================*/
void Mmg_fn_vDeleteBlock (unsigned char ucBlockId, unsigned char ucModuleId, struct tdstBlockInfoPriv_ *p_stMyBlocksInfo){
		struct tdstBlockInfoPriv_ *p_stMyBlockInfo = p_stMyBlocksInfo+ucBlockId;
 
#ifdef __DEBUG_MALLOC_MODE__
#ifdef __FATAL_ERR_MMG__
		if (p_stMyBlockInfo->p_cBeginBlock == C_p_cBlockNotValidKey){
#ifdef __ERROR_STRINGS__
			char szErrTxt[C_ucSizeOfErrTxt];
			sprintf (szErrTxt, "You have called 'Mmg_fn_vDeleteBlock' function\nfor the block #%d in [", ucBlockId);
			Erm_M_GetModuleInformation(szErrTxt+strlen(szErrTxt), ucModuleId);
			sprintf (szErrTxt+strlen(szErrTxt), "].\nAre you sure to have well call 'Mmg_fn_vInitblock' for it ?\n");
			Mmg_M_UpdateLastError(E_uwMmgPbInvalidBlock, szErrTxt);			
#else /*__ERROR_STRINGS__*/
			Mmg_M_UpdateLastError(E_uwMmgPbInvalidBlock, NULL);
#endif /*__ERROR_STRINGS__*/
		}
#endif /*__FATAL_ERR_MMG__*/
#endif /*__DEBUG_MALLOC_MODE__*/
 
 
		free (p_stMyBlockInfo->p_cBeginBlock);
#ifdef __DEBUG_MALLOC_MODE__
		free (p_stMyBlockInfo->d_stMallocInfo);
		p_stMyBlockInfo->d_stMallocInfo = NULL;
#endif /*__DEBUG_MALLOC_MODE__*/
 
 
		p_stMyBlockInfo->p_cBeginBlock = C_p_cBlockNotValidKey;
 
}/*Mmg_fn_vDeleteBlock*/
 
/* ##-########################### 
   ## DYNAMIC MODE
   ## kernel of allocation, reallocation & free 
   ############################## */
#ifdef __DYNAMIC_MALLOC_ALLOWED__ /*General*/
 
/* ##F#===================================================================================
NAME :          fn_p_vDynAlloc
DESCRIPTION :   Allocate a zone (with alignement) on a specif channel 
				Just using malloc function
INPUT :			Size to allocate
				Channel Id
OUTPUT :		Pointer on the allocated zone
=========================================================================================
CREATION : 06-11-97/Pierrick Crepy
=======================================================================================*/
void * fn_p_vDynAlloc (unsigned long ulSize, unsigned char ucChannel){
#ifdef __DYNAMIC_MALLOC_ALLOWED__
        unitAlloc *p_uaMalloc;  
#ifdef __DEBUG_MALLOC_MODE__
        unitAlloc *p_uaPtr;        
        tdstMallocInfo *p_stMyMallocInfo;
		tdstDynInfo *p_stMyDynInfo = (tdstDynInfo *) g_d_stCurrentModeInfo[ucChannel].p_vTdstBlockInfoOrTdstDynInfo;
#endif/* __DEBUG_MALLOC_MODE__*/
 
#if (defined(__FATAL_ERR_MMG__)||defined (__DEBUG_MALLOC_MODE__)) && (defined(__ERROR_STRINGS__))
		char szErrTxt[C_ucSizeOfErrTxt];
#endif /*(defined(__FATAL_ERR_MMG__)||defined (__DEBUG_MALLOC_MODE__)) && (defined(__ERROR_STRINGS__))*/
 
        unsigned long ulMalloc;
 
#if defined(U64)
	M_PrintfStopErrorN64(("Dynamic Allocation not allowed\n"));
#endif /* U64 */
#ifdef _DEBUG
#ifdef __FATAL_ERR_MMG__
		if (g_ucBLockedAllocation == C_ucTrue){
			Mmg_M_UpdateLastErrorWithCurrentModeInfo(E_uwMmgPbAccessMemoryDenied, "Dynamic Allocation : -> denied <-", ucChannel);
		}
#endif /*__FATAL_ERR_MMG__*/
#endif _DEBUG
 
        if (ulSize == 0){               
/*#ifdef __WARNING3_ERR_MMG__
                Mmg_M_UpdateLastErrorWithCurrentModeInfo (E_uwMmgPbSizeOfAllocIs0, NULL, ucChannel);
#endif 
				Mmg_MLeaveCriticalSection();*/
                return NULL;
        }
 
		Mmg_MEnterCriticalSection();
 
        Mmg_M_BigBoundSize (ulSize, C_uwAllocSize);
        ulSize >>= C_uwShiftAllocSize;
        ulSize += (C_ucMallocHeaderSize + C_ucMallocFooterSize); /* place for information(s) to manage the allocation place*/
        
        /* allocation of the Malloc*/
        /*-------------------------*/
        p_uaMalloc = (unitAlloc *) malloc (ulSize<<C_uwShiftAllocSize);
		/*p_uaMalloc = (unitAlloc *)VirtualAlloc (s_p_vRegionNumber, ulSize<<C_uwShiftAllocSize, MEM_RESERVE | MEM_COMMIT, PAGE_READWRITE);*/
        ulMalloc = (unsigned long) p_uaMalloc;
 
        /* test of allocation the begining of the block must be a muliple of C_uwAllocSize */
        Mmg_M_BigBoundSize (ulMalloc, C_uwAllocSize);
#ifdef __FATAL_ERR_MMG__
        if (p_uaMalloc != (unitAlloc *) ulMalloc){
#ifdef __ERROR_STRINGS__
			sprintf (szErrTxt, "Because 0X%X it's not multiple of %d", p_uaMalloc, C_uwAllocSize);
			Mmg_M_UpdateLastErrorWithCurrentModeInfo (E_uwMmgPbDynAllacationAlignment, szErrTxt, ucChannel);
#else /*__ERROR_STRINGS__*/
			Mmg_M_UpdateLastErrorWithCurrentModeInfo (E_uwMmgPbDynAllacationAlignment, NULL, ucChannel);
#endif/*__ERROR_STRINGS__*/
        }
#endif /*__FATAL_ERR_MMG__*/
 
        if (p_uaMalloc == NULL){
#ifdef __WARNING3_ERR_MMG__
			Mmg_M_UpdateLastErrorWithCurrentModeInfo (E_uwMmgPbDynAllacateMemory, NULL, ucChannel);
#endif /*__WARNING3_ERR_MMG__*/
				Mmg_MLeaveCriticalSection();
                return (NULL);
        }
 
        /* store malloc Information*/
        /*--------------------------*/
        *p_uaMalloc = (unitAlloc)ulSize;
 
#ifdef __DEBUG_MALLOC_MODE__
        *(p_uaMalloc + 1) = C_uaBeginKey;
        *(p_uaMalloc + ulSize -1) = C_uaEndKey;
        p_stMyMallocInfo = p_stMyDynInfo->d_stDynamicMallocInfo + (p_stMyDynInfo->ulNbDynamicMalloc++);
        if (p_stMyDynInfo->ulNbDynamicMalloc > p_stMyDynInfo->ulMaxNbDynamicMalloc) {
#ifdef __ERROR_STRINGS__
			sprintf(szErrTxt, "ulNbDynamicMalloc(%d) >  ulMaxNbDynamicMalloc (%d)\n", p_stMyDynInfo->ulNbDynamicMalloc, p_stMyDynInfo->ulMaxNbDynamicMalloc);
			Mmg_M_UpdateLastErrorWithCurrentModeInfo (E_uwMmgPbTooManyAllacation, szErrTxt, ucChannel);
#else /*__ERROR_STRINGS__*/
			Mmg_M_UpdateLastErrorWithCurrentModeInfo (E_uwMmgPbTooManyAllacation, NULL, ucChannel);
#endif /*__ERROR_STRINGS__*/
        }
        p_stMyDynInfo->ulNbTotalDynamicMalloc++;
        p_stMyMallocInfo->p_cBeginMalloc = (char *) (p_uaMalloc + C_ucMallocHeaderSize);
        p_stMyMallocInfo->p_cEndMalloc = ((char *) (p_uaMalloc + ulSize - C_ucMallocFooterSize)) - 1;
 
        /* initialisation of the malloc with the value 0xAA. */
        /*-------------------------------------------------*/
        /*Remark the bytes of Header of the free are not affected because there are yet well set with free Information*/
        ulSize-= C_ucMallocHeaderSize + C_ucMallocFooterSize;
        for (p_uaPtr = p_uaMalloc + C_ucMallocHeaderSize; ulSize > 0; ulSize--,p_uaPtr++){
                *p_uaPtr = C_uaCleanKey;
        }
#endif /* __DEBUG_MALLOC_MODE__*/
 
        /* return the Alloc adresse*/
        /*--------------------------*/
		Mmg_MLeaveCriticalSection();
        return ( (void *) (p_uaMalloc + C_ucMallocHeaderSize) );
#endif /*__DYNAMIC_MALLOC_ALLOWED__*/
}/*fn_p_cDynAlloc */
/* ================*/
 
/* ##F#===================================================================================
NAME :          fn_vDynFree
DESCRIPTION :   Free a zone allocated witn dynamic allocation on a specific channel
				Just using free function 
INPUT :			Pointer on an allocated zone
				Channel Id
=========================================================================================
CREATION : 06-11-97/Pierrick Crepy
=======================================================================================*/
void fn_vDynFree (void *p_vMemBlock, unsigned char ucChannel){
#ifdef __DYNAMIC_MALLOC_ALLOWED__
#ifdef __DEBUG_MALLOC_MODE__
	tdstMallocInfo *p_stMallocInfo;
	unsigned char b_ucFound = C_ucFalse;
	tdstDynInfo *p_stMyDynInfo = (tdstDynInfo *) g_d_stCurrentModeInfo[ucChannel].p_vTdstBlockInfoOrTdstDynInfo;
#endif /*__DEBUG_MALLOC_MODE__  */
 
#if defined(U64)
	M_PrintfStopErrorN64(("Dynamic DeAllocation not allowed\n"));
#endif /* U64 */
#ifdef _DEBUG
#ifdef __FATAL_ERR_MMG__
		if (g_ucBLockedAllocation == C_ucTrue){
			Mmg_M_UpdateLastErrorWithCurrentModeInfo (E_uwMmgPbAccessMemoryDenied, "Dynamic Free : -> denied <-", ucChannel);
		}
#endif /*__FATAL_ERR_MMG__*/
#endif /*_DEBUG*/
 
		Mmg_MEnterCriticalSection();
 
#ifdef __DEBUG_MALLOC_MODE__
#ifdef __WARNING3_ERR_MMG__
	if (p_vMemBlock==NULL){
		Mmg_M_UpdateLastErrorWithCurrentModeInfo (E_uwMmgPbFreeofNULL, NULL, ucChannel);
	}
	else 	
#endif /*__WARNING3_ERR_MMG__*/
	{/* of the else : p_vMemBlock!=NULL*/
 
		/* verification of the validity of the request*/
		/*---------------------------------------------*/
        
		/* find the good malloc */
		p_stMallocInfo = p_stMyDynInfo->d_stDynamicMallocInfo;
		while ((p_stMallocInfo < (p_stMyDynInfo->d_stDynamicMallocInfo) + p_stMyDynInfo->ulNbDynamicMalloc) && !b_ucFound){
				if (p_stMallocInfo->p_cBeginMalloc == (char *)p_vMemBlock) b_ucFound=C_ucTrue;          
				else p_stMallocInfo ++;
		}
#ifdef __WARNING3_ERR_MMG__
		if (!b_ucFound){
#ifdef __ERROR_STRINGS__
			char szErrTxt[C_ucSizeOfErrTxt];			
			sprintf(szErrTxt,"With fn_vDynFree(0X%X)\n", p_vMemBlock);
			Mmg_M_UpdateLastErrorWithCurrentModeInfo (E_uwMmgPbDynAddressNotValid, szErrTxt, ucChannel);
#else /*__ERROR_STRINGS__*/
			Mmg_M_UpdateLastErrorWithCurrentModeInfo (E_uwMmgPbDynAddressNotValid, NULL, ucChannel);
#endif /*__ERROR_STRINGS__*/
		}
		else
#endif /*__WARNING3_ERR_MMG__*/
#endif /*__DEBUG_MALLOC_MODE__  */
		{/* of the else: b_ucFound is set*/
			/*              ==> optimized Free<==*/
 
						/* Free the space*/
						/*-----------------                */
			free (((unitAlloc *)p_vMemBlock) - C_ucMallocHeaderSize);
						/*                if (!VirtualFree (((unitAlloc *)p_vMemBlock) - C_ucMallocHeaderSize, 0, MEM_RELEASE)){
		#ifdef __WARNING2_ERR_MMG__
								Mmg_M_UpdateLastErrorWithCurrentModeInfo (E_uwMmgPbDynamicFree, NULL, ucChannel);
		#else 
								;
		#endif __WARNING2_ERR_MMG__
						}
		*/
 
		/*              ==>     End of the optimized free<==*/
 
#ifdef __DEBUG_MALLOC_MODE__
			(p_stMyDynInfo->ulNbTotalDynamicFree)++;
			/* move up all the mallocs remainded*/
			/*-----------------------------------*/
			for (p_stMallocInfo ++; 
					  (p_stMallocInfo < (p_stMyDynInfo->d_stDynamicMallocInfo) + p_stMyDynInfo->ulNbDynamicMalloc);
					   p_stMallocInfo ++){
					*(p_stMallocInfo-1) = *p_stMallocInfo;
			}               
			(p_stMyDynInfo->ulNbDynamicMalloc)--;
#endif /*__DEBUG_MALLOC_MODE__*/
 
		}/* of the else: b_ucFound is set*/
#ifdef __DEBUG_MALLOC_MODE__
	}/* of the else : p_vMemBlock!=NULL*/
#endif /*__DEBUG_MALLOC_MODE__*/
	Mmg_MLeaveCriticalSection();
#endif /*__DYNAMIC_MALLOC_ALLOWED__*/
}/*fn_vDynFree */
/* ===========*/
 
/* ##F#===================================================================================
NAME :          fn_p_vDynRealloc
DESCRIPTION :   Reallcated a zone allocated witn dynamic allocation on a specific channel
				Just using realloc function 
INPUT :			Pointer on an allocated zone
				New Size
				Channel Id
=========================================================================================
CREATION : 06-11-97/Pierrick Crepy
=======================================================================================*/
void * fn_p_vDynRealloc (void *p_vMemBlock, unsigned long ulSize, unsigned char ucChannel){
#ifdef __DYNAMIC_MALLOC_ALLOWED__
        unitAlloc *p_uaTmp, *p_uaSizeMalloc;
        long lDiffSize;
 
#ifdef __DEBUG_MALLOC_MODE__
        tdstMallocInfo * p_stMyMallocInfo;
        tdstMallocInfo *p_stMallocInfo;
        unsigned char b_ucFound = C_ucFalse;
		tdstDynInfo *p_stMyDynInfo = (tdstDynInfo *) g_d_stCurrentModeInfo[ucChannel].p_vTdstBlockInfoOrTdstDynInfo;
#endif /*__DEBUG_MALLOC_MODE__  */
 
#ifdef _DEBUG
#ifdef __FATAL_ERR_MMG__
		if (g_ucBLockedAllocation == C_ucTrue){
			Mmg_M_UpdateLastErrorWithCurrentModeInfo (E_uwMmgPbAccessMemoryDenied, "Dynamic Reallocation : -> denied <-", ucChannel);
		}
#endif /*__FATAL_ERR_MMG__*/
#endif /*_DEBUG*/
 
		Mmg_MEnterCriticalSection();
 
#ifdef __DEBUG_MALLOC_MODE__
        /* verification of the validity of the request*/
        /*---------------------------------------------*/
                
        /* find the good malloc */
        p_stMallocInfo = p_stMyDynInfo->d_stDynamicMallocInfo;
        while ((p_stMallocInfo < (p_stMyDynInfo->d_stDynamicMallocInfo) + (p_stMyDynInfo->ulNbDynamicMalloc)) && !b_ucFound){
                if (p_stMallocInfo->p_cBeginMalloc == (char *)p_vMemBlock) b_ucFound=C_ucTrue;          
                else p_stMallocInfo ++;
        }
#ifdef __WARNING3_ERR_MMG__
        if (!b_ucFound){
#ifdef __ERROR_STRINGS__
			char szErrTxt[C_ucSizeOfErrTxt];			
			sprintf(szErrTxt,"With fn_p_vDynRealloc(0X%X)\n", p_vMemBlock);
			Mmg_M_UpdateLastErrorWithCurrentModeInfo (E_uwMmgPbDynAddressNotValid, szErrTxt, ucChannel);
#else /*__ERROR_STRINGS__*/
			Mmg_M_UpdateLastErrorWithCurrentModeInfo (E_uwMmgPbDynAddressNotValid, NULL, ucChannel);
#endif /*__ERROR_STRINGS__*/
        }
		else
#endif /*__WARNING3_ERR_MMG__*/
#endif /*__DEBUG_MALLOC_MODE__  */
		{ /* of the else: b_ucFound is set*/
			if (ulSize == 0){
					/*it is a free command          */
#ifdef __DEBUG_MALLOC_MODE__
					(p_stMyDynInfo->ulNbTotalDynamicFree)--;/* this is not a real free requested, then we don't have to increase the counter.*/
#endif /*__DEBUG_MALLOC_MODE__*/
					fn_vDynFree (p_vMemBlock, ucChannel);
					Mmg_MLeaveCriticalSection();
					return ((void * )0);
			}
 
			/* here ulsize != 0*/
			Mmg_M_BigBoundSize (ulSize, C_uwAllocSize);
			ulSize >>= C_uwShiftAllocSize;
			ulSize += (C_ucMallocHeaderSize + C_ucMallocFooterSize); /* place for information(s) to manage the allocation place*/
 
#ifdef __DEBUG_MALLOC_MODE__
			p_stMallocInfo = p_stMyDynInfo->d_stDynamicMallocInfo;
#endif /*__DEBUG_MALLOC_MODE__*/
 
			p_uaSizeMalloc = ((unitAlloc *) p_vMemBlock) - C_ucMallocHeaderSize; /* pointer of the real begining (before the header) of the malloc place*/
			lDiffSize = (long)(*p_uaSizeMalloc - ulSize);
 
			if (lDiffSize == 0){
					/* we do not change the size*/
					/*       ----------        */
					Mmg_MLeaveCriticalSection();
					return (p_vMemBlock);
			}
			else if (lDiffSize >0){
					/* we want to reduce the size*/
					/*            ------*/
 
					ulSize -= (C_ucMallocHeaderSize + C_ucMallocFooterSize); /* place for information(s) to manage the allocation place*/
					ulSize <<= C_uwShiftAllocSize;
 
#ifdef __DEBUG_MALLOC_MODE__
					(p_stMyDynInfo->ulNbTotalDynamicMalloc)--;/* this is not a real malloc requested, then we don't have to increase the counter.*/
#endif /*__DEBUG_MALLOC_MODE__*/
					p_uaTmp = (unitAlloc *) fn_p_vDynAlloc ((ulSize -(C_ucMallocHeaderSize + C_ucMallocFooterSize))<<C_uwShiftAllocSize, ucChannel);
 
 
					memcpy ((void *) p_uaTmp, p_vMemBlock, ((unsigned long)((*p_uaSizeMalloc - (unsigned long)lDiffSize - C_ucMallocFooterSize - C_ucMallocHeaderSize)))<< C_uwShiftAllocSize);               
 
#ifdef __DEBUG_MALLOC_MODE__
					(p_stMyDynInfo->ulNbTotalDynamicFree)--;/* this is not a real free requested, then we don't have to increase the counter.*/
#endif /*__DEBUG_MALLOC_MODE__*/
					fn_vDynFree (p_vMemBlock, ucChannel);
        
#ifdef __DEBUG_MALLOC_MODE__            
					/* store malloc Information*/
					/*--------------------------*/
					p_uaSizeMalloc = p_uaTmp - C_ucMallocHeaderSize; 
					p_stMyMallocInfo = p_stMyDynInfo->d_stDynamicMallocInfo + p_stMyDynInfo->ulNbDynamicMalloc-1;
					(p_stMyDynInfo->ulNbTotalDynamicMalloc)++;
					p_stMyMallocInfo->p_cBeginMalloc = (char *) p_uaTmp;
					p_stMyMallocInfo->p_cEndMalloc = ((char *) (p_uaSizeMalloc + ulSize - C_ucMallocFooterSize)) - 1;
#endif /* __DEBUG_MALLOC_MODE__*/
					Mmg_MLeaveCriticalSection();
					return ((void *) p_uaTmp);
			}/* we reduce*/
			else {
					/* we want to increase*/
					/*            --------*/
					lDiffSize = -lDiffSize;/* in order to have a posive value meaning the increasing requested*/
 
#ifdef __DEBUG_MALLOC_MODE__
					(p_stMyDynInfo->ulNbTotalDynamicMalloc)--;/* this is not a real malloc requested, then we don't have to increase the counter.*/
#endif /*__DEBUG_MALLOC_MODE__*/
					p_uaTmp = (unitAlloc *) fn_p_vDynAlloc ((ulSize -(C_ucMallocHeaderSize + C_ucMallocFooterSize))<<C_uwShiftAllocSize, ucChannel);
 
					memcpy ((void *) p_uaTmp, p_vMemBlock, (*p_uaSizeMalloc - C_ucMallocFooterSize - C_ucMallocHeaderSize)<< C_uwShiftAllocSize);
                
 
#ifdef __DEBUG_MALLOC_MODE__
					(p_stMyDynInfo->ulNbTotalDynamicFree)--;/* this is not a real free requested, then we don't have to increase the counter.*/
#endif /*__DEBUG_MALLOC_MODE__*/
					fn_vDynFree (p_vMemBlock, ucChannel);
 
 
#ifdef __DEBUG_MALLOC_MODE__            
					/* store malloc Information*/
					/*--------------------------            */
					p_uaSizeMalloc = p_uaTmp - C_ucMallocHeaderSize;
					p_stMyMallocInfo = (p_stMyDynInfo->d_stDynamicMallocInfo) + (p_stMyDynInfo->ulNbDynamicMalloc)-1;
					(p_stMyDynInfo->ulNbTotalDynamicRealloc)++;
					p_stMyMallocInfo->p_cBeginMalloc = (char *) p_uaTmp;
					p_stMyMallocInfo->p_cEndMalloc = ((char *) (p_uaSizeMalloc + ulSize - C_ucMallocFooterSize)) - 1;
 
#endif /* __DEBUG_MALLOC_MODE__*/
					Mmg_MLeaveCriticalSection();
					return ((void *) p_uaTmp);					
			}/* we increase */
		}/* of the else: b_ucFound is set*/
#endif /*__DYNAMIC_MALLOC_ALLOWED__*/
}/*fn_p_vDynRealloc */
/* ================*/
 
#endif /*__DYNAMIC_MALLOC_ALLOWED__*/
/* ##-########################### 
   ## STATIC MODE
   ## kernel of allocation, reallocation & free 
   ############################## */
 
/* ##F#===================================================================================
NAME :          fn_p_vStaAlloc
DESCRIPTION :   Allocate a memory zone in the block specified in the channel
				Get the first suitable place
INPUT :			New Size
				Channel Id
OUTPUT :		Pointer on the allocated zone
=========================================================================================
CREATION : 06-11-97/Pierrick Crepy
=======================================================================================*/
void * fn_p_vStaAlloc (unsigned long ulSize, unsigned char ucChannel){
		tdstBlockInfoPriv * p_stMyBlockInfo = (tdstBlockInfoPriv *) g_d_stCurrentModeInfo[ucChannel].p_vTdstBlockInfoOrTdstDynInfo;
#ifdef __DEBUG_MALLOC_MODE__
        tdstMallocInfo *p_stMyMallocInfo;
		tdstCurrentModeInfo stCurrentModeInfo = g_d_stCurrentModeInfo[ucChannel];
#endif /*__DEBUG_MALLOC_MODE__*/
 
#ifdef __ERROR_STRINGS__
#if defined(__WARNING3_ERR_MMG__) || defined (__DEBUG_MALLOC_MODE__)
			char szErrTxt[C_ucSizeOfErrTxt];
#endif/*defined(__WARNING3_ERR_MMG__) || defined (__DEBUG_MALLOC_MODE__)*/
#endif /*__ERROR_STRINGS__*/
 
#ifdef _DEBUG
#ifdef __FATAL_ERR_MMG__
		if (g_ucBLockedAllocation == C_ucTrue){
			Mmg_M_UpdateLastErrorWithCurrentModeInfo (E_uwMmgPbAccessMemoryDenied, "Static Allocation : -> denied <-", ucChannel);
		}
#endif /*__FATAL_ERR_MMG__*/
#endif /*_DEBUG*/
 
        if (ulSize == 0){               
/*#ifdef __WARNING3_ERR_MMG__
                Mmg_M_UpdateLastErrorWithCurrentModeInfo (E_uwMmgPbSizeOfAllocIs0, NULL, ucChannel);
#endif
				Mmg_MLeaveCriticalSection();*/
                return NULL;
        }
 
		Mmg_MEnterCriticalSection();
 
		/*XB*/
		M_CheckPointer(p_stMyBlockInfo);
		/*End XB*/
 
		if (p_stMyBlockInfo->p_cFirstFree != C_FirstFreeValueForBlockWithoutFree){/*BlockWithFree*/
			unitAlloc *p_uaMyFreeSpace;     
			unitAlloc *p_uaBeforeMyFreeSpace;       
			unsigned char b_ucFound = C_ucFalse;
 
			Mmg_M_BigBoundSize (ulSize, C_uwAllocSize);
			ulSize >>= C_uwShiftAllocSize;
			ulSize += (C_ucMallocHeaderSize + C_ucMallocFooterSize); /* place for information(s) to manage the allocation place*/
        
			/* find the first free enought big.*/
			/*---------------------------------*/
			p_uaMyFreeSpace = (unitAlloc *) p_stMyBlockInfo->p_cFirstFree;
			p_uaBeforeMyFreeSpace = p_uaMyFreeSpace;
 
			while ((p_uaMyFreeSpace != (unitAlloc *) 0 ) && !b_ucFound){
					  if ((*p_uaMyFreeSpace)>=(unitAlloc) ulSize){
							  b_ucFound = C_ucTrue;
					  }
					  else {/* not enought place*/
							p_uaBeforeMyFreeSpace = p_uaMyFreeSpace;
							p_uaMyFreeSpace = (unitAlloc *) *(p_uaMyFreeSpace+1);/* go to next*/
					  }
			}
			if (b_ucFound){
			
#ifdef __DEBUG_MALLOC_MODE__
#ifdef __ADD_PLACE_FOR_DEBUG_INFORMATION__
#ifdef __WARNING3_ERR_MMG__
				/* test of overflow on a block*/
				if (    (char *) ( p_uaMyFreeSpace+ (ulSize
										- ( (p_stMyBlockInfo->ulNbMalloc+1/*+1 pour le courant*/) * C_ucDebugInformationLoss )/* memMax - the place for debug information of all the allocation.*/
								 )
						)-1
					>
						(p_stMyBlockInfo->p_cEndBlock - (p_stMyBlockInfo->ulMaxNbStaticMalloc*(C_ucDebugInformationLoss<<C_uwShiftAllocSize))) /* the end of the memory without the memory added for the debug information*/
					)
				{
					unitAlloc *p_uaTheLastFreeSpace=p_uaMyFreeSpace;
#ifdef __ERROR_STRINGS__
					Mmg_fn_v_PrintInfoMalloc("\n~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~\n");
					Mmg_fn_v_PrintInfoMalloc("State of the block before the allocate problem:\n");
					sprintf (szErrTxt, "in the request 'fn_p_vStaAlloc(%d)'\n", ulSize);
					Mmg_fn_v_PrintInfoMalloc(szErrTxt);
					Mmg_fn_v_PrintInfoMalloc("~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~\n");
					Mmg_M_PrintBlockStatisticWithModuleId(stCurrentModeInfo.ucModuleId, stCurrentModeInfo.ucMode);
					Mmg_fn_v_PrintInfoMalloc("~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~\n\n");
 
					while ((unitAlloc *)*(p_uaTheLastFreeSpace+1) != NULL)
						p_uaTheLastFreeSpace = (unitAlloc *) *(p_uaTheLastFreeSpace+1);
 
					sprintf (szErrTxt, "You want to allocate %db(with the size field) but the maximum allocation allowed is %db.\nSee the %s file in witch the state (before the request of allocation)of the block is printed",
						(ulSize - C_ucDebugInformationLoss)<<C_uwShiftAllocSize,
						((*p_uaTheLastFreeSpace)- ((p_stMyBlockInfo->ulMaxNbStaticMalloc*C_ucDebugInformationLoss)- ( p_stMyBlockInfo->ulNbMalloc * C_ucDebugInformationLoss))) << C_uwShiftAllocSize,
						C_szMmgLogFileName);
					Mmg_M_UpdateLastErrorWithCurrentModeInfo (E_uwMmgPbBLockFull, szErrTxt, ucChannel);
#else /*__ERROR_STRINGS__*/
					Mmg_M_UpdateLastErrorWithCurrentModeInfo (E_uwMmgPbBLockFull, NULL, ucChannel);
#endif /*__ERROR_STRINGS__*/
					/*end of the completion of explaination of erors*/
					Mmg_MLeaveCriticalSection();
					return (NULL);
				}
#endif/*__WARNING3_ERR_MMG__*/
#endif /*__ADD_PLACE_FOR_DEBUG_INFORMATION__*/
#endif /*__DEBUG_MALLOC_MODE__*/
 
					/* use the free place (pointed by p_uaMyFreeSpace)& management of the free list*/
					/*------------------------------------------------------------------------------*/
				*p_uaMyFreeSpace -= ((unitAlloc) ulSize);/*lint !e613: Possible use of null pointer (p_uaMyFreeSpace)*/ /* the content of the size field is equal of the remain (not used for the allocation)*/
 
				if (*p_uaMyFreeSpace < (unitAlloc) C_ucFreeHeaderSize) /*lint !e613 : Possible use of null pointer (p_uaMyFreeSpace)*/
				{/*The remain of the free place is not enougth big to be managned*/
					/* we affect all the place of the free to the malloc                        */
					ulSize += (*p_uaMyFreeSpace);/*lint !e613 : Possible use of null pointer (p_uaMyFreeSpace)*/
#ifdef __DEBUG_MALLOC_MODE__   
					if ((unitAlloc *)(*(p_uaMyFreeSpace + 1))!= (unitAlloc *) 0)/*lint !e613 : Possible use of null pointer (p_uaMyFreeSpace)*/
					{/* if it's not the last free (remain)*/
						p_stMyBlockInfo->uwNbFree--; /*we have one less free*/
					}
#endif /* __DEBUG_MALLOC_MODE__*/
					
 
					/* management of the first free*/
					if (p_uaMyFreeSpace == p_uaBeforeMyFreeSpace){/* My free space is the first free*/
						p_stMyBlockInfo->p_cFirstFree = (char *) *(p_uaMyFreeSpace + 1);/*lint !e613 : Possible use of null pointer (p_uaMyFreeSpace)*/
					}
					else {/*commom case*/
						/* the 'old' free place will become empty (everything is used for the malloc)*/
						/* Management of the Free list : the 'next' field of the free place before the free place used, will be affect to the contents of the 'next' field of the free place used */
						*(p_uaBeforeMyFreeSpace + 1) = *(p_uaMyFreeSpace + 1);/*lint !e613 : Possible use of null pointer (p_uaMyFreeSpace)*/
					}
				}
				else {/* management of the remained place after the new alloction.*/
					*(p_uaMyFreeSpace+ulSize)= *p_uaMyFreeSpace;/*lint !e613: Possible use of null pointer (p_uaMyFreeSpace)*//* set the 'size' field of remained place*/
					/* the 'next' field of the remain is equal to the old next field of the free space used*/
					*(p_uaMyFreeSpace+ulSize+1)= *(p_uaMyFreeSpace+1);/*lint !e613: Possible use of null pointer (p_uaMyFreeSpace)*/
 
					/* management of the first free*/
					if (p_uaMyFreeSpace == (unitAlloc *) p_stMyBlockInfo->p_cFirstFree)/*lint !e613: Possible use of null pointer (p_uaMyFreeSpace)*/
					{                          
						p_stMyBlockInfo->p_cFirstFree = (char *) (p_uaMyFreeSpace+ulSize);/*lint !e613: Possible use of null pointer (p_uaMyFreeSpace)*/
					}
					else {/* common case*/
						/* the 'next' field of the free place before the free place used, will be affect to the content of the remain of the free place used */
						*(p_uaBeforeMyFreeSpace + 1) = (unitAlloc) (p_uaMyFreeSpace + ulSize);/*lint !e613: Possible use of null pointer (p_uaMyFreeSpace)*/
					}
				}
 
				/* store malloc Information*/
				/*--------------------------*/
				*p_uaMyFreeSpace = (unitAlloc)ulSize;/*lint !e613: Possible use of null pointer (p_uaMyFreeSpace)*/
 
#ifdef __DEBUG_MALLOC_MODE__
				*(p_uaMyFreeSpace + 1) = C_uaBeginKey;/*lint !e613: Possible use of null pointer (p_uaMyFreeSpace)*/
				*(p_uaMyFreeSpace + ulSize -1) = C_uaEndKey;/*lint !e613: Possible use of null pointer (p_uaMyFreeSpace)*/
				p_stMyMallocInfo = p_stMyBlockInfo->d_stMallocInfo + (p_stMyBlockInfo->ulNbMalloc)++;
				if (p_stMyBlockInfo->ulNbMalloc > p_stMyBlockInfo->ulMaxNbStaticMalloc) {
#ifdef __ERROR_STRINGS__
					sprintf(szErrTxt, "ulNbMalloc(%d) >  ulMaxNbStaticMalloc (%d)\n", p_stMyBlockInfo->ulNbMalloc, p_stMyBlockInfo->ulMaxNbStaticMalloc);
					Mmg_M_UpdateLastErrorWithCurrentModeInfo (E_uwMmgPbTooManyAllacation, szErrTxt, ucChannel);
#else /*__ERROR_STRINGS__*/
					Mmg_M_UpdateLastErrorWithCurrentModeInfo (E_uwMmgPbTooManyAllacation, NULL, ucChannel);
#endif /*__ERROR_STRINGS__*/
				}
 
				p_stMyMallocInfo->p_cBeginMalloc = (char *) (p_uaMyFreeSpace + C_ucMallocHeaderSize);/*lint !e613: Possible use of null pointer (p_uaMyFreeSpace)*/
				p_stMyMallocInfo->p_cEndMalloc = ((char *) (p_uaMyFreeSpace + ulSize - C_ucMallocFooterSize)) - 1;/*lint !e613: Possible use of null pointer (p_uaMyFreeSpace)*/
#endif /* __DEBUG_MALLOC_MODE__*/
				if ((char *)(p_uaMyFreeSpace+ *p_uaMyFreeSpace) -1 >=p_stMyBlockInfo->p_cMaxMem)/*lint !e613: Possible use of null pointer (p_uaMyFreeSpace)*/
				{
					/* Managemement of the mem max information in order to be able to compute an estination of the optimzed version*/
					p_stMyBlockInfo->p_cMaxMem=(char *)(p_uaMyFreeSpace+ *p_uaMyFreeSpace)-1;/*lint !e613: Possible use of null pointer (p_uaMyFreeSpace)*/
 
#ifdef __DEBUG_MALLOC_MODE__            
					p_stMyBlockInfo->ulCountMallocBeforeMaxMem = p_stMyBlockInfo->ulNbMalloc;
					p_stMyBlockInfo->ulCountFreeBeforeMaxMem = p_stMyBlockInfo->uwNbFree;
#endif /* __DEBUG_MALLOC_MODE__                 */
 
#ifdef __ADD_PLACE_FOR_DEBUG_INFORMATION__
 
#ifdef __WARNING3_ERR_MMG__
					if (    ( p_stMyBlockInfo->ulNbMalloc )
								>
							p_stMyBlockInfo->ulMaxNbStaticMalloc
						)
					{
#ifdef __ERROR_STRINGS__
						sprintf(szErrTxt, "ulNbMalloc(%d) >  ulMaxNbStaticMalloc (%d)\n", p_stMyBlockInfo->ulNbMalloc, p_stMyBlockInfo->ulMaxNbStaticMalloc);
						Mmg_M_UpdateLastErrorWithCurrentModeInfo (E_uwMmgPbSpaceForDebugInformationIsFull, szErrTxt, ucChannel);
#else /*__ERROR_STRINGS__*/
						Mmg_M_UpdateLastErrorWithCurrentModeInfo (E_uwMmgPbSpaceForDebugInformationIsFull, NULL, ucChannel);
#endif /*__ERROR_STRINGS__*/
					}
#endif /*__WARNING3_ERR_MMG__*/
#endif /*__ADD_PLACE_FOR_DEBUG_INFORMATION__*/
 
 
				}/* Managemement of the mem max information */
#ifdef __DEBUG_MALLOC_MODE__
				p_stMyBlockInfo->ulNbTotalMalloc++;
#endif /* __DEBUG_MALLOC_MODE__*/
 
				/* return the Alloc adresse*/
				/*--------------------------*/
				Mmg_MLeaveCriticalSection();
				return ( (void *) (p_uaMyFreeSpace + C_ucMallocHeaderSize) );/*lint !e613: Possible use of null pointer (p_uaMyFreeSpace)*/
			}
			else{
#ifdef __WARNING3_ERR_MMG__
#ifdef __DEBUG_MALLOC_MODE__
#ifdef __ERROR_STRINGS__
				sprintf (szErrTxt, "there is no free space enougth big (i.e. %db)\n,even with the 'added debug information' memory\n",
					(ulSize - C_ucDebugInformationLoss)<<C_uwShiftAllocSize);
				Mmg_M_UpdateLastErrorWithCurrentModeInfo (E_uwMmgPbBLockFull, szErrTxt, ucChannel);
#else /*__ERROR_STRINGS__*/			
				Mmg_M_UpdateLastErrorWithCurrentModeInfo (E_uwMmgPbBLockFull, NULL, ucChannel);
#endif /*__ERROR_STRINGS__*/
 
#else /* __DEBUG_MALLOC_MODE__*/
 
#ifdef __ERROR_STRINGS__
				sprintf (szErrTxt, "there is no free space enougth big (i.e. %db)\n,even with the 'added debug information' memory\n",
					ulSize<<C_uwShiftAllocSize);
				Mmg_M_UpdateLastErrorWithCurrentModeInfo (E_uwMmgPbBLockFull, szErrTxt, ucChannel);
#else /*__ERROR_STRINGS__*/			
				Mmg_M_UpdateLastErrorWithCurrentModeInfo (E_uwMmgPbBLockFull, NULL, ucChannel);
#endif /*__ERROR_STRINGS__*/
 
#endif /* __DEBUG_MALLOC_MODE__*/
#endif/*__WARNING3_ERR_MMG__*/
				Mmg_MLeaveCriticalSection();
				return (NULL);
			}
	
		}/*BlockWithFree*/
		else{/*BlockWithoutFree*/
			unsigned long ulI;
#ifdef D_CheckSystemForBlockWithoutFree
			tdstInformationHeaderOfBolckWithoutFree *p_stInfoHeaderBolck = 
				(tdstInformationHeaderOfBolckWithoutFree *) p_stMyBlockInfo->p_cBeginBlock;
 
/*#define Mmg_M_BigBoundSize(ulSize, ucAlignment)*/
/*            if ( (ulSize) & (unsigned long)((p_stInfoHeaderBolck->ucAlignment)-1)) {
				(ulSize) = ((ulSize) & (~((unsigned long)((p_stInfoHeaderBolck->ucAlignment)-1)))) + (p_stInfoHeaderBolck->ucAlignment);
            }*/
 
			Mmg_M_BigBoundSize (ulSize, p_stInfoHeaderBolck->ucAlignment);/* added to be shure that the alignment is Ok*/
#endif /*D_CheckSystemForBlockWithoutFree*/
 
			/* compute the real remain;*/
			ulI = p_stMyBlockInfo->p_cEndBlock-p_stMyBlockInfo->p_cMaxMem;
			if (ulSize > ulI) {
#ifdef __WARNING3_ERR_MMG__
#ifdef __ERROR_STRINGS__
				sprintf(szErrTxt, "the is not enought memory(%db) for the allocation size requested (%d)\n", ulI, ulSize);
				Mmg_M_UpdateLastErrorWithCurrentModeInfo (E_uwMmgPbBLockFull, szErrTxt, ucChannel);
#else /*__ERROR_STRINGS__*/
				Mmg_M_UpdateLastErrorWithCurrentModeInfo (E_uwMmgPbBLockFull, NULL, ucChannel);
#endif /*__ERROR_STRINGS__*/	 
#endif /*__WARNING3_ERR_MMG__*/
				Mmg_MLeaveCriticalSection();
				return (NULL);
			}
 
#ifdef D_CheckSystemForBlockWithoutFree
 
			/* the check overflow key just after the p_cMaxMem*/
			if ((p_stInfoHeaderBolck->ucMode & C_Check_OverflowFlag) && 
				(ulI >= sizeof (C_TypeOfOverflowCheckKeyForBlockWithoutFree)) && /*there is enought space to store the remain*/
				(!Mmg_fn_b_cIsItEqualToOverflowCheckKey(p_stMyBlockInfo->p_cMaxMem+1)) ) {
#ifdef U64
				M_PrintfN64(("E_uwMmgPbOverFlowBeforeOnTheRemainTag: p_cMaxMem+1=0X%X\n", p_stMyBlockInfo->p_cMaxMem+1));
#endif /*U64*/
#ifdef __ERROR_STRINGS__
				sprintf(szErrTxt, "The key expexted should be 0X%X, but we have 0X%X\n",C_ulOverflowCheckKey, (*(C_TypeOfOverflowCheckKeyForBlockWithoutFree *)(p_stMyBlockInfo->p_cMaxMem+1)));
				Mmg_M_UpdateLastErrorWithCurrentModeInfo (E_uwMmgPbOverFlowBeforeOnTheRemainTag, szErrTxt, ucChannel);
#else /*__ERROR_STRINGS__*/
				Mmg_M_UpdateLastErrorWithCurrentModeInfo (E_uwMmgPbOverFlowBeforeOnTheRemainTag, NULL, ucChannel);
#endif /*__ERROR_STRINGS__*/
			}
 
			/* if needed (C_FillTheBlockWithCleanKeyFlag), erase the old key by */
			if (p_stInfoHeaderBolck->ucMode & C_FillTheBlockWithCleanKeyFlag){
				char * p_cTmp;
				for (p_cTmp = p_stMyBlockInfo->p_cMaxMem+1; 
						(p_cTmp <= p_stMyBlockInfo->p_cMaxMem+sizeof(C_TypeOfOverflowCheckKeyForBlockWithoutFree)) &&
							(p_cTmp <= p_stMyBlockInfo->p_cEndBlock);
						p_cTmp++){
						*p_cTmp = (char)C_uaCleanKeyForBlockWithoutFree;
				}
			}
 
 
			/* check the alignment*/
			if (p_stInfoHeaderBolck->ucMode & C_Check_AlignementFlag){
				ulI = ulSize;
				Mmg_M_BigBoundSize (ulSize, p_stInfoHeaderBolck->ucAlignment);
 
				if (ulI != ulSize) {
#ifdef U64
					M_PrintfN64(("E_uwMmgPbAlignmentAllocationRequested: %d [%d]--> %d\n", ulI, p_stInfoHeaderBolck->ucAlignment, ulSize));
#endif /*U64*/
#ifdef __ERROR_STRINGS__
					sprintf(szErrTxt, "the size requested (%d) is not a multiple of the alignment(%d)\n", ulI, p_stInfoHeaderBolck->ucAlignment);
					Mmg_M_UpdateLastErrorWithCurrentModeInfo (E_uwMmgPbAlignmentAllocationRequested, szErrTxt, ucChannel);
#else /*__ERROR_STRINGS__*/
					Mmg_M_UpdateLastErrorWithCurrentModeInfo (E_uwMmgPbAlignmentAllocationRequested, NULL, ucChannel);
#endif /*__ERROR_STRINGS__*/
				}
			}/*C_Check_AlignementFlag*/
#endif /*D_CheckSystemForBlockWithoutFree*/
 
			/*save the adresse of the return pointer in ulI*/
			ulI = (unsigned long) p_stMyBlockInfo->p_cMaxMem + 1;
 
			p_stMyBlockInfo->p_cMaxMem += ulSize;
 
#ifdef D_CheckSystemForBlockWithoutFree
			/*Store the overflow key check*/
			if ((p_stMyBlockInfo->p_cEndBlock - p_stMyBlockInfo->p_cMaxMem) >= sizeof(C_TypeOfOverflowCheckKeyForBlockWithoutFree)){/*there is enought space to store the OverflowCheckKey*/
				Mmg_fn_vWriteOverflowCheckKey(p_stMyBlockInfo->p_cMaxMem+1);
			}
#endif /*D_CheckSystemForBlockWithoutFree*/
			Mmg_MLeaveCriticalSection();
			return ((void*) ulI);
/*			return (NULL);*/
 
		}/*BlockWithoutFree*/
}/*fn_p_cStaAlloc */
/* ================*/
 
/* ##F#===================================================================================
NAME :          fn_vStaFree
DESCRIPTION :   Free a memory zone in the block specified in the channel
				append with the previous and next zone if possible
INPUT :			Pointer on an allocated zone
				Channel Id
=========================================================================================
CREATION : 06-11-97/Pierrick Crepy
=======================================================================================*/
void fn_vStaFree (void *p_vMemBlock, unsigned char ucChannel){
/*   ===========*/
#ifdef __DEBUG_MALLOC_MODE__
        unsigned char b_ucFound = C_ucFalse;
        tdstMallocInfo * p_stMallocInfo;
		unsigned short uwNbCreatedFree = 1;/*the common case (without any join), we create 1 new free*/
#endif/*__DEBUG_MALLOC_MODE__*/
        tdstBlockInfoPriv * p_stMyBlockInfo = (tdstBlockInfoPriv *) g_d_stCurrentModeInfo[ucChannel].p_vTdstBlockInfoOrTdstDynInfo;
        unitAlloc * p_uaNextFree;
        unitAlloc * p_uaSizeMalloc;
        unitAlloc *p_uaAfterFreeSpace;  
        unitAlloc *p_uaBeforeFreeSpace; 
 
/* Oliv' - Portage v15 - Blindage pour éviter les trucs genre GAM_Malloc -> TMP_Free !!*/
#ifndef RETAIL
	if (((char*)p_vMemBlock) < p_stMyBlockInfo->p_cBeginBlock || ((char*)p_vMemBlock)>p_stMyBlockInfo->p_cEndBlock)
	{
		Mmg_M_UpdateLastErrorWithCurrentModeInfo (E_uwMmgPbStaAddressNotValid, NULL, ucChannel);
#ifdef U64
		M_PrintfStopErrorN64(("Deallocating memory not in the right block !!!\n"));
#endif
	}
#endif /*RETAIL*/
/* EndOfOliv'*/
 
#ifdef _DEBUG
#ifdef __FATAL_ERR_MMG__
		if (g_ucBLockedAllocation == C_ucTrue){
			Mmg_M_UpdateLastErrorWithCurrentModeInfo (E_uwMmgPbAccessMemoryDenied, "Static Free : -> denied <-", ucChannel);			
		}
#endif /*__FATAL_ERR_MMG__*/
#endif /*_DEBUG*/
 
 
#ifdef D_CheckSystemForBlockWithoutFree
		if (p_stMyBlockInfo->p_cFirstFree == C_FirstFreeValueForBlockWithoutFree){
			Mmg_M_UpdateLastError(E_uwMmgPbNoAvailableFunctionForBlockWithoutFree, NULL)
		}
#endif /*D_CheckSystemForBlockWithoutFree*/
 
		Mmg_MEnterCriticalSection();
 
#ifdef __DEBUG_MALLOC_MODE__
#ifdef __WARNING3_ERR_MMG__
		if (p_vMemBlock==NULL){
			Mmg_M_UpdateLastErrorWithCurrentModeInfo (E_uwMmgPbFreeofNULL, NULL, ucChannel);
		}
		else
#endif /*__WARNING3_ERR_MMG__*/
		{/* of the else : p_vMemBlock!=NULL*/
			p_stMallocInfo = p_stMyBlockInfo->d_stMallocInfo; 
			/* verification of the validity of the request*/
			/*---------------------------------------------*/
                
			/* find the good malloc */
			while ((p_stMallocInfo < p_stMyBlockInfo->d_stMallocInfo + (p_stMyBlockInfo->ulNbMalloc)) && !b_ucFound){
					if (p_stMallocInfo->p_cBeginMalloc == (char *)p_vMemBlock) b_ucFound=C_ucTrue;          
					else p_stMallocInfo ++;
			}
#ifdef __WARNING3_ERR_MMG__
			if (!b_ucFound){
#ifdef __ERROR_STRINGS__
				char szErrTxt[C_ucSizeOfErrTxt];
				sprintf (szErrTxt, "With fn_vStaFree(0X%X)\n", p_vMemBlock);
				Mmg_M_UpdateLastErrorWithCurrentModeInfo (E_uwMmgPbStaAddressNotValid, szErrTxt, ucChannel);
#else /*__ERROR_STRINGS__*/			
				Mmg_M_UpdateLastErrorWithCurrentModeInfo (E_uwMmgPbStaAddressNotValid, NULL, ucChannel);
#endif /*__ERROR_STRINGS__*/
			}
			else
#endif /* __WARNING3_ERR_MMG__*/
			{/* ofthe else : b_ucfound is set*/
#endif /*__DEBUG_MALLOC_MODE__*/
 
				/* Management of the free list*/
				/*-----------------------------*/
 
				/* Goal: We want the sort list of free, then we insert the new free space between the (2) contiguous free space.*/
				/* look for the rigth place.*/
				p_uaBeforeFreeSpace = p_uaAfterFreeSpace = (unitAlloc *) p_stMyBlockInfo->p_cFirstFree;
				while ((p_uaAfterFreeSpace != (unitAlloc *) 0 ) && (p_uaAfterFreeSpace < (unitAlloc *) p_vMemBlock) ){
						p_uaBeforeFreeSpace = p_uaAfterFreeSpace;
#ifdef CHECK_MEMORY
						if(p_uaAfterFreeSpace==((unitAlloc *) p_vMemBlock) - C_ucMallocHeaderSize)
						{
							osSyncPrintf("Bouclage : always a Free de %x\n",(unsigned long)p_vMemBlock); 
							fn_vDebug();
						}

						if(p_uaAfterFreeSpace==(unitAlloc *) *(p_uaAfterFreeSpace+1))
						{
							osSyncPrintf("Bouclage : Free de %x\n",(unsigned long)p_vMemBlock); 
							fn_vDebug();
						}
#endif
						p_uaAfterFreeSpace = (unitAlloc *) *(p_uaAfterFreeSpace+1);/* go to next*/
				}
				/* here p_uaAfterFreeSpace point at the free space just after & p_uaBeforeFreeSpace that is just before*/
 
				/* general case:*/
				/*  |            Free          | (...) |         allocation         | (...) |   Free   |*/
				/*  ^-- p_uaBeforeFreeSpace               ^-- p_vMemBlock                   ^-- p_uaAfterFreeSpace*/
 
				/* set information for the new free space*/
				/* size of the free block is the same that the size of malloc block at the begining at adresse [ ((unitAlloc) p_vMemBlock) - C_ucMallocHeaderSize ]*/
 
				/* mamnagement of the next field of the list    */
				/*p_uaNextFree points at the 'next' field of my new free place*/
				p_uaNextFree = ((unitAlloc *) p_vMemBlock) - C_ucMallocHeaderSize + 1;/*1 to junp the size field (of the free place) in order point at the next field*/
				p_uaSizeMalloc = ((unitAlloc *) p_vMemBlock) - C_ucMallocHeaderSize; /* ptr of the real begining (before the header) of the malloc place*/
 
				if (p_uaBeforeFreeSpace == p_uaAfterFreeSpace) {/*my new free space will become the first element of the free list*/
						/* Management of joining with the old first free space after my new free*/
						if ( (p_uaSizeMalloc + *p_uaSizeMalloc) == p_uaAfterFreeSpace ){
								/*my new free space and the old first free space have to be joined with thz free space just after because the end of my new free space =begining of the first free space                                                */
								/*                                                                                                                      -----------                      ----------------               */
								*(p_uaNextFree-1) = *(p_uaNextFree-1) + *p_uaAfterFreeSpace;/*lint !e613: Possible use of null pointer (p_uaMyFreeSpace)*/ /*the 'size' field of my new free space must be added with the content of 'size' field of my joined free space                      */
								*p_uaNextFree = *(p_uaAfterFreeSpace + 1);/*lint !e613: Possible use of null pointer (p_uaMyFreeSpace)*/ /* the 'next' field of my new free space is equal to the 'next' field of my old first free space*/
#ifdef __DEBUG_MALLOC_MODE__
								/* clean the area of the old free, i.e. the Header of the Free just after*/
								*p_uaAfterFreeSpace = C_uaCleanKey;/*lint !e613: Possible use of null pointer (p_uaMyFreeSpace)*/ /* the FreeSize field*/
								*(p_uaAfterFreeSpace+1) = C_uaCleanKey;/*lint !e613: Possible use of null pointer (p_uaMyFreeSpace)*//* the field of the adress of the next free*/
								uwNbCreatedFree--;/*we have join 2 free together*/
#endif /*__DEBUG_MALLOC_MODE__  */
						}
						else{ /* common case : no need to join*/
								*p_uaNextFree = (unitAlloc) p_uaAfterFreeSpace;
						}       
 
						/*The begining of the new free space.*/
						p_stMyBlockInfo->p_cFirstFree = (char *) (((unitAlloc *) p_vMemBlock) - C_ucMallocHeaderSize);
				}
 
				else {/* common case: insert the new fre space between p_uaBeforeFreeSpace & p_uaAfterFreeSpace.*/
						/* Management of joining with the free space just after my new free space*/
						if ( (p_uaSizeMalloc + *p_uaSizeMalloc) == p_uaAfterFreeSpace ){/*my new free space and the free space just after have to be joined because the end of my new free space = begining of the free space after*/
								*(p_uaNextFree-1) = *(p_uaNextFree-1) + *p_uaAfterFreeSpace;/*lint !e613: Possible use of null pointer (p_uaMyFreeSpace)*/ /*the 'size' field of my new free space must be added with the content of 'size' field of my joined free space                      */
								*p_uaNextFree = *(p_uaAfterFreeSpace + 1);/*lint !e613: Possible use of null pointer (p_uaMyFreeSpace)*/ /* the 'next' field of my new free space is equal to the 'next' field of the free space just after*/
#ifdef __DEBUG_MALLOC_MODE__
								/* clean the area of the old free, i.e. the Header of the Free just after*/
								*p_uaAfterFreeSpace = C_uaCleanKey;/*lint !e613: Possible use of null pointer (p_uaMyFreeSpace)*/ /* the FreeSize field*/
								*(p_uaAfterFreeSpace+1) = C_uaCleanKey;/*lint !e613: Possible use of null pointer (p_uaMyFreeSpace)*/ /* the field of the adress of the next free*/
								uwNbCreatedFree--;/*we have join 2 free together*/
#endif /*__DEBUG_MALLOC_MODE__  */
						}
						else {/* no need to join my free space with the free space just after*/
								*p_uaNextFree = *(p_uaBeforeFreeSpace +1);/*the 'next' field of my free space is equal to the contents of the next field of the fre space just before it*/
						}
 
						/* Management of joining with the free space just before my new free space*/
						if ( (p_uaBeforeFreeSpace  + *p_uaBeforeFreeSpace) == p_uaSizeMalloc ){/*my new free space and the free space just before have to be joined because the end of the free space before = begining of my new free space*/
								*(p_uaBeforeFreeSpace) =*(p_uaBeforeFreeSpace) + *(p_uaNextFree-1);/*the 'size' field of the free space just before must be added with the content of 'size' field of my new free space                 */
								*(p_uaBeforeFreeSpace +1) = *p_uaNextFree;/* the 'next' field of the free space just before is equal to the 'next' field of my new free space*/
#ifdef __DEBUG_MALLOC_MODE__
								/* clean the area the Header of the new Free located at the old allocation*/
								*p_uaSizeMalloc = C_uaCleanKey;/* the FreeSize field*/
								*(p_uaSizeMalloc+1) = C_uaCleanKey;/* the field of the adress of the next free*/
								uwNbCreatedFree--;/*we have join 2 free together*/
 
								/* code only used for clean the new free area.*/
								/* this is the only case where the begining of the new free space change (not equal to p_vMemBlock), then we have to set p_vMemblock in order to point on the right place*/
		/* a supprimer                        p_vMemBlock = (void *) (p_uaBeforeFreeSpace + C_ucMallocHeaderSize);*/
 
#endif /*__DEBUG_MALLOC_MODE__*/
						}
						else{/* no need to join my free space with the free space just before*/
								*(p_uaBeforeFreeSpace +1) = (unitAlloc)(((unitAlloc*) p_vMemBlock) - C_ucMallocHeaderSize);/*the contents of the next field just before my new free space must be equal to the adresse of my new free space.*/
						}
				}
 
 
#ifdef __DEBUG_MALLOC_MODE__
 
				/* clean the area of the new free. we use the variable p_uaNextFree for scan the memory & p_uaAfterfreespace for the end of the free area.*/
				for (   p_uaNextFree = ((unitAlloc *) p_stMallocInfo->p_cBeginMalloc);
								p_uaNextFree < ((unitAlloc *) p_stMallocInfo->p_cEndMalloc) + 1 /*for the ending key*/;
								p_uaNextFree++
					){
						*p_uaNextFree = C_uaCleanKey;
				}
 
				/* move up all the mallocs remainded*/
				/*-----------------------------------*/
				for (p_stMallocInfo ++; 
						  (p_stMallocInfo < p_stMyBlockInfo->d_stMallocInfo + (p_stMyBlockInfo->ulNbMalloc));
						   p_stMallocInfo ++){
						*(p_stMallocInfo-1) = *p_stMallocInfo;
				}               
				(p_stMyBlockInfo->ulNbMalloc) --;
 
				p_stMyBlockInfo->ulNbTotalFree++;
				p_stMyBlockInfo->uwNbFree+= uwNbCreatedFree;		
			}/* ofthe else : b_ucfound is set*/
		}/* of the else : p_vMemBlock!=NULL*/
#endif /*__DEBUG_MALLOC_MODE__  */
		Mmg_MLeaveCriticalSection();
}/* fn_vStaFree */
/*  ===========*/
 
/* ##F#===================================================================================
NAME :          fn_p_vStaRealloc
DESCRIPTION :   Realloc a memory zone in the block specified in the channel
				always try to allocated at a lower address
INPUT :			Pointer on an allocated zone
				New Size
				Channel Id
OUTPUT :		Pointeur on the new zone
=========================================================================================
CREATION : 06-11-97/Pierrick Crepy
=======================================================================================*/
void * fn_p_vStaRealloc (void *p_vMemBlock, unsigned long ulSize, unsigned char ucChannel){
/*     ================*/
#ifdef __DEBUG_MALLOC_MODE__
        tdstMallocInfo * p_stMallocInfo;
        tdstMallocInfo *p_stMyMallocInfo;
		unsigned long ulMyNbMalloc;		
		tdstCurrentModeInfo stCurrentModeInfo = g_d_stCurrentModeInfo[ucChannel];
#ifdef __ERROR_STRINGS__
		char szErrTxt[C_ucSizeOfErrTxt];
#endif /*__ERROR_STRINGS__*/
 
#endif/*__DEBUG_MALLOC_MODE__*/
        tdstBlockInfoPriv * p_stMyBlockInfo = (tdstBlockInfoPriv *) g_d_stCurrentModeInfo[ucChannel].p_vTdstBlockInfoOrTdstDynInfo;
        unitAlloc * p_uaTmp;/*temporary pointer: if we reduce the allocation p_uaTmp=pointer at the new free space. // !! voir a renomer*/
        unitAlloc * p_uaSizeMalloc;
        unitAlloc *p_uaBeforeBeforeFreeSpace;   
        unitAlloc *p_uaBeforeFreeSpace; 
        unitAlloc *p_uaAfterFreeSpace;  
        unitAlloc *p_uaAfterAfterFreeSpace;     
        unitAlloc uaBeforeFreeSize, uaAfterFreeSize;/* size of the free space just before & after the allocation. 0 meaning there are not adjacent to the malloc*/
        long lDiffSize;/* difference between the actual size and the size requested (ulSize) */
        unsigned char b_ucFound = C_ucFalse;
 
 
#ifdef _DEBUG
#ifdef __FATAL_ERR_MMG__
		if (g_ucBLockedAllocation == C_ucTrue){
			Mmg_M_UpdateLastErrorWithCurrentModeInfo (E_uwMmgPbAccessMemoryDenied, "Static Reallocation : -> denied <-", ucChannel);			
		}
#endif /*__FATAL_ERR_MMG__*/
#endif /*_DEBUG*/
 
 
#ifdef D_CheckSystemForBlockWithoutFree
		if (p_stMyBlockInfo->p_cFirstFree == C_FirstFreeValueForBlockWithoutFree){
			Mmg_M_UpdateLastError(E_uwMmgPbNoAvailableFunctionForBlockWithoutFree, NULL)
		}
#endif /*D_CheckSystemForBlockWithoutFree*/
 
		Mmg_MEnterCriticalSection();
 
#ifdef __DEBUG_MALLOC_MODE__    
        p_stMallocInfo = p_stMyBlockInfo->d_stMallocInfo; 
        /* verification of the validity of the request & find the ulMyNbMalloc*/
        /*---------------------------------------------------------------------*/
                
        /* find the good malloc ulMyNbMalloc*/
        ulMyNbMalloc = 0;
        while ((p_stMallocInfo < p_stMyBlockInfo->d_stMallocInfo + (p_stMyBlockInfo->ulNbMalloc)) && !b_ucFound){
                if (p_stMallocInfo->p_cBeginMalloc == (char *)p_vMemBlock) b_ucFound=C_ucTrue;          
                else {
                        p_stMallocInfo ++;
                        ulMyNbMalloc++;
                }
        }
#ifdef __WARNING3_ERR_MMG__
        if (!b_ucFound){
#ifdef __ERROR_STRINGS__
			sprintf (szErrTxt, "With fn_vStaRealloc(0X%X)\n", p_vMemBlock);
			Mmg_M_UpdateLastErrorWithCurrentModeInfo (E_uwMmgPbStaAddressNotValid, szErrTxt, ucChannel);
#else /*__ERROR_STRINGS__*/
			Mmg_M_UpdateLastErrorWithCurrentModeInfo (E_uwMmgPbStaAddressNotValid, NULL, ucChannel);
#endif /*__ERROR_STRINGS__*/
        }
		else
#endif /* __WARNING3_ERR_MMG__*/
#endif /*__DEBUG_MALLOC_MODE__*/
		{/* of the else b_ucFound is set*/
 
			if (ulSize == 0){
					/*it is a free command                          */
	#ifdef __DEBUG_MALLOC_MODE__
					(p_stMyBlockInfo->ulNbTotalFree)--;/* this is not a real free requested, then we don't have to increase the counter.          */
	#endif /*__DEBUG_MALLOC_MODE__*/
					fn_vStaFree (p_vMemBlock, ucChannel);
					Mmg_MLeaveCriticalSection();
					return ((void * )0);
			}
 
			Mmg_M_BigBoundSize (ulSize, C_uwAllocSize);
			ulSize >>= C_uwShiftAllocSize;
			ulSize += (C_ucMallocHeaderSize + C_ucMallocFooterSize); /* place for information(s) to manage the allocation place*/
 
			p_uaSizeMalloc = ((unitAlloc *) p_vMemBlock) - C_ucMallocHeaderSize; /* pointer of the real begining (before the header) of the malloc place*/
			lDiffSize = (long)(*p_uaSizeMalloc - ulSize);
 
			/*check if there is a space enought big to receive the allocation before p_vMemblock*/
			/*-----               -----------------                           ------------------*/
 
			p_uaBeforeBeforeFreeSpace = p_uaBeforeFreeSpace = (unitAlloc *) p_stMyBlockInfo->p_cFirstFree;
			b_ucFound = C_ucFalse;
			while ((p_uaBeforeFreeSpace != (unitAlloc *) 0 ) && (p_uaBeforeFreeSpace < p_uaSizeMalloc) && !b_ucFound ){
					  if ((*p_uaBeforeFreeSpace)>=(unitAlloc) ulSize){
							  b_ucFound = C_ucTrue;
					  }
					  else {/* not enought place*/
							p_uaBeforeBeforeFreeSpace = p_uaBeforeFreeSpace;
							p_uaBeforeFreeSpace = (unitAlloc *) *(p_uaBeforeFreeSpace+1);/* go to next*/
					  }
			}
			if (b_ucFound){
					/* we can move up */
					/*        -------*/
					ulSize -= (C_ucMallocHeaderSize + C_ucMallocFooterSize); /* place for information(s) to manage the allocation place*/
					ulSize <<= C_uwShiftAllocSize;
 
#ifdef __DEBUG_MALLOC_MODE__
					p_stMyBlockInfo->ulNbTotalMalloc--;/* this is not a real malloc requested, then we don't have to increase the counter.*/
#endif /*__DEBUG_MALLOC_MODE__*/
					p_uaTmp = (unitAlloc *) fn_p_vStaAlloc (ulSize, ucChannel);
 
 
					memcpy ((void *) p_uaTmp, p_vMemBlock, ulSize);
                
 
 
#ifdef __DEBUG_MALLOC_MODE__
					p_stMyBlockInfo->ulNbTotalFree--;/* this is not a real free requested, then we don't have to increase the counter.*/
#endif /*__DEBUG_MALLOC_MODE__*/
					fn_vStaFree (p_vMemBlock, ucChannel);
#ifdef __DEBUG_MALLOC_MODE__
					/* the free have move up all the elt after the freed malloc of the Malloc info Table*/
					/* then we have to use the last elt of the malloc info table*/
					ulMyNbMalloc= (unsigned short) (p_stMyBlockInfo->ulNbMalloc -1);
#endif /*__DEBUG_MALLOC_MODE__*/
 
 
 
#ifdef __DEBUG_MALLOC_MODE__                            
					p_stMyBlockInfo->ulNbTotalRealloc++;
					p_vMemBlock = p_uaTmp;
#endif /* __DEBUG_MALLOC_MODE__*/
                
					p_uaSizeMalloc = p_uaTmp - C_ucMallocHeaderSize;
					if ((char*)(p_uaSizeMalloc + *p_uaSizeMalloc)-1>=p_stMyBlockInfo->p_cMaxMem){
							/* Managemement of the mem max information i order to be able to compute an estination of the optimzed version*/
							p_stMyBlockInfo->p_cMaxMem=(char*)(p_uaSizeMalloc + *p_uaSizeMalloc)-1;
 
#ifdef __DEBUG_MALLOC_MODE__
							p_stMyBlockInfo->ulCountMallocBeforeMaxMem = p_stMyBlockInfo->ulNbMalloc;
							p_stMyBlockInfo->ulCountFreeBeforeMaxMem = p_stMyBlockInfo->uwNbFree;
#endif /* __DEBUG_MALLOC_MODE__*/
					}
	/* not necessary
#ifdef __DEBUG_MALLOC_MODE__
					// count the real number of free
					p_uaTmp = (unitAlloc*)p_stMyBlockInfo->p_cFirstFree;
					for (uwI=0; *(p_uaTmp+1) != (unitAlloc)0; uwI++, p_uaTmp = (unitAlloc *) *(p_uaTmp+1));
					p_stMyBlockInfo->uwNbFree = uwI;
					p_uaTmp = p_vMemBlock;
#endif __DEBUG_MALLOC_MODE__
	*/
 
					Mmg_MLeaveCriticalSection();
					return ((void *) p_uaTmp);
	/*              -------*/
			}/* end of move up*/
 
			/* inplice else because there is an return just before in the if*/
 
        
			/* common algorithm     */
			/* Verify if there is any free space just after or before the actual malloc*/
			/* ------                 ----       ---------------------                */
			p_uaBeforeBeforeFreeSpace = p_uaBeforeFreeSpace = p_uaAfterFreeSpace = (unitAlloc *) p_stMyBlockInfo->p_cFirstFree;
			while ((p_uaAfterFreeSpace != (unitAlloc *) 0 ) && (p_uaAfterFreeSpace < (unitAlloc *) p_vMemBlock) ){
					p_uaBeforeBeforeFreeSpace = p_uaBeforeFreeSpace;
					p_uaBeforeFreeSpace = p_uaAfterFreeSpace;
					p_uaAfterFreeSpace = (unitAlloc *) *(p_uaAfterFreeSpace+1);/* go to next*/
			}
			/* here p_uaAfterFreeSpace point at the free space just after & p_uaBeforeFreeSpace that is just before & *(p_uaBeforeBefore+1) = p_uaBeforeFree*/
 
			/* general case:*/
			/* |        Free            | ... |        Free      | (...) |   allocation  | (...) |   Free   |*/
			/* ^-- p_uaBeforeBeforeFree       ^-- p_uaBeforeFree         ^-- p_vMemBlock         ^-- p_uaAfterFree*/
 
			if ((lDiffSize == 0) && ((p_uaBeforeFreeSpace != (unitAlloc *) 0) && (p_uaBeforeFreeSpace + *p_uaBeforeFreeSpace == p_uaSizeMalloc))){
					/* we want to 'move up' just before the malloc with the same size. Because there is a free space just before my malloc */
					/*            ---------------------*/
 
					/* Yes there is a free space just before my malloc */
					/*                                ------*/
					/*==> We will move the malloc to the beginig of the free, in order to have the new free space after.*/
 
					/* general case:*/
					/* |        Free            | ... |        Free      ||      allocation     | (...) |   Free   |*/
					/* ^-- p_uaBeforeBeforeFree       ^-- p_uaBeforeFree  ^-- p_vMemBlock               ^-- p_uaAfterFree*/
 
					/* definition of my new free space after : p_uaTmp*/
					/*                                         -------*/
					p_uaTmp = p_uaSizeMalloc + *p_uaSizeMalloc - *p_uaBeforeFreeSpace;/* point at the begining of the new free space. Just after the end of the allocation.*/
        					
					/*we have to move the begining of the allocation to p_uaSizeMalloc + lDiffSize*/
					memmove (p_uaBeforeFreeSpace, p_uaSizeMalloc, (*p_uaSizeMalloc - (unsigned long)lDiffSize - C_ucMallocFooterSize)<< C_uwShiftAllocSize );
					*(p_uaTmp+1) = (unitAlloc) p_uaAfterFreeSpace; /*restore the real 'next field'*/
					*p_uaTmp = (unitAlloc) (((unitAlloc *)p_vMemBlock) - p_uaBeforeFreeSpace - C_ucMallocHeaderSize);/* restore the 'size' field for my free space.*/
 
 
					/* general case:*/
					/* |        Free            | ... |      allocation     ||        Free      | (...) |   Free   |*/
					/* ^-- p_uaBeforeBeforeFree       ^-- p_uaBeforeFree     ^--p_uaTmp                 ^-- p_uaAfterFree*/
                
					p_vMemBlock = (void *) (p_uaBeforeFreeSpace + C_ucMallocHeaderSize);/* the new return value*/
					p_uaSizeMalloc = p_uaBeforeFreeSpace;
 
					/*Management of the free list*/
					if (p_uaBeforeBeforeFreeSpace == p_uaBeforeFreeSpace){/*first elt of the free list*/
							p_stMyBlockInfo->p_cFirstFree = (char *) p_uaTmp;
					}
					else {/* commom case*/
							*(p_uaBeforeBeforeFreeSpace +1) = (unitAlloc) p_uaTmp;/*the 'next' field of my free before the free space used have contain the value of the begining of my new free space*/
					}
                
					/* test if we have to join my new space free with the after free space.*/
					if ((p_uaTmp + *p_uaTmp)== p_uaAfterFreeSpace){/*My new free is adjacent to the free space after. Then we have to join both.*/
							/* general case:*/
							/* |        Free            | ... |      allocation     ||        Free      ||   Free   | (...) |Free|*/
							/* ^-- p_uaBeforeBeforeFree       ^-- p_uaBeforeFree     ^--p_uaTmp          ^-- p_uaAfterFree*/
 
							*p_uaTmp = *p_uaTmp + *p_uaAfterFreeSpace;/*lint !e613: Possible use of null pointer (p_uaAfterFreeSpace)*/ /*the 'size' field of my new free space must be added with the content of 'size' field of my free space joined with*/
							*(p_uaTmp+1) = *(p_uaAfterFreeSpace + 1);/*lint !e613: Possible use of null pointer (p_uaAfterFreeSpace)*/ /* the 'next' field of my new free space is equal to the 'next' field of my old free space after*/
							/* general case:*/
							/* |        Free            | ... |      allocation     ||        new joined free       | (...) |Free|*/
							/* ^-- p_uaBeforeBeforeFree       ^-- p_uaBeforeFree     ^--p_uaTmp                            */
#ifdef __DEBUG_MALLOC_MODE__            
							p_stMyBlockInfo->uwNbFree --; /*there is one less free*/
#endif /*__DEBUG_MALLOC_MODE__            */
 
					}
 
					/* store malloc Information:*/
					/*--------------------------*/
					*p_uaSizeMalloc = (unitAlloc)ulSize;
					p_vMemBlock = (void *)(p_uaSizeMalloc + C_ucMallocHeaderSize);
 
#ifdef __DEBUG_MALLOC_MODE__            
					*(p_uaSizeMalloc + ulSize - C_ucMallocFooterSize) = C_uaEndKey;
					p_stMyBlockInfo->ulNbTotalRealloc++;
					p_stMyMallocInfo = p_stMyBlockInfo->d_stMallocInfo + ulMyNbMalloc;
					p_stMyMallocInfo->p_cBeginMalloc = (char *) p_vMemBlock;
					p_stMyMallocInfo->p_cEndMalloc = ((char *) (p_uaSizeMalloc + ulSize - C_ucMallocFooterSize)) - 1;
#endif /* __DEBUG_MALLOC_MODE__*/
					if ((char*)(p_uaSizeMalloc + *p_uaSizeMalloc)-1>=p_stMyBlockInfo->p_cMaxMem){
							/* Managemement of the mem max information i order to be able to compute an estination of the optimzed version*/
							p_stMyBlockInfo->p_cMaxMem=(char*)(p_uaSizeMalloc + *p_uaSizeMalloc)-1;
 
#ifdef __DEBUG_MALLOC_MODE__
							p_stMyBlockInfo->ulCountMallocBeforeMaxMem = p_stMyBlockInfo->ulNbMalloc;
							p_stMyBlockInfo->ulCountFreeBeforeMaxMem = p_stMyBlockInfo->uwNbFree;
#endif /* __DEBUG_MALLOC_MODE__*/
					}
#ifdef __DEBUG_MALLOC_MODE__
					/* clean the area of the new free. we use the variable p_uaBeforeSpaceFree for scan the memory & p_uaAfterfreespace for the end of the free area.*/
					for (   p_uaBeforeFreeSpace = p_uaTmp + C_ucFreeHeaderSize,
											p_uaAfterFreeSpace = p_uaBeforeFreeSpace + *p_uaTmp - C_ucFreeHeaderSize;
									p_uaBeforeFreeSpace < p_uaAfterFreeSpace;
									p_uaBeforeFreeSpace++
							){
							*p_uaBeforeFreeSpace = C_uaCleanKey;
					}
#endif /* __DEBUG_MALLOC_MODE__*/
 
	/* not necessary
#ifdef __DEBUG_MALLOC_MODE__
					// counte the real number of free
					p_uaTmp = (unitAlloc*)p_stMyBlockInfo->p_cFirstFree;
					for (uwI=0; *(p_uaTmp+1) != (unitAlloc)0; uwI++, p_uaTmp = (unitAlloc*) *(p_uaTmp+1));
					p_stMyBlockInfo->uwNbFree = uwI;
#endif  __DEBUG_MALLOC_MODE__
	*/
 
					Mmg_MLeaveCriticalSection();
					return (p_vMemBlock);
			}/* end of "we want to 'move up' just before the malloc with the same size because there is a free space just before my malloc "*/
 
 
			else if (lDiffSize > 0){
					/* we want to reduce the malloc */
					/*            ------*/
					if ((p_uaBeforeFreeSpace != (unitAlloc *) 0) && (p_uaBeforeFreeSpace + *p_uaBeforeFreeSpace == p_uaSizeMalloc)){
							/* Yes there is a free space just before my malloc */
							/*                                ------*/
							/*==> We will move the malloc to the beginig of the free, in order to have the new free space after.*/
 
							/* general case:*/
							/* |        Free            | ... |        Free      ||      allocation     | (...) |   Free   |*/
							/* ^-- p_uaBeforeBeforeFree       ^-- p_uaBeforeFree  ^-- p_vMemBlock               ^-- p_uaAfterFree*/
 
							/* definition of my new free space after : p_uaTmp*/
							/*                                         -------*/
							p_uaTmp = p_uaSizeMalloc + *p_uaSizeMalloc - lDiffSize - *p_uaBeforeFreeSpace;/* point at the begining of the new free space. Just after the end of the allocation.*/
 
							/*we have to move the begining of the allocation to p_uaSizeMalloc + lDiffSize*/
							memmove (p_uaBeforeFreeSpace, p_uaSizeMalloc, (*p_uaSizeMalloc - (unsigned long)lDiffSize - C_ucMallocFooterSize)<< C_uwShiftAllocSize );
							*(p_uaTmp+1) = (unitAlloc) p_uaAfterFreeSpace;
							*p_uaTmp = (unitAlloc)(((unitAlloc *)p_vMemBlock) - p_uaBeforeFreeSpace - C_ucMallocHeaderSize + lDiffSize);/* restore the 'size' field for my free space.*/
 
 
							/* general case:*/
							/* |        Free            | ... |    allocation   ||        Free      | (...) |   Free   |*/
							/* ^-- p_uaBeforeBeforeFree       ^-- p_uaBeforeFree ^--p_uaTmp                 ^-- p_uaAfterFree*/
 
							p_vMemBlock = (void *) (p_uaBeforeFreeSpace + C_ucMallocHeaderSize);/* the new return value*/
							p_uaSizeMalloc = p_uaBeforeFreeSpace;
 
							/*Management of the free list*/
							if (p_uaBeforeBeforeFreeSpace == p_uaBeforeFreeSpace){/*first elt of the free list*/
									p_stMyBlockInfo->p_cFirstFree = (char *) p_uaTmp;
							}
							else {/* commom case*/
									*(p_uaBeforeBeforeFreeSpace +1) = (unitAlloc) p_uaTmp;/*the 'next' field of my free before the free space used have contain the value of the begining of my new free space*/
							}
                        
							/* test if we have to join my new space free with the after free space.*/
							if ((p_uaTmp + *p_uaTmp)== p_uaAfterFreeSpace){/*My new free is adjacent to the free space after. Then we have to join both.*/
									/* general case:*/
									/* |        Free            | ... |    allocation   ||        Free      ||       Free      | (...) |Free|*/
									/* ^-- p_uaBeforeBeforeFree       ^-- p_uaBeforeFree ^--p_uaTmp          ^-- p_uaAfterFree*/
 
									*p_uaTmp = *p_uaTmp + *p_uaAfterFreeSpace;/*lint !e613: Possible use of null pointer*/ /*the 'size' field of my new free space must be added with the content of 'size' field of my free space joined with*/
									*(p_uaTmp+1) = *(p_uaAfterFreeSpace + 1);/*lint !e613: Possible use of null pointer*/ /* the 'next' field of my new free space is equal to the 'next' field of my old free space after*/
 
									/* general case:*/
									/* |        Free            | ... |    allocation   ||             New joined free         | (...) |Free|*/
									/* ^-- p_uaBeforeBeforeFree       ^-- p_uaBeforeFree ^--p_uaTmp                                   */
#ifdef __DEBUG_MALLOC_MODE__            
									p_stMyBlockInfo->uwNbFree --; /*there is one less free*/
#endif /*__DEBUG_MALLOC_MODE__            */
 
							}
					}/*there is a free space just before my malloc */
 
 
					else if (p_uaSizeMalloc + *p_uaSizeMalloc == p_uaAfterFreeSpace ){
							/* Yes there is a free space just after my malloc ==> then we joined those 2 free spaces*/
							/*                                -----*/
 
							/* general case:*/
							/* |        Free            | ... |        Free      | ... |      allocation     ||   Free   | ... |Free|*/
							/* ^-- p_uaBeforeBeforeFree       ^-- p_uaBeforeFree       ^-- p_vMemBlock        ^-- p_uaAfterFree*/
 
							/* definition of my new free space : p_uaTmp*/
							/*                                   -------*/
							p_uaTmp = p_uaSizeMalloc + *p_uaSizeMalloc - lDiffSize;/* point at the begining of the new free space*/
 
							/* general case:*/
							/* |        Free            | ... |        Free      | ... |   allocation  ||   Free   | ... |Free|*/
							/* ^-- p_uaBeforeBeforeFree       ^-- p_uaBeforeFree       ^-- p_vMemBlock  ^-- p_uaTmp*/
 
							*p_uaTmp = (unitAlloc)lDiffSize + *p_uaAfterFreeSpace;/*lint !e613: Possible use of null pointer*/ /* like my new space is joined to the free just after we have to increase the 'size' field with the space joined*/
 
							*(p_uaTmp+1) = *(p_uaAfterFreeSpace+1);/*lint !e613: Possible use of null pointer*/ /* the 'next' field of my new space must have the address contained in the next field of my old first free space*/
 
							if (p_uaAfterFreeSpace == p_uaBeforeFreeSpace ){/* this is the first free space*/
									p_stMyBlockInfo->p_cFirstFree = (char *) p_uaTmp;/*The begining of the new free space.*/
							}
							else {/* common case this is not the fisrt free space*/
									*(p_uaBeforeFreeSpace + 1)  = (unitAlloc) p_uaTmp;/*lint !e613: Possible use of null pointer*/ /* the 'next' field of my free space just before my point at my new free space*/
							}
					}/*there is a free space just after my malloc*/
 
					else if (lDiffSize >= (long)C_ucFreeHeaderSize){
							/* there isn't a free space just after or before my malloc and we can manage the free space poduced in the list of frees*/
							/* we will generate a new free space*/
 
							/* general case:*/
							/* |        Free            | ... |        Free      | (...) |         allocation        | (...) |   Free   |*/
							/* ^-- p_uaBeforeBeforeFree       ^-- p_uaBeforeFree         ^-- p_vMemBlock                     ^-- p_uaAfterFree*/
 
							/* definition of my new free space : p_uaTmp*/
							/*                                   -------*/
							p_uaTmp = p_uaSizeMalloc + *p_uaSizeMalloc - lDiffSize;/* point at the begining of the new free space*/
 
							/* general case:*/
							/* |        Free            | ... |        Free      | (...) |   allocation  || New Free | (...) |   Free   |*/
							/* ^-- p_uaBeforeBeforeFree       ^-- p_uaBeforeFree         ^-- p_vMemBlock  ^--P_uaTmp         ^-- p_uaAfterFree*/
#ifdef __DEBUG_MALLOC_MODE__            
							p_stMyBlockInfo->uwNbFree ++; /*there is one more free*/
#endif /*__DEBUG_MALLOC_MODE__            */
 
							*p_uaTmp = (unitAlloc)lDiffSize;/* the 'size' field of my new free space*/
							*(p_uaTmp+1) = (unitAlloc) p_uaAfterFreeSpace; /*The 'next' field of my new free space will contain the adresse of my old first elt free list*/
 
							if (p_uaBeforeFreeSpace == p_uaAfterFreeSpace){/* My new free space is the first elt of the free list.*/
									p_stMyBlockInfo->p_cFirstFree = (char *) p_uaTmp;/*The begining of the new free space.*/
							}
							else {/* commom case: My new free space will be between  p_uaBeforeFreeSpace & p_uaAfterFreeSpace*/
									*(p_uaBeforeFreeSpace + 1)  = (unitAlloc) p_uaTmp;/*lint !e613: Possible use of null pointer*/ /* the 'next' field of my free space just before my point at my new free space*/
							}
					}
					else {
						Mmg_MLeaveCriticalSection();
						return (p_vMemBlock);/* no change because, the lDiffSize is to little to be managed*/
					}
 
					/* store malloc Information:*/
					/*--------------------------*/
					*p_uaSizeMalloc = (unitAlloc)ulSize;
					p_vMemBlock = (void *)(p_uaSizeMalloc + C_ucMallocHeaderSize);
 
#ifdef __DEBUG_MALLOC_MODE__            
					*(p_uaSizeMalloc + ulSize - C_ucMallocFooterSize) = C_uaEndKey;
					p_stMyBlockInfo->ulNbTotalRealloc++;
					p_stMyMallocInfo = p_stMyBlockInfo->d_stMallocInfo + ulMyNbMalloc;
					p_stMyMallocInfo->p_cBeginMalloc = (char *) p_vMemBlock;
					p_stMyMallocInfo->p_cEndMalloc = ((char *) (p_uaSizeMalloc + ulSize - C_ucMallocFooterSize)) -1;
#endif /* __DEBUG_MALLOC_MODE__*/
 
					if ((char*)(p_uaSizeMalloc + *p_uaSizeMalloc)-1>=p_stMyBlockInfo->p_cMaxMem){
							/* Managemement of the mem max information i order to be able to compute an estination of the optimzed version*/
							p_stMyBlockInfo->p_cMaxMem=(char*)(p_uaSizeMalloc + *p_uaSizeMalloc)-1;
 
#ifdef __DEBUG_MALLOC_MODE__
							p_stMyBlockInfo->ulCountMallocBeforeMaxMem = p_stMyBlockInfo->ulNbMalloc;
							p_stMyBlockInfo->ulCountFreeBeforeMaxMem = p_stMyBlockInfo->uwNbFree;
#endif /* __DEBUG_MALLOC_MODE__*/
					}
 
#ifdef __DEBUG_MALLOC_MODE__
					/* clean the area of the new free. we use the variable p_uaBeforeSpaceFree for scan the memory & p_uaAfterfreespace for the end of the free area.*/
					for (   p_uaBeforeFreeSpace = p_uaTmp + C_ucFreeHeaderSize,
						p_uaAfterFreeSpace = p_uaBeforeFreeSpace + *p_uaTmp - C_ucFreeHeaderSize;/*lint !e644: p_uaTmp may not have been initialized*/
									p_uaBeforeFreeSpace < p_uaAfterFreeSpace;
									p_uaBeforeFreeSpace++
							){
							*p_uaBeforeFreeSpace = C_uaCleanKey;
					}
#endif /* __DEBUG_MALLOC_MODE__*/
 
	/*not necessary                                
#ifdef __DEBUG_MALLOC_MODE__
					// count the real number of free
					p_uaTmp = (unitAlloc*)p_stMyBlockInfo->p_cFirstFree;
					for (uwI=0; *(p_uaTmp+1) != (unitAlloc)0; uwI++, p_uaTmp = (unitAlloc*) *(p_uaTmp+1));
					p_stMyBlockInfo->uwNbFree = uwI;
#endif __DEBUG_MALLOC_MODE__
	*/
 
					Mmg_MLeaveCriticalSection();
					return (p_vMemBlock);
			}/* end of the if we reduce the allocation*/
 
			else if (lDiffSize < 0){
					/* we want to increase the allocation*/
					/*            --------*/
 
					lDiffSize = -lDiffSize;/* in order to have a posive value meaning the increasing requested*/
                
					if ( ( (p_uaBeforeFreeSpace +(*p_uaBeforeFreeSpace)) == p_uaSizeMalloc ) && 
							 ((uaBeforeFreeSize = *p_uaBeforeFreeSpace) >= (unitAlloc)lDiffSize) )/*lint !e613: Possible use of null pointer (p_uaBeforeFreeSpace)*/
					{
							/*         ^------- : size of the free space just before*/
 
							/* we have enought space just before the allocation, with the free space begining at p_uaBeforeFreeSpace.*/
							/*         -------------          ------*/
							/*==> We will move the malloc to the beginig of the free, in order to have the new free space after.*/
 
#ifdef __DEBUG_MALLOC_MODE__
#ifdef __ADD_PLACE_FOR_DEBUG_INFORMATION__
#ifdef __WARNING3_ERR_MMG__
						/* test of overflow on a block*/
						if (    ((char *) ( p_uaBeforeFreeSpace +ulSize
							- ( p_stMyBlockInfo->ulNbMalloc) * C_ucDebugInformationLoss )/* memMax - the place for debug information of all the allocation.*/
								)-1
							>
								(p_stMyBlockInfo->p_cEndBlock - (p_stMyBlockInfo->ulMaxNbStaticMalloc*(C_ucDebugInformationLoss<<C_uwShiftAllocSize))) /* the end of the memory without the memory added for the debug information*/
							)
						{
#ifdef __ERROR_STRINGS__
							unitAlloc *p_uaTheLastFreeSpace=p_uaBeforeFreeSpace;
 
							Mmg_fn_v_PrintInfoMalloc("\n~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~\n");
							Mmg_fn_v_PrintInfoMalloc("State of the block before the reallocate problem:\n");
							sprintf (szErrTxt, "in the request 'fn_p_vStaRealloc (0X%X, %d)'\n", p_vMemBlock, ulSize);
							Mmg_fn_v_PrintInfoMalloc(szErrTxt);
							Mmg_fn_v_PrintInfoMalloc("~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~\n");
							Mmg_M_PrintBlockStatisticWithModuleId(stCurrentModeInfo.ucModuleId, stCurrentModeInfo.ucMode);
							Mmg_fn_v_PrintInfoMalloc("~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~\n\n");
 
							while ((unitAlloc *)*(p_uaTheLastFreeSpace+1) != NULL)
								p_uaTheLastFreeSpace = (unitAlloc *) *(p_uaTheLastFreeSpace+1);
 
							sprintf (szErrTxt, "You have called reallocate for add %db,\n but the maximum allocation allowed is %db.\nSee the %s file in witch the state (before the request of allocation)of the block is printed",
								(lDiffSize)<<C_uwShiftAllocSize,
								((*p_uaTheLastFreeSpace)- ((p_stMyBlockInfo->ulMaxNbStaticMalloc*C_ucDebugInformationLoss)- ( p_stMyBlockInfo->ulNbMalloc * C_ucDebugInformationLoss)) + uaBeforeFreeSize) << C_uwShiftAllocSize,
								C_szMmgLogFileName);
							Mmg_M_UpdateLastErrorWithCurrentModeInfo (E_uwMmgPbBLockFull, szErrTxt, ucChannel);
#else /*__ERROR_STRINGS__*/
							Mmg_M_UpdateLastErrorWithCurrentModeInfo (E_uwMmgPbBLockFull, NULL, ucChannel);
#endif /*__ERROR_STRINGS__*/
							Mmg_MLeaveCriticalSection();
							return (NULL);
						}
#endif/*__WARNING3_ERR_MMG__*/
#endif /*__ADD_PLACE_FOR_DEBUG_INFORMATION__*/
#endif /*__DEBUG_MALLOC_MODE__*/
 
 
 
							*p_uaBeforeFreeSpace -= ((unitAlloc) lDiffSize);/*lint !e613: Possible use of null pointer (p_uaBeforeFreeSpace)*/ /* the content of the 'size' field is equal of the remain (not used for the allocation)*/
 
							if (*p_uaBeforeFreeSpace < (unitAlloc) C_ucFreeHeaderSize) /*lint !e613: Possible use of null pointer (p_uaBeforeFreeSpace)*/
							{/*The remain of the free place is not enougth big to be managned*/
									/* we affect all the place to the malloc. The 'old' free place if empty (everything is used for the malloc)*/
									ulSize += (*p_uaBeforeFreeSpace);/*lint !e613: Possible use of null pointer (p_uaBeforeFreeSpace)*/
									lDiffSize = lDiffSize + (long)(*p_uaBeforeFreeSpace);/*lint !e613: Possible use of null pointer (p_uaBeforeFreeSpace)*/
 
									/* management of the first free*/
									if (p_uaBeforeFreeSpace == p_uaBeforeBeforeFreeSpace){/* this is the first elt of the list*/
											p_stMyBlockInfo->p_cFirstFree = (char *) p_uaAfterFreeSpace;
									}
									else {/*commom case*/
											/* the free place before will become empty (everything is used for the malloc)*/
											/* Management of the Free list : the 'next' field of the free place before the free place used, will be affect to the contents of the 'next' field of the free place used */
											*(p_uaBeforeBeforeFreeSpace + 1) = (unitAlloc) p_uaAfterFreeSpace;/* !! a tester*/
									}
 
									/* general case:*/
									/*      |           Free           | ... |         Free         ||    allocation    | (...) |Free|*/
									/*      ^--p_uaBeforeBeforeFreespace     ^---p_uaBeforeFreeSpace ^--p_uaSizeMalloc                  ^--p_uaAfterFreeSpace                               */
 
									/*we have to move the begining of the allocation to p_uaBeforeFreeSpace*/
									memmove (p_uaBeforeFreeSpace, p_uaSizeMalloc, (*p_uaSizeMalloc - C_ucMallocFooterSize)<< C_uwShiftAllocSize );/*lint !e668: Possibly passing a null pointer to function*/
 
									/* general case:*/
									/*      |           Free           | ... |   allocation    |++++++++++++++++++++++++| (...) |Free|*/
									/*      ^--p_uaBeforeBeforeFreespace     ^---p_uaBeforeFreeSpace                                ^--p_uaAfterFreeSpace*/
									/* with ++++: meanimg the new space added for the allocation*/
#ifdef __DEBUG_MALLOC_MODE__            
									p_stMyBlockInfo->uwNbFree --; /*there is one less free*/
#endif /*__DEBUG_MALLOC_MODE__            */
 
 
									/* store malloc Information (first part)*/
									/*----------------------------------------*/
									p_uaSizeMalloc = p_uaBeforeFreeSpace;
									p_vMemBlock = (void *) (p_uaBeforeFreeSpace + C_ucMallocHeaderSize);/*lint !e613: Possible use of null pointer (p_uaBeforeFreeSpace)*/ /* the new adresse of the allocation                                                                        */
 
#ifdef __DEBUG_MALLOC_MODE__            
									/* clean the area of the new allocation. we use the variable p_uaBeforeSpaceFree for scan the memory & p_uaAfterfreespace for the end of the free area.*/
									for (   p_uaBeforeFreeSpace = p_uaBeforeFreeSpace + *p_uaBeforeFreeSpace - C_ucMallocFooterSize,
													p_uaAfterFreeSpace = p_uaBeforeFreeSpace + lDiffSize;/*lint !e613: Possible use of null pointer (p_uaBeforeFreeSpace)*/
													p_uaBeforeFreeSpace < p_uaAfterFreeSpace;
													p_uaBeforeFreeSpace++
											)
									{
											*p_uaBeforeFreeSpace = C_uaCleanKey;
									}
#endif /* __DEBUG_MALLOC_MODE__*/
 
							}
							else {/* management of the remained place after the new alloction.*/
 
									/* general case:*/
									/*      |           Free           | ... |         Free         ||    allocation    | (...) |Free|*/
									/*      ^--p_uaBeforeBeforeFreespace     ^---p_uaBeforeFreeSpace ^--p_uaSizeMalloc          ^--p_uaAfterFreeSpace                               */
 
									/* definition of my new free space after allocation : p_uaTmp*/
									/*                                                    -------*/
									p_uaTmp = p_uaBeforeFreeSpace + *p_uaSizeMalloc + lDiffSize;/*lint !e613: Possible use of null pointer (p_uaBeforeFreeSpace)*/ /* point at the begining of the new free space*/
 
									/*we have to move the begining of the allocation to p_uaBeforeFreeSpace*/
									memmove (p_uaBeforeFreeSpace, p_uaSizeMalloc, (*p_uaSizeMalloc - C_ucMallocFooterSize)<< C_uwShiftAllocSize );/*lint !e668: Possibly passing a null pointer to function memmove*/
 
									/* general case:*/
									/*      |           Free           | ... |   allocation     ++++++++||     Free     | (...) |Free|*/
									/*      ^--p_uaBeforeBeforeFreespace     ^---p_uaBeforeFreeSpace     ^--p_uaTmp             ^--p_uaAfterFreeSpace*/
									/* with ++++: meanimg the new space added for the allocation*/
 
									/* set information of my new free space*/
									*p_uaTmp = (unitAlloc) (uaBeforeFreeSize - (unsigned long)lDiffSize);/* set the 'size' field of the new free space = [size of my old free space just before] - [value of my increaseing allocation].*/
									*(p_uaTmp +1) = (unitAlloc) p_uaAfterFreeSpace;/* set the 'next' field of my new free space*/
 
									/*Management of the free list*/
									if (p_uaBeforeBeforeFreeSpace == p_uaBeforeFreeSpace){/*first elt of the free list*/
											p_stMyBlockInfo->p_cFirstFree = (char *) p_uaTmp;
									}
									else {/* commom case*/
											*(p_uaBeforeBeforeFreeSpace +1) = (unitAlloc) p_uaTmp;/*the 'next' field of my free before the free space used have contain the value of the begining of my new free space*/
									}
                                
									/* test if we have to join my new space free with the after free space.*/
									if ((p_uaTmp + *p_uaTmp)== p_uaAfterFreeSpace){/*My new free is adjacent to the free space after. Then we have to join both.*/
										/* general case:*/
										/*      |           Free           | ... |   allocation     ++++++++||     Free     ||Free|*/
										/*      ^--p_uaBeforeBeforeFreespace     ^---p_uaBeforeFreeSpace     ^--p_uaTmp      ^--p_uaAfterFreeSpace*/
#ifdef __DEBUG_MALLOC_MODE__            
										p_stMyBlockInfo->uwNbFree --; /*there is one less free*/
#endif /*__DEBUG_MALLOC_MODE__            */
 
										*p_uaTmp = *p_uaTmp + *p_uaAfterFreeSpace;/*lint !e613: Possible use of null pointer (p_uaAfterFreeSpace)*/ /*the 'size' field of my new free space must be added with the content of 'size' field of my free space joined with*/
										*(p_uaTmp+1) = *(p_uaAfterFreeSpace + 1);/*lint !e613: Possible use of null pointer (p_uaBeforeFreeSpace))*/ /* the 'next' field of my new free space is equal to the 'next' field of my old free space after*/
									}
 
									/* store malloc Information (first part)*/
									/*----------------------------------------*/
									p_uaSizeMalloc = p_uaBeforeFreeSpace;
									p_vMemBlock = (void *) (p_uaBeforeFreeSpace + C_ucMallocHeaderSize);/*lint !e613: Possible use of null pointer (p_uaBeforeFreeSpace)*/ /* the new adresse of the allocation                                                                        */
 
#ifdef __DEBUG_MALLOC_MODE__            
									/* clean the area of the new allocation. we use the variable p_uaBeforeSpaceFree for scan the memory & p_uaAfterfreespace for the end of the free area.*/
									for (   p_uaBeforeFreeSpace = p_uaBeforeFreeSpace + *p_uaBeforeFreeSpace - C_ucMallocFooterSize,
															p_uaAfterFreeSpace = p_uaBeforeFreeSpace + lDiffSize;/*lint !e613: Possible use of null pointer (p_uaBeforeFreeSpace)*/
													p_uaBeforeFreeSpace < p_uaAfterFreeSpace;
													p_uaBeforeFreeSpace++
											){
											*p_uaBeforeFreeSpace = C_uaCleanKey;
									}
 
									/* clean the area of the new free. we use the variable p_uaBeforeSpaceFree for scan the memory & p_uaAfterfreespace for the end of the free area.*/
									for (   p_uaBeforeFreeSpace = p_uaTmp + C_ucFreeHeaderSize,
															p_uaAfterFreeSpace = p_uaBeforeFreeSpace + *p_uaTmp - C_ucFreeHeaderSize;
													p_uaBeforeFreeSpace < p_uaAfterFreeSpace;
													p_uaBeforeFreeSpace++
											){
											*p_uaBeforeFreeSpace = C_uaCleanKey;
									}
#endif /* __DEBUG_MALLOC_MODE__*/
 
							}
 
							/* store malloc Information (continued)*/
							/*---------------------------------------*/
							*p_uaSizeMalloc = (unitAlloc)ulSize;/*lint !e613: Possible use of null pointer (p_uaSizeMalloc)*/
 
#ifdef __DEBUG_MALLOC_MODE__            
							*(p_uaSizeMalloc + ulSize -1) = C_uaEndKey;/*lint !e613: Possible use of null pointer (p_uaSizeMalloc)*/
							p_stMyBlockInfo->ulNbTotalRealloc++;
							p_stMyMallocInfo = p_stMyBlockInfo->d_stMallocInfo + ulMyNbMalloc;
							p_stMyMallocInfo->p_cBeginMalloc = (char *) p_vMemBlock;
							p_stMyMallocInfo->p_cEndMalloc = ((char *) (p_uaSizeMalloc + ulSize - C_ucMallocFooterSize)) - 1;/*lint !e613: Possible use of null pointer (p_uaSizeMalloc)*/
#endif /* __DEBUG_MALLOC_MODE__*/
							if ((char*)(p_uaSizeMalloc + *p_uaSizeMalloc)-1>=p_stMyBlockInfo->p_cMaxMem)/*lint !e613: Possible use of null pointer (p_uaSizeMalloc)*/
							{
									/* Managemement of the mem max information i order to be able to compute an estination of the optimzed version*/
									p_stMyBlockInfo->p_cMaxMem=(char*)(p_uaSizeMalloc + *p_uaSizeMalloc)-1;/*lint !e613: Possible use of null pointer (p_uaSizeMalloc)*/
 
#ifdef __DEBUG_MALLOC_MODE__
									p_stMyBlockInfo->ulCountMallocBeforeMaxMem = p_stMyBlockInfo->ulNbMalloc;
									p_stMyBlockInfo->ulCountFreeBeforeMaxMem = p_stMyBlockInfo->uwNbFree;
#endif /* __DEBUG_MALLOC_MODE__*/
							}
 
	/*not necessary
#ifdef __DEBUG_MALLOC_MODE__
					// count the real number of free
					p_uaTmp = (unitAlloc*)p_stMyBlockInfo->p_cFirstFree;
					for (uwI=0; *(p_uaTmp+1) != (unitAlloc)0; uwI++, p_uaTmp = (unitAlloc*) *(p_uaTmp+1));
					p_stMyBlockInfo->uwNbFree = uwI;
#endif  __DEBUG_MALLOC_MODE__
	*/
							Mmg_MLeaveCriticalSection();
							return (p_vMemBlock);
					}/* end of Yes, we have enought space before the allocation.*/
 
 
				else if ( ( p_uaSizeMalloc + *p_uaSizeMalloc == p_uaAfterFreeSpace) && 
							 ((p_uaBeforeFreeSpace +(*p_uaBeforeFreeSpace)) == p_uaSizeMalloc )&&
							 ((uaBeforeFreeSize + (uaAfterFreeSize = *p_uaAfterFreeSpace)) >= (unitAlloc) lDiffSize) )/*lint !e613: Possible use of null pointer (p_uaBeforeFreeSpace) & (p_uaAfterFreeSpace)*/
				{
					/*                                                     ^------- : size of the free space just after*/
 
					/* We have not eougth space with the space just before.*/
					/* But The space just before + just after is enougth big*/
					/*               ------------------------*/
 
#ifdef __DEBUG_MALLOC_MODE__
#ifdef __ADD_PLACE_FOR_DEBUG_INFORMATION__
#ifdef __WARNING3_ERR_MMG__
					/* test of overflow on a block*/
					if (    ((char *) ( p_uaBeforeFreeSpace +ulSize
						- ( p_stMyBlockInfo->ulNbMalloc) * C_ucDebugInformationLoss )/* memMax - the place for debug information of all the allocation.*/
							)-1
						>
							(p_stMyBlockInfo->p_cEndBlock - (p_stMyBlockInfo->ulMaxNbStaticMalloc*(C_ucDebugInformationLoss<<C_uwShiftAllocSize))) /* the end of the memory without the memory added for the debug information*/
						)
					{
#ifdef __ERROR_STRINGS__
						unitAlloc *p_uaTheLastFreeSpace=p_uaBeforeFreeSpace;
 
						Mmg_fn_v_PrintInfoMalloc("\n~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~\n");
						Mmg_fn_v_PrintInfoMalloc("State of the block before the reallocate problem:\n");
						sprintf (szErrTxt, "in the request 'fn_p_vStaRealloc (0X%X, %d)'\n", p_vMemBlock, ulSize);
						Mmg_fn_v_PrintInfoMalloc(szErrTxt);
						Mmg_fn_v_PrintInfoMalloc("~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~\n");
						Mmg_M_PrintBlockStatisticWithModuleId(stCurrentModeInfo.ucModuleId, stCurrentModeInfo.ucMode);
						Mmg_fn_v_PrintInfoMalloc("~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~\n\n");
 
						while ((unitAlloc *)*(p_uaTheLastFreeSpace+1) != NULL)
							p_uaTheLastFreeSpace = (unitAlloc *) *(p_uaTheLastFreeSpace+1);
 
						sprintf (szErrTxt, "You have called reallocate for add %db,\n but the maximum allocation allowed is %db.\nSee the %s file in witch the state (before the request of allocation)of the block is printed",
							(lDiffSize)<<C_uwShiftAllocSize,
							((*p_uaTheLastFreeSpace)- ((p_stMyBlockInfo->ulMaxNbStaticMalloc*C_ucDebugInformationLoss)- ( p_stMyBlockInfo->ulNbMalloc * C_ucDebugInformationLoss)) + uaBeforeFreeSize) << C_uwShiftAllocSize,
							C_szMmgLogFileName);
						Mmg_M_UpdateLastErrorWithCurrentModeInfo (E_uwMmgPbBLockFull, szErrTxt, ucChannel);
#else /*__ERROR_STRINGS__*/
						Mmg_M_UpdateLastErrorWithCurrentModeInfo (E_uwMmgPbBLockFull, NULL, ucChannel);
#endif /*__ERROR_STRINGS__*/
						Mmg_MLeaveCriticalSection();
						return (NULL);
					}
#endif/*__WARNING3_ERR_MMG__*/
#endif /*__ADD_PLACE_FOR_DEBUG_INFORMATION__*/
#endif /*__DEBUG_MALLOC_MODE__*/
 
					
 
					/* in order to save the adresse of the space free just after the free just after my allocation, the 'next' field of the free before my allocation will containhis adresse*/
					p_uaAfterAfterFreeSpace = (unitAlloc *) (*(p_uaAfterFreeSpace+1));/*lint !e613: Possible use of null pointer (p_uaAfterFreeSpace)*/
 
					/* general case:*/
					/*      |          Free          |...|         Free         ||   allocation   ||       Free         | ... |Free|*/
					/*      ^--p_uaBeforeBeforeFreespace ^---p_uaBeforeFreeSpace ^--p_uaSizeMalloc ^--p_uaAfterFreeSpace      ^--P_auAfterAfterSpace*/
 
 
					*p_uaBeforeFreeSpace = (unitAlloc) (uaBeforeFreeSize + uaAfterFreeSize - (unitAlloc)lDiffSize);/*lint !e613: Possible use of null pointer (p_uaBeforeFreeSpace)*/ /* the content of the 'size' field is equal of the remain (not used for the allocation)*/
 
					if (*p_uaBeforeFreeSpace < (unitAlloc) C_ucFreeHeaderSize) /*lint !e613: Possible use of null pointer (p_uaBeforeFreeSpace)*/
					{/*The remain of the free place is not enougth big to be managned*/
 
						/* we affect all the place to the malloc. The 'old' free place if empty (everything is used for the malloc)*/
						ulSize += (*p_uaBeforeFreeSpace);/*lint !e613: Possible use of null pointer (p_uaBeforeFreeSpace)*/
						lDiffSize = lDiffSize + (long)(*p_uaBeforeFreeSpace);/*lint !e613: Possible use of null pointer (p_uaBeforeFreeSpace)*/
 
						/* management of the first free*/
						if (p_uaBeforeBeforeFreeSpace == p_uaBeforeFreeSpace){/* this is the first elt of the list*/
								p_stMyBlockInfo->p_cFirstFree = (char *) *(p_uaAfterFreeSpace+1);/*lint !e613: Possible use of null pointer (p_uaAfterFreeSpace)*/
						}
						else {/*commom case*/
								/* the free place before will become empty (everything is used for the malloc)*/
								/* Management of the Free list : the 'next' field of the free place before the free place used, will be affect to the contents of the 'next' field of the free place used */
								*(p_uaBeforeBeforeFreeSpace + 1) = *(p_uaAfterFreeSpace+1);/*lint !e613: Possible use of null pointer (p_uaAfterFreeSpace)*/
						}
 
						/* general case:*/
						/*      |          Free          |...|         Free         ||   allocation   ||       Free         | ... |Free|*/
						/*      ^--p_uaBeforeBeforeFreespace ^---p_uaBeforeFreeSpace ^--p_uaSizeMalloc ^--p_uaAfterFreeSpace      ^--P_auAfterAfterSpace*/
 
						/*we have to move the begining of the allocation to p_uaBeforeFreeSpace*/
						memmove (p_uaBeforeFreeSpace, p_uaSizeMalloc, (*p_uaSizeMalloc - C_ucMallocFooterSize)<< C_uwShiftAllocSize );/*lint !e668: Possibly passing a null pointer to function memmove*/
 
						/* general case:*/
						/*      |          Free          |...|   allocation   |+++++++++++++++++++++++++++++++++++++++++++++| ... |Free|*/
						/*      ^--p_uaBeforeBeforeFreespace ^---p_uaBeforeFreeSpace                                              ^--P_auAfterAfterSpace*/
						/* with ++++: meanimg the new space added for the allocation*/
#ifdef __DEBUG_MALLOC_MODE__            
						p_stMyBlockInfo->uwNbFree -=2; /*there is two less frees*/
#endif /*__DEBUG_MALLOC_MODE__            */
 
						/* store malloc Information (first part)*/
						/*--------------------------------------*/
						p_uaSizeMalloc = p_uaBeforeFreeSpace;
						p_vMemBlock = (void *) (p_uaBeforeFreeSpace + C_ucMallocHeaderSize);/*lint !e613: Possible use of null pointer (p_uaBeforeFreeSpace)*/ /* the new adresse of the allocation                                                                        */
 
#ifdef __DEBUG_MALLOC_MODE__            
						/* clean the area of the new allocation. we use the variable p_uaBeforeSpaceFree for scan the memory & p_uaAfterfreespace for the end of the free area.*/
						for (   p_uaBeforeFreeSpace = p_uaBeforeFreeSpace + *p_uaBeforeFreeSpace - C_ucMallocFooterSize,
												p_uaAfterFreeSpace = p_uaBeforeFreeSpace + lDiffSize;/*lint !e613: Possible use of null pointer (p_uaBeforeFreeSpace)*/
										p_uaBeforeFreeSpace < p_uaAfterFreeSpace;
										p_uaBeforeFreeSpace++
								){
								*p_uaBeforeFreeSpace = C_uaCleanKey;
						}
#endif /* __DEBUG_MALLOC_MODE__*/
					}
 
					else {/* management of the remained place after the new alloction.*/
 
						/* general case:*/
						/*      |          Free          |...|         Free         ||   allocation   ||       Free         | ... |Free|*/
						/*      ^--p_uaBeforeBeforeFreespace ^---p_uaBeforeFreeSpace ^--p_uaSizeMalloc ^--p_uaAfterFreeSpace      ^--P_auAfterAfterSpace*/
 
						/* definition of my new free space after allocation : p_uaTmp*/
						/*                                                    -------*/
 
						p_uaTmp = p_uaBeforeFreeSpace + *p_uaSizeMalloc + lDiffSize;/*lint !e613: Possible use of null pointer (p_uaBeforeFreeSpace)*/ /* point at the begining of the new free space*/
 
						/*we have to move the begining of the allocation to p_uaBeforeFreeSpace*/
						memmove (p_uaBeforeFreeSpace, p_uaSizeMalloc, (*p_uaSizeMalloc - C_ucMallocFooterSize)<< C_uwShiftAllocSize );/*lint !e668: Possibly passing a null pointer to function memmove*/
 
						/* general case:*/
						/*      |          Free          |...|   allocation   |+++++++++++++++++++++++++++++| free remained | ... |Free|*/
						/*      ^--p_uaBeforeBeforeFreespace ^---p_uaBeforeFreeSpace                        ^--p_uaTmp            ^--P_auAfterAfterSpace*/
						/* with ++++: meanimg the new space added for the allocation*/
#ifdef __DEBUG_MALLOC_MODE__            
						p_stMyBlockInfo->uwNbFree --; /*there is one less free*/
#endif /*__DEBUG_MALLOC_MODE__            */
						/* set information of my new free space*/
						*p_uaTmp = (unitAlloc) (uaBeforeFreeSize + uaAfterFreeSize - (unitAlloc)lDiffSize);/* set the 'size' field of the new free space = [size of my old free space just before and just after] - [value of my increaseing allocation].*/
						*(p_uaTmp +1) = (unitAlloc) p_uaAfterAfterFreeSpace;/* set the 'next' field of my new free space */
 
						/*Management of the free list*/
						if (p_uaBeforeBeforeFreeSpace == p_uaBeforeFreeSpace){/*first elt of the free list*/
								p_stMyBlockInfo->p_cFirstFree = (char *) p_uaTmp;
						}
						else {/* commom case*/
								*(p_uaBeforeBeforeFreeSpace +1) = (unitAlloc) p_uaTmp;/*the 'next' field of my free before the free space used have contain the value of the begining of my new free space*/
						}
                                
						/* store malloc Information (first part)*/
						/*--------------------------------------*/
						p_uaSizeMalloc = p_uaBeforeFreeSpace;
						p_vMemBlock = (void *) (p_uaBeforeFreeSpace + C_ucMallocHeaderSize);/*lint !e613: Possible use of null pointer (p_uaBeforeFreeSpace)*/ /* the new adresse of the allocation*/
 
#ifdef __DEBUG_MALLOC_MODE__            
						/* clean the area of the new allocation. we use the variable p_uaBeforeSpaceFree for scan the memory & p_uaAfterfreespace for the end of the free area.*/
						for (   p_uaBeforeFreeSpace = p_uaBeforeFreeSpace + *p_uaBeforeFreeSpace - C_ucMallocFooterSize,
												p_uaAfterFreeSpace = p_uaBeforeFreeSpace + lDiffSize;/*lint !e613: Possible use of null pointer (p_uaBeforeFreeSpace)*/
										p_uaBeforeFreeSpace < p_uaAfterFreeSpace;
										p_uaBeforeFreeSpace++
								){
								*p_uaBeforeFreeSpace = C_uaCleanKey;
						}
 
						/* clean the area of the new free. we use the variable p_uaBeforeSpaceFree for scan the memory & p_uaAfterfreespace for the end of the free area.*/
						for (   p_uaBeforeFreeSpace = p_uaTmp + C_ucFreeHeaderSize,
												p_uaAfterFreeSpace = p_uaBeforeFreeSpace + *p_uaTmp - C_ucFreeHeaderSize;
										p_uaBeforeFreeSpace < p_uaAfterFreeSpace;
										p_uaBeforeFreeSpace++
								){
								*p_uaBeforeFreeSpace = C_uaCleanKey;
						}
#endif /* __DEBUG_MALLOC_MODE__*/
					}
 
					/* store malloc Information (continued)*/
					/*--------------------------------------*/
					*p_uaSizeMalloc = (unitAlloc)ulSize;/*lint !e613: Possible use of null pointer (p_uaSizeMalloc)*/
 
#ifdef __DEBUG_MALLOC_MODE__            
					*(p_uaSizeMalloc + ulSize -1) = C_uaEndKey;/*lint !e613: Possible use of null pointer (p_uaSizeMalloc)*/
					p_stMyBlockInfo->ulNbTotalRealloc++;
					p_stMyMallocInfo = p_stMyBlockInfo->d_stMallocInfo + ulMyNbMalloc;
					p_stMyMallocInfo->p_cBeginMalloc = (char *) p_vMemBlock;
					p_stMyMallocInfo->p_cEndMalloc = ((char *) (p_uaSizeMalloc + ulSize - C_ucMallocFooterSize)) - 1;/*lint !e613: Possible use of null pointer (p_uaSizeMalloc)*/
#endif /* __DEBUG_MALLOC_MODE__*/
					if ((char*)(p_uaSizeMalloc + *p_uaSizeMalloc)-1>=p_stMyBlockInfo->p_cMaxMem)/*lint !e613: Possible use of null pointer (p_uaSizeMalloc)*/
					{
						/* Managemement of the mem max information i order to be able to compute an estination of the optimzed version*/
						p_stMyBlockInfo->p_cMaxMem=(char*)(p_uaSizeMalloc + *p_uaSizeMalloc)-1;/*lint !e613: Possible use of null pointer (p_uaSizeMalloc)*/
 
#ifdef __DEBUG_MALLOC_MODE__
						p_stMyBlockInfo->ulCountMallocBeforeMaxMem = p_stMyBlockInfo->ulNbMalloc;
						p_stMyBlockInfo->ulCountFreeBeforeMaxMem = p_stMyBlockInfo->uwNbFree;
#endif /* __DEBUG_MALLOC_MODE__*/
					}
 
	/* not necessary
#ifdef __DEBUG_MALLOC_MODE__
					// count the real number of free
					p_uaTmp = (unitAlloc*)p_stMyBlockInfo->p_cFirstFree;
					for (uwI=0; *(p_uaTmp+1) != (unitAlloc)0; uwI++, p_uaTmp = (unitAlloc*) *(p_uaTmp+1));
					p_stMyBlockInfo->uwNbFree = uwI;
#endif  __DEBUG_MALLOC_MODE__
	*/
 
					Mmg_MLeaveCriticalSection();
					return (p_vMemBlock);
 
				}/* end of Yes there are enougth space just before + just after*/
 
				else if ( ( p_uaSizeMalloc + *p_uaSizeMalloc == p_uaAfterFreeSpace) && 
						 ((uaAfterFreeSize = *p_uaAfterFreeSpace) >= (unitAlloc) lDiffSize) )/*lint !e613: Possible use of null pointer (p_uaAfterFreeSpace))*/
				{
 
					/* we have enought space just after the allocation, with the free space begining at p_uaAfterFreeSpace.*/
					/*         -------------          -----*/
 
					/* general case:*/
					/* |        Free            | ... |        Free      | (...) |   allocation  ||     Free     | (...) |free|*/
					/* ^-- p_uaBeforeBeforeFree       ^-- p_uaBeforeFree         ^-- p_vMemBlock  ^-- p_uaAfterFree*/
 
#ifdef __DEBUG_MALLOC_MODE__
#ifdef __ADD_PLACE_FOR_DEBUG_INFORMATION__
#ifdef __WARNING3_ERR_MMG__
					/* test of overflow on a block*/
					if (    ((char *) ( p_uaSizeMalloc +ulSize
									   - ( p_stMyBlockInfo->ulNbMalloc ) * C_ucDebugInformationLoss )/* memMax - the place for debug information of all the allocation.*/
							)-1
						>
							(p_stMyBlockInfo->p_cEndBlock - (p_stMyBlockInfo->ulMaxNbStaticMalloc*(C_ucDebugInformationLoss<<C_uwShiftAllocSize))) /* the end of the memory without the memory added for the debug information*/
						)
					{
#ifdef __ERROR_STRINGS__
						unitAlloc *p_uaTheLastFreeSpace=p_uaBeforeFreeSpace;
 
						Mmg_fn_v_PrintInfoMalloc("\n~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~\n");
						Mmg_fn_v_PrintInfoMalloc("State of the block before the reallocate problem:\n");
						sprintf (szErrTxt, "in the request 'fn_p_vStaRealloc (0X%X, %d)'\n", p_vMemBlock, ulSize);
						Mmg_fn_v_PrintInfoMalloc(szErrTxt);
						Mmg_fn_v_PrintInfoMalloc("~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~\n");
						Mmg_M_PrintBlockStatisticWithModuleId(stCurrentModeInfo.ucModuleId, stCurrentModeInfo.ucMode);
						Mmg_fn_v_PrintInfoMalloc("~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~\n\n");
 
						while ((unitAlloc *)*(p_uaTheLastFreeSpace+1) != NULL)
							p_uaTheLastFreeSpace = (unitAlloc *) *(p_uaTheLastFreeSpace+1);
 
						sprintf (szErrTxt, "You have called reallocate for add %db,\n but the maximum allocation allowed is %db.\nSee the %s file in witch the state (before the request of allocation)of the block is printed",
							(lDiffSize)<<C_uwShiftAllocSize,
							((*p_uaTheLastFreeSpace)- ((p_stMyBlockInfo->ulMaxNbStaticMalloc*C_ucDebugInformationLoss)- ( p_stMyBlockInfo->ulNbMalloc * C_ucDebugInformationLoss))) << C_uwShiftAllocSize,
							C_szMmgLogFileName);
 
						Mmg_M_UpdateLastErrorWithCurrentModeInfo (E_uwMmgPbBLockFull, szErrTxt, ucChannel);
#else /*__ERROR_STRINGS__*/
						Mmg_M_UpdateLastErrorWithCurrentModeInfo (E_uwMmgPbBLockFull, NULL, ucChannel);
#endif /*__ERROR_STRINGS__*/
						Mmg_MLeaveCriticalSection();
						return (NULL);
					}
#endif/*__WARNING3_ERR_MMG__*/
#endif/*__ADD_PLACE_FOR_DEBUG_INFORMATION__*/
#endif /*__DEBUG_MALLOC_MODE__*/
 
 
 
					*p_uaAfterFreeSpace -= ((unitAlloc) lDiffSize);/*lint !e613: Possible use of null pointer (p_uaAfterFreeSpace)*/ /* the content of the 'size' field is equal of the remain (not used for the allocation)*/
 
					if (*p_uaAfterFreeSpace < (unitAlloc) C_ucFreeHeaderSize) /*lint !e613: Possible use of null pointer (p_uaAfterFreeSpace)*/ 
					{/*The remain of the free place is not enougth big to be managned*/
						/* we affect all the place to the malloc. The 'old' free place if empty (everything is used for the malloc)*/
 
						ulSize += (*p_uaAfterFreeSpace);/*lint !e613: Possible use of null pointer (p_uaAfterFreeSpace)*/ 
						lDiffSize = lDiffSize + (long)(*p_uaAfterFreeSpace);/*lint !e613: Possible use of null pointer (p_uaAfterFreeSpace)*/
 
						/* general case:*/
						/* |        Free            | ... |        Free      | (...) |   allocation  |+++++++++++++++| (...) |free|*/
						/* ^-- p_uaBeforeBeforeFree       ^-- p_uaBeforeFree         ^-- p_vMemBlock  ^-- p_uaAfterFree*/
 
#ifdef __DEBUG_MALLOC_MODE__            
						p_stMyBlockInfo->uwNbFree --; /*there is one less free*/
#endif /*__DEBUG_MALLOC_MODE__            */
 
						/* management of the first free*/
						if (p_uaAfterFreeSpace == p_uaBeforeFreeSpace){/* this is the first elt of the list*/
								p_stMyBlockInfo->p_cFirstFree = (char *) *(p_uaAfterFreeSpace+1);/*lint !e613: Possible use of null pointer (p_uaAfterFreeSpace)*/ 
						}
						else {/* commom case*/
								/* the free place after will become empty (everything is used for the malloc)*/
								/* Management of the Free list : the 'next' field of the free place before the free place used, will be affect to the contents of the 'next' field of the free place used */
								*(p_uaBeforeFreeSpace + 1) = *(p_uaAfterFreeSpace + 1);/*lint !e613: Possible use of null pointer (p_uaAfterFreeSpace) & (p_uaBeforeFreeSpace)*/ 
						}
					}
					else {/* management of the remained place after the new alloction.*/
 
						p_uaTmp = (unitAlloc *) *(p_uaAfterFreeSpace + 1);/*lint !e613: Possible use of null pointer (p_uaAfterFreeSpace)*/ /* save the next field of my old free after my allocation*/
						*(p_uaAfterFreeSpace + lDiffSize) = *p_uaAfterFreeSpace;/*lint !e613: Possible use of null pointer (p_uaAfterFreeSpace)*/ /* set the 'size' field of remained space at the rigth place*/
						*(p_uaAfterFreeSpace + lDiffSize + 1) = (unitAlloc) p_uaTmp;/*lint !e613: Possible use of null pointer (p_uaAfterFreeSpace)*/ /* set the 'next' field of remained space at the rigth place*/
 
						/* general case:*/
						/* |        Free            | ... |        Free      | (...) |   allocation  |+++++|  Free   | (...) |free|*/
						/* ^-- p_uaBeforeBeforeFree       ^-- p_uaBeforeFree         ^-- p_vMemBlock  ^-- p_uaAfterFree*/
 
						/* management of the first free*/
						if (p_uaBeforeFreeSpace == p_uaAfterFreeSpace){/* this is the first elt of the list*/
								p_stMyBlockInfo->p_cFirstFree = (char *) (p_uaAfterFreeSpace + lDiffSize);/*lint !e613: Possible use of null pointer (p_uaAfterFreeSpace)*/
						}
						else {/* commom case.*/
								*(p_uaBeforeFreeSpace+1) = (unitAlloc) (p_uaAfterFreeSpace + lDiffSize);/*lint !e613: Possible use of null pointer (p_uaAfterFreeSpace)*/ /*managment of the free list. The 'next' field of free space just before the allocation have chage.*/
						}
					}
 
					/* store malloc Information*/
					/*--------------------------*/
					*p_uaSizeMalloc = (unitAlloc)ulSize;
 
#ifdef __DEBUG_MALLOC_MODE__            
					*(p_uaSizeMalloc + ulSize -1) = C_uaEndKey;
					p_stMyBlockInfo->ulNbTotalRealloc++;
					p_stMyMallocInfo = p_stMyBlockInfo->d_stMallocInfo + ulMyNbMalloc;
					p_stMyMallocInfo->p_cEndMalloc = ((char *) (p_uaSizeMalloc + ulSize - C_ucMallocFooterSize)) - 1;
#endif /* __DEBUG_MALLOC_MODE__*/
					if ((char*)(p_uaSizeMalloc + *p_uaSizeMalloc)-1>=p_stMyBlockInfo->p_cMaxMem)
					{
						/* Managemement of the mem max information i order to be able to compute an estination of the optimzed version*/
						p_stMyBlockInfo->p_cMaxMem=(char*)(p_uaSizeMalloc + *p_uaSizeMalloc)-1;
 
#ifdef __DEBUG_MALLOC_MODE__
						p_stMyBlockInfo->ulCountMallocBeforeMaxMem = p_stMyBlockInfo->ulNbMalloc;
						p_stMyBlockInfo->ulCountFreeBeforeMaxMem = p_stMyBlockInfo->uwNbFree;
#endif /* __DEBUG_MALLOC_MODE__*/
					}
 
#ifdef __DEBUG_MALLOC_MODE__
					/* clean the area of the new allocation. we use the variable p_uaBeforeSpaceFree for scan the memory & p_uaAfterfreespace for the end of the free area.*/
					for (   p_uaBeforeFreeSpace = p_uaAfterFreeSpace - C_ucMallocFooterSize,
							p_uaAfterFreeSpace = p_uaBeforeFreeSpace + lDiffSize;/*lint !e613: Possible use of null pointer (p_uaAfterFreeSpace)*/
							p_uaBeforeFreeSpace < p_uaAfterFreeSpace;
							p_uaBeforeFreeSpace++
						)
					{
						*p_uaBeforeFreeSpace = C_uaCleanKey;
					}
 
#endif /* __DEBUG_MALLOC_MODE__*/
 
	/*not necessary
#ifdef __DEBUG_MALLOC_MODE__
					// count the real number of free
					p_uaTmp = (unitAlloc*)p_stMyBlockInfo->p_cFirstFree;
					for (uwI=0; *(p_uaTmp+1) != (unitAlloc)0; uwI++, p_uaTmp = (unitAlloc*) *(p_uaTmp+1));
					p_stMyBlockInfo->uwNbFree = uwI;
#endif  __DEBUG_MALLOC_MODE__
	*/
 
					Mmg_MLeaveCriticalSection();
					return (p_vMemBlock);
				}/* end of Yes, we have enought space after the allocation.*/
 
				else{ /* There are no space around the allocation*/
						/*            ----------------*/
 
					ulSize -= (C_ucMallocHeaderSize + C_ucMallocFooterSize); /* place for information(s) to manage the allocation place*/
					ulSize <<= C_uwShiftAllocSize;
                        
#ifdef __DEBUG_MALLOC_MODE__
					p_stMyBlockInfo->ulNbTotalMalloc--;/* this is not a real malloc requested, then we don't have to increase the counter.*/
#endif /*__DEBUG_MALLOC_MODE__*/
					p_uaTmp = (unitAlloc *) fn_p_vStaAlloc (ulSize, ucChannel);
 
					if (p_uaTmp != NULL) {
						memcpy ((void *) p_uaTmp, p_vMemBlock, (*p_uaSizeMalloc - C_ucMallocFooterSize - C_ucMallocHeaderSize)<< C_uwShiftAllocSize);
 
#ifdef __DEBUG_MALLOC_MODE__
						p_stMyBlockInfo->ulNbTotalFree--;/* this is not a real free requested, then we don't have to increase the counter.*/
#endif /*__DEBUG_MALLOC_MODE__*/
						fn_vStaFree (p_vMemBlock, ucChannel);
#ifdef __DEBUG_MALLOC_MODE__
						/* the free have move up all the elt after the freed malloc of the Malloc info Table*/
						/* then we have to use the last elt of the malloc info table*/
						ulMyNbMalloc= (unsigned short) (p_stMyBlockInfo->ulNbMalloc -1);
#endif /*__DEBUG_MALLOC_MODE__*/
 
 
 
					/* store malloc Information*/
					/*--------------------------*/
#ifdef __DEBUG_MALLOC_MODE__            
						p_stMyBlockInfo->ulNbTotalRealloc++;
						p_vMemBlock = p_uaTmp;
#endif /* __DEBUG_MALLOC_MODE__*/
						p_uaSizeMalloc = p_uaTmp - C_ucMallocHeaderSize;
						if ((char*)(p_uaSizeMalloc + *p_uaSizeMalloc)-1>=p_stMyBlockInfo->p_cMaxMem)
						{
							/* Managemement of the mem max information i order to be able to compute an estination of the optimzed version*/
							p_stMyBlockInfo->p_cMaxMem=(char*)(p_uaSizeMalloc + *p_uaSizeMalloc)-1;
 
#ifdef __DEBUG_MALLOC_MODE__
							p_stMyBlockInfo->ulCountMallocBeforeMaxMem = p_stMyBlockInfo->ulNbMalloc;
							p_stMyBlockInfo->ulCountFreeBeforeMaxMem = p_stMyBlockInfo->uwNbFree;
#endif /* __DEBUG_MALLOC_MODE__*/
						}
					}/* end of the if(p_uaTmp != NULL)*/
	/* not necessary
#ifdef __DEBUG_MALLOC_MODE__
					// count the real number of free
					p_uaTmp = (unitAlloc*)p_stMyBlockInfo->p_cFirstFree;
					for (uwI=0; *(p_uaTmp+1) != (unitAlloc)0; uwI++, p_uaTmp = (unitAlloc*) *(p_uaTmp+1));
					p_stMyBlockInfo->uwNbFree = uwI;
					p_uaTmp = p_vMemBlock;
#endif  __DEBUG_MALLOC_MODE__
	*/
					Mmg_MLeaveCriticalSection();
					return ((void *) p_uaTmp);
				}/* There are no space around the allocation*/
			}/* we want to increase the alocation*/
        
	/* not necessary
#ifdef __DEBUG_MALLOC_MODE__
			// count the real number of free
			p_uaTmp = (unitAlloc*)p_stMyBlockInfo->p_cFirstFree;
			for (uwI=0; *(p_uaTmp+1) != (unitAlloc)0; uwI++, p_uaTmp = (unitAlloc*) *(p_uaTmp+1));
			p_stMyBlockInfo->uwNbFree = uwI;
#endif  __DEBUG_MALLOC_MODE__
	*/
			Mmg_MLeaveCriticalSection();
			return (p_vMemBlock); /* nothing done*/
		}/* of the elese b_ucFound is set*/
}/*fn_p_vStaRealloc */
/* ================*/
 
/* ##-########################### 
   ## DYNAMYC & STATIC MODE
   ## General kernel of allocation, reallocation & free 
   ############################## */
 
#ifdef __DYNAMIC_MALLOC_ALLOWED__
 
/* ##F#===================================================================================
NAME :          fn_p_vGenAlloc
DESCRIPTION :   Allocate a memory zone in the channel using the corresponding Mode
INPUT :			Size
				Channel Id
OUTPUT :		Pointeur on the zone allocated
=========================================================================================
CREATION : 06-11-97/Pierrick Crepy
=======================================================================================*/
void * fn_p_vGenAlloc (unsigned long ulSize, unsigned char ucChannel){
/*     ===============*/
 
#ifdef 	USE_PROFILER 
#ifndef	U64
        MMG_fn_vRegisterMemoryAllocation  (ucChannel , ulSize);
#endif
#endif
#if defined(U64) && !defined(RETAIL)
	if(ulSize<=0)
	{
		osSyncPrintf("Try to alloc %ld bytes!!\n",ulSize);
		ASM_BREAK;
	}
#endif /* U64  && !RETAIL */
        if (Mmg_M_ucIsStaticMode(ucChannel)) 
				{
#ifdef SHOW_RAST_MEM
					tdstBlockInfoPriv * p_stMyBlockInfo = (tdstBlockInfoPriv *) g_d_stCurrentModeInfo[ucChannel].p_vTdstBlockInfoOrTdstDynInfo;
					if(p_stMyBlockInfo->p_cFirstFree != C_FirstFreeValueForBlockWithoutFree)
					{
						unsigned long ul=ulSize;
 
						Mmg_M_BigBoundSize (ul, C_uwAllocSize);
						ul >>= C_uwShiftAllocSize;
						ul += (C_ucMallocHeaderSize + C_ucMallocFooterSize);
						ul <<= C_uwShiftAllocSize;
 
						RM_g_ulRealSize+=ul;
 
#ifdef SHOW_RAST_MEM_FOR_DESIGNER
						RMFD_g_ulRealSize[RMFD_g_tdeRastMemSuperType]+=ul;
#endif /* SHOW_RAST_MEM_FOR_DESIGNER */
					}
					else
					{
						unsigned long ul=ulSize;
#ifdef D_CheckSystemForBlockWithoutFree
						tdstInformationHeaderOfBolckWithoutFree *p_stInfoHeaderBolck=(tdstInformationHeaderOfBolckWithoutFree *)p_stMyBlockInfo->p_cBeginBlock;
						if(p_stInfoHeaderBolck->ucMode & C_Check_AlignementFlag)
						{
							Mmg_M_BigBoundSize (ul, p_stInfoHeaderBolck->ucAlignment);
						}
#endif /* D_CheckSystemForBlockWithoutFree */
						RM_g_ulRealSize+=ul;
 
#ifdef SHOW_RAST_MEM_FOR_DESIGNER
						RMFD_g_ulRealSize[RMFD_g_tdeRastMemSuperType]+=ul;
#endif /* SHOW_RAST_MEM_FOR_DESIGNER */
					}
					RM_g_ulAskedSize+=ulSize;
 
#ifdef SHOW_RAST_MEM_FOR_DESIGNER
					RMFD_g_ulAskedSize[RMFD_g_tdeRastMemSuperType]+=ulSize;
#endif /* SHOW_RAST_MEM_FOR_DESIGNER */
 
#endif /* SHOW_RAST_MEM */
 
#if !defined(RETAIL) && !defined(U64)
					/* Il we must save binary datas, set the allocated mem to 0,*/
					/* to avoid wrong pointer detection */
					if( MMG_g_bResetMemOnAllocation )
					{
						char *p_cAllocatedMem = fn_p_vStaAlloc (ulSize, ucChannel);
						if( p_cAllocatedMem )
						{
							Mmg_M_BigBoundSize (ulSize, C_uwAllocSize);
							memset( p_cAllocatedMem, 0, ulSize );
						}
						return p_cAllocatedMem;
					}
					else
#endif /* ! RETAIL && ! U64*/
						return (fn_p_vStaAlloc (ulSize, ucChannel));
				}
        else 
				{
#ifdef SHOW_RAST_MEM
					unsigned long ul=ulSize;
 
					Mmg_M_BigBoundSize (ul, C_uwAllocSize);
					ul >>= C_uwShiftAllocSize;
					ul += (C_ucMallocHeaderSize + C_ucMallocFooterSize);
					ul <<= C_uwShiftAllocSize;
 
					RM_g_ulRealSize+=ul;
 
#ifdef SHOW_RAST_MEM_FOR_DESIGNER
					RMFD_g_ulRealSize[RMFD_g_tdeRastMemSuperType]+=ul;
#endif /* SHOW_RAST_MEM_FOR_DESIGNER */
 
					RM_g_ulAskedSize+=ulSize;
 
#ifdef SHOW_RAST_MEM_FOR_DESIGNER
					RMFD_g_ulAskedSize[RMFD_g_tdeRastMemSuperType]+=ulSize;
#endif /* SHOW_RAST_MEM_FOR_DESIGNER */
 
#endif /* SHOW_RAST_MEM */
                return (fn_p_vDynAlloc (ulSize, ucChannel));
				}
}/* end of fn_p_vAlloc*/
 
/* ##F#===================================================================================
NAME :          fn_p_vGenFree
DESCRIPTION :   Free a memory zone in the channel using the corresponding Mode
INPUT :			Pointer on the zone allocated
				Channel Id
=========================================================================================
CREATION : 06-11-97/Pierrick Crepy
=======================================================================================*/
void fn_vGenFree (void *p_vMemBlock, unsigned char ucChannel){
/*   ===========*/
#ifdef 	USE_PROFILER 
#ifndef	U64
        MMG_fn_vRegisterMemoryFree (ucChannel , p_vMemBlock);
#endif
#endif
        if (Mmg_M_ucIsStaticMode(ucChannel)) 
                fn_vStaFree (p_vMemBlock, ucChannel);
        else 
                fn_vDynFree (p_vMemBlock, ucChannel);
}/*end of fn_vFree */
 
/* ##F#===================================================================================
NAME :          fn_p_vGenRealloc
DESCRIPTION :   Reallocate a memory zone in the channel using the corresponding Mode
INPUT :			Pointer on the zone allocated
				Size
				Channel Id
OUTPUT :		Pointeur on the new zone allocated
=========================================================================================
CREATION : 06-11-97/Pierrick Crepy
=======================================================================================*/
void * fn_p_vGenRealloc (void *p_vMemBlock, unsigned long ulSize, unsigned char ucChannel){
/*     ================*/
        if (Mmg_M_ucIsStaticMode(ucChannel)) 
#if !defined(RETAIL) && !defined(U64)
			/* Il we must save binary datas, set the allocated mem to 0,*/
			/* to avoid wrong pointer detection */
		if( MMG_g_bResetMemOnAllocation )
		{
			unsigned long ulPrevSize = *((unsigned long *)p_vMemBlock-1);
			p_vMemBlock = fn_p_vStaRealloc (p_vMemBlock, ulSize, ucChannel);
			if( p_vMemBlock )
			{
				long lSizeDiff =  *((unsigned long *)p_vMemBlock-1) - ulPrevSize;
				if( lSizeDiff > 0 )
					memset( (unsigned long *)p_vMemBlock+ulPrevSize-1, 0, lSizeDiff << C_uwShiftAllocSize );
			}
			return p_vMemBlock;
		}
		else
#endif /* ! RETAIL && ! U64*/
                return (fn_p_vStaRealloc (p_vMemBlock, ulSize, ucChannel));
        else 
                return (fn_p_vDynRealloc (p_vMemBlock, ulSize, ucChannel));
}/* end of fn_p_vRealloc*/
 
#endif /* __DYNAMIC_MALLOC_ALLOWED__*/
 
/* ##-########################### 
   ## Management of Test
   ############################## */
 
/* ##F#===================================================================================
NAME :          Mmg_fn_ulmsize
DESCRIPTION :   return the size in byte used for the allocation of a zone
INPUT :			Pointer on the allocated zone
OUTPUT :		Real size of the zone (including the management data)
=========================================================================================
CREATION : 06-11-97/Pierrick Crepy
=======================================================================================*/
#ifndef _FIRE_DEADCODE_U64_
unsigned long Mmg_fn_ulmsize(void *p_vMemBlock){
	unitAlloc * p_uaPtr;
#ifdef __DEBUG_MALLOC_MODE__
#if defined(__ERROR_STRINGS__) && defined(__FATAL_ERR_MMG__)
	char szErrTxt[C_ucSizeOfErrTxt];
#endif /*defined(__ERROR_STRINGS__) && defined(__FATAL_ERR_MMG__)*/
 
	p_uaPtr = (unitAlloc *)p_vMemBlock;	
	p_uaPtr--;
 
#ifdef __FATAL_ERR_MMG__
    if (*p_uaPtr != (unitAlloc)C_uaBeginKey){
#ifdef __ERROR_STRINGS__
		sprintf(szErrTxt,"Yes,at the address 0X%X there is the value 0X%X\nIt's quite different to the expected 'C_uaBeginKey' value (0X%X)", p_uaPtr, (unitAlloc)*p_uaPtr, C_uaBeginKey);
        Mmg_M_UpdateLastError (E_uwMmgPbOverflowBefore, szErrTxt);
#else /*__ERROR_STRINGS__*/
		Mmg_M_UpdateLastError (E_uwMmgPbOverflowBefore, NULL);
#endif /*__ERROR_STRINGS__*/
    }
#endif /*__FATAL_ERR_MMG__*/
	p_uaPtr = ((unitAlloc *)p_vMemBlock) + *(p_uaPtr-1)/*size*/ - C_ucMallocHeaderSize - C_ucMallocFooterSize;
#ifdef __FATAL_ERR_MMG__
    if (*p_uaPtr != (unitAlloc) C_uaEndKey){
#ifdef __ERROR_STRINGS__
		sprintf(szErrTxt,"Yes,at the address 0X%X there is the value 0X%X\nIt's quite different to the expected 'C_uaEndKey' value (0X%X)", p_uaPtr, (unitAlloc)*p_uaPtr, C_uaEndKey);
		Mmg_M_UpdateLastError (E_uwMmgPbOverflowAfter, szErrTxt);
#else /*__ERROR_STRINGS__*/
		Mmg_M_UpdateLastError (E_uwMmgPbOverflowAfter, NULL);
#endif /*__ERROR_STRINGS__*/
    }	
#endif /*__FATAL_ERR_MMG__*/
 
#endif /*__DEBUG_MALLOC_MODE__*/
 
 
	p_uaPtr = (unitAlloc *)p_vMemBlock;	
#ifdef __DEBUG_MALLOC_MODE__
	p_uaPtr-=2;
#else /*__DEBUG_MALLOC_MODE__*/
	p_uaPtr--;
#endif /*__DEBUG_MALLOC_MODE__*/
 
	return ((unsigned long) ((*p_uaPtr)<< C_uwShiftAllocSize));
}/* end of Mmg_fn_ulmsize*/
#endif /* _FIRE_DEADCODE_U64_ */
 
/* ##F#===================================================================================
NAME :          Mmg_fn_vTestMallocIntegrityAt
DESCRIPTION :   Check the integrity of an allocated zone (only in debug mode)
INPUT :			Pointer on the block structure
=========================================================================================
CREATION : 06-11-97/Pierrick Crepy
=======================================================================================*/
void Mmg_fn_vTestMallocIntegrityAt(void *p_vMemBlock)
{
#ifdef __DEBUG_MALLOC_MODE__
	unitAlloc * p_uaPtr;
#if defined(__ERROR_STRINGS__) && defined(__FATAL_ERR_MMG__)
	char szErrTxt[C_ucSizeOfErrTxt];
#endif /*defined(__ERROR_STRINGS__) && defined(__FATAL_ERR_MMG__)*/
 
	p_uaPtr = (unitAlloc *)p_vMemBlock;	
	p_uaPtr--;
 
#ifdef __FATAL_ERR_MMG__
    if (*p_uaPtr != (unitAlloc)C_uaBeginKey){
#ifdef __ERROR_STRINGS__
		sprintf(szErrTxt,"Yes,at the address 0X%X there is the value 0X%X\nIt's quite different to the expected 'C_uaBeginKey' value (0X%X)", p_uaPtr, (unitAlloc)*p_uaPtr, C_uaBeginKey);
        Mmg_M_UpdateLastError (E_uwMmgPbOverflowBefore, szErrTxt);
#else /*__ERROR_STRINGS__*/
		Mmg_M_UpdateLastError (E_uwMmgPbOverflowBefore, NULL);
#endif /*__ERROR_STRINGS__*/
    }
#endif /*__FATAL_ERR_MMG__*/
	p_uaPtr = ((unitAlloc *)p_vMemBlock) + *(p_uaPtr-1)/*size*/ - C_ucMallocHeaderSize - C_ucMallocFooterSize;
#ifdef __FATAL_ERR_MMG__
    if (*p_uaPtr != (unitAlloc) C_uaEndKey){
#ifdef __ERROR_STRINGS__
		sprintf(szErrTxt,"Yes,at the address 0X%X there is the value 0X%X\nIt's quite different to the expected 'C_uaEndKey' value (0X%X)", p_uaPtr, (unitAlloc)*p_uaPtr, C_uaEndKey);
		Mmg_M_UpdateLastError (E_uwMmgPbOverflowAfter, szErrTxt);
#else /*__ERROR_STRINGS__*/
		Mmg_M_UpdateLastError (E_uwMmgPbOverflowAfter, NULL);
#endif /*__ERROR_STRINGS__*/
    }	
#endif /*__FATAL_ERR_MMG__*/
 
#endif /*__DEBUG_MALLOC_MODE__*/
}/* end of Mmg_fn_vTestMallocIntegrityAt*/
 
/* ##F#===================================================================================
NAME :          Mmg_fn_vTestMalloc
DESCRIPTION :   Check integrity for all allocation (only in debug mode)
=========================================================================================
CREATION : 06-11-97/Pierrick Crepy
=======================================================================================*/
void Mmg_fn_vTestMalloc()
/*///////////////////*/
{
#ifdef __DEBUG_MALLOC_MODE__
        unsigned char ucBlockId;
        unsigned char ucModuleId;
        unsigned long ulNumMalloc;     
        tdstBlockInfoPriv *p_stMyBlockInfo;
        tdstMallocInfo *p_stMyMallocInfo;
        unitAlloc * p_uaPtr;
        tdstBlockInfoPriv *a_stMyBlockInfo;
#ifdef __DYNAMIC_MALLOC_ALLOWED__
        tdstDynInfo *p_stMyDynInfo;
#endif /*__DYNAMIC_MALLOC_ALLOWED__*/
#ifdef __ERROR_STRINGS__
		char szErrTxt[C_ucSizeOfErrTxt];
#endif /*__ERROR_STRINGS__*/
 
#ifdef __DYNAMIC_MALLOC_ALLOWED__ 
        for (ucModuleId=0; ucModuleId < g_ucErmNbOfModule; ucModuleId++){
                p_stMyDynInfo = g_d_p_stMmgModuleDynInfo[ucModuleId];
                if (p_stMyDynInfo != NULL){
                        for (ulNumMalloc=0; ulNumMalloc < p_stMyDynInfo->ulNbDynamicMalloc; ulNumMalloc++){
                                p_stMyMallocInfo = (p_stMyDynInfo->d_stDynamicMallocInfo) + ulNumMalloc;
 
                                p_uaPtr = (unitAlloc *)(p_stMyMallocInfo->p_cBeginMalloc);
                                p_uaPtr--;
#ifdef __FATAL_ERR_MMG__
                                if (*p_uaPtr != (unitAlloc)C_uaBeginKey){
#ifdef __ERROR_STRINGS__
									sprintf(szErrTxt,"Yes,at the address 0X%X there is the value 0X%X\nIt's quite different to the expected 'C_uaBeginKey' value (0X%X)", p_uaPtr, (unitAlloc)*p_uaPtr, C_uaBeginKey);
                                    /*Mmg_M_UpdateLastErrorWithCurrentModeInfo (E_uwMmgPbDynOverflowBefore, szErrTxt, ucChannel);*/
									Mmg_M_UpdateLastErrorWithModuleIdAnducModeReference(ucModuleId, E_ucDynamic, E_uwMmgPbDynOverflowBefore, szErrTxt);
#else /*__ERROR_STRINGS__*/
									Mmg_M_UpdateLastErrorWithModuleIdAnducModeReference(ucModuleId, E_ucDynamic, E_uwMmgPbDynOverflowBefore, NULL);
#endif /*__ERROR_STRINGS__*/
                                }
#endif /*__FATAL_ERR_MMG__*/
                                p_uaPtr = (unitAlloc *)(p_stMyMallocInfo->p_cEndMalloc + 1);
#ifdef __FATAL_ERR_MMG__
                                if (*p_uaPtr != (unitAlloc) C_uaEndKey){
#ifdef __ERROR_STRINGS__
									sprintf(szErrTxt,"Yes,at the address 0X%X there is the value 0X%X\nIt's quite different to the expected 'C_uaEndKey' value (0X%X)", p_uaPtr, (unitAlloc)*p_uaPtr, C_uaEndKey);
									/*Mmg_M_UpdateLastErrorWithCurrentModeInfo (E_uwMmgPbDynOverflowAfter, szErrTxt, ucChannel);*/
									Mmg_M_UpdateLastErrorWithModuleIdAnducModeReference(ucModuleId, E_ucDynamic, E_uwMmgPbDynOverflowAfter, szErrTxt
										);
#else /*__ERROR_STRINGS__*/
									Mmg_M_UpdateLastErrorWithModuleIdAnducModeReference(ucModuleId, E_ucDynamic, E_uwMmgPbDynOverflowAfter, NULL);
#endif /*__ERROR_STRINGS__*/
                                }
#endif /*__FATAL_ERR_MMG__*/
                        }/* for */
                } /*if not NULL*/
        }/* end of for module*/
#endif /*__DYNAMIC_MALLOC_ALLOWED__*/
 
        for (ucModuleId=0; ucModuleId < g_ucErmNbOfModule; ucModuleId++){               
                a_stMyBlockInfo = g_a_p_stMmgModuleBlocksInfo[ucModuleId]; 
				if ((a_stMyBlockInfo == NULL) || (a_stMyBlockInfo->p_cFirstFree == C_FirstFreeValueForBlockWithoutFree )) continue;
				else{
					for (ucBlockId=0; ucBlockId<g_a_ucBlocksNbInModule[ucModuleId];ucBlockId++){
							p_stMyBlockInfo = a_stMyBlockInfo + ucBlockId;
							if (p_stMyBlockInfo->p_cBeginBlock == C_p_cBlockNotValidKey) break;/* the block is not initialized*/
							if (
								(p_stMyBlockInfo->p_cBeginBlock == NULL) ||
								(p_stMyBlockInfo->p_cEndBlock == NULL)||
								(p_stMyBlockInfo->p_cBeginBlock > p_stMyBlockInfo->p_cEndBlock)
							   )
							{
#ifdef __ERROR_STRINGS__
								if (p_stMyBlockInfo->p_cBeginBlock == NULL)
									sprintf(szErrTxt, "p_cBeginBlock == NULL\n");
								else if(p_stMyBlockInfo->p_cEndBlock == NULL)
									sprintf(szErrTxt, "p_cEndBlock == NULL\n");
								else if (p_stMyBlockInfo->p_cBeginBlock > p_stMyBlockInfo->p_cEndBlock)
									sprintf(szErrTxt, "p_cBeginBlock > p_cEndBlock\n");
								/*Mmg_M_UpdateLastErrorWithCurrentModeInfo (E_uwMmgPbInvalidMallocInfo, szErrTxt, ucChannel);*/
								Mmg_M_UpdateLastErrorWithModuleIdAnducModeReference(ucModuleId, ucBlockId, E_uwMmgPbInvalidMallocInfo, szErrTxt);
#else /*__ERROR_STRINGS__*/
								Mmg_M_UpdateLastErrorWithModuleIdAnducModeReference(ucModuleId, ucBlockId, E_uwMmgPbInvalidMallocInfo, NULL);
#endif /*__ERROR_STRINGS__*/
								break;
							}
							Mmg_fn_vTestNbFree(ucModuleId, ucBlockId, p_stMyBlockInfo);/*!! yob !!a virer just pour tester la validite de uwNbFree  !! yob !!*/
 
							/* test of the allocation size*/
#ifdef __ADD_PLACE_FOR_DEBUG_INFORMATION__
#ifdef __WARNING3_ERR_MMG__
							if (    (p_stMyBlockInfo->p_cMaxMem
									- ((( p_stMyBlockInfo->ulCountMallocBeforeMaxMem) * (C_ucDebugInformationLoss<<C_uwShiftAllocSize) )))/* memMax - the place for debug information of all the allocation.*/
								>
									(p_stMyBlockInfo->p_cEndBlock - (p_stMyBlockInfo->ulMaxNbStaticMalloc*(C_ucDebugInformationLoss<<C_uwShiftAllocSize))) /* the end of the memory without the memory added for the debug information*/
								)
							{
#ifdef __ERROR_STRINGS__
								sprintf (szErrTxt, 
									"The Maximun adresse is 0X%X occured (this append with %d allocations before) is to hight\nthis problem come from testMalloc function !\nPlease warn the developper of Mmg to fix the Bug\n",
									p_stMyBlockInfo->p_cMaxMem,
									p_stMyBlockInfo->ulCountMallocBeforeMaxMem);
								Mmg_M_UpdateLastErrorWithModuleIdAnducModeReference(ucModuleId, ucBlockId, E_uwMmgPbBLockFull, szErrTxt);
#else /*__ERROR_STRINGS__*/
								Mmg_M_UpdateLastErrorWithModuleIdAnducModeReference(ucModuleId, ucBlockId, E_uwMmgPbBLockFull, NULL);
#endif /*__ERROR_STRINGS__*/
							}
#endif/*__WARNING3_ERR_MMG__*/
#endif /*__ADD_PLACE_FOR_DEBUG_INFORMATION__*/
 
							for (ulNumMalloc=0; ulNumMalloc < p_stMyBlockInfo->ulNbMalloc; ulNumMalloc++){
									p_stMyMallocInfo = (p_stMyBlockInfo->d_stMallocInfo)+ulNumMalloc;
 
									p_uaPtr = (unitAlloc *)(p_stMyMallocInfo->p_cBeginMalloc);
									p_uaPtr--;
#ifdef __FATAL_ERR_MMG__
									if (*p_uaPtr != (unitAlloc)C_uaBeginKey){
#ifdef __ERROR_STRINGS__										
										sprintf(szErrTxt,"Yes,at the address 0X%X there is the value 0X%X\nIt's quite different to the expected 'C_uaBeginKey' value (0X%X)", p_uaPtr, (unitAlloc)*p_uaPtr, C_uaBeginKey);
										/*Mmg_M_UpdateLastErrorWithCurrentModeInfo (E_uwMmgPbStaOverflowBefore, szErrTxt, ucChannel);*/
										Mmg_M_UpdateLastErrorWithModuleIdAnducModeReference(ucModuleId, ucBlockId, E_uwMmgPbStaOverflowBefore, szErrTxt);
#else /*__ERROR_STRINGS__*/
										Mmg_M_UpdateLastErrorWithModuleIdAnducModeReference(ucModuleId, ucBlockId, E_uwMmgPbStaOverflowBefore, NULL);
#endif /*__ERROR_STRINGS__*/
									}
#endif /*__FATAL_ERR_MMG__*/
									p_uaPtr = (unitAlloc *)(p_stMyMallocInfo->p_cEndMalloc + 1);
#ifdef __FATAL_ERR_MMG__
									if (*p_uaPtr != (unitAlloc) C_uaEndKey){
#ifdef __ERROR_STRINGS__
										sprintf(szErrTxt,"Yes,at the address 0X%X there is the value 0X%X\nIt's quite different to the expected 'C_uaEndKey' value (0X%X)", p_uaPtr, (unitAlloc)*p_uaPtr, C_uaEndKey);
										/*Mmg_M_UpdateLastErrorWithCurrentModeInfo (E_uwMmgPbStaOverflowAfter, szErrTxt, ucChannel);*/
										Mmg_M_UpdateLastErrorWithModuleIdAnducModeReference(ucModuleId, ucBlockId, E_uwMmgPbStaOverflowAfter, szErrTxt);
#else /*__ERROR_STRINGS__*/
										Mmg_M_UpdateLastErrorWithModuleIdAnducModeReference(ucModuleId, ucBlockId, E_uwMmgPbStaOverflowAfter, NULL);
#endif /*__ERROR_STRINGS__*/
									}
#endif /*__FATAL_ERR_MMG__*/
							}
					}/* end of for block*/
				}
        }/* end of for module*/
 
#endif /*__DEBUG_MALLOC_MODE__*/
}/* Mmg_fn_vTestMalloc*/
 
 
/*---------*/
/* Debug --*/
/*---------*/
 
/* ##F#===================================================================================
NAME :          fn_vSortMallocInfoTable
DESCRIPTION :   Sort the malloc info table by block address ascending (only in debug mode)
INPUT :			Pointer on malloc info structure
				Table Size
=========================================================================================
CREATION : 06-11-97/Pierrick Crepy
=======================================================================================*/
#ifndef _FIRE_DEADCODE_U64_
void fn_vSortMallocInfoTable (tdstMallocInfo * p_stMyMallocInfo, unsigned long ulSizeTable){
#ifdef __DEBUG_MALLOC_MODE__
        unsigned long ulI, ulJ;
        tdstMallocInfo stTmp;
        for (ulI=0; ulI < ulSizeTable-1; ulI++){
                for (ulJ=(unsigned short)(ulI+1); ulJ < ulSizeTable; ulJ++){
                        if ((p_stMyMallocInfo+ulJ)->p_cBeginMalloc < (p_stMyMallocInfo+ulI)->p_cBeginMalloc){
                                stTmp = *(p_stMyMallocInfo+ulI);
                                *(p_stMyMallocInfo+ulI) = *(p_stMyMallocInfo+ulJ);
                                *(p_stMyMallocInfo+ulJ) = stTmp;
                        }
                }
        }
#endif /*__DEBUG_MALLOC_MODE__*/
}/*lint !e715: p_stMyMallocInfo & ulSizeTable(line 1836) not referenced*/
#endif /* _FIRE_DEADCODE_U64_ */
 
/* ##F#===================================================================================
NAME :          Mmg_fn_vPrintAllDynamicMalloc
DESCRIPTION :   Print the map of dynamic allocation for a module (only in debug mode)
INPUT :			Module Id
				Pointer on dynamic malloc info structure
				Flag to indicate that info must be sorted
=========================================================================================
CREATION : 06-11-97/Pierrick Crepy
=======================================================================================*/
#ifndef _FIRE_DEADCODE_U64_
#ifdef __DYNAMIC_MALLOC_ALLOWED__
#ifdef __DEBUG_MALLOC_MODE__
void Mmg_fn_vPrintAllDynamicMalloc (unsigned char ucModuleId, struct tdstDynInfo_ *p_stMyDynInfo, unsigned char ucSorted){
/*   -------------------------*/
        tdstMallocInfo * p_stMyMallocInfo;
        unsigned char ucI;
        unsigned long ulI;
        unsigned long ulLength,ulMaxSize=0;
        char a_cHistoMalloc [C_ucNbColumnForHisto+3];/* +3 for '\n'+('\n'+)'\0'*/
        char a_cLine [C_ucNbPrintedColumn], a_cLine2 [C_ucNbPrintedColumn];
    
        p_stMyMallocInfo = p_stMyDynInfo->d_stDynamicMallocInfo;
        if (ucSorted) fn_vSortMallocInfoTable (p_stMyMallocInfo, p_stMyDynInfo->ulNbDynamicMalloc);
 
        /* fill up a_HistoMalloc with '*' */
        for (ucI=0; ucI < C_ucNbColumnForHisto+1; ucI++){
                a_cHistoMalloc[ucI]= '*';
        }
 
        /* look for the maximum size*/
        for (ulI=0; ulI<p_stMyDynInfo->ulNbDynamicMalloc; ulI++, p_stMyMallocInfo++){
                ulLength = ((unsigned long)(p_stMyMallocInfo->p_cEndMalloc)) -  ((unsigned long)(p_stMyMallocInfo->p_cBeginMalloc)) + 1;
                if (ulLength>ulMaxSize) ulMaxSize = ulLength;
        }       
 
		*a_cLine='\n';
		Erm_M_GetModuleInformation(a_cLine+1, ucModuleId);
        sprintf (a_cLine+strlen(a_cLine),":\n");
        Mmg_fn_v_PrintInfoMalloc (a_cLine );
        Mmg_fn_v_PrintInfoMalloc (" The list of all Dynamic Mallocs\n");
        Mmg_fn_v_PrintInfoMalloc ("---------------------------------\n\n");
        /* print the map*/
        p_stMyMallocInfo = p_stMyDynInfo->d_stDynamicMallocInfo;
        for (ulI=0; ulI<p_stMyDynInfo->ulNbDynamicMalloc; ulI++, p_stMyMallocInfo++){
                /* the malloc*/
                ulLength = ((unsigned long)(p_stMyMallocInfo->p_cEndMalloc)) -  ((unsigned long) (p_stMyMallocInfo->p_cBeginMalloc)) + 1;
                sprintf (a_cLine, "Malloc -%d-\t: 0x%X->0x%X\t\t(%db; %.2fKb; %.2fMb)\n", 
                                ulI+1, (long)p_stMyMallocInfo->p_cBeginMalloc, (long)p_stMyMallocInfo->p_cEndMalloc, ulLength, (float)ulLength/1024, (float)ulLength/(1024*1024));
                if (ulMaxSize) ulLength = ulLength * C_ucNbColumnForHisto / ulMaxSize;
				else ulLength = 0;
                if (!ulLength) ulLength = 1;
                a_cHistoMalloc [ulLength] = '\n';
                a_cHistoMalloc [ulLength+1] = '\0';
                Mmg_fn_v_PrintInfoMalloc (a_cHistoMalloc);
                Mmg_fn_v_PrintInfoMalloc (a_cLine );
				/*lint -save -e701 : Shift left of signed quantity (int)*/
                sprintf (a_cLine2, "Total place\t: 0x%X->0x%X\t\t(%db; %.2fKb; %.2fMb)\n", 
                        (unsigned long)(p_stMyMallocInfo->p_cBeginMalloc - (C_ucMallocHeaderSize<<C_uwShiftAllocSize)),
                        (unsigned long)(p_stMyMallocInfo->p_cEndMalloc + (C_ucMallocFooterSize<<C_uwShiftAllocSize)),
                        (*(p_stMyMallocInfo->p_cBeginMalloc - (C_ucMallocHeaderSize<<C_uwShiftAllocSize)))<<C_uwShiftAllocSize,
                        (float)((*(p_stMyMallocInfo->p_cBeginMalloc - (C_ucMallocHeaderSize<<C_uwShiftAllocSize)))<<C_uwShiftAllocSize)/1024,
                        (float)((*(p_stMyMallocInfo->p_cBeginMalloc - (C_ucMallocHeaderSize<<C_uwShiftAllocSize)))<<C_uwShiftAllocSize)/(1024*1024) );
				/*lint -restore*/
                Mmg_fn_v_PrintInfoMalloc (a_cLine2);
                a_cHistoMalloc [ulLength+1] = '\n';
                a_cHistoMalloc [ulLength+2] = '\0';
                Mmg_fn_v_PrintInfoMalloc (a_cHistoMalloc);
                a_cHistoMalloc[ulLength++]= '*';/* reset  the Histogram fill up with '*'*/
                a_cHistoMalloc[ulLength++]= '*';/* reset  the Histogram fill up with '*'                */
                a_cHistoMalloc[ulLength]= '*';/* reset  the Histogram fill up with '*'*/
        }/* end of for of my malloc*/
}/*lint !e715: p_stMyDynInfo&szModuleName&ucSorted (line 1852) not referenced*/
#endif /*__DYNAMIC_MALLOC_ALLOWED__*/
#endif /*__DEBUG_MALLOC_MODE__*/
/* end of Mmg_fn_vPrintAllDynamicMalloc */
 
/* ##F#===================================================================================
NAME :          Mmg_fn_vPrintMapOfBlock
DESCRIPTION :   Print the map of static allocation for a block (only in debug mode)
INPUT :			Module Id
				Pointer on block info structure
				Block Id
				Flag to indicate that info must be sorted
=========================================================================================
CREATION : 06-11-97/Pierrick Crepy
=======================================================================================*/
void Mmg_fn_vPrintMapOfBlock (unsigned char ucModuleId, struct tdstBlockInfoPriv_ *p_stMyBlocksInfo, unsigned char ucBlockId, unsigned char ucSorted){
/*   --------------------*/
#ifdef __DEBUG_MALLOC_MODE__	
		struct tdstBlockInfoPriv_ *p_stMyBlockInfo = p_stMyBlocksInfo+ucBlockId;
        tdstMallocInfo * p_stMyMallocInfo;
        unsigned char ucI;
		unsigned long ulI;
        unsigned short uwCounterFree;
        unsigned long ulLength,ulMaxSize=0;
        char a_cHistoMalloc [C_ucNbColumnForHisto+3];/* +3 for '\n'+('\n'+)'\0'*/
        char a_cHistoFree [C_ucNbColumnForHisto+3];/* +3 for '\n'+('\n'+)'\0'*/
        char a_cLineEnd [C_ucNbColumnForHisto+2];/* +3 for '\n'+'\0'*/
        char a_cLine [C_ucNbPrintedColumn], a_cLine2 [C_ucNbPrintedColumn];
        
        unitAlloc * p_uaPtr;
    
 
#ifdef D_CheckSystemForBlockWithoutFree
		if (p_stMyBlockInfo->p_cFirstFree == C_FirstFreeValueForBlockWithoutFree){
			Mmg_M_UpdateLastError(E_uwMmgPbNoAvailableFunctionForBlockWithoutFree, NULL)
		}
#endif /*D_CheckSystemForBlockWithoutFree*/
 
        p_stMyMallocInfo = p_stMyBlockInfo->d_stMallocInfo;
    
        if (ucSorted) fn_vSortMallocInfoTable (p_stMyMallocInfo, p_stMyBlockInfo->ulNbMalloc);
 
        /* fill up a_HistoMalloc with '*', a_HistoMalloc with 'O' & a_lineEnd with '_'*/
        for (ucI=0; ucI < C_ucNbColumnForHisto+1; ucI++){
                a_cHistoMalloc[ucI]= '*';
                a_cHistoFree[ucI]= 'O';
                a_cLineEnd[ucI]='_';
        }
        a_cLineEnd [C_ucNbColumnForHisto]='\0';
 
        /* look for the maximum size*/
        for (ulI=0; ulI<p_stMyBlockInfo->ulNbMalloc; ulI++, p_stMyMallocInfo++){                
                ulLength = ((unsigned long)(p_stMyMallocInfo->p_cEndMalloc)) -  ((unsigned long)(p_stMyMallocInfo->p_cBeginMalloc)) + 1;
                if (ulLength>ulMaxSize) ulMaxSize = ulLength;
        }       
        /* max with free*/
        for (   p_uaPtr = (unitAlloc *) p_stMyBlockInfo->p_cFirstFree;
                        (p_uaPtr != (unitAlloc *)0) && (*(p_uaPtr +1) != (unitAlloc)0);/* Do not take the last free.*/
                        p_uaPtr = (unitAlloc *) *(p_uaPtr+1)/*go to next*/){
                if (((*p_uaPtr)<<C_uwShiftAllocSize) > (unitAlloc) ulMaxSize) ulMaxSize = (unsigned long) ((*p_uaPtr)<<C_uwShiftAllocSize);
        }
 
		*a_cLine='\n';
		Erm_M_GetModuleInformation(a_cLine+1, ucModuleId);
        sprintf (a_cLine+strlen(a_cLine),":\n");
        Mmg_fn_v_PrintInfoMalloc (a_cLine ); 
 
        sprintf (a_cLine2, "The list of all Static Mallocs of the block # %d\n", ucBlockId);
        Mmg_fn_v_PrintInfoMalloc (a_cLine2);
        Mmg_fn_v_PrintInfoMalloc ("---------------------------------------------------\n\n");
        /* print the map*/
        p_stMyMallocInfo = p_stMyBlockInfo->d_stMallocInfo;
        uwCounterFree = 0;
        p_uaPtr=(unitAlloc *) p_stMyBlockInfo->p_cFirstFree;
        for (ulI=0; ulI<p_stMyBlockInfo->ulNbMalloc; ulI++, p_stMyMallocInfo++){
                if ( (*(p_uaPtr+1) != (unitAlloc)0) && ( ((char *) p_uaPtr) < p_stMyMallocInfo->p_cBeginMalloc ) ){
                        /* we have a free before the malloc*/
                        uwCounterFree++;
                        ulLength = (unsigned long) ((*p_uaPtr) << C_uwShiftAllocSize) ;
                        sprintf (a_cLine, "Free -%d-\t: 0x%X->0x%X\t\t(%db; %.2fKb; %.2fMb)\n", 
                                        uwCounterFree, (unsigned long) p_uaPtr, (unsigned long)(((char *)(p_uaPtr+*p_uaPtr)) -1), 
                                        ulLength, (float)ulLength/1024, (float)ulLength/(1024*1024));
                        if (ulMaxSize) ulLength = ulLength * C_ucNbColumnForHisto / ulMaxSize;
						else ulLength = 0;
                        if (!ulLength) ulLength = 1;
                        a_cHistoFree [ulLength] = '\n';
                        a_cHistoFree [ulLength+1] = '\0';
                        Mmg_fn_v_PrintInfoMalloc (a_cHistoFree);
                        Mmg_fn_v_PrintInfoMalloc (a_cLine );                   
                        a_cHistoFree [ulLength+1] = '\n';
                        a_cHistoFree [ulLength+2] = '\0';
                        Mmg_fn_v_PrintInfoMalloc (a_cHistoFree);
                        a_cHistoFree[ulLength++]= 'O';/* reset  the Histofgram fill up with 'O'                 */
                        a_cHistoFree[ulLength++]= 'O';/* reset  the Histofgram fill up with 'O'                 */
                        a_cHistoFree[ulLength]= 'O';/* reset  the Histofgram fill up with 'O'                   */
                        p_uaPtr = (unitAlloc *) *(p_uaPtr +1); /* go to next*/
                }/* end of if of my free                */
 
                /* the malloc*/
                ulLength = ((unsigned long)(p_stMyMallocInfo->p_cEndMalloc)) -  ((unsigned long) (p_stMyMallocInfo->p_cBeginMalloc)) + 1;
                sprintf (a_cLine, "Malloc -%d-\t: 0x%X->0x%X\t\t(%db; %.2fKb; %.2fMb)\n", 
                                ulI+1, (unsigned long)(p_stMyMallocInfo->p_cBeginMalloc), (unsigned long)(p_stMyMallocInfo->p_cEndMalloc), ulLength, (float)ulLength/1024, (float)ulLength/(1024*1024));
                if (ulMaxSize) ulLength = ulLength * C_ucNbColumnForHisto / ulMaxSize;   
				else ulLength = 0;
                if (!ulLength) ulLength = 1;
                a_cHistoMalloc [ulLength] = '\n';
                a_cHistoMalloc [ulLength+1] = '\0';
                Mmg_fn_v_PrintInfoMalloc (a_cHistoMalloc);
                Mmg_fn_v_PrintInfoMalloc (a_cLine );
 
				/*lint -save -e790 :  Suspicious truncation, integral to float*/
				sprintf (a_cLine2, "Total place\t: 0x%X->0x%X\t\t(%db; %.2fKb; %.2fMb)\n", 
                        (unsigned long)(p_stMyMallocInfo->p_cBeginMalloc - (C_ucMallocHeaderSize<<C_uwShiftAllocSize)),
                        (unsigned long) (p_stMyMallocInfo->p_cEndMalloc + (C_ucMallocFooterSize<<C_uwShiftAllocSize)),
                        (*(unitAlloc *)(p_stMyMallocInfo->p_cBeginMalloc - (C_ucMallocHeaderSize<<C_uwShiftAllocSize)))<<C_uwShiftAllocSize,
                        (float)((*(unitAlloc *)(p_stMyMallocInfo->p_cBeginMalloc - (C_ucMallocHeaderSize<<C_uwShiftAllocSize)))<<C_uwShiftAllocSize)/1024,
                        (float)((*(unitAlloc *)(p_stMyMallocInfo->p_cBeginMalloc - (C_ucMallocHeaderSize<<C_uwShiftAllocSize)))<<C_uwShiftAllocSize)/(1024*1024) );          
				/*lint -restore*/
                Mmg_fn_v_PrintInfoMalloc (a_cLine2);           
                a_cHistoMalloc [ulLength+1] = '\n';
                a_cHistoMalloc [ulLength+2] = '\0';
                sprintf (a_cLine2, "%s\n\n", a_cHistoMalloc);
                Mmg_fn_v_PrintInfoMalloc (a_cHistoMalloc);
                a_cHistoMalloc[ulLength++]= '*';/* reset  the Histogram fill up with '*'*/
                a_cHistoMalloc[ulLength++]= '*';/* reset  the Histogram fill up with '*'*/
                a_cHistoMalloc[ulLength]= '*';/* reset  the Histogram fill up with '*'*/
        }/* end of for of my malloc*/
 
#ifdef __ADD_PLACE_FOR_DEBUG_INFORMATION__
        sprintf(a_cLine2, "%s\n", a_cLineEnd);
        Mmg_fn_v_PrintInfoMalloc (a_cLine2);             
 
        ulLength = (p_stMyBlockInfo->ulMaxNbStaticMalloc*(C_ucDebugInformationLoss<<C_uwShiftAllocSize));
        Mmg_M_BigBoundSize(ulLength, C_uwAllocSize);
 
        sprintf (a_cLine2, "Memory added for store the debug information:\t(%db; %.2fKb; %.2fMb)\n", ulLength, (float)ulLength/1024, (float)ulLength/(1024*1024));
        Mmg_fn_v_PrintInfoMalloc (a_cLine2);
 
        ulLength = (unsigned long) ( (p_stMyBlockInfo->ulNbMalloc))*(C_ucDebugInformationLoss<<C_uwShiftAllocSize);
        sprintf (a_cLine2, "Used added Memory :                          \t(%db; %.2fKb; %.2fMb) (%.2f%%)\n", ulLength, (float)ulLength/1024, (float)ulLength/(1024*1024), (float)ulLength/(p_stMyBlockInfo->ulMaxNbStaticMalloc*(C_ucDebugInformationLoss<<C_uwShiftAllocSize))*100);
        Mmg_fn_v_PrintInfoMalloc (a_cLine2);
 
        if (ulLength < (p_stMyBlockInfo->ulMaxNbStaticMalloc*(C_ucDebugInformationLoss<<C_uwShiftAllocSize))){
                ulLength = (unsigned long) (p_stMyBlockInfo->ulMaxNbStaticMalloc*(C_ucDebugInformationLoss<<C_uwShiftAllocSize)) - ulLength;
                sprintf (a_cLine2, "Remain of added Memory :                     \t(%db; %.2fKb; %.2fMb)\n", ulLength, (float)ulLength/1024, (float)ulLength/(1024*1024));
                Mmg_fn_v_PrintInfoMalloc (a_cLine2);
        }
        else{
                Mmg_fn_v_PrintInfoMalloc ("\tThe Memory added for store the debug information is FULL !!\n");
        }
        
        sprintf(a_cLine2, "%s\n", a_cLineEnd);
        Mmg_fn_v_PrintInfoMalloc (a_cLine2);             
#endif /*__ADD_PLACE_FOR_DEBUG_INFORMATION__*/
 
        /* print the remainder of the free space.*/
        if (*(p_uaPtr+1) == (unitAlloc)0){
                ulLength = (unsigned long) ((*p_uaPtr)<<C_uwShiftAllocSize );
                sprintf(a_cLine2, "%s\n", a_cLineEnd);
                Mmg_fn_v_PrintInfoMalloc (a_cLine2);
                sprintf (a_cLine2, "Remain with memory added for debug information     \t: 0x%X->0x%X\n", 
                                        (unsigned long)p_uaPtr, (unsigned long)(((char *)(p_uaPtr+*p_uaPtr)) -1));
                Mmg_fn_v_PrintInfoMalloc (a_cLine2);
                sprintf (a_cLine2, "\t(%db; %.2fKb; %.2fMb)\n", 
                                        ulLength, (float)ulLength/1024, (float)ulLength/(1024*1024));
                Mmg_fn_v_PrintInfoMalloc (a_cLine2);
 
                ulLength -= (p_stMyBlockInfo->ulMaxNbStaticMalloc*(C_ucDebugInformationLoss<<C_uwShiftAllocSize));
                ulLength += ( (p_stMyBlockInfo->ulNbMalloc)) * (C_ucDebugInformationLoss<<C_uwShiftAllocSize);
				if (ulLength != 0){
					sprintf (a_cLine2, "(pessimistic)Estimated remain for other allocations \t: 0x%X->0x%X\n", 
											(unsigned long)p_uaPtr, (unsigned long)(((char *)p_uaPtr)+ulLength-1));
				}
				else{
					sprintf (a_cLine2, "(pessimistic)Estimated remain for other allocations ", 
											(unsigned long)p_uaPtr, (unsigned long)(((char *)p_uaPtr)+ulLength-1));
				}
                Mmg_fn_v_PrintInfoMalloc (a_cLine2);
                sprintf (a_cLine2, "\t(%db; %.2fKb; %.2fMb)\n", 
                                        ulLength, (float)ulLength/1024, (float)ulLength/(1024*1024));
                Mmg_fn_v_PrintInfoMalloc (a_cLine2);
                sprintf(a_cLine2, "%s\n\n", a_cLineEnd);
                Mmg_fn_v_PrintInfoMalloc (a_cLine2);
        }
#endif /*__DEBUG_MALLOC_MODE__*/
}/*lint !e715 p_stMyBlockInfo&ucBlockId&szModuleName& (line 1916) not referenced*/
/* end of Mmg_fn_vPrintMapOfBlock*/
 
/* ##F#===================================================================================
NAME :          Mmg_fn_vPrintDebugMapOfBlock
DESCRIPTION :   Print the map of static allocation for a block (only in debug mode)
INPUT :			Module Id
				Pointer on block info structure
				Block Id
=========================================================================================
CREATION : 06-11-97/Pierrick Crepy
=======================================================================================*/
/* Modif#5 : new function*/
void Mmg_fn_vPrintDebugMapOfBlock (unsigned char ucModuleId, struct tdstBlockInfoPriv_ *p_stMyBlocksInfo, unsigned char ucBlockId){
/*   --------------------*/
#ifdef __DEBUG_MALLOC_MODE__
		struct tdstBlockInfoPriv_ *p_stMyBlockInfo = p_stMyBlocksInfo+ucBlockId;
        unsigned char ucI;
        unsigned long ulI;
        unsigned short uwCounterFree;
        unsigned long ulLength,ulMaxSize=0;
        char a_cHistoMalloc [C_ucNbColumnForHisto+3];/* +3 for '\n'+('\n'+)'\0'*/
        char a_cHistoFree [C_ucNbColumnForHisto+3];/* +3 for '\n'+('\n'+)'\0'*/
        char a_cLineEnd [C_ucNbColumnForHisto+2];/* +3 for '\n'+'\0'*/
        char a_cLine [C_ucNbPrintedColumn], a_cLine2 [C_ucNbPrintedColumn];
        
        unitAlloc * p_uaPtr;
		
        /* fill up a_HistoMalloc with '*', a_HistoMalloc with 'O' & a_lineEnd with '_'*/
        for (ucI=0; ucI < C_ucNbColumnForHisto+1; ucI++){
                a_cHistoMalloc[ucI]= '*';
                a_cHistoFree[ucI]= 'O';
                a_cLineEnd[ucI]='_';
        }
        a_cLineEnd [C_ucNbColumnForHisto]='\0';
 
        /* look for the maximum size of malloc or free*/
        ulI=0;
		p_uaPtr=(unitAlloc *)p_stMyBlockInfo->p_cBeginBlock;
		while (p_uaPtr<(unitAlloc *)p_stMyBlockInfo->p_cEndBlock){
			if (*(p_uaPtr+1) == C_uaBeginKey){
				/* it's a malloc*/
				ulLength = ((*p_uaPtr) - C_ucMallocHeaderSize - C_ucMallocFooterSize);
				ulLength <<= C_uwShiftAllocSize;
                if (ulLength>ulMaxSize) ulMaxSize = ulLength;			
				p_uaPtr += (*p_uaPtr);
				ulI++;
			}
			else {
				/* it's a free*/
				if ((p_uaPtr != (unitAlloc *)0) && (*(p_uaPtr +1) != (unitAlloc)0)){/* Do not take the last free.*/
					ulLength = (*p_uaPtr);
					ulLength <<= C_uwShiftAllocSize;					
					if (ulLength > ulMaxSize) ulMaxSize = ulLength;
				}
				else {
					break;/* this is the last free then we go out of the while with p_uaPtr pointed on the last free*/
				}
				p_uaPtr += (*p_uaPtr);
			}
                
        }/*end of while*/
		if (ulI != p_stMyBlockInfo->ulNbMalloc){
			/*p_uaPtr = (unitAlloc)ulI/0; // just for allowed a breack point*/
		}
 
		*a_cLine = '\n';
		Erm_M_GetModuleInformation(a_cLine+1, ucModuleId);
        sprintf (a_cLine+strlen(a_cLine),":\n");
        Mmg_fn_v_PrintInfoMalloc (a_cLine ); 
 
        sprintf (a_cLine2, "The Debug list of all Static Mallocs of the block # %d\n", ucBlockId);
        Mmg_fn_v_PrintInfoMalloc (a_cLine2);
        Mmg_fn_v_PrintInfoMalloc ("---------------------------------------------------\n\n");
        /* print the map*/
        uwCounterFree = 0;
        ulI=0;
		p_uaPtr=(unitAlloc *)p_stMyBlockInfo->p_cBeginBlock;
		while (p_uaPtr<(unitAlloc *)p_stMyBlockInfo->p_cEndBlock){
			if (*(p_uaPtr+1) == C_uaBeginKey){
				/* it's a malloc*/
				ulLength = ((*p_uaPtr) - C_ucMallocHeaderSize - C_ucMallocFooterSize)<< C_uwShiftAllocSize;
 
                sprintf (a_cLine, "Malloc -%d-\t: 0x%X->0x%X\t\t(%db; %.2fKb; %.2fMb)\n", 
                                ulI+1, (unsigned long)(p_uaPtr+C_ucMallocHeaderSize), ((unsigned long)(p_uaPtr+*p_uaPtr-C_ucMallocFooterSize))-1, ulLength, (float)ulLength/1024, (float)ulLength/(1024*1024));
                if (ulMaxSize) ulLength = ulLength * C_ucNbColumnForHisto / ulMaxSize;   
				else ulLength = 0;
                if (!ulLength) ulLength = 1;
                a_cHistoMalloc [ulLength] = '\n';
                a_cHistoMalloc [ulLength+1] = '\0';
                Mmg_fn_v_PrintInfoMalloc (a_cHistoMalloc);
                Mmg_fn_v_PrintInfoMalloc (a_cLine );
                
				
				/*lint -save -e790 :  Suspicious truncation, integral to float*/
				sprintf (a_cLine2, "Total place\t: 0x%X->0x%X\t\t(%db; %.2fKb; %.2fMb)\n", 
                        (unsigned long)(p_uaPtr),
                        ((unsigned long) (p_uaPtr + *p_uaPtr))-1,
                        (*p_uaPtr)<<C_uwShiftAllocSize,
                        (float)((*p_uaPtr)<<C_uwShiftAllocSize)/1024,
                        (float)((*p_uaPtr)<<C_uwShiftAllocSize)/(1024*1024) );          
				/*lint -restore*/
                Mmg_fn_v_PrintInfoMalloc (a_cLine2);           
                a_cHistoMalloc [ulLength+1] = '\n';
                a_cHistoMalloc [ulLength+2] = '\0';
                sprintf (a_cLine2, "%s\n\n", a_cHistoMalloc);
                Mmg_fn_v_PrintInfoMalloc (a_cHistoMalloc);
                a_cHistoMalloc[ulLength++]= '*';/* reset  the Histogram fill up with '*'*/
                a_cHistoMalloc[ulLength++]= '*';/* reset  the Histogram fill up with '*'*/
                a_cHistoMalloc[ulLength]= '*';/* reset  the Histogram fill up with '*'*/
 
				ulI++;
				p_uaPtr += (*p_uaPtr);
			}
			else {
				/* it's a free*/
				if ((p_uaPtr != (unitAlloc *)0) && (*(p_uaPtr +1) != (unitAlloc)0)){/* Do not take the last free.*/
 
                    uwCounterFree++;
                    ulLength = (unsigned long) ((*p_uaPtr) << C_uwShiftAllocSize) ;
                    sprintf (a_cLine, "Free -%d-\t: 0x%X->0x%X\t\t(%db; %.2fKb; %.2fMb)\n", 
                                    uwCounterFree, (unsigned long) p_uaPtr, (unsigned long)(((char *)(p_uaPtr+*p_uaPtr)) -1), 
                                    ulLength, (float)ulLength/1024, (float)ulLength/(1024*1024));
                    if (ulMaxSize) ulLength = ulLength * C_ucNbColumnForHisto / ulMaxSize;
					else ulLength = 0;
                    if (!ulLength) ulLength = 1;
                    a_cHistoFree [ulLength] = '\n';
                    a_cHistoFree [ulLength+1] = '\0';
                    Mmg_fn_v_PrintInfoMalloc (a_cHistoFree);
                    Mmg_fn_v_PrintInfoMalloc (a_cLine );                   
                    a_cHistoFree [ulLength+1] = '\n';
                    a_cHistoFree [ulLength+2] = '\0';
                    Mmg_fn_v_PrintInfoMalloc (a_cHistoFree);
                    a_cHistoFree[ulLength++]= 'O';/* reset  the Histofgram fill up with 'O'                 */
                    a_cHistoFree[ulLength++]= 'O';/* reset  the Histofgram fill up with 'O'                 */
                    a_cHistoFree[ulLength]= 'O';/* reset  the Histofgram fill up with 'O'                   */
				}
				else {
					break;/* this is the last free then we go out of the while with p_uaPtr pointed on the last free*/
				}
				p_uaPtr += (*p_uaPtr);
			}
                
        }/*end of while*/
 
#ifdef __ADD_PLACE_FOR_DEBUG_INFORMATION__
        sprintf(a_cLine2, "%s\n", a_cLineEnd);
        Mmg_fn_v_PrintInfoMalloc (a_cLine2);             
 
        ulLength = (p_stMyBlockInfo->ulMaxNbStaticMalloc*(C_ucDebugInformationLoss<<C_uwShiftAllocSize));
        Mmg_M_BigBoundSize(ulLength, C_uwAllocSize);
 
        sprintf (a_cLine2, "Memory added for store the debug information:\t(%db; %.2fKb; %.2fMb)\n", ulLength, (float)ulLength/1024, (float)ulLength/(1024*1024));
        Mmg_fn_v_PrintInfoMalloc (a_cLine2);
 
        ulLength = (unsigned long) ( (p_stMyBlockInfo->ulNbMalloc))*(C_ucDebugInformationLoss<<C_uwShiftAllocSize);
        sprintf (a_cLine2, "Used added Memory :                          \t(%db; %.2fKb; %.2fMb) (%.2f%%)\n", ulLength, (float)ulLength/1024, (float)ulLength/(1024*1024), (float)ulLength/(p_stMyBlockInfo->ulMaxNbStaticMalloc*(C_ucDebugInformationLoss<<C_uwShiftAllocSize))*100);
        Mmg_fn_v_PrintInfoMalloc (a_cLine2);
 
        if (ulLength < (p_stMyBlockInfo->ulMaxNbStaticMalloc*(C_ucDebugInformationLoss<<C_uwShiftAllocSize))){
                ulLength = (unsigned long) (p_stMyBlockInfo->ulMaxNbStaticMalloc*(C_ucDebugInformationLoss<<C_uwShiftAllocSize)) - ulLength;
                sprintf (a_cLine2, "Remain of added Memory :                     \t(%db; %.2fKb; %.2fMb)\n", ulLength, (float)ulLength/1024, (float)ulLength/(1024*1024));
                Mmg_fn_v_PrintInfoMalloc (a_cLine2);
        }
        else{
                Mmg_fn_v_PrintInfoMalloc ("\tThe Memory added for store the debug information is FULL !!\n");
        }
        
        sprintf(a_cLine2, "%s\n", a_cLineEnd);
        Mmg_fn_v_PrintInfoMalloc (a_cLine2);             
#endif /*__ADD_PLACE_FOR_DEBUG_INFORMATION__*/
 
        /* print the remainder of the free space.*/
        if (*(p_uaPtr+1) == (unitAlloc)0){
                ulLength = (unsigned long) ((*p_uaPtr)<<C_uwShiftAllocSize );
                sprintf(a_cLine2, "%s\n", a_cLineEnd);
                Mmg_fn_v_PrintInfoMalloc (a_cLine2);
                sprintf (a_cLine2, "Remain with memory added for debug information     \t: 0x%X->0x%X\n", 
                                        (unsigned long)p_uaPtr, (unsigned long)(((char *)(p_uaPtr+*p_uaPtr)) -1));
                Mmg_fn_v_PrintInfoMalloc (a_cLine2);
                sprintf (a_cLine2, "\t(%db; %.2fKb; %.2fMb)\n", 
                                        ulLength, (float)ulLength/1024, (float)ulLength/(1024*1024));
                Mmg_fn_v_PrintInfoMalloc (a_cLine2);
                ulLength -= (p_stMyBlockInfo->ulMaxNbStaticMalloc*(C_ucDebugInformationLoss<<C_uwShiftAllocSize));
                ulLength += ( (p_stMyBlockInfo->ulNbMalloc)) * (C_ucDebugInformationLoss<<C_uwShiftAllocSize);
				if (ulLength != 0){
					sprintf (a_cLine2, "(pessimistic)Estimated remain for other allocations \t: 0x%X->0x%X\n", 
											(unsigned long)p_uaPtr, (unsigned long)(((char *)p_uaPtr)+ulLength-1));
				}
				else{
					sprintf (a_cLine2, "(pessimistic)Estimated remain for other allocations ", 
											(unsigned long)p_uaPtr, (unsigned long)(((char *)p_uaPtr)+ulLength-1));
				}
                Mmg_fn_v_PrintInfoMalloc (a_cLine2);
                sprintf (a_cLine2, "\t(%db; %.2fKb; %.2fMb)\n", 
                                        ulLength, (float)ulLength/1024, (float)ulLength/(1024*1024));
                Mmg_fn_v_PrintInfoMalloc (a_cLine2);
                sprintf(a_cLine2, "%s\n\n", a_cLineEnd);
                Mmg_fn_v_PrintInfoMalloc (a_cLine2);
        }
#endif /*__DEBUG_MALLOC_MODE__*/
}/*lint !e715 p_stMyBlockInfo&ucBlockId&szModuleName& (line 1916) not referenced*/
/* end of Mmg_fn_vPrintDebugMapOfBlock*/
 
/* ##-########################### 
   ## Management of Statistic
   ############################## */
/* ##F#===================================================================================
NAME :          Mmg_fn_vPrintBlockStatistic 
DESCRIPTION :   Print statistic on a block  (only in debug mode)
INPUT :			Module Id
				Pointer on block info structure
				Block Id
=========================================================================================
CREATION : 06-11-97/Pierrick Crepy
=======================================================================================*/
void Mmg_fn_vPrintBlockStatistic (unsigned char ucModuleId, struct tdstBlockInfoPriv_ *p_stMyBlocksInfo, unsigned char ucBlockId){
/*   -----------------------*/
#ifdef __DEBUG_MALLOC_MODE__
		struct tdstBlockInfoPriv_ *p_stMyBlockInfo = p_stMyBlocksInfo+ucBlockId;
        tdstMallocInfo * p_stMyMallocInfo;
        unsigned short uwI;
		unsigned long ulI;
        unsigned char ucPtr;
        unsigned long ulLargestMalloc=0, ulSmallestMalloc=0xffffffff, ulLargestFree=0, ulSmallestFree=0xffffffff;
        unsigned long ulIdLargestMalloc=0xffffffff,ulIdSmallestMalloc=0xffffffff;
        unsigned char ucPrintedLength;
        unsigned long ulMaxPrint;
        unsigned long ulDebugInfoRemain;
        unsigned short uwCounterFree;
        unsigned long ulLengthMalloc=0, ulLengthFree=0, ulLength;
        char a_cMap [C_ucNbColumnForHisto+3];/* +3 for '\n'+(\n)+'\0'*/
        char a_cLine [C_ucNbPrintedColumn];
        
        unitAlloc * p_uaPtr;/* used for scan the free space. After scaning the all the free list, p_uaPtr points at the last free*/
    
 
#ifdef D_CheckSystemForBlockWithoutFree
		if (p_stMyBlockInfo->p_cFirstFree == C_FirstFreeValueForBlockWithoutFree){
			Mmg_M_UpdateLastError(E_uwMmgPbNoAvailableFunctionForBlockWithoutFree, NULL)
		}
#endif /*D_CheckSystemForBlockWithoutFree*/
 
        /* look for the maximum & mimimum size of all the mallocs*/
        p_stMyMallocInfo = p_stMyBlockInfo->d_stMallocInfo;
        for (ulI=0; ulI<p_stMyBlockInfo->ulNbMalloc; ulI++, p_stMyMallocInfo++){                
                ulLength = (unsigned long)(*((unitAlloc *)p_stMyMallocInfo->p_cBeginMalloc - C_ucMallocHeaderSize));
                ulLengthMalloc += ulLength;
                if (ulLength>ulLargestMalloc){
                        ulLargestMalloc = ulLength;
                        ulIdLargestMalloc = ulI;
                }
                if (ulLength<ulSmallestMalloc){
                        ulSmallestMalloc = ulLength;
                        ulIdSmallestMalloc = ulI;
                }
        }       
        ulLargestMalloc -= C_ucDebugInformationLoss;
        ulSmallestMalloc -= C_ucDebugInformationLoss;
 
        /* look for the maximum & mimimum size of all the frees except the last free space.*/
        uwCounterFree = 0;
        for (   p_uaPtr = (unitAlloc *) p_stMyBlockInfo->p_cFirstFree;
                        (p_uaPtr != (unitAlloc *)0) && (*(p_uaPtr +1) != (unitAlloc)0);/* Do not take the last free.*/
                        p_uaPtr = (unitAlloc *) *(p_uaPtr+1)/*go to next*/){
                uwCounterFree++;
                ulLengthFree += (*p_uaPtr);
                if (*p_uaPtr > (unitAlloc) ulLargestFree) ulLargestFree = (unsigned long) (*p_uaPtr);
                if (*p_uaPtr < (unitAlloc) ulSmallestFree) ulSmallestFree = (unsigned long) (*p_uaPtr);
        }
 
#ifdef __ADD_PLACE_FOR_DEBUG_INFORMATION__      
        ulDebugInfoRemain = (p_stMyBlockInfo->ulMaxNbStaticMalloc*(C_ucDebugInformationLoss<<C_uwShiftAllocSize));
        Mmg_M_BigBoundSize(ulDebugInfoRemain, C_uwAllocSize);
		ulDebugInfoRemain >>= C_uwShiftAllocSize;/* convert into unitAlloc*/
        if ( ulDebugInfoRemain > (unsigned long)((p_stMyBlockInfo->ulNbMalloc )*C_ucDebugInformationLoss) ){
                ulDebugInfoRemain = ulDebugInfoRemain - (unsigned long)((p_stMyBlockInfo->ulNbMalloc )*C_ucDebugInformationLoss);
				/* ulDebugInfoRemain = remain for debug information in UnitAlloc*/
				/*                                                  -------------*/
        }
        else ulDebugInfoRemain = 0;
#else /*__ADD_PLACE_FOR_DEBUG_INFORMATION__*/
        ulDebugInfoRemain = 0;
#endif /*__ADD_PLACE_FOR_DEBUG_INFORMATION__*/
 
        /*print the debug map & information*/
        ulMaxPrint = ulLengthFree + ulLengthMalloc + (*p_uaPtr)/*the full real last free*/ - ulDebugInfoRemain;/*lint !e613: Possible use of null pointer (p_uaPtr)*/
 
        *a_cLine = '\n';
		Erm_M_GetModuleInformation(a_cLine+1, ucModuleId);
        sprintf (a_cLine+strlen(a_cLine),":\n");
        Mmg_fn_v_PrintInfoMalloc (a_cLine ); 
 
        Mmg_fn_v_PrintInfoMalloc ("=====================================\n");
        sprintf (a_cLine," Statistics of the static block #%d:\n", ucBlockId);
        Mmg_fn_v_PrintInfoMalloc (a_cLine);
        Mmg_fn_v_PrintInfoMalloc ("=====================================\n");
 
#ifdef __ADD_PLACE_FOR_DEBUG_INFORMATION__
        ulLength = (unsigned long) p_stMyBlockInfo->p_cEndBlock - (unsigned long) p_stMyBlockInfo->p_cBeginBlock + 1 - (p_stMyBlockInfo->ulMaxNbStaticMalloc*(C_ucDebugInformationLoss<<C_uwShiftAllocSize));
        sprintf (a_cLine, "\t-Usefull size (without the 'AddedDebugMemory'): 0x%X->0x%X\t(%db; %.2fKb; %.2fMb)\n", (unsigned long)(p_stMyBlockInfo->p_cBeginBlock), (unsigned long)(p_stMyBlockInfo->p_cEndBlock), ulLength, (float)ulLength/1024, (float)ulLength/(1024*1024));
        Mmg_fn_v_PrintInfoMalloc (a_cLine);
		ulLength = (unsigned long) (p_stMyBlockInfo->ulMaxNbStaticMalloc*(C_ucDebugInformationLoss<<C_uwShiftAllocSize));
        sprintf (a_cLine, "\t-Size for the 'AddedDebugMemory': 0x%X->0x%X\t\t(%db; %.2fKb; %.2fMb)\n", (unsigned long)(p_stMyBlockInfo->p_cBeginBlock), (unsigned long)(p_stMyBlockInfo->p_cEndBlock), ulLength, (float)ulLength/1024, (float)ulLength/(1024*1024));
        Mmg_fn_v_PrintInfoMalloc (a_cLine);
        sprintf (a_cLine, "\t-The 'AddedDebugMemory' correspond to %d allocations\n", p_stMyBlockInfo->ulMaxNbStaticMalloc);
        Mmg_fn_v_PrintInfoMalloc (a_cLine);
        sprintf (a_cLine, "\t-There are %d alloactions used now,i.e %.2f%% of the 'AddedDebugMemory'\n", 
			(p_stMyBlockInfo->ulNbMalloc),
			(float)((p_stMyBlockInfo->ulNbMalloc)*100/ p_stMyBlockInfo->ulMaxNbStaticMalloc) );
        Mmg_fn_v_PrintInfoMalloc (a_cLine);		
#endif /*__ADD_PLACE_FOR_DEBUG_INFORMATION__*/
 
        ulLength = (unsigned long) p_stMyBlockInfo->p_cEndBlock - (unsigned long) p_stMyBlockInfo->p_cBeginBlock + 1;
        sprintf (a_cLine, "\t-The full size: 0x%X->0x%X\t\t(%db; %.2fKb; %.2fMb)\n", (unsigned long)(p_stMyBlockInfo->p_cBeginBlock), (unsigned long)(p_stMyBlockInfo->p_cEndBlock), ulLength, (float)ulLength/1024, (float)ulLength/(1024*1024)); 
        Mmg_fn_v_PrintInfoMalloc (a_cLine);
        if ((ulLength-(ulDebugInfoRemain<<C_uwShiftAllocSize))){
			sprintf (a_cLine, "\t-The maximum address is 0x%X (with %d allocations & %d frees), %.2f%% of all the block has been used\n", (unsigned long)(p_stMyBlockInfo->p_cMaxMem), p_stMyBlockInfo->ulCountMallocBeforeMaxMem, p_stMyBlockInfo->ulCountFreeBeforeMaxMem, 
					(float)((unsigned long) p_stMyBlockInfo->p_cMaxMem - (unsigned long) p_stMyBlockInfo->p_cBeginBlock)*100/(ulLength-(ulDebugInfoRemain<<C_uwShiftAllocSize))
					);/*lint !e790: Suspicious truncation, integral to float*/
		}
		else
			sprintf (a_cLine, "\t-The maximum address is 0x%X (with %d allocations & %d frees)\n",
				(unsigned long)(p_stMyBlockInfo->p_cMaxMem),
				p_stMyBlockInfo->ulCountMallocBeforeMaxMem,
				p_stMyBlockInfo->ulCountFreeBeforeMaxMem);
        Mmg_fn_v_PrintInfoMalloc (a_cLine);
        sprintf (a_cLine, "\t-Address of the first Free Space: 0x%X\n",(unsigned long) (p_stMyBlockInfo->p_cFirstFree));
        Mmg_fn_v_PrintInfoMalloc (a_cLine);
        sprintf (a_cLine, "\t-%d requested reallocations\n",p_stMyBlockInfo->ulNbTotalRealloc);
        Mmg_fn_v_PrintInfoMalloc (a_cLine);
 
        
        /* compute the general Map */
        /* -----------------------*/
        /*---------------------------*/
        /* the unallocated free space */
        /*---------------------------*/
        if (ulMaxPrint) ucPrintedLength = (unsigned char) (ulLengthFree * C_ucNbColumnForHisto / ulMaxPrint);   
		else ucPrintedLength  = 0;
        if ((ulLengthFree) && (ucPrintedLength == 0)) ucPrintedLength=1;
        for (uwI=0; uwI < ucPrintedLength; uwI++){
                a_cMap[uwI]='-';
        }
        ucPtr = (unsigned char) uwI;
        /************************************/
        /* the allocated space without loss*/
        /************************************/
        ulLengthMalloc -= (p_stMyBlockInfo->ulNbMalloc*C_ucDebugInformationLoss); /* loss*/
		if (ulMaxPrint){
			ucPrintedLength = (unsigned char)(
					ulLengthMalloc 
					* C_ucNbColumnForHisto / ulMaxPrint);   
		}
		else ucPrintedLength =0;
        if ((ulLengthMalloc) && (ucPrintedLength == 0)) ucPrintedLength=1;
        for (uwI=0; uwI < ucPrintedLength; uwI++){
                a_cMap[ucPtr + uwI]='*';
        }
        ucPtr += (unsigned char) uwI;
        /*+++++++++++++++++++++++++++++*/
        /* the loss of allocated & free space*/
        /*+++++++++++++++++++++++++++++*/
		if (ulMaxPrint){
			ucPrintedLength =(unsigned char)((p_stMyBlockInfo->ulNbMalloc )*C_ucDebugInformationLoss /* loss*/
					* C_ucNbColumnForHisto / ulMaxPrint);   
		}
		else ucPrintedLength = 0;
        if ((ulLengthMalloc) && (ucPrintedLength == 0)) ucPrintedLength=1;
        for (uwI=0; uwI < ucPrintedLength; uwI++){
                a_cMap[ucPtr + uwI]='+';
        }
        ucPtr += (unsigned char) uwI;
 
        /*OOOOOOOOOOOOOOOO*/
        /* the last first*/
        /*OOOOOOOOOOOOOOOO*/
        for (uwI=ucPtr; uwI < C_ucNbColumnForHisto; uwI++){
                a_cMap[uwI]='O';
        }
        a_cMap[uwI]='\n';
        a_cMap[uwI+1]='\0';     
 
        /* print the general Map        */
#ifdef __ADD_PLACE_FOR_DEBUG_INFORMATION__
        Mmg_fn_v_PrintInfoMalloc ("\n===================================================================\n");
        Mmg_fn_v_PrintInfoMalloc ("= The General Map of the memory (without any 'AddedDebugMemory'): =\n");     
        Mmg_fn_v_PrintInfoMalloc ("===================================================================\n\n");
#else /*__ADD_PLACE_FOR_DEBUG_INFORMATION__*/
        Mmg_fn_v_PrintInfoMalloc ("\n==================================\n");
        Mmg_fn_v_PrintInfoMalloc ("= The General Map of the memory: =\n");     
        Mmg_fn_v_PrintInfoMalloc ("==================================\n\n");
#endif /*__ADD_PLACE_FOR_DEBUG_INFORMATION__*/
 
        Mmg_fn_v_PrintInfoMalloc (a_cMap);
        Mmg_fn_v_PrintInfoMalloc (a_cMap);
        Mmg_fn_v_PrintInfoMalloc (a_cMap);
        
 
 
        ulMaxPrint = M_Max(ulLengthFree, ulLengthMalloc);
        ulMaxPrint = M_Max(ulMaxPrint, (*p_uaPtr) - ulDebugInfoRemain);/*lint !e613: Possible use of null pointer (p_uaPtr)*/
 
        Mmg_fn_v_PrintInfoMalloc ("\n=========================\n");
        Mmg_fn_v_PrintInfoMalloc ("= Legend & Explanation: =\n");
        Mmg_fn_v_PrintInfoMalloc ("=========================\n\n");
        /*----------------------------*/
        /* the unallocated free space */
        /*----------------------------*/
        if (ulMaxPrint) ucPrintedLength = (unsigned char)(ulLengthFree * C_ucNbColumnForHisto / ulMaxPrint);
		else ulLengthFree =0;
        if (ucPrintedLength == 0) ucPrintedLength=1;
        for (uwI=0; uwI < ucPrintedLength; uwI++){
                a_cMap[uwI]='-';
        }
        a_cMap[uwI]='\n';
        a_cMap[uwI+1]='\0';     
        Mmg_fn_v_PrintInfoMalloc (a_cMap);
        Mmg_fn_v_PrintInfoMalloc ("Free Unallocated space:\n");
        Mmg_fn_v_PrintInfoMalloc (a_cMap);
        ulLengthFree <<= C_uwShiftAllocSize;
        sprintf (a_cLine, "\t-Request:%d; current:%d; size :    \t%db (%.2fKb; %.2fMb)\n",p_stMyBlockInfo->ulNbTotalFree, uwCounterFree, ulLengthFree, (float)ulLengthFree / 1024, (float)ulLengthFree / (1024*1024));
        Mmg_fn_v_PrintInfoMalloc (a_cLine);
 
		if (uwCounterFree > 0){/* i.e ulLargestFree > 0*/
			ulLargestFree <<= C_uwShiftAllocSize;
			sprintf (a_cLine, "\t-Size of the largest Free:           \t%db (%.2fKb; %.2fMb)\n", ulLargestFree, (float)ulLargestFree/ 1024, (float)ulLargestFree/ (1024*1024));
			Mmg_fn_v_PrintInfoMalloc (a_cLine);
			ulSmallestFree <<= C_uwShiftAllocSize;
			sprintf (a_cLine, "\t-Size of the smallest Free:          \t%db (%.2fKb; %.2fMb)\n", ulSmallestFree, (float)ulSmallestFree/ 1024, (float)ulSmallestFree/ (1024*1024));
			Mmg_fn_v_PrintInfoMalloc (a_cLine);
			if (uwCounterFree){
				sprintf (a_cLine, "\t-Average size of Free space:         \t%db (%.2fKb; %.2fMb)\n", ulLengthFree/uwCounterFree, ((float)ulLengthFree/(float)uwCounterFree)/ 1024, ((float)ulLengthFree/(float)uwCounterFree)/ (1024*1024));
				Mmg_fn_v_PrintInfoMalloc (a_cLine);
			}
		}
 
        a_cMap[uwI+1]='\n';
        a_cMap[uwI+2]='\0';     
        Mmg_fn_v_PrintInfoMalloc (a_cMap);
        ulLengthFree >>= C_uwShiftAllocSize; /* restore the unitAlloc unit*/
 
        /************************************/
        /* the allocated space without loss*/
        /************************************/
		if (ulMaxPrint){
			ucPrintedLength = (unsigned char)(
					ulLengthMalloc 
					* C_ucNbColumnForHisto / ulMaxPrint);   
		}
		else ucPrintedLength = 0;
        if (ucPrintedLength == 0) ucPrintedLength=1;
        for (uwI=0; uwI < ucPrintedLength; uwI++){
                a_cMap[uwI]='*';
        }
        a_cMap[uwI]='\n';
        a_cMap[uwI+1]='\0';     
        Mmg_fn_v_PrintInfoMalloc (a_cMap);
        Mmg_fn_v_PrintInfoMalloc ("Allocated space without loss (but with the field 'size of malloc'):\n");
        Mmg_fn_v_PrintInfoMalloc (a_cMap);
        ulLengthMalloc <<= C_uwShiftAllocSize;
        sprintf (a_cLine, "\t-Request:%d; current:%d; size :    \t%db (%.2fKb; %.2fMb)\n",p_stMyBlockInfo->ulNbTotalMalloc, p_stMyBlockInfo->ulNbMalloc, ulLengthMalloc, (float)ulLengthMalloc / 1024, (float)ulLengthMalloc / (1024*1024));
        Mmg_fn_v_PrintInfoMalloc (a_cLine);
 
		if (ulLargestMalloc > 0){/* i.e p_stMyBlockInfo->ulNbTotalMalloc >0*/
			ulLargestMalloc <<= C_uwShiftAllocSize;
			sprintf (a_cLine, "\t-The Largest Allocation:             \t%db (%.2fKb; %.2fMb)\n", ulLargestMalloc, (float)ulLargestMalloc/ 1024, (float)ulLargestMalloc/ (1024*1024));
			Mmg_fn_v_PrintInfoMalloc (a_cLine);
			ulSmallestMalloc <<= C_uwShiftAllocSize;
			sprintf (a_cLine, "\t-The Smallest Allocation:            \t%db (%.2fKb; %.2fMb)\n", ulSmallestMalloc, (float)ulSmallestMalloc/ 1024, (float)ulSmallestMalloc/ (1024*1024));
			Mmg_fn_v_PrintInfoMalloc (a_cLine);
			if (p_stMyBlockInfo->ulNbMalloc){
				sprintf (a_cLine, "\t-The average Allocation:             \t%db (%.2fKb; %.2fMb)\n", ulLengthMalloc/p_stMyBlockInfo->ulNbMalloc, ((float)ulLengthMalloc/(float)p_stMyBlockInfo->ulNbMalloc)/ 1024, ((float)ulLengthMalloc/(float)p_stMyBlockInfo->ulNbMalloc)/ (1024*1024));
				Mmg_fn_v_PrintInfoMalloc (a_cLine);
			}
		}
 
        a_cMap[uwI+1]='\n';
        a_cMap[uwI+2]='\0';     
        Mmg_fn_v_PrintInfoMalloc (a_cMap);
        ulLengthMalloc >>= C_uwShiftAllocSize;/* restore the unitAlloc unit*/
 
        /*+++++++++++++++++++++++++++++*/
        /* the loss of allocated */
        /*+++++++++++++++++++++++++++++*/
        if (ulMaxPrint){
			ucPrintedLength = (unsigned char)((
					  ((p_stMyBlockInfo->ulNbMalloc)*C_ucDebugInformationLoss)) /* loss*/
					* C_ucNbColumnForHisto / ulMaxPrint);   
		}
		else ucPrintedLength = 0; 
        if (ucPrintedLength == 0) ucPrintedLength=1;
        for (uwI=0; uwI < ucPrintedLength; uwI++){
                a_cMap[uwI]='+';
        }
        a_cMap[uwI]='\n';
        a_cMap[uwI+1]='\0';     
        Mmg_fn_v_PrintInfoMalloc (a_cMap);
        Mmg_fn_v_PrintInfoMalloc ("The debug loss of the allocated space:\n");
        Mmg_fn_v_PrintInfoMalloc (a_cMap);
        ulLength = ((p_stMyBlockInfo->ulNbMalloc)*C_ucDebugInformationLoss); /* loss*/
        ulLength <<= C_uwShiftAllocSize;
        if ((unsigned long)p_stMyBlockInfo->p_cEndBlock - (unsigned long)p_stMyBlockInfo->p_cBeginBlock + 1 - (ulDebugInfoRemain<<C_uwShiftAllocSize))
			sprintf (a_cLine, "\t-Size : %db (%.2fKb; %.2fMb) = %.2f%% of the all the available space\n", ulLength, (float)ulLength / 1024, (float)ulLength / (1024*1024), (float) ulLength*100 /(float)((unsigned long)p_stMyBlockInfo->p_cEndBlock - (unsigned long)p_stMyBlockInfo->p_cBeginBlock + 1 - (ulDebugInfoRemain<<C_uwShiftAllocSize)));/*lint !e790: Suspicious truncation, integral to float*/
		else
			sprintf (a_cLine, "\t-Size : %db (%.2fKb; %.2fMb)\n", ulLength, (float)ulLength / 1024, (float)ulLength / (1024*1024));
        Mmg_fn_v_PrintInfoMalloc (a_cLine);
        a_cMap[uwI+1]='\n';
        a_cMap[uwI+2]='\0';     
        Mmg_fn_v_PrintInfoMalloc (a_cMap);
 
        /*OOOOOOOOOOOOOOOO*/
        /* the last first*/
        /*OOOOOOOOOOOOOOOO */
 
        if (ulMaxPrint)
		ucPrintedLength = (unsigned char)( ( ((unitAlloc)*p_uaPtr) - ulDebugInfoRemain)
                                                * C_ucNbColumnForHisto / ulMaxPrint);/*lint !e613: Possible use of null pointer (p_uaPtr)*/
		else ucPrintedLength = 0;
        if (ucPrintedLength == 0) ucPrintedLength=1;
        for (uwI=0; uwI < ucPrintedLength; uwI++){
                a_cMap[uwI]='O';
        }
        a_cMap[uwI]='\n';
        a_cMap[uwI+1]='\0';     
        Mmg_fn_v_PrintInfoMalloc (a_cMap);
        Mmg_fn_v_PrintInfoMalloc ("Remain (last Free space):\n");
        Mmg_fn_v_PrintInfoMalloc (a_cMap);
        ulLength = *p_uaPtr;/*lint !e613: Possible use of null pointer (p_uaPtr)*/
        ulLength -=ulDebugInfoRemain;
        ulLength <<= C_uwShiftAllocSize;
        if ((unsigned long)p_stMyBlockInfo->p_cEndBlock - (unsigned long)p_stMyBlockInfo->p_cBeginBlock + 1 - (ulDebugInfoRemain<<C_uwShiftAllocSize))
			sprintf (a_cLine, "\t-Size : %db (%.2fKb; %.2fMb) = %.2f%% of the all the available space\n", ulLength, (float)ulLength / 1024, (float)ulLength / (1024*1024), (float) ulLength*100 /(float)((unsigned long)p_stMyBlockInfo->p_cEndBlock - (unsigned long)p_stMyBlockInfo->p_cBeginBlock + 1 - (ulDebugInfoRemain<<C_uwShiftAllocSize)));/*lint !e790: Suspicious truncation, integral to float*/
		else
			sprintf (a_cLine, "\t-Size : %db (%.2fKb; %.2fMb)\n", ulLength, (float)ulLength / 1024, (float)ulLength / (1024*1024));
        Mmg_fn_v_PrintInfoMalloc (a_cLine);
        a_cMap[uwI+1]='\n';
        a_cMap[uwI+2]='\0';     
        Mmg_fn_v_PrintInfoMalloc (a_cMap);
#endif /*__DEBUG_MALLOC_MODE__*/
}/*lint !e715: p_stMyBlockInfo&ucBlockId& (line 2075) not referenced*/
/* end of Mmg_fn_vPrintBlockStatistic*/
 
/* ##F#===================================================================================
NAME :          Mmg_fn_vPrintDynamicMallocStatistic
DESCRIPTION :   Print statistic on a dynamic allocation of a module  (only in debug mode)
INPUT :			Module Id
				Pointer on block info structure
=========================================================================================
CREATION : 06-11-97/Pierrick Crepy
=======================================================================================*/
#ifdef __DEBUG_MALLOC_MODE__
#ifdef __DYNAMIC_MALLOC_ALLOWED__
void Mmg_fn_vPrintDynamicMallocStatistic (unsigned char ucModuleId, struct tdstDynInfo_ *p_stMyDynInfo){
/*   -------------------------------*/
        tdstMallocInfo * p_stMyMallocInfo;
        unsigned long ulI;
        unsigned long ulMaxPrint;
        unsigned long ulLargestMalloc=0, ulSmallestMalloc=0xffffffff;
        unsigned long ulIdLargestMalloc=0xffffffff,ulIdSmallestMalloc=0xffffffff;
        unsigned char ucPrintedLength;
        unsigned long ulLengthMalloc=0, ulLength, ulLoss;
        char a_cMap [C_ucNbColumnForHisto+3];/* +3 for '\n'+(\n)+'\0'*/
        char a_cLine [C_ucNbPrintedColumn];
        
        /* look for the maximum & mimimum size of all the mallocs*/
        p_stMyMallocInfo = p_stMyDynInfo->d_stDynamicMallocInfo;
        for (ulI=0; ulI<p_stMyDynInfo->ulNbDynamicMalloc; ulI++, p_stMyMallocInfo++){
                ulLength = (unsigned long)(*((unitAlloc *)p_stMyMallocInfo->p_cBeginMalloc - C_ucMallocHeaderSize));
                ulLengthMalloc += ulLength;
                if (ulLength>ulLargestMalloc){
                        ulLargestMalloc = ulLength;
                        ulIdLargestMalloc = ulI;
                }
                if (ulLength<ulSmallestMalloc){
                        ulSmallestMalloc = ulLength;
                        ulIdSmallestMalloc = ulI;
                }
        }                                                                       
		*a_cLine= '\n';
        Erm_M_GetModuleInformation(a_cLine+1, ucModuleId);
        sprintf (a_cLine+strlen(a_cLine),":\n");
        Mmg_fn_v_PrintInfoMalloc(a_cLine ); 
 
        Mmg_fn_v_PrintInfoMalloc ("==================================\n");
        sprintf (a_cLine," Statistics of dynamic allocation :\n");
        Mmg_fn_v_PrintInfoMalloc (a_cLine);
        Mmg_fn_v_PrintInfoMalloc ("==================================\n");
        sprintf (a_cLine, "\t-%d requested reallocations\n\n",p_stMyDynInfo->ulNbTotalDynamicRealloc);
        Mmg_fn_v_PrintInfoMalloc (a_cLine);
 
        /************************************/
        /* the allocated space without loss*/
        /************************************/
 
        ulLoss = p_stMyDynInfo->ulNbDynamicMalloc * (C_ucMallocHeaderSize+C_ucMallocFooterSize-C_ucOptimizedMallocHeaderSize-C_ucOptimizedMallocFooterSize);
        ulMaxPrint = M_Max(ulLoss, ulLengthMalloc);/* why not! ulLoss > ulLengthMalloc ?*/
        ulLength = ulLengthMalloc - ulLoss;
 
		if (ulMaxPrint){
			ucPrintedLength = (unsigned char)(
                ulLengthMalloc 
                * C_ucNbColumnForHisto / ulMaxPrint);   
		}
		else ucPrintedLength = 0;
        if (ucPrintedLength == 0) ucPrintedLength=1;
        for (ulI=0; ulI < ucPrintedLength; ulI++){
                a_cMap[ulI]='*';
        }
        a_cMap[ulI]='\n';
        a_cMap[ulI+1]='\0';     
        Mmg_fn_v_PrintInfoMalloc (a_cMap);
        Mmg_fn_v_PrintInfoMalloc ("Total allocated space without loss:\n");
        Mmg_fn_v_PrintInfoMalloc (a_cMap);
        ulLengthMalloc <<= C_uwShiftAllocSize;
        sprintf (a_cLine, "\t-Request:%d; current:%d; size :    \t%db (%.2fKb; %.2fMb)\n",p_stMyDynInfo->ulNbTotalDynamicMalloc, p_stMyDynInfo->ulNbDynamicMalloc, ulLengthMalloc, (float)ulLengthMalloc / 1024, (float)ulLengthMalloc / (1024*1024));
        Mmg_fn_v_PrintInfoMalloc (a_cLine);
        ulLargestMalloc <<= C_uwShiftAllocSize;
        sprintf (a_cLine, "\t-The Largest Allocation:             \t%db (%.2fKb; %.2fMb)\n", ulLargestMalloc, (float)ulLargestMalloc/ 1024, (float)ulLargestMalloc/ (1024*1024));
        Mmg_fn_v_PrintInfoMalloc (a_cLine);
        ulSmallestMalloc <<= C_uwShiftAllocSize;
        sprintf (a_cLine, "\t-The Smallest Allocation:            \t%db (%.2fKb; %.2fMb)\n", ulSmallestMalloc, (float)ulSmallestMalloc/ 1024, (float)ulSmallestMalloc/ (1024*1024));
        Mmg_fn_v_PrintInfoMalloc (a_cLine);
        if (p_stMyDynInfo->ulNbDynamicMalloc){
			sprintf (a_cLine, "\t-The average Allocation:             \t%db (%.2fKb; %.2fMb)\n", ulLengthMalloc/p_stMyDynInfo->ulNbDynamicMalloc, ((float)ulLengthMalloc/(float)p_stMyDynInfo->ulNbDynamicMalloc)/ 1024, ((float)ulLengthMalloc/(float)p_stMyDynInfo->ulNbDynamicMalloc)/ (1024*1024));
			Mmg_fn_v_PrintInfoMalloc (a_cLine);
		}
        a_cMap[ulI+1]='\n';
        a_cMap[ulI+2]='\0';     
        Mmg_fn_v_PrintInfoMalloc (a_cMap);
        ulLengthMalloc >>= C_uwShiftAllocSize;/* restore the unitAlloc unit*/
 
        /*+++++++++++++++++++++++++++++*/
        /* the loss of allocated space*/
        /*+++++++++++++++++++++++++++++*/
        if (ulMaxPrint) ucPrintedLength = (unsigned char)(ulLoss * C_ucNbColumnForHisto / ulMaxPrint);  
		else ucPrintedLength  = 0;
        if (ucPrintedLength == 0) ucPrintedLength=1;
        for (ulI=0; ulI < ucPrintedLength; ulI++){
                a_cMap[ulI]='+';
        }
        a_cMap[ulI]='\n';
        a_cMap[ulI+1]='\0';     
        Mmg_fn_v_PrintInfoMalloc (a_cMap);
        Mmg_fn_v_PrintInfoMalloc ("The debug loss of the allocated space:\n");
        Mmg_fn_v_PrintInfoMalloc (a_cMap);
        ulLength = ulLoss;
        ulLength <<= C_uwShiftAllocSize;
        if ((ulLengthMalloc << C_uwShiftAllocSize)+ulLength)
			sprintf (a_cLine, "\t-Size : %db (%.2fKb; %.2fMb) = %.2f%% of all the allocation space\n", ulLength, (float)ulLength / 1024, (float)ulLength / (1024*1024), (float)ulLength*100/(float)((ulLengthMalloc << C_uwShiftAllocSize)+ulLength));/*lint !e790: Suspicious truncation, integral to float*/
		else 
			sprintf (a_cLine, "\t-Size : %db (%.2fKb; %.2fMb)\n", ulLength, (float)ulLength / 1024, (float)ulLength / (1024*1024));
        Mmg_fn_v_PrintInfoMalloc (a_cLine);
        a_cMap[ulI+1]='\n';
        a_cMap[ulI+2]='\0';     
        Mmg_fn_v_PrintInfoMalloc (a_cMap);
}/*lint !e715: p_stMyDynInfo&szModuleName (line 2521) not referenced*/
#endif/* __DYNAMIC_MALLOC_ALLOWED__*/
#endif /*__DEBUG_MALLOC_MODE__*/
/* end of Mmg_fn_vPrintDynamicMallocStatistic */
 
/* ##F#===================================================================================
NAME :          Mmg_fn_v_ClearLogFile
DESCRIPTION :   Clear the log file C_szMmgLogFileName
=========================================================================================
CREATION : 06-11-97/Pierrick Crepy
=======================================================================================*/
void Mmg_fn_v_ClearLogFile(){
#ifdef __DEBUG_MALLOC_MODE__
		FILE *hpMmgLogFile;
		remove (C_szMmgLogFileName);/*lint !e534*/
		hpMmgLogFile = fopen( C_szMmgLogFileName, "w" );
#ifdef _DEBUG
		if (GetLastError())
		{
			LPVOID lpMsgBuf;
 
			FormatMessage( 
				FORMAT_MESSAGE_ALLOCATE_BUFFER | FORMAT_MESSAGE_FROM_SYSTEM,
				NULL,
				GetLastError(),
				MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT), /* Default language*/
				(LPTSTR) &lpMsgBuf,
				0,
				NULL 
			);/*lint !e534*/
 
			/* Display the string.*/
			Erm_fn_iMessageBox(lpMsgBuf, C_szMmgLogFileName, MB_OK|MB_ICONINFORMATION );
 
			/* Free the buffer.*/
			LocalFree( lpMsgBuf );
		}
#endif /*_DEBUG*/
        if (hpMmgLogFile) fclose(hpMmgLogFile);
 
 
#endif /*__DEBUG_MALLOC_MODE__*/
}
 
 
/* ##F#===================================================================================
NAME :          Mmg_fn_v_PrintInfoMalloc
DESCRIPTION :   Add a string in the log file C_szMmgLogFileName
INPUT :			String to print
=========================================================================================
CREATION : 06-11-97/Pierrick Crepy
=======================================================================================*/
void Mmg_fn_v_PrintInfoMalloc(char *p_cTxt)
{
#ifdef __DEBUG_MALLOC_MODE__
	FILE *hpMmgLogFile;
    hpMmgLogFile = fopen( C_szMmgLogFileName, "a" );
	if (hpMmgLogFile){
		fprintf (hpMmgLogFile,"%s", p_cTxt);
		fclose(hpMmgLogFile);
	}
#endif /*__DEBUG_MALLOC_MODE__*/
}
 
 
 
/* ##-########################### 
   ## debug function just for the developper
   ############################## */
 
/* ##F#===================================================================================
NAME :          Mmg_fn_vTestNbFreeIntheCurentMode
DESCRIPTION :   Check the validity of nb frre on a channel(only in debug mode)
INPUT :			Channel Id
=========================================================================================
CREATION : 06-11-97/Pierrick Crepy
=======================================================================================*/
void Mmg_fn_vTestNbFreeIntheCurentMode(unsigned char ucChannel)
/*not use for the moment*/
{
#ifdef __DEBUG_MALLOC_MODE__
	tdstBlockInfoPriv * p_stMyBlockInfo = (tdstBlockInfoPriv *) g_d_stCurrentModeInfo[ucChannel].p_vTdstBlockInfoOrTdstDynInfo;
	unitAlloc * p_uaTmp;/*temporary pointer: if we reduce the allocation p_uaTmp=pointer at the new free space. // !! voir a renomer*/
	unsigned short uwI;
 
    /* count the real number of free*/
    p_uaTmp = (unitAlloc*)p_stMyBlockInfo->p_cFirstFree;
    for (uwI=0; *(p_uaTmp+1) != (unitAlloc)0; uwI++, p_uaTmp = (unitAlloc*) *(p_uaTmp+1));/*lint !e722: Suspicious use of ;*/
    if (p_stMyBlockInfo->uwNbFree != uwI){
#ifdef __WARNING3_ERR_MMG__
#ifdef __ERROR_STRINGS__
		char szErrTxt[C_ucSizeOfErrTxt];
		sprintf(szErrTxt, "uwNbFree(%d) != the real number of actual free(%d)\n", p_stMyBlockInfo->uwNbFree, uwI);
		Mmg_M_UpdateLastErrorWithCurrentModeInfo (E_uwMmgPbBbFree, szErrTxt, ucChannel);
#else /*__ERROR_STRINGS__*/
		Mmg_M_UpdateLastErrorWithCurrentModeInfo (E_uwMmgPbBbFree, szErrTxt, NULL);
#endif /*__ERROR_STRINGS__*/
#endif /*__WARNING3_ERR_MMG__*/
		p_stMyBlockInfo->uwNbFree = uwI;
	}
#endif /* __DEBUG_MALLOC_MODE__*/
}
 
/* ##F#===================================================================================
NAME :          Mmg_fn_vTestNbFree
DESCRIPTION :   Check the validity of nb free in a static bloc (only in debug mode)
INPUT :			Module Id
				Block Id
				Pointer on a block info structure
=========================================================================================
CREATION : 06-11-97/Pierrick Crepy
=======================================================================================*/
void Mmg_fn_vTestNbFree(unsigned char ucModuleId, unsigned char ucBlockId, struct tdstBlockInfoPriv_ *p_stBlockInfo)
{
#ifdef __DEBUG_MALLOC_MODE__
				unitAlloc * p_uaTmp;/*temporary pointer: if we reduce the allocation p_uaTmp=pointer at the new free space. // !! voir a renomer*/
				unsigned short uwI;
				
/*				if (p_stBlockInfo->p_cFirstFree != p_stBlockInfo->p_cEndBlock) {*/
					/* count the real number of free*/
					p_uaTmp = (unitAlloc*)p_stBlockInfo->p_cFirstFree;
					for (uwI=0; *(p_uaTmp+1) != (unitAlloc)0; uwI++, p_uaTmp = (unitAlloc*) *(p_uaTmp+1));/*lint !e722: Suspicious use of ;*/
					if (p_stBlockInfo->uwNbFree != uwI){
#ifdef __WARNING3_ERR_MMG__
#ifdef __ERROR_STRINGS__
						char szErrTxt[C_ucSizeOfErrTxt];
						sprintf(szErrTxt, "uwNbFree(%d) != the real number of actual free(%d)\n", p_stBlockInfo->uwNbFree, uwI);
						Mmg_M_UpdateLastErrorWithModuleIdAnducModeReference(ucModuleId, ucBlockId, E_uwMmgPbBbFree, szErrTxt);
#else /*__ERROR_STRINGS__*/
						Mmg_M_UpdateLastErrorWithModuleIdAnducModeReference(ucModuleId, ucBlockId, E_uwMmgPbBbFree, NULL);
#endif /*__ERROR_STRINGS__*/
 
#endif /*__WARNING3_ERR_MEM__*/
						
						p_stBlockInfo->uwNbFree = uwI;
					}
/*				}*/
#endif /* __DEBUG_MALLOC_MODE__*/
}/*lint !e715*/
 
/* ##F#===================================================================================
NAME :          Mmg_fn_vBlockGarbageCollector4Ch
DESCRIPTION :   Do a garbage collector on a block, beware all pointer that point into
				the bloc must be pass in parameter (even local pointer in the block)
INPUT :			Table of pointer (point into the block)
				Max Malloc in the block
				Channel Id
=========================================================================================
CREATION : 06-11-97/Pierrick Crepy
=======================================================================================*/
void Mmg_fn_vBlockGarbageCollector4Ch(void** a_pp_vTab[], unsigned short uwMaxNbMallocInBlock, unsigned char ucChannel){
	unsigned short uwI, uwJ;
	void ** pp_vTmp;		
	char *p_cMyFirstFree = ((tdstBlockInfoPriv *)(g_d_stCurrentModeInfo[ucChannel].p_vTdstBlockInfoOrTdstDynInfo))->p_cFirstFree;
#ifdef __DEBUG_MALLOC_MODE__
	char szTxt[100];
	char * p_vSv;
#endif /*__DEBUG_MALLOC_MODE__*/
 
 
 
#ifdef D_CheckSystemForBlockWithoutFree
		if (p_cMyFirstFree == C_FirstFreeValueForBlockWithoutFree){
			Mmg_M_UpdateLastError(E_uwMmgPbNoAvailableFunctionForBlockWithoutFree, NULL)
		}
#endif /*D_CheckSystemForBlockWithoutFree*/
 
 
	/* sort a_pp_cTab*/
    for (uwI=0; uwI < /*C_uwNumberOfMallocMax*/uwMaxNbMallocInBlock-1; uwI++){
            for (uwJ=(unsigned short)(uwI+1); uwJ < uwMaxNbMallocInBlock; uwJ++){
                    if (*(a_pp_vTab[uwJ]) < *(a_pp_vTab[uwI])){
                            pp_vTmp = a_pp_vTab[uwI];
                            a_pp_vTab[uwI] = a_pp_vTab[uwJ];
                            a_pp_vTab[uwJ] = pp_vTmp;
                    }
            }
	}
 
	for( uwI = 0; uwI < uwMaxNbMallocInBlock; uwI++ ){
 
		if (*(a_pp_vTab[uwI])>(void *) p_cMyFirstFree ){
#ifdef __DEBUG_MALLOC_MODE__
			p_vSv = (void *) (*(a_pp_vTab[uwI]));
			*(a_pp_vTab[uwI]) = (void *) Mmg_fn_p_vRealloc (*(a_pp_vTab[uwI]),((*(((unitAlloc *)(*(a_pp_vTab[uwI]))) - 2)) - (C_ucMallocHeaderSize + C_ucMallocFooterSize))<<C_uwShiftAllocSize);/* 2 for the [starting key] + [size of the malloc]*/
			sprintf (szTxt, "Mmg_fn_p_vRealloc (0X%X,%d) ==> 0X%X\n", p_vSv, ((*(((unitAlloc *)(*(a_pp_vTab[uwI]))) - 2)) - (C_ucMallocHeaderSize + C_ucMallocFooterSize))<<C_uwShiftAllocSize, *(a_pp_vTab[uwI]) );
			Mmg_fn_v_PrintInfoMalloc (szTxt);
#else /*__DEBUG_MALLOC_MODE__*/
			*(a_pp_vTab[uwI]) = (void *) Mmg_fn_p_vRealloc (*(a_pp_vTab[uwI]),((*(((unitAlloc *)(*(a_pp_vTab[uwI]))) - 1)) - (C_ucMallocHeaderSize + C_ucMallocFooterSize))<<C_uwShiftAllocSize);/* 1 for the [size of the malloc]*/
#endif /*__DEBUG_MALLOC_MODE__*/
		}
	}
}/*Mmg_fn_vBlockGarbageCollector*/
#endif /* _FIRE_DEADCODE_U64_ */
 
/* ##F#===================================================================================
NAME :          Mmg_fn_vBlockGarbageCollector4Ch
DESCRIPTION :   return Block Id & beginning address if found
INPUT :			Pointer on a zone
				pointer to stock the block Id
				pointer to stock the beginning address of the block
=========================================================================================
CREATION : 06-11-97/Pierrick Crepy
=======================================================================================*/
void Mmg_fn_vWhereIs (void * p_vPtr, unsigned short *p_uwModuleBlockId, void ** pp_vBeginAdr){
	unsigned char ucModuleId, ucBlockId;	
    tdstBlockInfoPriv *a_stMyBlockInfo;
 
	*p_uwModuleBlockId = 0xFFFF;
	for (ucModuleId=0; (ucModuleId<g_ucErmNbOfModule) && (*p_uwModuleBlockId == 0xFFFF); ucModuleId++){		              
        a_stMyBlockInfo = g_a_p_stMmgModuleBlocksInfo[ucModuleId];
		if (a_stMyBlockInfo != NULL){
			for (ucBlockId=0; (ucBlockId<g_a_ucBlocksNbInModule[ucModuleId]) && (*p_uwModuleBlockId == 0xFFFF); ucBlockId++, a_stMyBlockInfo++){
				if ( (a_stMyBlockInfo != NULL) && (a_stMyBlockInfo->p_cBeginBlock != C_p_cBlockNotValidKey)){
					if ((p_vPtr >= (void *)a_stMyBlockInfo->p_cBeginBlock) && (p_vPtr <= (void *)a_stMyBlockInfo->p_cEndBlock)){
						*p_uwModuleBlockId = (ucModuleId<<8) | ucBlockId;
						*pp_vBeginAdr = (void *)a_stMyBlockInfo->p_cBeginBlock;
					}
				}
			}
		}
	}
#ifdef __FATAL_ERR_MMG__
#ifdef _DEBUG
	if (*p_uwModuleBlockId == 0xFFFF){
		char szTxt[50];
		sprintf (szTxt, "In Mmg_fn_vWhereIs(0X%X, ...)\n", p_vPtr);
		Mmg_M_UpdateLastErrorWithoutMessage(E_uwMmgPbInvalidStaticAddress,szTxt);
	}
#endif /*_DEBUG*/
#endif __FATAL_ERR_MMG__
}/*Mmg_fn_vWhereIs */
 
/* ##F#===================================================================================
NAME :          Mmg_fn_p_vGiveTheBeginingAddress 
DESCRIPTION :   return the beginning address of a block
INPUT :			Block Id
OUTPUT :		address of the block beginning
=========================================================================================
CREATION : 06-11-97/Pierrick Crepy
=======================================================================================*/
void * Mmg_fn_p_vGiveTheBeginingAddress (unsigned short uwModuleBlockId){
	unsigned char ucModuleId = uwModuleBlockId>>8;
	unsigned char ucBlockId = uwModuleBlockId & 0xFF;
 
#if defined(__FATAL_ERR_MMG__) && defined(_DEBUG)
#ifdef __ERROR_STRINGS__
	char szErrTxt[C_ucSizeOfErrTxt];
#endif /*__ERROR_STRINGS__*/
	if (ucModuleId >= g_ucErmNbOfModule){
		char szTxt[50];
		sprintf (szTxt, "ModuleId = %d, but only %d modules are initialized \n", ucModuleId, g_ucErmNbOfModule);
		Mmg_M_UpdateLastError(E_uwMmgPbInvalidModuleId,szTxt);
	}
	if (g_a_p_stMmgModuleBlocksInfo[ucModuleId]== NULL){
#ifdef __ERROR_STRINGS__
		sprintf (szErrTxt, "In Module:[");
		Erm_M_GetModuleInformation(szErrTxt+strlen(szErrTxt), ucModuleId);
		sprintf (szErrTxt+strlen(szErrTxt), "]\n");
		Mmg_M_UpdateLastError(E_uwMmgPbNoStaticMemory,szErrTxt);
#else /*__ERROR_STRINGS__*/
		Mmg_M_UpdateLastError(E_uwMmgPbNoStaticMemory,NULL);
#endif /*__ERROR_STRINGS__*/
	}
	if (ucBlockId >= g_a_ucBlocksNbInModule[ucModuleId]){
#ifdef __ERROR_STRINGS__
		sprintf (szErrTxt, "BlockId = %d, but there are only %d Block\nin the module [", ucBlockId, g_a_ucBlocksNbInModule[ucModuleId]);
		Erm_M_GetModuleInformation(szErrTxt+strlen(szErrTxt), ucModuleId);
		sprintf (szErrTxt+strlen(szErrTxt), "]\n");
		Mmg_M_UpdateLastError(E_uwMmgPbInvalidBlockId,szErrTxt);
#else /*__ERROR_STRINGS__*/
		Mmg_M_UpdateLastError(E_uwMmgPbInvalidBlockId,NULL);
#endif /*__ERROR_STRINGS__*/
	}
	if ((g_a_p_stMmgModuleBlocksInfo[ucModuleId])[ucBlockId].p_cBeginBlock == C_p_cBlockNotValidKey){
#ifdef __ERROR_STRINGS__
		sprintf (szErrTxt, "The Block#%d in the module [", ucBlockId);
		Erm_M_GetModuleInformation(szErrTxt+strlen(szErrTxt), ucModuleId);
		sprintf (szErrTxt+strlen(szErrTxt), "] is not valide:\nit's should be not well initialize ! Because :\np_cBeginBlock = C_p_cBlockNotValidKey (0X%X)\n", C_p_cBlockNotValidKey);
		Mmg_M_UpdateLastError(E_uwMmgPbInvalidBlockId,szErrTxt);
#else /*__ERROR_STRINGS__*/
		Mmg_M_UpdateLastError(E_uwMmgPbInvalidBlockId,NULL);
#endif /*__ERROR_STRINGS__*/
	}
#endif /*defined(__FATAL_ERR_MMG__) && defined(_DEBUG)*/
	return ((g_a_p_stMmgModuleBlocksInfo[ucModuleId])[ucBlockId].p_cBeginBlock);
 
}/*Mmg_fn_p_vGiveTheBeginingAddress*/
 
#ifdef _DEBUG
/* ##F#===================================================================================
NAME :          Mmg_fn_vLockAlloaction
DESCRIPTION :   Allow blocking of all alloc operation
=========================================================================================
CREATION : 06-11-97/Pierrick Crepy
=======================================================================================*/
void Mmg_fn_vLockAlloaction(){
	g_ucBLockedAllocation = C_ucTrue;
}
 
/* ##F#===================================================================================
NAME :          Mmg_fn_vUnLockAlloaction
DESCRIPTION :   Allow unblocking of all alloc operation
=========================================================================================
CREATION : 06-11-97/Pierrick Crepy
=======================================================================================*/
void Mmg_fn_vUnLockAlloaction(){
	g_ucBLockedAllocation = C_ucFalse;
}
#endif _DEBUG
 
/* ##F#===================================================================================
NAME :          Mmg_fn_ucGiveChannelId
DESCRIPTION :   Provide a unique channel identificator for a couple (Thraed,group)
				BEWARE : always use the default group
INPUT :			Thraed Id
				Group Id
OUTPUT :		Channel Id
=========================================================================================
CREATION : 06-11-97/Pierrick Crepy
LAST MODIFICATIONS : 25-11-97/Carlos Torres Check group & re-use of release channel
=======================================================================================*/
unsigned char Mmg_fn_ucGiveChannelId(unsigned long ulThreadId, unsigned char ucGroupId){
	unsigned char ucI= 1;/*1 for jump the defaulf channel*/
	unsigned char b_ucFound = C_ucFalse;
	tdstChannelInfo * p_stChannelInfo = g_stGeneralChannelInfo.d_stTabChannelInfo+1;/*1 for jump the defaulf channel*/
 
#ifdef __DEBUG_MALLOC_MODE__
	/* cannot release channel already release*/
	if (ucGroupId != C_ucMmgDefaultGroup) {
#ifdef __ERROR_STRINGS__
		char szErrTxt[C_ucSizeOfErrTxt];
		sprintf (szErrTxt, "You choose the group %d to obtain a channel",ucGroupId);
		Mmg_M_UpdateLastError(E_uwMmgInvalidGroup, szErrTxt);
#else /*__ERROR_STRINGS__*/
			Mmg_M_UpdateLastError(E_uwMmgInvalidGroup, NULL);
#endif /*__ERROR_STRINGS__*/
	}
#endif
 
	/* try to find an existing channel or a free channel*/
	while((ucI < g_stGeneralChannelInfo.ucNbchannelUsed) && 
		  (!b_ucFound) &&
		  (p_stChannelInfo->ucGroupId == C_ucMmgDefaultGroup)) {
		if ((p_stChannelInfo->ulThreadId == ulThreadId) && (p_stChannelInfo->ucGroupId == ucGroupId)) {
			b_ucFound = C_ucTrue;
		}
		else {
			 ucI++;
			 p_stChannelInfo++;
		}
	}
 
	if (b_ucFound) {
		return ucI;
	}
	else {/*! b_ucFound*/
#ifdef __DEBUG_MALLOC_MODE__
		if (ucI >= g_stGeneralChannelInfo.ucMAxNbChannel){
#ifdef __ERROR_STRINGS__
			char szErrTxt[C_ucSizeOfErrTxt];
			sprintf (szErrTxt, "You can only use %d channel(s) available\nPlease check the ucMaxNbChannel parameter when you call  Mmg_fn_vFirstInitMmgModule() function", g_stGeneralChannelInfo.ucMAxNbChannel);
			Mmg_M_UpdateLastError(E_uwMmgPbTooManyChannel, szErrTxt);
#else /*__ERROR_STRINGS__*/
			Mmg_M_UpdateLastError(E_uwMmgPbTooManyChannel, NULL);
#endif /*__ERROR_STRINGS__*/
		}
#endif /* __DEBUG_MALLOC_MODE__ */
 
		p_stChannelInfo->ulThreadId = ulThreadId;
		p_stChannelInfo->ucGroupId = ucGroupId;
 
		/* set the last channel used*/
		if (ucI == g_stGeneralChannelInfo.ucNbchannelUsed)
			g_stGeneralChannelInfo.ucNbchannelUsed++;
		return (ucI);		
	}
}/*Mmg_fn_ucGiveChannelId*/
 
/* ##F#===================================================================================
NAME :          Mmg_fn_ucGiveChannelId
DESCRIPTION :   Provide a unique channel identificator for a couple (Thraed,group)
				BEWARE : always use the default group
INPUT :			Thraed Id
				Group Id
OUTPUT :		Channel Id
=========================================================================================
CREATION : 06-11-97/Pierrick Crepy
=======================================================================================*/
#ifndef _FIRE_DEADCODE_U64_
void Mmg_fn_vReleaseChannelId(unsigned char ucChannelId) {
	/* get channel info in the table*/
	tdstChannelInfo * p_stChannelInfo = g_stGeneralChannelInfo.d_stTabChannelInfo+ucChannelId;
 
#ifdef __DEBUG_MALLOC_MODE__
	/* cannot release default channel*/
	if (ucChannelId == C_ucMmgDefaultChannel) {
		Mmg_M_UpdateLastError(E_uwMmgPbDftChannelCannotBeFree, NULL);
		return;
	}
 
	/* cannot release channel >= MaxChannel */
	if (ucChannelId >= g_stGeneralChannelInfo.ucMAxNbChannel) {
#ifdef __ERROR_STRINGS__
		char szErrTxt[C_ucSizeOfErrTxt];
		sprintf (szErrTxt, "You try to release the channel %d, but you can only use %d channel",ucChannelId, g_stGeneralChannelInfo.ucMAxNbChannel);
		Mmg_M_UpdateLastError(E_uwMmgPbInvalChannel, szErrTxt);
#else /*__ERROR_STRINGS__*/
			Mmg_M_UpdateLastError(E_uwMmgPbInvalChannel, NULL);
#endif /*__ERROR_STRINGS__*/
		return;
	}
 
	/* cannot release channel already release*/
	if ((p_stChannelInfo->ucGroupId != C_ucMmgDefaultGroup) ||
		(ucChannelId >= g_stGeneralChannelInfo.ucNbchannelUsed)) {
#ifdef __ERROR_STRINGS__
		char szErrTxt[C_ucSizeOfErrTxt];
		sprintf (szErrTxt, "You try to release the channel %d, but it was already released",ucChannelId);
		Mmg_M_UpdateLastError(E_uwMmgPbInvalChannel, szErrTxt);
#else /*__ERROR_STRINGS__*/
			Mmg_M_UpdateLastError(E_uwMmgPbInvalChannel, NULL);
#endif /*__ERROR_STRINGS__*/
		return;
	}
#endif
 
	/* set invalid group*/
	p_stChannelInfo->ucGroupId = C_ucMmgInvalidGroup;
}
#endif /* _FIRE_DEADCODE_U64_ */
 
/* ##F#===================================================================================
NAME :          Mmg_fn_v_SetModeAlloc
DESCRIPTION :   Set the mode dynamic or static (choosing a block) for a channel
INPUT :			Module Id
				New Mode
				Channel Id
=========================================================================================
CREATION : 06-11-97/Pierrick Crepy
=======================================================================================*/
void Mmg_fn_v_SetModeAlloc(unsigned char ucModuleId, unsigned char ucNewMode, unsigned char ucChannel)
/*              ------------------ */
{
        (g_d_stCurrentModeInfo[ucChannel]).ucMode = (ucNewMode);
        (g_d_stCurrentModeInfo[ucChannel]).ucModuleId = ucModuleId;
        if ((ucNewMode) != E_ucDynamic){
                (g_d_stCurrentModeInfo[ucChannel]).p_vTdstBlockInfoOrTdstDynInfo = (void *) (g_a_p_stMmgModuleBlocksInfo[ucModuleId]+ucNewMode);
        }
        else{
#ifdef __DYNAMIC_MALLOC_ALLOWED__
 
#ifdef __DEBUG_MALLOC_MODE__
                (g_d_stCurrentModeInfo[ucChannel]).p_vTdstBlockInfoOrTdstDynInfo = (void *) g_d_p_stMmgModuleDynInfo[ucModuleId];
#endif /*__DEBUG_MALLOC_MODE__*/
 
#else /*__DYNAMIC_MALLOC_ALLOWED__*/
                (g_d_stCurrentModeInfo[ucChannel]).p_vTdstBlockInfoOrTdstDynInfo = NULL;
                Mmg_M_UpdateFatalDebugError(E_uwMmgPbCanNotUseDynMode);
#endif /*__DYNAMIC_MALLOC_ALLOWED__*/
        }
}/*Mmg_fn_v_SetModeAlloc*/
 
 
/* ##F#===================================================================================
NAME :          Mmg_fn_vFirstInitMmgModule 
DESCRIPTION :   Initialization of the Mmg module  MUST be use before using MMG functions
INPUT :			Max number of channel authorized
=========================================================================================
CREATION : 06-11-97/Pierrick Crepy
=======================================================================================*/
void Mmg_fn_vFirstInitMmgModule (unsigned char ucMaxNbChannel){
	unsigned char ucI;
#ifdef __DEBUG_MALLOC_MODE__
#ifdef __ERROR_STRINGS__
			char szErrTxt[C_ucSizeOfErrTxt];
#endif /*__ERROR_STRINGS__*/
#endif /*__DEBUG_MALLOC_MODE__*/
 
#ifdef __DEBUG_MALLOC_MODE__
#ifdef __FATAL_ERR_MMG__
	if ((ucMaxNbChannel < 1) || (ucMaxNbChannel > C_MaxNbPossibleChannel)) {
#ifdef __ERROR_STRINGS__
		sprintf (szErrTxt, "The range of ucMaxNbChannel is [1, C_MaxNbPossibleChannel=%d], But Your ucMaxNbChannel =%d", C_MaxNbPossibleChannel, ucMaxNbChannel);
		Mmg_M_UpdateLastError(E_uwMmgPbInvalNbOfChannel, szErrTxt);
#else /*__ERROR_STRINGS__*/
		Mmg_M_UpdateLastError(E_uwMmgPbInvalNbOfChannel, NULL);
#endif /*__ERROR_STRINGS__*/
	}
#endif /*__FATAL_ERR_MMG__*/
#endif /*__DEBUG_MALLOC_MODE__*/
 
	g_d_stCurrentModeInfo = (struct tdstCurrentModeInfo_ *) malloc (ucMaxNbChannel * sizeof (struct tdstCurrentModeInfo_));
#ifdef __DEBUG_MALLOC_MODE__
#ifdef __FATAL_ERR_MMG__
	if (g_d_stCurrentModeInfo == NULL){
#ifdef __ERROR_STRINGS__
		sprintf (szErrTxt, "g_d_stCurrentModeInfo is not allocated");
		Mmg_M_UpdateLastError(E_uwMmgPbInFirstInitMmgModule, szErrTxt);
#else /*__ERROR_STRINGS__*/
		Mmg_M_UpdateLastError(E_uwMmgPbInFirstInitMmgModule, NULL);
#endif /*__ERROR_STRINGS__*/
	}
#endif /*__FATAL_ERR_MMG__*/
#endif /*__DEBUG_MALLOC_MODE__*/
 
	g_stGeneralChannelInfo.d_stTabChannelInfo = (struct tdstChannelInfo_ *) malloc (ucMaxNbChannel * sizeof (struct tdstChannelInfo_ ));
#ifdef __DEBUG_MALLOC_MODE__
#ifdef __FATAL_ERR_MMG__
	if (g_stGeneralChannelInfo.d_stTabChannelInfo == NULL){
#ifdef __ERROR_STRINGS__
		sprintf (szErrTxt, "g_stGeneralChannelInfo.d_stTabChannelInfo is not allocated");
		Mmg_M_UpdateLastError(E_uwMmgPbInFirstInitMmgModule, szErrTxt);
#else /*__ERROR_STRINGS__*/
		Mmg_M_UpdateLastError(E_uwMmgPbInFirstInitMmgModule, NULL);
#endif /*__ERROR_STRINGS__*/
	}
#endif /*__FATAL_ERR_MMG__*/
#endif /*__DEBUG_MALLOC_MODE__*/
 
	g_stGeneralChannelInfo.ucMAxNbChannel = ucMaxNbChannel;
	g_stGeneralChannelInfo.ucNbchannelUsed = 1;
 
#ifdef __DYNAMIC_MALLOC_ALLOWED__
#ifdef __DEBUG_MALLOC_MODE__
	g_d_p_stMmgModuleDynInfo = (struct tdstDynInfo_ **) malloc (sizeof(struct tdstDynInfo_ *) * C_ucNbOfMaxModule);
	if (g_d_p_stMmgModuleDynInfo == NULL){
#ifdef __ERROR_STRINGS__
		sprintf (szErrTxt, "g_d_p_stMmgModuleDynInfo is not allocated");
		Mmg_M_UpdateLastError(E_uwMmgPbInFirstInitMmgModule, szErrTxt);
#else /*__ERROR_STRINGS__*/
		Mmg_M_UpdateLastError(E_uwMmgPbInFirstInitMmgModule, NULL);
#endif /*__ERROR_STRINGS__*/
	}
#endif /*__DEBUG_MALLOC_MODE__*/
#endif /*__DYNAMIC_MALLOC_ALLOWED__*/
 
	for (ucI=0; ucI<C_ucNbOfMaxModule; ucI++) {
			g_a_p_stMmgModuleBlocksInfo[ucI] = NULL;
#ifdef __DEBUG_MALLOC_MODE__
#ifdef __DYNAMIC_MALLOC_ALLOWED__
			g_d_p_stMmgModuleDynInfo[ucI] = NULL;
#endif /*__DYNAMIC_MALLOC_ALLOWED__*/
#endif /*__DEBUG_MALLOC_MODE__*/
	}
	Mmg_MCreateCriticalSection();
}/*Mmg_fn_vFirstInitMmgModule*/
 
/* ##F#===================================================================================
NAME :          Mmg_fn_vStopMmgModule
DESCRIPTION :   Destroy all ressource allocated by MMG. MUST be use before the end of the program
=========================================================================================
CREATION : 06-11-97/Pierrick Crepy
=======================================================================================*/
 
#ifndef _FIRE_DEADCODE_U64_ /* Added by RUC */
void Mmg_fn_vStopMmgModule(){
	unsigned char ucI;
	for (ucI = 0; ucI < g_ucErmNbOfModule; ucI++){/* scan each module*/
		Mmg_fn_v_StopMmg(ucI);
	}
	Mmg_MDeleteCriticalSection();
	free (g_d_stCurrentModeInfo);
	g_d_stCurrentModeInfo = NULL;
	free (g_stGeneralChannelInfo.d_stTabChannelInfo);
	g_stGeneralChannelInfo.d_stTabChannelInfo = NULL;
}
#endif /* _FIRE_DEADCODE_U64_ */ /* Added by RUC */
 
 
/* ##F#===================================================================================
NAME :          Mmg_fn_v_InitMmg
DESCRIPTION :   Initialization of Mmg for another module. MUST be done before the module 
				can use MMG functions.
INPUT :			Module Id
				Max static block
				Max dynamic allocation allowed
=========================================================================================
CREATION : 06-11-97/Pierrick Crepy
=======================================================================================*/
void Mmg_fn_v_InitMmg(unsigned char ucModuleId, unsigned char ucMaxBlocksNb, unsigned long ulMaxNbDynamicMalloc)
/*   ---------------- */
{
	unsigned char ucI;
	tdstBlockInfoPriv *p_stMyBlockInfo;
#ifdef __DEBUG_MALLOC_MODE__
#ifdef __ERROR_STRINGS__
	char szErrTxt[C_ucSizeOfErrTxt];
#endif /*__ERROR_STRINGS__*/
    if (ucModuleId == C_ucModuleNotInitialized){
       Mmg_M_UpdateFatalDebugError(E_uwMmgPbCanNotInitMmg);
    }
    else{
#endif /*__DEBUG_MALLOC_MODE__*/
 
#if (defined(USE_PROFILER) && !defined(U64))
    {
        static long bFirstCall = TRUE;
        if (bFirstCall)
        {
            MMG_fn_vInitMemoryRasterDeclaration ();
            bFirstCall = FALSE;
        }
    }
#endif
 
		if (ucMaxBlocksNb > 0){
			g_a_p_stMmgModuleBlocksInfo[ucModuleId] = (tdstBlockInfoPriv *) malloc (sizeof (tdstBlockInfoPriv) * ucMaxBlocksNb);
 
#ifdef __DEBUG_MALLOC_MODE__
 
			if (g_a_p_stMmgModuleBlocksInfo[ucModuleId] == NULL){
#ifdef __ERROR_STRINGS__
				sprintf (szErrTxt, "The g_d_p_stMmgModuleDynInfo[%d] (i.e for the module ", ucModuleId);
				Erm_M_GetModuleInformation(szErrTxt+strlen(szErrTxt), ucModuleId);
				sprintf (szErrTxt+strlen(szErrTxt), ") is not allocated");
 
				Mmg_M_UpdateLastError(E_uwMmgPbInInitMmg, szErrTxt);
#else /*__ERROR_STRINGS__*/
				Mmg_M_UpdateLastError(E_uwMmgPbInInitMmg, NULL);
#endif /*__ERROR_STRINGS__*/
			}
 
#ifdef __DYNAMIC_MALLOC_ALLOWED__
			g_d_p_stMmgModuleDynInfo[ucModuleId] = (tdstDynInfo *) malloc (sizeof(tdstDynInfo));
			if (g_d_p_stMmgModuleDynInfo[ucModuleId] == NULL){
#ifdef __ERROR_STRINGS__
				sprintf (szErrTxt, "The g_d_p_stMmgModuleDynInfo[%d] (i.e for the module ", ucModuleId);
				Erm_M_GetModuleInformation(szErrTxt+strlen(szErrTxt), ucModuleId);
				sprintf (szErrTxt+strlen(szErrTxt), ") is not allocated");
				Mmg_M_UpdateLastError(E_uwMmgPbInInitMmg, szErrTxt);
#else /*__ERROR_STRINGS__*/
				Mmg_M_UpdateLastError(E_uwMmgPbInInitMmg, NULL);
#endif /*__ERROR_STRINGS__*/
			}
			g_d_p_stMmgModuleDynInfo[ucModuleId]->ulMaxNbDynamicMalloc = ulMaxNbDynamicMalloc;
			g_d_p_stMmgModuleDynInfo[ucModuleId]->d_stDynamicMallocInfo = malloc (sizeof(tdstMallocInfo) * ulMaxNbDynamicMalloc);
			if (g_d_p_stMmgModuleDynInfo[ucModuleId]->d_stDynamicMallocInfo == NULL){
#ifdef __ERROR_STRINGS__
				sprintf (szErrTxt, "The g_d_p_stMmgModuleDynInfo[%d]->d_stDynamicMallocInfo (i.e for the module ", ucModuleId);
				Erm_M_GetModuleInformation(szErrTxt+strlen(szErrTxt), ucModuleId);
				sprintf (szErrTxt+strlen(szErrTxt), ") is not allocated");
				Mmg_M_UpdateLastError(E_uwMmgPbInInitMmg, szErrTxt);
#else /*__ERROR_STRINGS__*/
				Mmg_M_UpdateLastError(E_uwMmgPbInInitMmg, NULL);
#endif /*__ERROR_STRINGS__*/
			}
#endif /*__DYNAMIC_MALLOC_ALLOWED__*/
 
#endif /*__DEBUG_MALLOC_MODE__*/
 
			for (ucI=0, p_stMyBlockInfo = g_a_p_stMmgModuleBlocksInfo[ucModuleId];ucI<ucMaxBlocksNb; ucI++, p_stMyBlockInfo++){
				p_stMyBlockInfo->p_cBeginBlock = C_p_cBlockNotValidKey;
			}
			g_a_ucBlocksNbInModule[ucModuleId] = ucMaxBlocksNb;
		}
#ifdef __DEBUG_MALLOC_MODE__
#ifdef __DYNAMIC_MALLOC_ALLOWED__
        Mmg_M_InitDynInfo(g_d_p_stMmgModuleDynInfo[ucModuleId]);
#endif /*__DYNAMIC_MALLOC_ALLOWED__*/
#endif /*__DEBUG_MALLOC_MODE__*/
 
#ifdef __DEBUG_MALLOC_MODE__
    }
    Mmg_fn_v_ClearLogFile();
#endif /*__DEBUG_MALLOC_MODE__*/
}/*Mmg_fn_v_InitMmg*/
 
/* ##F#===================================================================================
NAME :          Mmg_fn_v_InitMmg
DESCRIPTION :   Destroy all ressource allocated for the management of memory for a module
INPUT :			Module Id
=========================================================================================
CREATION : 06-11-97/Pierrick Crepy
=======================================================================================*/
 
#ifndef _FIRE_DEADCODE_U64_ /* Added by RUC */
void Mmg_fn_v_StopMmg(unsigned char ucModuleId){
	unsigned char ucI;
 
	if (g_a_p_stMmgModuleBlocksInfo[ucModuleId]!= NULL){
		/*delete evey initialized block */
		for (ucI=0; ucI<g_a_ucBlocksNbInModule[ucModuleId]; ucI++){
			if (g_a_p_stMmgModuleBlocksInfo[ucModuleId][ucI].p_cBeginBlock != C_p_cBlockNotValidKey){
				/* the block right initialized*/
				Mmg_fn_vDeleteBlock (ucI, ucModuleId, g_a_p_stMmgModuleBlocksInfo[ucModuleId]);
			}
		}
 
		free (g_a_p_stMmgModuleBlocksInfo[ucModuleId]);
		g_a_p_stMmgModuleBlocksInfo[ucModuleId] = NULL;
#ifdef __DEBUG_MALLOC_MODE__
#ifdef __DYNAMIC_MALLOC_ALLOWED__
		free(g_d_p_stMmgModuleDynInfo[ucModuleId]->d_stDynamicMallocInfo);
		g_d_p_stMmgModuleDynInfo[ucModuleId]->d_stDynamicMallocInfo = NULL;
		free (g_d_p_stMmgModuleDynInfo[ucModuleId]);
		g_d_p_stMmgModuleDynInfo[ucModuleId] = NULL;
#endif /*__DYNAMIC_MALLOC_ALLOWED__*/
#endif /*__DEBUG_MALLOC_MODE__*/
	}
}
#endif /* _FIRE_DEADCODE_U64_ */ /* Added by RUC */
 
 
/* ##F#===================================================================================
NAME :          Mmg_fn_v_PrintAllocationsUsedForMmg
DESCRIPTION :   Print statistic concerning the memory used to manage allocation
=========================================================================================
CREATION : 06-11-97/Pierrick Crepy
=======================================================================================*/
#ifndef _FIRE_DEADCODE_U64_
void Mmg_fn_v_PrintAllocationsUsedForMmg(){
#ifdef __ERROR_STRINGS__
	unsigned char ucI, ucJ, ucNbModuleUsedMmg =0;
	unsigned long ulSize, ulStaticSubTotal,ulDynamicMemoryUsed = 0, ulStaticMemoryUsed = 0;
#ifdef __DEBUG_MALLOC_MODE__
	unsigned long ulSizeForTraceOfEachAllocation;
#endif /*__DEBUG_MALLOC_MODE__*/
#ifdef __ADD_PLACE_FOR_DEBUG_INFORMATION__
	unsigned long ulSize2;
#endif /*__ADD_PLACE_FOR_DEBUG_INFORMATION__*/
#if defined(__DEBUG_MALLOC_MODE__) && defined(__DYNAMIC_MALLOC_ALLOWED__)
	unsigned long ulDynamicSubTotal;
#endif /*defined(__DEBUG_MALLOC_MODE__) && defined(__DYNAMIC_MALLOC_ALLOWED__)*/
	char szErrTxt[C_ucSizeOfErrTxt];
	tdstBlockInfoPriv *p_stMyBlocksInfo;
 
	Erm_fn_v_Printsz ("\n|-----------------------------------------|\n");
	Erm_fn_v_Printsz ("| Memory Used for the management of Mmg : |\n");
	Erm_fn_v_Printsz ("|-----------------------------------------|\n");
 
	for (ucI = 0; ucI < g_ucErmNbOfModule; ucI++){/* scan each module*/
		ulStaticSubTotal = 0;
#if defined(__DEBUG_MALLOC_MODE__) && defined(__DYNAMIC_MALLOC_ALLOWED__)
		ulDynamicSubTotal = 0;
#endif/* defined(__DEBUG_MALLOC_MODE__) && defined(__DYNAMIC_MALLOC_ALLOWED__)*/
		if (Mmg_M_b_ucTheModuleUseStaticMemory(ucI)){/*this module use the static memory and perhaps the dynamic*/
			ucNbModuleUsedMmg ++;
			sprintf (szErrTxt, "=> module (#%d) : ", ucI);
			Erm_M_GetModuleInformation(szErrTxt+strlen(szErrTxt), ucI);
			sprintf (szErrTxt+strlen(szErrTxt), "\n");
			Erm_fn_v_Printsz (szErrTxt);
#if defined(__DEBUG_MALLOC_MODE__) && defined(__DYNAMIC_MALLOC_ALLOWED__)
			ulSize = (sizeof(struct tdstDynInfo_) * C_ucNbOfMaxModule);
			ulSize2 = sizeof(tdstMallocInfo) * g_d_p_stMmgModuleDynInfo[ucI]->ulMaxNbDynamicMalloc;
			ulDynamicSubTotal = ulSize+ulSize2;
			sprintf (szErrTxt, "\t-> Dynamic Memory : General data (%db)+ Data for %d allocations (%db) = %db (%.2fKb; %.2fMb)\n",
				ulSize,
				g_d_p_stMmgModuleDynInfo[ucI]->ulMaxNbDynamicMalloc, ulSize2,
				ulDynamicSubTotal, (float)ulDynamicSubTotal/1024, (float)ulDynamicSubTotal/(1024*1024));
			Erm_fn_v_Printsz (szErrTxt);
#endif /*defined (__DEBUG_MALLOC_MODE__) && defined(__DYNAMIC_MALLOC_ALLOWED__)*/
			ulSize = (sizeof (tdstBlockInfoPriv) * Mmg_M_ucGetNbOfBlocksUsedInModule(ucI));
			ulStaticSubTotal = ulSize;
			sprintf (szErrTxt,"\t-> Static Memory : General Data for %d Block(s) = %d\n", Mmg_M_ucGetNbOfBlocksUsedInModule(ucI), ulSize);
			Erm_fn_v_Printsz (szErrTxt);			
			for (ucJ=0, p_stMyBlocksInfo = g_a_p_stMmgModuleBlocksInfo[ucI]; ucJ<g_a_ucBlocksNbInModule[ucI]; ucJ++, p_stMyBlocksInfo++){
				if (p_stMyBlocksInfo->p_cBeginBlock != C_p_cBlockNotValidKey){
#ifdef __ADD_PLACE_FOR_DEBUG_INFORMATION__
					ulSize = (long) (p_stMyBlocksInfo->p_cEndBlock - p_stMyBlocksInfo->p_cBeginBlock)+1;
					ulSize2 = (p_stMyBlocksInfo->ulMaxNbStaticMalloc*(C_ucDebugInformationLoss<<C_uwShiftAllocSize));
					ulSizeForTraceOfEachAllocation = 
					ulStaticSubTotal += ulSize;
					sprintf (szErrTxt, "\t\t* Block #%d: %db allocated + %db for 2*%d 'Check Keys' = %db (%.2fKb; %.2fMb)\n", 
						ucJ,
						ulSize-ulSize2,
						ulSize2, p_stMyBlocksInfo->ulMaxNbStaticMalloc,
						ulSize, (float)ulSize/1024, (float)ulSize/(1024*1024));
					Erm_fn_v_Printsz (szErrTxt);
#else /*__ADD_PLACE_FOR_DEBUG_INFORMATION__*/
					ulSize =(long) (p_stMyBlocksInfo->p_cEndBlock - p_stMyBlocksInfo->p_cBeginBlock+1);
					ulStaticSubTotal += ulSize;
					sprintf (szErrTxt, "\t\t* Block #%d: %db (%.2fKb; %.2fMb) allocated\n",
						ucJ, ulSize, (float)ulSize/1024, (float)ulSize/(1024*1024));
					Erm_fn_v_Printsz (szErrTxt);
#endif /*__ADD_PLACE_FOR_DEBUG_INFORMATION__*/
				}/*end of the if p_stMyBlockInfo->p_cBeginBlock != C_p_cBlockNotValidKey*/
			}/*end of for*/
 
#if defined(__DEBUG_MALLOC_MODE__) && defined(__DYNAMIC_MALLOC_ALLOWED__)			
			ulSize = ulDynamicSubTotal + ulStaticSubTotal;
			sprintf (szErrTxt,"\t-> Total Memory for the module #%d: Dynamic (%db)+ Static (%db) = %db (%.2fKb; %.2fMb)\n",
				ucI,
				ulDynamicSubTotal, ulStaticSubTotal,
				ulSize, (float)ulSize/1024, (float)ulSize/(1024*1024));
			Erm_fn_v_Printsz (szErrTxt);
#else /*defined(__DEBUG_MALLOC_MODE__) && defined(__DYNAMIC_MALLOC_ALLOWED__)*/	
			sprintf (szErrTxt,"\t-> Total Static Memory for the module #%d: %db (%.2fKb; %.2fMb)\n",
				ucI,
				ulStaticSubTotal, (float)ulStaticSubTotal/1024, (float)ulStaticSubTotal/(1024*1024));
			Erm_fn_v_Printsz (szErrTxt);
#endif /*defined(__DEBUG_MALLOC_MODE__) && defined(__DYNAMIC_MALLOC_ALLOWED__)*/
		}/* end if module used memeory.*/
#if defined(__DEBUG_MALLOC_MODE__) && defined(__DYNAMIC_MALLOC_ALLOWED__)
		ulDynamicMemoryUsed+=ulDynamicSubTotal;
#endif /*defined(__DEBUG_MALLOC_MODE__) && defined(__DYNAMIC_MALLOC_ALLOWED__)*/
		ulStaticMemoryUsed+=ulStaticSubTotal;
	}/*for ucI*/
#if defined(__DEBUG_MALLOC_MODE__) && defined(__DYNAMIC_MALLOC_ALLOWED__)
	ulSize = ulDynamicMemoryUsed + ulStaticMemoryUsed;
	sprintf (szErrTxt, "=> Total Memory used for %d Modules/%d : Dynamic (%db)+ Static (%db) = %db (%.2fKb; %.2fMb)\n\n",
		ucNbModuleUsedMmg, g_ucErmNbOfModule,
		ulDynamicMemoryUsed, ulStaticMemoryUsed,
		ulSize, (float)ulSize/1024, (float)ulSize/(1024*1024));
#else /*#if defined(__DEBUG_MALLOC_MODE__) && defined(__DYNAMIC_MALLOC_ALLOWED__)*/
	sprintf (szErrTxt, "=> Total Static Memory used for %d Modules/%d : %db (%.2fKb; %.2fMb)\n\n",
		ucNbModuleUsedMmg, g_ucErmNbOfModule,
		ulStaticMemoryUsed, (float)ulStaticMemoryUsed/1024, (float)ulStaticMemoryUsed/(1024*1024));
#endif /*defined(__DEBUG_MALLOC_MODE__) && defined(__DYNAMIC_MALLOC_ALLOWED__)*/
	Erm_fn_v_Printsz (szErrTxt);
 
#endif /*__ERROR_STRINGS__*/
}/*Mmg_fn_v_PrintAllocationsUsedForMmg*/
 
/* ##F#===================================================================================
NAME :          Mmg_fn_vGiveInformationBlock
DESCRIPTION :   Give information data on a block 
					-> address of block beginning
					-> address of block end
					-> address of the first free
					-> the maximum address reached (different of the last address used)
INPUT :			Module Id
				Block ID
				pointer on structure of block info
=========================================================================================
CREATION : 06-11-97/Pierrick Crepy
=======================================================================================*/
void Mmg_fn_vGiveInformationBlock(unsigned char ucModuleId, unsigned char ucBlockId, struct tdstBlockInfo_ *p_stMyBlockInfoForOutside){
	struct tdstBlockInfoPriv_ * p_stMyStBlockInfo;
 
#ifdef __DEBUG_MALLOC_MODE__
#ifdef __FATAL_ERR_MMG__ 
	if (ucBlockId >= g_a_ucBlocksNbInModule[ucModuleId]){
#ifdef __ERROR_STRINGS__
		char szErrTxt[C_ucSizeOfErrTxt];
		sprintf (szErrTxt, "BlockId = %d, but there are only %d Block\nin the module [", ucBlockId, g_a_ucBlocksNbInModule[ucModuleId]);
		Erm_M_GetModuleInformation(szErrTxt+strlen(szErrTxt), ucModuleId);
		sprintf (szErrTxt+strlen(szErrTxt), "]\n");
		Mmg_M_UpdateLastError(E_uwMmgPbInvalidBlockId,szErrTxt);
#else /*__ERROR_STRINGS__*/
		Mmg_M_UpdateLastError(E_uwMmgPbInvalidBlockId,NULL);
#endif /*__ERROR_STRINGS__*/
	}
#endif /*__FATAL_ERR_MMG__*/
#endif /*__DEBUG_MALLOC_MODE__*/
 
	/*implicite else with the fatal error*/
	p_stMyStBlockInfo = g_a_p_stMmgModuleBlocksInfo[ucModuleId]+ucBlockId;
	p_stMyBlockInfoForOutside->p_cBeginBlock = p_stMyStBlockInfo->p_cBeginBlock;
	p_stMyBlockInfoForOutside->p_cEndBlock = p_stMyStBlockInfo->p_cEndBlock;
	p_stMyBlockInfoForOutside->p_cFirstFree = p_stMyStBlockInfo->p_cFirstFree;
	p_stMyBlockInfoForOutside->p_cMaxMem = p_stMyStBlockInfo->p_cMaxMem; 
}/*Mmg_fn_vGiveInformationBlock*/
 
/* ##F#===================================================================================
NAME :          Mmg_fn_vSaveInformationBlock
DESCRIPTION :   Init a block with the following info structure
					-> address of block beginning
					-> address of block end
					-> address of the first free
					-> the maximum address reached (different of the last address used)
INPUT :			Module Id
				Block ID
				pointer on structure of block info
=========================================================================================
CREATION : 06-11-97/Pierrick Crepy
=======================================================================================*/
void Mmg_fn_vSaveInformationBlock(unsigned char ucModuleId, unsigned char ucBlockId, struct tdstBlockInfo_ *p_stMyBlockInfoFromOutside){
	struct tdstBlockInfoPriv_ * p_stMyStBlockInfo;
 
 
#ifdef __DEBUG_MALLOC_MODE__
#ifdef __FATAL_ERR_MMG__ 
	if (ucBlockId >= g_a_ucBlocksNbInModule[ucModuleId]){
#ifdef __ERROR_STRINGS__
		char szErrTxt[C_ucSizeOfErrTxt];
		sprintf (szErrTxt, "BlockId = %d, but there are only %d Block\nin the module [", ucBlockId, g_a_ucBlocksNbInModule[ucModuleId]);
		Erm_M_GetModuleInformation(szErrTxt+strlen(szErrTxt), ucModuleId);
		sprintf (szErrTxt+strlen(szErrTxt), "]\n");
		Mmg_M_UpdateLastError(E_uwMmgPbInvalidBlockId,szErrTxt);
#else /*__ERROR_STRINGS__*/
		Mmg_M_UpdateLastError(E_uwMmgPbInvalidBlockId,NULL);
#endif /*__ERROR_STRINGS__*/
	}
#endif /*__FATAL_ERR_MMG__*/
#endif /*__DEBUG_MALLOC_MODE__*/
 
	/*implicite else with the fatal error*/
	p_stMyStBlockInfo = g_a_p_stMmgModuleBlocksInfo[ucModuleId]+ucBlockId;
	p_stMyStBlockInfo->p_cBeginBlock = p_stMyBlockInfoFromOutside->p_cBeginBlock ;
	p_stMyStBlockInfo->p_cEndBlock = p_stMyBlockInfoFromOutside->p_cEndBlock;
	p_stMyStBlockInfo->p_cFirstFree = p_stMyBlockInfoFromOutside->p_cFirstFree;
	p_stMyStBlockInfo->p_cMaxMem = p_stMyBlockInfoFromOutside->p_cMaxMem; 
}/*Mmg_fn_vSaveInformationBlock*/
 
/* ##F#===================================================================================
NAME :          Mmg_fn_ulSizeOfUsefullMemory 
DESCRIPTION :   return the size of the usefull memory in a block
INPUT :			Module Id
				Block ID
OUTPUT :		size of usefull memory
=========================================================================================
CREATION : 06-11-97/Pierrick Crepy
=======================================================================================*/
unsigned long Mmg_fn_ulSizeOfUsefullMemory (unsigned char ucModuleId, unsigned char ucBlockId){
	unitAlloc * p_uaLastFree;
	struct tdstBlockInfoPriv_ * p_stMyStBlockInfo;
 
#ifdef __DEBUG_MALLOC_MODE__
#ifdef __FATAL_ERR_MMG__ 
	if (ucBlockId >= g_a_ucBlocksNbInModule[ucModuleId]){
#ifdef __ERROR_STRINGS__
		char szErrTxt[C_ucSizeOfErrTxt];
		sprintf (szErrTxt, "BlockId = %d, but there are only %d Block\nin the module [", ucBlockId, g_a_ucBlocksNbInModule[ucModuleId]);
		Erm_M_GetModuleInformation(szErrTxt+strlen(szErrTxt), ucModuleId);
		sprintf (szErrTxt+strlen(szErrTxt), "]\n");
		Mmg_M_UpdateLastError(E_uwMmgPbInvalidBlockId,szErrTxt);
#else /*__ERROR_STRINGS__*/
		Mmg_M_UpdateLastError(E_uwMmgPbInvalidBlockId,NULL);
#endif /*__ERROR_STRINGS__*/
	}
#endif /*__FATAL_ERR_MMG__*/
#endif /*__DEBUG_MALLOC_MODE__*/
 
	/*implicite else with the fatal error*/
	p_stMyStBlockInfo = g_a_p_stMmgModuleBlocksInfo[ucModuleId]+ucBlockId;
 
	if (p_stMyStBlockInfo->p_cFirstFree == C_FirstFreeValueForBlockWithoutFree ){/* Block with free*/
#ifdef D_CheckSystemForBlockWithoutFree
		return (p_stMyStBlockInfo->p_cMaxMem - p_stMyStBlockInfo->p_cBeginBlock + 1);
#else /*D_CheckSystemForBlockWithoutFree*/
		return (p_stMyStBlockInfo->p_cMaxMem - p_stMyStBlockInfo->p_cBeginBlock + 1 
			- (((tdstInformationHeaderOfBolckWithoutFree *)p_stMyStBlockInfo->p_cBeginBlock)->ucBoundededHeaderSize));
#endif /*D_CheckSystemForBlockWithoutFree*/
	}
	else{ /* Block with free*/
		p_uaLastFree = (unitAlloc *)p_stMyStBlockInfo->p_cFirstFree;
		while (((unitAlloc *)p_uaLastFree != NULL) && ((unitAlloc *)*(p_uaLastFree +1) != NULL) ){
			p_uaLastFree = (unitAlloc *)*(p_uaLastFree +1);
		}
 
		if ( (p_uaLastFree != NULL) && ((char *)(p_uaLastFree + *(p_uaLastFree)))-1 ==  p_stMyStBlockInfo->p_cEndBlock ) {/* the block is not full		*/
			return ( ((char *)(p_uaLastFree + C_ucFreeHeaderSize)) - p_stMyStBlockInfo->p_cBeginBlock);
		}
		else { /* the block is full		*/
			return (p_stMyStBlockInfo->p_cEndBlock - p_stMyStBlockInfo->p_cBeginBlock + 1);
		}
	}
}/*Mmg_fn_ulSizeOfUsefullMemory */
#endif /* _FIRE_DEADCODE_U64_ */
 
 
#ifdef __ERROR_STRINGS__
/* ##F#===================================================================================
NAME :          Mmg_fn_v_UpdateLastErrorWithModuleId
DESCRIPTION :   raise an error using module Id
INPUT :			Module Id
				Error to raise
				Message to display
=========================================================================================
CREATION : 06-11-97/Pierrick Crepy
=======================================================================================*/
void Mmg_fn_v_UpdateLastErrorWithModuleId(unsigned char ucModuleId,unsigned short uwMyErr, char *szPersonalTxt)
{
	char szMyRealTxt[C_ucSizeOfErrTxt];
	
	if (szPersonalTxt != NULL){
		sprintf (szMyRealTxt, "In [");
		Erm_M_GetModuleInformation(szMyRealTxt+strlen(szMyRealTxt), ucModuleId);
		sprintf (szMyRealTxt+strlen(szMyRealTxt), "]\n%s", szPersonalTxt);
	}
	else{
		sprintf (szMyRealTxt, "In [");
		Erm_M_GetModuleInformation(szMyRealTxt+strlen(szMyRealTxt), ucModuleId);
		sprintf (szMyRealTxt+strlen(szMyRealTxt), "]\n");
	}
	Erm_M_UpdateLastError (Mmg, C_ucErmDefaultChannel, uwMyErr, C_lErmNoDebugData, C_ucErmOpenInfoWindow, C_ucAllowStopForDebug, szMyRealTxt);
}
 
/* ##F#===================================================================================
NAME :          Mmg_fn_v_UpdateLastErrorWithCurrentModeInfo
DESCRIPTION :   raise an error using channel
INPUT :			Error to raise
				Message to display
				Channel Id
=========================================================================================
CREATION : 06-11-97/Pierrick Crepy
=======================================================================================*/
void Mmg_fn_v_UpdateLastErrorWithCurrentModeInfo(unsigned short uwMyErr,char * szPersonalTxt,unsigned char ucChannel)
{
	tdstCurrentModeInfo stCurrentModeInfo = g_d_stCurrentModeInfo[ucChannel];
	char szMyRealTxt[C_ucSizeOfErrTxt];
 
	if (stCurrentModeInfo.ucMode == E_ucDynamic)
		if (szPersonalTxt != NULL){
			sprintf (szMyRealTxt, "In [");
			Erm_M_GetModuleInformation(szMyRealTxt+strlen(szMyRealTxt), stCurrentModeInfo.ucModuleId);
			sprintf (szMyRealTxt+strlen(szMyRealTxt), "], for Dynamic mode\n%s", szPersonalTxt);
		}
		else{
			sprintf (szMyRealTxt, "In [");
			Erm_M_GetModuleInformation(szMyRealTxt+strlen(szMyRealTxt), stCurrentModeInfo.ucModuleId);
			sprintf (szMyRealTxt+strlen(szMyRealTxt), "], for Dynamic mode\n");
		}
	else
		if (szPersonalTxt != NULL){
			sprintf (szMyRealTxt, "In [");
			Erm_M_GetModuleInformation(szMyRealTxt+strlen(szMyRealTxt), stCurrentModeInfo.ucModuleId);
			sprintf (szMyRealTxt+strlen(szMyRealTxt), "], for Static mode (Block #%d)\n%s", stCurrentModeInfo.ucMode, szPersonalTxt);
		}
		else{
			sprintf (szMyRealTxt, "In [");
			Erm_M_GetModuleInformation(szMyRealTxt+strlen(szMyRealTxt), stCurrentModeInfo.ucModuleId);
			sprintf (szMyRealTxt+strlen(szMyRealTxt), "], for Static mode (Block #%d)\n", stCurrentModeInfo.ucMode);
		}
	Mmg_M_szAddChannelInfoToSzInitTxt(szMyRealTxt, ucChannel);
	Erm_M_UpdateLastError (Mmg, C_ucErmDefaultChannel, uwMyErr, C_lErmNoDebugData, C_ucErmOpenInfoWindow, C_ucAllowStopForDebug, szMyRealTxt);
}/* end of Mmg_fn_v_UpdateLastErrorWithCurrentModeInfo*/
 
/* ##F#===================================================================================
NAME :          Mmg_fn_v_UpdateLastErrorWithModuleIdAnducModeReference
DESCRIPTION :   raise an error using module id and allocation mode
INPUT :			Module Id
				Allocation Mode
				Error to raise
				Message to display
=========================================================================================
CREATION : 06-11-97/Pierrick Crepy
=======================================================================================*/
void Mmg_fn_v_UpdateLastErrorWithModuleIdAnducModeReference(unsigned char ucModuleId, unsigned char ucMode, unsigned short uwMyErr, char *szPersonalTxt)
{
	char szMyRealTxt[C_ucSizeOfErrTxt];
	if (ucMode == E_ucDynamic)
		if (szPersonalTxt != NULL){
			sprintf (szMyRealTxt, "In [");
			Erm_M_GetModuleInformation(szMyRealTxt+strlen(szMyRealTxt), ucModuleId);
			sprintf (szMyRealTxt+strlen(szMyRealTxt), "], for Dynamic mode\n%s", szPersonalTxt);
		}
		else{
			sprintf (szMyRealTxt, "In [");
			Erm_M_GetModuleInformation(szMyRealTxt+strlen(szMyRealTxt), ucModuleId);
			sprintf (szMyRealTxt+strlen(szMyRealTxt), "], for Dynamic mode\n");
		}
	else
		if (szPersonalTxt != NULL){
			sprintf (szMyRealTxt, "In [");
			Erm_M_GetModuleInformation(szMyRealTxt+strlen(szMyRealTxt), ucModuleId);
			sprintf (szMyRealTxt+strlen(szMyRealTxt), "], for Static mode (Block #%d)\n%s", ucMode, szPersonalTxt);
		}
		else{
			sprintf (szMyRealTxt, "In [");
			Erm_M_GetModuleInformation(szMyRealTxt+strlen(szMyRealTxt), ucModuleId);
			sprintf (szMyRealTxt+strlen(szMyRealTxt), "], for Static mode (Block #%d)\n", ucMode);
		}
	Erm_M_UpdateLastError (Mmg, C_ucErmDefaultChannel, uwMyErr, C_lErmNoDebugData, C_ucErmOpenInfoWindow, C_ucAllowStopForDebug, szMyRealTxt);
}/*end Mmg_fn_v_UpdateLastErrorWithModuleIdAnducModeReference*/
#endif /*__ERROR_STRINGS__*/