static TA_RetCode freeFileIndexPriv( void *toBeFreed )
{
TA_PROLOG;
TA_FileIndexPriv *asciiFileData;
TA_Libc *libHandle;
TA_StringCache *stringCache;
asciiFileData = (TA_FileIndexPriv *)toBeFreed;
libHandle = asciiFileData->libHandle;
TA_TRACE_BEGIN( libHandle, freeFileIndexPriv );
stringCache = TA_GetGlobalStringCache( libHandle );
if( !asciiFileData )
{
TA_TRACE_RETURN( TA_ALLOC_ERR );
}
if( freeListAndElement( libHandle, asciiFileData->listLocationToken, freeTokenInfo ) != TA_SUCCESS )
{
TA_TRACE_RETURN( TA_ALLOC_ERR );
}
if( freeListAndElement( libHandle, asciiFileData->listCategory, freeCategoryData ) != TA_SUCCESS )
{
TA_TRACE_RETURN( TA_ALLOC_ERR );
}
if( asciiFileData->root )
TA_FileIndexFreeValueTree( libHandle, asciiFileData->root );
if( asciiFileData->scratchPad )
TA_Free( libHandle, asciiFileData->scratchPad );
if( asciiFileData->wildOneChar )
TA_StringFree( stringCache, asciiFileData->wildOneChar );
if( asciiFileData->wildZeroOrMoreChar )
TA_StringFree( stringCache, asciiFileData->wildZeroOrMoreChar );
if( asciiFileData->wildOneOrMoreChar )
TA_StringFree( stringCache, asciiFileData->wildOneOrMoreChar );
if( asciiFileData->initialCategoryString )
TA_StringFree( stringCache, asciiFileData->initialCategoryString );
if( asciiFileData->initialCategoryCountryString )
TA_StringFree( stringCache, asciiFileData->initialCategoryCountryString );
if( asciiFileData->initialCategoryExchangeString )
TA_StringFree( stringCache, asciiFileData->initialCategoryExchangeString );
if( asciiFileData->initialCategoryTypeString )
TA_StringFree( stringCache, asciiFileData->initialCategoryTypeString );
TA_Free( libHandle, asciiFileData );
TA_TRACE_RETURN( TA_SUCCESS );
}
/* Generated */ TA_LIB_API TA_RetCode TA_ACCBANDS_StateFree( struct TA_ACCBANDS_State** _state )
/* Generated */
/* Generated */ #endif
/**** END GENCODE SECTION 9 - DO NOT DELETE THIS LINE ****/
{
/* insert local variable here */
TA_RetCode retCode;
retCode = FUNCTION_CALL_STATE_FREE(SMA)( (struct TA_SMA_State**) &STATE_P.stateSMA1 );
if (retCode != ENUM_VALUE(RetCode,TA_SUCCESS,Success)) return retCode;
retCode = FUNCTION_CALL_STATE_FREE(SMA)( (struct TA_SMA_State**) &STATE_P.stateSMA2 );
if (retCode != ENUM_VALUE(RetCode,TA_SUCCESS,Success)) return retCode;
retCode = FUNCTION_CALL_STATE_FREE(SMA)( (struct TA_SMA_State**) &STATE_P.stateSMA3 );
if (retCode != ENUM_VALUE(RetCode,TA_SUCCESS,Success)) return retCode;
/**** START GENCODE SECTION 10 - DO NOT DELETE THIS LINE ****/
/* Generated */
/* Generated */ #ifndef TA_FUNC_NO_RANGE_CHECK
/* Generated */
/* Generated */ if (_state == NULL)
/* Generated */ return ENUM_VALUE(RetCode,TA_BAD_PARAM,BadParam);
/* Generated */ if (STATE != NULL) {
/* Generated */ if (MEM_P != NULL) TA_Free(MEM_P);
/* Generated */ TA_Free(STATE); STATE = NULL;}
/* Generated */
/* Generated */ #endif /* TA_FUNC_NO_RANGE_CHECK */
/* Generated */
/**** END GENCODE SECTION 10 - DO NOT DELETE THIS LINE ****/
/* insert state free code here. */
return ENUM_VALUE(RetCode,TA_SUCCESS,Success);
}
TA_RetCode TA_FuncTableFree( TA_StringTable *table )
{
TA_StringTableFuncHidden *stringTableHidden;
TA_Libc *libHandle;
if( table )
{
stringTableHidden = (TA_StringTableFuncHidden *)table->hiddenData;
if( !stringTableHidden )
return TA_INTERNAL_ERROR(3);
if( stringTableHidden->magicNb != TA_STRING_TABLE_FUNC_MAGIC_NB )
return TA_BAD_OBJECT;
libHandle = stringTableHidden->libHandle;
TA_Free( libHandle, stringTableHidden );
if( table->string )
TA_Free( libHandle, (void *)table->string );
TA_Free( libHandle, table );
}
return TA_SUCCESS;
}
TA_RetCode TA_FileSeqClose( TA_FileHandle *handle )
{
TA_PROLOG
TA_RetCode retCode;
TA_FileHandlePriv *fileHandlePriv;
TA_SystemGlobal *global;
#if defined( USE_WIN32_API )
DWORD win32Error;
BOOL retValue;
#endif
TA_TRACE_BEGIN( TA_FileSeqClose );
retCode = TA_GetGlobal( &TA_SystemGlobalControl, (void **)&global );
if( retCode != TA_SUCCESS )
{
TA_TRACE_RETURN( retCode );
}
TA_ASSERT( handle != NULL );
fileHandlePriv = (TA_FileHandlePriv *)handle;
if( fileHandlePriv )
{
#if defined( USE_WIN32_API )
if( fileHandlePriv->handle != INVALID_HANDLE_VALUE )
{
retValue = CloseHandle( fileHandlePriv->handle );
if( retValue == 0 )
{
win32Error = GetLastError();
global->lastError = win32Error;
TA_FATAL( NULL, 0, win32Error );
}
}
if( fileHandlePriv->allocBuffer )
{
freeDiskBuffer( fileHandlePriv->allocBuffer,
fileHandlePriv->allocBufferSize );
}
#endif
#if defined( USE_OSLAYER )
if( fileHandlePriv->handle != NULL )
fclose( fileHandlePriv->handle );
if( fileHandlePriv->allocBuffer )
TA_Free( fileHandlePriv->allocBuffer );
#endif
if( fileHandlePriv->streamAccess )
{
TA_StreamAccessFree( fileHandlePriv->streamAccess );
}
TA_Free( fileHandlePriv );
}
TA_TRACE_RETURN( TA_SUCCESS );
}
static TA_RetCode TA_TraceGlobalShutdown( void *globalAllocated )
{
TA_TraceGlobal *global;
TA_RetCode retCode = TA_SUCCESS;
global = (TA_TraceGlobal *)globalAllocated;
if( !global )
return retCode;
if( global->fatalError.str )
TA_Free( global->fatalError.str );
#if !defined( TA_SINGLE_THREAD )
retCode = TA_SemaDestroy( &global->fatalSema );
retCode = TA_SemaDestroy( &global->callSema );
#endif
#ifdef TA_DEBUG
#if defined( TA_SINGLE_THREAD )
if( global->callStack )
TA_ListFree( global->callStack );
#endif
if( global->functionCalled )
TA_DictFree( global->functionCalled );
#endif
TA_Free( global );
return retCode;
}
TA_RetCode TA_PMArrayFree( TA_PMArray *toBeFreed )
{
TA_PMPriv *pmPriv;
TA_PM *pm;
if( toBeFreed )
{
pm = (TA_PM *)toBeFreed->hiddenData;
if( pm )
{
pmPriv = (TA_PMPriv *)pm->hiddenData;
if( pmPriv )
{
if( pmPriv->magicNb != TA_PMPRIV_MAGIC_NB )
return TA_BAD_OBJECT;
if( toBeFreed->period != TA_DAILY )
{
if( toBeFreed->timestamp )
TA_Free( (void *)toBeFreed->timestamp );
if( toBeFreed->data )
TA_Free( (void *)toBeFreed->data );
}
TA_Free( toBeFreed );
}
}
}
return TA_SUCCESS;
}
TA_RetCode TA_FuncTableFree( TA_StringTable *table )
{
TA_StringTablePriv *stringTablePriv;
if( table )
{
stringTablePriv = (TA_StringTablePriv *)table->hiddenData;
if( !stringTablePriv )
{
return TA_INTERNAL_ERROR(3);
}
if( stringTablePriv->magicNumber != TA_STRING_TABLE_FUNC_MAGIC_NB )
{
return TA_BAD_OBJECT;
}
if( table->string )
TA_Free( (void *)table->string );
TA_Free( table );
}
return TA_SUCCESS;
}
TA_RetCode TA_WebPageFree( TA_WebPage *webPage )
{
TA_WebPageHiddenData *hiddenData;
if( webPage )
{
hiddenData = webPage->hiddenData;
if( !hiddenData )
return TA_INTERNAL_ERROR(32);
if( hiddenData->magicNb != TA_WEBPAGE_MAGIC_NB )
return TA_BAD_OBJECT;
/* The object is validated, can start to free ressources
* from this point.
*/
/* Free private data */
TA_Free( hiddenData );
/* Free public data. */
if( webPage->content )
TA_StreamFree( webPage->content );
TA_Free( webPage );
}
return TA_SUCCESS;
}
TA_RetCode TA_FuncTableFree( TA_StringTable *table )
{
TA_PROLOG
TA_StringTablePriv *stringTablePriv;
TA_TRACE_BEGIN( TA_FuncTableFree );
if( table )
{
stringTablePriv = (TA_StringTablePriv *)table->hiddenData;
if( !stringTablePriv )
{
TA_TRACE_RETURN( TA_INTERNAL_ERROR(3) );
}
if( stringTablePriv->magicNumber != TA_STRING_TABLE_FUNC_MAGIC_NB )
{
TA_TRACE_RETURN( TA_BAD_OBJECT );
}
if( table->string )
TA_Free( (void *)table->string );
TA_Free( table );
}
TA_TRACE_RETURN( TA_SUCCESS );
}
/**** Local functions definitions. ****/
static TA_RetCode TA_NetworkGlobalInit( void **globalToAlloc )
{
#if !defined( TA_SINGLE_THREAD )
TA_RetCode retCode;
#endif
TA_NetworkGlobal *global;
if( !globalToAlloc )
return TA_BAD_PARAM;
*globalToAlloc = NULL;
#if defined( USE_LIBCURL )
#if defined(WIN32)
if( curl_global_init(CURL_GLOBAL_WIN32) != CURLE_OK )
return TA_LIBCURL_GLOBAL_INIT_FAILED;
#else
if( curl_global_init(CURL_GLOBAL_NOTHING) != CURLE_OK )
return TA_LIBCURL_GLOBAL_INIT_FAILED;
#endif
#endif
global = (TA_NetworkGlobal *)TA_Malloc( sizeof( TA_NetworkGlobal ) );
if( !global )
return TA_ALLOC_ERR;
memset( global, 0, sizeof( TA_NetworkGlobal ) );
#if defined( USE_LIBCURL )
global->curlHandle = curl_easy_init();
if( global->curlHandle == NULL )
{
TA_Free( global );
return TA_LIBCURL_INIT_FAILED;
}
#endif
#if !defined( TA_SINGLE_THREAD )
/* Initialize the mutex in a non-block state. */
retCode = TA_SemaInit( &global->mutexSema, 1 );
if( retCode != TA_SUCCESS )
{
TA_Free( global );
return retCode;
}
#endif
global->initialized = 1;
/* Success, return the allocated memory to the caller. */
*globalToAlloc = global;
return TA_SUCCESS;
}
TA_RetCode TA_ReadOpInfoFree( TA_ReadOpInfo *readOpInfoToBeFreed )
{
if( readOpInfoToBeFreed )
{
if( readOpInfoToBeFreed->arrayReadOp )
TA_Free( readOpInfoToBeFreed->arrayReadOp );
TA_Free( readOpInfoToBeFreed );
}
return TA_SUCCESS;
}
TA_RetCode TA_FileIndexAddTokenInfo( TA_FileIndexPriv *data,
TA_TokenId id,
TA_String *value,
TA_TokenInfo *optBefore )
{
TA_PROLOG;
TA_RetCode retCode;
TA_TokenInfo *info;
TA_Libc *libHandle;
TA_StringCache *stringCache;
libHandle = data->libHandle;
TA_TRACE_BEGIN( libHandle, TA_FileIndexAddTokenInfo );
stringCache = TA_GetGlobalStringCache( libHandle );
info = TA_Malloc( libHandle, sizeof( TA_TokenInfo ) );
if( !info )
{
TA_TRACE_RETURN( TA_ALLOC_ERR );
}
info->id = id;
if( value == NULL )
info->value = NULL;
else
{
info->value = TA_StringDup( stringCache, value );
if( !info->value )
{
TA_Free( libHandle, info );
TA_TRACE_RETURN( TA_ALLOC_ERR );
}
}
if( optBefore )
retCode = TA_ListAddBefore( data->listLocationToken, optBefore, info );
else
retCode = TA_ListAddTail( data->listLocationToken, info );
if( retCode != TA_SUCCESS )
{
if( info->value )
TA_StringFree( stringCache, info->value );
TA_Free( libHandle, info );
TA_TRACE_RETURN( retCode );
}
TA_TRACE_RETURN( TA_SUCCESS );
}
size_t libcurlWriteMemoryCallback(void *ptr, size_t size, size_t nmemb, void *data)
{
register int bufferSize;
TA_WebPage *webPage;
TA_WebPageHiddenData *webPageHidden;
TA_RetCode retCode;
char *buffer;
webPage = (TA_WebPage *)data;
webPageHidden = (TA_WebPageHiddenData *)webPage->hiddenData;
bufferSize = size * nmemb;
/* Make a copy of the provided data. */
buffer = TA_Malloc( bufferSize );
if( !buffer )
return 0; /* Error. */
memcpy( buffer, ptr, bufferSize );
/* Add the data to the stream. */
if( !webPage->content )
{
/* The first buffer will initiate the creation of
* the stream.
*/
webPage->content = TA_StreamAllocFromBuffer( buffer, bufferSize,
NULL, NULL );
if( !webPage->content )
{
TA_Free( buffer );
return 0; /* Error. */
}
}
else
{
/* Add the buffer to the stream. */
retCode = TA_StreamAddBuffer( webPage->content,
buffer, bufferSize,
NULL, NULL );
if( retCode != TA_SUCCESS )
{
TA_Free( buffer );
return 0; /* Error */
}
}
return bufferSize;
}
/**** Local functions definitions. ****/
static void freePrivateHandle( TA_PrivateHandle *privData )
{
TA_StringCache *stringCache;
stringCache = TA_GetGlobalStringCache();
if( stringCache )
{
if( privData->ta_sim_ref_cat )
TA_StringFree( stringCache, privData->ta_sim_ref_cat );
if( privData->ta_sim_mrg_cat )
TA_StringFree( stringCache, privData->ta_sim_mrg_cat );
if( privData->daily_ref_0 )
TA_StringFree( stringCache, privData->daily_ref_0 );
if( privData->intra_ref_0 )
TA_StringFree( stringCache, privData->intra_ref_0 );
if( privData->mrg_0 )
TA_StringFree( stringCache, privData->mrg_0 );
}
FREE_IF_NOT_NULL( privData->mrgHistory.open );
FREE_IF_NOT_NULL( privData->mrgHistory.high );
FREE_IF_NOT_NULL( privData->mrgHistory.low );
FREE_IF_NOT_NULL( privData->mrgHistory.close );
FREE_IF_NOT_NULL( privData->mrgHistory.volume );
FREE_IF_NOT_NULL( privData->mrgHistory.openInterest );
FREE_IF_NOT_NULL( privData->mrgHistory.timestamp );
TA_Free( privData );
}
TA_RetCode TA_TradeLogFree( TA_TradeLog *toBeFreed )
{
TA_TradeLogPriv *tradeLogPriv;
if( toBeFreed )
{
/* Make sure this is a valid object. */
tradeLogPriv = (TA_TradeLogPriv *)toBeFreed->hiddenData;
if( !tradeLogPriv || (tradeLogPriv->magicNb != TA_TRADELOGPRIV_MAGIC_NB) )
return TA_BAD_OBJECT;
/* If it currently belong to a TA_PM, prevent the de-allocation. */
if( tradeLogPriv->nbReferenceFromTA_PM != 0 )
return TA_PM_REFERENCE_EXIST;
/* Free the private members */
if( tradeLogPriv->tradeDictCAT )
TA_DictFree(tradeLogPriv->tradeDictCAT);
if( tradeLogPriv->tradeDictSYM )
TA_DictFree(tradeLogPriv->tradeDictSYM);
if( tradeLogPriv->tradeDictCATSYM )
TA_DictFree(tradeLogPriv->tradeDictCATSYM);
if( tradeLogPriv->tradeDictUserKey )
TA_DictFree(tradeLogPriv->tradeDictUserKey);
TA_AllocatorForDataLog_FreeAll( &tradeLogPriv->allocator );
/* Free the public portion. */
TA_Free( toBeFreed );
}
return TA_SUCCESS;
}
static TA_RetCode TA_NetworkGlobalShutdown( void *globalAllocated )
{
TA_NetworkGlobal *global;
TA_RetCode retCode = TA_SUCCESS;
global = (TA_NetworkGlobal *)globalAllocated;
if( !global )
return retCode;
if( global->initialized )
{
#if defined( USE_WININET )
if( global->hInternet )
InternetCloseHandle( global->hInternet);
#endif
#if defined( USE_LIBCURL )
curl_global_cleanup();
#endif
global->initialized = 0;
}
#if !defined( TA_SINGLE_THREAD )
retCode = TA_SemaDestroy( &global->mutexSema );
#endif
TA_Free( global );
return retCode;
}
/* Initialize the cache mechanism. */
TA_RetCode TA_StringCacheAlloc( TA_StringCache **newStringCache )
{
TA_StringCachePriv *stringCachePriv;
#if !defined( TA_SINGLE_THREAD )
TA_RetCode retCode;
#endif
if( !newStringCache )
return TA_BAD_PARAM;
*newStringCache = NULL;
stringCachePriv = (TA_StringCachePriv *)TA_Malloc( sizeof( TA_StringCachePriv ) );
if( !stringCachePriv )
return TA_ALLOC_ERR;
memset( stringCachePriv, 0, sizeof( TA_StringCachePriv ) );
#if !defined( TA_SINGLE_THREAD )
retCode = TA_SemaInit( &stringCachePriv->sema, 1 );
if( retCode != TA_SUCCESS )
{
TA_Free( stringCachePriv );
return retCode;
}
#endif
/* Success, return the cache to the caller. */
*newStringCache = (TA_StringCache *)stringCachePriv;
return TA_SUCCESS;
}
static TA_RetCode freeSymbolData( TA_Libc *libHandle, void *toBeFreed )
{
TA_FileIndexSymbolData *symbolData;
TA_StringCache *stringCache;
stringCache = TA_GetGlobalStringCache( libHandle );
symbolData = (TA_FileIndexSymbolData *)toBeFreed;
if( !symbolData )
return TA_ALLOC_ERR;
/* Not yet im[plemented !!!
if( symbolData->dataPerDate )
{
if( freeListAndElement( symbolData->dataPerDate, freeDataPerDate ) != TA_SUCCESS )
return TA_ALLOC_ERR;
}
*/
if( symbolData->string )
TA_StringFree( stringCache, symbolData->string );
TA_Free( libHandle, symbolData );
return TA_SUCCESS;
}
TA_RetCode TA_ReadOpInfoFree( TA_ReadOpInfo *readOpInfoToBeFreed )
{
TA_Libc *libHandle;
if( readOpInfoToBeFreed )
{
libHandle = readOpInfoToBeFreed->libHandle;
if( readOpInfoToBeFreed->arrayReadOp )
TA_Free( libHandle, readOpInfoToBeFreed->arrayReadOp );
TA_Free( libHandle, readOpInfoToBeFreed );
}
return TA_SUCCESS;
}
/* A little utility to fetch a web page and send the raw data
* to the provided FILE pointer. This ptr could be "stdout" to
* display on the console.
*
* Example:
* TA_WebFetch( "www.yahoo.com", stdout );
* or
* TA_WebFetch( "http://www.yahoo.com/mt", myFile );
*/
TA_RetCode TA_WebFetch( TA_Libc *libHandle, const char *url, FILE *out )
{
TA_RetCode retCode;
TA_WebPage *webPage;
const char *stringStart;
const char *webSitePage;
char *allocString;
unsigned int webSiteLength;
if( !url )
return TA_BAD_PARAM;
allocString = NULL;
/* Skip the http:// if specified. */
stringStart = url;
if( strncmp( url, "http://", 7 ) == 0 )
stringStart += 7;
/* Find if there is a specifc web page specified. */
webSitePage = strchr( stringStart, '/' );
if( webSitePage )
{
webSitePage++;
if( *webSitePage == '\0' )
{
webSitePage = NULL;
}
else
{
webSiteLength = webSitePage - stringStart - 1;
allocString = (char *)TA_Malloc( libHandle, webSiteLength+1 );
if( !allocString )
return TA_ALLOC_ERR;
strncpy( allocString, stringStart, webSiteLength );
allocString[webSiteLength] = '\0';
stringStart = allocString;
}
}
retCode = TA_WebPageAlloc( libHandle,
stringStart,
webSitePage,
NULL, NULL,
&webPage,
2 );
if( allocString )
TA_Free( libHandle, allocString );
if( retCode == TA_SUCCESS )
{
retCode = TA_StreamToFile( webPage->content, out );
TA_WebPageFree( webPage );
}
return retCode;
}
TA_RetCode TA_StringCacheFree( TA_StringCache *stringCacheToFree )
{
TA_StringCachePriv *stringCachePriv;
unsigned int i;
if( !stringCacheToFree )
return TA_BAD_PARAM;
stringCachePriv = (TA_StringCachePriv *)stringCacheToFree;
for( i=0; i < NB_CACHE_ENTRY; i++ )
{
if( stringCachePriv->cache[i] != NULL )
TA_StringFree( stringCacheToFree,
(TA_String *)stringCachePriv->cache[i] );
}
#if !defined( TA_SINGLE_THREAD )
TA_SemaDestroy( &stringCachePriv->sema );
#endif
TA_Free( stringCachePriv );
return TA_SUCCESS;
}
/**** Local functions definitions. ****/
static TA_RetCode rangeTestFunction(
TA_Integer startIdx,
TA_Integer endIdx,
TA_Real *outputBuffer,
TA_Integer *outBegIdx,
TA_Integer *outNbElement,
TA_Integer *lookback,
void *opaqueData,
unsigned int outputNb )
{
TA_RetCode retCode;
TA_RangeTestParam *testParam;
TA_Real *out1;
TA_Real *out2;
TA_Real *dummyOutput;
(void)outputNb;
testParam = (TA_RangeTestParam *)opaqueData;
dummyOutput = TA_Malloc( (endIdx-startIdx+1) * sizeof(TA_Real) );
if( outputNb == 0 )
{
out1 = outputBuffer;
out2 = dummyOutput;
}
else
{
out1 = dummyOutput;
out2 = outputBuffer;
}
switch( testParam->test->theFunction )
{
case TA_HT_PHASOR_TEST:
retCode = TA_HT_PHASOR( startIdx,
endIdx,
testParam->price,
outBegIdx,
outNbElement,
out1, out2 );
*lookback = TA_HT_PHASOR_Lookback();
break;
case TA_HT_SINE_TEST:
retCode = TA_HT_SINE( startIdx,
endIdx,
testParam->price,
outBegIdx,
outNbElement,
out1, out2 );
*lookback = TA_HT_SINE_Lookback();
break;
default:
retCode = TA_INTERNAL_ERROR(132);
}
TA_Free(dummyOutput);
return retCode;
}
TA_RetCode TA_ParamHolderFree( TA_ParamHolder *paramsToFree )
{
TA_PROLOG
TA_ParamHolderPriv *paramPriv;
TA_ParamHolderInput *input;
TA_ParamHolderOptInput *optInput;
TA_ParamHolderOutput *output;
TA_TRACE_BEGIN( TA_ParamHolderFree );
if( !paramsToFree )
{
TA_TRACE_RETURN( TA_SUCCESS );
}
paramPriv = paramsToFree->hiddenData;
if( !paramPriv )
{
TA_TRACE_RETURN( TA_INVALID_PARAM_HOLDER );
}
if( paramPriv->magicNumber != TA_PARAM_HOLDER_PRIV_MAGIC_NB )
{
TA_TRACE_RETURN( TA_INVALID_PARAM_HOLDER );
}
optInput = paramPriv->optIn;
if( optInput )
TA_Free( optInput );
input = paramPriv->in;
if( input )
TA_Free( input );
output = paramPriv->out;
if( output )
TA_Free( output );
TA_Free( paramsToFree );
TA_TRACE_RETURN( TA_SUCCESS );
}
TA_RetCode TA_DictFree( TA_Dict *dict )
{
TA_PrivDictInfo *theDict;
dnode_t *node;
dnode_t *next;
TA_String *stringToDelete;
void *valueToDelete;
dict_t *kazlibDict;
TA_Libc *libHandle;
int flags;
theDict = (TA_PrivDictInfo *)dict;
if( theDict == NULL )
return TA_BAD_PARAM;
kazlibDict = &theDict->d;
libHandle = theDict->libHandle;
/* Delete all the key-value pair sequentially. */
node = dict_first( libHandle, kazlibDict );
while (node != NULL)
{
/* Get the next node. */
next = dict_next( libHandle, kazlibDict, node );
/* Free the 'node, the 'key' string and the 'value'. */
flags = theDict->flags;
valueToDelete = dnode_get(node);
if( flags & (TA_DICT_KEY_TWO_STRING|TA_DICT_KEY_ONE_STRING) )
{
stringToDelete = TA_StringFromChar(dnode_getkey(node));
dict_delete_free( libHandle, kazlibDict, node );
TA_StringFree( TA_GetGlobalStringCache( libHandle ), stringToDelete );
}
else
dict_delete_free( libHandle, kazlibDict, node );
if( flags & TA_DICT_KEY_TWO_STRING )
{
/* The value is a dictionary. Delete it. */
TA_DictFree( (TA_Dict *)valueToDelete );
}
else if( theDict->freeValueFunc )
theDict->freeValueFunc( libHandle, valueToDelete );
node = next;
}
/* Free the TA_PrivDictInfo */
TA_Free( libHandle, theDict );
return TA_SUCCESS;
}
TA_RetCode TA_ParamHoldersFree( TA_ParamHolder *inputParamsToFree,
TA_ParamHolder *optInputParamsToFree,
TA_ParamHolder *outputParamsToFree )
{
TA_PROLOG;
TA_Libc *libHandle;
TA_ParamHolderPriv *input;
TA_ParamHolderPriv *optInput;
TA_ParamHolderPriv *output;
input = (TA_ParamHolderPriv *)inputParamsToFree;
optInput = (TA_ParamHolderPriv *)optInputParamsToFree;
output = (TA_ParamHolderPriv *)outputParamsToFree;
if( !input || !output )
return TA_BAD_PARAM;
if( (input->magicNumber != TA_PARAM_HOLDER_PRIV_MAGIC_NB) ||
(output->magicNumber != TA_PARAM_HOLDER_PRIV_MAGIC_NB) )
return TA_INVALID_PARAM_HOLDER;
libHandle = input->libHandle;
TA_TRACE_BEGIN( libHandle, TA_ParamHoldersFree );
if( optInput )
{
if( optInput->magicNumber != TA_PARAM_HOLDER_PRIV_MAGIC_NB )
{
TA_TRACE_RETURN( TA_INVALID_PARAM_HOLDER );
}
}
TA_Free( libHandle, input );
if( optInput )
TA_Free( libHandle, optInput );
TA_Free( libHandle, output );
TA_TRACE_RETURN( TA_SUCCESS );
}
static TA_RetCode TA_SystemGlobalInit( void **globalToAlloc )
{
TA_PROLOG
TA_RetCode retCode;
TA_SystemGlobal *global;
TA_TRACE_BEGIN( TA_SystemGlobalInit );
TA_ASSERT( globalToAlloc != NULL );
*globalToAlloc = NULL;
global = (TA_SystemGlobal *)TA_Malloc( sizeof( TA_SystemGlobal ) );
if( !global )
{
TA_TRACE_RETURN( TA_ALLOC_ERR );
}
memset( global, 0, sizeof( TA_SystemGlobal ) );
retCode = TA_StringCacheAlloc( &global->dirnameCache );
if( retCode != TA_SUCCESS )
{
TA_Free( global );
TA_TRACE_RETURN( TA_ALLOC_ERR );
}
retCode = TA_StringCacheAlloc( &global->filenameCache );
if( retCode != TA_SUCCESS )
{
TA_StringCacheFree( global->dirnameCache );
TA_Free( global );
TA_TRACE_RETURN( TA_ALLOC_ERR );
}
/* Success! Return the global to the caller. */
*globalToAlloc = global;
TA_TRACE_RETURN( TA_SUCCESS );
}
TA_RetCode TA_GroupTableFree( TA_StringTable *table )
{
TA_StringTableGroupHidden *stringTableHidden;
TA_Libc *libHandle;
if( table )
{
stringTableHidden = (TA_StringTableGroupHidden *)table->hiddenData;
if( !stringTableHidden )
return TA_INTERNAL_ERROR(1);
if( stringTableHidden->magicNb != TA_STRING_TABLE_GROUP_MAGIC_NB )
return TA_BAD_OBJECT;
libHandle = stringTableHidden->libHandle;
TA_Free( libHandle, stringTableHidden );
TA_Free( libHandle, table );
}
return TA_SUCCESS;
}
TA_RetCode TA_PMFree( TA_PM *toBeFreed )
{
TA_PMPriv *pmPriv;
TA_TradeLogPriv *tradeLogPriv;
if( toBeFreed )
{
/* Make sure this is a valid object */
pmPriv = (TA_PMPriv *)toBeFreed->hiddenData;
if( !pmPriv || (pmPriv->magicNb != TA_PMPRIV_MAGIC_NB) )
return TA_BAD_OBJECT;
/* Clearly mark this object as being unusable. */
pmPriv->magicNb = 0;
/* Indicate to all TA_TradeLog that they do
* no belong to this TA_PM anymore.
*/
tradeLogPriv = TA_ListAccessHead( &pmPriv->tradeLogList );
while( tradeLogPriv )
{
tradeLogPriv->nbReferenceFromTA_PM--;
tradeLogPriv = TA_ListAccessNext( &pmPriv->tradeLogList );
}
TA_ListFree( &pmPriv->tradeLogList );
/* Free all the cached arrays. */
FREE_IF_NOT_NULL( pmPriv->equity );
FREE_IF_NOT_NULL( pmPriv->arrayTimestamp );
FREE_IF_NOT_NULL( pmPriv->shortArrayCache.investment );
FREE_IF_NOT_NULL( pmPriv->shortArrayCache.profit );
FREE_IF_NOT_NULL( pmPriv->longArrayCache.investment );
FREE_IF_NOT_NULL( pmPriv->longArrayCache.profit );
FREE_IF_NOT_NULL( pmPriv->totalArrayCache.investment );
FREE_IF_NOT_NULL( pmPriv->totalArrayCache.profit );
/* Last thing that must be freed... */
TA_Free( toBeFreed );
}
return TA_SUCCESS;
}
TA_RetCode TA_DirectoryFree( TA_Directory *directory )
{
TA_RetCode retCode;
TA_SystemGlobal *global;
retCode = TA_GetGlobal( &TA_SystemGlobalControl, (void **)&global );
if( retCode != TA_SUCCESS )
return retCode;
if( directory )
{
stringListFree( global->filenameCache, directory->listOfFile );
stringListFree( global->dirnameCache, directory->listOfDirectory );
TA_Free( directory );
}
return TA_SUCCESS;
}
static TA_RetCode freeTokenInfo( TA_Libc *libHandle, void *toBeFreed )
{
TA_TokenInfo *info;
TA_StringCache *stringCache;
stringCache = TA_GetGlobalStringCache( libHandle );
info = (TA_TokenInfo *)toBeFreed;
if( !info )
return TA_ALLOC_ERR;
if( info->value )
TA_StringFree( stringCache, info->value );
TA_Free( libHandle, info );
return TA_SUCCESS;
}