/* Allows to dynamically add a mini-driver. */
TA_RetCode TA_SQL_AddMinidriver( const char scheme[], const TA_SQL_Minidriver *minidriver )
{
TA_PROLOG
TA_String *schemeStr;
TA_StringCache *cache;
TA_RetCode retCode;
TA_TRACE_BEGIN( TA_SQL_AddMinidriver );
if( !minidriverDict )
{
minidriverDict = TA_DictAlloc( TA_DICT_KEY_ONE_STRING, NULL );
if( !minidriverDict )
{
TA_TRACE_RETURN( TA_ALLOC_ERR );
}
}
cache = TA_GetGlobalStringCache();
TA_ASSERT( cache != NULL );
schemeStr = TA_StringAlloc( cache, scheme );
if( !schemeStr )
{
TA_DictFree(minidriverDict);
TA_TRACE_RETURN( TA_ALLOC_ERR );
}
retCode = TA_DictAddPair_S( minidriverDict, schemeStr, (void *)minidriver );
TA_StringFree( cache, schemeStr );
TA_TRACE_RETURN( retCode );
}
TA_RetCode TA_DictAddPair_S2( TA_Dict *dict,
TA_String *key1,
TA_String *key2,
void *value )
{
TA_PrivDictInfo *theDict;
dnode_t *node;
TA_String *dupKey;
TA_Dict *subDict;
TA_Libc *libHandle;
dict_t *kazlibDict;
theDict = (TA_PrivDictInfo *)dict;
if( (theDict == NULL) ||
(key1 == NULL) || (key2 == NULL) || (value == NULL) )
return TA_BAD_PARAM;
kazlibDict = &theDict->d;
libHandle = theDict->libHandle;
/* Verify if a a dictionary already exist for key1. */
node = dict_lookup( libHandle, kazlibDict, TA_StringToChar(key1) );
if( node )
{
/* A dictionary already exist with the same key1... re-use it. */
subDict = (TA_Dict *)dnode_get( node );
}
else
{
/* Alloc a new directory corresponding to key1. */
subDict = TA_DictAlloc( libHandle, TA_DICT_KEY_ONE_STRING, theDict->freeValueFunc );
if( !subDict )
return TA_ALLOC_ERR;
dupKey = TA_StringDup( TA_GetGlobalStringCache( libHandle ), key1 );
if( !dupKey )
{
TA_DictFree( subDict );
return TA_ALLOC_ERR;
}
if( !dict_alloc_insert( libHandle, kazlibDict, TA_StringToChar(dupKey), subDict ) )
{
TA_DictFree( subDict );
TA_StringFree( TA_GetGlobalStringCache( libHandle ), dupKey );
return TA_ALLOC_ERR;
}
}
/* Insert the string in the subDict using key2 */
return TA_DictAddPair_S( subDict, key2, value );
}
static TA_RetCode TA_TraceGlobalInit( void **globalToAlloc )
{
TA_TraceGlobal *global;
#if !defined( TA_SINGLE_THREAD )
TA_RetCode retCode;
#endif
if( !globalToAlloc )
return TA_BAD_PARAM;
*globalToAlloc = NULL;
global = TA_Malloc( sizeof( TA_TraceGlobal ) );
if( !global )
return TA_ALLOC_ERR;
memset( global, 0, sizeof( TA_TraceGlobal ) );
#if !defined( TA_SINGLE_THREAD )
/* Initialize the mutexes in a non-block state. */
retCode = TA_SemaInit( &global->callSema, 1 );
if( retCode != TA_SUCCESS )
{
TA_Free( global );
return retCode;
}
retCode = TA_SemaInit( &global->fatalSema, 1 );
if( retCode != TA_SUCCESS )
{
TA_SemaDestroy( &global->callSema );
TA_Free( global );
return retCode;
}
#endif
#ifdef TA_DEBUG
#if defined( TA_SINGLE_THREAD )
/* When single threaded, maintain a calling stack. */
global->callStack = TA_ListAlloc();
if( !global->callStack )
{
TA_Free( global );
return TA_ALLOC_ERR;
}
#endif
/* All function call and checkpoint are maintained in a dictionary. */
global->functionCalled = TA_DictAlloc( TA_DICT_KEY_ONE_STRING, freeTracePosition );
if( !global->functionCalled )
{
#if !defined( TA_SINGLE_THREAD )
TA_SemaDestroy( &global->callSema );
TA_SemaDestroy( &global->fatalSema );
#else
TA_ListFree( global->callStack );
#endif
TA_Free( global );
return TA_ALLOC_ERR;
}
#endif
/* Success, return the allocated memory to the caller. */
*globalToAlloc = global;
return TA_SUCCESS;
}
TA_RetCode TA_TradeLogAlloc( TA_TradeLog **allocatedTradeLog )
{
TA_TradeLog *tradeLog;
TA_TradeLogPriv *tradeLogPriv;
TA_RetCode retCode;
if( allocatedTradeLog )
*allocatedTradeLog = NULL;
else
return TA_BAD_PARAM;
/* Allocate the public and private structure. */
tradeLog = TA_Malloc( sizeof( TA_TradeLog ) + sizeof( TA_TradeLogPriv ) );
if( !tradeLog )
return TA_ALLOC_ERR;
memset( tradeLog, 0, sizeof( TA_TradeLog ) + sizeof( TA_TradeLogPriv ) );
tradeLogPriv = (TA_TradeLogPriv *)(((char *)tradeLog)+sizeof(TA_TradeLog));
tradeLogPriv->magicNb = TA_TRADELOGPRIV_MAGIC_NB;
tradeLog->hiddenData = tradeLogPriv;
TA_ListInit( &tradeLogPriv->defaultDictEntry.shortEntryPrivList );
TA_ListInit( &tradeLogPriv->defaultDictEntry.longEntryPrivList );
/* TA_TradeLogFree can be safely called from this point. */
tradeLogPriv->tradeDictCAT = TA_DictAlloc( TA_DICT_KEY_ONE_STRING, freeTradeDictEntry );
if( !tradeLogPriv->tradeDictCAT )
{
TA_TradeLogFree( tradeLog );
return TA_ALLOC_ERR;
}
tradeLogPriv->tradeDictSYM = TA_DictAlloc( TA_DICT_KEY_ONE_STRING, freeTradeDictEntry );
if( !tradeLogPriv->tradeDictSYM )
{
TA_TradeLogFree( tradeLog );
return TA_ALLOC_ERR;
}
tradeLogPriv->tradeDictCATSYM = TA_DictAlloc( TA_DICT_KEY_TWO_STRING, freeTradeDictEntry );
if( !tradeLogPriv->tradeDictCATSYM )
{
TA_TradeLogFree( tradeLog );
return TA_ALLOC_ERR;
}
tradeLogPriv->tradeDictUserKey = TA_DictAlloc( TA_DICT_KEY_INTEGER, freeTradeDictEntry );
if( !tradeLogPriv->tradeDictUserKey )
{
TA_TradeLogFree( tradeLog );
return TA_ALLOC_ERR;
}
retCode = TA_AllocatorForDataLog_Init( &tradeLogPriv->allocator );
if( retCode != TA_SUCCESS )
{
TA_TradeLogFree( tradeLog );
return retCode;
}
/* Initialize the caller pointer on the allocated TA_TradeLog */
*allocatedTradeLog = tradeLog;
return TA_SUCCESS;
}