os-c-wrapper.cpp

Go to the documentation of this file.

/*
 * This file is part of the µOS++ distribution.
 *   (https://github.com/micro-os-plus)
 * Copyright (c) 2016 Liviu Ionescu.
 *
 * Permission is hereby granted, free of charge, to any person
 * obtaining a copy of this software and associated documentation
 * files (the "Software"), to deal in the Software without
 * restriction, including without limitation the rights to use,
 * copy, modify, merge, publish, distribute, sublicense, and/or
 * sell copies of the Software, and to permit persons to whom
 * the Software is furnished to do so, subject to the following
 * conditions:
 *
 * The above copyright notice and this permission notice shall be
 * included in all copies or substantial portions of the Software.
 *
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
 * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
 * OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
 * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
 * HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
 * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
 * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
 * OTHER DEALINGS IN THE SOFTWARE.
 */
 
/*
 * The code provides an implementation of the C API for the µOS++
 * and legacy CMSIS, using the CMSIC++ RTOS definitions.
 */
 
#include <cmsis-plus/rtos/os.h>
#include <cmsis-plus/rtos/os-c-api.h>
 
// ----------------------------------------------------------------------------
 
#if defined(__clang__)
#pragma clang diagnostic ignored "-Wc++98-compat"
#endif
 
// ----------------------------------------------------------------------------
 
using namespace os;
using namespace os::rtos;
 
// ----------------------------------------------------------------------------
 
// Validate C typedefs sizes & alignment.
 
static_assert(sizeof(os_result_t) == sizeof(result_t), "adjust size of os_result_t");
static_assert(alignof(os_result_t) == alignof(result_t), "adjust align of os_result_t");
 
static_assert(sizeof(os_flags_mode_t) == sizeof(flags::mode_t), "adjust size of os_flags_mode_t");
static_assert(alignof(os_flags_mode_t) == alignof(flags::mode_t), "adjust align of os_flags_mode_t");
 
static_assert(sizeof(os_flags_mask_t) == sizeof(flags::mask_t), "adjust size of os_flags_mask_t");
static_assert(alignof(os_flags_mask_t) == alignof(flags::mask_t), "adjust align of os_flags_mask_t");
 
static_assert(sizeof(os_sched_state_t) == sizeof(scheduler::state_t), "adjust size of os_sched_state_t");
static_assert(alignof(os_sched_state_t) == alignof(scheduler::state_t), "adjust align of os_sched_state_t");
 
static_assert(sizeof(os_irq_state_t) == sizeof(interrupts::state_t), "adjust size of os_irq_state_t");
static_assert(alignof(os_irq_state_t) == alignof(interrupts::state_t), "adjust align of os_irq_state_t");
 
static_assert(sizeof(os_clock_timestamp_t) == sizeof(clock::timestamp_t), "adjust size of os_port_clock_timestamp_t");
static_assert(alignof(os_clock_timestamp_t) == alignof(clock::timestamp_t), "adjust align of os_port_clock_timestamp_t");
 
static_assert(sizeof(os_clock_duration_t) == sizeof(clock::duration_t), "adjust size of os_port_clock_duration_t");
static_assert(alignof(os_clock_duration_t) == alignof(clock::duration_t), "adjust align of os_port_clock_duration_t");
 
static_assert(sizeof(os_clock_offset_t) == sizeof(clock::offset_t), "adjust size of os_port_clock_offset_t");
static_assert(alignof(os_clock_offset_t) == alignof(clock::offset_t), "adjust align of os_port_clock_offset_t");
 
static_assert(sizeof(os_statistics_counter_t) == sizeof(statistics::counter_t), "adjust size of os_statistics_counter_t");
static_assert(alignof(os_statistics_counter_t) == alignof(statistics::counter_t), "adjust align of os_statistics_counter_t");
 
static_assert(sizeof(os_statistics_duration_t) == sizeof(statistics::duration_t), "adjust size of os_statistics_duration_t");
static_assert(alignof(os_statistics_duration_t) == alignof(statistics::duration_t), "adjust align of os_statistics_duration_t");
 
static_assert(sizeof(os_thread_func_args_t) == sizeof(thread::func_args_t), "adjust size of os_thread_func_args_t");
static_assert(alignof(os_thread_func_args_t) == alignof(thread::func_args_t), "adjust align of os_thread_func_args_t");
 
static_assert(sizeof(os_thread_func_t) == sizeof(thread::func_t), "adjust size of os_thread_func_t");
static_assert(alignof(os_thread_func_t) == alignof(thread::func_t), "adjust align of os_thread_func_t");
 
static_assert(sizeof(os_thread_state_t) == sizeof(thread::state_t), "adjust size of os_thread_state_t");
static_assert(alignof(os_thread_state_t) == alignof(thread::state_t), "adjust align of os_thread_state_t");
 
static_assert(sizeof(os_thread_prio_t) == sizeof(thread::priority_t), "adjust size of os_thread_prio_t");
static_assert(alignof(os_thread_prio_t) == alignof(thread::priority_t), "adjust align of os_thread_prio_t");
 
static_assert(sizeof(os_timer_func_args_t) == sizeof(timer::func_args_t), "adjust size of os_timer_func_args_t");
static_assert(alignof(os_timer_func_args_t) == alignof(timer::func_args_t), "adjust align of os_timer_func_args_t");
 
static_assert(sizeof(os_timer_func_t) == sizeof(timer::func_t), "adjust size of os_timer_func_t");
static_assert(alignof(os_timer_func_t) == alignof(timer::func_t), "adjust align of os_timer_func_t");
 
static_assert(sizeof(os_timer_type_t) == sizeof(timer::type_t), "adjust size of os_timer_type_t");
static_assert(alignof(os_timer_type_t) == alignof(timer::type_t), "adjust align of os_timer_type_t");
 
static_assert(sizeof(os_timer_state_t) == sizeof(timer::state_t), "adjust size of os_timer_state_t");
static_assert(alignof(os_timer_state_t) == alignof(timer::state_t), "adjust align of os_timer_state_t");
 
static_assert(sizeof(os_mutex_count_t) == sizeof(mutex::count_t), "adjust size of os_mutex_count_t");
static_assert(alignof(os_mutex_count_t) == alignof(mutex::count_t), "adjust align of os_mutex_count_t");
 
static_assert(sizeof(os_mutex_type_t) == sizeof(mutex::type_t), "adjust size of os_mutex_type_t");
static_assert(alignof(os_mutex_type_t) == alignof(mutex::type_t), "adjust align of os_mutex_type_t");
 
static_assert(sizeof(os_mutex_protocol_t) == sizeof(mutex::protocol_t), "adjust size of os_mutex_protocol_t");
static_assert(alignof(os_mutex_protocol_t) == alignof(mutex::protocol_t), "adjust align of os_mutex_protocol_t");
 
static_assert(sizeof(os_mutex_robustness_t) == sizeof(mutex::robustness_t), "adjust size of os_mutex_robustness_t");
static_assert(alignof(os_mutex_robustness_t) == alignof(mutex::robustness_t), "adjust align of os_mutex_robustness_t");
 
static_assert(sizeof(os_semaphore_count_t) == sizeof(semaphore::count_t), "adjust size of os_semaphore_count_t");
static_assert(alignof(os_semaphore_count_t) == alignof(semaphore::count_t), "adjust align of os_semaphore_count_t");
 
static_assert(sizeof(os_mempool_size_t) == sizeof(memory_pool::size_t), "adjust size of os_mempool_size_t");
static_assert(alignof(os_mempool_size_t) == alignof(memory_pool::size_t), "adjust align of os_mempool_size_t");
 
static_assert(sizeof(os_mqueue_size_t) == sizeof(message_queue::size_t), "adjust size of os_mqueue_size_t");
static_assert(alignof(os_mqueue_size_t) == alignof(message_queue::size_t), "adjust align of os_mqueue_size_t");
 
static_assert(sizeof(os_mqueue_msg_size_t) == sizeof(message_queue::msg_size_t), "adjust size of os_mqueue_msg_size_t");
static_assert(alignof(os_mqueue_msg_size_t) == alignof(message_queue::msg_size_t), "adjust align of os_mqueue_msg_size_t");
 
static_assert(sizeof(os_mqueue_index_t) == sizeof(message_queue::index_t), "adjust size of os_mqueue_index_t");
static_assert(alignof(os_mqueue_index_t) == alignof(message_queue::index_t), "adjust align of os_mqueue_index_t");
 
static_assert(sizeof(os_mqueue_prio_t) == sizeof(message_queue::priority_t), "adjust size of os_mqueue_prio_t");
static_assert(alignof(os_mqueue_prio_t) == alignof(message_queue::priority_t), "adjust align of os_mqueue_prio_t");
 
// ----------------------------------------------------------------------------
 
// Validate C enumeration values
 
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wenum-compare"
#if defined(__clang__)
#pragma clang diagnostic ignored "-Wanon-enum-enum-conversion"
#else
#pragma GCC diagnostic ignored "-Wsign-compare"
#endif
 
static_assert(os_thread_priority_idle == thread::priority::idle, "adjust os_thread_priority_idle");
static_assert(os_thread_priority_low == thread::priority::low, "adjust os_thread_priority_low");
static_assert(os_thread_priority_below_normal == thread::priority::below_normal, "adjust os_thread_priority_below_normal");
static_assert(os_thread_priority_normal == thread::priority::normal, "adjust os_thread_priority_normal");
static_assert(os_thread_priority_above_normal == thread::priority::above_normal, "adjust os_thread_priority_above_normal");
static_assert(os_thread_priority_high == thread::priority::high, "adjust os_thread_priority_high");
static_assert(os_thread_priority_realtime == thread::priority::realtime, "adjust os_thread_priority_realtime");
static_assert(os_thread_priority_error == thread::priority::error, "adjust os_thread_priority_error");
 
static_assert(os_flags_mode_all == flags::mode::all, "adjust os_flags_mode_all");
static_assert(os_flags_mode_any == flags::mode::any, "adjust os_flags_mode_any");
static_assert(os_flags_mode_clear == flags::mode::clear, "adjust os_flags_mode_clear");
 
static_assert(os_thread_state_undefined == thread::state::undefined, "adjust os_thread_state_undefined");
static_assert(os_thread_state_initialising == thread::state::initializing, "adjust os_thread_state_initializing");
static_assert(os_thread_state_ready == thread::state::ready, "adjust os_thread_state_ready");
static_assert(os_thread_state_running == thread::state::running, "adjust os_thread_state_running");
static_assert(os_thread_state_suspended == thread::state::suspended, "adjust os_thread_state_suspended");
static_assert(os_thread_state_terminated == thread::state::terminated, "adjust os_thread_state_terminated");
static_assert(os_thread_state_destroyed == thread::state::destroyed, "adjust os_thread_state_destroyed");
 
static_assert(os_timer_once == timer::run::once, "adjust os_timer_once");
static_assert(os_timer_periodic == timer::run::periodic, "adjust os_timer_periodic");
 
static_assert(os_mutex_protocol_none == mutex::protocol::none, "adjust os_mutex_protocol_none");
static_assert(os_mutex_protocol_inherit == mutex::protocol::inherit, "adjust os_mutex_protocol_inherit");
static_assert(os_mutex_protocol_protect == mutex::protocol::protect, "adjust os_mutex_protocol_protect");
 
static_assert(os_mutex_robustness_stalled == mutex::robustness::stalled, "adjust os_mutex_robustness_stalled");
static_assert(os_mutex_robustness_robust == mutex::robustness::robust, "adjust os_mutex_robustness_robust");
 
static_assert(os_mutex_type_normal == mutex::type::normal, "adjust os_mutex_type_normal");
static_assert(os_mutex_type_errorcheck == mutex::type::errorcheck, "adjust os_mutex_type_errorcheck");
static_assert(os_mutex_type_recursive == mutex::type::recursive, "adjust os_mutex_type_recursive");
static_assert(os_mutex_type_default == mutex::type::default_, "adjust os_mutex_type_default");
 
#pragma GCC diagnostic pop
 
// ----------------------------------------------------------------------------
 
// Validate C structs sizes (should match the C++ objects sizes).
// Validate offset of individual members (if needed, validate member size).
 
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Winvalid-offsetof"
 
static_assert(sizeof(rtos::clock) == sizeof(os_clock_t), "adjust os_clock_t size");
 
static_assert(sizeof(rtos::thread) == sizeof(os_thread_t), "adjust os_thread_t size");
static_assert(sizeof(rtos::thread::attributes) == sizeof(os_thread_attr_t), "adjust os_thread_attr_t size");
static_assert(offsetof(rtos::thread::attributes, th_stack_address) == offsetof(os_thread_attr_t, th_stack_address), "adjust os_thread_attr_t members");
static_assert(offsetof(rtos::thread::attributes, th_stack_size_bytes) == offsetof(os_thread_attr_t, th_stack_size_bytes), "adjust os_thread_attr_t members");
static_assert(offsetof(rtos::thread::attributes, th_priority) == offsetof(os_thread_attr_t, th_priority), "adjust os_thread_attr_t members");
static_assert(offsetof(rtos::thread::attributes, th_enable_assert_reuse) == offsetof(os_thread_attr_t, th_enable_assert_reuse), "adjust os_thread_attr_t members");
 
static_assert(sizeof(rtos::timer) == sizeof(os_timer_t), "adjust size of os_timer_t");
static_assert(sizeof(rtos::timer::attributes) == sizeof(os_timer_attr_t), "adjust size of os_timer_attr_t");
static_assert(offsetof(rtos::timer::attributes, tm_type) == offsetof(os_timer_attr_t, tm_type), "adjust os_timer_attr_t members");
 
static_assert(sizeof(rtos::mutex) == sizeof(os_mutex_t), "adjust size of os_mutex_t");
static_assert(sizeof(rtos::mutex::attributes) == sizeof(os_mutex_attr_t), "adjust size of os_mutex_attr_t");
static_assert(offsetof(rtos::mutex::attributes, mx_priority_ceiling) == offsetof(os_mutex_attr_t, mx_priority_ceiling), "adjust os_mutex_attr_t members");
static_assert(offsetof(rtos::mutex::attributes, mx_protocol) == offsetof(os_mutex_attr_t, mx_protocol), "adjust os_mutex_attr_t members");
static_assert(offsetof(rtos::mutex::attributes, mx_robustness) == offsetof(os_mutex_attr_t, mx_robustness), "adjust os_mutex_attr_t members");
static_assert(offsetof(rtos::mutex::attributes, mx_type) == offsetof(os_mutex_attr_t, mx_type), "adjust os_mutex_attr_t members");
static_assert(offsetof(rtos::mutex::attributes, mx_max_count) == offsetof(os_mutex_attr_t, mx_max_count), "adjust os_mutex_attr_t members");
 
static_assert(sizeof(rtos::condition_variable) == sizeof(os_condvar_t), "adjust size of os_condvar_t");
static_assert(sizeof(rtos::condition_variable::attributes) == sizeof(os_condvar_attr_t), "adjust size of os_condvar_attr_t");
 
static_assert(sizeof(rtos::semaphore) == sizeof(os_semaphore_t), "adjust size of os_semaphore_t");
static_assert(sizeof(rtos::semaphore::attributes) == sizeof(os_semaphore_attr_t), "adjust size of os_semaphore_attr_t");
static_assert(offsetof(rtos::semaphore::attributes, sm_initial_value) == offsetof(os_semaphore_attr_t, sm_initial_value), "adjust os_semaphore_attr_t members");
static_assert(offsetof(rtos::semaphore::attributes, sm_max_value) == offsetof(os_semaphore_attr_t, sm_max_value), "adjust os_semaphore_attr_t members");
 
static_assert(sizeof(rtos::memory_pool) == sizeof(os_mempool_t), "adjust size of os_mempool_t");
static_assert(sizeof(rtos::memory_pool::attributes) == sizeof(os_mempool_attr_t), "adjust size of os_mempool_attr_t");
static_assert(offsetof(rtos::memory_pool::attributes, mp_pool_address) == offsetof(os_mempool_attr_t, mp_pool_address), "adjust os_mempool_attr_t members");
static_assert(offsetof(rtos::memory_pool::attributes, mp_pool_size_bytes) == offsetof(os_mempool_attr_t, mp_pool_size_bytes), "adjust os_mempool_attr_t members");
 
static_assert(sizeof(rtos::message_queue) == sizeof(os_mqueue_t), "adjust size of os_mqueue_t");
static_assert(sizeof(rtos::message_queue::attributes) == sizeof(os_mqueue_attr_t), "adjust size of os_mqueue_attr_t");
static_assert(offsetof(rtos::message_queue::attributes, mq_queue_address) == offsetof(os_mqueue_attr_t, mq_queue_addr), "adjust os_mqueue_attr_t members");
static_assert(offsetof(rtos::message_queue::attributes, mq_queue_size_bytes) == offsetof(os_mqueue_attr_t, mq_queue_size_bytes), "adjust os_mqueue_attr_t members");
 
static_assert(sizeof(rtos::event_flags) == sizeof(os_evflags_t), "adjust size of os_evflags_t");
static_assert(sizeof(rtos::event_flags::attributes) == sizeof(os_evflags_attr_t), "adjust size of os_evflags_attr_t");
 
static_assert(sizeof(class thread::stack) == sizeof(os_thread_stack_t), "adjust size of os_thread_stack_t");
static_assert(sizeof(class thread::context) == sizeof(os_thread_context_t), "adjust size of os_thread_context_t");
 
#if defined(OS_INCLUDE_RTOS_STATISTICS_THREAD_CONTEXT_SWITCHES) \
  || defined(OS_INCLUDE_RTOS_STATISTICS_THREAD_CPU_CYCLES)
static_assert(sizeof(class thread::statistics) == sizeof(os_thread_statistics_t), "adjust size of os_thread_statistics_t");
#endif
 
static_assert(sizeof(internal::timer_node) == sizeof(os_internal_clock_timer_node_t), "adjust size of os_internal_clock_timer_node_t");
 
#pragma GCC diagnostic pop
 
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wold-style-cast"
 
// ----------------------------------------------------------------------------
 
os_result_t
os_sched_initialize (void)
{
  return (os_result_t) scheduler::initialize ();
}
 
void
os_sched_start (void)
{
  scheduler::start ();
}
 
bool
os_sched_is_started (void)
{
  return scheduler::started ();
}
 
os_sched_state_t
os_sched_lock (void)
{
  return scheduler::lock ();
}
 
os_sched_state_t
os_sched_unlock (void)
{
  return scheduler::unlock ();
}
 
os_sched_state_t
os_sched_set_locked (os_sched_state_t state)
{
  return scheduler::locked (state);
}
 
bool
os_sched_is_locked (void)
{
  return scheduler::locked ();
}
 
bool
os_sched_is_preemptive (void)
{
  return scheduler::preemptive ();
}
 
bool
os_sched_set_preemptive (bool state)
{
  return scheduler::preemptive (state);
}
 
#if defined(OS_INCLUDE_RTOS_STATISTICS_THREAD_CONTEXT_SWITCHES)
 
os_statistics_counter_t
os_sched_stat_get_context_switches (void)
{
  return static_cast<os_statistics_counter_t> (scheduler::statistics::context_switches ());
}
 
#endif /* defined(OS_INCLUDE_RTOS_STATISTICS_THREAD_CONTEXT_SWITCHES) */
 
#if defined(OS_INCLUDE_RTOS_STATISTICS_THREAD_CPU_CYCLES)
 
os_statistics_duration_t
os_sched_stat_get_cpu_cycles (void)
{
  return static_cast<os_statistics_duration_t> (scheduler::statistics::cpu_cycles ());
}
 
#endif /* defined(OS_INCLUDE_RTOS_STATISTICS_THREAD_CPU_CYCLES) */
 
// ----------------------------------------------------------------------------
 
bool
os_irq_in_handler_mode (void)
{
  return interrupts::in_handler_mode ();
}
 
// ----------------------------------------------------------------------------
 
os_irq_state_t
os_irq_critical_enter (void)
{
  return interrupts::critical_section::enter ();
}
 
void
os_irq_critical_exit (os_irq_state_t state)
{
  interrupts::critical_section::exit (state);
}
 
// ----------------------------------------------------------------------------
 
os_irq_state_t
os_irq_uncritical_enter (void)
{
  return interrupts::uncritical_section::enter ();
}
 
void
os_irq_uncritical_exit (os_irq_state_t state)
{
  interrupts::uncritical_section::exit (state);
}
 
#if defined(OS_HAS_INTERRUPTS_STACK) || defined(__DOXYGEN__)
 
os_thread_stack_t*
os_irq_get_stack (void)
  {
    return reinterpret_cast<os_thread_stack_t*> (rtos::interrupts::stack ());
  }
 
#endif
 
// ----------------------------------------------------------------------------
 
os_thread_t*
os_this_thread (void)
{
  return (os_thread_t*) &this_thread::thread ();
}
 
void
os_this_thread_suspend (void)
{
  return this_thread::suspend ();
}
 
void
os_this_thread_exit (void* exit_ptr)
{
  this_thread::exit (exit_ptr);
}
 
os_result_t
os_this_thread_flags_wait (os_flags_mask_t mask, os_flags_mask_t* oflags,
                           os_flags_mode_t mode)
{
  return (os_result_t) this_thread::flags_wait (mask, oflags, mode);
}
 
os_result_t
os_this_thread_flags_try_wait (os_flags_mask_t mask, os_flags_mask_t* oflags,
                               os_flags_mode_t mode)
{
  return (os_result_t) this_thread::flags_try_wait (mask, oflags, mode);
}
 
os_result_t
os_this_thread_flags_timed_wait (os_flags_mask_t mask,
                                 os_clock_duration_t timeout,
                                 os_flags_mask_t* oflags, os_flags_mode_t mode)
{
  return (os_result_t) this_thread::flags_timed_wait (mask, timeout, oflags,
                                                      mode);
}
 
os_result_t
os_this_thread_flags_clear (os_flags_mask_t mask, os_flags_mask_t* oflags)
{
  return (os_result_t) this_thread::flags_clear (mask, oflags);
}
 
os_flags_mask_t
os_this_thread_flags_get (os_flags_mask_t mask, os_flags_mode_t mode)
{
  return (os_flags_mask_t) this_thread::flags_get (mask, mode);
}
 
// ----------------------------------------------------------------------------
 
void
os_thread_attr_init (os_thread_attr_t* attr)
{
  assert (attr != nullptr);
  new (attr) thread::attributes ();
}
 
void
os_thread_construct (os_thread_t* thread, const char* name,
                     os_thread_func_t func, const os_thread_func_args_t args,
                     const os_thread_attr_t* attr)
{
  assert (thread != nullptr);
  if (attr == nullptr)
    {
      attr = (const os_thread_attr_t*) &thread::initializer;
    }
  new (thread) rtos::thread (name, (thread::func_t) func,
                             (thread::func_args_t) args,
                             (const thread::attributes&) *attr);
}
 
void
os_thread_destruct (os_thread_t* thread)
{
  assert (thread != nullptr);
  (reinterpret_cast<rtos::thread&> (*thread)).~thread ();
}
 
os_thread_t*
os_thread_new (const char* name, os_thread_func_t func,
               const os_thread_func_args_t args, const os_thread_attr_t* attr)
{
  if (attr == nullptr)
    {
      attr = (const os_thread_attr_t*) &thread::initializer;
    }
  return reinterpret_cast<os_thread_t*> (new rtos::thread (
      name, (thread::func_t) func, (thread::func_args_t) args,
      (const thread::attributes&) *attr));
}
 
void
os_thread_delete (os_thread_t* thread)
{
  assert (thread != nullptr);
  delete reinterpret_cast<rtos::thread*> (thread);
}
 
bool
os_thread_is_constructed (os_thread_t* thread)
{
  assert (thread != nullptr);
  return rtos::thread::is_constructed(
    reinterpret_cast<rtos::thread&> (*thread));
}
 
const char*
os_thread_get_name (os_thread_t* thread)
{
  assert (thread != nullptr);
  return (reinterpret_cast<rtos::thread&> (*thread)).name ();
}
 
os_thread_prio_t
os_thread_get_priority (os_thread_t* thread)
{
  assert (thread != nullptr);
  return (os_thread_prio_t) (reinterpret_cast<rtos::thread&> (*thread)).priority ();
}
 
os_result_t
os_thread_set_priority (os_thread_t* thread, os_thread_prio_t prio)
{
  assert (thread != nullptr);
  return (os_result_t) (reinterpret_cast<rtos::thread&> (*thread)).priority (
      prio);
}
 
os_result_t
os_thread_kill (os_thread_t* thread)
{
  assert (thread != nullptr);
  return (os_result_t) reinterpret_cast<rtos::thread&> (*thread).kill ();
}
 
os_result_t
os_thread_join (os_thread_t* thread, void** exit_ptr)
{
  assert (thread != nullptr);
  return (os_result_t) reinterpret_cast<rtos::thread&> (*thread).join (exit_ptr);
}
 
void
os_thread_resume (os_thread_t* thread)
{
  assert (thread != nullptr);
  return (reinterpret_cast<rtos::thread&> (*thread)).resume ();
}
 
os_result_t
os_thread_flags_raise (os_thread_t* thread, os_flags_mask_t mask,
                       os_flags_mask_t* oflags)
{
  assert (thread != nullptr);
  return (os_result_t) (reinterpret_cast<rtos::thread&> (*thread)).flags_raise (
      mask, oflags);
}
 
os_thread_state_t
os_thread_get_state (os_thread_t* thread)
{
  assert (thread != nullptr);
  return reinterpret_cast<os_thread_state_t> ((reinterpret_cast<rtos::thread&> (*thread)).state ());
}
 
#if defined(OS_INCLUDE_RTOS_CUSTOM_THREAD_USER_STORAGE) || defined(__DOXYGEN__)
 
os_thread_user_storage_t*
os_thread_get_user_storage (os_thread_t* thread)
  {
    assert(thread != nullptr);
    return (reinterpret_cast<rtos::thread&> (*thread)).user_storage ();
  }
 
#endif /* defined(OS_INCLUDE_RTOS_CUSTOM_THREAD_USER_STORAGE) */
 
os_thread_stack_t*
os_thread_get_stack (os_thread_t* thread)
{
  assert (thread != nullptr);
  return reinterpret_cast<os_thread_stack_t*> (&(reinterpret_cast<rtos::thread&> (*thread)).stack ());
}
 
// ----------------------------------------------------------------------------
 
size_t
os_thread_stack_get_default_size (void)
{
  return thread::stack::default_size ();
}
 
size_t
os_thread_stack_set_default_size (size_t size_bytes)
{
  return thread::stack::default_size (size_bytes);
}
 
size_t
os_thread_stack_get_min_size (void)
{
  return thread::stack::min_size ();
}
 
size_t
os_thread_stack_set_min_size (size_t size_bytes)
{
  return thread::stack::min_size (size_bytes);
}
 
os_thread_stack_element_t*
os_thread_stack_get_bottom (os_thread_stack_t* stack)
{
  assert (stack != nullptr);
  return (reinterpret_cast<class rtos::thread::stack&> (*stack)).bottom ();
}
 
os_thread_stack_element_t*
os_thread_stack_get_top (os_thread_stack_t* stack)
{
  assert (stack != nullptr);
  return (reinterpret_cast<class rtos::thread::stack&> (*stack)).top ();
}
 
size_t
os_thread_stack_get_size (os_thread_stack_t* stack)
{
  assert (stack != nullptr);
  return (reinterpret_cast<class rtos::thread::stack&> (*stack)).size ();
}
 
size_t
os_thread_stack_get_available (os_thread_stack_t* stack)
{
  assert (stack != nullptr);
  return (reinterpret_cast<class rtos::thread::stack&> (*stack)).available ();
}
 
bool
os_thread_stack_check_bottom_magic (os_thread_stack_t* stack)
{
  assert (stack != nullptr);
  return (reinterpret_cast<class rtos::thread::stack&> (*stack)).check_bottom_magic ();
}
 
bool
os_thread_stack_check_top_magic (os_thread_stack_t* stack)
{
  assert (stack != nullptr);
  return (reinterpret_cast<class rtos::thread::stack&> (*stack)).check_top_magic ();
}
 
// ----------------------------------------------------------------------------
 
#if defined(OS_INCLUDE_RTOS_STATISTICS_THREAD_CONTEXT_SWITCHES)
 
os_statistics_counter_t
os_thread_stat_get_context_switches (os_thread_t* thread)
{
  assert (thread != nullptr);
  return static_cast<os_statistics_counter_t> ((reinterpret_cast<rtos::thread&> (*thread)).statistics ().context_switches ());
}
 
#endif /* defined(OS_INCLUDE_RTOS_STATISTICS_THREAD_CONTEXT_SWITCHES) */
 
#if defined(OS_INCLUDE_RTOS_STATISTICS_THREAD_CPU_CYCLES)
 
os_statistics_duration_t
os_thread_stat_get_cpu_cycles (os_thread_t* thread)
{
  assert (thread != nullptr);
  return static_cast<os_statistics_duration_t> ((reinterpret_cast<rtos::thread&> (*thread)).statistics ().cpu_cycles ());
}
 
#endif /* defined(OS_INCLUDE_RTOS_STATISTICS_THREAD_CPU_CYCLES) */
 
// ----------------------------------------------------------------------------
 
os_iterator_t
os_children_threads_iter_begin (os_thread_t* thread)
{
  return reinterpret_cast<os_iterator_t> (scheduler::children_threads (
      reinterpret_cast<rtos::thread*> (thread)).begin ().get_iterator_pointer ());
}
 
os_iterator_t
os_children_threads_iter_end (os_thread_t* thread)
{
  return reinterpret_cast<os_iterator_t> (scheduler::children_threads (
      reinterpret_cast<rtos::thread*> (thread)).end ().get_iterator_pointer ());
}
 
os_thread_t*
os_children_threads_iter_get (os_iterator_t iterator)
{
  // Construct a local iterator object based on the pointer.
  thread::threads_list::iterator it
    { reinterpret_cast<utils::double_list_links*> (iterator) };
  return reinterpret_cast<os_thread_t*> (&(*it));
}
 
os_iterator_t
os_children_threads_iter_next (os_iterator_t iterator)
{
  thread::threads_list::iterator it
    { reinterpret_cast<utils::double_list_links*> (iterator) };
  ++it;
 
  return reinterpret_cast<os_iterator_t> (it.get_iterator_pointer ());
}
 
// ----------------------------------------------------------------------------
 
const char*
os_clock_get_name (os_clock_t* clock)
{
  assert (clock != nullptr);
  return (reinterpret_cast<rtos::clock&> (*clock)).name ();
}
 
os_clock_timestamp_t
os_clock_now (os_clock_t* clock)
{
  assert (clock != nullptr);
  return (os_clock_timestamp_t) (reinterpret_cast<rtos::clock&> (*clock)).now ();
}
 
os_clock_timestamp_t
os_clock_steady_now (os_clock_t* clock)
{
  assert (clock != nullptr);
  return (os_clock_timestamp_t) (reinterpret_cast<rtos::clock&> (*clock)).steady_now ();
}
 
os_result_t
os_clock_sleep_for (os_clock_t* clock, os_clock_duration_t duration)
{
  assert (clock != nullptr);
  return (os_result_t) (reinterpret_cast<rtos::clock&> (*clock)).sleep_for (
      duration);
}
 
os_result_t
os_clock_sleep_until (os_clock_t* clock, os_clock_timestamp_t timestamp)
{
  assert (clock != nullptr);
  return (os_result_t) (reinterpret_cast<rtos::clock&> (*clock)).sleep_until (
      timestamp);
}
 
os_result_t
os_clock_wait_for (os_clock_t* clock, os_clock_duration_t timeout)
{
  assert (clock != nullptr);
  return (os_result_t) (reinterpret_cast<rtos::clock&> (*clock)).wait_for (
      timeout);
}
 
os_clock_offset_t
os_clock_get_offset (os_clock_t* clock)
{
  assert (clock != nullptr);
  return (os_clock_offset_t) (reinterpret_cast<rtos::clock&> (*clock)).offset ();
 
}
 
os_clock_offset_t
os_clock_set_offset (os_clock_t* clock, os_clock_offset_t offset)
{
  assert (clock != nullptr);
  assert (clock != nullptr);
  return (os_clock_offset_t) (reinterpret_cast<rtos::clock&> (*clock)).offset (
      (clock::offset_t) offset);
 
}
 
os_clock_t*
os_clock_get_sysclock (void)
{
  return (os_clock_t*) &sysclock;
}
 
os_clock_t*
os_clock_get_rtclock (void)
{
  return (os_clock_t*) &rtclock;
}
 
os_clock_t*
os_clock_get_hrclock (void)
{
  return (os_clock_t*) &hrclock;
}
 
// ----------------------------------------------------------------------------
 
os_clock_timestamp_t
os_sysclock_now (void)
{
  return (os_clock_timestamp_t) sysclock.now ();
}
 
os_result_t
os_sysclock_sleep_for (os_clock_duration_t duration)
{
  return (os_result_t) sysclock.sleep_for (duration);
}
 
os_result_t
os_sysclock_sleep_until (os_clock_timestamp_t timestamp)
{
  return (os_result_t) sysclock.sleep_until (timestamp);
}
 
os_result_t
os_sysclock_wait_for (os_clock_duration_t timeout)
{
  return (os_result_t) sysclock.wait_for (timeout);
}
 
// ----------------------------------------------------------------------------
 
void
os_timer_attr_init (os_timer_attr_t* attr)
{
  assert (attr != nullptr);
  new (attr) timer::attributes ();
}
 
void
os_timer_attr_periodic_init (os_timer_attr_t* attr)
{
  assert (attr != nullptr);
  new (attr) timer::attributes_periodic ();
}
 
const os_timer_attr_t*
os_timer_attr_get_periodic (void)
{
  return (const os_timer_attr_t*) &timer::periodic_initializer;
}
 
void
os_timer_construct (os_timer_t* timer, const char* name,
                    os_timer_func_t function, os_timer_func_args_t args,
                    const os_timer_attr_t* attr)
{
  assert (timer != nullptr);
  if (attr == nullptr)
    {
      attr = (const os_timer_attr_t*) &timer::periodic_initializer;
    }
  new (timer) rtos::timer (name, (timer::func_t) function,
                           (timer::func_args_t) args,
                           (const timer::attributes&) *attr);
}
 
void
os_timer_destruct (os_timer_t* timer)
{
  assert (timer != nullptr);
  (reinterpret_cast<rtos::timer&> (*timer)).~timer ();
}
 
os_timer_t*
os_timer_new (const char* name, os_timer_func_t function,
              os_timer_func_args_t args, const os_timer_attr_t* attr)
{
  if (attr == nullptr)
    {
      attr = (const os_timer_attr_t*) &timer::periodic_initializer;
    }
  return reinterpret_cast<os_timer_t*> (new rtos::timer (
      name, (timer::func_t) function, (timer::func_args_t) args,
      (const timer::attributes&) *attr));
}
 
void
os_timer_delete (os_timer_t* timer)
{
  assert (timer != nullptr);
  delete reinterpret_cast<rtos::timer*> (timer);
}
 
const char*
os_timer_get_name (os_timer_t* timer)
{
  assert (timer != nullptr);
  return (reinterpret_cast<rtos::timer&> (*timer)).name ();
}
 
os_result_t
os_timer_start (os_timer_t* timer, os_clock_duration_t period)
{
  assert (timer != nullptr);
  return (os_result_t) (reinterpret_cast<rtos::timer&> (*timer)).start (period);
}
 
os_result_t
os_timer_stop (os_timer_t* timer)
{
  assert (timer != nullptr);
  return (os_result_t) (reinterpret_cast<rtos::timer&> (*timer)).stop ();
}
 
// ----------------------------------------------------------------------------
 
void
os_mutex_attr_init (os_mutex_attr_t* attr)
{
  assert (attr != nullptr);
  new (attr) mutex::attributes ();
}
 
void
os_mutex_attr_recursive_init (os_mutex_attr_t* attr)
{
  assert (attr != nullptr);
  new (attr) mutex::attributes_recursive ();
}
 
const os_mutex_attr_t*
os_mutex_attr_get_recursive (void)
{
  return (const os_mutex_attr_t*) &mutex::initializer_recursive;
}
 
void
os_mutex_construct (os_mutex_t* mutex, const char* name,
                    const os_mutex_attr_t* attr)
{
  assert (mutex != nullptr);
  if (attr == nullptr)
    {
      attr = (const os_mutex_attr_t*) &mutex::initializer_normal;
    }
  new (mutex) rtos::mutex (name, (const mutex::attributes&) *attr);
}
 
void
os_mutex_recursive_construct (os_mutex_t* mutex, const char* name,
                              const os_mutex_attr_t* attr)
{
  assert (mutex != nullptr);
  if (attr == nullptr)
    {
      attr = (const os_mutex_attr_t*) &mutex::initializer_recursive;
    }
  new (mutex) rtos::mutex_recursive (name, (const mutex::attributes&) *attr);
}
 
void
os_mutex_destruct (os_mutex_t* mutex)
{
  assert (mutex != nullptr);
  (reinterpret_cast<rtos::mutex&> (*mutex)).~mutex ();
}
 
os_mutex_t*
os_mutex_new (const char* name, const os_mutex_attr_t* attr)
{
  if (attr == nullptr)
    {
      attr = (const os_mutex_attr_t*) &mutex::initializer_normal;
    }
  return reinterpret_cast<os_mutex_t*> (new rtos::mutex (
      name, (const mutex::attributes&) *attr));
}
 
os_mutex_t*
os_mutex_recursive_new (const char* name, const os_mutex_attr_t* attr)
{
  if (attr == nullptr)
    {
      attr = (const os_mutex_attr_t*) &mutex::initializer_recursive;
    }
  return reinterpret_cast<os_mutex_t*> (new rtos::mutex_recursive (
      name, (const mutex::attributes&) *attr));
}
 
void
os_mutex_delete (os_mutex_t* mutex)
{
  assert (mutex != nullptr);
  delete reinterpret_cast<rtos::mutex*> (mutex);
}
 
const char*
os_mutex_get_name (os_mutex_t* mutex)
{
  assert (mutex != nullptr);
  return (reinterpret_cast<rtos::mutex&> (*mutex)).name ();
}
 
os_result_t
os_mutex_lock (os_mutex_t* mutex)
{
  assert (mutex != nullptr);
  return (os_result_t) (reinterpret_cast<rtos::mutex&> (*mutex)).lock ();
}
 
os_result_t
os_mutex_try_lock (os_mutex_t* mutex)
{
  assert (mutex != nullptr);
  return (os_result_t) (reinterpret_cast<rtos::mutex&> (*mutex)).try_lock ();
}
 
os_result_t
os_mutex_timed_lock (os_mutex_t* mutex, os_clock_duration_t timeout)
{
  assert (mutex != nullptr);
  return (os_result_t) (reinterpret_cast<rtos::mutex&> (*mutex)).timed_lock (
      timeout);
}
 
os_result_t
os_mutex_unlock (os_mutex_t* mutex)
{
  assert (mutex != nullptr);
  return (os_result_t) (reinterpret_cast<rtos::mutex&> (*mutex)).unlock ();
}
 
os_thread_prio_t
os_mutex_get_prio_ceiling (os_mutex_t* mutex)
{
  assert (mutex != nullptr);
  return (os_thread_prio_t) (reinterpret_cast<rtos::mutex&> (*mutex)).prio_ceiling ();
}
 
os_result_t
os_mutex_set_prio_ceiling (os_mutex_t* mutex, os_thread_prio_t prio_ceiling,
                           os_thread_prio_t* old_prio_ceiling)
{
  assert (mutex != nullptr);
  return (os_result_t) (reinterpret_cast<rtos::mutex&> (*mutex)).prio_ceiling (
      prio_ceiling, old_prio_ceiling);
}
 
os_result_t
os_mutex_mark_consistent (os_mutex_t* mutex)
{
  assert (mutex != nullptr);
  return (os_result_t) (reinterpret_cast<rtos::mutex&> (*mutex)).consistent ();
}
 
os_thread_t*
os_mutex_get_owner (os_mutex_t* mutex)
{
  assert (mutex != nullptr);
  return (os_thread_t*) (reinterpret_cast<rtos::mutex&> (*mutex)).owner ();
}
 
os_mutex_type_t
os_mutex_get_type (os_mutex_t* mutex)
{
  assert (mutex != nullptr);
  return (reinterpret_cast<rtos::mutex&> (*mutex)).type ();
}
 
os_mutex_protocol_t
os_mutex_get_protocol (os_mutex_t* mutex)
{
  assert (mutex != nullptr);
  return (reinterpret_cast<rtos::mutex&> (*mutex)).protocol ();
}
 
os_mutex_robustness_t
os_mutex_get_robustness (os_mutex_t* mutex)
{
  assert (mutex != nullptr);
  return (reinterpret_cast<rtos::mutex&> (*mutex)).robustness ();
}
 
os_result_t
os_mutex_reset (os_mutex_t* mutex)
{
  assert (mutex != nullptr);
  return (os_result_t) (reinterpret_cast<rtos::mutex&> (*mutex)).reset ();
}
 
// ----------------------------------------------------------------------------
 
void
os_condvar_attr_init (os_condvar_attr_t* attr)
{
  assert (attr != nullptr);
  new (attr) condition_variable::attributes ();
}
 
void
os_condvar_construct (os_condvar_t* condvar, const char* name,
                      const os_condvar_attr_t* attr)
{
  assert (condvar != nullptr);
  if (attr == nullptr)
    {
      attr = (const os_condvar_attr_t*) &condition_variable::initializer;
    }
  new (condvar) condition_variable (name,
                                    (const condition_variable::attributes&) *attr);
}
 
void
os_condvar_destruct (os_condvar_t* condvar)
{
  assert (condvar != nullptr);
  (reinterpret_cast<condition_variable&> (*condvar)).~condition_variable ();
}
 
os_condvar_t*
os_condvar_new (const char* name, const os_condvar_attr_t* attr)
{
  if (attr == nullptr)
    {
      attr = (const os_condvar_attr_t*) &condition_variable::initializer;
    }
  return reinterpret_cast<os_condvar_t*> (new condition_variable (
      name, (const condition_variable::attributes&) *attr));
}
 
void
os_condvar_delete (os_condvar_t* condvar)
{
  assert (condvar != nullptr);
  delete reinterpret_cast<condition_variable*> (condvar);
}
 
const char*
os_condvar_get_name (os_condvar_t* condvar)
{
  assert (condvar != nullptr);
  return (reinterpret_cast<condition_variable&> (*condvar)).name ();
}
 
os_result_t
os_condvar_signal (os_condvar_t* condvar)
{
  assert (condvar != nullptr);
  return (os_result_t) (reinterpret_cast<condition_variable&> (*condvar)).signal ();
}
 
os_result_t
os_condvar_broadcast (os_condvar_t* condvar)
{
  assert (condvar != nullptr);
  return (os_result_t) (reinterpret_cast<condition_variable&> (*condvar)).broadcast ();
}
 
os_result_t
os_condvar_wait (os_condvar_t* condvar, os_mutex_t* mutex)
{
  assert (condvar != nullptr);
  return (os_result_t) (reinterpret_cast<condition_variable&> (*condvar)).wait (
      reinterpret_cast<rtos::mutex&> (*mutex));
}
 
os_result_t
os_condvar_timed_wait (os_condvar_t* condvar, os_mutex_t* mutex,
                       os_clock_duration_t timeout)
{
  assert (condvar != nullptr);
  return (os_result_t) (reinterpret_cast<condition_variable&> (*condvar)).timed_wait (
      reinterpret_cast<rtos::mutex&> (*mutex), timeout);
}
 
// ----------------------------------------------------------------------------
 
void
os_semaphore_attr_init (os_semaphore_attr_t* attr)
{
  assert (attr != nullptr);
  new (attr) semaphore::attributes
    { };
}
 
void
os_semaphore_attr_binary_init (os_semaphore_attr_t* attr,
                               const os_semaphore_count_t initial_value)
{
  assert (attr != nullptr);
  new (attr) semaphore::attributes_binary
    { initial_value };
}
 
void
os_semaphore_attr_counting_init (os_semaphore_attr_t* attr,
                                 const os_semaphore_count_t max_value,
                                 const os_semaphore_count_t initial_value)
{
  assert (attr != nullptr);
  new (attr) semaphore::attributes_counting
    { max_value, initial_value };
}
 
const os_semaphore_attr_t*
os_semaphore_attr_get_binary (void)
{
  return (const os_semaphore_attr_t*) &semaphore::initializer_binary;
}
 
void
os_semaphore_construct (os_semaphore_t* semaphore, const char* name,
                        const os_semaphore_attr_t* attr)
{
  assert (semaphore != nullptr);
  if (attr == nullptr)
    {
      attr = (const os_semaphore_attr_t*) &semaphore::initializer_binary;
    }
  new (semaphore) rtos::semaphore
    { name, (const semaphore::attributes&) *attr };
}
 
void
os_semaphore_binary_construct (os_semaphore_t* semaphore, const char* name,
                               const os_semaphore_count_t initial_value)
{
  assert (semaphore != nullptr);
  new (semaphore) rtos::semaphore_binary
    { name, initial_value };
}
 
void
os_semaphore_counting_construct (os_semaphore_t* semaphore, const char* name,
                                 const os_semaphore_count_t max_value,
                                 const os_semaphore_count_t initial_value)
{
  assert (semaphore != nullptr);
  new (semaphore) rtos::semaphore_counting
    { name, max_value, initial_value };
}
 
void
os_semaphore_destruct (os_semaphore_t* semaphore)
{
  assert (semaphore != nullptr);
  (reinterpret_cast<rtos::semaphore&> (*semaphore)).~semaphore ();
}
 
os_semaphore_t*
os_semaphore_new (const char* name, const os_semaphore_attr_t* attr)
{
  if (attr == nullptr)
    {
      attr = (const os_semaphore_attr_t*) &semaphore::initializer_binary;
    }
  return reinterpret_cast<os_semaphore_t*> (new rtos::semaphore
    { name, (const semaphore::attributes&) *attr });
}
 
os_semaphore_t*
os_semaphore_binary_new (const char* name,
                         const os_semaphore_count_t initial_value)
{
  return reinterpret_cast<os_semaphore_t*> (new rtos::semaphore_binary
    { name, initial_value });
}
 
os_semaphore_t*
os_semaphore_counting_new (const char* name,
                           const os_semaphore_count_t max_value,
                           const os_semaphore_count_t initial_value)
{
  return reinterpret_cast<os_semaphore_t*> (new rtos::semaphore_counting
    { name, max_value, initial_value });
}
 
void
os_semaphore_delete (os_semaphore_t* semaphore)
{
  assert (semaphore != nullptr);
  delete reinterpret_cast<rtos::semaphore*> (semaphore);
}
 
const char*
os_semaphore_get_name (os_semaphore_t* semaphore)
{
  assert (semaphore != nullptr);
  return (reinterpret_cast<rtos::semaphore&> (*semaphore)).name ();
}
 
os_result_t
os_semaphore_post (os_semaphore_t* semaphore)
{
  assert (semaphore != nullptr);
  return (os_result_t) (reinterpret_cast<rtos::semaphore&> (*semaphore)).post ();
}
 
os_result_t
os_semaphore_wait (os_semaphore_t* semaphore)
{
  assert (semaphore != nullptr);
  return (os_result_t) (reinterpret_cast<rtos::semaphore&> (*semaphore)).wait ();
}
 
os_result_t
os_semaphore_try_wait (os_semaphore_t* semaphore)
{
  assert (semaphore != nullptr);
  return (os_result_t) (reinterpret_cast<rtos::semaphore&> (*semaphore)).try_wait ();
}
 
os_result_t
os_semaphore_timed_wait (os_semaphore_t* semaphore, os_clock_duration_t timeout)
{
  assert (semaphore != nullptr);
  return (os_result_t) (reinterpret_cast<rtos::semaphore&> (*semaphore)).timed_wait (
      timeout);
}
 
os_semaphore_count_t
os_semaphore_get_value (os_semaphore_t* semaphore)
{
  assert (semaphore != nullptr);
  return (os_semaphore_count_t) (reinterpret_cast<rtos::semaphore&> (*semaphore)).value ();
}
 
os_result_t
os_semaphore_reset (os_semaphore_t* semaphore)
{
  assert (semaphore != nullptr);
  return (os_result_t) (reinterpret_cast<rtos::semaphore&> (*semaphore)).reset ();
}
 
os_semaphore_count_t
os_semaphore_get_initial_value (os_semaphore_t* semaphore)
{
  assert (semaphore != nullptr);
  return (os_semaphore_count_t) (reinterpret_cast<rtos::semaphore&> (*semaphore)).initial_value ();
}
 
os_semaphore_count_t
os_semaphore_get_max_value (os_semaphore_t* semaphore)
{
  assert (semaphore != nullptr);
  return (os_semaphore_count_t) (reinterpret_cast<rtos::semaphore&> (*semaphore)).max_value ();
}
 
// ----------------------------------------------------------------------------
 
void
os_mempool_attr_init (os_mempool_attr_t* attr)
{
  assert (attr != nullptr);
  new (attr) memory_pool::attributes ();
}
 
void
os_mempool_construct (os_mempool_t* mempool, const char* name, size_t blocks,
                      size_t block_size_bytes, const os_mempool_attr_t* attr)
{
  assert (mempool != nullptr);
  if (attr == nullptr)
    {
      attr = (const os_mempool_attr_t*) &memory_pool::initializer;
    }
  new (mempool) memory_pool (name, blocks, block_size_bytes,
                             (const memory_pool::attributes&) *attr);
}
 
void
os_mempool_destruct (os_mempool_t* mempool)
{
  assert (mempool != nullptr);
  (reinterpret_cast<memory_pool&> (*mempool)).~memory_pool ();
}
 
os_mempool_t*
os_mempool_new (const char* name, size_t blocks, size_t block_size_bytes,
                const os_mempool_attr_t* attr)
{
  if (attr == nullptr)
    {
      attr = (const os_mempool_attr_t*) &memory_pool::initializer;
    }
  return reinterpret_cast<os_mempool_t*> (new memory_pool (
      name, blocks, block_size_bytes, (const memory_pool::attributes&) *attr));
}
 
void
os_mempool_delete (os_mempool_t* mempool)
{
  assert (mempool != nullptr);
  delete reinterpret_cast<memory_pool*> (mempool);
}
 
const char*
os_mempool_get_name (os_mempool_t* mempool)
{
  assert (mempool != nullptr);
  return (reinterpret_cast<memory_pool&> (*mempool)).name ();
}
 
void*
os_mempool_alloc (os_mempool_t* mempool)
{
  assert (mempool != nullptr);
  return (reinterpret_cast<memory_pool&> (*mempool)).alloc ();
}
 
void*
os_mempool_try_alloc (os_mempool_t* mempool)
{
  assert (mempool != nullptr);
  return (reinterpret_cast<memory_pool&> (*mempool)).try_alloc ();
}
 
void*
os_mempool_timed_alloc (os_mempool_t* mempool, os_clock_duration_t timeout)
{
  assert (mempool != nullptr);
  return (reinterpret_cast<memory_pool&> (*mempool)).timed_alloc (timeout);
}
 
os_result_t
os_mempool_free (os_mempool_t* mempool, void* block)
{
  assert (mempool != nullptr);
  return (os_result_t) (reinterpret_cast<memory_pool&> (*mempool)).free (block);
}
 
size_t
os_mempool_get_capacity (os_mempool_t* mempool)
{
  assert (mempool != nullptr);
  return (reinterpret_cast<memory_pool&> (*mempool)).capacity ();
}
 
size_t
os_mempool_get_count (os_mempool_t* mempool)
{
  assert (mempool != nullptr);
  return (reinterpret_cast<memory_pool&> (*mempool)).count ();
}
 
size_t
os_mempool_get_block_size (os_mempool_t* mempool)
{
  assert (mempool != nullptr);
  return (reinterpret_cast<memory_pool&> (*mempool)).block_size ();
}
 
bool
os_mempool_is_empty (os_mempool_t* mempool)
{
  assert (mempool != nullptr);
  return (reinterpret_cast<memory_pool&> (*mempool)).empty ();
}
 
bool
os_mempool_is_full (os_mempool_t* mempool)
{
  assert (mempool != nullptr);
  return (reinterpret_cast<memory_pool&> (*mempool)).full ();
}
 
os_result_t
os_mempool_reset (os_mempool_t* mempool)
{
  assert (mempool != nullptr);
  return (os_result_t) (reinterpret_cast<memory_pool&> (*mempool)).reset ();
}
 
void*
os_mempool_get_pool (os_mempool_t* mempool)
{
  assert (mempool != nullptr);
  return (void*) (reinterpret_cast<memory_pool&> (*mempool)).pool ();
}
 
// --------------------------------------------------------------------------
 
void
os_mqueue_attr_init (os_mqueue_attr_t* attr)
{
  assert (attr != nullptr);
  new (attr) message_queue::attributes ();
}
 
void
os_mqueue_construct (os_mqueue_t* mqueue, const char* name, size_t msgs,
                     size_t msg_size_bytes, const os_mqueue_attr_t* attr)
{
  assert (mqueue != nullptr);
  if (attr == nullptr)
    {
      attr = (const os_mqueue_attr_t*) &message_queue::initializer;
    }
  new (mqueue) message_queue (name, msgs, msg_size_bytes,
                              (const message_queue::attributes&) *attr);
}
 
void
os_mqueue_destruct (os_mqueue_t* mqueue)
{
  assert (mqueue != nullptr);
  (reinterpret_cast<message_queue&> (*mqueue)).~message_queue ();
}
 
os_mqueue_t*
os_mqueue_new (const char* name, size_t msgs, size_t msg_size_bytes,
               const os_mqueue_attr_t* attr)
{
  if (attr == nullptr)
    {
      attr = (const os_mqueue_attr_t*) &message_queue::initializer;
    }
  return reinterpret_cast<os_mqueue_t*> (new message_queue (
      name, msgs, msg_size_bytes, (const message_queue::attributes&) *attr));
}
 
void
os_mqueue_delete (os_mqueue_t* mqueue)
{
  assert (mqueue != nullptr);
  delete reinterpret_cast<message_queue*> (mqueue);
}
 
const char*
os_mqueue_get_name (os_mqueue_t* mqueue)
{
  assert (mqueue != nullptr);
  return (reinterpret_cast<message_queue&> (*mqueue)).name ();
}
 
os_result_t
os_mqueue_send (os_mqueue_t* mqueue, const void* msg, size_t nbytes,
                os_mqueue_prio_t mprio)
{
  assert (mqueue != nullptr);
  return (os_result_t) (reinterpret_cast<message_queue&> (*mqueue)).send (
      msg, nbytes, mprio);
}
 
os_result_t
os_mqueue_try_send (os_mqueue_t* mqueue, const void* msg, size_t nbytes,
                    os_mqueue_prio_t mprio)
{
  assert (mqueue != nullptr);
  return (os_result_t) (reinterpret_cast<message_queue&> (*mqueue)).try_send (
      msg, nbytes, mprio);
}
 
os_result_t
os_mqueue_timed_send (os_mqueue_t* mqueue, const void* msg, size_t nbytes,
                      os_clock_duration_t timeout, os_mqueue_prio_t mprio)
{
  assert (mqueue != nullptr);
  return (os_result_t) (reinterpret_cast<message_queue&> (*mqueue)).timed_send (
      msg, nbytes, timeout, mprio);
}
 
os_result_t
os_mqueue_receive (os_mqueue_t* mqueue, void* msg, size_t nbytes,
                   os_mqueue_prio_t* mprio)
{
  assert (mqueue != nullptr);
  return (os_result_t) (reinterpret_cast<message_queue&> (*mqueue)).receive (
      msg, nbytes, mprio);
}
 
os_result_t
os_mqueue_try_receive (os_mqueue_t* mqueue, void* msg, size_t nbytes,
                       os_mqueue_prio_t* mprio)
{
  assert (mqueue != nullptr);
  return (os_result_t) (reinterpret_cast<message_queue&> (*mqueue)).try_receive (
      msg, nbytes, mprio);
}
 
os_result_t
os_mqueue_timed_receive (os_mqueue_t* mqueue, void* msg, size_t nbytes,
                         os_clock_duration_t timeout, os_mqueue_prio_t* mprio)
{
  assert (mqueue != nullptr);
  return (os_result_t) (reinterpret_cast<message_queue&> (*mqueue)).timed_receive (
      msg, nbytes, timeout, mprio);
}
 
size_t
os_mqueue_get_length (os_mqueue_t* mqueue)
{
  assert (mqueue != nullptr);
  return (reinterpret_cast<message_queue&> (*mqueue)).length ();
}
 
size_t
os_mqueue_get_capacity (os_mqueue_t* mqueue)
{
  assert (mqueue != nullptr);
  return (reinterpret_cast<message_queue&> (*mqueue)).capacity ();
}
 
size_t
os_mqueue_get_msg_size (os_mqueue_t* mqueue)
{
  assert (mqueue != nullptr);
  return (reinterpret_cast<message_queue&> (*mqueue)).msg_size ();
}
 
bool
os_mqueue_is_empty (os_mqueue_t* mqueue)
{
  assert (mqueue != nullptr);
  return (reinterpret_cast<message_queue&> (*mqueue)).empty ();
}
 
bool
os_mqueue_is_full (os_mqueue_t* mqueue)
{
  assert (mqueue != nullptr);
  return (reinterpret_cast<message_queue&> (*mqueue)).full ();
}
 
os_result_t
os_mqueue_reset (os_mqueue_t* mqueue)
{
  assert (mqueue != nullptr);
  return (os_result_t) (reinterpret_cast<message_queue&> (*mqueue)).reset ();
}
 
// --------------------------------------------------------------------------
 
void
os_evflags_attr_init (os_evflags_attr_t* attr)
{
  assert (attr != nullptr);
  new (attr) event_flags::attributes ();
}
 
void
os_evflags_construct (os_evflags_t* evflags, const char* name,
                      const os_evflags_attr_t* attr)
{
  assert (evflags != nullptr);
  if (attr == nullptr)
    {
      attr = (const os_evflags_attr_t*) &event_flags::initializer;
    }
  new (evflags) event_flags (name, (const event_flags::attributes&) *attr);
}
 
void
os_evflags_destruct (os_evflags_t* evflags)
{
  assert (evflags != nullptr);
  (reinterpret_cast<event_flags&> (*evflags)).~event_flags ();
}
 
os_evflags_t*
os_evflags_new (const char* name, const os_evflags_attr_t* attr)
{
  if (attr == nullptr)
    {
      attr = (const os_evflags_attr_t*) &event_flags::initializer;
    }
  return reinterpret_cast<os_evflags_t*> (new event_flags (
      name, (const event_flags::attributes&) *attr));
}
 
void
os_evflags_delete (os_evflags_t* evflags)
{
  assert (evflags != nullptr);
  delete reinterpret_cast<event_flags*> (evflags);
}
 
const char*
os_evflags_get_name (os_evflags_t* evflags)
{
  assert (evflags != nullptr);
  return (reinterpret_cast<event_flags&> (*evflags)).name ();
}
 
os_result_t
os_evflags_wait (os_evflags_t* evflags, os_flags_mask_t mask,
                 os_flags_mask_t* oflags, os_flags_mode_t mode)
{
  assert (evflags != nullptr);
  return (os_result_t) (reinterpret_cast<event_flags&> (*evflags)).wait (mask,
                                                                         oflags,
                                                                         mode);
}
 
os_result_t
os_evflags_try_wait (os_evflags_t* evflags, os_flags_mask_t mask,
                     os_flags_mask_t* oflags, os_flags_mode_t mode)
{
  assert (evflags != nullptr);
  return (os_result_t) (reinterpret_cast<event_flags&> (*evflags)).try_wait (
      mask, oflags, mode);
}
 
os_result_t
os_evflags_timed_wait (os_evflags_t* evflags, os_flags_mask_t mask,
                       os_clock_duration_t timeout, os_flags_mask_t* oflags,
                       os_flags_mode_t mode)
{
  assert (evflags != nullptr);
  return (os_result_t) (reinterpret_cast<event_flags&> (*evflags)).timed_wait (
      mask, timeout, oflags, mode);
}
 
os_result_t
os_evflags_raise (os_evflags_t* evflags, os_flags_mask_t mask,
                  os_flags_mask_t* oflags)
{
  assert (evflags != nullptr);
  return (os_result_t) (reinterpret_cast<event_flags&> (*evflags)).raise (
      mask, oflags);
}
 
os_result_t
os_evflags_clear (os_evflags_t* evflags, os_flags_mask_t mask,
                  os_flags_mask_t* oflags)
{
  assert (evflags != nullptr);
  return (os_result_t) (reinterpret_cast<event_flags&> (*evflags)).clear (
      mask, oflags);
}
 
os_flags_mask_t
os_evflags_get (os_evflags_t* evflags, os_flags_mask_t mask,
                os_flags_mode_t mode)
{
  assert (evflags != nullptr);
  return (os_flags_mask_t) (reinterpret_cast<event_flags&> (*evflags)).get (
      mask, mode);
}
 
bool
os_evflags_are_waiting (os_evflags_t* evflags)
{
  assert (evflags != nullptr);
  return (reinterpret_cast<event_flags&> (*evflags)).waiting ();
}
 
// --------------------------------------------------------------------------
 
os_memory_t*
os_memory_get_default (void)
{
  return reinterpret_cast<os_memory_t*> (rtos::memory::get_default_resource ());
}
 
void*
os_memory_allocate (os_memory_t* memory, size_t bytes, size_t alignment)
{
  assert (memory != nullptr);
  return (reinterpret_cast<rtos::memory::memory_resource&> (*memory)).allocate (
      bytes, alignment);
}
 
void
os_memory_deallocate (os_memory_t* memory, void* addr, size_t bytes,
                      size_t alignment)
{
  assert (memory != nullptr);
  (reinterpret_cast<rtos::memory::memory_resource&> (*memory)).deallocate (
      addr, bytes, alignment);
}
 
void
os_memory_reset (os_memory_t* memory)
{
  assert (memory != nullptr);
  (reinterpret_cast<rtos::memory::memory_resource&> (*memory)).reset ();
}
 
bool
os_memory_coalesce (os_memory_t* memory)
{
  assert (memory != nullptr);
  return (reinterpret_cast<rtos::memory::memory_resource&> (*memory)).coalesce ();
}
 
size_t
os_memory_get_total_bytes (os_memory_t* memory)
{
  assert (memory != nullptr);
  return (reinterpret_cast<rtos::memory::memory_resource&> (*memory)).total_bytes ();
}
 
size_t
os_memory_get_allocated_bytes (os_memory_t* memory)
{
  assert (memory != nullptr);
  return (reinterpret_cast<rtos::memory::memory_resource&> (*memory)).allocated_bytes ();
}
 
size_t
os_memory_get_free_bytes (os_memory_t* memory)
{
  assert (memory != nullptr);
  return (reinterpret_cast<rtos::memory::memory_resource&> (*memory)).free_bytes ();
}
 
size_t
os_memory_get_allocated_chunks (os_memory_t* memory)
{
  assert (memory != nullptr);
  return (reinterpret_cast<rtos::memory::memory_resource&> (*memory)).allocated_chunks ();
}
 
size_t
os_memory_get_free_chunks (os_memory_t* memory)
{
  assert (memory != nullptr);
  return (reinterpret_cast<rtos::memory::memory_resource&> (*memory)).free_chunks ();
}
 
// ****************************************************************************
// ***** Legacy CMSIS RTOS implementation *****
 
#include <cmsis-plus/legacy/cmsis_os.h>
 
// ----------------------------------------------------------------------------
//  ==== Kernel Control Functions ====
 
osStatus
osKernelInitialize (void)
{
  if (interrupts::in_handler_mode ())
    {
      return osErrorISR;
    }
 
  scheduler::initialize ();
  return osOK;
}
 
osStatus
osKernelStart (void)
{
  scheduler::start ();
  // In µOS++ this does not return.
}
 
int32_t
osKernelRunning (void)
{
  return scheduler::started () ? 1 : 0;
}
 
#if (defined (osFeature_SysTick)  &&  (osFeature_SysTick != 0))
 
uint32_t
osKernelSysTick (void)
{
  // Get the current SysTick timestamp down to cpu cycles.
  return static_cast<uint32_t> (hrclock.now ());
}
 
#endif    // System Timer available
 
// ----------------------------------------------------------------------------
//  ==== Thread Management ====
 
osThreadId
osThreadCreate (const osThreadDef_t* thread_def, void* args)
{
  if (interrupts::in_handler_mode ())
    {
      return nullptr;
    }
 
  if (thread_def == nullptr)
    {
      return nullptr;
    }
 
  thread::attributes attr;
  attr.th_priority = thread_def->tpriority;
  attr.th_stack_size_bytes = thread_def->stacksize;
 
  // Creating thread with invalid priority should fail (validator requirement).
  if (thread_def->tpriority >= osPriorityError)
    {
      return nullptr;
    }
 
  // Find a free slot in the tread definitions array.
  for (uint32_t i = 0; i < thread_def->instances; ++i)
    {
      thread* th = (thread*) &thread_def->data[i];
      if (th->state () == thread::state::undefined
          || th->state () == thread::state::destroyed)
        {
          if (attr.th_stack_size_bytes > 0)
            {
              attr.th_stack_address = &thread_def->stack[(i)
                  * ((thread_def->stacksize + sizeof(uint64_t) - 1)
                      / sizeof(uint64_t))];
            }
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wcast-function-type"
          new (th) thread (thread_def->name,
                           reinterpret_cast<thread::func_t> (thread_def->pthread), args, attr);
#pragma GCC diagnostic pop
 
          // No need to yield here, already done by constructor.
          return reinterpret_cast<osThreadId> (th);
        }
    }
  return nullptr;
}
 
osThreadId
osThreadGetId (void)
{
  if (interrupts::in_handler_mode ())
    {
      return nullptr;
    }
 
  return reinterpret_cast<osThreadId> (&this_thread::thread ());
}
 
osStatus
osThreadTerminate (osThreadId thread_id)
{
  if (interrupts::in_handler_mode ())
    {
      return osErrorISR;
    }
 
  if (thread_id == nullptr)
    {
      return osErrorParameter;
    }
 
  thread::state_t state =
      (reinterpret_cast<rtos::thread&> (*thread_id)).state ();
  if (state == thread::state::undefined)
    {
      return osErrorResource;
    }
 
  if ((reinterpret_cast<thread*> (thread_id)) == &this_thread::thread ())
    {
      this_thread::exit ();
      /* NOTREACHED */
    }
  else
    {
      (reinterpret_cast<rtos::thread&> (*thread_id)).kill ();
    }
 
  return osOK;
}
 
osStatus
osThreadYield (void)
{
  if (interrupts::in_handler_mode ())
    {
      return osErrorISR;
    }
 
  this_thread::yield ();
 
  return osOK;
}
 
osStatus
osThreadSetPriority (osThreadId thread_id, osPriority priority)
{
  if (interrupts::in_handler_mode ())
    {
      return osErrorISR;
    }
 
  if (thread_id == nullptr)
    {
      return osErrorParameter;
    }
 
  thread::state_t state =
      (reinterpret_cast<rtos::thread&> (*thread_id)).state ();
  if (state == thread::state::undefined || state >= thread::state::destroyed)
    {
      return osErrorResource;
    }
 
  if (priority < osPriorityIdle || priority >= osPriorityError)
    {
      return osErrorValue;
    }
 
  // Call C++ mutator.
  thread::priority_t prio = static_cast<thread::priority_t> (priority);
  result_t res =
      ((reinterpret_cast<rtos::thread&> (*thread_id)).priority (prio));
 
  // A mandatory yield is needed here, must be done
  // by the implementation.
 
  if (res == result::ok)
    {
      return osOK;
    }
  else if (res == EINVAL)
    {
      return osErrorValue;
    }
  else
    {
      return osErrorOS;
    }
}
 
osPriority
osThreadGetPriority (osThreadId thread_id)
{
  if (interrupts::in_handler_mode ())
    {
      return osPriorityError;
    }
 
  if (thread_id == nullptr)
    {
      return osPriorityError;
    }
 
  // Call C++ accessor.
  thread::priority_t prio =
      (reinterpret_cast<rtos::thread&> (*thread_id)).priority ();
  return static_cast<osPriority> (prio);
}
 
// ----------------------------------------------------------------------------
//  ==== Generic Wait Functions ====
 
osStatus
osDelay (uint32_t millisec)
{
  if (interrupts::in_handler_mode ())
    {
      return osErrorISR;
    }
 
  result_t res = sysclock.sleep_for (
      clock_systick::ticks_cast ((uint64_t) (millisec * 1000u)));
 
  if (res == ETIMEDOUT)
    {
      return osEventTimeout;
    }
  else
    {
      return osErrorOS;
    }
}
 
#if (defined (osFeature_Wait)  &&  (osFeature_Wait != 0))
 
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Waggregate-return"
 
osEvent
osWait (uint32_t millisec)
{
  osEvent event;
 
  if (interrupts::in_handler_mode ())
    {
      event.status = osErrorISR;
      return event;
    }
 
  result_t res = sysclock.wait_for (
      clock_systick::ticks_cast ((uint64_t) (millisec * 1000u)));
 
  // TODO: return events
  if (res == ETIMEDOUT)
    {
      event.status = osEventTimeout;
    }
  else
    {
      event.status = osErrorOS;
    }
 
  return event;
}
 
#pragma GCC diagnostic pop
 
#endif  // Generic Wait available
 
// ----------------------------------------------------------------------------
//  ==== Timer Management Functions ====
 
osTimerId
osTimerCreate (const osTimerDef_t* timer_def, os_timer_type type, void* args)
{
  if (interrupts::in_handler_mode ())
    {
      return nullptr;
    }
 
  if (timer_def == nullptr)
    {
      return nullptr;
    }
 
  timer::attributes attr;
  attr.tm_type = (timer::type_t) type;
 
  new ((void*) timer_def->data) timer (timer_def->name,
                                       (timer::func_t) timer_def->ptimer,
                                       (timer::func_args_t) args, attr);
 
  return reinterpret_cast<osTimerId> (timer_def->data);
}
 
osStatus
osTimerStart (osTimerId timer_id, uint32_t millisec)
{
  if (interrupts::in_handler_mode ())
    {
      return osErrorISR;
    }
 
  if (timer_id == nullptr)
    {
      return osErrorParameter;
    }
 
  result_t res = (reinterpret_cast<rtos::timer&> (*timer_id)).start (
      clock_systick::ticks_cast ((uint64_t) (millisec * 1000u)));
 
  if (res == result::ok)
    {
      return osOK;
    }
  else
    {
      return osErrorOS;
    }
}
 
osStatus
osTimerStop (osTimerId timer_id)
{
  if (interrupts::in_handler_mode ())
    {
      return osErrorISR;
    }
 
  if (timer_id == nullptr)
    {
      return osErrorParameter;
    }
 
  result_t res = (reinterpret_cast<rtos::timer&> (*timer_id)).stop ();
  if (res == result::ok)
    {
      return osOK;
    }
  else if (res == EAGAIN)
    {
      return osErrorResource;
    }
  else
    {
      return osErrorOS;
    }
}
 
osStatus
osTimerDelete (osTimerId timer_id)
{
  if (interrupts::in_handler_mode ())
    {
      return osErrorISR;
    }
 
  if (timer_id == nullptr)
    {
      return osErrorParameter;
    }
 
  (reinterpret_cast<rtos::timer&> (*timer_id)).~timer ();
  return osOK;
}
 
// ----------------------------------------------------------------------------
//  ==== Signal Management ====
 
int32_t
osSignalSet (osThreadId thread_id, int32_t signals)
{
  if (thread_id == nullptr)
    {
      return (int32_t) 0x80000000;
    }
 
  if (signals == (int32_t) 0x80000000)
    {
      return (int32_t) 0x80000000;
    }
 
  flags::mask_t osig;
  ((thread*) (thread_id))->flags_raise ((flags::mask_t) signals, &osig);
  return (int32_t) osig;
}
 
int32_t
osSignalClear (osThreadId thread_id, int32_t signals)
{
  if (thread_id == nullptr)
    {
      return (int32_t) 0x80000000;
    }
 
  if (interrupts::in_handler_mode () || (signals == 0))
    {
      return (int32_t) 0x80000000;
    }
 
  flags::mask_t sig;
 
#if defined(OS_INCLUDE_RTOS_THREAD_PUBLIC_FLAGS_CLEAR)
  ((thread*) (thread_id))->flags_clear ((flags::mask_t) signals, &sig);
#else
  assert(((thread* ) (thread_id)) == &this_thread::thread ());
  // IGNORE THREAD ID!
  this_thread::flags_clear ((flags::mask_t) signals, &sig);
#endif
  return (int32_t) sig;
}
 
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Waggregate-return"
 
osEvent
osSignalWait (int32_t signals, uint32_t millisec)
{
  osEvent event;
 
  if (interrupts::in_handler_mode ())
    {
      event.status = osErrorISR;
      return event;
    }
 
  if ((uint32_t) signals & 0x80000000)
    {
      event.status = osErrorValue;
      return event;
    }
 
  result_t res;
  if (millisec == osWaitForever)
    {
      res = this_thread::flags_wait ((flags::mask_t) signals,
                                     (flags::mask_t*) &event.value.signals);
    }
  else if (millisec == 0)
    {
      res = this_thread::flags_try_wait ((flags::mask_t) signals,
                                         (flags::mask_t*) &event.value.signals);
    }
  else
    {
      res = this_thread::flags_timed_wait (
          (flags::mask_t) signals,
          clock_systick::ticks_cast ((uint64_t) (millisec * 1000u)),
          (flags::mask_t*) &event.value.signals);
    }
 
  if (res == result::ok)
    {
      event.status = osEventSignal;
    }
  else if (res == EWOULDBLOCK)
    {
      event.status = osOK; // Only for try_flags_wait().
    }
  else if (res == ETIMEDOUT)
    {
      event.status = osEventTimeout; // Only for timed_flags_wait().
    }
  else if (res == EPERM)
    {
      event.status = osErrorISR;
    }
  else if (res == EINVAL)
    {
      event.status = osErrorValue;
    }
  else
    {
      event.status = osErrorOS;
    }
 
  return event;
}
 
#pragma GCC diagnostic pop
 
// ----------------------------------------------------------------------------
 
//  ==== Mutex Management ====
 
osMutexId
osMutexCreate (const osMutexDef_t* mutex_def)
{
  if (interrupts::in_handler_mode ())
    {
      return nullptr;
    }
 
  if (mutex_def == nullptr)
    {
      return nullptr;
    }
 
  mutex::attributes attr;
  attr.mx_type = mutex::type::recursive;
  attr.mx_protocol = mutex::protocol::inherit;
 
  new ((void*) mutex_def->data) mutex (mutex_def->name, attr);
 
  return reinterpret_cast<osMutexId> (mutex_def->data);
}
 
osStatus
osMutexWait (osMutexId mutex_id, uint32_t millisec)
{
  if (interrupts::in_handler_mode ())
    {
      return osErrorISR;
    }
 
  if (mutex_id == nullptr)
    {
      return osErrorParameter;
    }
 
  result_t ret;
  if (millisec == osWaitForever)
    {
      ret = (reinterpret_cast<rtos::mutex&> (*mutex_id)).lock ();
      // osErrorResource:
    }
  else if (millisec == 0)
    {
      ret = (reinterpret_cast<rtos::mutex&> (*mutex_id)).try_lock ();
    }
  else
    {
      ret = (reinterpret_cast<rtos::mutex&> (*mutex_id)).timed_lock (
          clock_systick::ticks_cast ((uint64_t) (millisec * 1000u)));
      // osErrorTimeoutResource:
    }
 
  if (ret == result::ok)
    {
      // osOK: the mutex has been obtained.
      return osOK;
    }
  else if (ret == EWOULDBLOCK)
    {
      // The mutex could not be obtained when no timeout was specified.
      // Only for try_lock().
      return osErrorResource;
    }
  else if (ret == ENOTRECOVERABLE)
    {
      // The mutex could not be obtained when no timeout was specified.
      // Only for lock().
      return osErrorResource;
    }
  else if (ret == ETIMEDOUT)
    {
      // The mutex could not be obtained in the given time.
      // Only for timed_lock().
      return osErrorTimeoutResource;
    }
  else
    {
      return osErrorOS;
    }
 
  /* NOTREACHED */
}
 
osStatus
osMutexRelease (osMutexId mutex_id)
{
  if (interrupts::in_handler_mode ())
    {
      return osErrorISR;
    }
 
  if (mutex_id == nullptr)
    {
      return osErrorParameter;
    }
 
  result_t res;
  res = (reinterpret_cast<rtos::mutex&> (*mutex_id)).unlock ();
 
  if (res == result::ok)
    {
      return osOK;
    }
  else if ((res == EPERM) || (res == ENOTRECOVERABLE))
    {
      return osErrorResource;
    }
  else
    {
      return osErrorOS;
    }
}
 
osStatus
osMutexDelete (osMutexId mutex_id)
{
  if (interrupts::in_handler_mode ())
    {
      return osErrorISR;
    }
 
  if (mutex_id == nullptr)
    {
      return osErrorParameter;
    }
 
  (reinterpret_cast<rtos::mutex&> (*mutex_id)).~mutex ();
  return osOK;
}
 
// ----------------------------------------------------------------------------
 
//  ==== Semaphore Management Functions ====
 
#if (defined (osFeature_Semaphore)  &&  (osFeature_Semaphore != 0))
 
osSemaphoreId
osSemaphoreCreate (const osSemaphoreDef_t* semaphore_def, int32_t count)
{
  if (interrupts::in_handler_mode ())
    {
      return nullptr;
    }
 
  if (semaphore_def == nullptr)
    {
      return nullptr;
    }
 
  semaphore::attributes attr;
  attr.sm_initial_value = (semaphore::count_t) count;
  // The logic is very strange, the CMSIS expects both the max-count to be the
  // same as count, and also to accept a count of 0, which leads to
  // useless semaphores. We patch this behaviour in the wrapper, the main
  // object uses a more realistic max_value.
  attr.sm_max_value = (semaphore::count_t) (
      count == 0 ? osFeature_Semaphore : count);
 
  new ((void*) semaphore_def->data) semaphore (semaphore_def->name, attr);
 
  return reinterpret_cast<osSemaphoreId> (semaphore_def->data);
}
 
int32_t
osSemaphoreWait (osSemaphoreId semaphore_id, uint32_t millisec)
{
  if (interrupts::in_handler_mode ())
    {
      return -1;
    }
 
  if (semaphore_id == nullptr)
    {
      return -1;
    }
 
  result_t res;
  if (millisec == osWaitForever)
    {
      res = (reinterpret_cast<rtos::semaphore&> (*semaphore_id)).wait ();
    }
  else if (millisec == 0)
    {
      res = (reinterpret_cast<rtos::semaphore&> (*semaphore_id)).try_wait ();
      if (res == EWOULDBLOCK)
        {
          return 0;
        }
    }
  else
    {
      res = (reinterpret_cast<rtos::semaphore&> (*semaphore_id)).timed_wait (
          clock_systick::ticks_cast ((uint64_t) (millisec * 1000u)));
      if (res == ETIMEDOUT)
        {
          return 0;
        }
    }
 
  if (res == 0)
    {
      int count =
          (int32_t) (reinterpret_cast<rtos::semaphore&> (*semaphore_id)).value ();
      return count + 1;
    }
  else
    {
      return -1;
    }
}
 
osStatus
osSemaphoreRelease (osSemaphoreId semaphore_id)
{
  if (semaphore_id == nullptr)
    {
      return osErrorParameter;
    }
 
  if ((reinterpret_cast<rtos::semaphore&> (*semaphore_id)).initial_value ()
      == 0)
    {
      return osErrorResource;
    }
 
  result_t res = (reinterpret_cast<rtos::semaphore&> (*semaphore_id)).post ();
 
  if (res == result::ok)
    {
      return osOK;
    }
  else if (res == EAGAIN)
    {
      return osErrorResource;
    }
  else
    {
      return osErrorOS;
    }
}
 
osStatus
osSemaphoreDelete (osSemaphoreId semaphore_id)
{
  if (interrupts::in_handler_mode ())
    {
      return osErrorISR;
    }
 
  if (semaphore_id == nullptr)
    {
      return osErrorParameter;
    }
 
  (reinterpret_cast<rtos::semaphore&> (*semaphore_id)).~semaphore ();
  return osOK;
}
 
#endif /* Semaphore available */
 
// ----------------------------------------------------------------------------
//  ==== Memory Pool Management Functions ====
 
#if (defined (osFeature_Pool)  &&  (osFeature_Pool != 0))
 
osPoolId
osPoolCreate (const osPoolDef_t* pool_def)
{
  if (interrupts::in_handler_mode ())
    {
      return nullptr;
    }
 
  if (pool_def == nullptr)
    {
      return nullptr;
    }
 
  memory_pool::attributes attr;
  attr.mp_pool_address = pool_def->pool;
  attr.mp_pool_size_bytes = pool_def->pool_sz;
 
  new ((void*) pool_def->data) memory_pool (pool_def->name,
                                            (std::size_t) pool_def->items,
                                            (std::size_t) pool_def->item_sz,
                                            attr);
 
  return reinterpret_cast<osPoolId> (pool_def->data);
}
 
void*
osPoolAlloc (osPoolId pool_id)
{
  if (pool_id == nullptr)
    {
      return nullptr;
    }
 
  return (reinterpret_cast<memory_pool&> (*pool_id)).try_alloc ();
}
 
void*
osPoolCAlloc (osPoolId pool_id)
{
  if (pool_id == nullptr)
    {
      return nullptr;
    }
 
  void* ret;
  ret = (reinterpret_cast<memory_pool&> (*pool_id)).try_alloc ();
  if (ret != nullptr)
    {
      memset (ret, 0,
              (reinterpret_cast<memory_pool&> (*pool_id)).block_size ());
    }
 
  return ret;
}
 
osStatus
osPoolFree (osPoolId pool_id, void* block)
{
  if (pool_id == nullptr)
    {
      return osErrorParameter;
    }
 
  if (block == nullptr)
    {
      return osErrorParameter;
    }
 
  result_t res;
  res = (reinterpret_cast<memory_pool&> (*pool_id)).free (block);
 
  if (res == result::ok)
    {
      return osOK;
    }
  else if (res == EINVAL)
    {
      return osErrorValue;
    }
  else
    {
      return osErrorOS;
    }
}
 
#endif /* Memory Pool Management available */
 
// ----------------------------------------------------------------------------
//  ==== Message Queue Management Functions ====
 
#if (defined (osFeature_MessageQ)  &&  (osFeature_MessageQ != 0))
 
osMessageQId
osMessageCreate (const osMessageQDef_t* queue_def,
                 osThreadId thread_id __attribute__((unused)))
{
  if (interrupts::in_handler_mode ())
    {
      return nullptr;
    }
 
  if (queue_def == nullptr)
    {
      return nullptr;
    }
 
  message_queue::attributes attr;
  attr.mq_queue_address = queue_def->queue;
  attr.mq_queue_size_bytes = queue_def->queue_sz;
 
  new ((void*) queue_def->data) message_queue (queue_def->name,
                                               (std::size_t) queue_def->items,
                                               (std::size_t) queue_def->item_sz,
                                               attr);
 
  return reinterpret_cast<osMessageQId> (queue_def->data);
}
 
osStatus
osMessagePut (osMessageQId queue_id, uint32_t info, uint32_t millisec)
{
#pragma GCC diagnostic push
#if defined ( __clang__ )
#pragma clang diagnostic ignored "-Wint-to-pointer-cast"
#endif
 
  if (queue_id == nullptr)
    {
      return osErrorParameter;
    }
 
  result_t res;
  if (millisec == osWaitForever)
    {
      if (interrupts::in_handler_mode ())
        {
          return osErrorParameter;
        }
      res = (reinterpret_cast<message_queue&> (*queue_id)).send (
          (const char*) &info, sizeof(uint32_t), 0);
      // osOK, osErrorResource, osErrorParameter
    }
  else if (millisec == 0)
    {
      res = (reinterpret_cast<message_queue&> (*queue_id)).try_send (
          (const char*) &info, sizeof(uint32_t), 0);
      // osOK, osErrorResource, osErrorParameter
    }
  else
    {
      if (interrupts::in_handler_mode ())
        {
          return osErrorParameter;
        }
      res = (reinterpret_cast<message_queue&> (*queue_id)).timed_send (
          (const char*) &info, sizeof(uint32_t),
          clock_systick::ticks_cast ((uint64_t) (millisec * 1000u)), 0);
      // osOK, osErrorTimeoutResource, osErrorParameter
    }
 
  if (res == result::ok)
    {
      // The message was put into the queue.
      return osOK;
    }
  else if (res == EWOULDBLOCK)
    {
      // No memory in the queue was available
      return osErrorResource;
    }
  else if (res == ETIMEDOUT)
    {
      // No memory in the queue was available during the given time limit.
      return osErrorTimeoutResource;
    }
  else if (res == EINVAL || res == EMSGSIZE)
    {
      // A parameter is invalid or outside of a permitted range.
      return osErrorParameter;
    }
  else
    {
      return osErrorOS;
    }
 
#pragma GCC diagnostic pop
}
 
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Waggregate-return"
 
osEvent
osMessageGet (osMessageQId queue_id, uint32_t millisec)
{
  osEvent event;
  result_t res;
 
  if (queue_id == nullptr)
    {
      event.status = osErrorParameter;
      return event;
    }
 
  if (millisec == osWaitForever)
    {
      if (interrupts::in_handler_mode ())
        {
          event.status = osErrorParameter;
          return event;
        }
      res = (reinterpret_cast<message_queue&> (*queue_id)).receive (
          (char*) &event.value.v, sizeof(uint32_t), nullptr);
      // result::event_message;
    }
  else if (millisec == 0)
    {
      res = (reinterpret_cast<message_queue&> (*queue_id)).try_receive (
          (char*) &event.value.v, sizeof(uint32_t), nullptr);
      // result::event_message when message;
      // result::ok when no meessage
    }
  else
    {
      if (interrupts::in_handler_mode ())
        {
          event.status = osErrorParameter;
          return event;
        }
      res = (reinterpret_cast<message_queue&> (*queue_id)).timed_receive (
          (char*) &event.value.v, sizeof(uint32_t),
          clock_systick::ticks_cast ((uint64_t) (millisec * 1000u)), nullptr);
      // result::event_message when message;
      // result::event_timeout when timeout;
    }
 
  if (res == result::ok)
    {
      // Message received, value.p contains the pointer to message.
      event.status = osEventMessage;
    }
  else if (res == ETIMEDOUT)
    {
      // No message has arrived during the given timeout period.
      event.status = osEventTimeout;
    }
  else if (res == EINVAL || res == EMSGSIZE)
    {
      // A parameter is invalid or outside of a permitted range.
      event.status = osErrorParameter;
    }
  else if (res == EWOULDBLOCK)
    {
      // No message is available in the queue and no timeout was specified.
      event.status = osOK;
    }
  else
    {
      event.status = osErrorOS;
    }
 
  return event;
}
 
#pragma GCC diagnostic pop
 
#endif /* Message Queues available */
 
// ----------------------------------------------------------------------------
//  ==== Mail Queue Management Functions ====
 
#if (defined (osFeature_MailQ)  &&  (osFeature_MailQ != 0))
 
osMailQId
osMailCreate (const osMailQDef_t* mail_def,
              osThreadId thread_id __attribute__((unused)))
{
  if (interrupts::in_handler_mode ())
    {
      return nullptr;
    }
 
  if (mail_def == nullptr)
    {
      return nullptr;
    }
 
  memory_pool::attributes pool_attr;
  pool_attr.mp_pool_address = mail_def->pool;
  pool_attr.mp_pool_size_bytes = mail_def->pool_sz;
  new ((void*) &mail_def->data->pool) memory_pool (
      mail_def->name, (std::size_t) mail_def->items,
      (std::size_t) mail_def->pool_item_sz, pool_attr);
 
  message_queue::attributes queue_attr;
  queue_attr.mq_queue_address = mail_def->queue;
  queue_attr.mq_queue_size_bytes = mail_def->queue_sz;
  new ((void*) &mail_def->data->queue) message_queue (
      mail_def->name, (std::size_t) mail_def->items,
      (std::size_t) mail_def->queue_item_sz, queue_attr);
 
  return (osMailQId) (mail_def->data);
}
 
void*
osMailAlloc (osMailQId mail_id, uint32_t millisec)
{
  if (mail_id == nullptr)
    {
      return nullptr;
    }
 
  void* ret = nullptr;
 
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wstrict-aliasing"
  if (millisec == osWaitForever)
    {
      if (interrupts::in_handler_mode ())
        {
          return nullptr;
        }
      ret = (reinterpret_cast<memory_pool&> (mail_id->pool)).alloc ();
    }
  else if (millisec == 0)
    {
      ret = (reinterpret_cast<memory_pool&> (mail_id->pool)).try_alloc ();
    }
  else
    {
      if (interrupts::in_handler_mode ())
        {
          return nullptr;
        }
      ret = (reinterpret_cast<memory_pool&> (mail_id->pool)).timed_alloc (
          clock_systick::ticks_cast ((uint64_t) (millisec * 1000u)));
    }
#pragma GCC diagnostic pop
  return ret;
}
 
void*
osMailCAlloc (osMailQId mail_id, uint32_t millisec)
{
  void* ret = osMailAlloc (mail_id, millisec);
  if (ret != nullptr)
    {
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wstrict-aliasing"
      memset (ret, 0,
              (reinterpret_cast<memory_pool&> (mail_id->pool)).block_size ());
#pragma GCC diagnostic pop
    }
  return ret;
}
 
osStatus
osMailPut (osMailQId mail_id, void* mail)
{
  if (mail_id == nullptr)
    {
      return osErrorParameter;
    }
  if (mail == nullptr)
    {
      return osErrorValue;
    }
 
  // Validate pointer.
  memory_pool* pool = reinterpret_cast<memory_pool*> (&mail_id->pool);
  if (((char*) mail < (char*) (pool->pool ()))
      || (((char*) mail)
          >= ((char*) (pool->pool ()) + pool->capacity () * pool->block_size ())))
    {
      return osErrorValue;
    }
 
  result_t res;
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wstrict-aliasing"
  res = (reinterpret_cast<message_queue&> (mail_id->queue)).try_send (
      (const char*) &mail, sizeof(void*), 0);
#pragma GCC diagnostic pop
  if (res == result::ok)
    {
      return osOK;
    }
  else
    {
      return osErrorOS;
    }
}
 
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Waggregate-return"
#pragma GCC diagnostic ignored "-Wstrict-aliasing"
 
osEvent
osMailGet (osMailQId mail_id, uint32_t millisec)
{
  osEvent event;
  result_t res;
 
  if (mail_id == nullptr)
    {
      event.status = osErrorParameter;
      return event;
    }
 
  if (millisec == osWaitForever)
    {
      if (interrupts::in_handler_mode ())
        {
          event.status = osErrorParameter;
          return event;
        }
      res = (reinterpret_cast<message_queue&> ((mail_id->queue))).receive (
          (char*) &event.value.p, sizeof(void*), nullptr);
      // osEventMail for ok,
    }
  else if (millisec == 0)
    {
      res = (reinterpret_cast<message_queue&> (mail_id->queue)).try_receive (
          (char*) &event.value.p, sizeof(void*), nullptr);
      // osEventMail for ok,
    }
  else
    {
      if (interrupts::in_handler_mode ())
        {
          event.status = osErrorParameter;
          return event;
        }
      res = (reinterpret_cast<message_queue&> (mail_id->queue)).timed_receive (
          (char*) &event.value.p, sizeof(void*),
          clock_systick::ticks_cast ((uint64_t) (millisec * 1000u)), nullptr);
      // osEventMail for ok, osEventTimeout
    }
 
  if (res == result::ok)
    {
      // Mail received, value.p contains the pointer to mail content.
      event.status = osEventMail;
    }
  else if (res == EWOULDBLOCK)
    {
      // No mail is available in the queue and no timeout was specified.
      event.status = osOK;
    }
  else if (res == EINVAL || res == EMSGSIZE)
    {
      // A parameter is invalid or outside of a permitted range.
      event.status = osErrorParameter;
    }
  else if (res == ETIMEDOUT)
    {
      // No mail has arrived during the given timeout period.
      event.status = osEventTimeout;
    }
  else
    {
      event.status = osErrorOS;
    }
 
  return event;
}
 
#pragma GCC diagnostic pop
 
osStatus
osMailFree (osMailQId mail_id, void* mail)
{
  if (mail_id == nullptr)
    {
      return osErrorParameter;
    }
  if (mail == nullptr)
    {
      return osErrorValue;
    }
 
  return osPoolFree (&(mail_id->pool), mail);
}
 
#endif /* Mail Queues available */
 
// ----------------------------------------------------------------------------
 
#pragma GCC diagnostic pop
 
// ----------------------------------------------------------------------------