自学教程：C++ Assert_isTrue函数代码示例

/* *  ======== Timer_getStatus ======== */Timer_Status Timer_getStatus(UInt timerId){    Assert_isTrue(timerId < Timer_NUM_TIMER_DEVICES, NULL);    if (Timer_module->availMask & (0x1 << timerId)) {        return (Timer_Status_FREE);    }    else {        return (Timer_Status_INUSE);    }}

/*! *  ======== InterruptDsp_intDisable ======== *  Disables remote processor interrupt */     Void InterruptDsp_intDisable(UInt16 remoteProcId, IInterrupt_IntInfo *intInfo){    UInt16 index;    Assert_isTrue(((remoteProcId < MultiProc_getNumProcsInCluster()) &&            (remoteProcId != MultiProc_self())), ti_sdo_ipc_Ipc_A_internal);    index = MBX_TABLE_IDX(remoteProcId, MultiProc_self());    REG32(MAILBOX_IRQENABLE_CLR_DSP(index)) = MAILBOX_REG_VAL(SUBMBX_IDX(index));}

/*! *  ======== InterruptDsp_intRegister ========  */Void InterruptDsp_intRegister(UInt16 remoteProcId, IInterrupt_IntInfo *intInfo,                              Fxn func, UArg arg){    UInt        key;    UInt        eventId;    UInt        combinedEventId;    Int         index;     Hwi_Params  params;    InterruptDsp_FxnTable *table;     Assert_isTrue(((remoteProcId < MultiProc_getNumProcsInCluster()) &&                    (remoteProcId != MultiProc_self())), ti_sdo_ipc_Ipc_A_internal);    index = PROCID(remoteProcId);        /* Disable global interrupts */    key = Hwi_disable();    table = &(InterruptDsp_module->fxnTable[index]);    table->func = func;    table->arg  = arg;        InterruptDsp_intClear(remoteProcId, intInfo);        /* Make sure the interrupt only gets plugged once */    eventId = InterruptDsp_dspInterruptTable[index];        InterruptDsp_module->numPlugged++;        if (InterruptDsp_module->numPlugged == 1) {        EventCombiner_dispatchPlug(eventId,            (Hwi_FuncPtr)InterruptDsp_intShmStub, eventId, TRUE);        Hwi_Params_init(&params);          combinedEventId = eventId / EVENT_GROUP_SIZE;                      params.eventId = combinedEventId;        params.arg = combinedEventId;        params.enableInt = TRUE;        Hwi_create(intInfo->intVectorId, &ti_sysbios_family_c64p_EventCombiner_dispatch,                   &params, NULL);        Hwi_enableInterrupt(intInfo->intVectorId);    }    else {        EventCombiner_dispatchPlug(eventId,                (Hwi_FuncPtr)InterruptDsp_intShmStub, eventId, TRUE);    }    /* Enable the mailbox interrupt to the DSP */    InterruptDsp_intEnable(remoteProcId, intInfo);        /* Restore global interrupts */    Hwi_restore(key);}

/* *  ======== Event_post ======== */Void Event_post(Event_Object *event, UInt eventId){    UInt tskKey, hwiKey;    Event_PendElem *elem;    Queue_Handle pendQ;    Assert_isTrue((eventId != 0), Event_A_nullEventId);    Log_write3(Event_LM_post, (UArg)event, (UArg)event->postedEvents, (UArg)eventId);    pendQ = Event_Instance_State_pendQ(event);    /* atomically post this event */    hwiKey = Hwi_disable();    /* or in this eventId */    event->postedEvents |= eventId;    /* confirm that ANY tasks are pending on this event */    if (Queue_empty(pendQ)) {        Hwi_restore(hwiKey);        return;    }    tskKey = Task_disable();    /* examine pendElem on pendQ */    elem = (Event_PendElem *)Queue_head(pendQ);    /* check for match, consume matching eventIds if so. */    elem->matchingEvents = Event_checkEvents(event, elem->andMask, elem->orMask);    if (elem->matchingEvents != 0) {        /* remove event elem from elem queue */        Queue_remove((Queue_Elem *)elem);        /* mark the Event as having been posted */        elem->pendState = Event_PendState_POSTED;        /* disable Clock object */        if (BIOS_clockEnabled && (elem->tpElem.clock != NULL)) {            Clock_stop(elem->tpElem.clock);        }        /* put task back into readyQ */        Task_unblockI(elem->tpElem.task, hwiKey);    }    Hwi_restore(hwiKey);    /* context switch may occur here */    Task_restore(tskKey);}

Int dvsdk_grapx_display_rpc_display_toggle (Int instID){  Int status;      Assert_isTrue((MultiProc_self() != MultiProc_getId("VPSS-M3")), Assert_E_assertFailed);  status = dvsdk_grapx_display_rpc_remote_mode_init();  if (status >= 0) {    status = dvsdk_grapx_display_exec_rpc(instID, g_RemoteStubContext.nDisplayToggelFxnIdx);  }  return status;  }

/* *  ======== SemaphoreMP_registerEvent ======== */Int SemaphoreMP_registerEvent(UArg arg, UInt16 remoteProcId) {    Int status;        status = Notify_registerEvent(remoteProcId, 0, SemaphoreMP_notifyEventId,             SemaphoreMP_cbFxn, NULL);                Assert_isTrue(status >= 0, ti_sdo_ipc_Ipc_A_internal);        return (0);}

/* *  ======== Timer_getStatus ======== *  Get the FREE/INUSE status of the timer. */Timer_Status Timer_getStatus(UInt timerId){    Assert_isTrue(timerId < Timer_numTimerDevices, NULL);    if (Timer_module->availMask & (0x1 << timerId)) {        return (Timer_Status_FREE);    }    else {        return (Timer_Status_INUSE);    }}

/* *  ======== Algorithm_exit ======== */Void Algorithm_exit(){    Assert_isTrue(curInit > 0, (Assert_Id)NULL);    if (--curInit == 0) {        ALG_exit();        DMAN3_CE_exit();        RMAN_exit();    }}

/* *  ======== Timer_getHandle ======== */Timer_Handle Timer_getHandle(UInt id){    Assert_isTrue((id < Timer_NUM_TIMER_DEVICES), NULL);    if (id >= Timer_NUM_TIMER_DEVICES) {        return (NULL);    }    else {        return (Timer_module->handles[id]);    }}

/* *  ======== Hwi_reconfig ======== *  Reconfigure a dispatched interrupt. */Void Hwi_reconfig(Hwi_Object *hwi, Hwi_FuncPtr fxn, const Hwi_Params *params){    UInt intNum;    Int priority;    for (intNum = 0; intNum < Hwi_NUM_INTERRUPTS; intNum++) {        if (Hwi_module->dispatchTable[intNum] == hwi) {            break;        }    }    Hwi_disableInterrupt(intNum);    hwi->fxn = fxn;    hwi->arg = params->arg;    priority = params->priority;    /*      * the -1 sentinel priority is the default passed by hal Hwi_create().     * Translate it to 31, which is our default priority.     */    if (priority == -1) {        priority = 31;    }    Hwi_module->priorities[intNum] = priority;    Hwi_setPriority(intNum, priority);    Assert_isTrue((params->maskSetting != Hwi_MaskingOption_BITMASK),                  Hwi_A_unsupportedMaskingOption);                      switch (params->maskSetting) {        case Hwi_MaskingOption_NONE:            hwi->handler = Hwi_handlerNONE;            break;        case Hwi_MaskingOption_ALL:            hwi->handler = Hwi_handlerALL;            break;        case Hwi_MaskingOption_LOWER:            hwi->handler = Hwi_handlerLOWER;            break;        case Hwi_MaskingOption_BITMASK:        case Hwi_MaskingOption_SELF:            hwi->handler = Hwi_handlerSELF;            break;    }    if (params->enableInt) {        Hwi_enableInterrupt(intNum);    }}

/* *  ======== DriverAdapter_reclaim ======== */Void DriverAdapter_reclaim(DriverAdapter_Object *obj,     DriverTypes_Packet **packet, Error_Block *eb){    List_Handle fromDriver;    fromDriver = DriverAdapter_Instance_State_fromDriver(obj);    /* Should never ever get this assert */    Assert_isTrue(!List_empty(fromDriver), DriverAdapter_A_noReadyPacket);    *packet = (DriverTypes_Packet *)List_get(fromDriver);}

/* *  ======== IpcMgr_callIpcStart ======== *  Initialize standard IPC module, which may use the RPMSG protocol as well. * *  Calls the Ipc_start command.  This must be done after IpcMgr_ipcStartup(). * *  Use for stacks using a combination of TransportRpmsg and other Transports. */Void IpcMgr_callIpcStart(){    Int status;    /*     *  Ipc_start() calls Ipc_attach() to synchronize all remote processors     *  if 'Ipc.procSync' is set to 'Ipc.ProcSync_ALL' in *.cfg     *  HOST is skipped, thanks to overriding NotifySetup_numIntLines().     */    status = Ipc_start();    Assert_isTrue(status >= 0, NULL);}

/* *  ======== Clock_Instance_finalize ======== */Void Clock_Instance_finalize(Clock_Object *obj){    UInt key;    Assert_isTrue(((BIOS_getThreadType() != BIOS_ThreadType_Hwi) &&                   (BIOS_getThreadType() != BIOS_ThreadType_Swi)),                        Clock_A_badThreadType);    key = Hwi_disable();    Queue_remove(&obj->elem);    Hwi_restore(key);}

/* *  ======== Notify_attach ======== *  Called within Ipc module or directly by the user */Int Notify_attach(UInt16 remoteProcId, Ptr sharedAddr){    Int status;    Assert_isTrue(remoteProcId < ti_sdo_utils_MultiProc_numProcessors,                  ti_sdo_ipc_Notify_A_invArgument);    /* Use the NotifySetup proxy to setup drivers */    status = ti_sdo_ipc_Notify_SetupProxy_attach(remoteProcId, sharedAddr);    return (status);}

static void _ECPY_initEDMA3CHANStaticProperties(IRES_EDMA3CHAN2_Handle handle){    /* ensure that the toolchain uses same structure layout for PaRAM overlay */    Assert_isTrue((sizeof(IRES_EDMA3CHAN_PaRamStruct)==32), (Assert_Id)NULL);        if (_EDMA3_globalRegs == NULL) {        handle->ires.getStaticProperties((struct IRES_Obj *)handle,                  (IRES_Properties *)&_EDMA3CHAN_staticProperties);        _EDMA3_globalRegs = _EDMA3CHAN_staticProperties.globalRegs;    }}

/* *  ======== Notify_intLineRegistered ======== */Bool Notify_intLineRegistered(UInt16 procId, UInt16 lineId){    Bool registered;    UInt16 clusterId = ti_sdo_utils_MultiProc_getClusterId(procId);    Assert_isTrue(procId < ti_sdo_utils_MultiProc_numProcessors && lineId <                  ti_sdo_ipc_Notify_numLines, ti_sdo_ipc_Notify_A_invArgument);    registered = (Notify_module->notifyHandles[clusterId][lineId] != NULL);    return (registered);}

/* *  ======== Pmu_getOverflowStatus ======== */Bool Pmu_getOverflowStatus(UInt counterId){    Assert_isTrue((counterId < Pmu_module->numCounters),            Pmu_A_invalidCounterId);    if (Pmu_getOverflowStatusI(counterId)) {        return (TRUE);    }    else {        return (FALSE);    }}

/* *  ======== processWait ======== */static XDAS_Int32 processWait(IVIDDEC2BACK_Handle h, XDM_Context *context,        IVIDDEC2_OutArgs *outArgs, UInt timeout){    XDAS_Int32 retVal;    _VIDDEC2BACK_Msg *msg;    VISA_Handle visa = (VISA_Handle)h;    Assert_isTrue(!VISA_isLocal(visa), (Assert_Id)NULL);    /* wait for completion of "last" message */    retVal = VISA_wait(visa, (VISA_Msg *)&msg, timeout);    Assert_isTrue(msg->visa.cmd == _VIDDEC2BACK_CPROCESS, (Assert_Id)NULL);    /*     * Regardless of return value, unmarshall outArgs.     */    retVal = unmarshallMsg(h, context, outArgs, msg, retVal);    return (retVal);}

/* *  ======== VIDENCCOPY_TI_alloc ======== */Int VIDENCCOPY_TI_alloc(const IALG_Params *algParams,    IALG_Fxns **pf, IALG_MemRec memTab[]){    Registry_Result   result;    /*     *  No need to reference count for Registry_addModule(), since there     *  is no way to remove the module.     */    if (regInit == 0) {        /* Register this module for logging */        result = Registry_addModule(&ti_sdo_ce_examples_codecs_videnc_copy_desc,                MODNAME);        Assert_isTrue(result == Registry_SUCCESS, (Assert_Id)NULL);        if (result == Registry_SUCCESS) {            /* Set the diags mask to the CE default */            CESettings_init();            CESettings_setDiags(MODNAME);        }        regInit = 1;    }    Log_print3(Diags_ENTRY, "[+E] VIDENCCOPY_TI_alloc(0x%x, 0x%x, 0x%x)",            (IArg)algParams, (IArg)pf, (IArg)memTab);    /* Request memory for my object */    memTab[0].size = sizeof(VIDENCCOPY_TI_Obj);    memTab[0].alignment = 0;    memTab[0].space = IALG_EXTERNAL;    memTab[0].attrs = IALG_PERSIST;	// ADD BY ZHENGHANG   	memTab[1].size = sizeof(char)*25000 * 1024;    memTab[1].alignment = 0;    memTab[1].space = IALG_EXTERNAL;//IALG_DARAM0;    memTab[1].attrs = IALG_PERSIST;	// ADD BY ZHOULU		memTab[2].size = sizeof(char) * 150000 * 1024;	memTab[2].alignment = 0;	memTab[2].space = IALG_EXTERNAL;	memTab[2].attrs = IALG_PERSIST;	memTab[3].size = sizeof(char) * 127*1024;	memTab[3].alignment = 0;	memTab[3].space = IALG_DARAM0;	memTab[3].attrs = IALG_PERSIST;//IALG_DARAM0;    return (4);}

/* *  ======== Task_sleep ======== */Void Task_sleep(UInt timeout){    Task_PendElem elem;    UInt hwiKey, tskKey;    Clock_Struct clockStruct;    if (timeout == BIOS_NO_WAIT) {        return;    }    Assert_isTrue((timeout != BIOS_WAIT_FOREVER), Task_A_badTimeout);    /* add Clock event if timeout is not FOREVER */    if (BIOS_clockEnabled) {        Clock_Params clockParams;        Clock_Params_init(&clockParams);        clockParams.arg = (UArg)&elem;        clockParams.startFlag = FALSE;  /* will start when necessary, thankyou */        Clock_construct(&clockStruct, (Clock_FuncPtr)Task_sleepTimeout, timeout, &clockParams);        elem.clock = Clock_handle(&clockStruct);    }    hwiKey = Hwi_disable();    /* lock scheduler */    tskKey = Task_disable();    /* get task handle and block tsk */    elem.task = Task_self();    Task_blockI(elem.task);    if (BIOS_clockEnabled) {        Clock_startI(elem.clock);    }    /* Only needed for Task_delete() */    Queue_elemClear(&elem.qElem);    elem.task->pendElem = (Ptr)(&elem);    Hwi_restore(hwiKey);    Log_write3(Task_LM_sleep, (UArg)elem.task, (UArg)elem.task->fxn,                (UArg)timeout);    Task_restore(tskKey);       /* the calling task will block here */    /* deconstruct Clock if appropriate */    if (BIOS_clockEnabled) {        Clock_destruct(Clock_struct(elem.clock));    }}

/* *  ======== TransportShm_openByAddr ======== */Int TransportShm_openByAddr(Ptr sharedAddr,                      TransportShm_Handle *handlePtr,                      Error_Block *eb){    TransportShm_Params params;    TransportShm_Attrs *attrs;    Int status;    UInt16 id;    if (sharedAddr == NULL) {        return (MessageQ_E_FAIL);    }    TransportShm_Params_init(&params);    /* Tell Instance_init() that we're opening */    params.openFlag = TRUE;    attrs = (TransportShm_Attrs *)sharedAddr;    id = SharedRegion_getId(sharedAddr);    /* Assert that the region is valid */    Assert_isTrue(id != SharedRegion_INVALIDREGIONID,            ti_sdo_ipc_Ipc_A_addrNotInSharedRegion);    /* invalidate the attrs before using it */    if (SharedRegion_isCacheEnabled(id)) {        Cache_inv(attrs, sizeof(TransportShm_Attrs), Cache_Type_ALL, TRUE);    }    /* set params field */    params.sharedAddr    = sharedAddr;    params.priority      = attrs->priority;    if (attrs->flag != TransportShm_UP) {        /* make sure transport is up */        *handlePtr = NULL;        status = MessageQ_E_NOTFOUND;    }    else {        /* Create the object */        *handlePtr = TransportShm_create(attrs->creatorProcId, &params, eb);        if (*handlePtr == NULL) {            status = MessageQ_E_FAIL;        }        else {            status = MessageQ_S_SUCCESS;        }    }    return (status);}

/* *  ======== Ipc_readConfig ======== */Int Ipc_readConfig(UInt16 remoteProcId, UInt32 tag, Ptr cfg, SizeT size){    Int status = Ipc_E_FAIL;    UInt16 clusterId = ti_sdo_utils_MultiProc_getClusterId(remoteProcId);    volatile ti_sdo_ipc_Ipc_ConfigEntry *entry;    Bool cacheEnabled = SharedRegion_isCacheEnabled(0);    /* Assert that the remoteProc in our cluster and isn't our own */    Assert_isTrue(clusterId < ti_sdo_utils_MultiProc_numProcsInCluster,                  ti_sdo_utils_MultiProc_A_invalidMultiProcId);    if (cacheEnabled) {        Cache_inv(Ipc_module->procEntry[clusterId].remoteConfigList,                  SharedRegion_getCacheLineSize(0),                  Cache_Type_ALL,                  TRUE);    }    entry = (ti_sdo_ipc_Ipc_ConfigEntry *)            *Ipc_module->procEntry[clusterId].remoteConfigList;    while ((SharedRegion_SRPtr)entry != ti_sdo_ipc_SharedRegion_INVALIDSRPTR) {        entry = (ti_sdo_ipc_Ipc_ConfigEntry *)                SharedRegion_getPtr((SharedRegion_SRPtr)entry);        /* Traverse the list to find the tag */        if (cacheEnabled) {            Cache_inv((Ptr)entry,                      size + sizeof(ti_sdo_ipc_Ipc_ConfigEntry),                      Cache_Type_ALL,                      TRUE);        }        if ((entry->remoteProcId == MultiProc_self()) &&            (entry->localProcId == remoteProcId) &&            (entry->tag == tag)) {            if (size == entry->size) {                memcpy(cfg, (Ptr)((UInt32)entry + sizeof(ti_sdo_ipc_Ipc_ConfigEntry)),                        entry->size);                return (Ipc_S_SUCCESS);            }            else {                return (Ipc_E_FAIL);            }        }        entry = (ti_sdo_ipc_Ipc_ConfigEntry *)entry->next;    }    return (status);}

/* *  ======== Pd_init ======== */Void Pd_init(Void){    Registry_Result     result;    if (curInit++ != 0) {        return;  /* already initialized */    }    /* register with xdc.runtime to get a diags mask */    result = Registry_addModule(&Registry_CURDESC, MODULE_NAME);    Assert_isTrue(result == Registry_SUCCESS, (Assert_Id)NULL);}

/*! *  ======== InterruptDsp_intEnable ======== *  Enable remote processor interrupt */     Void InterruptDsp_intEnable(UInt16 remoteProcId, IInterrupt_IntInfo *intInfo){    if (remoteProcId == InterruptDsp_hostProcId) {        REG32(MAILBOX_IRQENABLE_SET_DSP) = 0x40;    }    else if (remoteProcId == InterruptDsp_core0ProcId) {        REG32(MAILBOX_IRQENABLE_SET_DSP) = 0x10;    }    else {        /* DSP cannot talk to CORE1 */        Assert_isTrue(FALSE, ti_sdo_ipc_Ipc_A_internal);    }}

/* *  ======== processWait ======== */static XDAS_Int32 processWait(IAUDENC1_Handle h, XDM1_BufDesc *inBufs,    XDM1_BufDesc *outBufs, IAUDENC1_InArgs *inArgs, IAUDENC1_OutArgs *outArgs,    UInt timeout){    XDAS_Int32 retVal;    _AUDENC1_Msg *msg;    VISA_Handle visa = (VISA_Handle)h;    Assert_isTrue(!VISA_isLocal(visa), (Assert_Id)NULL);    /* wait for completion of "last" message */    retVal = VISA_wait(visa, (VISA_Msg *)&msg, timeout);    /* Unmarshall outArgs if there is a msg to unmarshall. */    if (msg != NULL) {        Assert_isTrue(msg->visa.cmd == _AUDENC1_CPROCESS, (Assert_Id)NULL);        unmarshallMsg(h, inBufs, outBufs, inArgs, outArgs, msg);    }    return (retVal);}

/* *  ======== TimestampProvider_Module_startup ======== */Int TimestampProvider_Module_startup( Int phase ){    Clock_TimerProxy_Handle clockTimer;    if (BIOS_clockEnabled && TimestampProvider_useClockTimer) {        /* get Clock's timer handle */        clockTimer = Clock_getTimerHandle();        Assert_isTrue((clockTimer != NULL), NULL);        MOD->timer = (Timer_Handle)clockTimer;    }    return Startup_DONE;}

/* *  ======== Mmu_initDescAttrs ======== */Void Mmu_initDescAttrs(Mmu_FirstLevelDescAttrs *attrs){    /* Assert that attrs != NULL */    Assert_isTrue(attrs != NULL, Mmu_A_nullPointer);        attrs->type = Mmu_defaultAttrs.type;    attrs->bufferable = Mmu_defaultAttrs.bufferable;            attrs->cacheable = Mmu_defaultAttrs.cacheable;    attrs->imp = Mmu_defaultAttrs.imp;    attrs->domain = Mmu_defaultAttrs.domain;    attrs->accPerm = Mmu_defaultAttrs.accPerm;    attrs->imp = Mmu_defaultAttrs.imp;}

/*! *  ======== IntXbar_disconnectIRQ ======== */Void IntXbar_disconnectIRQ(UInt cpuIRQNum){#ifdef xdc_target__isaCompatible_arp32    Assert_isTrue((cpuIRQNum <= 7),            IntXbar_A_badEveIRQNum);    IntXbar_disconnect(cpuIRQNum + 1);#elif defined xdc_target__isaCompatible_66    Assert_isTrue((cpuIRQNum >= 32) && (cpuIRQNum <= 95),            IntXbar_A_badDspIRQNum);    IntXbar_disconnect(cpuIRQNum - 31);#elif (defined xdc_target__isaCompatible_v7M4)    Assert_isTrue((cpuIRQNum >= 23) && (cpuIRQNum <= 79),            IntXbar_A_badBenelliIRQNum);    IntXbar_disconnect(cpuIRQNum - 22);#elif defined xdc_target__isaCompatible_v7A15    Assert_isTrue((cpuIRQNum == 4) ||            ((cpuIRQNum >= 7) && (cpuIRQNum <= 130)) ||            ((cpuIRQNum >= 133) && (cpuIRQNum <= 138)) ||            ((cpuIRQNum >= 141) && (cpuIRQNum <= 159)),            IntXbar_A_badA15IRQNum);    if (cpuIRQNum == 4) {        IntXbar_disconnect(cpuIRQNum - 3);    }    else if ((cpuIRQNum >= 7) && (cpuIRQNum <= 130)) {        IntXbar_disconnect(cpuIRQNum - 5);    }    else if ((cpuIRQNum >= 133) && (cpuIRQNum <= 138)) {        IntXbar_disconnect(cpuIRQNum - 7);    }    else if ((cpuIRQNum >= 141) && (cpuIRQNum <= 159)) {        IntXbar_disconnect(cpuIRQNum - 7);    }#endif}

/* *  ======== MessageQ_open ======== */Int MessageQ_open(String name, MessageQ_QueueId *queueId){    Int         status;    Error_Block eb;    Assert_isTrue(name != NULL, ti_sdo_ipc_MessageQ_A_invalidParam);    Assert_isTrue(queueId != NULL, ti_sdo_ipc_MessageQ_A_invalidParam);    Error_init(&eb);        /* Search NameServer */    status = NameServer_getUInt32(            (NameServer_Handle)MessageQ_module->nameServer, name, queueId,             NULL);    if (status >= 0) {        return (MessageQ_S_SUCCESS);    /* name found */    }    else {        return (MessageQ_E_NOTFOUND);   /* name not found */    }}