Mercurial > flash_v2
changeset 1539:57cebf53b527
* include/kapi.h: Add throw specifications throughout.
* src/kapi.cxx: Ditto.
* include/sched.inl: Move include of thread.inl further down to
allow Cyg_Scheduler inlines to be defined first.
* include/thread.inl: Reorder destructors section and include
sched.inl right before it to solve mutual header dependency
problems.
| author | jlarmour |
|---|---|
| date | Mon, 15 Mar 2004 15:20:53 +0000 |
| parents | a7550c330045 |
| children | 1f2c3a031698 |
| files | packages/kernel/current/ChangeLog packages/kernel/current/include/kapi.h packages/kernel/current/include/sched.inl packages/kernel/current/include/thread.inl packages/kernel/current/src/common/kapi.cxx |
| diffstat | 5 files changed, 315 insertions(+), 299 deletions(-) [+] |
line wrap: on
line diff
--- a/packages/kernel/current/ChangeLog +++ b/packages/kernel/current/ChangeLog @@ -1,3 +1,13 @@ +2004-03-12 Jonathan Larmour <jifl@eCosCentric.com> + + * include/kapi.h: Add throw specifications throughout. + * src/kapi.cxx: Ditto. + * include/sched.inl: Move include of thread.inl further down to + allow Cyg_Scheduler inlines to be defined first. + * include/thread.inl: Reorder destructors section and include + sched.inl right before it to solve mutual header dependency + problems. + 2004-03-04 Jonathan Larmour <jifl@eCosCentric.com> * doc/kernel.sgml: Document cyg_thread_delete return value.
--- a/packages/kernel/current/include/kapi.h +++ b/packages/kernel/current/include/kapi.h @@ -130,21 +130,21 @@ typedef struct cyg_spinlock_t cyg_spinlo /* Scheduler operations */ /* Starts scheduler with created threads. Never returns. */ -void cyg_scheduler_start(void) CYGBLD_ATTRIB_NORET; +void cyg_scheduler_start(void) __THROW CYGBLD_ATTRIB_NORET; /* Lock and unlock the scheduler. When the scheduler is */ /* locked thread preemption is disabled. */ -void cyg_scheduler_lock(void); +void cyg_scheduler_lock(void) __THROW; -void cyg_scheduler_unlock(void); +void cyg_scheduler_unlock(void) __THROW; /* Just like 'cyg_scheduler_lock()', but never take the lock higher than 1 */ /* Thus this call is safe even if the scheduler is already locked and a */ /* subsequent call to 'cyg_scheduler_unlock()' will completely unlock. */ -void cyg_scheduler_safe_lock(void); +void cyg_scheduler_safe_lock(void) __THROW; /* Read the scheduler lock value. */ -cyg_ucount32 cyg_scheduler_read_lock(void); +cyg_ucount32 cyg_scheduler_read_lock(void) __THROW; /*---------------------------------------------------------------------------*/ /* Thread operations */ @@ -160,33 +160,33 @@ void cyg_thread_create( cyg_ucount32 stack_size, /* stack size, 0 = default */ cyg_handle_t *handle, /* returned thread handle */ cyg_thread *thread /* put thread here */ -); +) __THROW; -void cyg_thread_exit(void); +void cyg_thread_exit(void) __THROW; /* It may be necessary to arrange for the victim to run for it to disappear */ -cyg_bool_t cyg_thread_delete(cyg_handle_t thread); /* false if NOT deleted */ +cyg_bool_t cyg_thread_delete(cyg_handle_t thread) __THROW; /* false if NOT deleted */ -void cyg_thread_suspend(cyg_handle_t thread); +void cyg_thread_suspend(cyg_handle_t thread) __THROW; -void cyg_thread_resume(cyg_handle_t thread); +void cyg_thread_resume(cyg_handle_t thread) __THROW; -void cyg_thread_kill(cyg_handle_t thread); +void cyg_thread_kill(cyg_handle_t thread) __THROW; -void cyg_thread_release(cyg_handle_t thread); +void cyg_thread_release(cyg_handle_t thread) __THROW; -void cyg_thread_yield(void); +void cyg_thread_yield(void) __THROW; -cyg_handle_t cyg_thread_self(void); +cyg_handle_t cyg_thread_self(void) __THROW; -cyg_handle_t cyg_thread_idle_thread(void); +cyg_handle_t cyg_thread_idle_thread(void) __THROW; /* Priority manipulation */ -void cyg_thread_set_priority(cyg_handle_t thread, cyg_priority_t priority ); +void cyg_thread_set_priority(cyg_handle_t thread, cyg_priority_t priority ) __THROW; -cyg_priority_t cyg_thread_get_priority(cyg_handle_t thread); -cyg_priority_t cyg_thread_get_current_priority(cyg_handle_t thread); +cyg_priority_t cyg_thread_get_priority(cyg_handle_t thread) __THROW; +cyg_priority_t cyg_thread_get_current_priority(cyg_handle_t thread) __THROW; /* Deadline scheduling control (optional) */ @@ -194,17 +194,17 @@ void cyg_thread_deadline_wait( cyg_tick_count_t start_time, /* abs earliest start time */ cyg_tick_count_t run_time, /* worst case execution time */ cyg_tick_count_t deadline /* absolute deadline */ -); +) __THROW; -void cyg_thread_delay(cyg_tick_count_t delay); +void cyg_thread_delay(cyg_tick_count_t delay) __THROW; /* Stack information */ -cyg_addrword_t cyg_thread_get_stack_base(cyg_handle_t thread); +cyg_addrword_t cyg_thread_get_stack_base(cyg_handle_t thread) __THROW; -cyg_uint32 cyg_thread_get_stack_size(cyg_handle_t thread); +cyg_uint32 cyg_thread_get_stack_size(cyg_handle_t thread) __THROW; #ifdef CYGFUN_KERNEL_THREADS_STACK_MEASUREMENT -cyg_uint32 cyg_thread_measure_stack_usage(cyg_handle_t thread); +cyg_uint32 cyg_thread_measure_stack_usage(cyg_handle_t thread) __THROW; #endif /*---------------------------------------------------------------------------*/ @@ -223,30 +223,30 @@ typedef struct cyg_uint32 stack_used; } cyg_thread_info; -cyg_bool_t cyg_thread_get_next( cyg_handle_t *thread, cyg_uint16 *id ); +cyg_bool_t cyg_thread_get_next( cyg_handle_t *thread, cyg_uint16 *id ) __THROW; cyg_bool_t cyg_thread_get_info( cyg_handle_t thread, cyg_uint16 id, - cyg_thread_info *info ); + cyg_thread_info *info ) __THROW; -cyg_uint16 cyg_thread_get_id( cyg_handle_t thread ); +cyg_uint16 cyg_thread_get_id( cyg_handle_t thread ) __THROW; -cyg_handle_t cyg_thread_find( cyg_uint16 id ); +cyg_handle_t cyg_thread_find( cyg_uint16 id ) __THROW; /*---------------------------------------------------------------------------*/ /* Per-thread Data */ #ifdef CYGVAR_KERNEL_THREADS_DATA -cyg_ucount32 cyg_thread_new_data_index(void); +cyg_ucount32 cyg_thread_new_data_index(void) __THROW; -void cyg_thread_free_data_index(cyg_ucount32 index); +void cyg_thread_free_data_index(cyg_ucount32 index) __THROW; -CYG_ADDRWORD cyg_thread_get_data(cyg_ucount32 index); +CYG_ADDRWORD cyg_thread_get_data(cyg_ucount32 index) __THROW; -CYG_ADDRWORD *cyg_thread_get_data_ptr(cyg_ucount32 index); +CYG_ADDRWORD *cyg_thread_get_data_ptr(cyg_ucount32 index) __THROW; -void cyg_thread_set_data(cyg_ucount32 index, CYG_ADDRWORD data); +void cyg_thread_set_data(cyg_ucount32 index, CYG_ADDRWORD data) __THROW; #endif @@ -258,9 +258,9 @@ void cyg_thread_set_data(cyg_ucount32 in typedef void (*cyg_thread_destructor_fn)(cyg_addrword_t); cyg_bool_t cyg_thread_add_destructor( cyg_thread_destructor_fn fn, - cyg_addrword_t data ); + cyg_addrword_t data ) __THROW; cyg_bool_t cyg_thread_rem_destructor( cyg_thread_destructor_fn fn, - cyg_addrword_t data ); + cyg_addrword_t data ) __THROW; #endif /*---------------------------------------------------------------------------*/ @@ -276,19 +276,19 @@ void cyg_exception_set_handler( cyg_addrword_t new_data, cyg_exception_handler_t **old_handler, cyg_addrword_t *old_data -); +) __THROW; /* Clear exception hander to default value */ void cyg_exception_clear_handler( cyg_code_t exception_number -); +) __THROW; /* Invoke exception handler */ void cyg_exception_call_handler( cyg_handle_t thread, cyg_code_t exception_number, cyg_addrword_t exception_info -); +) __THROW; /*---------------------------------------------------------------------------*/ @@ -314,54 +314,54 @@ void cyg_interrupt_create( cyg_DSR_t *dsr, /* Deferred Service Routine */ cyg_handle_t *handle, /* returned handle */ cyg_interrupt *intr /* put interrupt here */ -); +) __THROW; -void cyg_interrupt_delete( cyg_handle_t interrupt ); +void cyg_interrupt_delete( cyg_handle_t interrupt ) __THROW; -void cyg_interrupt_attach( cyg_handle_t interrupt ); +void cyg_interrupt_attach( cyg_handle_t interrupt ) __THROW; -void cyg_interrupt_detach( cyg_handle_t interrupt ); +void cyg_interrupt_detach( cyg_handle_t interrupt ) __THROW; /* VSR manipulation */ void cyg_interrupt_get_vsr( cyg_vector_t vector, /* vector to get */ cyg_VSR_t **vsr /* vsr got */ -); +) __THROW; void cyg_interrupt_set_vsr( cyg_vector_t vector, /* vector to set */ cyg_VSR_t *vsr /* vsr to set */ -); +) __THROW; /* CPU level interrupt mask */ -void cyg_interrupt_disable(void); +void cyg_interrupt_disable(void) __THROW; -void cyg_interrupt_enable(void); +void cyg_interrupt_enable(void) __THROW; /* Interrupt controller access */ -void cyg_interrupt_mask(cyg_vector_t vector); -void cyg_interrupt_mask_intunsafe(cyg_vector_t vector); +void cyg_interrupt_mask(cyg_vector_t vector) __THROW; +void cyg_interrupt_mask_intunsafe(cyg_vector_t vector) __THROW; -void cyg_interrupt_unmask(cyg_vector_t vector); -void cyg_interrupt_unmask_intunsafe(cyg_vector_t vector); +void cyg_interrupt_unmask(cyg_vector_t vector) __THROW; +void cyg_interrupt_unmask_intunsafe(cyg_vector_t vector) __THROW; -void cyg_interrupt_acknowledge(cyg_vector_t vector); +void cyg_interrupt_acknowledge(cyg_vector_t vector) __THROW; void cyg_interrupt_configure( cyg_vector_t vector, /* vector to configure */ cyg_bool_t level, /* level or edge triggered */ cyg_bool_t up /* rising/faling edge, high/low level*/ -); +) __THROW; void cyg_interrupt_set_cpu( cyg_vector_t vector, /* vector to control */ cyg_cpu_t cpu /* CPU to set */ -); +) __THROW; cyg_cpu_t cyg_interrupt_get_cpu( cyg_vector_t vector /* vector to control */ -); +) __THROW; /*---------------------------------------------------------------------------*/ /* Counters, Clocks and Alarms */ @@ -369,24 +369,24 @@ cyg_cpu_t cyg_interrupt_get_cpu( void cyg_counter_create( cyg_handle_t *handle, /* returned counter handle */ cyg_counter *counter /* put counter here */ -); +) __THROW; -void cyg_counter_delete(cyg_handle_t counter); +void cyg_counter_delete(cyg_handle_t counter) __THROW; /* Return current value of counter */ -cyg_tick_count_t cyg_counter_current_value(cyg_handle_t counter); +cyg_tick_count_t cyg_counter_current_value(cyg_handle_t counter) __THROW; /* Set new current value */ void cyg_counter_set_value( cyg_handle_t counter, cyg_tick_count_t new_value -); +) __THROW; /* Advance counter by one tick */ -void cyg_counter_tick(cyg_handle_t counter); +void cyg_counter_tick(cyg_handle_t counter) __THROW; /* Advance counter by multiple ticks */ -void cyg_counter_multi_tick(cyg_handle_t counter, cyg_tick_count_t _ticks); +void cyg_counter_multi_tick(cyg_handle_t counter, cyg_tick_count_t _ticks) __THROW; #define CYG_RESOLUTION_T_MEMBERS \ @@ -403,32 +403,32 @@ void cyg_clock_create( cyg_resolution_t resolution, /* Initial resolution */ cyg_handle_t *handle, /* Returned clock handle */ cyg_clock *clock /* put clock here */ -); +) __THROW; -void cyg_clock_delete(cyg_handle_t clock); +void cyg_clock_delete(cyg_handle_t clock) __THROW; /* convert a clock handle to a counter handle so we can use the */ /* counter API on it. */ void cyg_clock_to_counter( cyg_handle_t clock, cyg_handle_t *counter -); +) __THROW; void cyg_clock_set_resolution( cyg_handle_t clock, cyg_resolution_t resolution /* New resolution */ -); +) __THROW; -cyg_resolution_t cyg_clock_get_resolution(cyg_handle_t clock); +cyg_resolution_t cyg_clock_get_resolution(cyg_handle_t clock) __THROW; /* handle of real time clock */ -cyg_handle_t cyg_real_time_clock(void); +cyg_handle_t cyg_real_time_clock(void) __THROW; /* returns value of real time clock's counter. This is the same as: (cyg_clock_to_counter(cyg_real_time_clock(), &h), cyg_counter_current_value(h)) */ -cyg_tick_count_t cyg_current_time(void); +cyg_tick_count_t cyg_current_time(void) __THROW; /* Alarm handler function */ typedef void cyg_alarm_t(cyg_handle_t alarm, cyg_addrword_t data); @@ -439,67 +439,67 @@ void cyg_alarm_create( cyg_addrword_t data, /* Call-back data */ cyg_handle_t *handle, /* Returned alarm object */ cyg_alarm *alarm /* put alarm here */ -); +) __THROW; /* Disable alarm, detach from counter and invalidate handles */ -void cyg_alarm_delete( cyg_handle_t alarm); +void cyg_alarm_delete( cyg_handle_t alarm) __THROW; void cyg_alarm_initialize( cyg_handle_t alarm, cyg_tick_count_t trigger, /* Absolute trigger time */ cyg_tick_count_t interval /* Relative retrigger interval */ -); +) __THROW; void cyg_alarm_get_times( cyg_handle_t alarm, cyg_tick_count_t *trigger, /* Next trigger time */ cyg_tick_count_t *interval /* Current interval */ -); +) __THROW; -void cyg_alarm_enable( cyg_handle_t alarm ); +void cyg_alarm_enable( cyg_handle_t alarm ) __THROW; -void cyg_alarm_disable( cyg_handle_t alarm ); +void cyg_alarm_disable( cyg_handle_t alarm ) __THROW; /*---------------------------------------------------------------------------*/ /* Mail boxes */ void cyg_mbox_create( cyg_handle_t *handle, cyg_mbox *mbox -); +) __THROW; -void cyg_mbox_delete(cyg_handle_t mbox); +void cyg_mbox_delete(cyg_handle_t mbox) __THROW; -void *cyg_mbox_get(cyg_handle_t mbox); +void *cyg_mbox_get(cyg_handle_t mbox) __THROW; #ifdef CYGFUN_KERNEL_THREADS_TIMER void *cyg_mbox_timed_get( cyg_handle_t mbox, cyg_tick_count_t abstime - ); + ) __THROW; #endif -void *cyg_mbox_tryget(cyg_handle_t mbox); +void *cyg_mbox_tryget(cyg_handle_t mbox) __THROW; -void *cyg_mbox_peek_item(cyg_handle_t mbox); +void *cyg_mbox_peek_item(cyg_handle_t mbox) __THROW; #ifdef CYGMFN_KERNEL_SYNCH_MBOXT_PUT_CAN_WAIT -cyg_bool_t cyg_mbox_put(cyg_handle_t mbox, void *item); +cyg_bool_t cyg_mbox_put(cyg_handle_t mbox, void *item) __THROW; #ifdef CYGFUN_KERNEL_THREADS_TIMER cyg_bool_t cyg_mbox_timed_put( cyg_handle_t mbox, void *item, cyg_tick_count_t abstime - ); + ) __THROW; #endif #endif -cyg_bool_t cyg_mbox_tryput(cyg_handle_t mbox, void *item); +cyg_bool_t cyg_mbox_tryput(cyg_handle_t mbox, void *item) __THROW; -cyg_count32 cyg_mbox_peek(cyg_handle_t mbox); +cyg_count32 cyg_mbox_peek(cyg_handle_t mbox) __THROW; -cyg_bool_t cyg_mbox_waiting_to_get(cyg_handle_t mbox); +cyg_bool_t cyg_mbox_waiting_to_get(cyg_handle_t mbox) __THROW; -cyg_bool_t cyg_mbox_waiting_to_put(cyg_handle_t mbox); +cyg_bool_t cyg_mbox_waiting_to_put(cyg_handle_t mbox) __THROW; /*-----------------------------------------------------------------------*/ @@ -518,24 +518,24 @@ cyg_bool_t cyg_mbox_waiting_to_put(cyg_h void cyg_semaphore_init( cyg_sem_t *sem, /* Semaphore to init */ cyg_count32 val /* Initial semaphore value */ -); +) __THROW; -void cyg_semaphore_destroy( cyg_sem_t *sem ); +void cyg_semaphore_destroy( cyg_sem_t *sem ) __THROW; -cyg_bool_t cyg_semaphore_wait( cyg_sem_t *sem ); +cyg_bool_t cyg_semaphore_wait( cyg_sem_t *sem ) __THROW; #ifdef CYGFUN_KERNEL_THREADS_TIMER cyg_bool_t cyg_semaphore_timed_wait( cyg_sem_t *sem, cyg_tick_count_t abstime - ); + ) __THROW; #endif -cyg_bool_t cyg_semaphore_trywait( cyg_sem_t *sem ); +cyg_bool_t cyg_semaphore_trywait( cyg_sem_t *sem ) __THROW; -void cyg_semaphore_post( cyg_sem_t *sem ); +void cyg_semaphore_post( cyg_sem_t *sem ) __THROW; -void cyg_semaphore_peek( cyg_sem_t *sem, cyg_count32 *val ); +void cyg_semaphore_peek( cyg_sem_t *sem, cyg_count32 *val ) __THROW; /*---------------------------------------------------------------------------*/ /* Flags */ @@ -548,17 +548,17 @@ typedef cyg_uint8 cyg_flag_mode_t; void cyg_flag_init( cyg_flag_t *flag /* Flag to init */ -); +) __THROW; -void cyg_flag_destroy( cyg_flag_t *flag ); +void cyg_flag_destroy( cyg_flag_t *flag ) __THROW; /* bitwise-or in the bits in value; awaken any waiting tasks whose condition is now satisfied */ -void cyg_flag_setbits( cyg_flag_t *flag, cyg_flag_value_t value); +void cyg_flag_setbits( cyg_flag_t *flag, cyg_flag_value_t value) __THROW; /* bitwise-and with the the bits in value; this clears the bits which are not set in value. No waiting task can be awoken. */ -void cyg_flag_maskbits( cyg_flag_t *flag, cyg_flag_value_t value); +void cyg_flag_maskbits( cyg_flag_t *flag, cyg_flag_value_t value) __THROW; /* wait for the flag value to match the pattern, according to the mode. If mode includes CLR, set the flag value to zero when @@ -567,23 +567,23 @@ void cyg_flag_maskbits( cyg_flag_t *flag Value must not itself be zero. */ cyg_flag_value_t cyg_flag_wait( cyg_flag_t *flag, cyg_flag_value_t pattern, - cyg_flag_mode_t mode ); + cyg_flag_mode_t mode ) __THROW; #ifdef CYGFUN_KERNEL_THREADS_TIMER cyg_flag_value_t cyg_flag_timed_wait( cyg_flag_t *flag, cyg_flag_value_t pattern, cyg_flag_mode_t mode, - cyg_tick_count_t abstime ); + cyg_tick_count_t abstime ) __THROW; #endif cyg_flag_value_t cyg_flag_poll( cyg_flag_t *flag, cyg_flag_value_t pattern, - cyg_flag_mode_t mode ); + cyg_flag_mode_t mode ) __THROW; -cyg_flag_value_t cyg_flag_peek( cyg_flag_t *flag ); +cyg_flag_value_t cyg_flag_peek( cyg_flag_t *flag ) __THROW; -cyg_bool_t cyg_flag_waiting( cyg_flag_t *flag ); +cyg_bool_t cyg_flag_waiting( cyg_flag_t *flag ) __THROW; /*---------------------------------------------------------------------------*/ /* Mutex */ @@ -599,24 +599,24 @@ enum cyg_mutex_protocol void cyg_mutex_init( cyg_mutex_t *mutex /* Mutex to init */ -); +) __THROW; -void cyg_mutex_destroy( cyg_mutex_t *mutex ); +void cyg_mutex_destroy( cyg_mutex_t *mutex ) __THROW; -cyg_bool_t cyg_mutex_lock( cyg_mutex_t *mutex ); +cyg_bool_t cyg_mutex_lock( cyg_mutex_t *mutex ) __THROW; -cyg_bool_t cyg_mutex_trylock( cyg_mutex_t *mutex ); +cyg_bool_t cyg_mutex_trylock( cyg_mutex_t *mutex ) __THROW; -void cyg_mutex_unlock( cyg_mutex_t *mutex ); +void cyg_mutex_unlock( cyg_mutex_t *mutex ) __THROW; -void cyg_mutex_release( cyg_mutex_t *mutex ); +void cyg_mutex_release( cyg_mutex_t *mutex ) __THROW; #ifdef CYGSEM_KERNEL_SYNCH_MUTEX_PRIORITY_INVERSION_PROTOCOL_CEILING -void cyg_mutex_set_ceiling( cyg_mutex_t *mutex, cyg_priority_t priority ); +void cyg_mutex_set_ceiling( cyg_mutex_t *mutex, cyg_priority_t priority ) __THROW; #endif #ifdef CYGSEM_KERNEL_SYNCH_MUTEX_PRIORITY_INVERSION_PROTOCOL_DYNAMIC -void cyg_mutex_set_protocol ( cyg_mutex_t *mutex, enum cyg_mutex_protocol protocol ); +void cyg_mutex_set_protocol ( cyg_mutex_t *mutex, enum cyg_mutex_protocol protocol ) __THROW; #endif /*---------------------------------------------------------------------------*/ @@ -625,21 +625,21 @@ void cyg_mutex_set_protocol ( cyg_mutex_ void cyg_cond_init( cyg_cond_t *cond, /* condition variable to init */ cyg_mutex_t *mutex /* associated mutex */ -); +) __THROW; -void cyg_cond_destroy( cyg_cond_t *cond ); +void cyg_cond_destroy( cyg_cond_t *cond ) __THROW; -cyg_bool_t cyg_cond_wait( cyg_cond_t *cond ); +cyg_bool_t cyg_cond_wait( cyg_cond_t *cond ) __THROW; -void cyg_cond_signal( cyg_cond_t *cond ); +void cyg_cond_signal( cyg_cond_t *cond ) __THROW; -void cyg_cond_broadcast( cyg_cond_t *cond ); +void cyg_cond_broadcast( cyg_cond_t *cond ) __THROW; #ifdef CYGMFN_KERNEL_SYNCH_CONDVAR_TIMED_WAIT cyg_bool_t cyg_cond_timed_wait( cyg_cond_t *cond, cyg_tick_count_t abstime - ); + ) __THROW; #endif /*---------------------------------------------------------------------------*/ @@ -648,23 +648,23 @@ cyg_bool_t cyg_cond_timed_wait( void cyg_spinlock_init( cyg_spinlock_t *lock, /* spinlock to initialize */ cyg_bool_t locked /* init locked or unlocked */ -); +) __THROW; -void cyg_spinlock_destroy( cyg_spinlock_t *lock ); +void cyg_spinlock_destroy( cyg_spinlock_t *lock ) __THROW; -void cyg_spinlock_spin( cyg_spinlock_t *lock ); +void cyg_spinlock_spin( cyg_spinlock_t *lock ) __THROW; -void cyg_spinlock_clear( cyg_spinlock_t *lock ); +void cyg_spinlock_clear( cyg_spinlock_t *lock ) __THROW; -cyg_bool_t cyg_spinlock_try( cyg_spinlock_t *lock ); +cyg_bool_t cyg_spinlock_try( cyg_spinlock_t *lock ) __THROW; -cyg_bool_t cyg_spinlock_test( cyg_spinlock_t *lock ); +cyg_bool_t cyg_spinlock_test( cyg_spinlock_t *lock ) __THROW; void cyg_spinlock_spin_intsave( cyg_spinlock_t *lock, - cyg_addrword_t *istate ); + cyg_addrword_t *istate ) __THROW; void cyg_spinlock_clear_intsave( cyg_spinlock_t *lock, - cyg_addrword_t istate ); + cyg_addrword_t istate ) __THROW; /*---------------------------------------------------------------------------*/ #ifdef __cplusplus
--- a/packages/kernel/current/include/sched.inl +++ b/packages/kernel/current/include/sched.inl @@ -61,8 +61,7 @@ //========================================================================== #include <cyg/kernel/instrmnt.h> - -#include <cyg/kernel/thread.inl> // we use some thread inlines here +#include <cyg/hal/hal_arch.h> // ------------------------------------------------------------------------- // Inlines for Cyg_Scheduler class @@ -152,6 +151,8 @@ inline void Cyg_Scheduler::unlock_simple // ------------------------------------------------------------------------- // Inlines for Cyg_SchedThread class +#include <cyg/kernel/thread.inl> // we use some thread inlines here + inline void Cyg_SchedThread::remove() { if( queue != NULL )
--- a/packages/kernel/current/include/thread.inl +++ b/packages/kernel/current/include/thread.inl @@ -518,57 +518,6 @@ inline void Cyg_Thread::set_data( Cyg_Th // ------------------------------------------------------------------------- -#ifdef CYGPKG_KERNEL_THREADS_DESTRUCTORS - -// Add and remove destructors. Returns true on success, false on failure. -inline cyg_bool -Cyg_Thread::add_destructor( destructor_fn fn, CYG_ADDRWORD data ) -{ - cyg_ucount16 i; -#ifndef CYGSEM_KERNEL_THREADS_DESTRUCTORS_PER_THREAD - Cyg_Scheduler::lock(); -#endif - for (i=0; i<CYGNUM_KERNEL_THREADS_DESTRUCTORS; i++) { - if (NULL == destructors[i].fn) { - destructors[i].data = data; - destructors[i].fn = fn; -#ifndef CYGSEM_KERNEL_THREADS_DESTRUCTORS_PER_THREAD - Cyg_Scheduler::unlock(); -#endif - return true; - } - } -#ifndef CYGSEM_KERNEL_THREADS_DESTRUCTORS_PER_THREAD - Cyg_Scheduler::unlock(); -#endif - return false; -} - -inline cyg_bool -Cyg_Thread::rem_destructor( destructor_fn fn, CYG_ADDRWORD data ) -{ - cyg_ucount16 i; -#ifndef CYGSEM_KERNEL_THREADS_DESTRUCTORS_PER_THREAD - Cyg_Scheduler::lock(); -#endif - for (i=0; i<CYGNUM_KERNEL_THREADS_DESTRUCTORS; i++) { - if (destructors[i].fn == fn && destructors[i].data == data) { - destructors[i].fn = NULL; -#ifndef CYGSEM_KERNEL_THREADS_DESTRUCTORS_PER_THREAD - Cyg_Scheduler::unlock(); -#endif - return true; - } - } -#ifndef CYGSEM_KERNEL_THREADS_DESTRUCTORS_PER_THREAD - Cyg_Scheduler::unlock(); -#endif - return false; -} -#endif - -// ------------------------------------------------------------------------- - #ifdef CYGVAR_KERNEL_THREADS_NAME inline char *Cyg_Thread::get_name() @@ -684,5 +633,61 @@ inline cyg_bool Cyg_ThreadQueue::empty() } // ------------------------------------------------------------------------- + +#ifdef CYGPKG_KERNEL_THREADS_DESTRUCTORS + +#ifndef CYGSEM_KERNEL_THREADS_DESTRUCTORS_PER_THREAD +# include <cyg/kernel/sched.inl> +#endif + +// Add and remove destructors. Returns true on success, false on failure. +inline cyg_bool +Cyg_Thread::add_destructor( destructor_fn fn, CYG_ADDRWORD data ) +{ + cyg_ucount16 i; +#ifndef CYGSEM_KERNEL_THREADS_DESTRUCTORS_PER_THREAD + Cyg_Scheduler::lock(); +#endif + for (i=0; i<CYGNUM_KERNEL_THREADS_DESTRUCTORS; i++) { + if (NULL == destructors[i].fn) { + destructors[i].data = data; + destructors[i].fn = fn; +#ifndef CYGSEM_KERNEL_THREADS_DESTRUCTORS_PER_THREAD + Cyg_Scheduler::unlock(); +#endif + return true; + } + } +#ifndef CYGSEM_KERNEL_THREADS_DESTRUCTORS_PER_THREAD + Cyg_Scheduler::unlock(); +#endif + return false; +} + +inline cyg_bool +Cyg_Thread::rem_destructor( destructor_fn fn, CYG_ADDRWORD data ) +{ + cyg_ucount16 i; +#ifndef CYGSEM_KERNEL_THREADS_DESTRUCTORS_PER_THREAD + Cyg_Scheduler::lock(); +#endif + for (i=0; i<CYGNUM_KERNEL_THREADS_DESTRUCTORS; i++) { + if (destructors[i].fn == fn && destructors[i].data == data) { + destructors[i].fn = NULL; +#ifndef CYGSEM_KERNEL_THREADS_DESTRUCTORS_PER_THREAD + Cyg_Scheduler::unlock(); +#endif + return true; + } + } +#ifndef CYGSEM_KERNEL_THREADS_DESTRUCTORS_PER_THREAD + Cyg_Scheduler::unlock(); +#endif + return false; +} +#endif + +// ------------------------------------------------------------------------- + #endif // ifndef CYGONCE_KERNEL_THREAD_INL // EOF thread.inl
--- a/packages/kernel/current/src/common/kapi.cxx +++ b/packages/kernel/current/src/common/kapi.cxx @@ -109,13 +109,13 @@ CYG_MACRO_END /* Scheduler operations */ /* Starts scheduler with created threads. Never returns. */ -externC void cyg_scheduler_start(void) +externC void cyg_scheduler_start(void) __THROW { Cyg_Scheduler::start(); } /* Lock the scheduler. */ -externC void cyg_scheduler_lock(void) +externC void cyg_scheduler_lock(void) __THROW { Cyg_Scheduler::lock(); // get_sched_lock() is unsigned, see below "cyg_ucount32 lock" @@ -124,7 +124,7 @@ externC void cyg_scheduler_lock(void) } /* Lock the scheduler, but never more than level=1. */ -externC void cyg_scheduler_safe_lock(void) +externC void cyg_scheduler_safe_lock(void) __THROW { Cyg_Scheduler::lock(); cyg_ucount32 slock = Cyg_Scheduler::get_sched_lock(); @@ -136,7 +136,7 @@ externC void cyg_scheduler_safe_lock(voi } /* Unlock the scheduler. */ -externC void cyg_scheduler_unlock(void) +externC void cyg_scheduler_unlock(void) __THROW { cyg_ucount32 slock = Cyg_Scheduler::get_sched_lock(); CYG_ASSERT( 0 < slock, "Scheduler not locked" ); @@ -146,7 +146,7 @@ externC void cyg_scheduler_unlock(void) } /* Read the scheduler lock value. */ -externC cyg_ucount32 cyg_scheduler_read_lock(void) +externC cyg_ucount32 cyg_scheduler_read_lock(void) __THROW { cyg_ucount32 slock = Cyg_Scheduler::get_sched_lock(); return slock; @@ -164,7 +164,7 @@ externC void cyg_thread_create( cyg_ucount32 stack_size, /* stack size, 0 = default */ cyg_handle_t *handle, /* returned thread handle */ cyg_thread *thread /* put thread here */ -) +) __THROW { CYG_ASSERT_SIZES( cyg_thread, Cyg_Thread ); @@ -182,12 +182,12 @@ externC void cyg_thread_create( *handle = (cyg_handle_t)thread; } -externC void cyg_thread_exit() +externC void cyg_thread_exit() __THROW { Cyg_Thread::exit(); } -externC cyg_bool_t cyg_thread_delete( cyg_handle_t thread ) +externC cyg_bool_t cyg_thread_delete( cyg_handle_t thread ) __THROW { Cyg_Thread *th = (Cyg_Thread *)thread; if( th->get_state() != Cyg_Thread::EXITED ) @@ -198,12 +198,12 @@ externC cyg_bool_t cyg_thread_delete( cy return true; } -externC void cyg_thread_suspend(cyg_handle_t thread) +externC void cyg_thread_suspend(cyg_handle_t thread) __THROW { ((Cyg_Thread *)thread)->suspend(); } -externC void cyg_thread_resume(cyg_handle_t thread) +externC void cyg_thread_resume(cyg_handle_t thread) __THROW { Cyg_Thread *th = (Cyg_Thread *)thread; @@ -216,33 +216,33 @@ externC void cyg_thread_resume(cyg_handl th->resume(); } -externC void cyg_thread_kill( cyg_handle_t thread) +externC void cyg_thread_kill( cyg_handle_t thread) __THROW { ((Cyg_Thread *)thread)->kill(); } -externC void cyg_thread_release( cyg_handle_t thread) +externC void cyg_thread_release( cyg_handle_t thread) __THROW { ((Cyg_Thread *)thread)->release(); } -externC void cyg_thread_yield() +externC void cyg_thread_yield() __THROW { Cyg_Thread::yield(); } -externC cyg_handle_t cyg_thread_self() +externC cyg_handle_t cyg_thread_self() __THROW { return (cyg_handle_t)Cyg_Thread::self(); } -externC cyg_uint16 cyg_thread_get_id( cyg_handle_t thread) +externC cyg_uint16 cyg_thread_get_id( cyg_handle_t thread) __THROW { return ((Cyg_Thread *)thread)->get_unique_id(); } // idle thread is not really a plain CygThread; danger. -externC cyg_handle_t cyg_thread_idle_thread() +externC cyg_handle_t cyg_thread_idle_thread() __THROW { extern Cyg_Thread idle_thread; return (cyg_handle_t)&idle_thread; @@ -250,7 +250,7 @@ externC cyg_handle_t cyg_thread_idle_thr /* Priority manipulation */ externC void cyg_thread_set_priority( - cyg_handle_t thread, cyg_priority_t priority ) + cyg_handle_t thread, cyg_priority_t priority ) __THROW { #ifdef CYGIMP_THREAD_PRIORITY ((Cyg_Thread *)thread)->set_priority(priority); @@ -260,7 +260,7 @@ externC void cyg_thread_set_priority( /* Get the normal priority, ie without any applied mutex inheritance or * ceiling protocol. */ -externC cyg_priority_t cyg_thread_get_priority(cyg_handle_t thread) +externC cyg_priority_t cyg_thread_get_priority(cyg_handle_t thread) __THROW { #ifdef CYGIMP_THREAD_PRIORITY return ((Cyg_Thread *)thread)->get_priority(); @@ -272,7 +272,7 @@ externC cyg_priority_t cyg_thread_get_pr /* Get the current priority, ie any applied mutex inheritance or * ceiling protocol. */ -externC cyg_priority_t cyg_thread_get_current_priority(cyg_handle_t thread) +externC cyg_priority_t cyg_thread_get_current_priority(cyg_handle_t thread) __THROW { #ifdef CYGIMP_THREAD_PRIORITY return ((Cyg_Thread *)thread)->get_current_priority(); @@ -287,29 +287,29 @@ externC void cyg_thread_deadline_wait( cyg_tick_count_t start_time, /* abs earliest start time */ cyg_tick_count_t run_time, /* worst case execution time */ cyg_tick_count_t deadline /* absolute deadline */ -) +) __THROW { CYG_ASSERT(0,"Not implemented"); } -externC void cyg_thread_delay(cyg_tick_count_t delay) +externC void cyg_thread_delay(cyg_tick_count_t delay) __THROW { Cyg_Thread::self()->delay(delay); } /* Stack information */ -externC cyg_addrword_t cyg_thread_get_stack_base(cyg_handle_t thread) +externC cyg_addrword_t cyg_thread_get_stack_base(cyg_handle_t thread) __THROW { return ((Cyg_Thread *)thread)->get_stack_base(); } -externC cyg_uint32 cyg_thread_get_stack_size(cyg_handle_t thread) +externC cyg_uint32 cyg_thread_get_stack_size(cyg_handle_t thread) __THROW { return ((Cyg_Thread *)thread)->get_stack_size(); } #ifdef CYGFUN_KERNEL_THREADS_STACK_MEASUREMENT -externC cyg_uint32 cyg_thread_measure_stack_usage(cyg_handle_t thread) +externC cyg_uint32 cyg_thread_measure_stack_usage(cyg_handle_t thread) __THROW { return ((Cyg_Thread *)thread)->measure_stack_usage(); } @@ -320,7 +320,7 @@ externC cyg_uint32 cyg_thread_measure_st #ifdef CYGVAR_KERNEL_THREADS_LIST -cyg_bool_t cyg_thread_get_next( cyg_handle_t *current, cyg_uint16 *id ) +cyg_bool_t cyg_thread_get_next( cyg_handle_t *current, cyg_uint16 *id ) __THROW { cyg_bool_t result = true; @@ -363,7 +363,7 @@ cyg_bool_t cyg_thread_get_next( cyg_hand return result; } -cyg_handle_t cyg_thread_find( cyg_uint16 id ) +cyg_handle_t cyg_thread_find( cyg_uint16 id ) __THROW { Cyg_Scheduler::lock(); @@ -386,7 +386,7 @@ cyg_handle_t cyg_thread_find( cyg_uint16 cyg_bool_t cyg_thread_get_info( cyg_handle_t threadh, cyg_uint16 id, - cyg_thread_info *info ) + cyg_thread_info *info ) __THROW { cyg_bool_t result = true; Cyg_Thread *thread = (Cyg_Thread *)threadh; @@ -430,30 +430,30 @@ cyg_bool_t cyg_thread_get_info( cyg_hand #ifdef CYGVAR_KERNEL_THREADS_DATA -externC cyg_ucount32 cyg_thread_new_data_index() +externC cyg_ucount32 cyg_thread_new_data_index() __THROW { Cyg_Thread::cyg_data_index index = Cyg_Thread::new_data_index(); CYG_ASSERT(index >= 0, "failed to allocate data index" ); return index; } -externC void cyg_thread_free_data_index(cyg_ucount32 index) +externC void cyg_thread_free_data_index(cyg_ucount32 index) __THROW { Cyg_Thread::free_data_index(index); } -externC CYG_ADDRWORD cyg_thread_get_data(cyg_ucount32 index) +externC CYG_ADDRWORD cyg_thread_get_data(cyg_ucount32 index) __THROW { return Cyg_Thread::get_data(index); } -externC CYG_ADDRWORD *cyg_thread_get_data_ptr(cyg_ucount32 index) +externC CYG_ADDRWORD *cyg_thread_get_data_ptr(cyg_ucount32 index) __THROW { return Cyg_Thread::get_data_ptr(index); } externC void cyg_thread_set_data(cyg_ucount32 index, CYG_ADDRWORD -data) +data) __THROW { Cyg_Thread::self()->set_data(index, data); } @@ -465,14 +465,14 @@ data) #ifdef CYGPKG_KERNEL_THREADS_DESTRUCTORS __externC cyg_bool_t cyg_thread_add_destructor( cyg_thread_destructor_fn fn, - cyg_addrword_t data ) + cyg_addrword_t data ) __THROW { return Cyg_Thread::self()->add_destructor( fn, data ); } __externC cyg_bool_t cyg_thread_rem_destructor( cyg_thread_destructor_fn fn, - cyg_addrword_t data ) + cyg_addrword_t data ) __THROW { return Cyg_Thread::self()->rem_destructor( fn, data ); } @@ -488,7 +488,7 @@ externC void cyg_exception_set_handler( cyg_addrword_t new_data, cyg_exception_handler_t **old_handler, cyg_addrword_t *old_data -) +) __THROW { Cyg_Thread::register_exception( exception_number, @@ -502,7 +502,7 @@ externC void cyg_exception_set_handler( /* Clear exception handler to default */ externC void cyg_exception_clear_handler( cyg_code_t exception_number -) +) __THROW { Cyg_Thread::deregister_exception( exception_number ); } @@ -512,7 +512,7 @@ externC void cyg_exception_call_handler( cyg_handle_t thread, cyg_code_t exception_number, cyg_addrword_t error_code -) +) __THROW { Cyg_Thread *t = (Cyg_Thread *)thread; @@ -531,7 +531,7 @@ externC void cyg_interrupt_create( cyg_DSR_t *dsr, /* Deferred Service Routine */ cyg_handle_t *handle, /* returned handle */ cyg_interrupt *intr /* put interrupt here */ -) +) __THROW { CYG_ASSERT_SIZES( cyg_interrupt, Cyg_Interrupt ); @@ -547,17 +547,17 @@ externC void cyg_interrupt_create( *handle = (cyg_handle_t)intr; } -externC void cyg_interrupt_delete( cyg_handle_t interrupt) +externC void cyg_interrupt_delete( cyg_handle_t interrupt) __THROW { ((Cyg_Interrupt *)interrupt)->~Cyg_Interrupt(); } -void cyg_interrupt_attach( cyg_handle_t interrupt ) +void cyg_interrupt_attach( cyg_handle_t interrupt ) __THROW { ((Cyg_Interrupt *)interrupt)->attach(); } -void cyg_interrupt_detach( cyg_handle_t interrupt ) +void cyg_interrupt_detach( cyg_handle_t interrupt ) __THROW { ((Cyg_Interrupt *)interrupt)->detach(); } @@ -567,7 +567,7 @@ void cyg_interrupt_detach( cyg_handle_t externC void cyg_interrupt_get_vsr( cyg_vector_t vector, /* vector to get */ cyg_VSR_t **vsr /* vsr got */ -) +) __THROW { Cyg_Interrupt::get_vsr( (cyg_vector)vector, (cyg_VSR **)vsr); } @@ -575,44 +575,44 @@ externC void cyg_interrupt_get_vsr( externC void cyg_interrupt_set_vsr( cyg_vector_t vector, /* vector to set */ cyg_VSR_t *vsr /* vsr to set */ -) +) __THROW { Cyg_Interrupt::set_vsr( (cyg_vector)vector, (cyg_VSR *)vsr); } /* CPU level interrupt mask */ -externC void cyg_interrupt_disable() +externC void cyg_interrupt_disable() __THROW { Cyg_Interrupt::disable_interrupts(); } -externC void cyg_interrupt_enable() +externC void cyg_interrupt_enable() __THROW { Cyg_Interrupt::enable_interrupts(); } /* Interrupt controller access */ -externC void cyg_interrupt_mask(cyg_vector_t vector) +externC void cyg_interrupt_mask(cyg_vector_t vector) __THROW { Cyg_Interrupt::mask_interrupt( (cyg_vector)vector); } -externC void cyg_interrupt_mask_intunsafe(cyg_vector_t vector) +externC void cyg_interrupt_mask_intunsafe(cyg_vector_t vector) __THROW { Cyg_Interrupt::mask_interrupt_intunsafe( (cyg_vector)vector); } -externC void cyg_interrupt_unmask(cyg_vector_t vector) +externC void cyg_interrupt_unmask(cyg_vector_t vector) __THROW { Cyg_Interrupt::unmask_interrupt( (cyg_vector)vector); } -externC void cyg_interrupt_unmask_intunsafe(cyg_vector_t vector) +externC void cyg_interrupt_unmask_intunsafe(cyg_vector_t vector) __THROW { Cyg_Interrupt::unmask_interrupt_intunsafe( (cyg_vector)vector); } -externC void cyg_interrupt_acknowledge(cyg_vector_t vector) +externC void cyg_interrupt_acknowledge(cyg_vector_t vector) __THROW { Cyg_Interrupt::acknowledge_interrupt( (cyg_vector)vector); } @@ -622,7 +622,7 @@ externC void cyg_interrupt_configure( cyg_vector_t vector, /* vector to configure */ cyg_bool_t level, /* level or edge triggered */ cyg_bool_t up /* rising/faling edge, high/low level*/ -) +) __THROW { Cyg_Interrupt::configure_interrupt( (cyg_vector)vector, level, up ); } @@ -630,7 +630,7 @@ externC void cyg_interrupt_configure( externC void cyg_interrupt_set_cpu( cyg_vector_t vector, /* vector to control */ cyg_cpu_t cpu /* CPU to set */ -) +) __THROW { #ifdef CYGPKG_KERNEL_SMP_SUPPORT Cyg_Interrupt::set_cpu( vector, cpu ); @@ -639,7 +639,7 @@ externC void cyg_interrupt_set_cpu( externC cyg_cpu_t cyg_interrupt_get_cpu( cyg_vector_t vector /* vector to control */ -) +) __THROW { #ifdef CYGPKG_KERNEL_SMP_SUPPORT return Cyg_Interrupt::get_cpu( vector ); @@ -655,7 +655,7 @@ externC cyg_cpu_t cyg_interrupt_get_cpu( externC void cyg_counter_create( cyg_handle_t *handle, /* returned counter handle */ cyg_counter *counter /* put counter here */ -) +) __THROW { CYG_ASSERT_SIZES( cyg_counter, Cyg_Counter ); @@ -666,13 +666,13 @@ externC void cyg_counter_create( *handle = (cyg_handle_t)counter; } -externC void cyg_counter_delete(cyg_handle_t counter) +externC void cyg_counter_delete(cyg_handle_t counter) __THROW { ((Cyg_Counter *)counter)->~Cyg_Counter(); } /* Return current value of counter */ -externC cyg_tick_count_t cyg_counter_current_value(cyg_handle_t counter) +externC cyg_tick_count_t cyg_counter_current_value(cyg_handle_t counter) __THROW { return ((Cyg_Counter *)counter)->current_value(); } @@ -681,19 +681,19 @@ externC cyg_tick_count_t cyg_counter_cur externC void cyg_counter_set_value( cyg_handle_t counter, cyg_tick_count_t new_value -) +) __THROW { ((Cyg_Counter *)counter)->set_value( new_value ); } /* Advance counter by one tick */ -externC void cyg_counter_tick(cyg_handle_t counter) +externC void cyg_counter_tick(cyg_handle_t counter) __THROW { ((Cyg_Counter *)counter)->tick(); } /* Advance counter by multiple ticks */ -externC void cyg_counter_multi_tick(cyg_handle_t counter, cyg_tick_count_t ticks) +externC void cyg_counter_multi_tick(cyg_handle_t counter, cyg_tick_count_t ticks) __THROW { ((Cyg_Counter *)counter)->tick(ticks); } @@ -703,7 +703,7 @@ externC void cyg_clock_create( cyg_resolution_t resolution, /* Initial resolution */ cyg_handle_t *handle, /* Returned clock handle */ cyg_clock *clock /* put clock here */ -) +) __THROW { CYG_ASSERT_SIZES( cyg_clock, Cyg_Clock ); @@ -719,7 +719,7 @@ externC void cyg_clock_create( *handle = (cyg_handle_t)clock; } -externC void cyg_clock_delete(cyg_handle_t clock) +externC void cyg_clock_delete(cyg_handle_t clock) __THROW { ((Cyg_Clock *)clock)->~Cyg_Clock(); } @@ -729,7 +729,7 @@ externC void cyg_clock_delete(cyg_handle externC void cyg_clock_to_counter( cyg_handle_t clock, cyg_handle_t *counter -) +) __THROW { CYG_CHECK_DATA_PTR( counter, "Bad counter handle pointer" ); *counter = (cyg_handle_t)(Cyg_Counter *)clock; @@ -738,7 +738,7 @@ externC void cyg_clock_to_counter( externC void cyg_clock_set_resolution( cyg_handle_t clock, cyg_resolution_t resolution /* New resolution */ -) +) __THROW { Cyg_Clock::cyg_resolution res; @@ -748,7 +748,7 @@ externC void cyg_clock_set_resolution( ((Cyg_Clock *)clock)->set_resolution( res ); } -externC cyg_resolution_t cyg_clock_get_resolution(cyg_handle_t clock) +externC cyg_resolution_t cyg_clock_get_resolution(cyg_handle_t clock) __THROW { Cyg_Clock::cyg_resolution res = ((Cyg_Clock *)clock)->get_resolution(); @@ -762,12 +762,12 @@ externC cyg_resolution_t cyg_clock_get_r } #ifdef CYGVAR_KERNEL_COUNTERS_CLOCK -externC cyg_handle_t cyg_real_time_clock(void) +externC cyg_handle_t cyg_real_time_clock(void) __THROW { return (cyg_handle_t)Cyg_Clock::real_time_clock; } -externC cyg_tick_count_t cyg_current_time(void) +externC cyg_tick_count_t cyg_current_time(void) __THROW { return Cyg_Clock::real_time_clock->current_value(); } @@ -779,7 +779,7 @@ externC void cyg_alarm_create( cyg_addrword_t data, /* Call-back data */ cyg_handle_t *handle, /* Returned alarm object */ cyg_alarm *alarm /* put alarm here */ -) +) __THROW { CYG_ASSERT_SIZES( cyg_alarm, Cyg_Alarm ); @@ -795,7 +795,7 @@ externC void cyg_alarm_create( } /* Disable alarm, detach from counter and invalidate handles */ -externC void cyg_alarm_delete( cyg_handle_t alarm) +externC void cyg_alarm_delete( cyg_handle_t alarm) __THROW { ((Cyg_Alarm *)alarm)->~Cyg_Alarm(); } @@ -804,7 +804,7 @@ externC void cyg_alarm_initialize( cyg_handle_t alarm, cyg_tick_count_t trigger, /* Absolute trigger time */ cyg_tick_count_t interval /* Relative retrigger interval */ -) +) __THROW { ((Cyg_Alarm *)alarm)->initialize( (cyg_tick_count)trigger, @@ -815,19 +815,19 @@ externC void cyg_alarm_get_times( cyg_handle_t alarm, cyg_tick_count_t *trigger, /* Next trigger time */ cyg_tick_count_t *interval /* Current interval */ -) +) __THROW { ((Cyg_Alarm *)alarm)->get_times( (cyg_tick_count*)trigger, (cyg_tick_count*)interval); } -externC void cyg_alarm_enable( cyg_handle_t alarm ) +externC void cyg_alarm_enable( cyg_handle_t alarm ) __THROW { ((Cyg_Alarm *)alarm)->enable(); } -externC void cyg_alarm_disable( cyg_handle_t alarm ) +externC void cyg_alarm_disable( cyg_handle_t alarm ) __THROW { ((Cyg_Alarm *)alarm)->disable(); } @@ -838,7 +838,7 @@ externC void cyg_alarm_disable( cyg_hand externC void cyg_mbox_create( cyg_handle_t *handle, cyg_mbox *mbox -) +) __THROW { CYG_ASSERT_SIZES( cyg_mbox, Cyg_Mbox ); @@ -849,12 +849,12 @@ externC void cyg_mbox_create( *handle = (cyg_handle_t)mbox; } -externC void cyg_mbox_delete(cyg_handle_t mbox) +externC void cyg_mbox_delete(cyg_handle_t mbox) __THROW { ((Cyg_Mbox *)mbox)->~Cyg_Mbox(); } -externC void *cyg_mbox_get(cyg_handle_t mbox) +externC void *cyg_mbox_get(cyg_handle_t mbox) __THROW { return ((Cyg_Mbox *)mbox)->get(); } @@ -863,24 +863,24 @@ externC void *cyg_mbox_get(cyg_handle_t void *cyg_mbox_timed_get( cyg_handle_t mbox, cyg_tick_count_t abstime - ) + ) __THROW { return ((Cyg_Mbox *)mbox)->get(abstime); } #endif -externC void *cyg_mbox_tryget(cyg_handle_t mbox) +externC void *cyg_mbox_tryget(cyg_handle_t mbox) __THROW { return ((Cyg_Mbox *)mbox)->tryget(); } -externC void *cyg_mbox_peek_item(cyg_handle_t mbox) +externC void *cyg_mbox_peek_item(cyg_handle_t mbox) __THROW { return ((Cyg_Mbox *)mbox)->peek_item(); } #ifdef CYGMFN_KERNEL_SYNCH_MBOXT_PUT_CAN_WAIT -externC cyg_bool_t cyg_mbox_put(cyg_handle_t mbox, void *item) +externC cyg_bool_t cyg_mbox_put(cyg_handle_t mbox, void *item) __THROW { return ((Cyg_Mbox *)mbox)->put(item); } @@ -890,29 +890,29 @@ externC cyg_bool_t cyg_mbox_timed_put( cyg_handle_t mbox, void *item, cyg_tick_count_t abstime - ) + ) __THROW { return ((Cyg_Mbox *)mbox)->put(item, abstime); } #endif #endif -externC cyg_bool_t cyg_mbox_tryput(cyg_handle_t mbox, void *item) +externC cyg_bool_t cyg_mbox_tryput(cyg_handle_t mbox, void *item) __THROW { return ((Cyg_Mbox *)mbox)->tryput(item); } -externC cyg_count32 cyg_mbox_peek(cyg_handle_t mbox) +externC cyg_count32 cyg_mbox_peek(cyg_handle_t mbox) __THROW { return ((Cyg_Mbox *)mbox)->peek(); } -externC cyg_bool_t cyg_mbox_waiting_to_get(cyg_handle_t mbox) +externC cyg_bool_t cyg_mbox_waiting_to_get(cyg_handle_t mbox) __THROW { return ((Cyg_Mbox *)mbox)->waiting_to_get(); } -externC cyg_bool_t cyg_mbox_waiting_to_put(cyg_handle_t mbox) +externC cyg_bool_t cyg_mbox_waiting_to_put(cyg_handle_t mbox) __THROW { return ((Cyg_Mbox *)mbox)->waiting_to_put(); } @@ -924,7 +924,7 @@ externC cyg_bool_t cyg_mbox_waiting_to_p externC void cyg_semaphore_init( cyg_sem_t *sem, /* Semaphore to init */ cyg_count32 val /* Initial semaphore value */ -) +) __THROW { CYG_ASSERT_SIZES( cyg_sem_t, Cyg_Counting_Semaphore ); @@ -932,12 +932,12 @@ externC void cyg_semaphore_init( t=t; } -externC void cyg_semaphore_destroy( cyg_sem_t *sem ) +externC void cyg_semaphore_destroy( cyg_sem_t *sem ) __THROW { ((Cyg_Counting_Semaphore *)sem)->~Cyg_Counting_Semaphore(); } -externC cyg_bool_t cyg_semaphore_wait( cyg_sem_t *sem ) +externC cyg_bool_t cyg_semaphore_wait( cyg_sem_t *sem ) __THROW { return ((Cyg_Counting_Semaphore *)sem)->wait(); } @@ -946,24 +946,24 @@ externC cyg_bool_t cyg_semaphore_wait( c externC cyg_bool_t cyg_semaphore_timed_wait( cyg_sem_t *sem, cyg_tick_count_t abstime - ) + ) __THROW { return ((Cyg_Counting_Semaphore *)sem)->wait(abstime); } #endif -externC int cyg_semaphore_trywait( cyg_sem_t *sem ) +externC int cyg_semaphore_trywait( cyg_sem_t *sem ) __THROW { return ((Cyg_Counting_Semaphore *)sem)->trywait(); } -externC void cyg_semaphore_post( cyg_sem_t *sem ) +externC void cyg_semaphore_post( cyg_sem_t *sem ) __THROW { ((Cyg_Counting_Semaphore *)sem)->post(); } -externC void cyg_semaphore_peek( cyg_sem_t *sem, cyg_count32 *val ) +externC void cyg_semaphore_peek( cyg_sem_t *sem, cyg_count32 *val ) __THROW { CYG_CHECK_DATA_PTR( val, "Bad val parameter" ); @@ -976,7 +976,7 @@ externC void cyg_semaphore_peek( cyg_sem void cyg_flag_init( cyg_flag_t *flag /* Flag to init */ -) +) __THROW { CYG_ASSERT_SIZES( cyg_flag_t, Cyg_Flag ); CYG_ASSERT( @@ -989,24 +989,24 @@ void cyg_flag_init( t=t; } -void cyg_flag_destroy( cyg_flag_t *flag ) +void cyg_flag_destroy( cyg_flag_t *flag ) __THROW { ((Cyg_Flag *)flag)->~Cyg_Flag(); } -void cyg_flag_setbits( cyg_flag_t *flag, cyg_flag_value_t value) +void cyg_flag_setbits( cyg_flag_t *flag, cyg_flag_value_t value) __THROW { ((Cyg_Flag *)flag)->setbits( value ); } -void cyg_flag_maskbits( cyg_flag_t *flag, cyg_flag_value_t value) +void cyg_flag_maskbits( cyg_flag_t *flag, cyg_flag_value_t value) __THROW { ((Cyg_Flag *)flag)->maskbits( value ); } cyg_flag_value_t cyg_flag_wait( cyg_flag_t *flag, cyg_flag_value_t pattern, - cyg_flag_mode_t mode ) + cyg_flag_mode_t mode ) __THROW { if ( 0 == pattern || 0 != (mode & ~3) ) return 0; @@ -1018,7 +1018,7 @@ cyg_flag_value_t cyg_flag_wait( cyg_flag cyg_flag_value_t cyg_flag_timed_wait( cyg_flag_t *flag, cyg_flag_value_t pattern, cyg_flag_mode_t mode, - cyg_tick_count_t abstime ) + cyg_tick_count_t abstime ) __THROW { if ( 0 == pattern || 0 != (mode & ~3) ) return 0; @@ -1029,7 +1029,7 @@ cyg_flag_value_t cyg_flag_timed_wait( cy cyg_flag_value_t cyg_flag_poll( cyg_flag_t *flag, cyg_flag_value_t pattern, - cyg_flag_mode_t mode ) + cyg_flag_mode_t mode ) __THROW { if ( 0 == pattern || 0 != (mode & ~3) ) return 0; @@ -1037,12 +1037,12 @@ cyg_flag_value_t cyg_flag_poll( cyg_flag } -cyg_flag_value_t cyg_flag_peek( cyg_flag_t *flag ) +cyg_flag_value_t cyg_flag_peek( cyg_flag_t *flag ) __THROW { return ((Cyg_Flag *)flag)->peek(); } -cyg_bool_t cyg_flag_waiting( cyg_flag_t *flag ) +cyg_bool_t cyg_flag_waiting( cyg_flag_t *flag ) __THROW { return ((Cyg_Flag *)flag)->waiting(); } @@ -1052,7 +1052,7 @@ cyg_bool_t cyg_flag_waiting( cyg_flag_t externC void cyg_mutex_init( cyg_mutex_t *mutex /* Mutex to init */ -) +) __THROW { CYG_ASSERT_SIZES( cyg_mutex_t, Cyg_Mutex ); @@ -1061,27 +1061,27 @@ externC void cyg_mutex_init( m=m; } -externC void cyg_mutex_destroy( cyg_mutex_t *mutex ) +externC void cyg_mutex_destroy( cyg_mutex_t *mutex ) __THROW { ((Cyg_Mutex *)mutex)->~Cyg_Mutex(); } -externC cyg_bool_t cyg_mutex_lock( cyg_mutex_t *mutex ) +externC cyg_bool_t cyg_mutex_lock( cyg_mutex_t *mutex ) __THROW { return ((Cyg_Mutex *)mutex)->lock(); } -externC cyg_bool_t cyg_mutex_trylock( cyg_mutex_t *mutex ) +externC cyg_bool_t cyg_mutex_trylock( cyg_mutex_t *mutex ) __THROW { return ((Cyg_Mutex *)mutex)->trylock(); } -externC void cyg_mutex_unlock( cyg_mutex_t *mutex ) +externC void cyg_mutex_unlock( cyg_mutex_t *mutex ) __THROW { ((Cyg_Mutex *)mutex)->unlock(); } -externC void cyg_mutex_release( cyg_mutex_t *mutex ) +externC void cyg_mutex_release( cyg_mutex_t *mutex ) __THROW { ((Cyg_Mutex *)mutex)->release(); } @@ -1089,7 +1089,7 @@ externC void cyg_mutex_release( cyg_mute #ifdef CYGSEM_KERNEL_SYNCH_MUTEX_PRIORITY_INVERSION_PROTOCOL_CEILING externC void cyg_mutex_set_ceiling( cyg_mutex_t *mutex, - cyg_priority_t priority ) + cyg_priority_t priority ) __THROW { ((Cyg_Mutex *)mutex)->set_ceiling(priority); } @@ -1098,7 +1098,7 @@ externC void cyg_mutex_set_ceiling( #ifdef CYGSEM_KERNEL_SYNCH_MUTEX_PRIORITY_INVERSION_PROTOCOL_DYNAMIC externC void cyg_mutex_set_protocol( cyg_mutex_t *mutex, - enum cyg_mutex_protocol protocol ) + enum cyg_mutex_protocol protocol ) __THROW { ((Cyg_Mutex *)mutex)->set_protocol((Cyg_Mutex::cyg_protcol)protocol); } @@ -1110,7 +1110,7 @@ externC void cyg_mutex_set_protocol( externC void cyg_cond_init( cyg_cond_t *cond, /* condition variable to init */ cyg_mutex_t *mutex /* associated mutex */ -) +) __THROW { CYG_ASSERT_SIZES( cyg_cond_t, Cyg_Condition_Variable ); @@ -1119,22 +1119,22 @@ externC void cyg_cond_init( t=t; } -externC void cyg_cond_destroy( cyg_cond_t *cond ) +externC void cyg_cond_destroy( cyg_cond_t *cond ) __THROW { ((Cyg_Condition_Variable *)cond)->~Cyg_Condition_Variable(); } -externC cyg_bool_t cyg_cond_wait( cyg_cond_t *cond ) +externC cyg_bool_t cyg_cond_wait( cyg_cond_t *cond ) __THROW { return ((Cyg_Condition_Variable *)cond)->wait(); } -externC void cyg_cond_signal( cyg_cond_t *cond ) +externC void cyg_cond_signal( cyg_cond_t *cond ) __THROW { ((Cyg_Condition_Variable *)cond)->signal(); } -externC void cyg_cond_broadcast( cyg_cond_t *cond ) +externC void cyg_cond_broadcast( cyg_cond_t *cond ) __THROW { ((Cyg_Condition_Variable *)cond)->broadcast(); } @@ -1143,7 +1143,7 @@ externC void cyg_cond_broadcast( cyg_con externC cyg_bool_t cyg_cond_timed_wait( cyg_cond_t *cond, cyg_tick_count_t abstime - ) + ) __THROW { return ((Cyg_Condition_Variable *)cond)->wait(abstime); } @@ -1156,7 +1156,7 @@ externC cyg_bool_t cyg_cond_timed_wait( externC void cyg_spinlock_init( cyg_spinlock_t *lock, /* spinlock to initialize */ cyg_bool_t locked /* init locked or unlocked */ -) +) __THROW { CYG_ASSERT_SIZES( cyg_spinlock_t, Cyg_SpinLock ); @@ -1168,39 +1168,39 @@ externC void cyg_spinlock_init( t->spin(); } -externC void cyg_spinlock_destroy( cyg_spinlock_t *lock ) +externC void cyg_spinlock_destroy( cyg_spinlock_t *lock ) __THROW { ((Cyg_SpinLock *)lock)->~Cyg_SpinLock(); } -externC void cyg_spinlock_spin( cyg_spinlock_t *lock ) +externC void cyg_spinlock_spin( cyg_spinlock_t *lock ) __THROW { ((Cyg_SpinLock *)lock)->spin(); } -externC void cyg_spinlock_clear( cyg_spinlock_t *lock ) +externC void cyg_spinlock_clear( cyg_spinlock_t *lock ) __THROW { ((Cyg_SpinLock *)lock)->clear(); } -externC cyg_bool_t cyg_spinlock_try( cyg_spinlock_t *lock ) +externC cyg_bool_t cyg_spinlock_try( cyg_spinlock_t *lock ) __THROW { return ((Cyg_SpinLock *)lock)->trylock(); } -externC cyg_bool_t cyg_spinlock_test( cyg_spinlock_t *lock ) +externC cyg_bool_t cyg_spinlock_test( cyg_spinlock_t *lock ) __THROW { return ((Cyg_SpinLock *)lock)->test(); } externC void cyg_spinlock_spin_intsave( cyg_spinlock_t *lock, - cyg_addrword_t *istate ) + cyg_addrword_t *istate ) __THROW { ((Cyg_SpinLock *)lock)->spin_intsave((CYG_INTERRUPT_STATE *)istate); } externC void cyg_spinlock_clear_intsave( cyg_spinlock_t *lock, - cyg_addrword_t istate ) + cyg_addrword_t istate ) __THROW { ((Cyg_SpinLock *)lock)->clear_intsave((CYG_INTERRUPT_STATE)istate); } @@ -1218,7 +1218,7 @@ class Cyg_Check_Structure_Sizes { int dummy; public: - Cyg_Check_Structure_Sizes( int x ); + Cyg_Check_Structure_Sizes( int x ) __THROW; }; @@ -1232,7 +1232,7 @@ if( sizeof(cstruct) != sizeof(cxxstruct) fmt = fmt; \ } -Cyg_Check_Structure_Sizes::Cyg_Check_Structure_Sizes(int x) +Cyg_Check_Structure_Sizes::Cyg_Check_Structure_Sizes(int x) __THROW { cyg_bool fail = false;