/* Check if the specified meta object is specified with associated with
the specified file in the specified file map
*/
c_bool
idl_fileMapObject(
/* QAC EXPECT 3673; No solution to the message here, but no problem either */
const idl_fileMap fileMap,
const char *fileName,
const c_baseObject object)
{
idl_file file;
c_baseObject o;
c_bool result = FALSE;
if (fileMap != NULL) {
/* find the file in the file map */
file = c_iterResolve(fileMap->files, idl_fileCompare, (c_iterResolveCompareArg)fileName);
if (file) {
/* find the meta object in the file association */
o = c_iterResolve (file->contains, idl_objectCompare, object);
if (o) {
/* if the object is found, the association is true */
result = TRUE;
}
}
}
return result;
}
/* Create source */
c_iter
idl_fileMapGetObjects(
const idl_fileMap fileMap,
const char *fileName)
{
idl_file file;
c_iter result;
result = 0;
if(fileMap != NULL) {
/* Lookup file */
file = c_iterResolve(fileMap->files, idl_fileCompare, (c_iterResolveCompareArg)fileName);
if (file) {
result = c_iterNew(0);
/* Walk metaobjects in filemap, add to source. */
if(file->contains) {
c_iterWalk(file->contains, (c_iterWalkAction)idl_fileMapFillList, result);
}
}
}
return result;
}
static void
q_countVarWalk(
q_expr e,
c_iter list)
{
q_list l;
q_expr found;
if (e != NULL) {
switch(e->kind) {
case T_VAR:
found = c_iterResolve(list,compareVar,e);
if (found == NULL) {
list = c_iterInsert(list,e);
}
break;
case T_FNC:
if (e->info.function->tag == Q_EXPR_CALLBACK) {
q_countVarWalk(q_getPar(e,2),list);
} else {
l = e->info.function->params;
while (l != NULL) {
q_countVarWalk(l->expr,list);
l = l->next;
}
}
break;
default:
break;
}
}
}
static void*
d_waitsetEventHandlerRunToCompletion(
void* userData)
{
d_subscriber subscriber;
d_durability durability;
d_admin admin;
d_waitset waitset;
c_iter events = NULL;
d_waitsetEntity we;
c_time time;
u_waitsetEvent event;
waitset = d_waitset(userData);
subscriber = d_waitsetGetSubscriber(waitset);
admin = d_subscriberGetAdmin(subscriber);
durability = d_adminGetDurability(admin);
time.seconds = 1;
time.nanoseconds = 0;
while(waitset->terminate == FALSE) {
if(waitset->timedWait == TRUE){
u_waitsetTimedWaitEvents(waitset->uwaitset, time,&events);
} else {
u_waitsetWaitEvents(waitset->uwaitset,&events);
}
if(d_durabilityGetState(durability) != D_STATE_TERMINATING){
if(waitset->terminate == FALSE){
d_lockLock(d_lock(waitset));
event = u_waitsetEvent(c_iterTakeFirst(events));
while(event){
we = c_iterResolve(waitset->entities, d_waitsetEntityFind, event->entity);
if(we){
we->action(we->dispatcher, event, we->usrData);
}
u_waitsetEventFree(event);
event = u_waitsetEvent(c_iterTakeFirst(events));
}
}
d_lockUnlock(d_lock(waitset));
}
if(events){/* events may be null if waitset was deleted */
c_iterFree(events);
}
}
return NULL;
}
u_result
u_dispatcherRemoveListener(
u_dispatcher _this,
u_dispatcherListener listener)
{
u_listener ul;
v_observer ko;
os_threadId tid;
u_result result = U_RESULT_OK;
struct compareArg arg;
if ((_this != NULL) && (listener != NULL)) {
os_mutexLock(&_this->mutex);
arg.listener = listener;
ul = (u_listener) c_iterResolve(_this->listeners, compare, &arg);
tid = _this->threadId;
if (ul != NULL) {
c_iterTake(_this->listeners, ul);
if (c_iterLength(_this->listeners) == 0) {
result = u_entityReadClaim(u_entity(_this), (v_entity*)(&ko));
if(result == U_RESULT_OK) {
assert(ko);
/* Wakeup the dispatch thread */
v_observerLock(ko);
v_observerNotify(ko, NULL, NULL);
v_observerUnlock(ko);
result = u_entityRelease(u_entity(_this));
if (result != U_RESULT_OK) {
OS_REPORT(OS_ERROR, "u_dispatcherRemoveListener", 0,
"Release observer failed.");
}
} else {
OS_REPORT(OS_WARNING, "u_dispatcherRemoveListener", 0,
"Failed to claim Dispatcher.");
}
}
u_listenerFree(ul);
}
os_mutexUnlock(&_this->mutex);
if ((c_iterLength(_this->listeners) == 0)
&& (os_threadIdToInteger(tid) != 0U)) {
os_threadWaitExit(tid, NULL);
}
} else {
OS_REPORT(OS_ERROR,"u_dispatcherInsertListener",0,
"Illegal parameter.");
result = U_RESULT_ILL_PARAM;
}
return result;
}
u_result
u_waitsetDetachFromDomain(
_Inout_ u_waitset _this,
_Inout_ u_domain domain)
{
u_result result;
os_result osr;
u_waitsetEntry entry;
assert(_this != NULL);
assert(domain != NULL);
osr = os_mutexLock_s(&_this->mutex);
if (osr == os_resultSuccess) {
entry = c_iterResolve(_this->entries, compare_domain, domain);
if (entry != NULL) {
_this->notifyDetached = OS_TRUE;
result = u_objectClose(entry);
if (result == U_RESULT_ALREADY_DELETED) {
result = U_RESULT_OK;
}
if (result == U_RESULT_OK) {
/* The entry is already freed but the address value can still
* be used to update the administration because it only removes
* the address value from the list.
*/
c_iterTake(_this->entries, entry);
} else {
result = U_RESULT_INTERNAL_ERROR;
OS_REPORT(OS_ERROR,
"u_waitsetDetachFromDomain", result,
"Operation u_waitsetEntryFree failed: "
"Waitset = 0x%"PA_PRIxADDR", result = %s",
(os_address)_this, u_resultImage(result));
assert(FALSE);
}
} else {
result = U_RESULT_PRECONDITION_NOT_MET;
}
(void)u_domainRemoveWaitset(domain, _this);
os_mutexUnlock(&_this->mutex);
} else {
result = U_RESULT_INTERNAL_ERROR;
OS_REPORT(OS_WARNING, "u_waitsetDetachFromDomain", result,
"Could not claim waitset.");
}
return result;
}
/* idl_searchObject will search in the specified "file"
association for the object specified in map->object.
If the object is found, it is returned and the associated
filename is stored in map->fileName.
*/
static void
idl_searchObject(
/* QAC EXPECT 3673; No solution to the message here, but no problem either */
const idl_file file,
const idl_map map)
{
c_baseObject o;
/* Search for the object in the specified "file" */
o = c_iterResolve(file->contains, idl_objectMap, map);
if (o != NULL) {
/* Store the associated filename */
map->fileName = file->fileName;
}
}
/* Add the specified meta object to the specified file */
static void
idl_fileObjectAdd(
/* QAC EXPECT 3673; No solution to the message here, but no problem either */
const idl_file file,
const c_baseObject object)
{
c_baseObject o;
/* find the meta object in the specified file */
o = c_iterResolve(file->contains, idl_objectCompare, object);
if (o == NULL) {
/* if not found, add it to the file */
c_iterInsert (file->contains, object);
}
}
/* Add an meta object association to a file for a specified file map */
void
idl_fileMapAssociation(
/* QAC EXPECT 3673; No solution to the message here, but no problem either */
const idl_fileMap fileMap,
const c_baseObject object,
const char *fileName)
{
idl_file file;
/* Find the file based upon the spcified filename */
file = c_iterResolve(fileMap->files, idl_fileCompare, (c_iterResolveCompareArg)fileName);
/* QAC EXPECT 3416; No side effect here */
assert(file);
/* Add the object association to the file */
idl_fileObjectAdd(file, object);
}
/* Add a file to the file map */
void
idl_fileMapAdd(
/* QAC EXPECT 3673; No solution to the message here, but no problem either */
const idl_fileMap fileMap,
const char *fileName)
{
idl_file file;
/* Find the file in the file map based on the file name */
file = c_iterResolve(fileMap->files, idl_fileCompare, (c_iterResolveCompareArg)fileName);
if (file == NULL) {
/* If not found, then add it now */
file = idl_fileNew(fileName);
c_iterAppend(fileMap->files, file);
}
}
c_bool idl_fileMapCheckFinalized(
const idl_fileMap fileMap,
const char* fileName)
{
idl_file file;
int count;
count = 0;
if(fileMap != NULL) {
file = c_iterResolve(fileMap->files, (c_iterResolveCompare)idl_fileCompare, (c_iterResolveCompareArg)fileName);
if(file) {
c_iterWalk(file->contains, (c_iterWalkAction)idl_checkFinalized, &count);
}
}
return !count;
}
c_bool
d_groupCreationQueueAdd(
d_groupCreationQueue queue,
d_group group)
{
c_bool result;
d_group found;
d_durability durability;
assert(d_objectIsValid(d_object(queue), D_GROUP_CREATION_QUEUE) == TRUE);
result = FALSE;
if(queue) {
d_lockLock(d_lock(queue));
found = c_iterResolve(queue->groups, (c_iterResolveCompare)compareGroups, group);
if(found == NULL){
queue->groups = c_iterInsert(queue->groups, group);
switch(d_groupGetKind(group)){
case D_DURABILITY_VOLATILE:
queue->groupsToCreateVolatile++;
break;
case D_DURABILITY_TRANSIENT:
case D_DURABILITY_TRANSIENT_LOCAL:
queue->groupsToCreateTransient++;
break;
case D_DURABILITY_PERSISTENT:
queue->groupsToCreatePersistent++;
break;
default:
assert(FALSE);
break;
}
durability = d_adminGetDurability(queue->admin);
d_durabilityUpdateStatistics(durability, d_statisticsUpdateGroupsToCreate, queue);
result = TRUE;
}
d_lockUnlock(d_lock(queue));
}
return result;
}
static void
checkTopicKeyList (
v_entity e,
c_voidp arg)
{
c_array keyList = v_topicMessageKeyList(e);
checkTopicKeyListArg *info = (checkTopicKeyListArg *) arg;
c_long i;
gapi_char *name;
c_long size;
c_iter iter;
gapi_boolean equal = TRUE;
iter = c_splitString(info->keyList, " \t,");
if ( iter ) {
size = c_arraySize(keyList);
for ( i = 0; equal && (i < size); i++ ) {
name = (gapi_char *)c_iterResolve(iter,
topicKeyCompare,
keyNameFromField(keyList[i]));
if ( !name ) {
equal = FALSE;
OS_REPORT_2(OS_API_INFO,
"gapi::kernelCheckTopicKeyList", 0,
"incompatible key <%s> found for topic <%s>",
keyNameFromField(keyList[i]),
v_entityName(e));
}
}
name = c_iterTakeFirst(iter);
while ( name ) {
os_free(name);
name = c_iterTakeFirst(iter);
}
c_iterFree(iter);
}
info->equal = equal;
}
/* This operation scans through the list of items within the 'stac' pragma.
* For each structure that is identified it will locate the corresponding
* meta structure. It will then locate each member mentioned in the 'stac'
* pragma within the member list of said meta structure. It will verify the
* located member is indeed a character array.
* It will then proceed to replace the meta data describing the located member
* with new meta data with as goal to have the new meta data identify the member
* as a string instead of as a character array.
* All replaced meta data is stored in out variables to facilitate restore the
* member list of the meta structure back into it's original configuration.
* This operation is needed then the meta data of the found structure is
* converted to XML. As the XML generation code is located in the database and
* we do not want the database to get knowledge of the 'stac' pragma.
*/
c_iter
idl_stacDefConvertAll(
idl_stacDef stacDef)
{
os_uint32 size;
os_uint32 i;
idl_stacMap stacMapItem;
c_structure structure;
c_iter memberNames;
os_uint32 memberNamesSize;
os_uint32 j;
os_char* memberName;
os_int32 memberIndex;
c_member member;
c_member newMember;
os_uint32* replacedIndex;
idl_stacDefReplaceInfo replaceData;
c_iter replaceInfo = NULL;
c_base base;
c_iter boundedStringToBeConverted;
os_boolean stacCanBeApplied = OS_TRUE;
os_boolean onlyExclusionlistings;
if(stacDef)
{
/* Create collections to hold the original members and their respective
* indexes in the member collection so we can easily restore the meta
* structure to it's original configuration at a later time.
*/
replaceInfo = c_iterNew(NULL);
size = c_iterLength (stacDef->stacList);
for(i = 0; i < size; i++)
{
stacMapItem = c_iterObject (stacDef->stacList, i);
/* find the matching structure in the meta data */
structure = idl_stacDefFindMetaStructureResolved(
stacMapItem->scope,
stacMapItem->typeName);
assert(structure);
replaceData = os_malloc(C_SIZEOF(idl_stacDefReplaceInfo));
replaceData->structure = structure;
replaceData->replacedIndexes = c_iterNew(NULL);
replaceData->replacedMembers = c_iterNew(NULL);
memberNames = c_splitString(stacMapItem->stacList, ",");
onlyExclusionlistings = idl_stacDefOnlyExclusionsDefined(stacMapItem->stacList);
memberNamesSize = c_iterLength(memberNames);
boundedStringToBeConverted = c_iterNew(NULL);
if(memberNamesSize == 0 || onlyExclusionlistings)
{
os_uint32 membersSize;
membersSize = c_arraySize(structure->members);
for(j = 0; j < membersSize; j++)
{
member = c_member(structure->members[j]);
memberName = c_specifier(member)->name;
/* check if this member is in the list of member names when
* the member names list contains exclusion listings
*/
if((onlyExclusionlistings && c_iterResolve(memberNames, idl_stacDefNamesAreEqual, memberName) == NULL) ||
memberNamesSize == 0)
{
stacCanBeApplied = idl_stacDefCanStacBeAppliedToMember(c_specifier(member)->type);
if(stacCanBeApplied)
{
/* this is a bounded string, so we want to convert */
c_iterInsert(boundedStringToBeConverted, member);
}
}
}
}
else
{
for(j = 0; j < memberNamesSize; j++)
{
memberName = c_iterTakeFirst(memberNames);
if(memberName[0] == '!')
{
printf("FATAL ERROR | #pragma stac: Illegal syntax combination detected. "
"The pragma stac definition for structure %s contains both normal "
"member listings (without the '!' character in front of them) as "
"well as exclusion member listings (with the '!' character in front "
"of them). This has no relevant meaning, please see the deployment manual "
"for information on usage of pragma stac.\n"
"Ignoring the following member defintion: '%s'\n",
c_metaScopedName(c_metaObject(structure)),
memberName);
exit(-2);
}
memberIndex = idl_stacDefFindMemberIndexByName(
structure->members,
memberName);
if(memberIndex == -1)
{
printf("FATAL ERROR | #pragma stac: Unable to locate member %s "
"within structure %s.\n",
memberName, c_metaScopedName(c_metaObject(structure)));
exit(-2);
}
member = structure->members[memberIndex];
/* Verify the member is a bounded string as required */
stacCanBeApplied = idl_stacDefCanStacBeAppliedToMember(c_specifier(member)->type);
if(!stacCanBeApplied)
{
printf("FATAL ERROR | #pragma stac: Member %s within structure "
"%s is not a bounded string (note: may be embedded within an array or sequence) as required.\n",
memberName, c_metaScopedName(c_metaObject(structure)));
assert(0);
exit(-2);
}
/* this is a bounded string, so we want to convert */
c_iterInsert(boundedStringToBeConverted, member);
}
}
while(c_iterLength(boundedStringToBeConverted) > 0)
{
member = c_iterTakeFirst(boundedStringToBeConverted);
memberIndex = idl_stacDefFindMemberIndexByName(
structure->members,
c_specifier(member)->name);
assert(memberIndex != -1);
newMember = c_metaDefine(c_metaObject(structure), M_MEMBER);
base = c_getBase(member);
c_specifier(newMember)->name = c_stringNew(base, c_specifier(member)->name);
c_specifier(newMember)->type = idl_stacDefConvertStacApprovedMember(structure, c_specifier(member)->type);
if(!c_specifier(newMember)->type)
{
printf("FATAL ERROR | #pragma stac: An internal error occured. Member %s within structure "
"%s failed to convert from a bounded string to a character array.\n",
c_specifier(newMember)->name, c_metaScopedName(c_metaObject(structure)));
assert(0);
exit(-2);
}
structure->members[memberIndex] = newMember;
c_iterInsert(replaceData->replacedMembers, member);
replacedIndex = os_malloc(sizeof(os_uint32));
*replacedIndex = (os_uint32)memberIndex;
c_iterInsert(replaceData->replacedIndexes, replacedIndex);
}
c_iterInsert(replaceInfo, replaceData);
}
}
return replaceInfo;
}
u_result
u_waitsetDetach_s(
const u_waitset _this,
const u_observable observable)
{
u_waitsetEntry entry;
u_domain domain;
u_result result;
os_result osr;
assert(_this != NULL);
assert(observable != NULL);
osr = os_mutexLock_s(&_this->mutex);
if (osr == os_resultSuccess) {
domain = u_observableDomain(observable);
if (domain != NULL) {
entry = c_iterResolve(_this->entries, compare_domain, domain);
if (entry != NULL) {
/* The following detach will wakeup any blocking wait call on this entry. */
result = u_waitsetEntryDetach(entry, observable);
if (result == U_RESULT_UNSUPPORTED) {
_this->detachCnt++;
/* removed last observable for this entry so can detach from domain. */
entry = c_iterTake(_this->entries, entry); /* use overwrite entry */
result = u_domainRemoveWaitset(domain, _this);
if (c_iterLength(_this->entries) == 1) {
_this->multi_mode = OS_FALSE;
} else {
_this->multi_mode = OS_TRUE;
}
while (_this->waitBusy) {
os_condWait(&_this->waitCv, &_this->mutex);
}
_this->detachCnt--;
/* Broadcast the detachCnt update. */
os_condBroadcast(&_this->waitCv);
os_mutexUnlock(&_this->mutex);
u_objectFree(entry);
} else {
os_mutexUnlock(&_this->mutex);
}
} else {
/* Check if the condition is already deleted */
v_public ko;
result = u_observableReadClaim(observable, &ko, C_MM_RESERVATION_NO_CHECK);
if (result == U_RESULT_OK) {
u_observableRelease(observable, C_MM_RESERVATION_NO_CHECK);
result = U_RESULT_PRECONDITION_NOT_MET;
OS_REPORT(OS_ERROR, "u_waitSetDetach_s", result, "Condition is not attached to Waitset");
}
os_mutexUnlock(&_this->mutex);
}
} else {
os_mutexUnlock(&_this->mutex);
result = U_RESULT_INTERNAL_ERROR;
OS_REPORT(OS_ERROR, "u_waitsetDetach_s", result,
"Failed to connect to domain.");
}
} else {
result = U_RESULT_INTERNAL_ERROR;
OS_REPORT(OS_ERROR, "u_waitSetDetach_s", result, "Could not lock the waitset.");
}
return result;
}
u_result
u_waitsetAttach(
const u_waitset _this,
const u_observable observable,
void *context)
{
u_waitsetEntry entry;
u_domain domain;
u_result result;
c_ulong length;
u_bool changed = FALSE;
os_result osr;
assert(_this != NULL);
assert(observable != NULL);
osr = os_mutexLock_s(&_this->mutex);
if (osr == os_resultSuccess) {
length = c_iterLength(_this->entries);
domain = u_observableDomain(observable);
if (domain != NULL) {
entry = c_iterResolve(_this->entries, compare_domain, domain);
} else {
entry = NULL;
}
if ((entry == NULL)&&(domain != NULL)) {
result = u_domainAddWaitset(domain, _this);
if (result == U_RESULT_OK) {
entry = u_waitsetEntryNew(_this, domain, _this->eventMask);
if (entry != NULL) {
_this->entries = c_iterInsert(_this->entries, entry);
changed = TRUE;
}
} else {
result = U_RESULT_INTERNAL_ERROR;
OS_REPORT(OS_ERROR, "u_waitSetAttach", result, "Failed to add waitset to domain.");
}
}
if (entry != NULL) {
result = u_waitsetEntryAttach(entry, observable, context);
} else {
result = U_RESULT_INTERNAL_ERROR;
OS_REPORT(OS_ERROR, "u_waitSetAttach", result, "Failed to connect to domain.");
}
if (changed == TRUE) {
if (length == 0) {
/* Wakeup waitset because its no longer in zero domain mode */
_this->multi_mode = OS_FALSE;
os_condSignal(&_this->cv);
result = U_RESULT_OK;
} else if (length == 1) {
_this->multi_mode = OS_TRUE;
c_iterWalk(_this->entries, set_multi_mode, (c_voidp)&_this->multi_mode);
}
}
os_mutexUnlock(&_this->mutex);
} else {
result = U_RESULT_INTERNAL_ERROR;
OS_REPORT(OS_ERROR, "u_waitSetAttach", result, "Could not lock the waitset.");
}
return result;
}
