rtos: NULL -> nullptr

kjbracey · kjbracey · commit ab4906153004 · 2019-07-12T14:07:02.000+03:00
Some build errors seen with NULL not being defined. Rather than
add cstddef includes, switch to C++11 nullptr.
diff --git a/rtos/ConditionVariable.cpp b/rtos/ConditionVariable.cpp
@@ -30,12 +30,12 @@
 
 namespace rtos {
 
-ConditionVariable::Waiter::Waiter(): sem(0), prev(NULL), next(NULL), in_list(false)
+ConditionVariable::Waiter::Waiter(): sem(0), prev(nullptr), next(nullptr), in_list(false)
 {
     // No initialization to do
 }
 
-ConditionVariable::ConditionVariable(Mutex &mutex): _mutex(mutex), _wait_list(NULL)
+ConditionVariable::ConditionVariable(Mutex &mutex): _mutex(mutex), _wait_list(nullptr)
 {
     // No initialization to do
 }
@@ -86,7 +86,7 @@ bool ConditionVariable::wait_until(uint64_t millisec)
 void ConditionVariable::notify_one()
 {
     MBED_ASSERT(_mutex.get_owner() == ThisThread::get_id());
-    if (_wait_list != NULL) {
+    if (_wait_list != nullptr) {
         _wait_list->sem.release();
         _remove_wait_list(&_wait_list, _wait_list);
     }
@@ -95,15 +95,15 @@ void ConditionVariable::notify_one()
 void ConditionVariable::notify_all()
 {
     MBED_ASSERT(_mutex.get_owner() == ThisThread::get_id());
-    while (_wait_list != NULL) {
+    while (_wait_list != nullptr) {
         _wait_list->sem.release();
         _remove_wait_list(&_wait_list, _wait_list);
     }
 }
 
 void ConditionVariable::_add_wait_list(Waiter **wait_list, Waiter *waiter)
 {
-    if (NULL == *wait_list) {
+    if (nullptr == *wait_list) {
         // Nothing in the list so add it directly.
         // Update prev and next pointer to reference self
         *wait_list = waiter;
@@ -137,18 +137,18 @@ void ConditionVariable::_remove_wait_list(Waiter **wait_list, Waiter *waiter)
 
     if (*wait_list == waiter) {
         // This was the last element in the list
-        *wait_list = NULL;
+        *wait_list = nullptr;
     }
 
     // Invalidate pointers
-    waiter->next = NULL;
-    waiter->prev = NULL;
+    waiter->next = nullptr;
+    waiter->prev = nullptr;
     waiter->in_list = false;
 }
 
 ConditionVariable::~ConditionVariable()
 {
-    MBED_ASSERT(NULL == _wait_list);
+    MBED_ASSERT(nullptr == _wait_list);
 }
 
 }
diff --git a/rtos/EventFlags.h b/rtos/EventFlags.h
@@ -112,7 +112,7 @@ class EventFlags : private mbed::NonCopyable<EventFlags> {
     ~EventFlags();
 
 private:
-    void constructor(const char *name = NULL);
+    void constructor(const char *name = nullptr);
     uint32_t wait(uint32_t flags, uint32_t opt, uint32_t millisec, bool clear);
 #if MBED_CONF_RTOS_PRESENT
     osEventFlagsId_t                _id;
diff --git a/rtos/Mail.h b/rtos/Mail.h
@@ -97,7 +97,7 @@ class Mail : private mbed::NonCopyable<Mail<T, queue_sz> > {
      *
      * @param   millisec  Not used (see note).
      *
-     * @return  Pointer to memory block that you can fill with mail or NULL in case error.
+     * @return  Pointer to memory block that you can fill with mail or nullptr in case error.
      *
      * @note You may call this function from ISR context.
      * @note If blocking is required, use Mail::alloc_for or Mail::alloc_until
@@ -111,7 +111,7 @@ class Mail : private mbed::NonCopyable<Mail<T, queue_sz> > {
      *
      * @param   millisec  Timeout value, or osWaitForever.
      *
-     * @return  Pointer to memory block that you can fill with mail or NULL in case error.
+     * @return  Pointer to memory block that you can fill with mail or nullptr in case error.
      *
      * @note You may call this function from ISR context if the millisec parameter is set to 0.
      */
@@ -124,7 +124,7 @@ class Mail : private mbed::NonCopyable<Mail<T, queue_sz> > {
      *
      * @param   millisec  Absolute timeout time, referenced to Kernel::get_ms_count().
      *
-     * @return  Pointer to memory block that you can fill with mail or NULL in case error.
+     * @return  Pointer to memory block that you can fill with mail or nullptr in case error.
      *
      * @note You cannot call this function from ISR context.
      * @note the underlying RTOS may have a limit to the maximum wait time
@@ -141,7 +141,7 @@ class Mail : private mbed::NonCopyable<Mail<T, queue_sz> > {
      *
      * @param   millisec  Not used (see note).
      *
-     * @return  Pointer to memory block that you can fill with mail or NULL in case error.
+     * @return  Pointer to memory block that you can fill with mail or nullptr in case error.
      *
      * @note You may call this function from ISR context if the millisec parameter is set to 0.
      * @note If blocking is required, use Mail::calloc_for or Mail::calloc_until
@@ -155,7 +155,7 @@ class Mail : private mbed::NonCopyable<Mail<T, queue_sz> > {
      *
      * @param   millisec  Timeout value, or osWaitForever.
      *
-     * @return  Pointer to memory block that you can fill with mail or NULL in case error.
+     * @return  Pointer to memory block that you can fill with mail or nullptr in case error.
      *
      * @note You may call this function from ISR context if the millisec parameter is set to 0.
      */
@@ -168,7 +168,7 @@ class Mail : private mbed::NonCopyable<Mail<T, queue_sz> > {
      *
      * @param   millisec  Absolute timeout time, referenced to Kernel::get_ms_count().
      *
-     * @return  Pointer to memory block that you can fill with mail or NULL in case error.
+     * @return  Pointer to memory block that you can fill with mail or nullptr in case error.
      *
      * @note You cannot call this function from ISR context.
      * @note the underlying RTOS may have a limit to the maximum wait time
diff --git a/rtos/MemoryPool.h b/rtos/MemoryPool.h
@@ -77,7 +77,7 @@ class MemoryPool : private mbed::NonCopyable<MemoryPool<T, pool_sz> > {
     }
 
     /** Allocate a memory block from a memory pool, without blocking.
-      @return  address of the allocated memory block or NULL in case of no memory available.
+      @return  address of the allocated memory block or nullptr in case of no memory available.
 
       @note You may call this function from ISR context.
     */
@@ -88,7 +88,7 @@ class MemoryPool : private mbed::NonCopyable<MemoryPool<T, pool_sz> > {
 
     /** Allocate a memory block from a memory pool, optionally blocking.
       @param   millisec  timeout value (osWaitForever to wait forever)
-      @return  address of the allocated memory block or NULL in case of no memory available.
+      @return  address of the allocated memory block or nullptr in case of no memory available.
 
       @note You may call this function from ISR context if the millisec parameter is set to 0.
     */
@@ -99,7 +99,7 @@ class MemoryPool : private mbed::NonCopyable<MemoryPool<T, pool_sz> > {
 
     /** Allocate a memory block from a memory pool, blocking.
       @param   millisec absolute timeout time, referenced to Kernel::get_ms_count().
-      @return  address of the allocated memory block or NULL in case of no memory available.
+      @return  address of the allocated memory block or nullptr in case of no memory available.
 
       @note You cannot call this function from ISR context.
       @note the underlying RTOS may have a limit to the maximum wait time
@@ -122,37 +122,37 @@ class MemoryPool : private mbed::NonCopyable<MemoryPool<T, pool_sz> > {
     }
 
     /** Allocate a memory block from a memory pool, without blocking, and set memory block to zero.
-      @return  address of the allocated memory block or NULL in case of no memory available.
+      @return  address of the allocated memory block or nullptr in case of no memory available.
 
       @note You may call this function from ISR context.
     */
     T *calloc(void)
     {
         T *item = alloc();
-        if (item != NULL) {
+        if (item != nullptr) {
             memset(item, 0, sizeof(T));
         }
         return item;
     }
 
     /** Allocate a memory block from a memory pool, optionally blocking, and set memory block to zero.
       @param   millisec  timeout value (osWaitForever to wait forever)
-      @return  address of the allocated memory block or NULL in case of no memory available.
+      @return  address of the allocated memory block or nullptr in case of no memory available.
 
       @note You may call this function from ISR context if the millisec parameter is set to 0.
     */
     T *calloc_for(uint32_t millisec)
     {
         T *item = alloc_for(millisec);
-        if (item != NULL) {
+        if (item != nullptr) {
             memset(item, 0, sizeof(T));
         }
         return item;
     }
 
     /** Allocate a memory block from a memory pool, blocking, and set memory block to zero.
       @param   millisec absolute timeout time, referenced to Kernel::get_ms_count().
-      @return  address of the allocated memory block or NULL in case of no memory available.
+      @return  address of the allocated memory block or nullptr in case of no memory available.
 
       @note You cannot call this function from ISR context.
       @note the underlying RTOS may have a limit to the maximum wait time
@@ -163,7 +163,7 @@ class MemoryPool : private mbed::NonCopyable<MemoryPool<T, pool_sz> > {
     T *calloc_until(uint64_t millisec)
     {
         T *item = alloc_until(millisec);
-        if (item != NULL) {
+        if (item != nullptr) {
             memset(item, 0, sizeof(T));
         }
         return item;
@@ -172,7 +172,7 @@ class MemoryPool : private mbed::NonCopyable<MemoryPool<T, pool_sz> > {
     /** Free a memory block.
       @param   block  address of the allocated memory block to be freed.
       @return         osOK on successful deallocation, osErrorParameter if given memory block id
-                      is NULL or invalid, or osErrorResource if given memory block is in an
+                      is nullptr or invalid, or osErrorResource if given memory block is in an
                       invalid memory pool state.
 
       @note You may call this function from ISR context.
diff --git a/rtos/Mutex.h b/rtos/Mutex.h
@@ -177,7 +177,7 @@ class Mutex : private mbed::NonCopyable<Mutex> {
 
 private:
 #if MBED_CONF_RTOS_PRESENT
-    void constructor(const char *name = NULL);
+    void constructor(const char *name = nullptr);
     friend class ConditionVariable;
 
     osMutexId_t               _id;
diff --git a/rtos/Queue.h b/rtos/Queue.h
@@ -187,8 +187,8 @@ class Queue : private mbed::NonCopyable<Queue<T, queue_sz> > {
     osEvent get(uint32_t millisec = osWaitForever)
     {
         osEvent event;
-        T *data = NULL;
-        osStatus_t res = osMessageQueueGet(_id, &data, NULL, millisec);
+        T *data = nullptr;
+        osStatus_t res = osMessageQueueGet(_id, &data, nullptr, millisec);
 
         switch (res) {
             case osOK:
diff --git a/rtos/RtosTimer.h b/rtos/RtosTimer.h
@@ -91,7 +91,7 @@ class RtosTimer : private mbed::NonCopyable<RtosTimer> {
     /** Create timer.
       @param   func      function to be executed by this timer.
       @param   type      osTimerOnce for one-shot or osTimerPeriodic for periodic behavior. (default: osTimerPeriodic)
-      @param   argument  argument to the timer call back function. (default: NULL)
+      @param   argument  argument to the timer call back function. (default: nullptr)
       @deprecated Replaced with RtosTimer(Callback<void()>, os_timer_type)
       @deprecated
           The RtosTimer has been superseded by the EventQueue. See RtosTimer.h for more details
@@ -102,7 +102,7 @@ class RtosTimer : private mbed::NonCopyable<RtosTimer> {
                           "Replaced with RtosTimer(Callback<void()>, os_timer_type)")
     MBED_DEPRECATED_SINCE("mbed-os-5.2",
                           "The RtosTimer has been superseded by the EventQueue. See RtosTimer.h for more details")
-    RtosTimer(void (*func)(void const *argument), os_timer_type type = osTimerPeriodic, void *argument = NULL)
+    RtosTimer(void (*func)(void const *argument), os_timer_type type = osTimerPeriodic, void *argument = nullptr)
     {
         constructor(mbed::callback((void (*)(void *))func, argument), type);
     }
diff --git a/rtos/Semaphore.cpp b/rtos/Semaphore.cpp
@@ -47,7 +47,7 @@ void Semaphore::constructor(int32_t count, uint16_t max_count)
     attr.cb_mem = &_obj_mem;
     attr.cb_size = sizeof(_obj_mem);
     _id = osSemaphoreNew(max_count, count, &attr);
-    MBED_ASSERT(_id != NULL);
+    MBED_ASSERT(_id != nullptr);
 #else
     _count = count;
     _max_count = max_count;
diff --git a/rtos/TARGET_CORTEX/mbed_rtx_idle.cpp b/rtos/TARGET_CORTEX/mbed_rtx_idle.cpp
@@ -159,8 +159,8 @@ extern "C" {
 
     void rtos_attach_idle_hook(void (*fptr)(void))
     {
-        //Attach the specified idle hook, or the default idle hook in case of a NULL pointer
-        if (fptr != NULL) {
+        //Attach the specified idle hook, or the default idle hook in case of a null pointer
+        if (fptr != nullptr) {
             idle_hook_fptr = fptr;
         } else {
             idle_hook_fptr = default_idle_hook;
diff --git a/rtos/ThisThread.cpp b/rtos/ThisThread.cpp
@@ -242,12 +242,12 @@ const char *get_name()
 {
 #if MBED_CONF_RTOS_PRESENT
     osThreadId_t id = osThreadGetId();
-    if (id == NULL) {
-        return NULL;
+    if (id == nullptr) {
+        return nullptr;
     }
     return osThreadGetName(id);
 #else
-    return NULL;
+    return nullptr;
 #endif
 }
 
diff --git a/rtos/ThisThread.h b/rtos/ThisThread.h
@@ -169,13 +169,13 @@ void sleep_until(uint64_t millisec);
 void yield();
 
 /** Get the thread id of the current running thread.
-  @return  thread ID for reference by other functions or NULL in case of error or in ISR context.
+  @return  thread ID for reference by other functions or nullptr in case of error or in ISR context.
   @note You may call this function from ISR context.
 */
 osThreadId_t get_id();
 
 /** Get the thread name of the current running thread.
-  @return  thread name pointer or NULL if thread has no name or in case of error.
+  @return  thread name pointer or nullptr if thread has no name or in case of error.
   @note You cannot call this function from ISR context.
 */
 const char *get_name();
diff --git a/rtos/Thread.cpp b/rtos/Thread.cpp
diff --git a/rtos/Thread.h b/rtos/Thread.h

Original file line number	Diff line number	Diff line change
`@@ -30,12 +30,12 @@`
`30`	`30`
`31`	`31`	`namespace rtos {`
`32`	`32`
`33`		`-ConditionVariable::Waiter::Waiter(): sem(0), prev(NULL), next(NULL), in_list(false)`
	`33`	`+ConditionVariable::Waiter::Waiter(): sem(0), prev(nullptr), next(nullptr), in_list(false)`
`34`	`34`	`{`
`35`	`35`	`// No initialization to do`
`36`	`36`	`}`
`37`	`37`
`38`		`-ConditionVariable::ConditionVariable(Mutex &mutex): _mutex(mutex), _wait_list(NULL)`
	`38`	`+ConditionVariable::ConditionVariable(Mutex &mutex): _mutex(mutex), _wait_list(nullptr)`
`39`	`39`	`{`
`40`	`40`	`// No initialization to do`
`41`	`41`	`}`
`@@ -86,7 +86,7 @@ bool ConditionVariable::wait_until(uint64_t millisec)`
`86`	`86`	`void ConditionVariable::notify_one()`
`87`	`87`	`{`
`88`	`88`	`MBED_ASSERT(_mutex.get_owner() == ThisThread::get_id());`
`89`		`- if (_wait_list != NULL) {`
	`89`	`+ if (_wait_list != nullptr) {`
`90`	`90`	`_wait_list->sem.release();`
`91`	`91`	`_remove_wait_list(&_wait_list, _wait_list);`
`92`	`92`	`}`
`@@ -95,15 +95,15 @@ void ConditionVariable::notify_one()`
`95`	`95`	`void ConditionVariable::notify_all()`
`96`	`96`	`{`
`97`	`97`	`MBED_ASSERT(_mutex.get_owner() == ThisThread::get_id());`
`98`		`- while (_wait_list != NULL) {`
	`98`	`+ while (_wait_list != nullptr) {`
`99`	`99`	`_wait_list->sem.release();`
`100`	`100`	`_remove_wait_list(&_wait_list, _wait_list);`
`101`	`101`	`}`
`102`	`102`	`}`
`103`	`103`
`104`	`104`	`void ConditionVariable::_add_wait_list(Waiter *wait_list, Waiter waiter)`
`105`	`105`	`{`
`106`		`- if (NULL == *wait_list) {`
	`106`	`+ if (nullptr == *wait_list) {`
`107`	`107`	`// Nothing in the list so add it directly.`
`108`	`108`	`// Update prev and next pointer to reference self`
`109`	`109`	`*wait_list = waiter;`
`@@ -137,18 +137,18 @@ void ConditionVariable::_remove_wait_list(Waiter *wait_list, Waiter waiter)`
`137`	`137`
`138`	`138`	`if (*wait_list == waiter) {`
`139`	`139`	`// This was the last element in the list`
`140`		`- *wait_list = NULL;`
	`140`	`+ *wait_list = nullptr;`
`141`	`141`	`}`
`142`	`142`
`143`	`143`	`// Invalidate pointers`
`144`		`- waiter->next = NULL;`
`145`		`- waiter->prev = NULL;`
	`144`	`+ waiter->next = nullptr;`
	`145`	`+ waiter->prev = nullptr;`
`146`	`146`	`waiter->in_list = false;`
`147`	`147`	`}`
`148`	`148`
`149`	`149`	`ConditionVariable::~ConditionVariable()`
`150`	`150`	`{`
`151`		`- MBED_ASSERT(NULL == _wait_list);`
	`151`	`+ MBED_ASSERT(nullptr == _wait_list);`
`152`	`152`	`}`
`153`	`153`
`154`	`154`	`}`
Original file line number	Diff line number	Diff line change
`@@ -97,7 +97,7 @@ class Mail : private mbed::NonCopyable<Mail<T, queue_sz> > {`
`97`	`97`	`*`
`98`	`98`	`* @param millisec Not used (see note).`
`99`	`99`	`*`
`100`		`- * @return Pointer to memory block that you can fill with mail or NULL in case error.`
	`100`	`+ * @return Pointer to memory block that you can fill with mail or nullptr in case error.`
`101`	`101`	`*`
`102`	`102`	`* @note You may call this function from ISR context.`
`103`	`103`	`* @note If blocking is required, use Mail::alloc_for or Mail::alloc_until`
`@@ -111,7 +111,7 @@ class Mail : private mbed::NonCopyable<Mail<T, queue_sz> > {`
`111`	`111`	`*`
`112`	`112`	`* @param millisec Timeout value, or osWaitForever.`
`113`	`113`	`*`
`114`		`- * @return Pointer to memory block that you can fill with mail or NULL in case error.`
	`114`	`+ * @return Pointer to memory block that you can fill with mail or nullptr in case error.`
`115`	`115`	`*`
`116`	`116`	`* @note You may call this function from ISR context if the millisec parameter is set to 0.`
`117`	`117`	`*/`
`@@ -124,7 +124,7 @@ class Mail : private mbed::NonCopyable<Mail<T, queue_sz> > {`
`124`	`124`	`*`
`125`	`125`	`* @param millisec Absolute timeout time, referenced to Kernel::get_ms_count().`
`126`	`126`	`*`
`127`		`- * @return Pointer to memory block that you can fill with mail or NULL in case error.`
	`127`	`+ * @return Pointer to memory block that you can fill with mail or nullptr in case error.`
`128`	`128`	`*`
`129`	`129`	`* @note You cannot call this function from ISR context.`
`130`	`130`	`* @note the underlying RTOS may have a limit to the maximum wait time`
`@@ -141,7 +141,7 @@ class Mail : private mbed::NonCopyable<Mail<T, queue_sz> > {`
`141`	`141`	`*`
`142`	`142`	`* @param millisec Not used (see note).`
`143`	`143`	`*`
`144`		`- * @return Pointer to memory block that you can fill with mail or NULL in case error.`
	`144`	`+ * @return Pointer to memory block that you can fill with mail or nullptr in case error.`
`145`	`145`	`*`
`146`	`146`	`* @note You may call this function from ISR context if the millisec parameter is set to 0.`
`147`	`147`	`* @note If blocking is required, use Mail::calloc_for or Mail::calloc_until`
`@@ -155,7 +155,7 @@ class Mail : private mbed::NonCopyable<Mail<T, queue_sz> > {`
`155`	`155`	`*`
`156`	`156`	`* @param millisec Timeout value, or osWaitForever.`
`157`	`157`	`*`
`158`		`- * @return Pointer to memory block that you can fill with mail or NULL in case error.`
	`158`	`+ * @return Pointer to memory block that you can fill with mail or nullptr in case error.`
`159`	`159`	`*`
`160`	`160`	`* @note You may call this function from ISR context if the millisec parameter is set to 0.`
`161`	`161`	`*/`
`@@ -168,7 +168,7 @@ class Mail : private mbed::NonCopyable<Mail<T, queue_sz> > {`
`168`	`168`	`*`
`169`	`169`	`* @param millisec Absolute timeout time, referenced to Kernel::get_ms_count().`
`170`	`170`	`*`
`171`		`- * @return Pointer to memory block that you can fill with mail or NULL in case error.`
	`171`	`+ * @return Pointer to memory block that you can fill with mail or nullptr in case error.`
`172`	`172`	`*`
`173`	`173`	`* @note You cannot call this function from ISR context.`
`174`	`174`	`* @note the underlying RTOS may have a limit to the maximum wait time`
Original file line number	Diff line number	Diff line change
`@@ -242,12 +242,12 @@ const char *get_name()`
`242`	`242`	`{`
`243`	`243`	`#if MBED_CONF_RTOS_PRESENT`
`244`	`244`	`osThreadId_t id = osThreadGetId();`
`245`		`- if (id == NULL) {`
`246`		`- return NULL;`
	`245`	`+ if (id == nullptr) {`
	`246`	`+ return nullptr;`
`247`	`247`	`}`
`248`	`248`	`return osThreadGetName(id);`
`249`	`249`	`#else`
`250`		`- return NULL;`
	`250`	`+ return nullptr;`
`251`	`251`	`#endif`
`252`	`252`	`}`
`253`	`253`