More MISRA.

git-svn-id: svn://svn.code.sf.net/p/chibios/svn/trunk@7718 35acf78f-673a-0410-8e92-d51de3d6d3f4

13 files changed, 150 insertions, 95 deletions

diff --git a/os/rt/include/chmtx.h b/os/rt/include/chmtx.h
index 4a4b643ff..caa0c8266 100644
--- a/os/rt/include/chmtx.h
+++ b/os/rt/include/chmtx.h
@@ -49,12 +49,12 @@
 /**

  * @brief   Type of a mutex structure.

  */

-typedef struct mutex mutex_t;

+typedef struct ch_mutex mutex_t;

 

 /**

  * @brief   Mutex structure.

  */

-struct mutex {

+struct ch_mutex {

   threads_queue_t       m_queue;    /**< @brief Queue of the threads sleeping

                                                 on this mutex.              */

   thread_t              *m_owner;   /**< @brief Owner @p thread_t pointer or

diff --git a/os/rt/include/chschd.h b/os/rt/include/chschd.h
index c166bc034..f57972a88 100644
--- a/os/rt/include/chschd.h
+++ b/os/rt/include/chschd.h
@@ -265,6 +265,31 @@ struct ch_thread {
      *        states.

      */

     void                *wtobjp;

+    /**

+     * @brief Pointer to a generic thread reference object.

+     * @note  This field is used to get a pointer to a synchronization

+     *        object and is valid when the thread is in @p CH_STATE_SUSPENDED

+     *        state.

+     */

+    thread_reference_t  *wttrp;

+#if (CH_CFG_USE_SEMAPHORES == TRUE) || defined(__DOXYGEN__)

+    /**

+     * @brief Pointer to a generic semaphore object.

+     * @note  This field is used to get a pointer to a synchronization

+     *        object and is valid when the thread is in @p CH_STATE_WTSEM

+     *        state.

+     */

+    struct ch_semaphore *wtsemp;

+#endif

+#if (CH_CFG_USE_MUTEXES == TRUE) || defined(__DOXYGEN__)

+    /**

+     * @brief Pointer to a generic mutex object.

+     * @note  This field is used to get a pointer to a synchronization

+     *        object and is valid when the thread is in @p CH_STATE_WTMTX

+     *        state.

+     */

+    struct ch_mutex     *wtmtxp;

+#endif

 #if (CH_CFG_USE_EVENTS == TRUE) || defined(__DOXYGEN__)

     /**

      * @brief Enabled events mask.

@@ -301,7 +326,7 @@ struct ch_thread {
    * @brief List of the mutexes owned by this thread.

    * @note  The list is terminated by a @p NULL in this field.

    */

-  struct mutex          *p_mtxlist;

+  struct ch_mutex       *p_mtxlist;

   /**

    * @brief Thread's own, non-inherited, priority.

    */

diff --git a/os/rt/include/chsem.h b/os/rt/include/chsem.h
index 51a29e0f2..efc1cea0b 100644
--- a/os/rt/include/chsem.h
+++ b/os/rt/include/chsem.h
@@ -49,7 +49,7 @@
 /**

  * @brief   Semaphore structure.

  */

-typedef struct semaphore {

+typedef struct ch_semaphore {

   threads_queue_t       s_queue;    /**< @brief Queue of the threads sleeping

                                                 on this semaphore.          */

   cnt_t                 s_cnt;      /**< @brief The semaphore counter.      */

diff --git a/os/rt/include/chsystypes.h b/os/rt/include/chsystypes.h
index cf101e0db..9a01a93c4 100644
--- a/os/rt/include/chsystypes.h
+++ b/os/rt/include/chsystypes.h
@@ -63,6 +63,11 @@ typedef uint16_t systime_t;
 typedef struct ch_thread thread_t;

 

 /**

+ * @brief   Type of a thread reference.

+ */

+typedef thread_t * thread_reference_t;

+

+/**

  * @brief   Type of a generic threads single link list, it works like a stack.

  */

 typedef struct ch_threads_list threads_list_t;

diff --git a/os/rt/include/chthreads.h b/os/rt/include/chthreads.h
index 44b9e2032..6632d8d62 100644
--- a/os/rt/include/chthreads.h
+++ b/os/rt/include/chthreads.h
@@ -45,11 +45,6 @@
 /*===========================================================================*/

 

 /**

- * @brief   Type of a thread reference.

- */

-typedef thread_t * thread_reference_t;

-

-/**

  * @brief   Thread function.

  */

 typedef msg_t (*tfunc_t)(void *p);

diff --git a/os/rt/src/chcond.c b/os/rt/src/chcond.c
index b6d6219da..20b0cd47e 100644
--- a/os/rt/src/chcond.c
+++ b/os/rt/src/chcond.c
@@ -154,7 +154,7 @@ void chCondBroadcastI(condition_variable_t *cp) {
   /* Empties the condition variable queue and inserts all the threads into the

      ready list in FIFO order. The wakeup message is set to @p MSG_RESET in

      order to make a chCondBroadcast() detectable from a chCondSignal().*/

-  while (cp->c_queue.p_next != (void *)&cp->c_queue) {

+  while (queue_notempty(&cp->c_queue)) {

     chSchReadyI(queue_fifo_remove(&cp->c_queue))->p_u.rdymsg = MSG_RESET;

   }

 }

diff --git a/os/rt/src/chevents.c b/os/rt/src/chevents.c
index 61b93086c..e768457f5 100644
--- a/os/rt/src/chevents.c
+++ b/os/rt/src/chevents.c
@@ -182,7 +182,8 @@ eventmask_t chEvtGetAndClearEvents(eventmask_t events) {
 eventmask_t chEvtAddEvents(eventmask_t events) {

 

   chSysLock();

-  events = (currp->p_epending |= events);

+  currp->p_epending |= events;

+  events = currp->p_epending;

   chSysUnlock();

 

   return events;

@@ -218,7 +219,7 @@ void chEvtBroadcastFlagsI(event_source_t *esp, eventflags_t flags) {
     elp->el_flags |= flags;

     /* When flags == 0 the thread will always be signaled because the

        source does not emit any flag.*/

-    if ((flags == 0) || ((elp->el_flags & elp->el_wflags) != 0)) {

+    if ((flags == 0U) || ((elp->el_flags & elp->el_wflags) != 0U)) {

       chEvtSignalI(elp->el_listener, elp->el_events);

     }

     elp = elp->el_next;

@@ -285,7 +286,7 @@ void chEvtSignalI(thread_t *tp, eventmask_t events) {
   tp->p_epending |= events;

   /* Test on the AND/OR conditions wait states.*/

   if (((tp->p_state == CH_STATE_WTOREVT) &&

-       ((tp->p_epending & tp->p_u.ewmask) != 0)) ||

+       ((tp->p_epending & tp->p_u.ewmask) != 0U)) ||

       ((tp->p_state == CH_STATE_WTANDEVT) &&

        ((tp->p_epending & tp->p_u.ewmask) == tp->p_u.ewmask))) {

     tp->p_u.rdymsg = MSG_OK;

@@ -349,8 +350,8 @@ void chEvtDispatch(const evhandler_t *handlers, eventmask_t events) {
   chDbgCheck(handlers != NULL);

 

   eid = 0;

-  while (events) {

-    if (events & EVENT_MASK(eid)) {

+  while (events != 0U) {

+    if ((events & EVENT_MASK(eid)) != 0U) {

       chDbgAssert(handlers[eid] != NULL, "null handler");

       events &= ~EVENT_MASK(eid);

       handlers[eid](eid);

@@ -383,12 +384,13 @@ eventmask_t chEvtWaitOne(eventmask_t events) {
   eventmask_t m;

 

   chSysLock();

-  if ((m = (ctp->p_epending & events)) == 0) {

+  m = ctp->p_epending & events;

+  if (m == 0U) {

     ctp->p_u.ewmask = events;

     chSchGoSleepS(CH_STATE_WTOREVT);

     m = ctp->p_epending & events;

   }

-  m ^= m & (m - 1);

+  m ^= m & (m - 1U);

   ctp->p_epending &= ~m;

   chSysUnlock();

 

@@ -412,7 +414,8 @@ eventmask_t chEvtWaitAny(eventmask_t events) {
   eventmask_t m;

 

   chSysLock();

-  if ((m = (ctp->p_epending & events)) == 0) {

+  m = ctp->p_epending & events;

+  if (m == 0U) {

     ctp->p_u.ewmask = events;

     chSchGoSleepS(CH_STATE_WTOREVT);

     m = ctp->p_epending & events;

@@ -477,7 +480,8 @@ eventmask_t chEvtWaitOneTimeout(eventmask_t events, systime_t time) {
   eventmask_t m;

 

   chSysLock();

-  if ((m = (ctp->p_epending & events)) == 0) {

+  m = ctp->p_epending & events;

+  if (m == 0U) {

     if (TIME_IMMEDIATE == time) {

       chSysUnlock();

       return (eventmask_t)0;

@@ -489,7 +493,7 @@ eventmask_t chEvtWaitOneTimeout(eventmask_t events, systime_t time) {
     }

     m = ctp->p_epending & events;

   }

-  m ^= m & (m - 1);

+  m ^= m & (m - 1U);

   ctp->p_epending &= ~m;

   chSysUnlock();

 

@@ -519,7 +523,8 @@ eventmask_t chEvtWaitAnyTimeout(eventmask_t events, systime_t time) {
   eventmask_t m;

 

   chSysLock();

-  if ((m = (ctp->p_epending & events)) == 0) {

+  m = ctp->p_epending & events;

+  if (m == 0U) {

     if (TIME_IMMEDIATE == time) {

       chSysUnlock();

       return (eventmask_t)0;

diff --git a/os/rt/src/chmboxes.c b/os/rt/src/chmboxes.c
index 5b8bc3f64..9c0c3ae0d 100644
--- a/os/rt/src/chmboxes.c
+++ b/os/rt/src/chmboxes.c
@@ -87,7 +87,9 @@ void chMBObjectInit(mailbox_t *mbp, msg_t *buf, cnt_t n) {
 

   chDbgCheck((mbp != NULL) && (buf != NULL) && (n > 0));

 

-  mbp->mb_buffer = mbp->mb_wrptr = mbp->mb_rdptr = buf;

+  mbp->mb_buffer = buf;

+  mbp->mb_rdptr = buf;

+  mbp->mb_wrptr = buf;

   mbp->mb_top = &buf[n];

   chSemObjectInit(&mbp->mb_emptysem, n);

   chSemObjectInit(&mbp->mb_fullsem, 0);

@@ -140,7 +142,7 @@ void chMBResetI(mailbox_t *mbp) {
  *

  * @param[in] mbp       the pointer to an initialized @p mailbox_t object

  * @param[in] msg       the message to be posted on the mailbox

- * @param[in] time      the number of ticks before the operation timeouts,

+ * @param[in] timeout   the number of ticks before the operation timeouts,

  *                      the following special values are allowed:

  *                      - @a TIME_IMMEDIATE immediate timeout.

  *                      - @a TIME_INFINITE no timeout.

@@ -152,11 +154,11 @@ void chMBResetI(mailbox_t *mbp) {
  *

  * @api

  */

-msg_t chMBPost(mailbox_t *mbp, msg_t msg, systime_t time) {

+msg_t chMBPost(mailbox_t *mbp, msg_t msg, systime_t timeout) {

   msg_t rdymsg;

 

   chSysLock();

-  rdymsg = chMBPostS(mbp, msg, time);

+  rdymsg = chMBPostS(mbp, msg, timeout);

   chSysUnlock();

 

   return rdymsg;

@@ -169,7 +171,7 @@ msg_t chMBPost(mailbox_t *mbp, msg_t msg, systime_t time) {
  *

  * @param[in] mbp       the pointer to an initialized @p mailbox_t object

  * @param[in] msg       the message to be posted on the mailbox

- * @param[in] time      the number of ticks before the operation timeouts,

+ * @param[in] timeout   the number of ticks before the operation timeouts,

  *                      the following special values are allowed:

  *                      - @a TIME_IMMEDIATE immediate timeout.

  *                      - @a TIME_INFINITE no timeout.

@@ -181,16 +183,17 @@ msg_t chMBPost(mailbox_t *mbp, msg_t msg, systime_t time) {
  *

  * @sclass

  */

-msg_t chMBPostS(mailbox_t *mbp, msg_t msg, systime_t time) {

+msg_t chMBPostS(mailbox_t *mbp, msg_t msg, systime_t timeout) {

   msg_t rdymsg;

 

   chDbgCheckClassS();

   chDbgCheck(mbp != NULL);

 

-  rdymsg = chSemWaitTimeoutS(&mbp->mb_emptysem, time);

+  rdymsg = chSemWaitTimeoutS(&mbp->mb_emptysem, timeout);

   if (rdymsg == MSG_OK) {

-    *mbp->mb_wrptr++ = msg;

-    /*lint -save -e946 [18.2] Normal pointers arithmetic, it is safe.*/

+    *mbp->mb_wrptr = msg;

+    mbp->mb_wrptr++;

+    /*lint -save -e946 [18.2, 18.3] Normal pointers arithmetic, it is safe.*/

     if (mbp->mb_wrptr >= mbp->mb_top) {

     /*lint -restore*/

       mbp->mb_wrptr = mbp->mb_buffer;

@@ -226,8 +229,9 @@ msg_t chMBPostI(mailbox_t *mbp, msg_t msg) {
   }

 

   chSemFastWaitI(&mbp->mb_emptysem);

-  *mbp->mb_wrptr++ = msg;

-  /*lint -save -e946 [18.2] Normal pointers arithmetic, it is safe.*/

+  *mbp->mb_wrptr = msg;

+  mbp->mb_wrptr++;

+  /*lint -save -e946 [18.2, 18.3] Normal pointers arithmetic, it is safe.*/

   if (mbp->mb_wrptr >= mbp->mb_top) {

   /*lint -restore*/

     mbp->mb_wrptr = mbp->mb_buffer;

@@ -244,7 +248,7 @@ msg_t chMBPostI(mailbox_t *mbp, msg_t msg) {
  *

  * @param[in] mbp       the pointer to an initialized @p mailbox_t object

  * @param[in] msg       the message to be posted on the mailbox

- * @param[in] time      the number of ticks before the operation timeouts,

+ * @param[in] timeout   the number of ticks before the operation timeouts,

  *                      the following special values are allowed:

  *                      - @a TIME_IMMEDIATE immediate timeout.

  *                      - @a TIME_INFINITE no timeout.

@@ -256,11 +260,11 @@ msg_t chMBPostI(mailbox_t *mbp, msg_t msg) {
  *

  * @api

  */

-msg_t chMBPostAhead(mailbox_t *mbp, msg_t msg, systime_t time) {

+msg_t chMBPostAhead(mailbox_t *mbp, msg_t msg, systime_t timeout) {

   msg_t rdymsg;

 

   chSysLock();

-  rdymsg = chMBPostAheadS(mbp, msg, time);

+  rdymsg = chMBPostAheadS(mbp, msg, timeout);

   chSysUnlock();

 

   return rdymsg;

@@ -273,7 +277,7 @@ msg_t chMBPostAhead(mailbox_t *mbp, msg_t msg, systime_t time) {
  *

  * @param[in] mbp       the pointer to an initialized @p mailbox_t object

  * @param[in] msg       the message to be posted on the mailbox

- * @param[in] time      the number of ticks before the operation timeouts,

+ * @param[in] timeout   the number of ticks before the operation timeouts,

  *                      the following special values are allowed:

  *                      - @a TIME_IMMEDIATE immediate timeout.

  *                      - @a TIME_INFINITE no timeout.

@@ -285,15 +289,15 @@ msg_t chMBPostAhead(mailbox_t *mbp, msg_t msg, systime_t time) {
  *

  * @sclass

  */

-msg_t chMBPostAheadS(mailbox_t *mbp, msg_t msg, systime_t time) {

+msg_t chMBPostAheadS(mailbox_t *mbp, msg_t msg, systime_t timeout) {

   msg_t rdymsg;

 

   chDbgCheckClassS();

   chDbgCheck(mbp != NULL);

 

-  rdymsg = chSemWaitTimeoutS(&mbp->mb_emptysem, time);

+  rdymsg = chSemWaitTimeoutS(&mbp->mb_emptysem, timeout);

   if (rdymsg == MSG_OK) {

-    /*lint -save -e946 [18.2] Normal pointers arithmetic, it is safe.*/

+    /*lint -save -e946 [18.2, 18.3] Normal pointers arithmetic, it is safe.*/

     if (--mbp->mb_rdptr < mbp->mb_buffer) {

     /*lint -restore*/

       mbp->mb_rdptr = mbp->mb_top - 1;

@@ -329,7 +333,7 @@ msg_t chMBPostAheadI(mailbox_t *mbp, msg_t msg) {
     return MSG_TIMEOUT;

   }

   chSemFastWaitI(&mbp->mb_emptysem);

-  /*lint -save -e946 [18.2] Normal pointers arithmetic, it is safe.*/

+  /*lint -save -e946 [18.2, 18.3] Normal pointers arithmetic, it is safe.*/

   if (--mbp->mb_rdptr < mbp->mb_buffer) {

   /*lint -restore*/

     mbp->mb_rdptr = mbp->mb_top - 1;

@@ -347,7 +351,7 @@ msg_t chMBPostAheadI(mailbox_t *mbp, msg_t msg) {
  *

  * @param[in] mbp       the pointer to an initialized @p mailbox_t object

  * @param[out] msgp     pointer to a message variable for the received message

- * @param[in] time      the number of ticks before the operation timeouts,

+ * @param[in] timeout   the number of ticks before the operation timeouts,

  *                      the following special values are allowed:

  *                      - @a TIME_IMMEDIATE immediate timeout.

  *                      - @a TIME_INFINITE no timeout.

@@ -359,11 +363,11 @@ msg_t chMBPostAheadI(mailbox_t *mbp, msg_t msg) {
  *

  * @api

  */

-msg_t chMBFetch(mailbox_t *mbp, msg_t *msgp, systime_t time) {

+msg_t chMBFetch(mailbox_t *mbp, msg_t *msgp, systime_t timeout) {

   msg_t rdymsg;

 

   chSysLock();

-  rdymsg = chMBFetchS(mbp, msgp, time);

+  rdymsg = chMBFetchS(mbp, msgp, timeout);

   chSysUnlock();

 

   return rdymsg;

@@ -376,7 +380,7 @@ msg_t chMBFetch(mailbox_t *mbp, msg_t *msgp, systime_t time) {
  *

  * @param[in] mbp       the pointer to an initialized @p mailbox_t object

  * @param[out] msgp     pointer to a message variable for the received message

- * @param[in] time      the number of ticks before the operation timeouts,

+ * @param[in] timeout   the number of ticks before the operation timeouts,

  *                      the following special values are allowed:

  *                      - @a TIME_IMMEDIATE immediate timeout.

  *                      - @a TIME_INFINITE no timeout.

@@ -388,16 +392,17 @@ msg_t chMBFetch(mailbox_t *mbp, msg_t *msgp, systime_t time) {
  *

  * @sclass

  */

-msg_t chMBFetchS(mailbox_t *mbp, msg_t *msgp, systime_t time) {

+msg_t chMBFetchS(mailbox_t *mbp, msg_t *msgp, systime_t timeout) {

   msg_t rdymsg;

 

   chDbgCheckClassS();

   chDbgCheck((mbp != NULL) && (msgp != NULL));

 

-  rdymsg = chSemWaitTimeoutS(&mbp->mb_fullsem, time);

+  rdymsg = chSemWaitTimeoutS(&mbp->mb_fullsem, timeout);

   if (rdymsg == MSG_OK) {

-    *msgp = *mbp->mb_rdptr++;

-    /*lint -save -e946 [18.2] Normal pointers arithmetic, it is safe.*/

+    *msgp = *mbp->mb_rdptr;

+    mbp->mb_rdptr++;

+    /*lint -save -e946 [18.2, 18.3] Normal pointers arithmetic, it is safe.*/

     if (mbp->mb_rdptr >= mbp->mb_top) {

     /*lint -restore*/

       mbp->mb_rdptr = mbp->mb_buffer;

@@ -432,8 +437,9 @@ msg_t chMBFetchI(mailbox_t *mbp, msg_t *msgp) {
     return MSG_TIMEOUT;

   }

   chSemFastWaitI(&mbp->mb_fullsem);

-  *msgp = *mbp->mb_rdptr++;

-  /*lint -save -e946 [18.2] Normal pointers arithmetic, it is safe.*/

+  *msgp = *mbp->mb_rdptr;

+  mbp->mb_rdptr++;

+  /*lint -save -e946 [18.2, 18.3] Normal pointers arithmetic, it is safe.*/

   if (mbp->mb_rdptr >= mbp->mb_top) {

   /*lint -restore*/

     mbp->mb_rdptr = mbp->mb_buffer;

diff --git a/os/rt/src/chmtx.c b/os/rt/src/chmtx.c
index 13ae7e6fc..3243f6eee 100644
--- a/os/rt/src/chmtx.c
+++ b/os/rt/src/chmtx.c
@@ -170,14 +170,15 @@ void chMtxLockS(mutex_t *mp) {
         switch (tp->p_state) {

         case CH_STATE_WTMTX:

           /* Re-enqueues the mutex owner with its new priority.*/

-          queue_prio_insert(queue_dequeue(tp),

-                            (threads_queue_t *)tp->p_u.wtobjp);

-          tp = ((mutex_t *)tp->p_u.wtobjp)->m_owner;

+          queue_prio_insert(queue_dequeue(tp), &tp->p_u.wtmtxp->m_queue);

+          tp = tp->p_u.wtmtxp->m_owner;

+          /*lint -e{9042} [16.1] Continues the while.*/

           continue;

-#if (CH_CFG_USE_CONDVARS == TRUE) |                                         \

+#if (CH_CFG_USE_CONDVARS == TRUE) ||                                        \

     ((CH_CFG_USE_SEMAPHORES == TRUE) &&                                     \

-     (CH_CFG_USE_SEMAPHORES_PRIORITY) == TRUE) |                            \

-    ((CH_CFG_USE_MESSAGES == TRUE) && (CH_CFG_USE_MESSAGES_PRIORITY == TRUE))

+     (CH_CFG_USE_SEMAPHORES_PRIORITY == TRUE)) ||                           \

+    ((CH_CFG_USE_MESSAGES == TRUE) &&                                       \

+     (CH_CFG_USE_MESSAGES_PRIORITY == TRUE))

 #if CH_CFG_USE_CONDVARS == TRUE

         case CH_STATE_WTCOND:

 #endif

@@ -189,8 +190,7 @@ void chMtxLockS(mutex_t *mp) {
         case CH_STATE_SNDMSGQ:

 #endif

           /* Re-enqueues tp with its new priority on the queue.*/

-          queue_prio_insert(queue_dequeue(tp),

-                            (threads_queue_t *)tp->p_u.wtobjp);

+          queue_prio_insert(queue_dequeue(tp), &tp->p_u.wtmtxp->m_queue);

           break;

 #endif

         case CH_STATE_READY:

@@ -210,7 +210,7 @@ void chMtxLockS(mutex_t *mp) {
 

       /* Sleep on the mutex.*/

       queue_prio_insert(ctp, &mp->m_queue);

-      ctp->p_u.wtobjp = mp;

+      ctp->p_u.wtmtxp = mp;

       chSchGoSleepS(CH_STATE_WTMTX);

 

       /* It is assumed that the thread performing the unlock operation assigns

diff --git a/os/rt/src/chqueues.c b/os/rt/src/chqueues.c
index f02eb14a0..fbe05e129 100644
--- a/os/rt/src/chqueues.c
+++ b/os/rt/src/chqueues.c
@@ -89,10 +89,14 @@ void chIQObjectInit(input_queue_t *iqp, uint8_t *bp, size_t size,
 

   chThdQueueObjectInit(&iqp->q_waiting);

   iqp->q_counter = 0;

-  iqp->q_buffer = iqp->q_rdptr = iqp->q_wrptr = bp;

-  iqp->q_top = bp + size;

-  iqp->q_notify = infy;

-  iqp->q_link = link;

+  iqp->q_buffer  = bp;

+  iqp->q_rdptr   = bp;

+  iqp->q_wrptr   = bp;

+  /*lint -save -e9016 [18.4] Normal pointers arithmetic.*/

+  iqp->q_top     = bp + size;

+  /*lint -restore*/

+  iqp->q_notify  = infy;

+  iqp->q_link    = link;

 }

 

 /**

@@ -110,7 +114,8 @@ void chIQResetI(input_queue_t *iqp) {
 

   chDbgCheckClassI();

 

-  iqp->q_rdptr = iqp->q_wrptr = iqp->q_buffer;

+  iqp->q_rdptr = iqp->q_buffer;

+  iqp->q_wrptr = iqp->q_buffer;

   iqp->q_counter = 0;

   chThdDequeueAllI(&iqp->q_waiting, Q_RESET);

 }

@@ -136,8 +141,9 @@ msg_t chIQPutI(input_queue_t *iqp, uint8_t b) {
     return Q_FULL;

   }

 

+  *iqp->q_wrptr = b;

+  iqp->q_wrptr++;

   iqp->q_counter++;

-  *iqp->q_wrptr++ = b;

   /*lint -save -e946 [18.2] Normal pointers arithmetic, it is safe.*/

   if (iqp->q_wrptr >= iqp->q_top) {

   /*lint -restore*/

@@ -173,20 +179,21 @@ msg_t chIQGetTimeout(input_queue_t *iqp, systime_t time) {
   uint8_t b;

 

   chSysLock();

-  if (iqp->q_notify) {

+  if (iqp->q_notify != NULL) {

     iqp->q_notify(iqp);

   }

 

   while (chIQIsEmptyI(iqp)) {

-    msg_t msg;

-    if ((msg = chThdEnqueueTimeoutS(&iqp->q_waiting, time)) < Q_OK) {

+    msg_t msg = chThdEnqueueTimeoutS(&iqp->q_waiting, time);

+    if (msg < Q_OK) {

       chSysUnlock();

       return msg;

     }

   }

 

+  b = *iqp->q_rdptr;

+  iqp->q_rdptr++;

   iqp->q_counter--;

-  b = *iqp->q_rdptr++;

   /*lint -save -e946 [18.2] Normal pointers arithmetic, it is safe.*/

   if (iqp->q_rdptr >= iqp->q_top) {

   /*lint -restore*/

@@ -194,7 +201,7 @@ msg_t chIQGetTimeout(input_queue_t *iqp, systime_t time) {
   }

   chSysUnlock();

 

-  return b;

+  return (msg_t)b;

 }

 

 /**

@@ -230,7 +237,7 @@ size_t chIQReadTimeout(input_queue_t *iqp, uint8_t *bp,
 

   chSysLock();

   while (true) {

-    if (nfy) {

+    if (nfy != NULL) {

       nfy(iqp);

     }

 

@@ -241,8 +248,10 @@ size_t chIQReadTimeout(input_queue_t *iqp, uint8_t *bp,
       }

     }

 

+    *bp = *iqp->q_rdptr;

+    bp++;

+    iqp->q_rdptr++;

     iqp->q_counter--;

-    *bp++ = *iqp->q_rdptr++;

     /*lint -save -e946 [18.2] Normal pointers arithmetic, it is safe.*/

     if (iqp->q_rdptr >= iqp->q_top) {

     /*lint -restore*/

@@ -251,7 +260,8 @@ size_t chIQReadTimeout(input_queue_t *iqp, uint8_t *bp,
 

     chSysUnlock(); /* Gives a preemption chance in a controlled point.*/

     r++;

-    if (--n == 0) {

+    n--;

+    if (n == 0U) {

       return r;

     }

 

@@ -280,10 +290,14 @@ void chOQObjectInit(output_queue_t *oqp, uint8_t *bp, size_t size,
 

   chThdQueueObjectInit(&oqp->q_waiting);

   oqp->q_counter = size;

-  oqp->q_buffer = oqp->q_rdptr = oqp->q_wrptr = bp;

-  oqp->q_top = bp + size;

-  oqp->q_notify = onfy;

-  oqp->q_link = link;

+  oqp->q_buffer  = bp;

+  oqp->q_rdptr   = bp;

+  oqp->q_wrptr   = bp;

+  /*lint -save -e9016 [18.4] Normal pointers arithmetic.*/

+  oqp->q_top     = bp + size;

+  /*lint -restore*/

+  oqp->q_notify  = onfy;

+  oqp->q_link    = link;

 }

 

 /**

@@ -301,7 +315,8 @@ void chOQResetI(output_queue_t *oqp) {
 

   chDbgCheckClassI();

 

-  oqp->q_rdptr = oqp->q_wrptr = oqp->q_buffer;

+  oqp->q_rdptr = oqp->q_buffer;

+  oqp->q_wrptr = oqp->q_buffer;

   oqp->q_counter = chQSizeX(oqp);

   chThdDequeueAllI(&oqp->q_waiting, Q_RESET);

 }

@@ -332,23 +347,23 @@ msg_t chOQPutTimeout(output_queue_t *oqp, uint8_t b, systime_t time) {
 

   chSysLock();

   while (chOQIsFullI(oqp)) {

-    msg_t msg;

-

-    if ((msg = chThdEnqueueTimeoutS(&oqp->q_waiting, time)) < Q_OK) {

+    msg_t msg = chThdEnqueueTimeoutS(&oqp->q_waiting, time);

+    if (msg < Q_OK) {

       chSysUnlock();

       return msg;

     }

   }

 

+  *oqp->q_wrptr = b;

+  oqp->q_wrptr++;

   oqp->q_counter--;

-  *oqp->q_wrptr++ = b;

   /*lint -save -e946 [18.2] Normal pointers arithmetic, it is safe.*/

   if (oqp->q_wrptr >= oqp->q_top) {

   /*lint -restore*/

     oqp->q_wrptr = oqp->q_buffer;

   }

 

-  if (oqp->q_notify) {

+  if (oqp->q_notify != NULL) {

     oqp->q_notify(oqp);

   }

   chSysUnlock();

@@ -375,8 +390,9 @@ msg_t chOQGetI(output_queue_t *oqp) {
     return Q_EMPTY;

   }

 

+  b = *oqp->q_rdptr;

+  oqp->q_rdptr++;

   oqp->q_counter++;

-  b = *oqp->q_rdptr++;

   /*lint -save -e946 [18.2] Normal pointers arithmetic, it is safe.*/

   if (oqp->q_rdptr >= oqp->q_top) {

   /*lint -restore*/

@@ -385,7 +401,7 @@ msg_t chOQGetI(output_queue_t *oqp) {
 

   chThdDequeueNextI(&oqp->q_waiting, Q_OK);

 

-  return b;

+  return (msg_t)b;

 }

 

 /**

@@ -427,21 +443,24 @@ size_t chOQWriteTimeout(output_queue_t *oqp, const uint8_t *bp,
         return w;

       }

     }

+    *oqp->q_wrptr = *bp;

+    bp++;

+    oqp->q_wrptr++;

     oqp->q_counter--;

-    *oqp->q_wrptr++ = *bp++;

     /*lint -save -e946 [18.2] Normal pointers arithmetic, it is safe.*/

     if (oqp->q_wrptr >= oqp->q_top) {

     /*lint -restore*/

       oqp->q_wrptr = oqp->q_buffer;

     }

 

-    if (nfy) {

+    if (nfy != NULL) {

       nfy(oqp);

     }

 

     chSysUnlock(); /* Gives a preemption chance in a controlled point.*/

     w++;

-    if (--n == 0) {

+    n--;

+    if (n == 0U) {

       return w;

     }

     chSysLock();

diff --git a/os/rt/src/chschd.c b/os/rt/src/chschd.c
index 03d5259ed..3e7f84002 100644
--- a/os/rt/src/chschd.c
+++ b/os/rt/src/chschd.c
@@ -289,11 +289,11 @@ static void wakeup(void *p) {
     chSysUnlockFromISR();

     return;

   case CH_STATE_SUSPENDED:

-    *(thread_reference_t *)tp->p_u.wtobjp = NULL;

+    *tp->p_u.wttrp = NULL;

     break;

 #if CH_CFG_USE_SEMAPHORES == TRUE

   case CH_STATE_WTSEM:

-    chSemFastSignalI((semaphore_t *)tp->p_u.wtobjp);

+    chSemFastSignalI(tp->p_u.wtsemp);

     /* Falls into, intentional. */

 #endif

 #if (CH_CFG_USE_CONDVARS == TRUE) && (CH_CFG_USE_CONDVARS_TIMEOUT == TRUE)

diff --git a/os/rt/src/chsem.c b/os/rt/src/chsem.c
index 87a28eb28..30a68e035 100644
--- a/os/rt/src/chsem.c
+++ b/os/rt/src/chsem.c
@@ -203,7 +203,7 @@ msg_t chSemWaitS(semaphore_t *sp) {
               "inconsistent semaphore");

 

   if (--sp->s_cnt < 0) {

-    currp->p_u.wtobjp = sp;

+    currp->p_u.wtsemp = sp;

     sem_insert(currp, &sp->s_queue);

     chSchGoSleepS(CH_STATE_WTSEM);

 

@@ -275,7 +275,7 @@ msg_t chSemWaitTimeoutS(semaphore_t *sp, systime_t time) {
 

       return MSG_TIMEOUT;

     }

-    currp->p_u.wtobjp = sp;

+    currp->p_u.wtsemp = sp;

     sem_insert(currp, &sp->s_queue);

 

     return chSchGoSleepTimeoutS(CH_STATE_WTSEM, time);

@@ -393,7 +393,7 @@ msg_t chSemSignalWait(semaphore_t *sps, semaphore_t *spw) {
   if (--spw->s_cnt < 0) {

     thread_t *ctp = currp;

     sem_insert(ctp, &spw->s_queue);

-    ctp->p_u.wtobjp = spw;

+    ctp->p_u.wtsemp = spw;

     chSchGoSleepS(CH_STATE_WTSEM);

     msg = ctp->p_u.rdymsg;

   }

diff --git a/os/rt/src/chthreads.c b/os/rt/src/chthreads.c
index af672774e..3f5f35878 100644
--- a/os/rt/src/chthreads.c
+++ b/os/rt/src/chthreads.c
@@ -511,7 +511,7 @@ msg_t chThdSuspendS(thread_reference_t *trp) {
   chDbgAssert(*trp == NULL, "not NULL");

 

   *trp = tp;

-  tp->p_u.wtobjp = &trp;

+  tp->p_u.wttrp = trp;

   chSchGoSleepS(CH_STATE_SUSPENDED);

 

   return chThdGetSelfX()->p_u.rdymsg;

@@ -546,7 +546,7 @@ msg_t chThdSuspendTimeoutS(thread_reference_t *trp, systime_t timeout) {
   }

 

   *trp = tp;

-  tp->p_u.wtobjp = &trp;

+  tp->p_u.wttrp = trp;

 

   return chSchGoSleepTimeoutS(CH_STATE_SUSPENDED, timeout);

 }