c_bool
d_readerListenerCopy(
c_object object,
c_voidp copyArg)
{
d_readerListener listener;
d_message message;
v_message readerMessage;
c_bool result = FALSE;
if(object != NULL) {
if (v_stateTest(v_readerSampleState(object), L_VALIDDATA)) {
listener = d_readerListener(copyArg);
readerMessage = v_message(v_dataReaderSampleTemplate(object)->message);
message = C_DISPLACE(readerMessage, listener->fieldOffset);
listener->lastInsertTime = v_dataReaderSample(object)->insertTime;
listener->lastSourceTime = readerMessage->writeTime;
listener->value = c_keep(object);
if(listener->value){
listener->message = message;
}
listener->processMessage = TRUE;
} else {
/* Ignore data that is not valid but continue with the read action */
result = TRUE;
}
}
return result;
}
/* Print an error at the location of the previously lexed token. */
void
cpp_error (cpp_reader * pfile, int level, const char *msgid, ...)
{
source_location src_loc;
va_list ap;
va_start (ap, msgid);
if (CPP_OPTION (pfile, traditional))
{
if (pfile->state.in_directive)
src_loc = pfile->directive_line;
else
src_loc = pfile->line_table->highest_line;
}
else
{
src_loc = pfile->cur_token[-1].src_loc;
}
if (_cpp_begin_message (pfile, level, src_loc, 0))
v_message (msgid, ap);
va_end (ap);
}
/* Print an error at a specific location. */
void
cpp_error_with_line (cpp_reader *pfile, int level,
source_location src_loc, unsigned int column,
const char *msgid, ...)
{
va_list ap;
va_start (ap, msgid);
if (_cpp_begin_message (pfile, level, src_loc, column))
v_message (msgid, ap);
va_end (ap);
}
/* Print an error at the location of the previously lexed token. */
void
cpp_error (cpp_reader * pfile, int level, const char *msgid, ...)
{
source_location src_loc;
va_list ap;
va_start (ap, msgid);
if (CPP_OPTION (pfile, client_diagnostic))
pfile->cb.error (pfile, level, _(msgid), &ap);
else
{
if (CPP_OPTION (pfile, traditional))
{
if (pfile->state.in_directive)
src_loc = pfile->directive_line;
else
src_loc = pfile->line_table->highest_line;
}
/* We don't want to refer to a token before the beginning of the
current run -- that is invalid. */
else if (pfile->cur_token == pfile->cur_run->base)
{
if (pfile->cur_run->prev != NULL)
src_loc = pfile->cur_run->prev->limit->src_loc;
else
src_loc = 0;
}
/* We don't want to refer to a token before the beginning of the
current run -- that is invalid. */
else if (pfile->cur_token == pfile->cur_run->base)
{
if (pfile->cur_run->prev != NULL)
src_loc = pfile->cur_run->prev->limit->src_loc;
else
src_loc = 0;
}
else
{
src_loc = pfile->cur_token[-1].src_loc;
}
if (_cpp_begin_message (pfile, level, src_loc, 0))
v_message (msgid, ap);
}
va_end (ap);
}
/* Print an error at the location of the previously lexed token. */
void
cpp_error (cpp_reader * pfile, int level, const char *msgid, ...)
{
source_location src_loc;
va_list ap;
va_start (ap, msgid);
if (CPP_OPTION (pfile, client_diagnostic))
pfile->cb.error (pfile, level, _(msgid), &ap);
else
{
if (CPP_OPTION (pfile, traditional))
{
if (pfile->state.in_directive)
src_loc = pfile->directive_line;
else
src_loc = pfile->line_table->highest_line;
}
else
{
/* Find actual previous token. */
cpp_token *t;
if (pfile->cur_token != pfile->cur_run->base)
t = pfile->cur_token - 1;
else
{
if (pfile->cur_run->prev != NULL)
t = pfile->cur_run->prev->limit;
else
t = NULL;
}
/* Retrieve corresponding source location, unless we failed. */
src_loc = t ? t->src_loc : 0;
}
if (_cpp_begin_message (pfile, level, src_loc, 0))
v_message (msgid, ap);
}
va_end (ap);
}
/* Print an error at the location of the previously lexed token. */
void
cpp_error (cpp_reader * pfile, int level, const char *msgid, ...)
{
source_location src_loc;
va_list ap;
va_start (ap, msgid);
if (CPP_OPTION (pfile, client_diagnostic))
{
/* Versions up to 4.0.2 used cpplib's notion of pedantic_errors
rather than the front end's, so preserve this for the 4.0
branch. */
if (level == CPP_DL_PEDWARN)
level = (CPP_OPTION (pfile, pedantic_errors)
? CPP_DL_ERROR
: CPP_DL_WARNING);
pfile->cb.error (pfile, level, _(msgid), &ap);
}
else
{
if (CPP_OPTION (pfile, traditional))
{
if (pfile->state.in_directive)
src_loc = pfile->directive_line;
else
src_loc = pfile->line_table->highest_line;
}
else
{
src_loc = pfile->cur_token[-1].src_loc;
}
if (_cpp_begin_message (pfile, level, src_loc, 0))
v_message (msgid, ap);
}
va_end (ap);
}
static c_bool
d_instanceInject(
c_object o,
c_voidp arg)
{
d_instance instance;
d_sample sample;
v_message message, storeMessage, unregisterMsg;
struct d_instanceInjectArg* inj;
v_writeResult wr;
os_time oneSec;
c_iter unregisterMessagesToInject;
c_bool success;
assert(o != NULL);
assert(C_TYPECHECK(o, d_instance));
instance = d_instance(o);
inj = (struct d_instanceInjectArg*)(arg);
unregisterMessagesToInject = c_iterNew(NULL);
sample = d_sample(instance->oldest);
while ((sample != NULL) && (inj->result == D_STORE_RESULT_OK)) {
storeMessage = d_sampleGetMessage(sample);
/* copy message */
c_cloneIn(inj->messageType, storeMessage, (c_voidp*)&(message));
/* inject message */
wr = v_groupWriteNoStream(inj->vgroup, message, NULL, V_NETWORKID_LOCAL);
oneSec.tv_sec = 1;
oneSec.tv_nsec = 0;
while(wr == V_WRITE_REJECTED){
wr = v_groupWriteNoStream(inj->vgroup, message, NULL, V_NETWORKID_LOCAL);
os_nanoSleep(oneSec);
}
if((wr != V_WRITE_SUCCESS) &&
(wr != V_WRITE_REGISTERED) &&
(wr != V_WRITE_UNREGISTERED)) {
OS_REPORT_1(OS_ERROR, D_CONTEXT, 0,
"Unable to write persistent data to group. (result: '%d')\n",
wr);
inj->result = D_STORE_RESULT_ERROR;
} else {
/* If a sample is written or registered, add unregister action */
unregisterMsg = findUnregisterMessage(unregisterMessagesToInject, message);
if(!unregisterMsg){
unregisterMsg = createUnregisterMessage (inj->vgroup, message);
/* Add the newly created unregister message to the list of extra messages to inject */
unregisterMessagesToInject = c_iterAppend (
unregisterMessagesToInject, unregisterMsg);
}
/* Set valid sequence number */
if (message->sequenceNumber >= unregisterMsg->sequenceNumber) {
unregisterMsg->sequenceNumber = message->sequenceNumber + 1;
}
}
sample = sample->newer;
}
if(inj->result == D_STORE_RESULT_OK){
oneSec.tv_sec = 1;
oneSec.tv_nsec = 0;
/* inject the extra unregister messages */
unregisterMsg = v_message(c_iterTakeFirst(unregisterMessagesToInject));
while (unregisterMsg) {
wr = v_groupWriteNoStream(inj->vgroup, unregisterMsg, NULL, V_NETWORKID_LOCAL);
while(wr == V_WRITE_REJECTED){
wr = v_groupWriteNoStream(inj->vgroup, unregisterMsg, NULL, V_NETWORKID_LOCAL);
os_nanoSleep(oneSec);
}
unregisterMsg = v_message(c_iterTakeFirst(unregisterMessagesToInject));
}
c_iterFree(unregisterMessagesToInject);
}
if(inj->result == D_STORE_RESULT_OK){
success = TRUE;
} else {
success = FALSE;
}
return success;
}
