void FcitxIsoCodes639EntryFree(FcitxIsoCodes639Entry* entry)
{
FREE_IF_NOT_NULL(entry->iso_639_1_code);
FREE_IF_NOT_NULL(entry->iso_639_2B_code);
FREE_IF_NOT_NULL(entry->iso_639_2T_code);
FREE_IF_NOT_NULL(entry->name);
free(entry);
}
void netgroup_entry_free(struct entry *entry) {
if (!entry)
return;
if (entry->type == TRIPLE_ENTRY) {
FREE_IF_NOT_NULL(entry->data.triple.hostname);
FREE_IF_NOT_NULL(entry->data.triple.username);
FREE_IF_NOT_NULL(entry->data.triple.domainname);
} else {
FREE_IF_NOT_NULL(entry->data.child.name);
}
free(entry);
}
/**** 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 );
}
void log_entry_destroy(log_entry_t * entry)
{
ASSERT(entry != NULL);
/** free up all memories */
FREE_IF_NOT_NULL(entry->message);
free(entry);
}
void wif_free_weavedata(WeaveData *data)
{
#define FREE_IF_NOT_NULL(a) if(a!=0) free(a)
FREE_IF_NOT_NULL(data->tieup);
FREE_IF_NOT_NULL(data->treadling);
FREE_IF_NOT_NULL(data->threading);
FREE_IF_NOT_NULL(data->colors);
FREE_IF_NOT_NULL(data->warp.colors);
FREE_IF_NOT_NULL(data->weft.colors);
FREE_IF_NOT_NULL(data);
}
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_TradeReportFree( TA_TradeReport *toBeFreed )
{
TA_TradeReportPriv *tradeReportPriv;
if( toBeFreed )
{
/* Make sure this TA_TradeReport is a valid object */
tradeReportPriv = (TA_TradeReportPriv *)toBeFreed->hiddenData;
if( !tradeReportPriv || (tradeReportPriv->magicNb != TA_TRADEREPORT_MAGIC_NB) )
return TA_BAD_OBJECT;
/* Clearly mark this object as being unusable. */
tradeReportPriv->magicNb = 0;
FREE_IF_NOT_NULL( toBeFreed->trades );
/* Last thing that must be freed... */
TA_Free( toBeFreed );
}
return TA_SUCCESS;
}
static TA_RetCode addSimMrgData( TA_PrivateHandle *privData,
TA_ParamForAddData *paramForAddData )
{
(void)paramForAddData;
(void)privData;
#if 0
/* Allocate the data if not already done. */
if( !privData->mrgAllocated )
{
memset( privData->mrgHistory, 0, sizeof( TA_History ) );
privData->mrgHistory.open = TA_Malloc( sizeof( TA_Real ) * 1000 ) );
privData->mrgHistory.high = TA_Malloc( sizeof( TA_Real ) * 1000 ) );
privData->mrgHistory.low = TA_Malloc( sizeof( TA_Real ) * 1000 ) );
privData->mrgHistory.close = TA_Malloc( sizeof( TA_Real ) * 1000 ) );
privData->mrgHistory.volume = TA_Malloc( sizeof( TA_Integer ) * 1000 ) );
privData->mrgHistory.openInterest = TA_Malloc( sizeof( TA_Integer ) * 1000 ) );
privData->mrgHistory.timestamp = TA_Malloc( sizeof( TA_Timestamp ) * 1000 ) );
if( !privData->mrgHistory.open ||
!privData->mrgHistory.high ||
!privData->mrgHistory.low ||
!privData->mrgHistory.close ||
!privData->mrgHistory.volume ||
!privData->mrgHistory.openInterest ||
!privData->mrgHistory.timestamp )
{
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 );
return TA_ALLOC_ERR;
}
}
TA_RetCode TA_ReadOp_Do( TA_FileHandle *fileHandle,
const TA_ReadOpInfo *readOpInfo,
TA_Period period,
const TA_Timestamp *start,
const TA_Timestamp *end,
unsigned int minimumNbBar,
TA_Field fieldToAlloc,
TA_ParamForAddData *paramForAddData,
unsigned int *nbBarAdded )
{
TA_PROLOG
TA_RetCode retCode;
TA_EstimateInfo estimationInfo;
unsigned int nbElementToAllocate;
unsigned int memoryNeeded; /* Boolean */
unsigned int timeNeeded; /* Boolean */
TA_Real *arrayReal[TA_REAL_ARRAY_SIZE];
TA_Integer *arrayInteger[TA_INTEGER_ARRAY_SIZE];
TA_Timestamp *timestamp;
TA_Real *openBeg, *highBeg, *lowBeg, *closeBeg;
TA_Integer *volumeBeg, *openInterestBeg;
TA_Timestamp *timestampBeg;
TA_Timestamp tmpTimestamp;
TA_ReadOp op;
TA_Field fieldToProcess;
unsigned int year, month, day, hour, min, sec;
TA_Integer curOp;
unsigned int nbTotalByteDone, nbTotalBarDone;
unsigned int nbBarAddedInTheBlock;
char monthChar[4];
char cnvtArray[CNVT_ARRAY_SIZE];
unsigned int cnvtArrayIdx;
unsigned int nbByteToAllocReal;
unsigned int nbByteToAllocInteger;
unsigned int fileSize;
unsigned int skipField;
unsigned int lineToSkip;
unsigned int nbByteRead;
unsigned int nbLetter;
TA_Real lastValidClose;
const char *car;
register TA_Real tmpReal;
register TA_Integer tmpInt;
register unsigned int tmpIdx;
register unsigned int nbCharToRead;
unsigned int lastOpFieldIncremented;
TA_TRACE_BEGIN( TA_PriceBarRead );
/* Initialization of local variables. */
openBeg = highBeg = lowBeg = closeBeg = NULL;
timestampBeg = NULL;
volumeBeg = openInterestBeg = NULL;
timestamp = NULL;
retCode = TA_SUCCESS;
lastValidClose = 0.0;
fieldToProcess = readOpInfo->fieldProvided & fieldToAlloc;
if( (fieldToProcess & fieldToAlloc) != fieldToAlloc )
{
/* Nothing to read because not all the requested
* fields are provided by this data source!
*/
return TA_SUCCESS;
}
/* Estimate the initial amount of memory to allocate. */
fileSize = TA_FileSize( fileHandle );
retCode = TA_EstimateAllocInit( start, end, period,
minimumNbBar, 2048,
&estimationInfo,
&nbElementToAllocate );
if( retCode != TA_SUCCESS )
{
TA_TRACE_RETURN( retCode );
}
if( nbElementToAllocate == 0 )
{
TA_TRACE_RETURN( TA_SUCCESS ); /* Nothing to read!? Just return... */
}
memset( arrayInteger, 0, sizeof( arrayInteger ) );
memset( arrayReal, 0, sizeof( arrayReal ) );
/* Set the date/time pointers to where the information will be stored. */
arrayInteger[TA_HOUR_IDX] = (TA_Integer *)&hour;
arrayInteger[TA_MIN_IDX] = (TA_Integer *)&min;
arrayInteger[TA_SEC_IDX] = (TA_Integer *)&sec;
arrayInteger[TA_MONTH_IDX] = (TA_Integer *)&month;
arrayInteger[TA_YEAR_IDX] = (TA_Integer *)&year;
arrayInteger[TA_DAY_IDX] = (TA_Integer *)&day;
/* Set default time/date. */
year = 1900;
month = day = 1;
hour = 23;
min = sec = 59;
/* Check if the processing of the time will be needed. */
timeNeeded = isTimeNeeded( readOpInfo->arrayReadOp);
/* 'car' always point to the character being currently handled. */
nbByteRead = 0;
car = TA_FileSeqRead( fileHandle, &nbByteRead );
if( (car == NULL) || (nbByteRead == 0) )
return TA_SUCCESS; /* End of file! */
--nbByteRead;
nbTotalByteDone = 0;
nbTotalBarDone = 0;
nbBarAddedInTheBlock = 0;
memoryNeeded = 1;
curOp = 0;
skipField = 0;
monthChar[3] = '\0';
/* When requested, skip header lines. */
lineToSkip = readOpInfo->nbHeaderLineToSkip;
while( lineToSkip-- )
{
while( *car != '\n' )
{
GET_CHAR;
if( car == NULL )
goto exit_loops;
}
}
line_loop: /* Always jump here when end-of-line is found (EOL). */
/* If curOp != 0, the last operations are canceled. */
REVERT_OPERATIONS;
curOp = 0;
lastOpFieldIncremented = 0;
/* Start over a new line. */
if( memoryNeeded )
{
/* Allocate the memory. */
nbByteToAllocReal = nbElementToAllocate * sizeof( TA_Real );
nbByteToAllocInteger = nbElementToAllocate * sizeof( TA_Integer );
timestamp = (TA_Timestamp *)TA_Malloc( nbElementToAllocate * sizeof( TA_Timestamp ) );
timestampBeg = timestamp;
if( !timestampBeg )
{
retCode = TA_ALLOC_ERR;
goto exit_loops;
}
#define TA_ALLOC_MEM(upperc,lowerc,typepar) \
{ \
if( fieldToProcess & TA_##upperc ) \
{ \
lowerc##Beg = (TA_##typepar *)TA_Malloc( nbByteToAlloc##typepar ); \
array##typepar[TA_##upperc##_IDX] = lowerc##Beg; \
if( !lowerc##Beg ) \
{ \
retCode = TA_ALLOC_ERR; \
goto exit_loops; \
} \
} \
}
TA_ALLOC_MEM( OPEN, open, Real );
TA_ALLOC_MEM( HIGH, high, Real );
TA_ALLOC_MEM( LOW, low, Real );
TA_ALLOC_MEM( CLOSE, close, Real );
TA_ALLOC_MEM( VOLUME, volume, Integer );
TA_ALLOC_MEM( OPENINTEREST, openInterest, Integer );
#undef TA_ALLOC_MEM
memoryNeeded = 0;
}
op_loop: /* Jump here when ready to proceed with the next command. */
op = readOpInfo->arrayReadOp[curOp];
if( !(op&TA_CMD_READ_MONTH_CHAR) )
{
/* Skip leading non-numeric character. */
SKIP_UNTIL_NUMERIC;
}
/* Shall we skip this field? */
if( TA_IS_SKIP_SET(op) )
{
if( (op&(TA_CMD_READ_REAL|TA_CMD_READ_INTEGER)) == 0 )
{
tmpInt = TA_GET_NB_NUMERIC(op);
curOp++;
while( tmpInt-- )
{
GET_CHAR;
CHECK_EOL_EOF;
}
}
else
{
if( skipField == 0 )
{
skipField = TA_GET_NB_NUMERIC(op);
TA_ASSERT( skipField > 0 );
}
if( --skipField == 0 )
curOp++;
SKIP_NUMERIC;
if( (op&TA_CMD_READ_REAL) && (*car == '.') )
{
GET_CHAR;
CHECK_EOL_EOF;
SKIP_NUMERIC;
}
}
}
else
{
cnvtArrayIdx = 0;
if( TA_IS_REAL_CMD(op) )
{
/* Extract a numeric into cnvtArray. */
READ_IN_CNVT_ARRAY;
/* This is a TA_Real. */
if( car && (*car == '.') )
{
/* Read rest of the float after the '.' */
READ_IN_CNVT_ARRAY;
}
cnvtArray[cnvtArrayIdx] = '\0';
tmpReal = atof( &cnvtArray[0] );
/* Write the TA_Real in memory. */
tmpIdx = TA_GET_IDX(op);
TA_ASSERT( tmpIdx < TA_REAL_ARRAY_SIZE );
TA_ASSERT( arrayReal[tmpIdx] != NULL );
if( tmpReal != 0.0 )
{
*(arrayReal[tmpIdx]) = tmpReal;
if( tmpIdx == TA_CLOSE_IDX )
lastValidClose = tmpReal;
}
else if( TA_IS_REPLACE_ZERO(op) )
{
/* Replace this zero value with the last known close.
* If there is no previous close, this line is ignored.
*/
if( lastValidClose != 0.0 )
*(arrayReal[tmpIdx]) = lastValidClose;
else
{
SKIP_LINE;
}
}
else
{
/* Zero are not expected, consider this as a failure
* and ignore all further data from this file.
*/
retCode = TA_PRICE_BAR_CONTAINS_ZERO;
goto exit_loops;
}
arrayReal[tmpIdx]++;
curOp++;
}
else
{
/* This is a TA_Integer. */
if( !(op&TA_CMD_READ_MONTH_CHAR) )
{
nbCharToRead = TA_GET_NB_NUMERIC(op);
if( nbCharToRead )
{
READ_N_CHAR_IN_CNVT_ARRAY(nbCharToRead);
}
else
{
READ_IN_CNVT_ARRAY;
}
cnvtArray[cnvtArrayIdx] = '\0';
tmpInt = atoi( &cnvtArray[0] );
}
else
{
/* Try to find a 3 letters month string.
* Translate it to a [1..12] integer.
*/
nbLetter = 1;
do
{
CHECK_EOL_EOF;
monthChar[nbLetter] = (char)toupper(*car);
GET_CHAR;
nbLetter++;
} while( nbLetter != 3 );
do
{
CHECK_EOL_EOF;
monthChar[0] = monthChar[1];
monthChar[1] = monthChar[2];
monthChar[2] = (char)toupper(*car);
if( strncmp("JAN",monthChar,3) == 0 )
tmpInt = 1;
else if( strncmp("FEB",monthChar,3) == 0 )
tmpInt = 2;
else if( strncmp("MAR",monthChar,3) == 0 )
tmpInt = 3;
else if( strncmp("APR",monthChar,3) == 0 )
tmpInt = 4;
else if( strncmp("MAY",monthChar,3) == 0 )
tmpInt = 5;
else if( strncmp("JUN",monthChar,3) == 0 )
tmpInt = 6;
else if( strncmp("JUL",monthChar,3) == 0 )
tmpInt = 7;
else if( strncmp("AUG",monthChar,3) == 0 )
tmpInt = 8;
else if( strncmp("SEP",monthChar,3) == 0 )
tmpInt = 9;
else if( strncmp("OCT",monthChar,3) == 0 )
tmpInt = 10;
else if( strncmp("NOV",monthChar,3) == 0 )
tmpInt = 11;
else if( strncmp("DEC",monthChar,3) == 0 )
tmpInt = 12;
else
tmpInt = 0;
GET_CHAR;
} while( tmpInt == 0 );
}
/* Write the TA_Integer in memory. */
tmpIdx = TA_GET_IDX(op);
TA_ASSERT( tmpIdx < TA_INTEGER_ARRAY_SIZE );
TA_ASSERT( arrayInteger[tmpIdx] != NULL );
*(arrayInteger[tmpIdx]) = tmpInt;
if( tmpIdx > TA_YEAR_IDX )
arrayInteger[tmpIdx]++;
curOp++;
if( TA_IS_TIMESTAMP_COMPLETE(op) )
{
/* Build the timestamp. */
retCode = TA_SetDate( year, month, day, &tmpTimestamp );
if( retCode != TA_SUCCESS )
goto exit_loops; /* Invalid date */
if( !timeNeeded )
{
/* Ignore time in comparison and use default to build the price bar. */
tmpTimestamp.time = 23595900; /* Default EOD time */
if( start && (tmpTimestamp.date < start->date) )
{
/* This price bar is not needed, jump to the next line. */
retCode = TA_SUCCESS;
SKIP_LINE;
}
if( end && (tmpTimestamp.date > end->date) )
{
/* This price bar is beyond the upper limit, just exit. */
goto exit_loops;
}
}
else
{
retCode = TA_SetTime( hour, min, sec, &tmpTimestamp );
if( retCode != TA_SUCCESS )
goto exit_loops; /* Invalid time */
if( start && TA_TimestampLess(&tmpTimestamp,start) )
{
/* This price bar is not needed, jump to the next line. */
retCode = TA_SUCCESS;
SKIP_LINE;
}
if( end && TA_TimestampGreater(&tmpTimestamp, end) )
{
/* This price bar is beyond the upper limit, just exit. */
goto exit_loops;
}
}
/* Write the timestamp in memory. */
*timestamp = tmpTimestamp;
}
}
if( TA_IS_READ_STOP_FLAG_SET(op) )
{
#ifdef DEBUG_PRINTF
printf( "(%d%d%d,%e,%e,%e,%e,%d)\n",
timestampBeg?TA_GetYear(×tampBeg[nbBarAddedInTheBlock]):0,
timestampBeg?TA_GetMonth(×tampBeg[nbBarAddedInTheBlock]):0,
timestampBeg?TA_GetDay(×tampBeg[nbBarAddedInTheBlock]):0,
openBeg?openBeg[nbBarAddedInTheBlock]:0.0,
highBeg?highBeg[nbBarAddedInTheBlock]:0.0,
lowBeg?lowBeg[nbBarAddedInTheBlock]:0.0,
closeBeg?closeBeg[nbBarAddedInTheBlock]:0.0,
volumeBeg?volumeBeg[nbBarAddedInTheBlock]:0 );
#endif
/* At this point, the price bar is completely written in memory. */
timestamp++;
curOp = 0;
nbBarAddedInTheBlock++;
if( nbBarAddedInTheBlock < nbElementToAllocate )
{
/* Go to next line. */
SKIP_LINE;
}
else
{
/* There is not enough memory for another bar, so re-allocate
* some more.
*/
retCode = TA_HistoryAddData( paramForAddData, nbBarAddedInTheBlock,
period, timestampBeg,
openBeg, highBeg, lowBeg, closeBeg,
volumeBeg, openInterestBeg );
/* TA_HistoryAddData is ALWAYS the owner of these memory block
* when called. So we set these to NULL to make sure there will
* be no attempt to free these from this function.
*/
openBeg = highBeg = lowBeg = closeBeg = NULL;
timestampBeg = NULL;
volumeBeg = openInterestBeg = NULL;
nbTotalBarDone += nbBarAddedInTheBlock;
nbBarAddedInTheBlock = 0;
if( retCode != TA_SUCCESS )
goto exit_loops;
retCode = TA_EstimateAllocNext( &estimationInfo, &nbElementToAllocate );
if( retCode != TA_SUCCESS )
goto exit_loops;
memoryNeeded = 1;
SKIP_LINE;
}
}
else
{
/* Make sure we did not hit an EOL or EOF prematurly, if yes,
* this line will be silently ignored.
*/
CHECK_EOL_EOF;
}
}
goto op_loop;
exit_loops: /* Jump here when the end-of-file is hit (or an error occured) */
/* On succesful exit, process possibly remaining data. */
if( (retCode == TA_SUCCESS) && (nbBarAddedInTheBlock != 0) )
{
retCode = TA_HistoryAddData( paramForAddData, nbBarAddedInTheBlock,
period, timestampBeg,
openBeg, highBeg, lowBeg, closeBeg,
volumeBeg, openInterestBeg );
openBeg = highBeg = lowBeg = closeBeg = NULL;
timestampBeg = NULL;
volumeBeg = openInterestBeg = NULL;
nbTotalBarDone += nbBarAddedInTheBlock;
}
/* ALWAYS verify if locally allocated memory needs to be freed. ALWAYS. */
FREE_IF_NOT_NULL( openBeg );
FREE_IF_NOT_NULL( highBeg );
FREE_IF_NOT_NULL( lowBeg );
FREE_IF_NOT_NULL( closeBeg );
FREE_IF_NOT_NULL( volumeBeg );
FREE_IF_NOT_NULL( openInterestBeg );
FREE_IF_NOT_NULL( timestampBeg );
/* An indication that no more data needs to be provided is not a failure. */
if( retCode == TA_ENOUGH_DATA )
retCode = TA_SUCCESS;
/* Return the number of added price bar to the caller. */
if( nbBarAdded )
*nbBarAdded = nbTotalBarDone;
TA_TRACE_RETURN( retCode );
}
void FcitxIsoCodes3166EntryFree(FcitxIsoCodes3166Entry* entry)
{
FREE_IF_NOT_NULL(entry->alpha_2_code);
FREE_IF_NOT_NULL(entry->name);
free(entry);
}
TA_RetCode TA_SIMULATOR_GetHistoryData( TA_DataSourceHandle *handle,
TA_CategoryHandle *categoryHandle,
TA_SymbolHandle *symbolHandle,
TA_Period period,
const TA_Timestamp *start,
const TA_Timestamp *end,
TA_Field fieldToAlloc,
TA_ParamForAddData *paramForAddData )
{
TA_PROLOG
TA_PrivateHandle *privateHandle;
TA_RetCode retCode;
TA_Timestamp *timestamp;
TA_Real *open, *high, *low, *close;
TA_Integer *volume;
unsigned int i;
(void)fieldToAlloc;
(void)end;
(void)start;
(void)period;
TA_TRACE_BEGIN( TA_SIMULATOR_GetHistoryData );
TA_ASSERT( handle != NULL );
privateHandle = (TA_PrivateHandle *)handle->opaqueData;
TA_ASSERT( privateHandle != NULL );
TA_ASSERT( paramForAddData != NULL );
TA_ASSERT( categoryHandle != NULL );
TA_ASSERT( symbolHandle != NULL );
retCode = TA_INTERNAL_ERROR(98);
/* Note: start/end index are currently ignored
* in this data source.
*/
/* Identify the category. */
switch( (unsigned int)categoryHandle->opaqueData )
{
case 0: /* This is TA_SIM_REF */
switch( (unsigned int)symbolHandle->opaqueData )
{
case 0:
timestamp = (TA_Timestamp *)NULL;
open = high = low = close = (TA_Real *)NULL;
volume = (TA_Integer *)NULL;
#define TA_ALLOC_COPY( varName, varType, varSize) { \
varName = TA_Malloc( sizeof( varType ) * varSize ); \
if( !varName ) \
{ \
FREE_IF_NOT_NULL( open ); \
FREE_IF_NOT_NULL( high ); \
FREE_IF_NOT_NULL( low ); \
FREE_IF_NOT_NULL( close ); \
FREE_IF_NOT_NULL( volume ); \
TA_TRACE_RETURN( TA_ALLOC_ERR ); \
} \
memcpy( varName, TA_SREF_##varName##_daily_ref_0_PRIV, sizeof( varType )*varSize ); }
TA_ALLOC_COPY( open, TA_Real, TA_REF_DAILY_NB_BARS );
TA_ALLOC_COPY( high, TA_Real, TA_REF_DAILY_NB_BARS );
TA_ALLOC_COPY( low, TA_Real, TA_REF_DAILY_NB_BARS );
TA_ALLOC_COPY( close, TA_Real, TA_REF_DAILY_NB_BARS );
TA_ALLOC_COPY( volume, TA_Integer, TA_REF_DAILY_NB_BARS );
#undef TA_ALLOC_COPY
/* Set the timestamp. */
timestamp = TA_Malloc( sizeof( TA_Timestamp ) * TA_REF_DAILY_NB_BARS );
if( !timestamp )
{
TA_Free( open );
TA_Free( high );
TA_Free( low );
TA_Free( close );
TA_Free( volume );
TA_TRACE_RETURN( TA_ALLOC_ERR );
}
for( i=0; i < TA_REF_DAILY_NB_BARS; i++ )
TA_TimestampCopy( ×tamp[i], &TA_SREF_timestamp_daily_ref_0_PRIV[i] );
retCode = TA_HistoryAddData( paramForAddData,
TA_REF_DAILY_NB_BARS, TA_DAILY,
timestamp,
open, high,
low, close,
volume, NULL );
break;
case 1:
/* Allocate the rest. */
timestamp = (TA_Timestamp *)NULL;
open = high = low = close = (TA_Real *)NULL;
#define TA_ALLOC_COPY( varName, varType, varSize) { \
varName = TA_Malloc( sizeof( varType ) * varSize ); \
if( !varName ) \
{ \
TA_Free( timestamp ); \
FREE_IF_NOT_NULL( open ); \
FREE_IF_NOT_NULL( high ); \
FREE_IF_NOT_NULL( low ); \
FREE_IF_NOT_NULL( close ); \
TA_TRACE_RETURN( TA_ALLOC_ERR ); \
} \
memcpy( varName, TA_SREF_##varName##_daily_ref_0_PRIV, sizeof( varType )*varSize ); }
TA_ALLOC_COPY( open, TA_Real, 33 );
TA_ALLOC_COPY( high, TA_Real, 33 );
TA_ALLOC_COPY( low, TA_Real, 33 );
TA_ALLOC_COPY( close, TA_Real, 33 );
#undef TA_ALLOC_COPY
/* Set the timestamp. */
timestamp = (TA_Timestamp *)TA_Malloc( sizeof( TA_Timestamp ) * 33 );
if( !timestamp )
{
FREE_IF_NOT_NULL( open );
FREE_IF_NOT_NULL( high );
FREE_IF_NOT_NULL( low );
FREE_IF_NOT_NULL( close );
TA_TRACE_RETURN( TA_ALLOC_ERR );
}
for( i=0; i < TA_REF_INTRA_NB_BARS; i++ )
TA_TimestampCopy( ×tamp[i], &TA_SREF_timestamp_intra_ref_0_PRIV[i] );
retCode = TA_HistoryAddData( paramForAddData,
TA_REF_INTRA_NB_BARS, TA_1MIN*10,
timestamp,
open, high,
low, close,
NULL, NULL );
break;
}
break;
case 1: /* This is TA_SIM_MRG */
retCode = addSimMrgData( privateHandle,
paramForAddData );
break;
}
TA_TRACE_RETURN( retCode );
}
