static void
idl_typedefOpenClose(
    idl_scope scope,
    const char *name,
    idl_typeDef defSpec,
    void *userData)
{
    c_char spaces[20];
    idl_tmplExp te;
    OS_UNUSED_ARG(userData);

    OS_UNUSED_ARG(userData);

    if (((idl_typeSpecType(idl_typeDefRefered(defSpec)) == idl_tstruct) ||
         (idl_typeSpecType(idl_typeDefRefered(defSpec)) == idl_tunion)) &&
         (idl_streamsResolve(idl_streamsDefDefGet(), scope, name))) {
        /* keylist defined for this typedef of struct or union */
        te = idl_tmplExpNew(idlpp_macroSet);
        idl_macroSetAdd(idlpp_macroSet,
            idl_macroNew("namescope", idl_cxxId(idl_scopeElementName(idl_scopeCur(scope)))));
        idl_macroSetAdd(idlpp_macroSet, idl_macroNew("typename", idl_cxxId(name)));
        snprintf(spaces, sizeof(spaces), "%d", idlpp_indent_level*4);
        idl_macroSetAdd(idlpp_macroSet, idl_macroNew("spaces", spaces));
        idlpp_inStream = idl_streamInNew(idlpp_template, idlpp_macroAttrib);
        idl_tmplExpProcessTmpl(te, idlpp_inStream, idl_fileCur());
        idl_streamInFree(idlpp_inStream);
        idl_tmplExpFree(te);
    }
}

static idl_action
idl_unionOpen(
    idl_scope scope,
    const char *name,
    idl_typeUnion unionSpec,
    void *userData)
{
    c_char spaces[20];
    idl_tmplExp te;

    OS_UNUSED_ARG(unionSpec);
    OS_UNUSED_ARG(userData);

    /* QAC EXPECT 3416; No side effects here */
    if (idl_streamsResolve(idl_streamsDefDefGet(), scope, name)) {
    /* keylist defined for this union */
        te = idl_tmplExpNew(idlpp_macroSet);
        idl_macroSetAdd(idlpp_macroSet,
            idl_macroNew("namescope", idl_cxxId(idl_scopeElementName(idl_scopeCur(scope)))));
        idl_macroSetAdd(idlpp_macroSet, idl_macroNew("typename", idl_cxxId(name)));
        idl_macroSetAdd(idlpp_macroSet, idl_macroNew("scopedtypename", idl_scopeStack(scope, "::", name)));
        snprintf(spaces, sizeof(spaces), "%d", idlpp_indent_level*4);
        idl_macroSetAdd(idlpp_macroSet, idl_macroNew("spaces", spaces));
        idlpp_inStream = idl_streamInNew(idlpp_template, idlpp_macroAttrib);
        idl_tmplExpProcessTmpl(te, idlpp_inStream, idl_fileCur());
        idl_streamInFree(idlpp_inStream);
        idl_tmplExpFree(te);
    }
    return idl_abort;
}

static c_ulong
cmx_participantDetach(
    u_observable o,
    c_ulong event,
    c_voidp usrData)
{
    v_serviceStateKind kind;
    u_serviceManager manager;

    OS_UNUSED_ARG(o);
    OS_UNUSED_ARG(event);
    OS_UNUSED_ARG(usrData);

    if ((event & V_EVENT_SERVICESTATE_CHANGED) == V_EVENT_SERVICESTATE_CHANGED) {
        if(cmx_isInitialized() == TRUE){
            manager = (u_serviceManager)usrData;

            if(manager != NULL){
                kind = u_serviceManagerGetServiceStateKind(manager, V_SPLICED_NAME);

                if ((kind != STATE_INITIALISING) && (kind != STATE_OPERATIONAL)) {
                    cmx_internalDetach();
                    u_objectFree(manager);
                    manager = NULL;
                }
            }
        }
    }
    return event;
}

static void
dummy_callback(
    v_public p,
    c_voidp arg)
{
    OS_UNUSED_ARG(p);
    OS_UNUSED_ARG(arg);
}

int dds_init (
    int argc,
    char ** argv)
{
    OS_UNUSED_ARG(argc);
    OS_UNUSED_ARG(argv);
    return 0;
}

unsigned char
DDS::OpenSplice::ReadCondition::test_sample_states (
    c_object o,
    c_voidp args)
{
    OS_UNUSED_ARG(o);
    OS_UNUSED_ARG(args);
    return true; /* state evaluation is now in the kernel. */
}

static int
os_threadStopCallback(
    os_threadId id,
    void *arg)
{
    OS_UNUSED_ARG(id);
    OS_UNUSED_ARG(arg);
    return 0;
}

void
c_mmUnbind(
    c_mm mm,
    const c_char *name)
{
    assert(0);
    OS_UNUSED_ARG(mm);
    OS_UNUSED_ARG(name);
}

static idl_action
idl_moduleOpen (
    idl_scope scope,
    const char *name,
    void *userData)
{
    c_ulong streamsIndex, streamsCount;
    idl_action result;
    OS_UNUSED_ARG(userData);

    OS_UNUSED_ARG(userData);

    /* Test whether the module contains a component within the pragma streams.
     * If it does not, then the module should not be generated since it will
     * contain no items (which is itself illegal idl syntax).
     *
     * Note that we are comparing against only the streams existing within this idl
     * file (idl_idlScopeStreamsList).  We do not use the result of idl_keyDefDefGet()
     * since this is a list of streams resulting from the preprocessed idl (which
     *  will include streams from other idl files that this may include).
     */
    result = idl_abort;
    streamsCount = os_iterLength(idl_idlScopeStreamsList);
    if (streamsCount != 0) {
        idl_scope moduleScope;
        idl_scopeElement newElement;

        /* the idl_scope parameter to this function does not yet include the scoping
         * for this module itself, so create a duplicate and add this scoping to it,
         * before testing whether this module contains one of the streams in this file.
         */
        moduleScope = idl_scopeDup(scope);
        newElement = idl_scopeElementNew(name, idl_tModule);
        idl_scopePush(moduleScope, newElement);

        /* Loop through the list of keys applying to this idl file and test whether
         * this particular module contains one of these keys.  If it does, generate
         * code for the module.
         */
        for (streamsIndex = 0; (streamsIndex < streamsCount) && (result == idl_abort); streamsIndex++) {
            idl_scope streamsScope = os_iterObject(idl_idlScopeStreamsList, streamsIndex);
            if (idl_scopeSub(moduleScope, streamsScope)) {
                /* Scopes match */
                result = idl_explore;
            }
        }
    }

    if (result == idl_explore) {
        idl_printIndent(idlpp_indent_level);
        idl_fileOutPrintf(idl_fileCur(), "module %s {\n", idl_cxxId(name));
        idl_fileOutPrintf(idl_fileCur(), "\n");
        idlpp_indent_level++;
    }
    return result;
}

os_result
os_mmfResize(
    os_mmfHandle mmfHandle,
    os_uint32 new_size)
{
    OS_UNUSED_ARG (mmfHandle);
    OS_UNUSED_ARG (new_size);
    OS_REPORT(OS_INFO, "os_mmfResize", 0, "NOT IMPLEMENTED");
    return os_resultUnavailable;
}

os_mmfHandle
os_mmfCreateHandle (
    const char *filename,
    const os_mmfAttr *mmfAttr)
{
    OS_UNUSED_ARG (filename);
    OS_UNUSED_ARG (mmfAttr);
    OS_REPORT(OS_INFO, "os_mmfCreateHandle", 0, "NOT IMPLEMENTED");
    return NULL;
}

void
DDS::OpenSplice::DataReaderView::nlReq_notify_listener (
    DDS::OpenSplice::Entity *sourceEntity,
    DDS::ULong               triggerMask,
    void                    *eventData)
{
    OS_UNUSED_ARG(sourceEntity);
    OS_UNUSED_ARG(triggerMask);
    OS_UNUSED_ARG(eventData);
}

os_signalHandlerExceptionHandle
os_signalHandlerRegisterCheckExceptionCallback(
    os_signalHandlerExceptionCallback callback,
    void * arg)
{
    OS_UNUSED_ARG(callback);
    OS_UNUSED_ARG(arg);

    return os_signalHandlerExceptionHandleNil;
}

os_result
os_mmfCreate(
    os_mmfHandle mmfHandle,
    os_address size)
{
    OS_UNUSED_ARG (mmfHandle);
    OS_UNUSED_ARG (size);
    OS_REPORT(OS_INFO, "os_mmfCreate", 0, "NOT IMPLEMENTED");
    return os_resultUnavailable;
}

static idl_action
idl_moduleOpen(
    idl_scope scope,
    const char *name,
    void *userData)
{
    OS_UNUSED_ARG(scope);
    OS_UNUSED_ARG(name);
    OS_UNUSED_ARG(userData);

    return idl_explore;
}

static void
idl_moduleClose(
    void *userData)
{
    OS_UNUSED_ARG(userData);

    /* this is only executed if idl_moduleOpen returns 'idl_explore' */
    OS_UNUSED_ARG(userData);
    idlpp_indent_level--;
    idl_printIndent(idlpp_indent_level);
    idl_fileOutPrintf(idl_fileCur(), "};\n");
    idl_fileOutPrintf(idl_fileCur(), "\n");
}

static idl_action
idl_moduleOpen(
    idl_scope scope,
    const char *name,
    void *userData)
{
    OS_UNUSED_ARG(scope);
    OS_UNUSED_ARG(userData);

    idl_printIndent(idlpp_indent_level);
    idl_fileOutPrintf(idl_fileCur(), "namespace %s {\n", idl_cxxId(name));
    idl_fileOutPrintf(idl_fileCur(), "\n");
    idlpp_indent_level++;
    return idl_explore;
}

v_writeResult
v_deliveryServiceEntryWrite(
    v_deliveryServiceEntry _this,
    v_message message,
    v_instance *instancePtr)
{
    v_deliveryInfoTemplate ackMsg;
    v_writeResult result = V_WRITE_REJECTED;
    v_reader reader;

    OS_UNUSED_ARG(instancePtr);
    assert(C_TYPECHECK(_this,v_deliveryServiceEntry));
    assert(message != NULL);

    /* Only write if the message is not produced by an incompatible writer. */
    reader = v_entryReader(_this);
    OSPL_LOCK(reader);

    /* Filter-out all QoS-incompatible messages. */
    if (!v_messageQos_isReaderCompatible(message->qos,reader)) {
        OSPL_UNLOCK(reader);
        return V_WRITE_SUCCESS;
    }

    /* If Alive then claim instance and trigger with sample event. */
    ackMsg = (v_deliveryInfoTemplate)message;
    result = v_deliveryServiceWrite(v_deliveryService(reader),ackMsg);

    OSPL_UNLOCK(reader);

    return result;
}

void
v_topicAdapterNotify(
    v_topicAdapter adapter,
    v_event event,
    c_voidp userData)
{
    C_STRUCT(v_event) e;
    c_bool forward = TRUE;

    OS_UNUSED_ARG(userData);
    assert(adapter != NULL);
    assert(C_TYPECHECK(adapter,v_topicAdapter));
    assert(event != NULL);

    switch (event->kind) {
    case V_EVENT_ALL_DATA_DISPOSED:
        v_statusNotifyAllDataDisposed(v_entity(adapter)->status);
    break;
    case V_EVENT_INCONSISTENT_TOPIC:
        v_statusNotifyInconsistentTopic(v_entity(adapter)->status);
    break;
    default:
        forward = FALSE;
    break;
    }
    if (forward) {
        e.kind = event->kind;
        e.source = v_observable(adapter);
        e.data = NULL;
        (void)v_entityNotifyListener(v_entity(adapter), &e);
    }
}

void
d_objectFree(
    d_object object,
    d_kind kind)
{
    os_uint32 refCount;

    OS_UNUSED_ARG(kind);
    assert(d_objectIsValid(object, kind) == TRUE);

    if(object){
       assert(object->confidence == D_CONFIDENCE);
       assert(object->kind == kind);
       assert(object->refCount >= 1);

       refCount = pa_decrement(&(object->refCount));

       if(refCount == 0){
           if(object->deinit){
               object->deinit(object);
           }
           object->confidence = D_CONFIDENCE_NULL;
           object->kind = D_BAD_TYPE;
           os_free(object);
           assert(doSub(kind));
       }
#if CHECK_REF
       if (kind == CHECK_REF_TYPE) {
           UT_TRACE("\n\n============ Free(%p): %d -> %d =============\n",
                   (void*)object, refCount+1, refCount);
       }
#endif
    }
}