/********************************************************************************************************************************/ /* Created: 9-Mar-2021 22:28:01 by OpenVMS SDL EV3-3 */ /* Source: 09-MAR-2021 22:28:00 $1$DGA8085:[STARLET_H.SRC]CMA$DEF.SDI;1 */ /********************************************************************************************************************************/ /*** MODULE CMA$DEF IDENT V3.15-001 ***/ #ifndef __CMA_DEF_LOADED #define __CMA_DEF_LOADED 1 #pragma __nostandard /* This file uses non-ANSI-Standard features */ #pragma __member_alignment __save #pragma __nomember_alignment #ifdef __INITIAL_POINTER_SIZE /* Defined whenever ptr size pragmas supported */ #pragma __required_pointer_size __save /* Save the previously-defined required ptr size */ #pragma __required_pointer_size __short /* And set ptr size default to 32-bit pointers */ #endif #ifdef __cplusplus extern "C" { #define __unknown_params ... #define __optional_params ... #else #define __unknown_params #define __optional_params ... #endif #ifndef __struct #if !defined(__VAXC) #define __struct struct #else #define __struct variant_struct #endif #endif #ifndef __union #if !defined(__VAXC) #define __union union #else #define __union variant_union #endif #endif /* */ /* FACILITY: */ /* */ /* Common Multithread Architecture (CMA) services */ /* */ /* ABSTRACT: */ /* */ /* External definitions for CMA services */ /* */ /* AUTHORS: */ /* */ /* Dave Butenhof (-Original) */ /* Paul Curtin (-Generic/SDL) */ /* */ /* CREATION DATE: */ /* */ /* 2 November 1988 (-Original) */ /* 7 September 1990 (-Generic/SDL) */ /* */ /* MODIFIED BY: */ /* */ /* Dave Butenhof */ /* Paul Curtin */ /* Gerald Feldman */ /* Brian Keane */ /* Webb Scales */ /* */ #ifndef CMA_DEF_INCLUDE #define CMA_DEF_INCLUDE #pragma nostandard #ifdef __cplusplus extern "C" { #endif /* */ /* Define a symbol which client code can test to determine whether the */ /* underlying threads package is DECthreads or not. This is especially */ /* important to clients of the Pthreads interface who may want to use */ /* certain DECthreads extensions, such as the global lock and non-real-time */ /* scheduling policies, on the DECthreads platform while maintaining */ /* portability to a "vanilla" pthreads implementation. */ /* */ #define _DECTHREADS_ 1 #if defined(vms) || defined(__vms) || defined (VMS) || defined(__VMS) || defined(__vms__) # if defined (__decc) || defined (__DECC) || (defined (__cplusplus) && defined (__DECCXX)) # pragma __extern_model __save # pragma __extern_model __strict_refdef # endif # include /* configuration symbols */ #else # include /* configuration symbols */ #endif /* * The implementation makes these basic decisions */ #if _CMA_OS_ != _CMA__VMS # include # include #endif /* * For the VMS cma$ interface, suppress the EXC_ exceptions */ #if !defined(_EXC_NO_EXCEPTIONS_) #define _EXC_NO_EXCEPTIONS_ #endif #if _CMA_OS_ == _CMA__VMS # include /* Bring in exception services */ #else # include /* Bring in exception services */ #endif #if (_CMA_OSIMPL_ == _CMA__OS_OSF) && _CMA_REENTRANT_CLIB_ # ifndef _REENTRANT # error "Please compile module including cma.h with -threads" # endif #endif #ifndef __ # if !defined(__STDC__) && !defined(__cplusplus) # define __(__args__) () # else # define __(__args__) __args__ # endif #endif #ifdef __NEW_STARLET typedef int CMA$T_INTEGER; #else /* __OLD_STARLET */ typedef int cma$t_integer; #endif /* #ifdef __NEW_STARLET */ #ifdef __NEW_STARLET typedef unsigned int CMA$T_BOOLEAN; #else /* __OLD_STARLET */ typedef unsigned int cma$t_boolean; #endif /* #ifdef __NEW_STARLET */ #ifdef __NEW_STARLET typedef unsigned int CMA$T_NATURAL; #else /* __OLD_STARLET */ typedef unsigned int cma$t_natural; #endif /* #ifdef __NEW_STARLET */ #ifdef __NEW_STARLET typedef float CMA$T_INTERVAL; #else /* __OLD_STARLET */ typedef float cma$t_interval; #endif /* #ifdef __NEW_STARLET */ #ifdef __NEW_STARLET typedef int CMA$T_KEY; #else /* __OLD_STARLET */ typedef int cma$t_key; #endif /* #ifdef __NEW_STARLET */ #ifdef __NEW_STARLET typedef int CMA$T_STATUS; #else /* __OLD_STARLET */ typedef int cma$t_status; #endif /* #ifdef __NEW_STARLET */ #ifdef __NEW_STARLET typedef int CMA$T_PRIORITY; #else /* __OLD_STARLET */ typedef int cma$t_priority; #endif /* #ifdef __NEW_STARLET */ #if _CMA_VOID_ #ifdef __NEW_STARLET typedef void *CMA$T_ADDRESS; #else typedef void *cma$t_address; #endif #else #ifdef __NEW_STARLET typedef char *CMA$T_ADDRESS; #else /* __OLD_STARLET */ typedef char *cma$t_address; #endif /* #ifdef __NEW_STARLET */ #endif #define CMA$C_PRIO_FIFO_MIN 16 #define CMA$C_PRIO_FIFO_MID 24 #define CMA$C_PRIO_FIFO_MAX 31 #define CMA$C_PRIO_RR_MIN 16 #define CMA$C_PRIO_RR_MID 24 #define CMA$C_PRIO_RR_MAX 31 #define CMA$C_PRIO_THROUGH_MIN 8 #define CMA$C_PRIO_THROUGH_MID 12 #define CMA$C_PRIO_THROUGH_MAX 15 #define CMA$C_PRIO_BACK_MIN 0 #define CMA$C_PRIO_BACK_MID 4 #define CMA$C_PRIO_BACK_MAX 7 #define CMA$C_PRIO_ADA_LOW_MIN 0 #define CMA$C_PRIO_ADA_LOW_MID 4 #define CMA$C_PRIO_ADA_LOW_MAX 7 #define CMA$C_PRIO_ADA_RTB_MIN 0 #define CMA$C_PRIO_ADA_RTB_MID 4 #define CMA$C_PRIO_ADA_RTB_MAX 7 /* */ /* The implementation of the date_time type should match the "native */ /* time" of the platform: that allows clients to use the full set of platform */ /* time operations, rather than just "get_expiration", to compute and */ /* test timed waits. */ /* */ /* This section assumes the platform is either "VMS" or "UNIX-ish". Others */ /* will require changes. */ /* */ #if _CMA_OS_ == _CMA__VMS #ifdef __NEW_STARLET typedef struct _cma$t_date_time { unsigned int low; unsigned int high; } CMA$T_DATE_TIME; #else /* __OLD_STARLET */ typedef struct _cma$t_date_time { unsigned int low; unsigned int high; } cma$t_date_time; #endif /* #ifdef __NEW_STARLET */ #else typedef struct timeval cma$t_date_time; #endif /* */ /* Sample decisions for what handles shall be */ /* */ #ifdef __NEW_STARLET typedef struct _cma$t_handle { CMA$T_NATURAL handle_field1; CMA$T_NATURAL handle_field2; } CMA$T_HANDLE; #else /* __OLD_STARLET */ typedef struct _cma$t_handle { cma$t_natural handle_field1; cma$t_natural handle_field2; } cma$t_handle; #endif /* #ifdef __NEW_STARLET */ #define CMA$C_HANDLE_SIZE 8 #if (_CMA_COMPILER_ == _CMA__CFRONT) && (_CMA_OS_ == _CMA__VMS) /* * The following declaration is a hack to support CFRONT (C++ preprocessor); * without an actual instance, the struct definition isn't written out. * Creates problems for VAX C when it compiles CFRONT output. */ static struct CMA_T_HANDLE cxxl_unused_handle; #endif #define cma$thread_get_unique(handle) \ (((unsigned int)((cma$t_thread *)handle)->handle_field2)) /* */ /* Sample decision for a one-time initialization control block and its */ /* initialization macro. */ /* */ /* */ #ifdef __NEW_STARLET typedef struct _cma$t_once { CMA$T_INTEGER once_field1; CMA$T_INTEGER once_field2; CMA$T_INTEGER once_field3; } CMA$T_ONCE; #else /* __OLD_STARLET */ typedef struct _cma$t_once { cma$t_integer once_field1; cma$t_integer once_field2; cma$t_integer once_field3; } cma$t_once; #endif /* #ifdef __NEW_STARLET */ /* */ /* Sample decision for a variable to save the current alert state. */ /* */ #ifdef __NEW_STARLET typedef struct _cma$t_alert_state { CMA$T_INTEGER state1; CMA$T_INTEGER state2; } CMA$T_ALERT_STATE; #else /* __OLD_STARLET */ typedef struct _cma$t_alert_state { cma$t_integer state1; cma$t_integer state2; } cma$t_alert_state; #endif /* #ifdef __NEW_STARLET */ /* */ /* The following are the portable CMA definitions */ /* */ /* */ /* Operations on threads */ /* */ #ifdef __NEW_STARLET typedef CMA$T_ADDRESS (*CMA$T_START_ROUTINE)( void *arg); #else /* __OLD_STARLET */ typedef cma$t_address (*cma$t_start_routine)(); #endif /* #ifdef __NEW_STARLET */ /* */ /* Constants */ /* */ #define CMA$C_FALSE 0 #define CMA$C_TRUE 1 #define CMA$C_NULL_PTR 0 /* */ /* Objects */ /* */ #ifdef __NEW_STARLET typedef CMA$T_HANDLE CMA$T_MUTEX; typedef CMA$T_HANDLE CMA$T_ATTR; typedef CMA$T_HANDLE CMA$T_THREAD; typedef CMA$T_HANDLE CMA$T_COND; typedef CMA$T_HANDLE CMA$T_STACK_NP; #else /* __OLD_STARLET */ typedef cma$t_handle cma$t_mutex; typedef cma$t_handle cma$t_attr; typedef cma$t_handle cma$t_thread; typedef cma$t_handle cma$t_cond; typedef cma$t_handle cma$t_stack_np; #endif /* #ifdef __NEW_STARLET */ /* * Predefined null handle */ #ifdef __NEW_STARLET _CMA_IMPORT_ CMA$T_HANDLE cma$c_null; #else /* __OLD_STARLET */ _CMA_IMPORT_ cma$t_handle cma$c_null; #endif /* #ifdef __NEW_STARLET */ /* * Declare a one time initialization control block. * * static cma$t_once block = cma$once_init; */ #define cma$once_init {0, 0, 0} /* * Exit status constants */ #ifdef __NEW_STARLET typedef enum _CMA$T_EXIT_STATUS { cma$c_null_thread = -1, cma$c_term_error = 0, cma$c_term_normal = 1, cma$c_term_alert = 2 } CMA$T_EXIT_STATUS; #else typedef enum _CMA$T_EXIT_STATUS { cma$c_null_thread = -1, cma$c_term_error = 0, cma$c_term_normal = 1, cma$c_term_alert = 2 } cma$t_exit_status; #endif /* * Schedule inheritance constants */ #ifdef __NEW_STARLET typedef enum _CMA$T_SCHED_INHERIT { cma$c_sched_inherit = 0, cma$c_sched_use_default = 1 } CMA$T_SCHED_INHERIT; #else typedef enum _CMA$T_SCHED_INHERIT { cma$c_sched_inherit = 0, cma$c_sched_use_default = 1 } cma$t_sched_inherit; #endif /* * Schedule policy constants */ #ifdef __NEW_STARLET typedef enum _CMA$T_SCHED_POLICY { cma$c_sched_fifo = 0, cma$c_sched_rr = 1, cma$c_sched_throughput = 2, cma$c_sched_background = 3, cma$c_sched_ada_low = 4, cma$c_sched_idle = 5 } CMA$T_SCHED_POLICY; #else typedef enum _CMA$T_SCHED_POLICY { cma$c_sched_fifo = 0, cma$c_sched_rr = 1, cma$c_sched_throughput = 2, cma$c_sched_background = 3, cma$c_sched_ada_low = 4, cma$c_sched_idle = 5 } cma$t_sched_policy; #endif /* * cma$c_sched_default and cma$c_sched_other definitions */ #define cma$c_sched_default cma$c_sched_throughput #define cma$c_sched_other cma$c_sched_default /* * Mutex types */ #ifdef __NEW_STARLET typedef enum _CMA$T_MUTEX_KIND { cma$c_mutex_fast = 0, cma$c_mutex_recursive = 1, cma$c_mutex_nonrecursive = 2 } CMA$T_MUTEX_KIND; #else typedef enum _CMA$T_MUTEX_KIND { cma$c_mutex_fast = 0, cma$c_mutex_recursive = 1, cma$c_mutex_nonrecursive = 2 } cma$t_mutex_kind; #endif /* */ /* Sample decision for error codes */ /* */ /* Values used are "VMS status codes" in decimal. These */ /* must remain in synch with the "message file" MESSAGE_VMS.MSG */ /* Note: these values cannot be altered after they have shipped in */ /* some CMA release. Octal boundaries are shown on the decimal */ /* values. GAF 6/1/92 Coordinated definitions with exc_handling.h */ /* */ #define CMA$_EXCEPTION 4227084 #define CMA$_EXCCOP 4227092 #define CMA$_UNINITEXC 4227100 #define CMA$_UNKSTATUS 4228100 #define CMA$_EXCCOPLOS 4228108 #define CMA$_ILLADDR 12 #define CMA$_EXQUOTA 28 #define CMA$_INSFMEM 292 #define CMA$_NOPRIV 36 #define CMA$_NORMAL 1 #define CMA$_ILLINSTR 1084 #define CMA$_RESADDR 1100 #define CMA$_PRIVINST 1084 #define CMA$_RESOPER 1108 #define CMA$_SIGTRAP 1044 #define CMA$_SIGIOT 44 #define CMA$_SIGEMT 1068 #define CMA$_ARITHERR 1164 #define CMA$_SIGSYS 20 #define CMA$_SIGPIPE 628 #define CMA$_EXCPU 8364 #define CMA$_EXFILSIZ 1004 #define CMA$_INTOVF 1148 #define CMA$_INTDIV 1156 #define CMA$_FLTOVF 1164 #define CMA$_FLTDIV 1172 #define CMA$_FLTUND 1180 #define CMA$_DECOVF 1188 #define CMA$_SUBRNG 1196 #define CMA$_ACCVIO 12 #define CMA$_SIGILL 1084 #define CMA$_SIGFPE 1164 #define CMA$_SIGBUS 1084 #define CMA$_SIGSEGV 1084 #define CMA$_SIGXCPU 8364 #define CMA$_SIGXFSZ 1004 #define CMA$_ALERTED 4227460 #define CMA$_ASSERTION 4227468 #define CMA$_BADPARAM 4227476 #define CMA$_BUGCHECK 4227484 #define CMA$_EXIT_THREAD 4227492 #define CMA$_EXISTENCE 4227500 #define CMA$_IN_USE 4227508 #define CMA$_USE_ERROR 4227516 #define CMA$_WRONGMUTEX 4227524 #define CMA$_STACKOVF 554 #define CMA$_NOSTACKMEM 4227540 #define CMA$_NOTCMASTACK 4227548 #define CMA$_TIMED_OUT 4227556 #define CMA$_UNIMP 4227564 #define CMA$_INIALRPRO 4227572 #define CMA$_DEFER_Q_FULL 4227580 #define CMA$_SIGNAL_Q_FULL 4227588 #define CMA$_ALERT_NESTING 4227596 /* */ /* EXCEPTION TYPE DEFINITIONS */ /* */ #ifdef __NEW_STARLET typedef char *CMA$EXC_ADDRESS_T; #else /* __OLD_STARLET */ typedef char *cma$exc_address_t; #endif /* #ifdef __NEW_STARLET */ #ifdef __NEW_STARLET typedef int CMA$EXC_KIND_T; #else /* __OLD_STARLET */ typedef int cma$exc_kind_t; #endif /* #ifdef __NEW_STARLET */ #ifdef __NEW_STARLET typedef int CMA$EXC_INT_T; #else /* __OLD_STARLET */ typedef int cma$exc_int_t; #endif /* #ifdef __NEW_STARLET */ /* */ /* Internal contents of an exception object. */ /* */ #ifdef __NEW_STARLET typedef struct _cma$t_exception { CMA$EXC_KIND_T exc_kind; CMA$EXC_ADDRESS_T exc_info; CMA$EXC_ADDRESS_T exc_filler [6]; } CMA$T_EXCEPTION; #else /* __OLD_STARLET */ typedef struct _cma$t_exception { cma$exc_kind_t exc_kind; cma$exc_address_t exc_info; cma$exc_address_t exc_filler [6]; } cma$t_exception; #endif /* #ifdef __NEW_STARLET */ #ifdef __NEW_STARLET _CMA_IMPORT_ CMA$T_EXCEPTION cma$e_uninitexc; _CMA_IMPORT_ CMA$T_EXCEPTION cma$e_illaddr; _CMA_IMPORT_ CMA$T_EXCEPTION cma$e_exquota; _CMA_IMPORT_ CMA$T_EXCEPTION cma$e_insfmem; _CMA_IMPORT_ CMA$T_EXCEPTION cma$e_nopriv; _CMA_IMPORT_ CMA$T_EXCEPTION cma$e_illinstr; _CMA_IMPORT_ CMA$T_EXCEPTION cma$e_resaddr; _CMA_IMPORT_ CMA$T_EXCEPTION cma$e_privinst; _CMA_IMPORT_ CMA$T_EXCEPTION cma$e_resoper; _CMA_IMPORT_ CMA$T_EXCEPTION cma$e_SIGTRAP; _CMA_IMPORT_ CMA$T_EXCEPTION cma$e_SIGIOT; _CMA_IMPORT_ CMA$T_EXCEPTION cma$e_SIGEMT; _CMA_IMPORT_ CMA$T_EXCEPTION cma$e_aritherr; _CMA_IMPORT_ CMA$T_EXCEPTION cma$e_SIGSYS; _CMA_IMPORT_ CMA$T_EXCEPTION cma$e_SIGPIPE; _CMA_IMPORT_ CMA$T_EXCEPTION cma$e_excpu; _CMA_IMPORT_ CMA$T_EXCEPTION cma$e_exfilsiz; _CMA_IMPORT_ CMA$T_EXCEPTION cma$e_intovf; _CMA_IMPORT_ CMA$T_EXCEPTION cma$e_intdiv; _CMA_IMPORT_ CMA$T_EXCEPTION cma$e_fltovf; _CMA_IMPORT_ CMA$T_EXCEPTION cma$e_fltdiv; _CMA_IMPORT_ CMA$T_EXCEPTION cma$e_fltund; _CMA_IMPORT_ CMA$T_EXCEPTION cma$e_decovf; _CMA_IMPORT_ CMA$T_EXCEPTION cma$e_subrng; _CMA_IMPORT_ CMA$T_EXCEPTION cma$e_alerted; _CMA_IMPORT_ CMA$T_EXCEPTION cma$e_assertion; _CMA_IMPORT_ CMA$T_EXCEPTION cma$e_badparam; _CMA_IMPORT_ CMA$T_EXCEPTION cma$e_bugcheck; _CMA_IMPORT_ CMA$T_EXCEPTION cma$e_exit_thread; _CMA_IMPORT_ CMA$T_EXCEPTION cma$e_existence; _CMA_IMPORT_ CMA$T_EXCEPTION cma$e_in_use; _CMA_IMPORT_ CMA$T_EXCEPTION cma$e_use_error; _CMA_IMPORT_ CMA$T_EXCEPTION cma$e_wrongmutex; _CMA_IMPORT_ CMA$T_EXCEPTION cma$e_stackovf; _CMA_IMPORT_ CMA$T_EXCEPTION cma$e_nostackmem; _CMA_IMPORT_ CMA$T_EXCEPTION cma$e_notcmastack; _CMA_IMPORT_ CMA$T_EXCEPTION cma$e_unimp; _CMA_IMPORT_ CMA$T_EXCEPTION cma$e_inialrpro; _CMA_IMPORT_ CMA$T_EXCEPTION cma$e_defer_q_full; _CMA_IMPORT_ CMA$T_EXCEPTION cma$e_signal_q_full; _CMA_IMPORT_ CMA$T_EXCEPTION cma$e_alert_nesting; #else _CMA_IMPORT_ cma$t_exception cma$e_uninitexc; _CMA_IMPORT_ cma$t_exception cma$e_illaddr; _CMA_IMPORT_ cma$t_exception cma$e_exquota; _CMA_IMPORT_ cma$t_exception cma$e_insfmem; _CMA_IMPORT_ cma$t_exception cma$e_nopriv; _CMA_IMPORT_ cma$t_exception cma$e_illinstr; _CMA_IMPORT_ cma$t_exception cma$e_resaddr; _CMA_IMPORT_ cma$t_exception cma$e_privinst; _CMA_IMPORT_ cma$t_exception cma$e_resoper; _CMA_IMPORT_ cma$t_exception cma$e_SIGTRAP; _CMA_IMPORT_ cma$t_exception cma$e_SIGIOT; _CMA_IMPORT_ cma$t_exception cma$e_SIGEMT; _CMA_IMPORT_ cma$t_exception cma$e_aritherr; _CMA_IMPORT_ cma$t_exception cma$e_SIGSYS; _CMA_IMPORT_ cma$t_exception cma$e_SIGPIPE; _CMA_IMPORT_ cma$t_exception cma$e_excpu; _CMA_IMPORT_ cma$t_exception cma$e_exfilsiz; _CMA_IMPORT_ cma$t_exception cma$e_intovf; _CMA_IMPORT_ cma$t_exception cma$e_intdiv; _CMA_IMPORT_ cma$t_exception cma$e_fltovf; _CMA_IMPORT_ cma$t_exception cma$e_fltdiv; _CMA_IMPORT_ cma$t_exception cma$e_fltund; _CMA_IMPORT_ cma$t_exception cma$e_decovf; _CMA_IMPORT_ cma$t_exception cma$e_subrng; _CMA_IMPORT_ cma$t_exception cma$e_alerted; _CMA_IMPORT_ cma$t_exception cma$e_assertion; _CMA_IMPORT_ cma$t_exception cma$e_badparam; _CMA_IMPORT_ cma$t_exception cma$e_bugcheck; _CMA_IMPORT_ cma$t_exception cma$e_exit_thread; _CMA_IMPORT_ cma$t_exception cma$e_existence; _CMA_IMPORT_ cma$t_exception cma$e_in_use; _CMA_IMPORT_ cma$t_exception cma$e_use_error; _CMA_IMPORT_ cma$t_exception cma$e_wrongmutex; _CMA_IMPORT_ cma$t_exception cma$e_stackovf; _CMA_IMPORT_ cma$t_exception cma$e_nostackmem; _CMA_IMPORT_ cma$t_exception cma$e_notcmastack; _CMA_IMPORT_ cma$t_exception cma$e_unimp; _CMA_IMPORT_ cma$t_exception cma$e_inialrpro; _CMA_IMPORT_ cma$t_exception cma$e_defer_q_full; _CMA_IMPORT_ cma$t_exception cma$e_signal_q_full; _CMA_IMPORT_ cma$t_exception cma$e_alert_nesting; #endif /* */ /* Operations on Handles */ /* */ /* */ /* The value of a handle can be assigned the value of another handle. */ /* */ #define cma$handle_assign CMA$HANDLE_ASSIGN #ifdef __NEW_STARLET void cma$handle_assign( CMA$T_HANDLE *handle1, CMA$T_HANDLE *handle2); #else /* __OLD_STARLET */ void cma$handle_assign(__unknown_params); #endif /* #ifdef __NEW_STARLET */ /* */ /* The value of a handle can be assigned the value of another handle. */ /* */ #define cma$handle_equal CMA$HANDLE_EQUAL #ifdef __NEW_STARLET CMA$T_BOOLEAN cma$handle_equal( CMA$T_HANDLE *handle1, CMA$T_HANDLE *handle2); #else /* __OLD_STARLET */ cma$t_boolean cma$handle_equal(__unknown_params); #endif /* #ifdef __NEW_STARLET */ /* */ /* An attributes object is created to specify the attributes of other CMA */ /* objects that will be created. */ /* */ #define cma$attr_create CMA$ATTR_CREATE #ifdef __NEW_STARLET void cma$attr_create( CMA$T_ATTR *new_att, CMA$T_ATTR *attr); #else /* __OLD_STARLET */ void cma$attr_create(__unknown_params); #endif /* #ifdef __NEW_STARLET */ /* */ /* An attributes object can be deleted when it is no longer needed. */ /* */ #define cma$attr_delete CMA$ATTR_DELETE #ifdef __NEW_STARLET void cma$attr_delete( CMA$T_ATTR *attr); #else /* __OLD_STARLET */ void cma$attr_delete(__unknown_params); #endif /* #ifdef __NEW_STARLET */ /* */ /* The following procedures can be used to control thread creation, */ /* termination and deletion. */ /* */ /* */ /* To create a thread object and runnable thread, a routine must be specified */ /* as the new thread's start routine. An argument may be passed to this */ /* routine, as an untyped address; an untyped address may also be returned as */ /* the routine's value. An attributes object may be used to specify details */ /* about the kind of thread being created. */ /* */ #define cma$thread_create CMA$THREAD_CREATE #ifdef __NEW_STARLET void cma$thread_create( CMA$T_THREAD *new_thread, CMA$T_ATTR *attr, int (*start_routine)(void), CMA$T_ADDRESS *arg); #else /* __OLD_STARLET */ void cma$thread_create(__unknown_params); #endif /* #ifdef __NEW_STARLET */ /* */ /* A thread object may be "detached" to specify that the return value and */ /* completion status will not be requested. */ /* */ #define cma$thread_detach CMA$THREAD_DETACH #ifdef __NEW_STARLET void cma$thread_detach( CMA$T_THREAD *thread); #else /* __OLD_STARLET */ void cma$thread_detach(__unknown_params); #endif /* #ifdef __NEW_STARLET */ /* */ /* A thread may terminate it's own execution. */ /* */ #define cma$thread_exit_error CMA$THREAD_EXIT_ERROR #ifdef __NEW_STARLET void cma$thread_exit_error(void); #else /* __OLD_STARLET */ void cma$thread_exit_error(void); #endif /* #ifdef __NEW_STARLET */ /* */ /* Exit a thread normally. */ /* */ #define cma$thread_exit_normal CMA$THREAD_EXIT_NORMAL #ifdef __NEW_STARLET void cma$thread_exit_normal( CMA$T_ADDRESS *result); #else /* __OLD_STARLET */ void cma$thread_exit_normal(__unknown_params); #endif /* #ifdef __NEW_STARLET */ /* */ /* A thread can await termination of another thread and retrieve the return */ /* value and completion status of the thread. */ /* */ #define cma$thread_join CMA$THREAD_JOIN #ifdef __NEW_STARLET void cma$thread_join( CMA$T_THREAD *thread, CMA$T_EXIT_STATUS *exit_status, CMA$T_ADDRESS *result); #else /* __OLD_STARLET */ void cma$thread_join(__unknown_params); #endif /* #ifdef __NEW_STARLET */ /* */ /* Operations to define thread creation attributes */ /* */ /* */ /* Set or obtain the default thread priority. */ /* */ #define cma$attr_set_priority CMA$ATTR_SET_PRIORITY #ifdef __NEW_STARLET void cma$attr_set_priority( CMA$T_ATTR *attr, CMA$T_PRIORITY *priority); #else /* __OLD_STARLET */ void cma$attr_set_priority(__unknown_params); #endif /* #ifdef __NEW_STARLET */ /* */ /* Obtain thread priority from attributes object. */ /* */ #define cma$attr_get_priority CMA$ATTR_GET_PRIORITY #ifdef __NEW_STARLET void cma$attr_get_priority( CMA$T_ATTR *attr, CMA$T_PRIORITY *priority); #else /* __OLD_STARLET */ void cma$attr_get_priority(__unknown_params); #endif /* #ifdef __NEW_STARLET */ /* */ /* Set or obtain the default scheduling algorithm. */ /* */ #define cma$attr_set_sched CMA$ATTR_SET_SCHED #ifdef __NEW_STARLET void cma$attr_set_sched( CMA$T_ATTR *attr, CMA$T_SCHED_POLICY *policy); #else /* __OLD_STARLET */ void cma$attr_set_sched(__unknown_params); #endif /* #ifdef __NEW_STARLET */ /* */ /* Get thread scheduling algorithm from attributes object. */ /* */ #define cma$attr_get_sched CMA$ATTR_GET_SCHED #ifdef __NEW_STARLET void cma$attr_get_sched( CMA$T_ATTR *attr, CMA$T_SCHED_POLICY *policy); #else /* __OLD_STARLET */ void cma$attr_get_sched(__unknown_params); #endif /* #ifdef __NEW_STARLET */ /* */ /* Set or obtain whether a thread will use the default scheduling attributes, */ /* or inherit them from the creating thread. */ /* */ #define cma$attr_set_inherit_sched CMA$ATTR_SET_INHERIT_SCHED #ifdef __NEW_STARLET void cma$attr_set_inherit_sched( CMA$T_ATTR *attr, CMA$T_SCHED_INHERIT *setting); #else /* __OLD_STARLET */ void cma$attr_set_inherit_sched(__unknown_params); #endif /* #ifdef __NEW_STARLET */ /* */ /* Obtain default scheduling attributes. */ /* */ #define cma$attr_get_inherit_sched CMA$ATTR_GET_INHERIT_SCHED #ifdef __NEW_STARLET void cma$attr_get_inherit_sched( CMA$T_ATTR *attr, CMA$T_SCHED_INHERIT *setting); #else /* __OLD_STARLET */ void cma$attr_get_inherit_sched(__unknown_params); #endif /* #ifdef __NEW_STARLET */ /* */ /* Set the default stack size */ /* */ #define cma$attr_set_stacksize CMA$ATTR_SET_STACKSIZE #ifdef __NEW_STARLET void cma$attr_set_stacksize( CMA$T_ATTR *attr, CMA$T_NATURAL *stacksize); #else /* __OLD_STARLET */ void cma$attr_set_stacksize(__unknown_params); #endif /* #ifdef __NEW_STARLET */ /* */ /* Obtain the default stack size. */ /* */ #define cma$attr_get_stacksize CMA$ATTR_GET_STACKSIZE #ifdef __NEW_STARLET void cma$attr_get_stacksize( CMA$T_ATTR *attr, CMA$T_NATURAL *stacksize); #else /* __OLD_STARLET */ void cma$attr_get_stacksize(__unknown_params); #endif /* #ifdef __NEW_STARLET */ /* */ /* Set the default guard size */ /* */ #define cma$attr_set_guardsize CMA$ATTR_SET_GUARDSIZE #ifdef __NEW_STARLET void cma$attr_set_guardsize( CMA$T_ATTR *attr, CMA$T_NATURAL *guardsize); #else /* __OLD_STARLET */ void cma$attr_set_guardsize(__unknown_params); #endif /* #ifdef __NEW_STARLET */ /* */ /* Obtain the default guard size */ /* */ #define cma$attr_get_guardsize CMA$ATTR_GET_GUARDSIZE #ifdef __NEW_STARLET void cma$attr_get_guardsize( CMA$T_ATTR *attr, CMA$T_NATURAL *guardsize); #else /* __OLD_STARLET */ void cma$attr_get_guardsize(__unknown_params); #endif /* #ifdef __NEW_STARLET */ /* */ /* Thread Scheduling Operations */ /* */ /* */ /* The current user_assigned priority of a thread can be changed. */ /* */ #define cma$thread_set_priority CMA$THREAD_SET_PRIORITY #ifdef __NEW_STARLET void cma$thread_set_priority( CMA$T_THREAD *thread, CMA$T_PRIORITY *priority); #else /* __OLD_STARLET */ void cma$thread_set_priority(__unknown_params); #endif /* #ifdef __NEW_STARLET */ /* */ /* The current user_assigned scheduler algorithm of a thread can be changed. */ /* */ #define cma$thread_set_sched CMA$THREAD_SET_SCHED #ifdef __NEW_STARLET void cma$thread_set_sched( CMA$T_THREAD *thread, CMA$T_SCHED_POLICY *policy); #else /* __OLD_STARLET */ void cma$thread_set_sched(__unknown_params); #endif /* #ifdef __NEW_STARLET */ /* */ /* A thread may tell the scheduler that its processor can be made available. */ /* */ #define cma$yield CMA$YIELD #ifdef __NEW_STARLET void cma$yield(void); #else /* __OLD_STARLET */ void cma$yield(void); #endif /* #ifdef __NEW_STARLET */ /* */ /* A thread may enter a wait state for a specifed period of time. */ /* */ #define cma$delay CMA$DELAY #ifdef __NEW_STARLET void cma$delay( CMA$T_INTERVAL interval); #else /* __OLD_STARLET */ void cma$delay(__unknown_params); #endif /* #ifdef __NEW_STARLET */ /* */ /* Thread Information Operations */ /* */ /* */ /* A thread may obtain a copy of its own thread handle. */ /* */ #define cma$thread_get_self CMA$THREAD_GET_SELF #ifdef __NEW_STARLET void cma$thread_get_self( CMA$T_THREAD *thread); #else /* __OLD_STARLET */ void cma$thread_get_self(__unknown_params); #endif /* #ifdef __NEW_STARLET */ /* */ /* The current user_assigned priority of a thread can be read. */ /* */ #define cma$thread_get_priority CMA$THREAD_GET_PRIORITY #ifdef __NEW_STARLET void cma$thread_get_priority( CMA$T_THREAD *thread, CMA$T_PRIORITY *priority); #else /* __OLD_STARLET */ void cma$thread_get_priority(__unknown_params); #endif /* #ifdef __NEW_STARLET */ /* */ /* The current user_assigned scheduler algorithm of a thread can be read. */ /* */ #define cma$thread_get_sched CMA$THREAD_GET_SCHED #ifdef __NEW_STARLET void cma$thread_get_sched( CMA$T_THREAD *thread, CMA$T_SCHED_POLICY *policy); #else /* __OLD_STARLET */ void cma$thread_get_sched(__unknown_params); #endif /* #ifdef __NEW_STARLET */ /* */ /* Operations on Mutexes */ /* */ /* */ /* Set whether mutex locks can nest. */ /* */ #define cma$attr_set_mutex_kind CMA$ATTR_SET_MUTEX_KIND #ifdef __NEW_STARLET void cma$attr_set_mutex_kind( CMA$T_ATTR *attr, CMA$T_MUTEX_KIND *nest); #else /* __OLD_STARLET */ void cma$attr_set_mutex_kind(__unknown_params); #endif /* #ifdef __NEW_STARLET */ /* */ /* Obtain whether mutex locks can nest. */ /* */ #define cma$attr_get_mutex_kind CMA$ATTR_GET_MUTEX_KIND #ifdef __NEW_STARLET void cma$attr_get_mutex_kind( CMA$T_ATTR *attr, CMA$T_MUTEX_KIND *nest); #else /* __OLD_STARLET */ void cma$attr_get_mutex_kind(__unknown_params); #endif /* #ifdef __NEW_STARLET */ /* */ /* The following routines create, delete, lock and unlock mutexes. */ /* */ #define cma$mutex_create CMA$MUTEX_CREATE #ifdef __NEW_STARLET void cma$mutex_create( CMA$T_MUTEX *new_mutex, CMA$T_ATTR *attr); #else /* __OLD_STARLET */ void cma$mutex_create(__unknown_params); #endif /* #ifdef __NEW_STARLET */ /* */ /* Delete a mutex. */ /* */ #define cma$mutex_delete CMA$MUTEX_DELETE #ifdef __NEW_STARLET void cma$mutex_delete( CMA$T_MUTEX *mutex); #else /* __OLD_STARLET */ void cma$mutex_delete(__unknown_params); #endif /* #ifdef __NEW_STARLET */ /* */ /* Lock a mutex. */ /* */ #define cma$mutex_lock CMA$MUTEX_LOCK #ifdef __NEW_STARLET void cma$mutex_lock( CMA$T_MUTEX *mutex); #else /* __OLD_STARLET */ void cma$mutex_lock(__unknown_params); #endif /* #ifdef __NEW_STARLET */ /* */ /* Try to lock a mutex. */ /* */ #define cma$mutex_try_lock CMA$MUTEX_TRY_LOCK #ifdef __NEW_STARLET CMA$T_BOOLEAN cma$mutex_try_lock( CMA$T_MUTEX *mutex); #else /* __OLD_STARLET */ cma$t_boolean cma$mutex_try_lock(__unknown_params); #endif /* #ifdef __NEW_STARLET */ /* */ /* Unlock a mutex. */ /* */ #define cma$mutex_unlock CMA$MUTEX_UNLOCK #ifdef __NEW_STARLET void cma$mutex_unlock( CMA$T_MUTEX *mutex); #else /* __OLD_STARLET */ void cma$mutex_unlock(__unknown_params); #endif /* #ifdef __NEW_STARLET */ /* */ /* Lock Global mutex. */ /* */ #define cma$lock_global CMA$LOCK_GLOBAL #ifdef __NEW_STARLET void cma$lock_global(void); #else /* __OLD_STARLET */ void cma$lock_global(void); #endif /* #ifdef __NEW_STARLET */ /* */ /* Unlock Global mutex. */ /* */ #define cma$unlock_global CMA$UNLOCK_GLOBAL #ifdef __NEW_STARLET void cma$unlock_global(void); #else /* __OLD_STARLET */ void cma$unlock_global(void); #endif /* #ifdef __NEW_STARLET */ /* */ /* A thread can create and delete condition variables. */ /* */ #define cma$cond_create CMA$COND_CREATE #ifdef __NEW_STARLET void cma$cond_create( CMA$T_COND *new_condition, CMA$T_ATTR *attr); #else /* __OLD_STARLET */ void cma$cond_create(__unknown_params); #endif /* #ifdef __NEW_STARLET */ /* */ /* Delete a condition variable. */ /* */ #define cma$cond_delete CMA$COND_DELETE #ifdef __NEW_STARLET void cma$cond_delete( CMA$T_COND *condition); #else /* __OLD_STARLET */ void cma$cond_delete(__unknown_params); #endif /* #ifdef __NEW_STARLET */ /* */ /* A thread can signal to and broadcast on a condition variable. */ /* */ #define cma$cond_broadcast CMA$COND_BROADCAST #ifdef __NEW_STARLET void cma$cond_broadcast( CMA$T_COND *condition); #else /* __OLD_STARLET */ void cma$cond_broadcast(__unknown_params); #endif /* #ifdef __NEW_STARLET */ /* */ /* Signal a condition variable. */ /* */ #define cma$cond_signal CMA$COND_SIGNAL #ifdef __NEW_STARLET void cma$cond_signal( CMA$T_COND *condition); #else /* __OLD_STARLET */ void cma$cond_signal(__unknown_params); #endif /* #ifdef __NEW_STARLET */ /* */ /* Interupt signal a condition variable. */ /* */ #define cma$cond_signal_int CMA$COND_SIGNAL_INT #ifdef __NEW_STARLET void cma$cond_signal_int( CMA$T_COND *condition); #else /* __OLD_STARLET */ void cma$cond_signal_int(__unknown_params); #endif /* #ifdef __NEW_STARLET */ /* */ /* A thread can wait for a condition variable to be signalled or broadcast. */ /* */ #define cma$cond_wait CMA$COND_WAIT #ifdef __NEW_STARLET void cma$cond_wait( CMA$T_COND *condition, CMA$T_MUTEX *mutex); #else /* __OLD_STARLET */ void cma$cond_wait(__unknown_params); #endif /* #ifdef __NEW_STARLET */ /* */ /* Operations for timed waiting */ /* */ /* */ /* A thread can perform a timed wait on a condition variable. */ /* */ #define cma$cond_timed_wait CMA$COND_TIMED_WAIT #ifdef __NEW_STARLET CMA$T_STATUS cma$cond_timed_wait( CMA$T_COND *condition, CMA$T_MUTEX *mutex, CMA$T_DATE_TIME *expiration); #else /* __OLD_STARLET */ cma$t_status cma$cond_timed_wait(__unknown_params); #endif /* #ifdef __NEW_STARLET */ /* */ /* A thread may perform some operations on absolute date-time and intervals. */ /* */ #define cma$time_get_expiration CMA$TIME_GET_EXPIRATION #ifdef __NEW_STARLET void cma$time_get_expiration( CMA$T_DATE_TIME *expiration, CMA$T_INTERVAL interval); #else /* __OLD_STARLET */ void cma$time_get_expiration(__unknown_params); #endif /* #ifdef __NEW_STARLET */ /* */ /* Operations for CMA and client initialization. */ /* */ /* */ /* Initialize the CMA facility. */ /* */ #define cma$init CMA$INIT #ifdef __NEW_STARLET void cma$init(void); #else /* __OLD_STARLET */ void cma$init(void); #endif /* #ifdef __NEW_STARLET */ /* */ /* A thread can declare a one-time initialization routine. The address of */ /* the init block and routine are passed as parameters. */ /* */ #ifdef __NEW_STARLET typedef void (*CMA$T_INIT_ROUTINE)(void); #else /* __OLD_STARLET */ typedef void (*cma$t_init_routine)(); #endif /* #ifdef __NEW_STARLET */ /* */ /* Once routine */ /* */ #define cma$once CMA$ONCE #ifdef __NEW_STARLET void cma$once( CMA$T_ADDRESS *init_block, CMA$T_INIT_ROUTINE *init_routine); #else /* __OLD_STARLET */ void cma$once(__unknown_params); #endif /* #ifdef __NEW_STARLET */ /* */ /* Operations for per-thread context */ /* */ #ifdef __NEW_STARLET typedef void (*CMA$T_DESTRUCTOR)( void *ctx_value); #else /* __OLD_STARLET */ typedef void (*cma$t_destructor)(); #endif /* #ifdef __NEW_STARLET */ /* */ /* A unique per-thread context key can be obtained for the process */ /* */ #define cma$key_create CMA$KEY_CREATE #ifdef __NEW_STARLET void cma$key_create( CMA$T_KEY *key, CMA$T_ATTR *attr, CMA$T_DESTRUCTOR *destructor); #else /* __OLD_STARLET */ void cma$key_create(__unknown_params); #endif /* #ifdef __NEW_STARLET */ /* */ /* A thread can set a per-thread context value identified by a key. */ /* */ #define cma$key_set_context CMA$KEY_SET_CONTEXT #ifdef __NEW_STARLET void cma$key_set_context( CMA$T_KEY *key, CMA$T_ADDRESS *context_value); #else /* __OLD_STARLET */ void cma$key_set_context(__unknown_params); #endif /* #ifdef __NEW_STARLET */ /* */ /* A thread can retrieve a per-thread context value identified by a key. */ /* */ #define cma$key_get_context CMA$KEY_GET_CONTEXT #ifdef __NEW_STARLET void cma$key_get_context( CMA$T_KEY *key, CMA$T_ADDRESS *context_value); #else /* __OLD_STARLET */ void cma$key_get_context(__unknown_params); #endif /* #ifdef __NEW_STARLET */ /* */ /* Operations for alerts. */ /* */ /* */ /* The current thread can request that a thread terminate it's execution. */ /* */ #define cma$thread_alert CMA$THREAD_ALERT #ifdef __NEW_STARLET void cma$thread_alert( CMA$T_THREAD *thread); #else /* __OLD_STARLET */ void cma$thread_alert(__unknown_params); #endif /* #ifdef __NEW_STARLET */ /* */ /* The current thread can poll for alert delivery. */ /* */ #define cma$alert_test CMA$ALERT_TEST #ifdef __NEW_STARLET void cma$alert_test(void); #else /* __OLD_STARLET */ void cma$alert_test(void); #endif /* #ifdef __NEW_STARLET */ /* */ /* Control alert delivery state. */ /* */ #define cma$alert_disable_asynch CMA$ALERT_DISABLE_ASYNCH #ifdef __NEW_STARLET void cma$alert_disable_asynch( CMA$T_ALERT_STATE *priority); #else /* __OLD_STARLET */ void cma$alert_disable_asynch(__unknown_params); #endif /* #ifdef __NEW_STARLET */ #define cma$alert_disable_general CMA$ALERT_DISABLE_GENERAL #ifdef __NEW_STARLET void cma$alert_disable_general( CMA$T_ALERT_STATE *priority); #else /* __OLD_STARLET */ void cma$alert_disable_general(__unknown_params); #endif /* #ifdef __NEW_STARLET */ #define cma$alert_enable_asynch CMA$ALERT_ENABLE_ASYNCH #ifdef __NEW_STARLET void cma$alert_enable_asynch(void); #else /* __OLD_STARLET */ void cma$alert_enable_asynch(void); #endif /* #ifdef __NEW_STARLET */ #define cma$alert_enable_general CMA$ALERT_ENABLE_GENERAL #ifdef __NEW_STARLET void cma$alert_enable_general( CMA$T_ALERT_STATE *priority); #else /* __OLD_STARLET */ void cma$alert_enable_general(__unknown_params); #endif /* #ifdef __NEW_STARLET */ #define cma$alert_restore CMA$ALERT_RESTORE #ifdef __NEW_STARLET void cma$alert_restore( CMA$T_ALERT_STATE *priority); #else /* __OLD_STARLET */ void cma$alert_restore(__unknown_params); #endif /* #ifdef __NEW_STARLET */ /* */ /* Operations on stacks */ /* */ #ifdef __NEW_STARLET typedef void (*CMA$T_CALL_ROUTINE)(void); #else /* __OLD_STARLET */ typedef void (*cma$t_call_routine)(); #endif /* #ifdef __NEW_STARLET */ /* */ /* Assign a stack to a thread */ /* */ #define cma$stack_assign_np CMA$STACK_ASSIGN_NP #ifdef __NEW_STARLET void cma$stack_assign_np( CMA$T_STACK_NP *stack, CMA$T_THREAD *thread); #else /* __OLD_STARLET */ void cma$stack_assign_np(__unknown_params); #endif /* #ifdef __NEW_STARLET */ /* */ /* Call a routine on a new stack */ /* */ #define cma$stack_call_routine_np CMA$STACK_CALL_ROUTINE_NP #ifdef __NEW_STARLET void cma$stack_call_routine_np( CMA$T_STACK_NP *stack, CMA$T_CALL_ROUTINE *routine, CMA$T_ADDRESS *arg, CMA$T_ADDRESS *result); #else /* __OLD_STARLET */ void cma$stack_call_routine_np(__unknown_params); #endif /* #ifdef __NEW_STARLET */ /* */ /* Check stack limit */ /* */ #define cma$stack_check_limit_np CMA$STACK_CHECK_LIMIT_NP #ifdef __NEW_STARLET CMA$T_BOOLEAN cma$stack_check_limit_np( CMA$T_INTEGER *size); #else /* __OLD_STARLET */ cma$t_boolean cma$stack_check_limit_np(__unknown_params); #endif /* #ifdef __NEW_STARLET */ /* */ /* Create a new stack */ /* */ #define cma$stack_create_np CMA$STACK_CREATE_NP #ifdef __NEW_STARLET void cma$stack_create_np( CMA$T_STACK_NP *stack, CMA$T_ATTR *attr); #else /* __OLD_STARLET */ void cma$stack_create_np(__unknown_params); #endif /* #ifdef __NEW_STARLET */ /* */ /* Delete a stack */ /* */ #define cma$stack_delete_np CMA$STACK_DELETE_NP #ifdef __NEW_STARLET void cma$stack_delete_np( CMA$T_STACK_NP *stack); #else /* __OLD_STARLET */ void cma$stack_delete_np(__unknown_params); #endif /* #ifdef __NEW_STARLET */ /* */ /* CMA Debug entry point */ /* */ #define cma$debug CMA$DEBUG #ifdef __NEW_STARLET void cma$debug(void); #else /* __OLD_STARLET */ void cma$debug(void); #endif /* #ifdef __NEW_STARLET */ #define cma$sigwait CMA$SIGWAIT #ifdef __NEW_STARLET CMA$T_INTEGER cma$sigwait( CMA$T_ADDRESS *wset); #else /* __OLD_STARLET */ cma$t_integer cma$sigwait(__unknown_params); #endif /* #ifdef __NEW_STARLET */ /************************************************************************** */ /* */ /* The following are the portable CMA High-Level Library definitions */ /* */ /************************************************************************** */ /* */ /* Operations on attributes objects */ /* */ #ifdef __NEW_STARLET typedef CMA$T_HANDLE CMA$LIB_T_ATTR; #else /* __OLD_STARLET */ typedef cma$t_handle cma$lib_t_attr; #endif /* #ifdef __NEW_STARLET */ /* */ /* An attributes object is created to specify the attributes of other CMA */ /* objects that will be created. */ /* */ #define cma$lib_attr_create CMA$LIB_ATTR_CREATE #ifdef __NEW_STARLET void cma$lib_attr_create( CMA$LIB_T_ATTR *new_attr, CMA$LIB_T_ATTR *attr); #else /* __OLD_STARLET */ void cma$lib_attr_create(__unknown_params); #endif /* #ifdef __NEW_STARLET */ /* */ /* An attributes object can be deleted when it is no longer needed. */ /* */ #define cma$lib_attr_delete CMA$LIB_ATTR_DELETE #ifdef __NEW_STARLET void cma$lib_attr_delete( CMA$LIB_T_ATTR *attr); #else /* __OLD_STARLET */ void cma$lib_attr_delete(__unknown_params); #endif /* #ifdef __NEW_STARLET */ /* */ /* Operations on queues */ /* */ #ifdef __NEW_STARLET typedef CMA$T_HANDLE CMA$LIB_T_QUEUE; #else /* __OLD_STARLET */ typedef cma$t_handle cma$lib_t_queue; #endif /* #ifdef __NEW_STARLET */ #define cma$lib_queue_create CMA$LIB_QUEUE_CREATE #ifdef __NEW_STARLET void cma$lib_queue_create( CMA$LIB_T_QUEUE *new_queue, CMA$LIB_T_ATTR *att); #else /* __OLD_STARLET */ void cma$lib_queue_create(__unknown_params); #endif /* #ifdef __NEW_STARLET */ #define cma$lib_queue_delete CMA$LIB_QUEUE_DELETE #ifdef __NEW_STARLET void cma$lib_queue_delete( CMA$LIB_T_QUEUE *queue); #else /* __OLD_STARLET */ void cma$lib_queue_delete(__unknown_params); #endif /* #ifdef __NEW_STARLET */ #define cma$lib_queue_dequeue CMA$LIB_QUEUE_DEQUEUE #ifdef __NEW_STARLET void cma$lib_queue_dequeue( CMA$LIB_T_QUEUE *queue, CMA$T_ADDRESS *element); #else /* __OLD_STARLET */ void cma$lib_queue_dequeue(__unknown_params); #endif /* #ifdef __NEW_STARLET */ #define cma$lib_queue_enqueue CMA$LIB_QUEUE_ENQUEUE #ifdef __NEW_STARLET void cma$lib_queue_enqueue( CMA$LIB_T_QUEUE *queue, CMA$T_ADDRESS element); #else /* __OLD_STARLET */ void cma$lib_queue_enqueue(__unknown_params); #endif /* #ifdef __NEW_STARLET */ #define cma$lib_queue_try_enqueue_int CMA$LIB_QUEUE_TRY_ENQUEUE_INT #ifdef __NEW_STARLET CMA$T_BOOLEAN cma$lib_queue_try_enqueue_int( CMA$LIB_T_QUEUE *queue, CMA$T_ADDRESS element); #else /* __OLD_STARLET */ cma$t_boolean cma$lib_queue_try_enqueue_int(__unknown_params); #endif /* #ifdef __NEW_STARLET */ #define cma$lib_queue_requeue CMA$LIB_QUEUE_REQUEUE #ifdef __NEW_STARLET void cma$lib_queue_requeue( CMA$LIB_T_QUEUE *queue, CMA$T_ADDRESS element); #else /* __OLD_STARLET */ void cma$lib_queue_requeue(__unknown_params); #endif /* #ifdef __NEW_STARLET */ #define cma$lib_queue_try_dequeue CMA$LIB_QUEUE_TRY_DEQUEUE #ifdef __NEW_STARLET CMA$T_BOOLEAN cma$lib_queue_try_dequeue( CMA$LIB_T_QUEUE *queue, CMA$T_ADDRESS *element); #else /* __OLD_STARLET */ cma$t_boolean cma$lib_queue_try_dequeue(__unknown_params); #endif /* #ifdef __NEW_STARLET */ #define cma$lib_queue_try_enqueue CMA$LIB_QUEUE_TRY_ENQUEUE #ifdef __NEW_STARLET CMA$T_BOOLEAN cma$lib_queue_try_enqueue( CMA$LIB_T_QUEUE *queue, CMA$T_ADDRESS element); #else /* __OLD_STARLET */ cma$t_boolean cma$lib_queue_try_enqueue(__unknown_params); #endif /* #ifdef __NEW_STARLET */ #define cma$lib_queue_try_requeue CMA$LIB_QUEUE_TRY_REQUEUE #ifdef __NEW_STARLET CMA$T_BOOLEAN cma$lib_queue_try_requeue( CMA$LIB_T_QUEUE *queue, CMA$T_ADDRESS element); #else /* __OLD_STARLET */ cma$t_boolean cma$lib_queue_try_requeue(__unknown_params); #endif /* #ifdef __NEW_STARLET */ /* */ /* Set or obtain the default queue size */ /* */ #define cma$lib_attr_get_queuesize CMA$LIB_ATTR_GET_QUEUESIZE #ifdef __NEW_STARLET void cma$lib_attr_get_queuesize( CMA$LIB_T_ATTR *attr, CMA$T_NATURAL *queuesize); #else /* __OLD_STARLET */ void cma$lib_attr_get_queuesize(__unknown_params); #endif /* #ifdef __NEW_STARLET */ #define cma$lib_attr_set_queuesize CMA$LIB_ATTR_SET_QUEUESIZE #ifdef __NEW_STARLET void cma$lib_attr_set_queuesize( CMA$LIB_T_ATTR *attr, CMA$T_NATURAL queuesize); #else /* __OLD_STARLET */ void cma$lib_attr_set_queuesize(__unknown_params); #endif /* #ifdef __NEW_STARLET */ #if _CMA_OS_ == _CMA__VMS # if (_CMA_COMPILER_ == _CMA__DECC) || (_CMA_COMPILER_ == _CMA__DECCPLUS) # pragma __extern_model __restore /* set prior to inclusion of cma_config.h */ # endif #endif #pragma standard /* set at top of this file */ #ifdef __cplusplus } #endif #endif #pragma __member_alignment __restore #ifdef __INITIAL_POINTER_SIZE /* Defined whenever ptr size pragmas supported */ #pragma __required_pointer_size __restore /* Restore the previously-defined required ptr size */ #endif #ifdef __cplusplus } #endif #pragma __standard #endif /* __CMA_DEF_LOADED */