PDK-4456: misra fixes in fvid2
authorPrasad Konnur <prasadkonnur@ti.com>
Thu, 12 Sep 2019 09:59:58 +0000 (15:29 +0530)
committerPrasad Konnur <prasadkonnur@ti.com>
Thu, 12 Sep 2019 10:23:47 +0000 (15:53 +0530)
Signed-off-by: Prasad Konnur <prasadkonnur@ti.com>
include/fvid2_utils.h
include/trace.h
src/fvid2_drvMgr.c
src/fvid2_graph.c
src/fvid2_utils.c

index 6e6c0857bf5a912dccc26ea34bda00496fddb0b5..0348f0e8586f33c8114f5432e2d1e33dde56eba1 100755 (executable)
@@ -60,44 +60,53 @@ extern "C" {
 #define FVID2UTILS_NUM_TIMESTAMP_LOG    (100U)
 
 /**
- *  struct Fvid2Utils_LinkListType
+ *  \anchor Fvid2Utils_LinkListType
+ *  \name Link List Type
+ *  @{
+ */
+/**
  *  \brief Enums for the type of link list to be created.
  */
-typedef enum
-{
-    FVID2UTILS_LLT_DOUBLE,
-    /**< Double link list. */
-    FVID2UTILS_LLT_CIRCULAR
-    /**< Circular link list using double link list. */
-} Fvid2Utils_LinkListType;
+typedef uint32_t Fvid2Utils_LinkListType;
+#define FVID2UTILS_LLT_DOUBLE           (0U)
+/**< Double link list. */
+#define FVID2UTILS_LLT_CIRCULAR         (1U)
+/**< Circular link list using double link list. */
+/* @} */
 
 /**
- *  struct Fvid2Utils_LinkAddMode
+ *  \anchor Fvid2Utils_LinkAddMode
+ *  \name Link Add Mode
+ *  @{
+ */
+/**
  *  \brief Enums for the different modes of adding a node to a link list.
  */
-typedef enum
-{
-    FVID2UTILS_LAM_TOP,
-    /**< Add nodes to the top of the list. */
-    FVID2UTILS_LAM_BOTTOM,
-    /**< Add nodes to the bottom of the list. */
-    FVID2UTILS_LAM_PRIORITY
-    /**< Add nodes to the list based on ascending order of priority.
-     *   Nodes with the same priority are always added to the bottom of the
-     *   existing nodes with same priority. */
-} Fvid2Utils_LinkAddMode;
-
-/**
- *  struct Fvid2Utils_LinkAddMode
+typedef uint32_t Fvid2Utils_LinkAddMode;
+#define FVID2UTILS_LAM_TOP              (0U)
+/**< Add nodes to the top of the list. */
+#define FVID2UTILS_LAM_BOTTOM           (1U)
+/**< Add nodes to the bottom of the list. */
+#define FVID2UTILS_LAM_PRIORITY         (2U)
+/**< Add nodes to the list based on ascending order of priority.
+ *   Nodes with the same priority are always added to the bottom of the
+ *   existing nodes with same priority. */
+/* @} */
+
+/**
+ *  \anchor Fvid2Utils_NodDir
+ *  \name Node Direction
+ *  @{
+ */
+/**
  *  \brief Enums for the different modes of adding a node to a link list.
  */
-typedef enum
-{
-    FVID2UTILS_NODE_DIR_HEAD,
-    /**< Add nodes to the top of the list. */
-    FVID2UTILS_NODE_DIR_TAIL
-    /**< Add nodes to the bottom of the list. */
-} Fvid2Utils_NodDir;
+typedef uint32_t Fvid2Utils_NodDir;
+#define FVID2UTILS_NODE_DIR_HEAD        (0U)
+/**< Add nodes to the top of the list. */
+#define FVID2UTILS_NODE_DIR_TAIL        (1U)
+/**< Add nodes to the bottom of the list. */
+/* @} */
 
 /* ========================================================================== */
 /*                         Structure Declarations                             */
@@ -207,6 +216,23 @@ typedef Fvid2Utils_Handle Fvid2Utils_QHandle;
 /* ========================================================================== */
 /*                          Function Declarations                             */
 /* ========================================================================== */
+/**
+ *  Fvid2Utils_init
+ *  \brief Initializes the Util objects and create pool semaphore
+ *
+ *  \returns                Returns 0 on success else returns error value
+ */
+int32_t Fvid2Utils_init(void);
+
+/**
+ *  Fvid2Utils_deInit
+ *  \brief De-Initializes the Util objects by removing pool semaphore
+ *
+ *  \param arg              Not used currently. Meant for future purpose
+ *
+ *  \return                 Returns 0 on success else returns error value
+ */
+int32_t Fvid2Utils_deInit(void *arg);
 
 /**
  *  Fvid2Utils_memset
@@ -696,9 +722,9 @@ static inline void Fvid2Utils_initPool(Fvid2Utils_PoolParams *params,
     uint32_t cnt;
 
     /* NULL pointer check */
-    GT_assert(traceMask, (NULL != params));
-    GT_assert(traceMask, (NULL != mem));
-    GT_assert(traceMask, (NULL != flag));
+    GT_assert(traceMask, (NULL_PTR != params));
+    GT_assert(traceMask, (NULL_PTR != mem));
+    GT_assert(traceMask, (NULL_PTR != flag));
 
     /* Init pool parameters */
     params->mem         = mem;
@@ -726,7 +752,7 @@ static inline void *Fvid2Utils_alloc(Fvid2Utils_PoolParams *params,
     void  *allocMem = NULL;
 
     /* NULL pointer check */
-    GT_assert(traceMask, (NULL != params));
+    GT_assert(traceMask, (NULL_PTR != params));
     /* Check if the requested size if within each fixed size element */
     GT_assert(traceMask, (size <= params->elemSize));
     GT_assert(traceMask, (0U != size));
@@ -766,8 +792,8 @@ static inline int32_t Fvid2Utils_free(Fvid2Utils_PoolParams *params,
     uintptr_t cookie;
 
     /* NULL pointer check */
-    GT_assert(traceMask, (NULL != params));
-    GT_assert(traceMask, (NULL != mem));
+    GT_assert(traceMask, (NULL_PTR != params));
+    GT_assert(traceMask, (NULL_PTR != mem));
 
     /* Disable global interrupts */
     cookie = HwiP_disable();
@@ -800,7 +826,7 @@ static inline int32_t Fvid2Utils_free(Fvid2Utils_PoolParams *params,
 static inline void Fvid2Utils_initTsPrfLog(Fvid2Utils_TsPrfLog *tsPrf)
 {
     /* NULL pointer check */
-    GT_assert(GT_DEFAULT_MASK, (NULL != tsPrf));
+    GT_assert(GT_DEFAULT_MASK, (NULL_PTR != tsPrf));
 
     Fvid2Utils_memset(tsPrf, 0, sizeof (Fvid2Utils_TsPrfLog));
     /* Min can't be init to 0, set a higher value so that actual min gets
@@ -813,7 +839,7 @@ static inline void Fvid2Utils_initTsPrfLog(Fvid2Utils_TsPrfLog *tsPrf)
 static inline void Fvid2Utils_startTsPrfLog(Fvid2Utils_TsPrfLog *tsPrf)
 {
     /* NULL pointer check */
-    GT_assert(GT_DEFAULT_MASK, (NULL != tsPrf));
+    GT_assert(GT_DEFAULT_MASK, (NULL_PTR != tsPrf));
 
     tsPrf->startTime = Osal_getTimestamp64();
 
@@ -825,7 +851,7 @@ static inline void Fvid2Utils_endTsPrfLog(Fvid2Utils_TsPrfLog *tsPrf)
     uint64_t endTime, diff;
 
     /* NULL pointer check */
-    GT_assert(GT_DEFAULT_MASK, (NULL != tsPrf));
+    GT_assert(GT_DEFAULT_MASK, (NULL_PTR != tsPrf));
 
     endTime = Osal_getTimestamp64();
     diff    = endTime - tsPrf->startTime;
index 3d2da447729db9d418099d3424d3f0a68b898f69..25cc2403d1bb2e66bdb68205d9786f2c3b1fafaf 100755 (executable)
@@ -75,38 +75,47 @@ extern "C" {
  */
 #define GT_DEFAULT_MASK                 (GT_ERR | GT_TraceState_Enable)
 
+/**
+ *  \anchor GT_TraceState
+ *  \name trace state
+ *  @{
+ */
 /*!
  *  @brief   Enumerates the types of states of trace (enable/disable)
  */
-typedef enum {
-    GT_TraceState_Disable = 0x00000000U,
-    /*!< Disable trace */
-    GT_TraceState_Enable = 0x00000001U,
-    /*!< Enable trace */
-    GT_TraceState_EndValue = 0x00000002U
-                             /*!< End delimiter indicating start of invalid
-                              *values for this enum */
-} GT_TraceState;
+typedef uint32_t GT_TraceState;
+#define    GT_TraceState_Disable    (0x00000000U)
+/*!< Disable trace */
+#define    GT_TraceState_Enable     (0x00000001U)
+/*!< Enable trace */
+#define    GT_TraceState_EndValue   (0x00000002U)
+/*!< End delimiter indicating start of invalid values for this enum */
+/* @} */
 
+/**
+ *  \anchor GT_TraceClass
+ *  \name trace class
+ *  @{
+ */
 /*!
  *  @brief   Enumerates the types of trace classes
  */
-typedef enum {
-    GT_ERR = 0x00010000U,
-    /*!< Class 1 trace: Used for errors/warnings */
-    GT_CRIT = 0x00020000U,
-    /*!< Class 2 trace: Used for critical information */
-    GT_INFO = 0x00030000U,
-    /*!< Class 3 trace: Used for additional information */
-    GT_INFO1 = 0x00040000U,
-    /*!< Class 4 trace: Used for additional information (sub level 1) */
-    GT_DEBUG = 0x00050000U,
-    /*!< Class 5 trace: Used for block level information */
-    GT_ENTER = 0x00060000U,
-    /*!< Indicates a function entry class of trace */
-    GT_LEAVE = 0x00070000U
-               /*!< Indicates a function leave class of trace */
-} GT_TraceClass;
+typedef uint32_t GT_TraceClass;
+#define    GT_ERR                   (0x00010000U)
+/*!< Class 1 trace: Used for errors/warnings */
+#define    GT_CRIT                  (0x00020000U)
+/*!< Class 2 trace: Used for critical information */
+#define    GT_INFO                  (0x00030000U)
+/*!< Class 3 trace: Used for additional information */
+#define    GT_INFO1                 (0x00040000U)
+/*!< Class 4 trace: Used for additional information (sub level 1) */
+#define    GT_DEBUG                 (0x00050000U)
+/*!< Class 5 trace: Used for block level information */
+#define    GT_ENTER                 (0x00060000U)
+/*!< Indicates a function entry class of trace */
+#define    GT_LEAVE                 (0x00070000U)
+/*!< Indicates a function leave class of trace */
+/* @} */
 
 /** \brief Log enable for FVID2 Utils. */
 #define Fvid2Trace                      (GT_DEFAULT_MASK)
index c4851d5b0c36d4883abf3620c0be8bd82a1c8aa7..2238f93cdc651148bbe1ec40156cc849e5cc596a 100755 (executable)
@@ -131,7 +131,7 @@ typedef struct
  */
 typedef struct
 {
-    char               *versionString;
+    const char         *versionString;
     /**< FVID2 drivers version number as string. */
     uint32_t            versionNumber;
     /**< FVID2 drivers version number as string. */
@@ -475,13 +475,13 @@ int32_t Fvid2_init(const Fvid2_InitPrms *initPrms)
 {
     uint32_t cnt;
     int32_t  retVal = FVID2_SOK;
-    int32_t  initValue;
+    uint32_t initValue;
     SemaphoreP_Params params;
 
     Fvid2InitPrms_init(&gFdmInitPrms);
     if (NULL != initPrms)
     {
-        Fvid2Utils_memcpy(&gFdmInitPrms, initPrms, sizeof (gFdmInitPrms));
+        Fvid2Utils_memcpy(&gFdmInitPrms, initPrms, (uint32_t)(sizeof (gFdmInitPrms)));
     }
 
     /* Init all global variables to zero */
@@ -503,7 +503,7 @@ int32_t Fvid2_init(const Fvid2_InitPrms *initPrms)
     /* Allocate lock semaphore */
     SemaphoreP_Params_init(&params);
     params.mode = SemaphoreP_Mode_BINARY;
-    initValue       = 1;
+    initValue       = 1U;
     gFdmObj.lockSem = SemaphoreP_create(initValue, &params);
     if (NULL == gFdmObj.lockSem)
     {
@@ -512,7 +512,7 @@ int32_t Fvid2_init(const Fvid2_InitPrms *initPrms)
     }
     SemaphoreP_Params_init(&params);
     params.mode = SemaphoreP_Mode_BINARY;
-    initValue       = 1;
+    initValue       = 1U;
     gFdmObj.printSem = SemaphoreP_create(initValue, &params);
     if (NULL == gFdmObj.printSem)
     {
@@ -523,7 +523,7 @@ int32_t Fvid2_init(const Fvid2_InitPrms *initPrms)
     /* Free-up memory if error occurs */
     if (FVID2_SOK != retVal)
     {
-        Fvid2_deInit(NULL);
+        (void) Fvid2_deInit(NULL);
     }
 
     return (retVal);
@@ -546,12 +546,12 @@ int32_t Fvid2_deInit(void *args)
     /* Delete the lock semaphore */
     if (NULL != gFdmObj.lockSem)
     {
-        SemaphoreP_delete(gFdmObj.lockSem);
+        (void) SemaphoreP_delete(gFdmObj.lockSem);
         gFdmObj.lockSem = NULL;
     }
     if (NULL != gFdmObj.printSem)
     {
-        SemaphoreP_delete(gFdmObj.printSem);
+        (void) SemaphoreP_delete(gFdmObj.printSem);
         gFdmObj.printSem = NULL;
     }
 
@@ -593,9 +593,9 @@ int32_t Fvid2_registerDriver(const Fvid2_DrvOps *drvOps)
     uint32_t    cnt;
 
     /* Check for NULL pointers */
-    OSAL_Assert(NULL == drvOps);
+    OSAL_Assert(NULL_PTR == drvOps);
 
-    SemaphoreP_pend(gFdmObj.lockSem, SemaphoreP_WAIT_FOREVER);
+    (void) SemaphoreP_pend(gFdmObj.lockSem, SemaphoreP_WAIT_FOREVER);
 
     /* Check whether the driver is already registered */
     for (cnt = 0u; cnt < FVID2_CFG_FDM_NUM_DRV_OBJS; cnt++)
@@ -603,7 +603,7 @@ int32_t Fvid2_registerDriver(const Fvid2_DrvOps *drvOps)
         if (TRUE == gFdmObj.fdmDriverObjects[cnt].isUsed)
         {
             /* Check for NULL pointers */
-            OSAL_Assert(NULL == gFdmObj.fdmDriverObjects[cnt].drvOps);
+            OSAL_Assert(NULL_PTR == gFdmObj.fdmDriverObjects[cnt].drvOps);
 
             if (drvOps->drvId == gFdmObj.fdmDriverObjects[cnt].drvOps->drvId)
             {
@@ -631,7 +631,7 @@ int32_t Fvid2_registerDriver(const Fvid2_DrvOps *drvOps)
         }
     }
 
-    SemaphoreP_post(gFdmObj.lockSem);
+    (void) SemaphoreP_post(gFdmObj.lockSem);
 
     return (retVal);
 }
@@ -645,14 +645,14 @@ int32_t Fvid2_unRegisterDriver(const Fvid2_DrvOps *drvOps)
     int32_t retVal = FVID2_EFAIL;
 
     /* Check for NULL pointers */
-    OSAL_Assert(NULL == drvOps);
+    OSAL_Assert(NULL_PTR == drvOps);
 
-    SemaphoreP_pend(gFdmObj.lockSem, SemaphoreP_WAIT_FOREVER);
+    (void) SemaphoreP_pend(gFdmObj.lockSem, SemaphoreP_WAIT_FOREVER);
 
     /* Free the driver object */
     retVal = fdmFreeDriverObject(drvOps);
 
-    SemaphoreP_post(gFdmObj.lockSem);
+    (void) SemaphoreP_post(gFdmObj.lockSem);
 
     return (retVal);
 }
@@ -673,7 +673,7 @@ Fvid2_Handle Fvid2_create(uint32_t              drvId,
     Fdm_Channel      *channel   = NULL;
     Fvid2_DrvCbParams fdmCbParams, *tempCbParams;
 
-    SemaphoreP_pend(gFdmObj.lockSem, SemaphoreP_WAIT_FOREVER);
+    (void) SemaphoreP_pend(gFdmObj.lockSem, SemaphoreP_WAIT_FOREVER);
 
     /* Get the matching driver object */
     for (cnt = 0u; cnt < FVID2_CFG_FDM_NUM_DRV_OBJS; cnt++)
@@ -681,7 +681,7 @@ Fvid2_Handle Fvid2_create(uint32_t              drvId,
         if (TRUE == gFdmObj.fdmDriverObjects[cnt].isUsed)
         {
             /* Check for NULL pointers */
-            OSAL_Assert(NULL == gFdmObj.fdmDriverObjects[cnt].drvOps);
+            OSAL_Assert(NULL_PTR == gFdmObj.fdmDriverObjects[cnt].drvOps);
 
             if (drvId == gFdmObj.fdmDriverObjects[cnt].drvOps->drvId)
             {
@@ -759,7 +759,7 @@ Fvid2_Handle Fvid2_create(uint32_t              drvId,
             GT_0trace(Fvid2Trace, GT_ERR, "Driver create failed!!\r\n");
 
             /* Free the allocated channel object */
-            fdmFreeChannelObject(channel);
+            (void) fdmFreeChannelObject(channel);
             channel = NULL;
         }
     }
@@ -768,7 +768,7 @@ Fvid2_Handle Fvid2_create(uint32_t              drvId,
         GT_0trace(Fvid2Trace, GT_ERR, "EALLOC: Invalid driver ID!!\r\n");
     }
 
-    SemaphoreP_post(gFdmObj.lockSem);
+    (void) SemaphoreP_post(gFdmObj.lockSem);
 
     return (channel);
 }
@@ -783,15 +783,15 @@ int32_t Fvid2_delete(Fvid2_Handle handle, void *deleteArgs)
     int32_t      retVal = FVID2_SOK;
     Fdm_Channel *channel;
 
-    SemaphoreP_pend(gFdmObj.lockSem, SemaphoreP_WAIT_FOREVER);
+    (void) SemaphoreP_pend(gFdmObj.lockSem, SemaphoreP_WAIT_FOREVER);
 
     if (NULL != handle)
     {
         channel = (Fdm_Channel *) handle;
 
         /* Check for NULL pointers */
-        OSAL_Assert(NULL == channel->drv);
-        OSAL_Assert(NULL == channel->drv->drvOps);
+        OSAL_Assert(NULL_PTR == channel->drv);
+        OSAL_Assert(NULL_PTR == channel->drv->drvOps);
 
         if (NULL != channel->drv->drvOps->deleteFxn)
         {
@@ -813,7 +813,7 @@ int32_t Fvid2_delete(Fvid2_Handle handle, void *deleteArgs)
         channel->cbParams.errCbFxn = NULL;
         channel->cbParams.errList  = NULL;
         channel->cbParams.appData  = NULL;
-        fdmFreeChannelObject(channel);
+        (void) fdmFreeChannelObject(channel);
     }
     else
     {
@@ -821,7 +821,7 @@ int32_t Fvid2_delete(Fvid2_Handle handle, void *deleteArgs)
         retVal = FVID2_EBADARGS;
     }
 
-    SemaphoreP_post(gFdmObj.lockSem);
+    (void) SemaphoreP_post(gFdmObj.lockSem);
 
     return (retVal);
 }
@@ -844,8 +844,8 @@ int32_t Fvid2_control(Fvid2_Handle  handle,
         channel = (Fdm_Channel *) handle;
 
         /* Check for NULL pointers */
-        OSAL_Assert(NULL == channel->drv);
-        OSAL_Assert(NULL == channel->drv->drvOps);
+        OSAL_Assert(NULL_PTR == channel->drv);
+        OSAL_Assert(NULL_PTR == channel->drv->drvOps);
 
         if (NULL != channel->drv->drvOps->controlFxn)
         {
@@ -889,8 +889,8 @@ int32_t Fvid2_queue(Fvid2_Handle     handle,
         channel = (Fdm_Channel *) handle;
 
         /* Check for NULL pointers */
-        OSAL_Assert(NULL == channel->drv);
-        OSAL_Assert(NULL == channel->drv->drvOps);
+        OSAL_Assert(NULL_PTR == channel->drv);
+        OSAL_Assert(NULL_PTR == channel->drv->drvOps);
 
         if (NULL != channel->drv->drvOps->queueFxn)
         {
@@ -934,8 +934,8 @@ int32_t Fvid2_dequeue(Fvid2_Handle      handle,
         channel = (Fdm_Channel *) handle;
 
         /* Check for NULL pointers */
-        OSAL_Assert(NULL == channel->drv);
-        OSAL_Assert(NULL == channel->drv->drvOps);
+        OSAL_Assert(NULL_PTR == channel->drv);
+        OSAL_Assert(NULL_PTR == channel->drv->drvOps);
 
         if (NULL != channel->drv->drvOps->dequeueFxn)
         {
@@ -979,8 +979,8 @@ int32_t Fvid2_processRequest(Fvid2_Handle     handle,
         channel = (Fdm_Channel *) handle;
 
         /* Check for NULL pointers */
-        OSAL_Assert(NULL == channel->drv);
-        OSAL_Assert(NULL == channel->drv->drvOps);
+        OSAL_Assert(NULL_PTR == channel->drv);
+        OSAL_Assert(NULL_PTR == channel->drv->drvOps);
 
         if (NULL != channel->drv->drvOps->processRequestFxn)
         {
@@ -1024,8 +1024,8 @@ int32_t Fvid2_getProcessedRequest(Fvid2_Handle     handle,
         channel = (Fdm_Channel *) handle;
 
         /* Check for NULL pointers */
-        OSAL_Assert(NULL == channel->drv);
-        OSAL_Assert(NULL == channel->drv->drvOps);
+        OSAL_Assert(NULL_PTR == channel->drv);
+        OSAL_Assert(NULL_PTR == channel->drv->drvOps);
 
         if (NULL != channel->drv->drvOps->getProcessedRequestFxn)
         {
@@ -1257,8 +1257,8 @@ void Fvid2_copyFrameList(Fvid2_FrameList *dest, Fvid2_FrameList *src)
     uint32_t frmCnt;
 
     /* Check for NULL pointers */
-    OSAL_Assert(NULL == dest);
-    OSAL_Assert(NULL == src);
+    OSAL_Assert(NULL_PTR == dest);
+    OSAL_Assert(NULL_PTR == src);
     OSAL_Assert(src->numFrames >= FVID2_MAX_FRAME_PTR);
 
     dest->numFrames  = src->numFrames;
@@ -1285,8 +1285,8 @@ void Fvid2_duplicateFrameList(Fvid2_FrameList *dest, const Fvid2_FrameList *src)
     uint32_t frmCnt;
 
     /* Check for NULL pointers */
-    OSAL_Assert(NULL == dest);
-    OSAL_Assert(NULL == src);
+    OSAL_Assert(NULL_PTR == dest);
+    OSAL_Assert(NULL_PTR == src);
     OSAL_Assert(src->numFrames >= FVID2_MAX_FRAME_PTR);
 
     dest->numFrames  = src->numFrames;
@@ -1315,10 +1315,10 @@ static int32_t fdmDriverCbFxn(void *fdmData)
     Fdm_Channel *channel;
 
     /* Check for NULL pointers */
-    OSAL_Assert(NULL == fdmData);
+    OSAL_Assert(NULL_PTR == fdmData);
 
     channel = (Fdm_Channel *) fdmData;
-    OSAL_Assert(NULL == channel->cbParams.cbFxn);
+    OSAL_Assert(NULL_PTR == channel->cbParams.cbFxn);
     retVal = channel->cbParams.cbFxn(channel, channel->cbParams.appData);
 
     return (retVal);
@@ -1338,10 +1338,10 @@ static int32_t fdmDriverErrCbFxn(void *fdmData, void *errList)
     Fdm_Channel *channel;
 
     /* Check for NULL pointers */
-    OSAL_Assert(NULL == fdmData);
+    OSAL_Assert(NULL_PTR == fdmData);
 
     channel = (Fdm_Channel *) fdmData;
-    OSAL_Assert(NULL == channel->cbParams.errCbFxn);
+    OSAL_Assert(NULL_PTR == channel->cbParams.errCbFxn);
     retVal =
         channel->cbParams.errCbFxn(channel, channel->cbParams.appData, errList);
 
@@ -1382,7 +1382,7 @@ static int32_t fdmFreeDriverObject(const Fvid2_DrvOps *drvOps)
     int32_t  retVal = FVID2_EFAIL;
 
     /* Check for NULL pointers */
-    OSAL_Assert(NULL == drvOps);
+    OSAL_Assert(NULL_PTR == drvOps);
 
     /* Free the driver object */
     for (cnt = 0u; cnt < FVID2_CFG_FDM_NUM_DRV_OBJS; cnt++)
@@ -1447,7 +1447,7 @@ static int32_t fdmFreeChannelObject(Fdm_Channel *channel)
     int32_t retVal = FVID2_EALLOC;
 
     /* Check for NULL pointers */
-    OSAL_Assert(NULL == channel);
+    OSAL_Assert(NULL_PTR == channel);
 
     /* Free the channel object */
     if (TRUE == channel->isUsed)
@@ -1470,11 +1470,11 @@ void Fvid2_printf(const char *format, ...)
     va_list     vaArgPtr;
     char       *buf = NULL;
 
-    SemaphoreP_pend(gFdmObj.printSem, SemaphoreP_WAIT_FOREVER);
+    (void) SemaphoreP_pend(gFdmObj.printSem, SemaphoreP_WAIT_FOREVER);
 
     buf = &gRemoteDebug_serverObj.printBuf[0];
-    va_start(vaArgPtr, format);
-    vsnprintf(buf, REMOTE_DEBUG_SERVER_PRINT_BUF_LEN,
+    (void) va_start(vaArgPtr, format);
+    (void) vsnprintf(buf, REMOTE_DEBUG_SERVER_PRINT_BUF_LEN,
               (const char *) format, vaArgPtr);
     va_end(vaArgPtr);
 
@@ -1483,7 +1483,7 @@ void Fvid2_printf(const char *format, ...)
         gFdmInitPrms.printFxn(buf);
     }
 
-    SemaphoreP_post(gFdmObj.printSem);
+    (void) SemaphoreP_post(gFdmObj.printSem);
 #endif
     return;
 }
index c5bb1b560370fc42755ca9ab04ed6920faed8ec3..9756435269fea28326819a819f68c84026e39b8b 100755 (executable)
@@ -77,19 +77,19 @@ Fvid2_GraphInfo *Fvid2_graphInit(const Fvid2_GraphNodeList *inNodeList,
                                  const Fvid2_GraphEdgeList *inEdgeList,
                                  Fvid2_GraphInfo *graphHandle)
 {
-    GT_assert(Fvid2Trace, (graphHandle != NULL));
-    GT_assert(Fvid2Trace, (graphHandle->nodeList != NULL));
-    GT_assert(Fvid2Trace, (graphHandle->edgeList != NULL));
+    GT_assert(Fvid2Trace, (graphHandle != NULL_PTR));
+    GT_assert(Fvid2Trace, (graphHandle->nodeList != NULL_PTR));
+    GT_assert(Fvid2Trace, (graphHandle->edgeList != NULL_PTR));
 
-    GT_assert(Fvid2Trace, (inNodeList != NULL));
-    GT_assert(Fvid2Trace, (inEdgeList != NULL));
+    GT_assert(Fvid2Trace, (inNodeList != NULL_PTR));
+    GT_assert(Fvid2Trace, (inEdgeList != NULL_PTR));
 
     graphHandle->nodeList->numNodes = inNodeList->numNodes;
     graphHandle->edgeList->numEdges = inEdgeList->numEdges;
     graphHandle->nodeList->list = inNodeList->list;
     graphHandle->edgeList->list = inEdgeList->list;
 
-    Fvid2_graphConnect(inNodeList, inEdgeList);
+    (void) Fvid2_graphConnect(inNodeList, inEdgeList);
     return graphHandle;
 }
 
@@ -173,10 +173,10 @@ int32_t Fvid2_graphAllocNodes(const Fvid2_GraphNodeList *nodeList,
     {
         Fvid2_GraphNodeInfo *startNode = Fvid2_graphGetNodeInfo(
             nodeList, inputEdgeList[i].startNode);
-        GT_assert(Fvid2Trace, (startNode != NULL));
+        GT_assert(Fvid2Trace, (startNode != NULL_PTR));
         Fvid2_GraphNodeInfo *endNode = Fvid2_graphGetNodeInfo(
             nodeList, inputEdgeList[i].endNode);
-        GT_assert(Fvid2Trace, (endNode != NULL));
+        GT_assert(Fvid2Trace, (endNode != NULL_PTR));
         if ((startNode->nodeId == FVID2_GRAPH_INVALID_NODE_ID) &&
             (endNode->nodeId == FVID2_GRAPH_INVALID_NODE_ID))
         {
@@ -317,11 +317,11 @@ int32_t Fvid2_graphGetPath(const Fvid2_GraphNodeList *inNodeList,
     GT_assert(Fvid2Trace, (pathNodeCount < maxOutNodeCnt));
     outNodeList->numNodes = pathNodeCount;
 
-    GT_assert(Fvid2Trace, (outNodeList->list != NULL));
+    GT_assert(Fvid2Trace, (outNodeList->list != NULL_PTR));
 
     GT_assert(Fvid2Trace, (pathEdgeCount < maxOutEdgeCnt));
     outEdgeList->numEdges = pathEdgeCount;
-    GT_assert(Fvid2Trace, (outEdgeList->list != NULL));
+    GT_assert(Fvid2Trace, (outEdgeList->list != NULL_PTR));
 
     for (i = 0U; i < pathEdgeCount; i++)
     {
index dca5d91f5aca32ebc8b36478266fe109e3047e2c..a5f47e1d3544f96d87ad8fce372d28ec50484e22 100644 (file)
@@ -130,9 +130,9 @@ int32_t Fvid2Utils_deInit(void *arg)
 void Fvid2Utils_memset(void *mem, uint8_t ch, uint32_t byteCount)
 {
     /* NULL pointer check */
-    GT_assert(Fvid2Trace, (NULL != mem));
+    GT_assert(Fvid2Trace, (NULL_PTR != mem));
 
-    memset(mem, (int32_t) ch, byteCount);
+    (void) memset(mem, (int32_t) ch, byteCount);
 }
 
 /**
@@ -153,7 +153,7 @@ void *Fvid2Utils_memsetw(void *mem, uint32_t word, uint32_t wordCount)
     uint32_t *memPtr = NULL;
 
     /* NULL pointer check */
-    GT_assert(Fvid2Trace, (NULL != mem));
+    GT_assert(Fvid2Trace, (NULL_PTR != mem));
 
     memPtr = (uint32_t *) mem;
     for (count = 0; count < wordCount; count++)
@@ -178,10 +178,10 @@ void *Fvid2Utils_memsetw(void *mem, uint32_t word, uint32_t wordCount)
 void Fvid2Utils_memcpy(void *dest, const void *src, uint32_t byteCount)
 {
     /* NULL pointer check */
-    GT_assert(Fvid2Trace, (NULL != dest));
-    GT_assert(Fvid2Trace, (NULL != src));
+    GT_assert(Fvid2Trace, (NULL_PTR != dest));
+    GT_assert(Fvid2Trace, (NULL_PTR != src));
 
-    memcpy(dest, src, byteCount);
+    (void) memcpy(dest, src, byteCount);
 }
 
 /**
@@ -200,8 +200,8 @@ int32_t Fvid2Utils_memcmp(const void *mem1,
                           uint32_t byteCount)
 {
     /* NULL pointer check */
-    GT_assert(Fvid2Trace, (NULL != mem1));
-    GT_assert(Fvid2Trace, (NULL != mem2));
+    GT_assert(Fvid2Trace, (NULL_PTR != mem1));
+    GT_assert(Fvid2Trace, (NULL_PTR != mem2));
 
     return memcmp(mem1, mem2, byteCount);
 }
@@ -231,7 +231,7 @@ int32_t Fvid2Utils_constructLinkList(Fvid2UtilsLinkListObj  *llobj,
     }
     else
     {
-        GT_assert(Fvid2Trace, (NULL != llobj));
+        GT_assert(Fvid2Trace, (NULL_PTR != llobj));
         /* Initialize the variables */
         llobj->listType    = listType;
         llobj->addMode     = addMode;
@@ -255,9 +255,9 @@ int32_t Fvid2Utils_constructLinkList(Fvid2UtilsLinkListObj  *llobj,
 void Fvid2Utils_destructLinkList(Fvid2UtilsLinkListObj *llobj)
 {
     /* NULL pointer check */
-    GT_assert(Fvid2Trace, (NULL != llobj));
-    GT_assert(Fvid2Trace, (NULL == llobj->headNode));
-    GT_assert(Fvid2Trace, (NULL == llobj->tailNode));
+    GT_assert(Fvid2Trace, (NULL_PTR != llobj));
+    GT_assert(Fvid2Trace, (NULL_PTR == llobj->headNode));
+    GT_assert(Fvid2Trace, (NULL_PTR == llobj->tailNode));
 
     /* Free link list object */
     Fvid2Utils_memset(llobj, 0, sizeof (Fvid2UtilsLinkListObj));
@@ -278,7 +278,7 @@ int32_t Fvid2Utils_unLinkAllNodes(Fvid2Utils_Handle handle)
     Fvid2UtilsLinkListObj *llobj;
 
     /* NULL pointer check */
-    GT_assert(Fvid2Trace, (NULL != handle));
+    GT_assert(Fvid2Trace, (NULL_PTR != handle));
 
     llobj              = (Fvid2UtilsLinkListObj *) handle;
     llobj->headNode    = NULL;
@@ -314,8 +314,8 @@ void Fvid2Utils_linkNodePri(Fvid2Utils_Handle handle,
     Fvid2UtilsLinkListObj *llobj;
 
     /* NULL pointer check */
-    GT_assert(Fvid2Trace, (NULL != handle));
-    GT_assert(Fvid2Trace, (NULL != node));
+    GT_assert(Fvid2Trace, (NULL_PTR != handle));
+    GT_assert(Fvid2Trace, (NULL_PTR != node));
 
     llobj = (Fvid2UtilsLinkListObj *) handle;
 
@@ -329,7 +329,7 @@ void Fvid2Utils_linkNodePri(Fvid2Utils_Handle handle,
     }
     else if (FVID2UTILS_LLT_DOUBLE == llobj->listType)
     {
-        dutilsLinkDoublePri(llobj, node, node->data, priority, (uint32_t) FALSE);
+        (void) dutilsLinkDoublePri(llobj, node, node->data, priority, (uint32_t) FALSE);
     }
     else
     {
@@ -366,8 +366,8 @@ int32_t Fvid2Utils_linkUniqePriNode(Fvid2Utils_Handle handle,
     int32_t rtnValue = FVID2_SOK;
 
     /* NULL pointer check */
-    GT_assert(Fvid2Trace, (NULL != handle));
-    GT_assert(Fvid2Trace, (NULL != node));
+    GT_assert(Fvid2Trace, (NULL_PTR != handle));
+    GT_assert(Fvid2Trace, (NULL_PTR != node));
 
     llobj = (Fvid2UtilsLinkListObj *) handle;
 
@@ -429,8 +429,8 @@ void Fvid2Utils_unLinkNodePri(Fvid2Utils_Handle handle, Fvid2Utils_Node *node)
     Fvid2UtilsLinkListObj *llobj;
 
     /* NULL pointer check */
-    GT_assert(Fvid2Trace, (NULL != handle));
-    GT_assert(Fvid2Trace, (NULL != node));
+    GT_assert(Fvid2Trace, (NULL_PTR != handle));
+    GT_assert(Fvid2Trace, (NULL_PTR != node));
 
     llobj = (Fvid2UtilsLinkListObj *) handle;
     if (FVID2UTILS_LLT_CIRCULAR == llobj->listType)
@@ -462,11 +462,11 @@ void Fvid2Utils_unLinkNode(Fvid2Utils_Handle handle, const Fvid2Utils_Node *node
     Fvid2Utils_NodDir      dir = FVID2UTILS_NODE_DIR_HEAD;
 
     /* NULL pointer check */
-    GT_assert(Fvid2Trace, (NULL != handle));
-    GT_assert(Fvid2Trace, (NULL != node));
+    GT_assert(Fvid2Trace, (NULL_PTR != handle));
+    GT_assert(Fvid2Trace, (NULL_PTR != node));
 
     llobj = (Fvid2UtilsLinkListObj *) handle;
-    dutilsUnLinkDouble(llobj, dir, node);
+    (void) dutilsUnLinkDouble(llobj, dir, node);
 
     return;
 }
@@ -488,11 +488,11 @@ void Fvid2Utils_linkNodeToTail(Fvid2Utils_Handle handle, Fvid2Utils_Node *node)
     Fvid2UtilsLinkListObj *llobj;
 
     /* NULL pointer check */
-    GT_assert(Fvid2Trace, (NULL != node));
-    GT_assert(Fvid2Trace, (NULL != handle));
+    GT_assert(Fvid2Trace, (NULL_PTR != node));
+    GT_assert(Fvid2Trace, (NULL_PTR != handle));
 
     llobj = (Fvid2UtilsLinkListObj *) handle;
-    dutilsLinkDouble(llobj, node, node->data, dir);
+    (void) dutilsLinkDouble(llobj, node, node->data, dir);
 
     return;
 }
@@ -514,11 +514,11 @@ void Fvid2Utils_linkNodeToHead(Fvid2Utils_Handle handle, Fvid2Utils_Node *node)
     Fvid2UtilsLinkListObj *llobj;
 
     /* NULL pointer check */
-    GT_assert(Fvid2Trace, (NULL != node));
-    GT_assert(Fvid2Trace, (NULL != handle));
+    GT_assert(Fvid2Trace, (NULL_PTR != node));
+    GT_assert(Fvid2Trace, (NULL_PTR != handle));
 
     llobj = (Fvid2UtilsLinkListObj *) handle;
-    dutilsLinkDouble(llobj, node, node->data, dir);
+    (void) dutilsLinkDouble(llobj, node, node->data, dir);
 
     return;
 }
@@ -540,7 +540,7 @@ Fvid2Utils_Node *Fvid2Utils_unLinkNodeFromHead(Fvid2Utils_Handle handle)
     Fvid2UtilsLinkListObj *llobj;
 
     /* NULL pointer check */
-    GT_assert(Fvid2Trace, (NULL != handle));
+    GT_assert(Fvid2Trace, (NULL_PTR != handle));
 
     llobj = (Fvid2UtilsLinkListObj *) handle;
     return (dutilsUnLinkDouble(llobj, dir, NULL));
@@ -563,7 +563,7 @@ Fvid2Utils_Node *Fvid2Utils_unLinkNodeFromTail(Fvid2Utils_Handle handle)
     Fvid2UtilsLinkListObj *llobj;
 
     /* NULL pointer check */
-    GT_assert(Fvid2Trace, (NULL != handle));
+    GT_assert(Fvid2Trace, (NULL_PTR != handle));
 
     llobj = (Fvid2UtilsLinkListObj *) handle;
     return (dutilsUnLinkDouble(llobj, dir, NULL));
@@ -585,7 +585,7 @@ Fvid2Utils_Node *Fvid2Utils_getHeadNode(Fvid2Utils_Handle handle)
     Fvid2UtilsLinkListObj *llobj;
 
     /* NULL pointer check */
-    GT_assert(Fvid2Trace, (NULL != handle));
+    GT_assert(Fvid2Trace, (NULL_PTR != handle));
 
     llobj = (Fvid2UtilsLinkListObj *) handle;
 
@@ -608,7 +608,7 @@ Fvid2Utils_Node *Fvid2Utils_getTailNode(Fvid2Utils_Handle handle)
     Fvid2UtilsLinkListObj *llobj;
 
     /* NULL pointer check */
-    GT_assert(Fvid2Trace, (NULL != handle));
+    GT_assert(Fvid2Trace, (NULL_PTR != handle));
 
     llobj = (Fvid2UtilsLinkListObj *) handle;
     return (llobj->tailNode);
@@ -628,7 +628,7 @@ uint32_t Fvid2Utils_isListEmpty(Fvid2Utils_Handle handle)
     Fvid2UtilsLinkListObj *llobj;
 
     /* NULL pointer check */
-    GT_assert(Fvid2Trace, (NULL != handle));
+    GT_assert(Fvid2Trace, (NULL_PTR != handle));
 
     llobj = (Fvid2UtilsLinkListObj *) handle;
     if (NULL == llobj->headNode)
@@ -654,7 +654,7 @@ uint32_t Fvid2Utils_getNumNodes(Fvid2Utils_Handle handle)
     uint32_t numNodes = 0U;
 
     /* NULL pointer check */
-    GT_assert(Fvid2Trace, (NULL != handle));
+    GT_assert(Fvid2Trace, (NULL_PTR != handle));
 
     llobj = (Fvid2UtilsLinkListObj *) handle;
     if (FVID2UTILS_LLT_CIRCULAR == llobj->listType)
@@ -665,7 +665,7 @@ uint32_t Fvid2Utils_getNumNodes(Fvid2Utils_Handle handle)
             numNodes++;
             node = node->next;
             /* Not supposed to have NULL in circular list */
-            GT_assert(Fvid2Trace, (NULL != node));
+            GT_assert(Fvid2Trace, (NULL_PTR != node));
 
             /* Check if we have come to the end of the list */
             if (node == llobj->headNode)
@@ -736,10 +736,10 @@ void Fvid2Utils_queue(Fvid2Utils_QHandle handle,
     Fvid2Utils_NodDir      dir = FVID2UTILS_NODE_DIR_TAIL;
 
     /* NULL pointer check */
-    GT_assert(Fvid2Trace, (NULL != handle));
+    GT_assert(Fvid2Trace, (NULL_PTR != handle));
 
     llobj = (Fvid2UtilsLinkListObj *) handle;
-    dutilsLinkDouble(llobj, qElem, data, dir);
+    (void) dutilsLinkDouble(llobj, qElem, data, dir);
 
     return;
 }
@@ -761,7 +761,7 @@ void *Fvid2Utils_dequeue(Fvid2Utils_QHandle handle)
     Fvid2Utils_NodDir      dir = FVID2UTILS_NODE_DIR_HEAD;
 
     /* NULL pointer check */
-    GT_assert(Fvid2Trace, (NULL != handle));
+    GT_assert(Fvid2Trace, (NULL_PTR != handle));
 
     llobj = (Fvid2UtilsLinkListObj *) handle;
     node  = dutilsUnLinkDouble(llobj, dir, NULL);
@@ -794,7 +794,7 @@ void *Fvid2Utils_peakHead(Fvid2Utils_QHandle handle)
     Fvid2UtilsLinkListObj *llobj;
 
     /* NULL pointer check */
-    GT_assert(Fvid2Trace, (NULL != handle));
+    GT_assert(Fvid2Trace, (NULL_PTR != handle));
 
     llobj = (Fvid2UtilsLinkListObj *) handle;
     if (llobj->headNode != NULL)
@@ -822,7 +822,7 @@ void *Fvid2Utils_peakTail(Fvid2Utils_QHandle handle)
     Fvid2UtilsLinkListObj *llobj;
 
     /* NULL pointer check */
-    GT_assert(Fvid2Trace, (NULL != handle));
+    GT_assert(Fvid2Trace, (NULL_PTR != handle));
 
     llobj = (Fvid2UtilsLinkListObj *) handle;
     if (llobj->tailNode != NULL)
@@ -851,10 +851,10 @@ void Fvid2Utils_queueBack(Fvid2Utils_QHandle handle,
     Fvid2Utils_NodDir      dir = FVID2UTILS_NODE_DIR_HEAD;
 
     /* NULL pointer check */
-    GT_assert(Fvid2Trace, (NULL != handle));
+    GT_assert(Fvid2Trace, (NULL_PTR != handle));
 
     llobj = (Fvid2UtilsLinkListObj *) handle;
-    dutilsLinkDouble(llobj, qElem, data, dir);
+    (void) dutilsLinkDouble(llobj, qElem, data, dir);
 
     return;
 }
@@ -898,7 +898,7 @@ static Fvid2Utils_Node *dutilsLinkCircularPri(Fvid2Utils_Node *headNode,
     Fvid2Utils_Node *curNode;
 
     /* NULL pointer check */
-    GT_assert(Fvid2Trace, (NULL != node));
+    GT_assert(Fvid2Trace, (NULL_PTR != node));
 
     node->data     = data;
     node->priority = priority;
@@ -925,7 +925,7 @@ static Fvid2Utils_Node *dutilsLinkCircularPri(Fvid2Utils_Node *headNode,
             /* Move to next node */
             curNode = curNode->next;
             /* Not supposed to have NULL in circular list */
-            GT_assert(Fvid2Trace, (NULL != curNode));
+            GT_assert(Fvid2Trace, (NULL_PTR != curNode));
         } while (curNode != headNode);
         /* Check if we have come to the end of the list */
 
@@ -935,8 +935,8 @@ static Fvid2Utils_Node *dutilsLinkCircularPri(Fvid2Utils_Node *headNode,
         node->prev = curNode->prev;
 
         /* Not supposed to have NULL in circular list */
-        GT_assert(Fvid2Trace, (NULL != curNode->prev));
-        GT_assert(Fvid2Trace, (NULL != curNode->prev->next));
+        GT_assert(Fvid2Trace, (NULL_PTR != curNode->prev));
+        GT_assert(Fvid2Trace, (NULL_PTR != curNode->prev->next));
         curNode->prev->next = node;
         curNode->prev       = node;
     }
@@ -969,7 +969,7 @@ static int32_t dutilsLinkDoublePri(Fvid2UtilsLinkListObj *llobj,
     Fvid2Utils_Node *curNode, *prevNode = NULL;
 
     /* NULL pointer check */
-    GT_assert(Fvid2Trace, (NULL != node));
+    GT_assert(Fvid2Trace, (NULL_PTR != node));
 
     node->data     = data;
     node->priority = priority;
@@ -1039,12 +1039,12 @@ static Fvid2Utils_Node *dutilsUnLinkCircularPri(Fvid2Utils_Node *headNode,
                                                 Fvid2Utils_Node *node)
 {
     /* NULL pointer check */
-    GT_assert(Fvid2Trace, (NULL != headNode));
-    GT_assert(Fvid2Trace, (NULL != node));
+    GT_assert(Fvid2Trace, (NULL_PTR != headNode));
+    GT_assert(Fvid2Trace, (NULL_PTR != node));
 
     /* Not supposed to have NULL in circular list */
-    GT_assert(Fvid2Trace, (NULL != node->next));
-    GT_assert(Fvid2Trace, (NULL != node->prev));
+    GT_assert(Fvid2Trace, (NULL_PTR != node->next));
+    GT_assert(Fvid2Trace, (NULL_PTR != node->prev));
 
     /* Link the node's previous node to node's next node */
     node->prev->next = node->next;
@@ -1083,8 +1083,8 @@ static void dutilsUnLinkDoublePri(Fvid2UtilsLinkListObj *llobj,
                                   Fvid2Utils_Node       *node)
 {
     /* NULL pointer check */
-    GT_assert(Fvid2Trace, (NULL != llobj));
-    GT_assert(Fvid2Trace, (NULL != node));
+    GT_assert(Fvid2Trace, (NULL_PTR != llobj));
+    GT_assert(Fvid2Trace, (NULL_PTR != node));
 
     if (NULL == node->prev)
     {
@@ -1125,7 +1125,7 @@ static Fvid2Utils_Node *dutilsUnLinkDouble(Fvid2UtilsLinkListObj *llobj,
     uint32_t         nodeCnt;
 
     /* NULL pointer check */
-    GT_assert(Fvid2Trace, (NULL != llobj));
+    GT_assert(Fvid2Trace, (NULL_PTR != llobj));
 
     if (NULL == nodeToBeRem)
     {
@@ -1244,7 +1244,7 @@ static Fvid2Utils_Node *dutilsUnLinkDouble(Fvid2UtilsLinkListObj *llobj,
 uint32_t Fvid2Utils_getNodeCnt(Fvid2Utils_Handle handle)
 {
     /* NULL pointer check */
-    GT_assert(Fvid2Trace, (NULL != handle));
+    GT_assert(Fvid2Trace, (NULL_PTR != handle));
 
     return (((Fvid2UtilsLinkListObj *) handle)->numElements);
 }
@@ -1264,8 +1264,8 @@ static Fvid2Utils_Node *dutilsLinkDouble(Fvid2UtilsLinkListObj *llobj,
     Fvid2Utils_Node *headNode, *tailNode = NULL;
 
     /* NULL pointer check */
-    GT_assert(Fvid2Trace, (NULL != node));
-    GT_assert(Fvid2Trace, (NULL != llobj));
+    GT_assert(Fvid2Trace, (NULL_PTR != node));
+    GT_assert(Fvid2Trace, (NULL_PTR != llobj));
 
     node->data = data;
     /* check for the first element in the list */