os-c-wrapper.cpp

Go to the documentation of this file.

/*
 * This file is part of the µOS++ project (https://micro-os-plus.github.io/).
 * Copyright (c) 2016-2025 Liviu Ionescu. All rights reserved.
 *
 * Permission to use, copy, modify, and/or distribute this software
 * for any purpose is hereby granted, under the terms of the MIT license.
 *
 * If a copy of the license was not distributed with this file, it can
 * be obtained from https://opensource.org/licenses/mit.
 */
 
/*
 * The code provides an implementation of the C API for the µOS++
 * and legacy CMSIS, using the CMSIC++ RTOS definitions.
 */
 
#if defined(OS_USE_OS_APP_CONFIG_H)
#include <cmsis-plus/os-app-config.h>
#endif
 
#include <cmsis-plus/rtos/os.h>
#include <cmsis-plus/rtos/os-c-api.h>
 
// ----------------------------------------------------------------------------
 
#if defined(__clang__)
#pragma clang diagnostic ignored "-Wc++98-compat"
#elif defined(__GNUC__)
#pragma GCC diagnostic ignored "-Wuseless-cast"
#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
#if defined(__clang__)
#pragma clang diagnostic ignored "-Wanon-enum-enum-conversion"
#else
#pragma GCC diagnostic ignored "-Wenum-compare"
#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
#if defined(__clang__)
#pragma clang diagnostic ignored "-Winvalid-offsetof"
#elif defined(__GNUC__)
#pragma GCC diagnostic ignored "-Winvalid-offsetof"
#endif
 
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
#if defined(__clang__)
#pragma clang diagnostic ignored "-Wold-style-cast"
#elif defined(__GNUC__)
#pragma GCC diagnostic ignored "-Wold-style-cast"
#endif
 
// ----------------------------------------------------------------------------
 
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)
{
#pragma GCC diagnostic push
#if defined(__clang__)
#elif defined(__GNUC__)
#pragma GCC diagnostic ignored "-Waggregate-return"
#endif
  return reinterpret_cast<os_iterator_t> (
      scheduler::children_threads (reinterpret_cast<rtos::thread*> (thread))
          .begin ()
          .get_iterator_pointer ());
#pragma GCC diagnostic pop
}
 
os_iterator_t
os_children_threads_iter_end (os_thread_t* thread)
{
#pragma GCC diagnostic push
#if defined(__clang__)
#elif defined(__GNUC__)
#pragma GCC diagnostic ignored "-Waggregate-return"
#endif
  return reinterpret_cast<os_iterator_t> (
      scheduler::children_threads (reinterpret_cast<rtos::thread*> (thread))
          .end ()
          .get_iterator_pointer ());
#pragma GCC diagnostic pop
}
 
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 ();
}
 
// error unable to resolve reference to
// 'os::rtos::adjustable_clock::offset(os::rtos::clock::offset_t)' for \ref
// command
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);
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wcast-align"
  return (reinterpret_cast<rtos::memory::memory_resource&> (*memory))
      .allocate (bytes, alignment);
#pragma GCC diagnostic pop
}
 
void
os_memory_deallocate (os_memory_t* memory, void* addr, size_t bytes,
                      size_t alignment)
{
  assert (memory != nullptr);
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wcast-align"
  (reinterpret_cast<rtos::memory::memory_resource&> (*memory))
      .deallocate (addr, bytes, alignment);
#pragma GCC diagnostic pop
}
 
void
os_memory_reset (os_memory_t* memory)
{
  assert (memory != nullptr);
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wcast-align"
  (reinterpret_cast<rtos::memory::memory_resource&> (*memory)).reset ();
#pragma GCC diagnostic pop
}
 
bool
os_memory_coalesce (os_memory_t* memory)
{
  assert (memory != nullptr);
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wcast-align"
  return (reinterpret_cast<rtos::memory::memory_resource&> (*memory))
      .coalesce ();
#pragma GCC diagnostic pop
}
 
size_t
os_memory_get_total_bytes (os_memory_t* memory)
{
  assert (memory != nullptr);
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wcast-align"
  return (reinterpret_cast<rtos::memory::memory_resource&> (*memory))
      .total_bytes ();
#pragma GCC diagnostic pop
}
 
size_t
os_memory_get_allocated_bytes (os_memory_t* memory)
{
  assert (memory != nullptr);
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wcast-align"
  return (reinterpret_cast<rtos::memory::memory_resource&> (*memory))
      .allocated_bytes ();
#pragma GCC diagnostic pop
}
 
size_t
os_memory_get_free_bytes (os_memory_t* memory)
{
  assert (memory != nullptr);
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wcast-align"
  return (reinterpret_cast<rtos::memory::memory_resource&> (*memory))
      .free_bytes ();
#pragma GCC diagnostic pop
}
 
size_t
os_memory_get_allocated_chunks (os_memory_t* memory)
{
  assert (memory != nullptr);
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wcast-align"
  return (reinterpret_cast<rtos::memory::memory_resource&> (*memory))
      .allocated_chunks ();
#pragma GCC diagnostic pop
}
 
size_t
os_memory_get_free_chunks (os_memory_t* memory)
{
  assert (memory != nullptr);
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wcast-align"
  return (reinterpret_cast<rtos::memory::memory_resource&> (*memory))
      .free_chunks ();
#pragma GCC diagnostic pop
}
 
// ****************************************************************************
// ***** 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)
    {
#pragma GCC diagnostic push
#if defined(__clang__)
#pragma clang diagnostic ignored "-Wunsafe-buffer-usage"
#endif
      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
#if defined(__clang__)
#pragma clang diagnostic ignored "-Wcast-function-type"
#elif defined(__GNUC__)
#pragma GCC diagnostic ignored "-Wcast-function-type"
#endif
          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);
        }
#pragma GCC diagnostic pop
    }
  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
#if defined(__clang__)
#elif defined(__GNUC__)
#pragma GCC diagnostic ignored "-Waggregate-return"
#endif
 
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;
 
#pragma GCC diagnostic push
#if defined(__clang__)
#pragma clang diagnostic ignored "-Wcast-function-type-strict"
#endif
  new ((void*)timer_def->data)
      timer (timer_def->name, (timer::func_t)timer_def->ptimer,
             (timer::func_args_t)args, attr);
#pragma GCC diagnostic pop
 
  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
#if defined(__clang__)
#elif defined(__GNUC__)
#pragma GCC diagnostic ignored "-Waggregate-return"
#endif
 
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
#if defined(__clang__)
#elif defined(__GNUC__)
#pragma GCC diagnostic ignored "-Waggregate-return"
#endif
 
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
#if defined(__clang__)
#elif defined(__GNUC__)
#pragma GCC diagnostic ignored "-Wstrict-aliasing"
#endif
  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
#if defined(__clang__)
#elif defined(__GNUC__)
#pragma GCC diagnostic ignored "-Wstrict-aliasing"
#endif
      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);
#pragma GCC diagnostic push
#if defined(__clang__)
#pragma clang diagnostic ignored "-Wunsafe-buffer-usage"
#endif
  if (((char*)mail < (char*)(pool->pool ()))
      || (((char*)mail) >= ((char*)(pool->pool ())
                            + pool->capacity () * pool->block_size ())))
    {
      return osErrorValue;
    }
#pragma GCC diagnostic pop
 
  result_t res;
#pragma GCC diagnostic push
#if defined(__clang__)
#elif defined(__GNUC__)
#pragma GCC diagnostic ignored "-Wstrict-aliasing"
#endif
  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
#if defined(__clang__)
#elif defined(__GNUC__)
#pragma GCC diagnostic ignored "-Waggregate-return"
#endif
#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
 
// ----------------------------------------------------------------------------