From a5ba02231106d70330e8b01dd60edba922e11f86 Mon Sep 17 00:00:00 2001 From: barthess Date: Sun, 3 Aug 2014 20:23:16 +0000 Subject: CPP wrappers ported to Chibios v3. git-svn-id: svn://svn.code.sf.net/p/chibios/svn/trunk@7118 35acf78f-673a-0410-8e92-d51de3d6d3f4 --- os/various/cpp_wrappers/ch.cpp | 148 ++++++++++++++----------------- os/various/cpp_wrappers/ch.hpp | 111 +++++++++++------------ os/various/cpp_wrappers/syscalls_cpp.cpp | 78 ++++++++++++++++ os/various/cpp_wrappers/syscalls_cpp.hpp | 14 +++ 4 files changed, 215 insertions(+), 136 deletions(-) create mode 100644 os/various/cpp_wrappers/syscalls_cpp.cpp create mode 100644 os/various/cpp_wrappers/syscalls_cpp.hpp (limited to 'os') diff --git a/os/various/cpp_wrappers/ch.cpp b/os/various/cpp_wrappers/ch.cpp index d7b54bfb3..500db278d 100644 --- a/os/various/cpp_wrappers/ch.cpp +++ b/os/various/cpp_wrappers/ch.cpp @@ -45,22 +45,22 @@ namespace chibios_rt { void System::lockFromIsr(void) { - chSysLockFromIsr(); + chSysLockFromISR(); } void System::unlockFromIsr(void) { - chSysUnlockFromIsr(); + chSysUnlockFromISR(); } systime_t System::getTime(void) { - return chTimeNow(); + return chVTGetSystemTimeX(); } bool System::isTimeWithin(systime_t start, systime_t end) { - return (bool)chTimeIsWithin(start, end); + return chVTIsSystemTimeWithinX(start, end); } /*------------------------------------------------------------------------* @@ -97,7 +97,7 @@ namespace chibios_rt { bool Timer::isArmedI(void) { - return (bool)chVTIsArmedI(&timer_ref); + return chVTIsArmedI(&timer_ref); } /*------------------------------------------------------------------------* @@ -106,7 +106,7 @@ namespace chibios_rt { void ThreadReference::stop(void) { - chDbgPanic("invoked unimplemented method stop()"); + chSysHalt("invoked unimplemented method stop()"); } msg_t ThreadReference::suspend(void) { @@ -115,11 +115,10 @@ namespace chibios_rt { chSysLock(); chDbgAssert(thread_ref != NULL, - "ThreadReference, #1", "already referenced"); - thread_ref = chThdSelf(); - chSchGoSleepS(THD_STATE_SUSPENDED); + thread_ref = chThdGetSelfX(); + chSchGoSleepS(CH_STATE_SUSPENDED); msg = thread_ref->p_u.rdymsg; chSysUnlock(); @@ -129,24 +128,22 @@ namespace chibios_rt { msg_t ThreadReference::suspendS(void) { chDbgAssert(thread_ref == NULL, - "ThreadReference, #2", "already referenced"); - thread_ref = chThdSelf(); - chSchGoSleepS(THD_STATE_SUSPENDED); + thread_ref = chThdGetSelfX(); + chSchGoSleepS(CH_STATE_SUSPENDED); return thread_ref->p_u.rdymsg; } void ThreadReference::resume(msg_t msg) { - chSysLock() + chSysLock(); chDbgAssert(thread_ref != NULL, - "ThreadReference, #3", "not referenced"); if (thread_ref) { - Thread *tp = thread_ref; + thread_t *tp = thread_ref; thread_ref = NULL; chSchWakeupS(tp, msg); } @@ -157,11 +154,10 @@ namespace chibios_rt { void ThreadReference::resumeI(msg_t msg) { chDbgAssert(thread_ref != NULL, - "ThreadReference, #4", "not referenced"); if (thread_ref) { - Thread *tp = thread_ref; + thread_t *tp = thread_ref; thread_ref = NULL; tp->p_msg = msg; chSchReadyI(tp); @@ -171,30 +167,27 @@ namespace chibios_rt { void ThreadReference::requestTerminate(void) { chDbgAssert(thread_ref != NULL, - "ThreadReference, #5", "not referenced"); chThdTerminate(thread_ref); } -#if CH_USE_WAITEXIT +#if CH_CFG_USE_WAITEXIT msg_t ThreadReference::wait(void) { chDbgAssert(thread_ref != NULL, - "ThreadReference, #6", "not referenced"); msg_t msg = chThdWait(thread_ref); thread_ref = NULL; return msg; } -#endif /* CH_USE_WAITEXIT */ +#endif /* CH_CFG_USE_WAITEXIT */ -#if CH_USE_MESSAGES +#if CH_CFG_USE_MESSAGES msg_t ThreadReference::sendMessage(msg_t msg) { chDbgAssert(thread_ref != NULL, - "ThreadReference, #7", "not referenced"); return chMsgSend(thread_ref, msg); @@ -203,16 +196,14 @@ namespace chibios_rt { bool ThreadReference::isPendingMessage(void) { chDbgAssert(thread_ref != NULL, - "ThreadReference, #7", "not referenced"); - return (bool)chMsgIsPendingI(thread_ref); + return chMsgIsPendingI(thread_ref); } msg_t ThreadReference::getMessage(void) { chDbgAssert(thread_ref != NULL, - "ThreadReference, #8", "not referenced"); return chMsgGet(thread_ref); @@ -221,18 +212,16 @@ namespace chibios_rt { void ThreadReference::releaseMessage(msg_t msg) { chDbgAssert(thread_ref != NULL, - "ThreadReference, #9", "not referenced"); chMsgRelease(thread_ref, msg); } -#endif /* CH_USE_MESSAGES */ +#endif /* CH_CFG_USE_MESSAGES */ -#if CH_USE_EVENTS +#if CH_CFG_USE_EVENTS void ThreadReference::signalEvents(eventmask_t mask) { chDbgAssert(thread_ref != NULL, - "ThreadReference, #10", "not referenced"); chEvtSignal(thread_ref, mask); @@ -241,15 +230,14 @@ namespace chibios_rt { void ThreadReference::signalEventsI(eventmask_t mask) { chDbgAssert(thread_ref != NULL, - "ThreadReference, #11", "not referenced"); chEvtSignalI(thread_ref, mask); } -#endif /* CH_USE_EVENTS */ +#endif /* CH_CFG_USE_EVENTS */ -#if CH_USE_DYNAMIC -#endif /* CH_USE_DYNAMIC */ +#if CH_CFG_USE_DYNAMIC +#endif /* CH_CFG_USE_DYNAMIC */ /*------------------------------------------------------------------------* * chibios_rt::BaseThread * @@ -297,7 +285,7 @@ namespace chibios_rt { bool BaseThread::shouldTerminate(void) { - return (bool)chThdShouldTerminate(); + return chThdShouldTerminateX(); } void BaseThread::sleep(systime_t interval){ @@ -315,15 +303,15 @@ namespace chibios_rt { chThdYield(); } -#if CH_USE_MESSAGES +#if CH_CFG_USE_MESSAGES ThreadReference BaseThread::waitMessage(void) { ThreadReference tr(chMsgWait()); return tr; } -#endif /* CH_USE_MESSAGES */ +#endif /* CH_CFG_USE_MESSAGES */ -#if CH_USE_EVENTS +#if CH_CFG_USE_EVENTS eventmask_t BaseThread::getAndClearEvents(eventmask_t mask) { return chEvtGetAndClearEvents(mask); @@ -349,7 +337,7 @@ namespace chibios_rt { return chEvtWaitAll(ewmask); } -#if CH_USE_EVENTS_TIMEOUT +#if CH_CFG_USE_EVENTS_TIMEOUT eventmask_t BaseThread::waitOneEventTimeout(eventmask_t ewmask, systime_t time) { @@ -367,39 +355,39 @@ namespace chibios_rt { return chEvtWaitAllTimeout(ewmask, time); } -#endif /* CH_USE_EVENTS_TIMEOUT */ +#endif /* CH_CFG_USE_EVENTS_TIMEOUT */ void BaseThread::dispatchEvents(const evhandler_t handlers[], eventmask_t mask) { chEvtDispatch(handlers, mask); } -#endif /* CH_USE_EVENTS */ +#endif /* CH_CFG_USE_EVENTS */ -#if CH_USE_MUTEXES - void BaseThread::unlockMutex(void) { +#if CH_CFG_USE_MUTEXES + void BaseThread::unlockMutex(Mutex *mp) { - chMtxUnlock(); + chMtxUnlock(&mp->mutex); } - void BaseThread::unlockMutexS(void) { + void BaseThread::unlockMutexS(Mutex *mp) { - chMtxUnlockS(); + chMtxUnlockS(&mp->mutex); } void BaseThread::unlockAllMutexes(void) { chMtxUnlockAll(); } -#endif /* CH_USE_MUTEXES */ +#endif /* CH_CFG_USE_MUTEXES */ -#if CH_USE_SEMAPHORES +#if CH_CFG_USE_SEMAPHORES /*------------------------------------------------------------------------* * chibios_rt::CounterSemaphore * *------------------------------------------------------------------------*/ CounterSemaphore::CounterSemaphore(cnt_t n) { - chSemInit(&sem, n); + chSemObjectInit(&sem, n); } void CounterSemaphore::reset(cnt_t n) { @@ -452,20 +440,18 @@ namespace chibios_rt { return chSemGetCounterI(&sem); } -#if CH_USE_SEMSW msg_t CounterSemaphore::signalWait(CounterSemaphore *ssem, CounterSemaphore *wsem) { return chSemSignalWait(&ssem->sem, &wsem->sem); } -#endif /* CH_USE_SEMSW */ /*------------------------------------------------------------------------* * chibios_rt::BinarySemaphore * *------------------------------------------------------------------------*/ BinarySemaphore::BinarySemaphore(bool taken) { - chBSemInit(&bsem, (bool_t)taken); + chBSemObjectInit(&bsem, taken); } msg_t BinarySemaphore::wait(void) { @@ -490,12 +476,12 @@ namespace chibios_rt { void BinarySemaphore::reset(bool taken) { - chBSemReset(&bsem, (bool_t)taken); + chBSemReset(&bsem, taken); } void BinarySemaphore::resetI(bool taken) { - chBSemResetI(&bsem, (bool_t)taken); + chBSemResetI(&bsem, taken); } void BinarySemaphore::signal(void) { @@ -512,15 +498,15 @@ namespace chibios_rt { return (bool)chBSemGetStateI(&bsem); } -#endif /* CH_USE_SEMAPHORES */ +#endif /* CH_CFG_USE_SEMAPHORES */ -#if CH_USE_MUTEXES +#if CH_CFG_USE_MUTEXES /*------------------------------------------------------------------------* * chibios_rt::Mutex * *------------------------------------------------------------------------*/ Mutex::Mutex(void) { - chMtxInit(&mutex); + chMtxObjectInit(&mutex); } bool Mutex::tryLock(void) { @@ -543,13 +529,13 @@ namespace chibios_rt { chMtxLockS(&mutex); } -#if CH_USE_CONDVARS +#if CH_CFG_USE_CONDVARS /*------------------------------------------------------------------------* * chibios_rt::CondVar * *------------------------------------------------------------------------*/ CondVar::CondVar(void) { - chCondInit(&condvar); + chCondObjectInit(&condvar); } void CondVar::signal(void) { @@ -582,25 +568,25 @@ namespace chibios_rt { return chCondWaitS(&condvar); } -#if CH_USE_CONDVARS_TIMEOUT +#if CH_CFG_USE_CONDVARS_TIMEOUT msg_t CondVar::waitTimeout(systime_t time) { return chCondWaitTimeout(&condvar, time); } -#endif /* CH_USE_CONDVARS_TIMEOUT */ -#endif /* CH_USE_CONDVARS */ -#endif /* CH_USE_MUTEXES */ +#endif /* CH_CFG_USE_CONDVARS_TIMEOUT */ +#endif /* CH_CFG_USE_CONDVARS */ +#endif /* CH_CFG_USE_MUTEXES */ -#if CH_USE_EVENTS +#if CH_CFG_USE_EVENTS /*------------------------------------------------------------------------* * chibios_rt::EvtListener * *------------------------------------------------------------------------*/ - flagsmask_t EvtListener::getAndClearFlags(void) { + eventflags_t EvtListener::getAndClearFlags(void) { return chEvtGetAndClearFlags(&ev_listener); } - flagsmask_t EvtListener::getAndClearFlagsI(void) { + eventflags_t EvtListener::getAndClearFlagsI(void) { return chEvtGetAndClearFlagsI(&ev_listener); } @@ -610,7 +596,7 @@ namespace chibios_rt { *------------------------------------------------------------------------*/ EvtSource::EvtSource(void) { - chEvtInit(&ev_source); + chEvtObjectInit(&ev_source); } void EvtSource::registerOne(chibios_rt::EvtListener *elp, @@ -630,24 +616,24 @@ namespace chibios_rt { chEvtUnregister(&ev_source, &elp->ev_listener); } - void EvtSource::broadcastFlags(flagsmask_t flags) { + void EvtSource::broadcastFlags(eventflags_t flags) { chEvtBroadcastFlags(&ev_source, flags); } - void EvtSource::broadcastFlagsI(flagsmask_t flags) { + void EvtSource::broadcastFlagsI(eventflags_t flags) { chEvtBroadcastFlagsI(&ev_source, flags); } -#endif /* CH_USE_EVENTS */ +#endif /* CH_CFG_USE_EVENTS */ -#if CH_USE_QUEUES +#if CH_CFG_USE_QUEUES /*------------------------------------------------------------------------* * chibios_rt::InQueue * *------------------------------------------------------------------------*/ InQueue::InQueue(uint8_t *bp, size_t size, qnotify_t infy, void *link) { - chIQInit(&iq, bp, size, infy, link); + chIQObjectInit(&iq, bp, size, infy, link); } size_t InQueue::getFullI(void) { @@ -700,7 +686,7 @@ namespace chibios_rt { *------------------------------------------------------------------------*/ OutQueue::OutQueue(uint8_t *bp, size_t size, qnotify_t onfy, void *link) { - chOQInit(&oq, bp, size, onfy, link); + chOQObjectInit(&oq, bp, size, onfy, link); } size_t OutQueue::getFullI(void) { @@ -748,15 +734,15 @@ namespace chibios_rt { return chOQWriteTimeout(&oq, bp, n, time); } -#endif /* CH_USE_QUEUES */ +#endif /* CH_CFG_USE_QUEUES */ -#if CH_USE_MAILBOXES +#if CH_CFG_USE_MAILBOXES /*------------------------------------------------------------------------* * chibios_rt::Mailbox * *------------------------------------------------------------------------*/ Mailbox::Mailbox(msg_t *buf, cnt_t n) { - chMBInit(&mb, buf, n); + chMBObjectInit(&mb, buf, n); } void Mailbox::reset(void) { @@ -818,20 +804,20 @@ namespace chibios_rt { return chMBGetUsedCountI(&mb); } -#endif /* CH_USE_MAILBOXES */ +#endif /* CH_CFG_USE_MAILBOXES */ -#if CH_USE_MEMPOOLS +#if CH_CFG_USE_MEMPOOLS /*------------------------------------------------------------------------* * chibios_rt::MemoryPool * *------------------------------------------------------------------------*/ MemoryPool::MemoryPool(size_t size, memgetfunc_t provider) { - chPoolInit(&pool, size, provider); + chPoolObjectInit(&pool, size, provider); } MemoryPool::MemoryPool(size_t size, memgetfunc_t provider, void* p, size_t n) { - chPoolInit(&pool, size, provider); + chPoolObjectInit(&pool, size, provider); chPoolLoadArray(&pool, p, n); } @@ -860,7 +846,7 @@ namespace chibios_rt { chPoolFreeI(&pool, objp); } -#endif /* CH_USE_MEMPOOLS */ +#endif /* CH_CFG_USE_MEMPOOLS */ } /** @} */ diff --git a/os/various/cpp_wrappers/ch.hpp b/os/various/cpp_wrappers/ch.hpp index 53d3cf23b..7588e5ee1 100644 --- a/os/various/cpp_wrappers/ch.hpp +++ b/os/various/cpp_wrappers/ch.hpp @@ -28,10 +28,13 @@ #define _CH_HPP_ /** - * @brief ChibiOS kernel-related classes and interfaces. + * @brief ChibiOS-RT kernel-related classes and interfaces. */ namespace chibios_rt { + /* Forward declarations */ + class Mutex; + /*------------------------------------------------------------------------* * chibios_rt::System * *------------------------------------------------------------------------*/ @@ -182,7 +185,7 @@ namespace chibios_rt { /** * @brief Embedded @p VirtualTimer structure. */ - ::VirtualTimer timer_ref; + ::virtual_timer_t timer_ref; /** * @brief Enables a virtual timer. @@ -236,7 +239,7 @@ namespace chibios_rt { /** * @brief Pointer to the system thread. */ - ::Thread *thread_ref; + ::thread_t *thread_ref; /** * @brief Thread reference constructor. @@ -247,7 +250,7 @@ namespace chibios_rt { * * @init */ - ThreadReference(Thread *tp) : thread_ref(tp) { + ThreadReference(thread_t *tp) : thread_ref(tp) { }; @@ -312,7 +315,7 @@ namespace chibios_rt { */ void requestTerminate(void); -#if CH_USE_WAITEXIT || defined(__DOXYGEN__) +#if CH_CFG_USE_WAITEXIT || defined(__DOXYGEN__) /** * @brief Blocks the execution of the invoking thread until the specified * thread terminates then the exit code is returned. @@ -346,9 +349,9 @@ namespace chibios_rt { * @api */ msg_t wait(void); -#endif /* CH_USE_WAITEXIT */ +#endif /* CH_CFG_USE_WAITEXIT */ -#if CH_USE_MESSAGES || defined(__DOXYGEN__) +#if CH_CFG_USE_MESSAGES || defined(__DOXYGEN__) /** * @brief Sends a message to the thread and returns the answer. * @@ -386,9 +389,9 @@ namespace chibios_rt { * @api */ void releaseMessage(msg_t msg); -#endif /* CH_USE_MESSAGES */ +#endif /* CH_CFG_USE_MESSAGES */ -#if CH_USE_EVENTS || defined(__DOXYGEN__) +#if CH_CFG_USE_EVENTS || defined(__DOXYGEN__) /** * @brief Adds a set of event flags directly to specified @p Thread. * @@ -406,10 +409,10 @@ namespace chibios_rt { * @iclass */ void signalEventsI(eventmask_t mask); -#endif /* CH_USE_EVENTS */ +#endif /* CH_CFG_USE_EVENTS */ -#if CH_USE_DYNAMIC || defined(__DOXYGEN__) -#endif /* CH_USE_DYNAMIC */ +#if CH_CFG_USE_DYNAMIC || defined(__DOXYGEN__) +#endif /* CH_CFG_USE_DYNAMIC */ }; /*------------------------------------------------------------------------* @@ -550,7 +553,7 @@ namespace chibios_rt { */ static void yield(void); -#if CH_USE_MESSAGES || defined(__DOXYGEN__) +#if CH_CFG_USE_MESSAGES || defined(__DOXYGEN__) /** * @brief Waits for a message. * @@ -559,9 +562,9 @@ namespace chibios_rt { * @api */ static ThreadReference waitMessage(void); -#endif /* CH_USE_MESSAGES */ +#endif /* CH_CFG_USE_MESSAGES */ -#if CH_USE_EVENTS || defined(__DOXYGEN__) +#if CH_CFG_USE_EVENTS || defined(__DOXYGEN__) /** * @brief Clears the pending events specified in the mask. * @@ -630,7 +633,7 @@ namespace chibios_rt { */ static eventmask_t waitAllEvents(eventmask_t ewmask); -#if CH_USE_EVENTS_TIMEOUT || defined(__DOXYGEN__) +#if CH_CFG_USE_EVENTS_TIMEOUT || defined(__DOXYGEN__) /** * @brief Waits for a single event. * @details A pending event among those specified in @p ewmask is selected, @@ -689,7 +692,7 @@ namespace chibios_rt { */ static eventmask_t waitAllEventsTimeout(eventmask_t ewmask, systime_t time); -#endif /* CH_USE_EVENTS_TIMEOUT */ +#endif /* CH_CFG_USE_EVENTS_TIMEOUT */ /** * @brief Invokes the event handlers associated to an event flags mask. @@ -702,9 +705,9 @@ namespace chibios_rt { */ static void dispatchEvents(const evhandler_t handlers[], eventmask_t mask); -#endif /* CH_USE_EVENTS */ +#endif /* CH_CFG_USE_EVENTS */ -#if CH_USE_MUTEXES || defined(__DOXYGEN__) +#if CH_CFG_USE_MUTEXES || defined(__DOXYGEN__) /** * @brief Unlocks the next owned mutex in reverse lock order. * @pre The invoking thread must have at least one owned mutex. @@ -715,7 +718,7 @@ namespace chibios_rt { * * @api */ - static void unlockMutex(void); + static void unlockMutex(Mutex *mp); /** * @brief Unlocks the next owned mutex in reverse lock order. @@ -729,7 +732,7 @@ namespace chibios_rt { * * @sclass */ - static void unlockMutexS(void); + static void unlockMutexS(Mutex *mp); /** * @brief Unlocks all the mutexes owned by the invoking thread. @@ -743,7 +746,7 @@ namespace chibios_rt { * @api */ static void unlockAllMutexes(void); -#endif /* CH_USE_MUTEXES */ +#endif /* CH_CFG_USE_MUTEXES */ }; /*------------------------------------------------------------------------* @@ -758,7 +761,7 @@ namespace chibios_rt { template class BaseStaticThread : public BaseThread { protected: - WORKING_AREA(wa, N); + THD_WORKING_AREA(wa, N); public: /** @@ -789,7 +792,7 @@ namespace chibios_rt { } }; -#if CH_USE_SEMAPHORES || defined(__DOXYGEN__) +#if CH_CFG_USE_SEMAPHORES || defined(__DOXYGEN__) /*------------------------------------------------------------------------* * chibios_rt::CounterSemaphore * *------------------------------------------------------------------------*/ @@ -801,7 +804,7 @@ namespace chibios_rt { /** * @brief Embedded @p ::Semaphore structure. */ - ::Semaphore sem; + ::semaphore_t sem; /** * @brief CounterSemaphore constructor. @@ -963,7 +966,6 @@ namespace chibios_rt { */ cnt_t getCounterI(void); -#if CH_USE_SEMSW || defined(__DOXYGEN__) /** * @brief Atomic signal and wait operations. * @@ -980,7 +982,6 @@ namespace chibios_rt { */ static msg_t signalWait(CounterSemaphore *ssem, CounterSemaphore *wsem); -#endif /* CH_USE_SEMSW */ }; /*------------------------------------------------------------------------* * chibios_rt::BinarySemaphore * @@ -993,7 +994,7 @@ namespace chibios_rt { /** * @brief Embedded @p ::Semaphore structure. */ - ::BinarySemaphore bsem; + ::binary_semaphore_t bsem; /** * @brief BinarySemaphore constructor. @@ -1135,9 +1136,9 @@ namespace chibios_rt { */ bool getStateI(void); }; -#endif /* CH_USE_SEMAPHORES */ +#endif /* CH_CFG_USE_SEMAPHORES */ -#if CH_USE_MUTEXES || defined(__DOXYGEN__) +#if CH_CFG_USE_MUTEXES || defined(__DOXYGEN__) /*------------------------------------------------------------------------* * chibios_rt::Mutex * *------------------------------------------------------------------------*/ @@ -1149,7 +1150,7 @@ namespace chibios_rt { /** * @brief Embedded @p ::Mutex structure. */ - ::Mutex mutex; + ::mutex_t mutex; /** * @brief Mutex object constructor. @@ -1216,7 +1217,7 @@ namespace chibios_rt { void lockS(void); }; -#if CH_USE_CONDVARS || defined(__DOXYGEN__) +#if CH_CFG_USE_CONDVARS || defined(__DOXYGEN__) /*------------------------------------------------------------------------* * chibios_rt::CondVar * *------------------------------------------------------------------------*/ @@ -1228,7 +1229,7 @@ namespace chibios_rt { /** * @brief Embedded @p ::CondVar structure. */ - ::CondVar condvar; + ::condition_variable_t condvar; /** * @brief CondVar object constructor. @@ -1310,7 +1311,7 @@ namespace chibios_rt { */ msg_t waitS(void); -#if CH_USE_CONDVARS_TIMEOUT || defined(__DOXYGEN__) +#if CH_CFG_USE_CONDVARS_TIMEOUT || defined(__DOXYGEN__) /** * @brief Waits on the CondVar while releasing the controlling mutex. * @@ -1326,12 +1327,12 @@ namespace chibios_rt { * @api */ msg_t waitTimeout(systime_t time); -#endif /* CH_USE_CONDVARS_TIMEOUT */ +#endif /* CH_CFG_USE_CONDVARS_TIMEOUT */ }; -#endif /* CH_USE_CONDVARS */ -#endif /* CH_USE_MUTEXES */ +#endif /* CH_CFG_USE_CONDVARS */ +#endif /* CH_CFG_USE_MUTEXES */ -#if CH_USE_EVENTS || defined(__DOXYGEN__) +#if CH_CFG_USE_EVENTS || defined(__DOXYGEN__) /*------------------------------------------------------------------------* * chibios_rt::EvtListener * *------------------------------------------------------------------------*/ @@ -1343,7 +1344,7 @@ namespace chibios_rt { /** * @brief Embedded @p ::EventListener structure. */ - struct ::EventListener ev_listener; + ::event_listener_t ev_listener; /** * @brief Returns the pending flags from the listener and clears them. @@ -1353,7 +1354,7 @@ namespace chibios_rt { * * @api */ - flagsmask_t getAndClearFlags(void); + eventflags_t getAndClearFlags(void); /** * @brief Returns the flags associated to an @p EventListener. @@ -1365,7 +1366,7 @@ namespace chibios_rt { * * @iclass */ - flagsmask_t getAndClearFlagsI(void); + eventflags_t getAndClearFlagsI(void); }; /*------------------------------------------------------------------------* @@ -1379,7 +1380,7 @@ namespace chibios_rt { /** * @brief Embedded @p ::EventSource structure. */ - struct ::EventSource ev_source; + ::event_source_t ev_source; /** * @brief EvtSource object constructor. @@ -1433,7 +1434,7 @@ namespace chibios_rt { * * @api */ - void broadcastFlags(flagsmask_t flags); + void broadcastFlags(eventflags_t flags); /** * @brief Broadcasts on an event source. @@ -1445,11 +1446,11 @@ namespace chibios_rt { * * @iclass */ - void broadcastFlagsI(flagsmask_t flags); + void broadcastFlagsI(eventflags_t flags); }; -#endif /* CH_USE_EVENTS */ +#endif /* CH_CFG_USE_EVENTS */ -#if CH_USE_QUEUES || defined(__DOXYGEN__) +#if CH_CFG_USE_QUEUES || defined(__DOXYGEN__) /*------------------------------------------------------------------------* * chibios_rt::InQueue * *------------------------------------------------------------------------*/ @@ -1461,7 +1462,7 @@ namespace chibios_rt { /** * @brief Embedded @p ::InputQueue structure. */ - ::InputQueue iq; + ::input_queue_t iq; public: /** @@ -1642,7 +1643,7 @@ namespace chibios_rt { /** * @brief Embedded @p ::OutputQueue structure. */ - ::OutputQueue oq; + ::output_queue_t oq; public: /** @@ -1813,9 +1814,9 @@ namespace chibios_rt { onfy, link) { } }; -#endif /* CH_USE_QUEUES */ +#endif /* CH_CFG_USE_QUEUES */ -#if CH_USE_MAILBOXES || defined(__DOXYGEN__) +#if CH_CFG_USE_MAILBOXES || defined(__DOXYGEN__) /*------------------------------------------------------------------------* * chibios_rt::Mailbox * *------------------------------------------------------------------------*/ @@ -1827,7 +1828,7 @@ namespace chibios_rt { /** * @brief Embedded @p ::Mailbox structure. */ - ::Mailbox mb; + ::mailbox_t mb; /** * @brief Mailbox constructor. @@ -2066,9 +2067,9 @@ namespace chibios_rt { (cnt_t)(sizeof mb_buf / sizeof (msg_t))) { } }; -#endif /* CH_USE_MAILBOXES */ +#endif /* CH_CFG_USE_MAILBOXES */ -#if CH_USE_MEMPOOLS || defined(__DOXYGEN__) +#if CH_CFG_USE_MEMPOOLS || defined(__DOXYGEN__) /*------------------------------------------------------------------------* * chibios_rt::MemoryPool * *------------------------------------------------------------------------*/ @@ -2080,7 +2081,7 @@ namespace chibios_rt { /** * @brief Embedded @p ::MemoryPool structure. */ - ::MemoryPool pool; + ::memory_pool_t pool; /** * @brief MemoryPool constructor. @@ -2207,7 +2208,7 @@ namespace chibios_rt { loadArray(pool_buf, N); } }; -#endif /* CH_USE_MEMPOOLS */ +#endif /* CH_CFG_USE_MEMPOOLS */ /*------------------------------------------------------------------------* * chibios_rt::BaseSequentialStreamInterface * diff --git a/os/various/cpp_wrappers/syscalls_cpp.cpp b/os/various/cpp_wrappers/syscalls_cpp.cpp new file mode 100644 index 000000000..84a449a9f --- /dev/null +++ b/os/various/cpp_wrappers/syscalls_cpp.cpp @@ -0,0 +1,78 @@ +#include +#include + +#include "osal.h" + +#include "syscalls_cpp.hpp" + +/** + * + */ +#ifdef __cplusplus +extern "C" { +#endif +void _exit(int status){ + (void) status; + osalSysHalt("Unrealized"); + while(TRUE){} +} +#ifdef __cplusplus +} +#endif + +/** + * + */ +#ifdef __cplusplus +extern "C" { +#endif +pid_t _getpid(void){ + return 1; +} +#ifdef __cplusplus +} +#endif + +/** + * + */ +#undef errno +extern int errno; +#ifdef __cplusplus +extern "C" { +#endif +int _kill(int pid, int sig) { + (void)pid; + (void)sig; + errno = EINVAL; + return -1; +} +#ifdef __cplusplus +} +#endif + +/** + * + */ +#ifdef __cplusplus +extern "C" { +#endif +void _open_r(void){ + return; +} +#ifdef __cplusplus +} +#endif + +/** + * + */ +#ifdef __cplusplus +extern "C" { +#endif + void __cxa_pure_virtual() { + osalSysHalt("Pure virtual function call."); + } +#ifdef __cplusplus +} +#endif diff --git a/os/various/cpp_wrappers/syscalls_cpp.hpp b/os/various/cpp_wrappers/syscalls_cpp.hpp new file mode 100644 index 000000000..927f71f88 --- /dev/null +++ b/os/various/cpp_wrappers/syscalls_cpp.hpp @@ -0,0 +1,14 @@ +#ifndef SYSCALLS_CPP_HPP_ +#define SYSCALLS_CPP_HPP_ + +/* The ABI requires a 64-bit type. */ +__extension__ typedef int __guard __attribute__((mode (__DI__))); + +int __cxa_guard_acquire(__guard *); +void __cxa_guard_release (__guard *); +void __cxa_guard_abort (__guard *); + +void *__dso_handle = NULL; + + +#endif /* SYSCALLS_CPP_HPP_ */ -- cgit v1.2.3