ID tskid = tk_cre_tsk ( CONST T_CTSK *pk_ctsk );

ER ercd = tk_del_tsk ( ID tskid );

ER ercd = tk_sta_tsk ( ID tskid, INT stacd );

void tk_ext_tsk ( void );

void tk_exd_tsk ( void );

ER ercd = tk_ter_tsk ( ID tskid );

ER ercd = tk_chg_pri ( ID tskid, PRI tskpri );

ER ercd = tk_chg_slt ( ID tskid, RELTIM slicetime );

ER ercd = tk_chg_slt_u ( ID tskid, RELTIM_U slicetime_u );

ER ercd = tk_get_tsp ( ID tskid, T_TSKSPC *pk_tskspc );

ER ercd = tk_set_tsp ( ID tskid, CONST T_TSKSPC *pk_tskspc );

ID resid = tk_get_rid ( ID tskid );

ID oldid = tk_set_rid ( ID tskid, ID resid );

ER ercd = tk_get_reg ( ID tskid, T_REGS *pk_regs, T_EIT *pk_eit, T_CREGS *pk_cregs );

ER ercd = tk_set_reg ( ID tskid, CONST T_REGS *pk_regs, CONST T_EIT *pk_eit, CONST T_CREGS *pk_cregs );

ER ercd = tk_get_cpr ( ID tskid, INT copno, T_COPREGS *pk_copregs );

ER ercd = tk_set_cpr ( ID tskid, INT copno, CONST T_COPREGS *pk_copregs );

ER ercd = tk_inf_tsk ( ID tskid, T_ITSK *pk_itsk, BOOL clr );

ER ercd = tk_inf_tsk_u ( ID tskid, T_ITSK_U *pk_itsk_u, BOOL clr );

ER ercd = tk_ref_tsk ( ID tskid, T_RTSK *pk_rtsk );

ER ercd = tk_ref_tsk_u ( ID tskid, T_RTSK_U *pk_rtsk_u );

ER ercd = tk_slp_tsk ( TMO tmout );

ER ercd = tk_slp_tsk_u ( TMO_U tmout_u );

ER ercd = tk_wup_tsk ( ID tskid );

INT wupcnt = tk_can_wup ( ID tskid );

ER ercd = tk_rel_wai ( ID tskid );

ER ercd = tk_sus_tsk ( ID tskid );

ER ercd = tk_rsm_tsk ( ID tskid );

ER ercd = tk_frsm_tsk ( ID tskid );

ER ercd = tk_dly_tsk ( RELTIM dlytim );

ER ercd = tk_dly_tsk_u ( RELTIM_U dlytim_u );

ER ercd = tk_sig_tev ( ID tskid, INT tskevt );

INT tevptn = tk_wai_tev ( INT waiptn, TMO tmout );

INT tevptn = tk_wai_tev_u ( INT waiptn, TMO_U tmout_u );

INT tskwait = tk_dis_wai ( ID tskid, UW waitmask );

ER ercd = tk_ena_wai ( ID tskid );

ER ercd = tk_def_tex ( ID tskid, CONST T_DTEX *pk_dtex );

ER ercd = tk_ena_tex ( ID tskid, UINT texptn );

ER ercd = tk_dis_tex ( ID tskid, UINT texptn );

ER ercd = tk_ras_tex ( ID tskid, INT texcd );

INT texcd = tk_end_tex ( BOOL enatex );

ER ercd = tk_ref_tex ( ID tskid, T_RTEX *pk_rtex );

ID semid = tk_cre_sem ( CONST T_CSEM *pk_csem );

ER ercd = tk_del_sem ( ID semid );

ER ercd = tk_sig_sem ( ID semid, INT cnt );

ER ercd = tk_wai_sem ( ID semid, INT cnt, TMO tmout );

ER ercd = tk_wai_sem_u ( ID semid, INT cnt, TMO_U tmout_u );

ER ercd = tk_ref_sem ( ID semid, T_RSEM *pk_rsem );

ID flgid = tk_cre_flg ( CONST T_CFLG *pk_cflg );

ER ercd = tk_del_flg ( ID flgid );

ER ercd = tk_set_flg ( ID flgid, UINT setptn );

ER ercd = tk_clr_flg ( ID flgid, UINT clrptn );

ER ercd = tk_wai_flg ( ID flgid, UINT waiptn, UINT wfmode, UINT *p_flgptn, TMO tmout );

ER ercd = tk_wai_flg_u ( ID flgid, UINT waiptn, UINT wfmode, UINT *p_flgptn, TMO_U tmout_u );

ER ercd = tk_ref_flg ( ID flgid, T_RFLG *pk_rflg );

ID mbxid = tk_cre_mbx ( CONST T_CMBX* pk_cmbx );

ER ercd = tk_del_mbx ( ID mbxid );

ER ercd = tk_snd_mbx ( ID mbxid, T_MSG *pk_msg );

ER ercd = tk_rcv_mbx ( ID mbxid, T_MSG **ppk_msg, TMO tmout );

ER ercd = tk_rcv_mbx_u ( ID mbxid, T_MSG **ppk_msg, TMO_U tmout_u );

ER ercd = tk_ref_mbx ( ID mbxid, T_RMBX *pk_rmbx );

ID mtxid = tk_cre_mtx ( CONST T_CMTX *pk_cmtx );

ER ercd = tk_del_mtx ( ID mtxid );

ER ercd = tk_loc_mtx ( ID mtxid, TMO tmout );

ER ercd = tk_loc_mtx_u ( ID mtxid, TMO_U tmout_u );

ER ercd = tk_unl_mtx ( ID mtxid );

ER ercd = tk_ref_mtx ( ID mtxid, T_RMTX *pk_rmtx );

ID mbfid = tk_cre_mbf ( CONST T_CMBF *pk_cmbf );

ER ercd = tk_del_mbf ( ID mbfid );

ER ercd = tk_snd_mbf ( ID mbfid, CONST void *msg, INT msgsz, TMO tmout );

ER ercd = tk_snd_mbf_u ( ID mbfid, CONST void *msg, INT msgsz, TMO_U tmout_u );

INT msgsz = tk_rcv_mbf ( ID mbfid, void *msg, TMO tmout );

INT msgsz = tk_rcv_mbf_u ( ID mbfid, void *msg, TMO_U tmout_u );

ER ercd = tk_ref_mbf ( ID mbfid, T_RMBF *pk_rmbf );

ID porid = tk_cre_por ( CONST T_CPOR *pk_cpor );

ER ercd = tk_del_por ( ID porid );

INT rmsgsz = tk_cal_por ( ID porid, UINT calptn, void *msg, INT cmsgsz, TMO tmout );

INT rmsgsz = tk_cal_por_u ( ID porid, UINT calptn, void *msg, INT cmsgsz, TMO_U tmout_u );

INT cmsgsz = tk_acp_por ( ID porid, UINT acpptn, RNO *p_rdvno, void *msg, TMO tmout );

INT cmsgsz = tk_acp_por_u ( ID porid, UINT acpptn, RNO *p_rdvno, void *msg, TMO_U tmout_u );

ER ercd = tk_fwd_por ( ID porid, UINT calptn, RNO rdvno, void *msg, INT cmsgsz );

ER ercd = tk_rpl_rdv ( RNO rdvno, void *msg, INT rmsgsz );

ER ercd = tk_ref_por ( ID porid, T_RPOR *pk_rpor );

ID mpfid = tk_cre_mpf ( CONST T_CMPF *pk_cmpf );

ER ercd = tk_del_mpf ( ID mpfid );

ER ercd = tk_get_mpf ( ID mpfid, void **p_blf, TMO tmout );

ER ercd = tk_get_mpf_u ( ID mpfid, void **p_blf, TMO_U tmout_u );

ER ercd = tk_rel_mpf ( ID mpfid, void *blf );

ER ercd = tk_ref_mpf ( ID mpfid, T_RMPF *pk_rmpf );

ID mplid = tk_cre_mpl ( CONST T_CMPL *pk_cmpl );

ER ercd = tk_del_mpl ( ID mplid );

ER ercd = tk_get_mpl ( ID mplid, SZ blksz, void **p_blk, TMO tmout );

ER ercd = tk_get_mpl_u ( ID mplid, SZ blksz, void **p_blk, TMO_U tmout_u );

ER ercd = tk_rel_mpl ( ID mplid, void *blk );

ER ercd = tk_ref_mpl ( ID mplid, T_RMPL *pk_rmpl );

ER ercd = tk_set_tim ( CONST SYSTIM *pk_tim );

ER ercd = tk_set_tim_u ( SYSTIM_U tim_u );

ER ercd = tk_get_tim ( SYSTIM *pk_tim );

ER ercd = tk_get_tim_u ( SYSTIM_U *tim_u, UW *ofs );

ER ercd = tk_get_otm ( SYSTIM *pk_tim );

ER ercd = tk_get_otm_u ( SYSTIM_U *tim_u, UW *ofs );

ID cycid = tk_cre_cyc ( CONST T_CCYC *pk_ccyc );

ID cycid = tk_cre_cyc_u ( CONST T_CCYC_U *pk_ccyc_u );

ER ercd = tk_del_cyc ( ID cycid );

ER ercd = tk_sta_cyc ( ID cycid );

ER ercd = tk_stp_cyc ( ID cycid );

ER ercd = tk_ref_cyc ( ID cycid, T_RCYC *pk_rcyc );

ER ercd = tk_ref_cyc_u ( ID cycid, T_RCYC_U *pk_rcyc_u );

ID almid = tk_cre_alm ( CONST T_CALM *pk_calm );

ER ercd = tk_del_alm ( ID almid );

ER ercd = tk_sta_alm ( ID almid, RELTIM almtim );

ER ercd = tk_sta_alm_u ( ID almid, RELTIM_U almtim_u );

ER ercd = tk_stp_alm ( ID almid );

ER ercd = tk_ref_alm ( ID almid, T_RALM *pk_ralm );

ER ercd = tk_ref_alm_u ( ID almid, T_RALM_U *pk_ralm_u );

ER ercd = tk_def_int ( UINT intno, CONST T_DINT *pk_dint );

void tk_ret_int ( void );

ER ercd = tk_rot_rdq ( PRI tskpri );

ID tskid = tk_get_tid ( void );

ER ercd = tk_dis_dsp ( void );

ER ercd = tk_ena_dsp ( void );

ER ercd = tk_ref_sys ( T_RSYS *pk_rsys );

ER ercd = tk_set_pow ( UINT powmode );

ER ercd = tk_ref_ver ( T_RVER *pk_rver );

ER ercd = tk_def_ssy ( ID ssid, CONST T_DSSY *pk_dssy );

ER ercd = tk_sta_ssy ( ID ssid, ID resid, INT info );

ER ercd = tk_cln_ssy ( ID ssid, ID resid, INT info );

ER ercd = tk_evt_ssy ( ID ssid, INT evttyp, ID resid, INT info );

ER ercd = tk_ref_ssy ( ID ssid, T_RSSY *pk_rssy );

ER ercd = tk_cre_res ( void );

ER ercd = tk_del_res ( ID resid );

ER ercd = tk_get_res ( ID resid, ID ssid, void **p_resblk );

ER ercd = tk_get_smb ( void **addr, SZ nblk, UINT attr );

ER ercd = tk_rel_smb ( void *addr );

ER ercd = tk_ref_smb ( T_RSMB *pk_rsmb );

void* Vmalloc ( size_t size );

void* Vcalloc ( size_t nmemb, size_t size );

void* Vrealloc ( void *ptr, size_t size );

void Vfree ( void *ptr );

void* Kmalloc ( size_t size );

void* Kcalloc ( size_t nmemb, size_t size );

void* Krealloc ( void *ptr, size_t size );

void Kfree ( void *ptr );

ER ercd = SetTaskSpace ( ID tskid );

ER ercd = ChkSpaceR ( void *addr, SZ len );

ER ercd = ChkSpaceRW ( void *addr, SZ len );

ER ercd = ChkSpaceRE ( void *addr, SZ len );

SZ rlen = ChkSpaceBstrR ( CONST UB *str, SZ max );

SZ rlen = ChkSpaceBstrRW ( CONST UB *str, SZ max );

SZ rlen = ChkSpaceTstrR ( CONST TC *str, SZ max );

SZ rlen = ChkSpaceTstrRW ( CONST TC *str, SZ max );

ER ercd = LockSpace ( CONST void *addr, SZ len );

ER ercd = UnlockSpace ( CONST void *addr, SZ len );

SZ rlen = CnvPhysicalAddr ( CONST void *vaddr, SZ len, void **paddr );

ER ercd = MapMemory ( CONST void *paddr, SZ len, UINT attr, void **laddr );

ER ercd = UnmapMemory ( CONST void *laddr );

ER ercd = GetSpaceInfo ( CONST void *addr, SZ len, T_SPINFO *pk_spinfo );

SZ rlen = SetMemoryAccess ( CONST void *addr, SZ len, UINT mode );

ID dd = tk_opn_dev ( CONST UB *devnm, UINT omode );

ER ercd = tk_cls_dev ( ID dd, UINT option );

ID reqid = tk_rea_dev ( ID dd, W start, void *buf, SZ size, TMO tmout );

ID reqid = tk_rea_dev_du ( ID dd, D start_d, void *buf, SZ size, TMO_U tmout_u );

ER ercd = tk_srea_dev ( ID dd, W start, void *buf, SZ size, SZ *asize );

ER ercd = tk_srea_dev_d ( ID dd, D start_d, void *buf, SZ size, SZ *asize );

ID reqid = tk_wri_dev ( ID dd, W start, CONST void *buf, SZ size, TMO tmout );

ID reqid = tk_wri_dev_du ( ID dd, D start_d, CONST void *buf, SZ size, TMO_U tmout_u );

ER ercd = tk_swri_dev ( ID dd, W start, CONST void *buf, SZ size, SZ *asize );

ER ercd = tk_swri_dev_d ( ID dd, D start_d, CONST void *buf, W size, W *asize );

ID creqid = tk_wai_dev ( ID dd, ID reqid, SZ *asize, ER *ioer, TMO tmout );

ID creqid = tk_wai_dev_u ( ID dd, ID reqid, SZ *asize, ER *ioer, TMO_U tmout_u );

INT dissus = tk_sus_dev ( UINT mode );

ID pdevid = tk_get_dev ( ID devid, UB *devnm );

ID devid = tk_ref_dev ( CONST UB *devnm, T_RDEV *rdev );

ID devid = tk_oref_dev ( ID dd, T_RDEV *rdev );

INT remcnt = tk_lst_dev ( T_LDEV *ldev, INT start, INT ndev );

INT retcode = tk_evt_dev ( ID devid, INT evttyp, void *evtinf );

ID devid = tk_def_dev ( CONST UB *devnm, CONST T_DDEV *ddev, T_IDEV *idev );

ER ercd = tk_ref_idv ( T_IDEV *idev );

ER ercd = openfn ( ID devid, UINT omode, void *exinf );

ER ercd = closefn ( ID devid, UINT option, void *exinf );

ER ercd = execfn ( T_DEVREQ *devreq, TMO tmout, void *exinf );

ER ercd = execfn ( T_DEVREQ_D *devreq_d, TMO tmout, void *exinf );

ER ercd = execfn ( T_DEVREQ *devreq, TMO_U tmout_u, void *exinf );

ER ercd = execfn ( T_DEVREQ_D *devreq_d, TMO_U tmout_u, void *exinf );

INT creqno = waitfn ( T_DEVREQ *devreq, INT nreq, TMO tmout, void *exinf );

INT creqno = waitfn ( T_DEVREQ_D *devreq_d, INT nreq, TMO tmout, void *exinf );

INT creqno = waitfn ( T_DEVREQ *devreq, INT nreq, TMO_U tmout_u, void *exinf );

INT creqno = waitfn ( T_DEVREQ_D *devreq_d, INT nreq, TMO_U tmout_u, void *exinf );

ER ercd = abortfn ( ID tskid, T_DEVREQ *devreq, INT nreq, void *exinf );

ER ercd = abortfn ( ID tskid, T_DEVREQ_D *devreq_d, INT nreq, void *exinf );

INT retcode = eventfn ( INT evttyp, void *evtinf, void *exinf );

DI ( UINT intsts );

EI ( UINT intsts );

BOOL disint = isDI ( UINT intsts );

void SetCpuIntLevel ( INT level );

INT level = GetCpuIntLevel ( void );

void EnableInt ( UINT intno );

void EnableInt ( UINT intno, INT level );

void DisableInt ( UINT intno );

void ClearInt ( UINT intno );

void EndOfInt ( UINT intno );

BOOL rasint = CheckInt ( UINT intno );

void SetIntMode ( UINT intno, UINT mode );

void SetCtrlIntLevel ( INT level );

INT level = GetCtrlIntLevel ( void );

void out_b ( INT port, UB data );

void out_h ( INT port, UH data );

void out_w ( INT port, UW data );

void out_d ( INT port, UD data );

UB data = in_b ( INT port );

UH data = in_h ( INT port );

UW data = in_w ( INT port );

UD data = in_d ( INT port );

void WaitUsec ( UW usec );

void WaitNsec ( UW nsec );

void low_pow ( void );

void off_pow ( void );

INT ct = tk_get_cfn ( CONST UB *name, W *val, INT max );

INT rlen = tk_get_cfs ( CONST UB *name, UB *buf, INT max );

SZ rlen = SetCacheMode ( void *addr, SZ len, UINT mode );

SZ rlen = ControlCache ( void *addr, SZ len, UINT mode );

ER ercd = StartPhysicalTimer ( UINT ptmrno, UW limit, UINT mode );

ER ercd = StopPhysicalTimer ( UINT ptmrno );

ER ercd = GetPhysicalTimerCount ( UINT ptmrno, UW *p_count );

ER ercd = DefinePhysicalTimerHandler ( UINT ptmrno, CONST T_DPTMR *pk_dptmr );

ER ercd = GetPhysicalTimerConfig ( UINT ptmrno, T_RPTMR *pk_rptmr );

void SetOBJNAME ( void *exinf, CONST UB *name );

ER ercd = CreateLock ( FastLock *lock, CONST UB *name );

void DeleteLock ( FastLock *lock );

void Lock ( FastLock *lock );

void Unlock ( FastLock *lock );

ER ercd = CreateMLock ( FastMLock *lock, CONST UB *name );

ER ercd = DeleteMLock ( FastMLock *lock );

ER ercd = MLock ( FastMLock *lock, INT no );

ER ercd = MLockTmo ( FastMLock *lock, INT no, TMO tmout );

ER ercd = MLockTmo_u ( FastMLock *lock, INT no, TMO_U tmout_u );

ER ercd = MUnlock ( FastMLock *lock, INT no );

INT ct = td_lst_tsk ( ID list[], INT nent );

INT ct = td_lst_sem ( ID list[], INT nent );

INT ct = td_lst_flg ( ID list[], INT nent );

INT ct = td_lst_mbx ( ID list[], INT nent );

INT ct = td_lst_mtx ( ID list[], INT nent );

INT ct = td_lst_mbf ( ID list[], INT nent );

INT ct = td_lst_por ( ID list[], INT nent );

INT ct = td_lst_mpf ( ID list[], INT nent );

INT ct = td_lst_mpl ( ID list[], INT nent );

INT ct = td_lst_cyc ( ID list[], INT nent );

INT ct = td_lst_alm ( ID list[], INT nent );

INT ct = td_lst_ssy ( ID list[], INT nent );

INT ct = td_rdy_que ( PRI pri, ID list[], INT nent );

INT ct = td_sem_que ( ID semid, ID list[], INT nent );

INT ct = td_flg_que ( ID flgid, ID list[], INT nent );

INT ct = td_mbx_que ( ID mbxid, ID list[], INT nent );

INT ct = td_mtx_que ( ID mtxid, ID list[], INT nent );

INT ct = td_smbf_que ( ID mbfid, ID list[], INT nent );

INT ct = td_rmbf_que ( ID mbfid, ID list[], INT nent );

INT ct = td_cal_que ( ID porid, ID list[], INT nent );

INT ct = td_acp_que ( ID porid, ID list[], INT nent );

INT ct = td_mpf_que ( ID mpfid, ID list[], INT nent );

INT ct = td_mpl_que ( ID mplid, ID list[], INT nent );

ER ercd = td_ref_tsk ( ID tskid, TD_RTSK *rtsk );

ER ercd = td_ref_tsk_u ( ID tskid, TD_RTSK_U *rtsk_u );

ER ercd = td_ref_tex ( ID tskid, TD_RTEX *pk_rtex );

ER ercd = td_ref_sem ( ID semid, TD_RSEM *rsem );

ER ercd = td_ref_flg ( ID flgid, TD_RFLG *rflg );

ER ercd = td_ref_mbx ( ID mbxid, TD_RMBX *rmbx );

ER ercd = td_ref_mtx ( ID mtxid, TD_RMTX *rmtx );

ER ercd = td_ref_mbf ( ID mbfid, TD_RMBF *rmbf );

ER ercd = td_ref_por ( ID porid, TD_RPOR *rpor );

ER ercd = td_ref_mpf ( ID mpfid, TD_RMPF *rmpf );

ER ercd = td_ref_mpl ( ID mplid, TD_RMPL *rmpl );

ER ercd = td_ref_cyc ( ID cycid, TD_RCYC *rcyc );

ER ercd = td_ref_cyc_u ( ID cycid, TD_RCYC_U *rcyc_u );

ER ercd = td_ref_alm ( ID almid, TD_RALM *ralm );

ER ercd = td_ref_alm_u ( ID almid, TD_RALM_U *ralm_u );

ER ercd = td_ref_sys ( TD_RSYS *pk_rsys );

ER ercd = td_ref_ssy ( ID ssid, TD_RSSY *rssy );

ER ercd = td_inf_tsk ( ID tskid, TD_ITSK *pk_itsk, BOOL clr );

ER ercd = td_inf_tsk_u ( ID tskid, TD_ITSK_U *itsk_u, BOOL clr );

ER ercd = td_get_reg ( ID tskid, T_REGS *pk_regs, T_EIT *pk_eit, T_CREGS *pk_cregs );

ER ercd = td_set_reg ( ID tskid, CONST T_REGS *pk_regs, CONST T_EIT *pk_eit, CONST T_CREGS *pk_cregs );

ER ercd = td_get_tim ( SYSTIM *tim, UW *ofs );

ER ercd = td_get_tim_u ( SYSTIM_U *tim_u, UW *ofs );

ER ercd = td_get_otm ( SYSTIM *tim, UW *ofs );

ER ercd = td_get_otm_u ( SYSTIM_U *tim_u, UW *ofs );

ER ercd = td_ref_dsname ( UINT type, ID id, UB *dsname );

ER ercd = td_set_dsname ( UINT type, ID id, CONST UB *dsname );

ER ercd = td_hok_svc ( CONST TD_HSVC *hsvc );

ER ercd = td_hok_dsp ( CONST TD_HDSP *hdsp );

ER ercd = td_hok_int ( CONST TD_HINT *hint );