Embedded/common/src/b_BasicEm/Context.c - platform/external/neven - Gitiles

 /*
  * Copyright (C) 2008 The Android Open Source Project
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at
  *
  *      http://www.apache.org/licenses/LICENSE-2.0
  *
  * Unless required by applicable law or agreed to in writing, software
  * distributed under the License is distributed on an "AS IS" BASIS,
  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */

 /* ---- includes ----------------------------------------------------------- */

 #include "b_BasicEm/Functions.h"
 #include "b_BasicEm/Context.h"
 #include "b_BasicEm/String.h"

 /* ------------------------------------------------------------------------- */

 /* ========================================================================= */
 /*                                                                           */
 /* ---- \ghd{ auxiliary functions } ---------------------------------------- */
 /*                                                                           */
 /* ========================================================================= */

 /* ------------------------------------------------------------------------- */

 /* ========================================================================= */
 /*                                                                           */
 /* ---- \ghd{ constructor / destructor } ----------------------------------- */
 /*                                                                           */
 /* ========================================================================= */

 /* ------------------------------------------------------------------------- */

 void bbs_Context_init( struct bbs_Context* cpA )
 {
 	uint32 iL;
 	for( iL = 0; iL < bbs_CONTEXT_MAX_ERRORS; iL++ )
 	{
 		cpA->errStackE[ iL ].errorE = bbs_ERR_OK;
 		cpA->errStackE[ iL ].fileE[ 0 ] = 0;
 		cpA->errStackE[ iL ].lineE = 0;
 		cpA->errStackE[ iL ].textE[ 0 ] = 0;
 	}

 	cpA->errIndexE = 0;

 	bbs_MemTbl_init( cpA, &cpA->memTblE );

 	for( iL = 0; iL < bbs_CONTEXT_MAX_MEM_MANAGERS; iL++ )
 	{
 		bbs_DynMemManager_init( cpA, &cpA->dynMemManagerArrE[ iL ] );
 	}

 	cpA->dynMemManagerArrSizeE = 0;
 	cpA->errorHandlerE = NULL;
 	cpA->callbackHandlerE = NULL;
 	cpA->userPtrE = NULL;
 }

 /* ------------------------------------------------------------------------- */

 void bbs_Context_exit( struct bbs_Context* cpA )
 {
 	uint32 iL;
 	for( iL = 0; iL < bbs_CONTEXT_MAX_ERRORS; iL++ )
 	{
 		cpA->errStackE[ iL ].errorE = bbs_ERR_OK;
 		cpA->errStackE[ iL ].fileE[ 0 ] = 0;
 		cpA->errStackE[ iL ].lineE = 0;
 		cpA->errStackE[ iL ].textE[ 0 ] = 0;
 	}

 	cpA->errIndexE = 0;

 	bbs_MemTbl_exit( cpA, &cpA->memTblE );

 	for( iL = 0; iL < cpA->dynMemManagerArrSizeE; iL++ )
 	{
 		bbs_DynMemManager_freeAll( cpA, &cpA->dynMemManagerArrE[ iL ] );
 	}

 	for( iL = 0; iL < bbs_CONTEXT_MAX_MEM_MANAGERS; iL++ )
 	{
 		bbs_DynMemManager_exit( cpA, &cpA->dynMemManagerArrE[ iL ] );
 	}

 	cpA->dynMemManagerArrSizeE = 0;
 	cpA->errorHandlerE = NULL;
 	cpA->callbackHandlerE = NULL;
 	cpA->userPtrE = NULL;
 }

 /* ------------------------------------------------------------------------- */

 /* ========================================================================= */
 /*                                                                           */
 /* ---- \ghd{ operators } -------------------------------------------------- */
 /*                                                                           */
 /* ========================================================================= */

 /* ------------------------------------------------------------------------- */

 void bbs_Context_copy( struct bbs_Context* cpA, const struct bbs_Context* srcPtrA )
 {
 	bbs_ERROR0( "void bbs_Context_copy( struct bbs_Context* cpA, const struct bbs_Context* srcPtrA ):\n"
 		        "A comtext object cannot be copied" );
 }

 /* ------------------------------------------------------------------------- */

 /* ========================================================================= */
 /*                                                                           */
 /* ---- \ghd{ query functions } -------------------------------------------- */
 /*                                                                           */
 /* ========================================================================= */

 /* ------------------------------------------------------------------------- */

 /* ========================================================================= */
 /*                                                                           */
 /* ---- \ghd{ modify functions } ------------------------------------------- */
 /*                                                                           */
 /* ========================================================================= */

 /* ------------------------------------------------------------------------- */

 struct bbs_Error bbs_Error_create( uint32 errorA,
 								   uint32 lineA,
 								   const char* fileA,
 								   const char* textA,
 								   ... )
 {
 	struct bbs_Error errorL;
 	errorL.errorE = errorA;
 	errorL.lineE = lineA;

 	if( fileA != NULL )
 	{
 		uint32 lenL = bbs_strlen( fileA );
 		uint32 ofsL = ( lenL + 1 > bbs_ERROR_MAX_FILE_CHARS ) ? lenL + 1 - bbs_ERROR_MAX_FILE_CHARS : 0;
 		bbs_strcpy( errorL.fileE, fileA + ofsL );
 	}
 	else
 	{
 		errorL.fileE[ 0 ] = 0;
 	}

 	if( textA != NULL )
 	{
 		va_list argsL;
 		va_start( argsL, textA );
 		bbs_vsnprintf( errorL.textE, bbs_ERROR_MAX_TEXT_CHARS, textA, argsL );
 		va_end( argsL );
 	}
 	else
 	{
 		errorL.textE[ 0 ] = 0;
 	}

 	return errorL;
 }

 /* ------------------------------------------------------------------------- */

 /* ========================================================================= */
 /*                                                                           */
 /* ---- \ghd{ I/O } -------------------------------------------------------- */
 /*                                                                           */
 /* ========================================================================= */

 /* ------------------------------------------------------------------------- */

 /* ========================================================================= */
 /*                                                                           */
 /* ---- \ghd{ exec functions } --------------------------------------------- */
 /*                                                                           */
 /* ========================================================================= */

 /* ------------------------------------------------------------------------- */

 flag bbs_Context_pushError( struct bbs_Context* cpA, struct bbs_Error errorA )
 {
 	flag returnL = FALSE;
 	if( cpA->errIndexE < bbs_CONTEXT_MAX_ERRORS )
 	{
 		cpA->errStackE[ cpA->errIndexE++ ] = errorA;
 		returnL = TRUE;
 	}

 	if( cpA->errorHandlerE != NULL )
 	{
 		cpA->errorHandlerE( cpA );
 	}

 	return returnL;
 }

 /* ------------------------------------------------------------------------- */

 struct bbs_Error bbs_Context_popError( struct bbs_Context* cpA )
 {
 	if( cpA->errIndexE > 0 )
 	{
 		return cpA->errStackE[ --( cpA->errIndexE ) ];
 	}
 	else
 	{
 		return cpA->errStackE[ 0 ];
 	}
 }

 /* ------------------------------------------------------------------------- */

 struct bbs_Error bbs_Context_peekError( struct bbs_Context* cpA )
 {
 	if( cpA->errIndexE > 0 )
 	{
 		return cpA->errStackE[ cpA->errIndexE - 1 ];
 	}
 	else
 	{
 		return cpA->errStackE[ 0 ];
 	}
 }

 /* ------------------------------------------------------------------------- */

 flag bbs_Context_error( struct bbs_Context* cpA )
 {
 	return cpA->errIndexE > 0;
 }

 /* ------------------------------------------------------------------------- */

 bbs_errorFPtr bbs_Context_setErrorHandler( struct bbs_Context* cpA,
 									       bbs_errorFPtr errorHandlerA )
 {
 	bbs_errorFPtr oldErrorHandlerL = cpA->errorHandlerE;
 	cpA->errorHandlerE = errorHandlerA;
 	return oldErrorHandlerL;
 }

 /* ------------------------------------------------------------------------- */

 void bbs_Context_doCallback( struct bbs_Context* cpA )
 {
 	if( cpA->callbackHandlerE != NULL )
 	{
 		uint32 errorL = ( *cpA->callbackHandlerE )( cpA );
 		if( errorL != bbs_ERR_OK )
 		{
 			bbs_Context_pushError( cpA, bbs_Error_create( errorL, 0, NULL, NULL ) );
 		}
 	}
 }

 /* ------------------------------------------------------------------------- */

 bbs_callbackFPtr bbs_Context_setCallbackHandler( struct bbs_Context* cpA,
 									       bbs_callbackFPtr callbackHandlerA )
 {
 	bbs_callbackFPtr oldCallbackHandlerL = cpA->callbackHandlerE;
 	cpA->callbackHandlerE = callbackHandlerA;
 	return oldCallbackHandlerL;
 }

 /* ------------------------------------------------------------------------- */

 /** adds a static memory segment to memory table of context */
 void bbs_Context_addStaticSeg(	struct bbs_Context* cpA,
 							    uint16* memPtrA, /* pointer to memory */
 								uint32 sizeA,    /* size of memory segment in 16 bit units */
 								flag sharedA,    /* Indicates that this segment is to be shared among multiple objects */
 								uint32 idA )     /* ID of segment, id=0: unspecified */
 {
 	struct bbs_MemSeg memSegL;
 	bbs_DEF_fNameL( "void bbs_Context_addStaticSeg(....)" )


 	/* checks */
 	if( sharedA && cpA->memTblE.ssSizeE == bbs_MAX_MEM_SEGS )
 	{
 		bbs_ERROR1( "%s:\nShared Memory Table is full! Increase bbs_MAX_MEM_SEGS", fNameL );
 		return;
 	}
 	if( sharedA && cpA->memTblE.esSizeE == bbs_MAX_MEM_SEGS )
 	{
 		bbs_ERROR1( "%s:\nExclusive Memory Table is full! Increase bbs_MAX_MEM_SEGS", fNameL );
 		return;
 	}


 	bbs_MemSeg_init( cpA, &memSegL );
 	memSegL.memPtrE = memPtrA;
 	memSegL.sizeE = sizeA;
 	memSegL.allocIndexE = 0;
 	memSegL.sharedE = sharedA;
 	memSegL.idE = idA;
 	memSegL.dynMemManagerPtrE = NULL;

 	if( sharedA )
 	{
 		cpA->memTblE.ssArrE[ cpA->memTblE.ssSizeE++ ] = memSegL;
 	}
 	else
 	{
 		cpA->memTblE.esArrE[ cpA->memTblE.esSizeE ] = memSegL;
 		cpA->memTblE.espArrE[ cpA->memTblE.esSizeE ] = &cpA->memTblE.esArrE[ cpA->memTblE.esSizeE ];
 		cpA->memTblE.esSizeE++;
 	}
 }

 /* ------------------------------------------------------------------------- */

 /* adds a dynamic memory segment to memory table of context
  * Upon destruction of the context object any residual will be freed automatically
  */
 void bbs_Context_addDynamicSeg(	struct bbs_Context* cpA,
 								bbs_mallocFPtr mallocFPtrA,	/* function pointer to external mem alloc function (s. comment of type declaration)*/
 								bbs_freeFPtr freeFPtrA,     /* function pointer to external mem free function */
 								flag sharedA,    /* Indicates that this segment is to be shared among multiple objects */
 								uint32 idA )     /* ID of segment, id=0: unspecified */
 {
 	struct bbs_DynMemManager memManagerL;
 	struct bbs_MemSeg memSegL;
 	bbs_DEF_fNameL( "void bbs_Context_addDynamicSeg(....)" )


 	/* checks */
 	if( cpA->dynMemManagerArrSizeE == bbs_CONTEXT_MAX_MEM_MANAGERS )
 	{
 		bbs_ERROR1( "%s:\nMemory Manager Table is full! Increase bbs_CONTEXT_MAX_MEM_MANAGERS", fNameL );
 		return;
 	}
 	if( sharedA && cpA->memTblE.ssSizeE == bbs_MAX_MEM_SEGS )
 	{
 		bbs_ERROR1( "%s:\nShared Memory Table is full! Increase bbs_MAX_MEM_SEGS", fNameL );
 		return;
 	}
 	if( sharedA && cpA->memTblE.esSizeE == bbs_MAX_MEM_SEGS )
 	{
 		bbs_ERROR1( "%s:\nExclusive Memory Table is full! Increase bbs_MAX_MEM_SEGS", fNameL );
 		return;
 	}

 	bbs_DynMemManager_init( cpA, &memManagerL );
 	memManagerL.mallocFPtrE = mallocFPtrA;
 	memManagerL.freeFPtrE = freeFPtrA;
 	memManagerL.memPtrE = NULL;
 	cpA->dynMemManagerArrE[ cpA->dynMemManagerArrSizeE++ ] = memManagerL;

 	bbs_MemSeg_init( cpA, &memSegL );
 	memSegL.memPtrE = NULL;
 	memSegL.sizeE = 0;
 	memSegL.allocIndexE = 0;
 	memSegL.sharedE = sharedA;
 	memSegL.idE = idA;
 	memSegL.dynMemManagerPtrE = &cpA->dynMemManagerArrE[ cpA->dynMemManagerArrSizeE - 1 ];

 	if( sharedA )
 	{
 		cpA->memTblE.ssArrE[ cpA->memTblE.ssSizeE++ ] = memSegL;
 	}
 	else
 	{
 		cpA->memTblE.esArrE[ cpA->memTblE.esSizeE ] = memSegL;
 		cpA->memTblE.espArrE[ cpA->memTblE.esSizeE ] = &cpA->memTblE.esArrE[ cpA->memTblE.esSizeE ];
 		cpA->memTblE.esSizeE++;
 	}
 }

 /* ------------------------------------------------------------------------- */

 uint32 bbs_Context_exclAllocSize( struct bbs_Context* cpA, uint32 segIndexA )
 {
 	return bbs_MemSeg_allocatedSize( cpA, &cpA->memTblE.esArrE[ segIndexA ] );
 }

 /* ------------------------------------------------------------------------- */

 uint32 bbs_Context_shrdAllocSize( struct bbs_Context* cpA, uint32 segIndexA )
 {
 	return bbs_MemSeg_allocatedSize( cpA, &cpA->memTblE.ssArrE[ segIndexA ] );
 }

 /* ------------------------------------------------------------------------- */

 void bbs_Context_quickInit( struct bbs_Context* cpA,
 	 					    bbs_mallocFPtr mallocFPtrA,	/* function pointer to external mem alloc function (s. comment of type declaration)*/
 						    bbs_freeFPtr freeFPtrA,
 						    bbs_errorFPtr errorHandlerA )
 {
 	bbs_Context_init( cpA );
 	bbs_Context_addDynamicSeg( cpA, mallocFPtrA, freeFPtrA, FALSE, 0 );
 	bbs_Context_addDynamicSeg( cpA, mallocFPtrA, freeFPtrA, TRUE, 0 );
 	bbs_Context_setErrorHandler( cpA, errorHandlerA );
 }

 /* ------------------------------------------------------------------------- */

 /* ========================================================================= */
	/*
	* Copyright (C) 2008 The Android Open Source Project
	*
	* Licensed under the Apache License, Version 2.0 (the "License");
	* you may not use this file except in compliance with the License.
	* You may obtain a copy of the License at
	*
	* http://www.apache.org/licenses/LICENSE-2.0
	*
	* Unless required by applicable law or agreed to in writing, software
	* distributed under the License is distributed on an "AS IS" BASIS,
	* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
	* See the License for the specific language governing permissions and
	* limitations under the License.
	*/

	/* ---- includes ----------------------------------------------------------- */

	#include "b_BasicEm/Functions.h"
	#include "b_BasicEm/Context.h"
	#include "b_BasicEm/String.h"

	/* ------------------------------------------------------------------------- */

	/* ========================================================================= */
	/* */
	/* ---- \ghd{ auxiliary functions } ---------------------------------------- */
	/* */
	/* ========================================================================= */

	/* ------------------------------------------------------------------------- */

	/* ========================================================================= */
	/* */
	/* ---- \ghd{ constructor / destructor } ----------------------------------- */
	/* */
	/* ========================================================================= */

	/* ------------------------------------------------------------------------- */

	void bbs_Context_init( struct bbs_Context* cpA )
	{
	uint32 iL;
	for( iL = 0; iL < bbs_CONTEXT_MAX_ERRORS; iL++ )
	{
	cpA->errStackE[ iL ].errorE = bbs_ERR_OK;
	cpA->errStackE[ iL ].fileE[ 0 ] = 0;
	cpA->errStackE[ iL ].lineE = 0;
	cpA->errStackE[ iL ].textE[ 0 ] = 0;
	}

	cpA->errIndexE = 0;

	bbs_MemTbl_init( cpA, &cpA->memTblE );

	for( iL = 0; iL < bbs_CONTEXT_MAX_MEM_MANAGERS; iL++ )
	{
	bbs_DynMemManager_init( cpA, &cpA->dynMemManagerArrE[ iL ] );
	}

	cpA->dynMemManagerArrSizeE = 0;
	cpA->errorHandlerE = NULL;
	cpA->callbackHandlerE = NULL;
	cpA->userPtrE = NULL;
	}

	/* ------------------------------------------------------------------------- */

	void bbs_Context_exit( struct bbs_Context* cpA )
	{
	uint32 iL;
	for( iL = 0; iL < bbs_CONTEXT_MAX_ERRORS; iL++ )
	{
	cpA->errStackE[ iL ].errorE = bbs_ERR_OK;
	cpA->errStackE[ iL ].fileE[ 0 ] = 0;
	cpA->errStackE[ iL ].lineE = 0;
	cpA->errStackE[ iL ].textE[ 0 ] = 0;
	}

	cpA->errIndexE = 0;

	bbs_MemTbl_exit( cpA, &cpA->memTblE );

	for( iL = 0; iL < cpA->dynMemManagerArrSizeE; iL++ )
	{
	bbs_DynMemManager_freeAll( cpA, &cpA->dynMemManagerArrE[ iL ] );
	}

	for( iL = 0; iL < bbs_CONTEXT_MAX_MEM_MANAGERS; iL++ )
	{
	bbs_DynMemManager_exit( cpA, &cpA->dynMemManagerArrE[ iL ] );
	}

	cpA->dynMemManagerArrSizeE = 0;
	cpA->errorHandlerE = NULL;
	cpA->callbackHandlerE = NULL;
	cpA->userPtrE = NULL;
	}

	/* ------------------------------------------------------------------------- */

	/* ========================================================================= */
	/* */
	/* ---- \ghd{ operators } -------------------------------------------------- */
	/* */
	/* ========================================================================= */

	/* ------------------------------------------------------------------------- */

	void bbs_Context_copy( struct bbs_Context* cpA, const struct bbs_Context* srcPtrA )
	{
	bbs_ERROR0( "void bbs_Context_copy( struct bbs_Context* cpA, const struct bbs_Context* srcPtrA ):\n"
	"A comtext object cannot be copied" );
	}

	/* ------------------------------------------------------------------------- */

	/* ========================================================================= */
	/* */
	/* ---- \ghd{ query functions } -------------------------------------------- */
	/* */
	/* ========================================================================= */

	/* ------------------------------------------------------------------------- */

	/* ========================================================================= */
	/* */
	/* ---- \ghd{ modify functions } ------------------------------------------- */
	/* */
	/* ========================================================================= */

	/* ------------------------------------------------------------------------- */

	struct bbs_Error bbs_Error_create( uint32 errorA,
	uint32 lineA,
	const char* fileA,
	const char* textA,
	... )
	{
	struct bbs_Error errorL;
	errorL.errorE = errorA;
	errorL.lineE = lineA;

	if( fileA != NULL )
	{
	uint32 lenL = bbs_strlen( fileA );
	uint32 ofsL = ( lenL + 1 > bbs_ERROR_MAX_FILE_CHARS ) ? lenL + 1 - bbs_ERROR_MAX_FILE_CHARS : 0;
	bbs_strcpy( errorL.fileE, fileA + ofsL );
	}
	else
	{
	errorL.fileE[ 0 ] = 0;
	}

	if( textA != NULL )
	{
	va_list argsL;
	va_start( argsL, textA );
	bbs_vsnprintf( errorL.textE, bbs_ERROR_MAX_TEXT_CHARS, textA, argsL );
	va_end( argsL );
	}
	else
	{
	errorL.textE[ 0 ] = 0;
	}

	return errorL;
	}

	/* ------------------------------------------------------------------------- */

	/* ========================================================================= */
	/* */
	/* ---- \ghd{ I/O } -------------------------------------------------------- */
	/* */
	/* ========================================================================= */

	/* ------------------------------------------------------------------------- */

	/* ========================================================================= */
	/* */
	/* ---- \ghd{ exec functions } --------------------------------------------- */
	/* */
	/* ========================================================================= */

	/* ------------------------------------------------------------------------- */

	flag bbs_Context_pushError( struct bbs_Context* cpA, struct bbs_Error errorA )
	{
	flag returnL = FALSE;
	if( cpA->errIndexE < bbs_CONTEXT_MAX_ERRORS )
	{
	cpA->errStackE[ cpA->errIndexE++ ] = errorA;
	returnL = TRUE;
	}

	if( cpA->errorHandlerE != NULL )
	{
	cpA->errorHandlerE( cpA );
	}

	return returnL;
	}

	/* ------------------------------------------------------------------------- */

	struct bbs_Error bbs_Context_popError( struct bbs_Context* cpA )
	{
	if( cpA->errIndexE > 0 )
	{
	return cpA->errStackE[ --( cpA->errIndexE ) ];
	}
	else
	{
	return cpA->errStackE[ 0 ];
	}
	}

	/* ------------------------------------------------------------------------- */

	struct bbs_Error bbs_Context_peekError( struct bbs_Context* cpA )
	{
	if( cpA->errIndexE > 0 )
	{
	return cpA->errStackE[ cpA->errIndexE - 1 ];
	}
	else
	{
	return cpA->errStackE[ 0 ];
	}
	}

	/* ------------------------------------------------------------------------- */

	flag bbs_Context_error( struct bbs_Context* cpA )
	{
	return cpA->errIndexE > 0;
	}

	/* ------------------------------------------------------------------------- */

	bbs_errorFPtr bbs_Context_setErrorHandler( struct bbs_Context* cpA,
	bbs_errorFPtr errorHandlerA )
	{
	bbs_errorFPtr oldErrorHandlerL = cpA->errorHandlerE;
	cpA->errorHandlerE = errorHandlerA;
	return oldErrorHandlerL;
	}

	/* ------------------------------------------------------------------------- */

	void bbs_Context_doCallback( struct bbs_Context* cpA )
	{
	if( cpA->callbackHandlerE != NULL )
	{
	uint32 errorL = ( *cpA->callbackHandlerE )( cpA );
	if( errorL != bbs_ERR_OK )
	{
	bbs_Context_pushError( cpA, bbs_Error_create( errorL, 0, NULL, NULL ) );
	}
	}
	}

	/* ------------------------------------------------------------------------- */

	bbs_callbackFPtr bbs_Context_setCallbackHandler( struct bbs_Context* cpA,
	bbs_callbackFPtr callbackHandlerA )
	{
	bbs_callbackFPtr oldCallbackHandlerL = cpA->callbackHandlerE;
	cpA->callbackHandlerE = callbackHandlerA;
	return oldCallbackHandlerL;
	}

	/* ------------------------------------------------------------------------- */

	/** adds a static memory segment to memory table of context */
	void bbs_Context_addStaticSeg( struct bbs_Context* cpA,
	uint16* memPtrA, /* pointer to memory */
	uint32 sizeA, /* size of memory segment in 16 bit units */
	flag sharedA, /* Indicates that this segment is to be shared among multiple objects */
	uint32 idA ) /* ID of segment, id=0: unspecified */
	{
	struct bbs_MemSeg memSegL;
	bbs_DEF_fNameL( "void bbs_Context_addStaticSeg(....)" )


	/* checks */
	if( sharedA && cpA->memTblE.ssSizeE == bbs_MAX_MEM_SEGS )
	{
	bbs_ERROR1( "%s:\nShared Memory Table is full! Increase bbs_MAX_MEM_SEGS", fNameL );
	return;
	}
	if( sharedA && cpA->memTblE.esSizeE == bbs_MAX_MEM_SEGS )
	{
	bbs_ERROR1( "%s:\nExclusive Memory Table is full! Increase bbs_MAX_MEM_SEGS", fNameL );
	return;
	}


	bbs_MemSeg_init( cpA, &memSegL );
	memSegL.memPtrE = memPtrA;
	memSegL.sizeE = sizeA;
	memSegL.allocIndexE = 0;
	memSegL.sharedE = sharedA;
	memSegL.idE = idA;
	memSegL.dynMemManagerPtrE = NULL;

	if( sharedA )
	{
	cpA->memTblE.ssArrE[ cpA->memTblE.ssSizeE++ ] = memSegL;
	}
	else
	{
	cpA->memTblE.esArrE[ cpA->memTblE.esSizeE ] = memSegL;
	cpA->memTblE.espArrE[ cpA->memTblE.esSizeE ] = &cpA->memTblE.esArrE[ cpA->memTblE.esSizeE ];
	cpA->memTblE.esSizeE++;
	}
	}

	/* ------------------------------------------------------------------------- */

	/* adds a dynamic memory segment to memory table of context
	* Upon destruction of the context object any residual will be freed automatically
	*/
	void bbs_Context_addDynamicSeg( struct bbs_Context* cpA,
	bbs_mallocFPtr mallocFPtrA, /* function pointer to external mem alloc function (s. comment of type declaration)*/
	bbs_freeFPtr freeFPtrA, /* function pointer to external mem free function */
	flag sharedA, /* Indicates that this segment is to be shared among multiple objects */
	uint32 idA ) /* ID of segment, id=0: unspecified */
	{
	struct bbs_DynMemManager memManagerL;
	struct bbs_MemSeg memSegL;
	bbs_DEF_fNameL( "void bbs_Context_addDynamicSeg(....)" )


	/* checks */
	if( cpA->dynMemManagerArrSizeE == bbs_CONTEXT_MAX_MEM_MANAGERS )
	{
	bbs_ERROR1( "%s:\nMemory Manager Table is full! Increase bbs_CONTEXT_MAX_MEM_MANAGERS", fNameL );
	return;
	}
	if( sharedA && cpA->memTblE.ssSizeE == bbs_MAX_MEM_SEGS )
	{
	bbs_ERROR1( "%s:\nShared Memory Table is full! Increase bbs_MAX_MEM_SEGS", fNameL );
	return;
	}
	if( sharedA && cpA->memTblE.esSizeE == bbs_MAX_MEM_SEGS )
	{
	bbs_ERROR1( "%s:\nExclusive Memory Table is full! Increase bbs_MAX_MEM_SEGS", fNameL );
	return;
	}

	bbs_DynMemManager_init( cpA, &memManagerL );
	memManagerL.mallocFPtrE = mallocFPtrA;
	memManagerL.freeFPtrE = freeFPtrA;
	memManagerL.memPtrE = NULL;
	cpA->dynMemManagerArrE[ cpA->dynMemManagerArrSizeE++ ] = memManagerL;

	bbs_MemSeg_init( cpA, &memSegL );
	memSegL.memPtrE = NULL;
	memSegL.sizeE = 0;
	memSegL.allocIndexE = 0;
	memSegL.sharedE = sharedA;
	memSegL.idE = idA;
	memSegL.dynMemManagerPtrE = &cpA->dynMemManagerArrE[ cpA->dynMemManagerArrSizeE - 1 ];

	if( sharedA )
	{
	cpA->memTblE.ssArrE[ cpA->memTblE.ssSizeE++ ] = memSegL;
	}
	else
	{
	cpA->memTblE.esArrE[ cpA->memTblE.esSizeE ] = memSegL;
	cpA->memTblE.espArrE[ cpA->memTblE.esSizeE ] = &cpA->memTblE.esArrE[ cpA->memTblE.esSizeE ];
	cpA->memTblE.esSizeE++;
	}
	}

	/* ------------------------------------------------------------------------- */

	uint32 bbs_Context_exclAllocSize( struct bbs_Context* cpA, uint32 segIndexA )
	{
	return bbs_MemSeg_allocatedSize( cpA, &cpA->memTblE.esArrE[ segIndexA ] );
	}

	/* ------------------------------------------------------------------------- */

	uint32 bbs_Context_shrdAllocSize( struct bbs_Context* cpA, uint32 segIndexA )
	{
	return bbs_MemSeg_allocatedSize( cpA, &cpA->memTblE.ssArrE[ segIndexA ] );
	}

	/* ------------------------------------------------------------------------- */

	void bbs_Context_quickInit( struct bbs_Context* cpA,
	bbs_mallocFPtr mallocFPtrA, /* function pointer to external mem alloc function (s. comment of type declaration)*/
	bbs_freeFPtr freeFPtrA,
	bbs_errorFPtr errorHandlerA )
	{
	bbs_Context_init( cpA );
	bbs_Context_addDynamicSeg( cpA, mallocFPtrA, freeFPtrA, FALSE, 0 );
	bbs_Context_addDynamicSeg( cpA, mallocFPtrA, freeFPtrA, TRUE, 0 );
	bbs_Context_setErrorHandler( cpA, errorHandlerA );
	}

	/* ------------------------------------------------------------------------- */

	/* ========================================================================= */