toppers/outline_stub.hpp

解説を見る。

/*
 *  TOPPERS/C++ API Template Library
 *      Toyohashi Open Platform for Embedded Real-Time Systems/
 *      C++ API Template Library
 *
 *  Copyright (C) 2004 by TAKAGI Nobuhisa
 *
 *  上記著作権者は，以下の (1)〜(4) の条件か，Free Software Foundation
 *  によって公表されている GNU General Public License の Version 2 に記
 *  述されている条件を満たす場合に限り，本ソフトウェア（本ソフトウェア
 *  を改変したものを含む．以下同じ）を使用・複製・改変・再配布（以下，
 *  利用と呼ぶ）することを無償で許諾する．
 *  (1) 本ソフトウェアをソースコードの形で利用する場合には，上記の著作
 *      権表示，この利用条件および下記の無保証規定が，そのままの形でソー
 *      スコード中に含まれていること．
 *  (2) 本ソフトウェアを，ライブラリ形式など，他のソフトウェア開発に使
 *      用できる形で再配布する場合には，再配布に伴うドキュメント（利用
 *      者マニュアルなど）に，上記の著作権表示，この利用条件および下記
 *      の無保証規定を掲載すること．
 *  (3) 本ソフトウェアを，機器に組み込むなど，他のソフトウェア開発に使
 *      用できない形で再配布する場合には，次のいずれかの条件を満たすこ
 *      と．
 *    (a) 再配布に伴うドキュメント（利用者マニュアルなど）に，上記の著
 *        作権表示，この利用条件および下記の無保証規定を掲載すること．
 *    (b) 再配布の形態を，別に定める方法によって，TOPPERSプロジェクトに
 *        報告すること．
 *  (4) 本ソフトウェアの利用により直接的または間接的に生じるいかなる損
 *      害からも，上記著作権者およびTOPPERSプロジェクトを免責すること．
 *
 *  本ソフトウェアは，無保証で提供されているものである．上記著作権者お
 *  よびTOPPERSプロジェクトは，本ソフトウェアに関して，その適用可能性も
 *  含めて，いかなる保証も行わない．また，本ソフトウェアの利用により直
 *  接的または間接的に生じたいかなる損害に関しても，その責任を負わない．
 *
 *  @(#) $Id: outline_stub.hpp,v 1.1.1.1 2004/04/14 09:30:30 takagi-n Exp $
 */

#ifndef TOPPERS_OUTLINE_STUB_HPP_
#define TOPPERS_OUTLINE_STUB_HPP_

#include <toppers/kernel.hpp>

namespace toppers
{

    class outline_stub
    {
    public:
        //  互換性のための多重定義
        static ER stub_cre_tsk(ID tskid, t_ctsk* pk_ctsk);
        static ER stub_cre_tsk(ID tskid, const t_ctsk* pk_ctsk);
        static ER stub_del_tsk(ID tskid);
        static ER stub_act_tsk(ID tskid);
        static ER_UINT stub_can_act(ID tskid);
        static ER stub_sta_tsk(ID tskid, VP_INT stacd);
        static void stub_ext_tsk();
        static void stub_exd_tsk();
        static ER stub_ter_tsk(ID tskid);
        static ER stub_chg_pri(ID tskid, PRI tskpri);
        static ER stub_get_pri(ID tskid, PRI* p_tskpri);
        static ER stub_ref_tsk(ID tskid, t_rtsk* pk_rtsk);
        static ER stub_ref_tst(ID tskid, t_rtst* pk_rtst);


        static ER stub_slp_tsk();
        static ER stub_tslp_tsk(TMO tmout);
        static ER stub_wup_tsk(ID tskid);
        static ER_UINT stub_can_wup(ID tskid);
        static ER stub_rel_wai(ID tskid);
        static ER stub_sus_tsk(ID tskid);
        static ER stub_rsm_tsk(ID tskid);
        static ER stub_frsm_tsk(ID tskid);
        static ER stub_dly_tsk(RELTIM dlytim);

        //  互換性のための多重定義
        static ER stub_def_tex(ID tskid, t_dtex* pk_dtex);
        static ER stub_def_tex(ID tskid, const t_dtex* pk_dtex);
        static ER stub_ras_tex(ID tskid, TEXPTN rasptn);
        static ER stub_dis_tex();
        static ER stub_ena_tex();
        static bool stub_sns_tex();
        static ER stub_ref_tex(ID tskid, t_rtex* pk_rtex);

        //  互換性のための多重定義
        static ER stub_cre_sem(ID semid, t_csem* pk_csem);
        static ER stub_cre_sem(ID semid, const t_csem* pk_csem);
        static ER stub_del_sem(ID semid);
        static ER stub_sig_sem(ID semid);
        static ER stub_wai_sem(ID semid);
        static ER stub_pol_sem(ID semid);
        static ER stub_twai_sem(ID semid, TMO tmout);
        static ER stub_ref_sem(ID semid, t_rsem* pk_rsem);

        //  互換性のための多重定義
        static ER stub_cre_flg(ID flgid, t_cflg* pk_cflg);
        static ER stub_cre_flg(ID flgid, const t_cflg* pk_cflg);
        static ER stub_del_flg(ID flgid);
        static ER stub_set_flg(ID flgid, FLGPTN setptn);
        static ER stub_clr_flg(ID flgid, FLGPTN clrptn);
        static ER stub_wai_flg(ID flgid, FLGPTN waiptn, MODE wfmode, FLGPTN* p_flgptn);
        static ER stub_pol_flg(ID flgid, FLGPTN waiptn, MODE wfmode, FLGPTN* p_flgptn);
        static ER stub_twai_flg(ID flgid, FLGPTN waiptn, MODE wfmode, FLGPTN* p_flgptn, TMO tmout);
        static ER stub_ref_flg(ID flgid, t_rflg* pk_rflg);

        //  互換性のための多重定義
        static ER stub_cre_dtq(ID dtqid, t_cdtq* pk_cdtq);
        static ER stub_cre_dtq(ID dtqid, const t_cdtq* pk_cdtq);
        static ER stub_del_dtq(ID dtqid);
        static ER stub_snd_dtq(ID dtqid, VP_INT data);
        static ER stub_psnd_dtq(ID dtqid, VP_INT data);
        static ER stub_tsnd_dtq(ID dtqid, VP_INT data, TMO tmout);
        static ER stub_fsnd_dtq(ID dtqid, VP_INT data);
        static ER stub_rcv_dtq(ID dtqid, VP_INT* p_data);
        static ER stub_prcv_dtq(ID dtqid, VP_INT* p_data);
        static ER stub_trcv_dtq(ID dtqid, VP_INT* p_data, TMO tmout);
        static ER stub_ref_dtq(ID dtqid, t_rdtq* pk_rdtq);

        //  互換性のための多重定義
        static ER stub_cre_mbx(ID mbxid, t_cmbx* pk_cmbx);
        static ER stub_cre_mbx(ID mbxid, const t_cmbx* pk_cmbx);
        static ER stub_del_mbx(ID mbxid);
        static ER stub_snd_mbx(ID mbxid, T_MSG* pk_msg);
        static ER stub_rcv_mbx(ID mbxid, T_MSG** ppk_msg);
        static ER stub_prcv_mbx(ID mbxid, T_MSG** ppk_msg);
        static ER stub_trcv_mbx(ID mbxid, T_MSG** ppk_msg, TMO tmout);
        static ER stub_ref_mbx(ID mbxid, t_rmbx* pk_rmbx);

        //  互換性のための多重定義
        static ER stub_cre_mpf(ID mpfid, t_cmpf* pk_cmpf);
        static ER stub_cre_mpf(ID mpfid, const t_cmpf* pk_cmpf);
        static ER stub_del_mpf(ID mpfid);
        static ER stub_rel_mpf(ID mpfid, VP blk);
        static ER stub_get_mpf(ID mpfid, VP* p_blk);
        static ER stub_pget_mpf(ID mpfid, VP* p_blk);
        static ER stub_tget_mpf(ID mpfid, VP* p_blk, TMO tmout);
        static ER stub_ref_mpf(ID mpfid, t_rmpf* pk_rmpf);

        //  互換性のための多重定義
        static ER stub_set_tim(SYSTIM* p_systim);
        static ER stub_set_tim(const SYSTIM* p_systim);
        static ER stub_get_tim(SYSTIM* p_systim);

        //  互換性のための多重定義
        static ER stub_cre_cyc(ID cycid, t_ccyc* pk_ccyc);
        static ER stub_cre_cyc(ID cycid, const t_ccyc* pk_ccyc);
        static ER stub_del_cyc(ID cycid);
        static ER stub_sta_cyc(ID cycid);
        static ER stub_stp_cyc(ID cycid);
        static ER stub_ref_cyc(ID cycid, t_rcyc* pk_rcyc);


        static ER stub_rot_rdq(PRI tskpri);
        static ER stub_get_tid(ID* p_tskid);
        static ER stub_loc_cpu();
        static ER stub_unl_cpu();
        static ER stub_dis_dsp();
        static ER stub_ena_dsp();
        static bool stub_sns_ctx();
        static bool stub_sns_loc();
        static bool stub_sns_dsp();
        static bool stub_sns_dpn();
        static ER stub_ref_sys(t_rsys* pk_rsys);

        //  互換性のための多重定義
        static ER stub_def_inh(INHNO inhno, t_dinh* pk_dinh);
        static ER stub_def_inh(INHNO inhno, const t_dinh* pk_dinh);
        //  互換性のための多重定義
        static ER stub_cre_isr(ID isrid, t_cisr* pk_cisr);
        static ER stub_cre_isr(ID isrid, const t_cisr* pk_cisr);
        static ER stub_del_isr(ID isrid);
        static ER stub_ref_isr(ID isrid, t_risr* pk_risr);
        static ER stub_dis_int(INTNO intno);
        static ER stub_ena_int(INTNO intno);
        static ER stub_chg_ims(IMS ims);
        static ER stub_get_ims(IMS* P_ims);

        //  互換性のための多重定義
        static ER stub_def_exc(EXCNO excno, t_dexc* pk_dexc);
        static ER stub_def_exc(EXCNO excno, const t_dexc* pk_dexc);
        static ER stub_ref_cfg(t_rcfg* pk_rcfg);
        static ER stub_ref_ver(t_rver* pk_rver);


        static ER stub_iact_tsk(ID tskid);
        static ER stub_iwup_tsk(ID tskid);
        static ER stub_irel_wai(ID tskid);
        static ER stub_iras_tex(ID tskid, TEXPTN rasptn);
        static ER stub_isig_sem(ID semid);
        static ER stub_iset_flg(ID flgid, FLGPTN setptn);
        static ER stub_ipsnd_dtq(ID dtqid, VP_INT data);
        static ER stub_ifsnd_dtq(ID dtqid, VP_INT data);
        static ER stub_irot_rdq(PRI tskpri);
        static ER stub_iget_tid(ID* p_tskid);
        static ER stub_iloc_cpu();
        static ER stub_iunl_cpu();
        static ER stub_isig_tim();

        //  互換性のための多重定義
        static ER stub_cre_mtx(ID mtxid, t_cmtx* pk_cmtx);
        static ER stub_cre_mtx(ID mtxid, const t_cmtx* pk_cmtx);
        static ER stub_del_mtx(ID mtxid);
        static ER stub_unl_mtx(ID mtxid);
        static ER stub_loc_mtx(ID mtxid);
        static ER stub_ploc_mtx(ID mtxid);
        static ER stub_tloc_mtx(ID mtxid, TMO tmout);
        static ER stub_ref_mtx(ID mtxid, t_rmtx* pk_rmtx);

        //  互換性のための多重定義
        static ER stub_cre_mbf(ID mbfid, t_cmbf* pk_cmbf);
        static ER stub_cre_mbf(ID mbfid, const t_cmbf* pk_cmbf);
        static ER stub_del_mbf(ID mbfid);
        static ER stub_snd_mbf(ID mbfid, const void* msg, UINT msgsz);
        static ER stub_psnd_mbf(ID mbfid, const void* msg, UINT msgsz);
        static ER stub_tsnd_mbf(ID mbfid, const void* msg, UINT msgsz, TMO tmout);
        static ER_UINT stub_rcv_mbf(ID mbfid, void* msg);
        static ER_UINT stub_prcv_mbf(ID mbfid, void* msg);
        static ER_UINT stub_trcv_mbf(ID mbfid, void* msg, TMO tmout);
        static ER stub_ref_mbf(ID mbfid, t_rmbf* pk_rmbf);

        //  互換性のための多重定義
        static ER stub_cre_por(ID porid, t_cpor* pk_cpor);
        static ER stub_cre_por(ID porid, const t_cpor* pk_cpor);
        static ER stub_del_por(ID porid);
        static ER_UINT stub_cal_por(ID porid, RDVPTN calptn, void* msg, UINT cmsgsz);
        static ER_UINT stub_tcal_por(ID porid, RDVPTN calptn, void* msg, UINT cmsgsz, TMO tmout);
        static ER_UINT stub_acp_por(ID porid, RDVPTN acpptn, RDVNO* p_rdvno, void* msg);
        static ER_UINT stub_pacp_por(ID porid, RDVPTN acpptn, RDVNO* p_rdvno, void* msg);
        static ER_UINT stub_tacp_por(ID porid, RDVPTN acpptn, RDVNO* p_rdvno, void* msg, TMO tmout);
        static ER stub_fwd_por(ID porid, RDVPTN acpptn, RDVNO rdvno, const void* msg, UINT cmsgsz);
        static ER stub_rpl_rdv(RDVNO rdvno, const void* msg, UINT rmsgsz);
        static ER stub_ref_por(ID porid, t_rpor* pk_rpor);
        static ER stub_ref_rdv(RDVNO rdvid, t_rrdv* pk_rrdv);

        //  互換性のための多重定義
        static ER stub_cre_mpl(ID mplid, t_cmpl* pk_cmpl);
        static ER stub_cre_mpl(ID mplid, const t_cmpl* pk_cmpl);
        static ER stub_del_mpl(ID mplid);
        static ER stub_rel_mpl(ID mplid, VP blk);
        static ER stub_get_mpl(ID mplid, UINT blksz, VP* p_blk);
        static ER stub_pget_mpl(ID mplid, UINT blksz, VP* p_blk);
        static ER stub_tget_mpl(ID mplid, UINT blksz, VP* p_blk, TMO tmout);
        static ER stub_ref_mpl(ID mplid, t_rmpl* pk_rmpl);

        //  互換性のための多重定義
        static ER stub_cre_alm(ID almid, t_calm* pk_calm);
        static ER stub_cre_alm(ID almid, const t_calm* pk_calm);
        static ER stub_del_alm(ID almid);
        static ER stub_sta_alm(ID almid, RELTIM almtim);
        static ER stub_stp_alm(ID almid);
        static ER stub_ref_alm(ID almid, t_ralm* pk_ralm);

        //  互換性のための多重定義
        static ER stub_def_ovr(t_dovr* pk_dovr);
        static ER stub_def_ovr(const t_dovr* pk_dovr);
        static ER stub_sta_ovr(ID tskid, OVRTIM ovrtim);
        static ER stub_stp_ovr(ID tskid);
        static ER stub_ref_ovr(ID tskid, t_rovr* pk_rovr);

        //  互換性のための多重定義
        static ER_ID stub_acre_tsk(t_ctsk* pk_ctsk);
        static ER_ID stub_acre_tsk(const t_ctsk* pk_ctsk);
        //  互換性のための多重定義
        static ER_ID stub_acre_sem(t_csem* pk_csem);
        static ER_ID stub_acre_sem(const t_csem* pk_csem);
        //  互換性のための多重定義
        static ER_ID stub_acre_flg(t_cflg* pk_cflg);
        static ER_ID stub_acre_flg(const t_cflg* pk_cflg);
        //  互換性のための多重定義
        static ER_ID stub_acre_dtq(t_cdtq* pk_cdtq);
        static ER_ID stub_acre_dtq(const t_cdtq* pk_cdtq);
        //  互換性のための多重定義
        static ER_ID stub_acre_mbx(t_cmbx* pk_cmbx);
        static ER_ID stub_acre_mbx(const t_cmbx* pk_cmbx);
        //  互換性のための多重定義
        static ER_ID stub_acre_mtx(t_cmtx* pk_cmtx);
        static ER_ID stub_acre_mtx(const t_cmtx* pk_cmtx);
        //  互換性のための多重定義
        static ER_ID stub_acre_mbf(t_cmbf* pk_cmbf);
        static ER_ID stub_acre_mbf(const t_cmbf* pk_cmbf);
        //  互換性のための多重定義
        static ER_ID stub_acre_por(t_cpor* pk_cpor);
        static ER_ID stub_acre_por(const t_cpor* pk_cpor);
        //  互換性のための多重定義
        static ER_ID stub_acre_mpf(t_cmpf* pk_cmpf);
        static ER_ID stub_acre_mpf(const t_cmpf* pk_cmpf);
        //  互換性のための多重定義
        static ER_ID stub_acre_mpl(t_cmpl* pk_cmpl);
        static ER_ID stub_acre_mpl(const t_cmpl* pk_cmpl);
        //  互換性のための多重定義
        static ER_ID stub_acre_cyc(t_ccyc* pk_ccyc);
        static ER_ID stub_acre_cyc(const t_ccyc* pk_ccyc);
        //  互換性のための多重定義
        static ER_ID stub_acre_alm(t_calm* pk_calm);
        static ER_ID stub_acre_alm(const t_calm* pk_calm);
        //  互換性のための多重定義
        static ER_ID stub_acre_isr(t_cisr* pk_cisr);
        static ER_ID stub_acre_isr(const t_cisr* pk_cisr);


        static bool stub_vxsns_ctx(VP_INT exinf);
        static bool stub_vxsns_loc(VP_INT exinf);
        static bool stub_vxsns_dsp(VP_INT exinf);
        static bool stub_vxsns_dpn(VP_INT exinf);
        static bool stub_vxsns_tex(VP_INT exinf);
        static bool stub_vsns_ini();


        static ER stub_vxget_tim(SYSUTIM* p_sysutim);

        //  互換性のための多重定義
        static ER stub_def_svc(FN fncd, t_dsvc* pk_dsvc);
        static ER stub_def_svc(FN fncd, const t_dsvc* pk_dsvc);
        static ER_UINT stub_cal_svc(FN fncd);
        static ER_UINT stub_cal_svc(FN fncd, VP_INT par1);
        static ER_UINT stub_cal_svc(FN fncd, VP_INT par1, VP_INT par2);
        static ER_UINT stub_cal_svc(FN fncd, VP_INT par1, VP_INT par2, VP_INT par3);
        static ER_UINT stub_cal_svc(FN fncd, VP_INT par1, VP_INT par2, VP_INT par3, VP_INT par4);
        static ER_UINT stub_cal_svc(FN fncd, VP_INT par1, VP_INT par2, VP_INT par3, VP_INT par4, VP_INT par5);

    private:
        static ER call_cre_tsk(ID tskid, t_ctsk* pk_ctsk) throw();
        static ER call_cre_tsk(ID tskid, const t_ctsk* pk_ctsk) throw();
        static ER call_del_tsk(ID tskid) throw();
        static ER call_act_tsk(ID tskid) throw();
        static ER_UINT call_can_act(ID tskid) throw();
        static ER call_sta_tsk(ID tskid, VP_INT stacd) throw();
        static void call_ext_tsk() throw();
        static void call_exd_tsk() throw();
        static ER call_ter_tsk(ID tskid) throw();
        static ER call_chg_pri(ID tskid, PRI tskpri) throw();
        static ER call_get_pri(ID tskid, PRI* p_tskpri) throw();
        static ER call_ref_tsk(ID tskid, t_rtsk* pk_rtsk) throw();
        static ER call_ref_tst(ID tskid, t_rtst* pk_rtst) throw();
        static ER call_slp_tsk() throw();
        static ER call_tslp_tsk(TMO tmout) throw();
        static ER call_wup_tsk(ID tskid) throw();
        static ER_UINT call_can_wup(ID tskid) throw();
        static ER call_rel_wai(ID tskid) throw();
        static ER call_sus_tsk(ID tskid) throw();
        static ER call_rsm_tsk(ID tskid) throw();
        static ER call_frsm_tsk(ID tskid) throw();
        static ER call_dly_tsk(RELTIM dlytim) throw();
        static ER call_def_tex(ID tskid, t_dtex* pk_dtex) throw();
        static ER call_def_tex(ID tskid, const t_dtex* pk_dtex) throw();
        static ER call_ras_tex(ID tskid, TEXPTN rasptn) throw();
        static ER call_dis_tex() throw();
        static ER call_ena_tex() throw();
        static bool call_sns_tex() throw();
        static ER call_ref_tex(ID tskid, t_rtex* pk_rtex) throw();
        static ER call_cre_sem(ID semid, t_csem* pk_csem) throw();
        static ER call_cre_sem(ID semid, const t_csem* pk_csem) throw();
        static ER call_del_sem(ID semid) throw();
        static ER call_sig_sem(ID semid) throw();
        static ER call_wai_sem(ID semid) throw();
        static ER call_pol_sem(ID semid) throw();
        static ER call_twai_sem(ID semid, TMO tmout) throw();
        static ER call_ref_sem(ID semid, t_rsem* pk_rsem) throw();
        static ER call_cre_flg(ID flgid, t_cflg* pk_cflg) throw();
        static ER call_cre_flg(ID flgid, const t_cflg* pk_cflg) throw();
        static ER call_del_flg(ID flgid) throw();
        static ER call_set_flg(ID flgid, FLGPTN setptn) throw();
        static ER call_clr_flg(ID flgid, FLGPTN clrptn) throw();
        static ER call_wai_flg(ID flgid, FLGPTN waiptn, MODE wfmode, FLGPTN* p_flgptn) throw();
        static ER call_pol_flg(ID flgid, FLGPTN waiptn, MODE wfmode, FLGPTN* p_flgptn) throw();
        static ER call_twai_flg(ID flgid, FLGPTN waiptn, MODE wfmode, FLGPTN* p_flgptn, TMO tmout) throw();
        static ER call_ref_flg(ID flgid, t_rflg* pk_rflg) throw();
        static ER call_cre_dtq(ID dtqid, t_cdtq* pk_cdtq) throw();
        static ER call_cre_dtq(ID dtqid, const t_cdtq* pk_cdtq) throw();
        static ER call_del_dtq(ID dtqid) throw();
        static ER call_snd_dtq(ID dtqid, VP_INT data) throw();
        static ER call_psnd_dtq(ID dtqid, VP_INT data) throw();
        static ER call_tsnd_dtq(ID dtqid, VP_INT data, TMO tmout) throw();
        static ER call_fsnd_dtq(ID dtqid, VP_INT data) throw();
        static ER call_rcv_dtq(ID dtqid, VP_INT* p_data) throw();
        static ER call_prcv_dtq(ID dtqid, VP_INT* p_data) throw();
        static ER call_trcv_dtq(ID dtqid, VP_INT* p_data, TMO tmout) throw();
        static ER call_ref_dtq(ID dtqid, t_rdtq* pk_rdtq) throw();
        static ER call_cre_mbx(ID mbxid, t_cmbx* pk_cmbx) throw();
        static ER call_cre_mbx(ID mbxid, const t_cmbx* pk_cmbx) throw();
        static ER call_del_mbx(ID mbxid) throw();
        static ER call_snd_mbx(ID mbxid, T_MSG* pk_msg) throw();
        static ER call_rcv_mbx(ID mbxid, T_MSG** ppk_msg) throw();
        static ER call_prcv_mbx(ID mbxid, T_MSG** ppk_msg) throw();
        static ER call_trcv_mbx(ID mbxid, T_MSG** ppk_msg, TMO tmout) throw();
        static ER call_ref_mbx(ID mbxid, t_rmbx* pk_rmbx) throw();
        static ER call_cre_mpf(ID mpfid, t_cmpf* pk_cmpf) throw();
        static ER call_cre_mpf(ID mpfid, const t_cmpf* pk_cmpf) throw();
        static ER call_del_mpf(ID mpfid) throw();
        static ER call_rel_mpf(ID mpfid, VP blk) throw();
        static ER call_get_mpf(ID mpfid, VP* p_blk) throw();
        static ER call_pget_mpf(ID mpfid, VP* p_blk) throw();
        static ER call_tget_mpf(ID mpfid, VP* p_blk, TMO tmout) throw();
        static ER call_ref_mpf(ID mpfid, t_rmpf* pk_rmpf) throw();
        static ER call_set_tim(SYSTIM* p_systim) throw();
        static ER call_set_tim(const SYSTIM* p_systim) throw();
        static ER call_get_tim(SYSTIM* p_systim) throw();
        static ER call_cre_cyc(ID cycid, t_ccyc* pk_ccyc) throw();
        static ER call_cre_cyc(ID cycid, const t_ccyc* pk_ccyc) throw();
        static ER call_del_cyc(ID cycid) throw();
        static ER call_sta_cyc(ID cycid) throw();
        static ER call_stp_cyc(ID cycid) throw();
        static ER call_ref_cyc(ID cycid, t_rcyc* pk_rcyc) throw();
        static ER call_rot_rdq(PRI tskpri) throw();
        static ER call_get_tid(ID* p_tskid) throw();
        static ER call_loc_cpu() throw();
        static ER call_unl_cpu() throw();
        static ER call_dis_dsp() throw();
        static ER call_ena_dsp() throw();
        static bool call_sns_ctx() throw();
        static bool call_sns_loc() throw();
        static bool call_sns_dsp() throw();
        static bool call_sns_dpn() throw();
        static ER call_ref_sys(t_rsys* pk_rsys) throw();
        static ER call_def_inh(INHNO inhno, t_dinh* pk_dinh) throw();
        static ER call_def_inh(INHNO inhno, const t_dinh* pk_dinh) throw();
        static ER call_cre_isr(ID isrid, t_cisr* pk_cisr) throw();
        static ER call_cre_isr(ID isrid, const t_cisr* pk_cisr) throw();
        static ER call_del_isr(ID isrid) throw();
        static ER call_ref_isr(ID isrid, t_risr* pk_risr) throw();
        static ER call_dis_int(INTNO intno) throw();
        static ER call_ena_int(INTNO intno) throw();
        static ER call_chg_ims(IMS ims) throw();
        static ER call_get_ims(IMS* P_ims) throw();
        static ER call_def_exc(EXCNO excno, t_dexc* pk_dexc) throw();
        static ER call_def_exc(EXCNO excno, const t_dexc* pk_dexc) throw();
        static ER call_ref_cfg(t_rcfg* pk_rcfg) throw();
        static ER call_ref_ver(t_rver* pk_rver) throw();
        static ER call_iact_tsk(ID tskid) throw();
        static ER call_iwup_tsk(ID tskid) throw();
        static ER call_irel_wai(ID tskid) throw();
        static ER call_iras_tex(ID tskid, TEXPTN rasptn) throw();
        static ER call_isig_sem(ID semid) throw();
        static ER call_iset_flg(ID flgid, FLGPTN setptn) throw();
        static ER call_ipsnd_dtq(ID dtqid, VP_INT data) throw();
        static ER call_ifsnd_dtq(ID dtqid, VP_INT data) throw();
        static ER call_irot_rdq(PRI tskpri) throw();
        static ER call_iget_tid(ID* p_tskid) throw();
        static ER call_iloc_cpu() throw();
        static ER call_iunl_cpu() throw();
        static ER call_isig_tim() throw();
        static ER call_cre_mtx(ID mtxid, t_cmtx* pk_cmtx) throw();
        static ER call_cre_mtx(ID mtxid, const t_cmtx* pk_cmtx) throw();
        static ER call_del_mtx(ID mtxid) throw();
        static ER call_unl_mtx(ID mtxid) throw();
        static ER call_loc_mtx(ID mtxid) throw();
        static ER call_ploc_mtx(ID mtxid) throw();
        static ER call_tloc_mtx(ID mtxid, TMO tmout) throw();
        static ER call_ref_mtx(ID mtxid, t_rmtx* pk_rmtx) throw();
        static ER call_cre_mbf(ID mbfid, t_cmbf* pk_cmbf) throw();
        static ER call_cre_mbf(ID mbfid, const t_cmbf* pk_cmbf) throw();
        static ER call_del_mbf(ID mbfid) throw();
        static ER call_snd_mbf(ID mbfid, const void* msg, UINT msgsz) throw();
        static ER call_psnd_mbf(ID mbfid, const void* msg, UINT msgsz) throw();
        static ER call_tsnd_mbf(ID mbfid, const void* msg, UINT msgsz, TMO tmout) throw();
        static ER_UINT call_rcv_mbf(ID mbfid, void* msg) throw();
        static ER_UINT call_prcv_mbf(ID mbfid, void* msg) throw();
        static ER_UINT call_trcv_mbf(ID mbfid, void* msg, TMO tmout) throw();
        static ER call_ref_mbf(ID mbfid, t_rmbf* pk_rmbf) throw();
        static ER call_cre_por(ID porid, t_cpor* pk_cpor) throw();
        static ER call_cre_por(ID porid, const t_cpor* pk_cpor) throw();
        static ER call_del_por(ID porid) throw();
        static ER_UINT call_cal_por(ID porid, RDVPTN calptn, void* msg, UINT cmsgsz) throw();
        static ER_UINT call_tcal_por(ID porid, RDVPTN calptn, void* msg, UINT cmsgsz, TMO tmout) throw();
        static ER_UINT call_acp_por(ID porid, RDVPTN acpptn, RDVNO* p_rdvno, void* msg) throw();
        static ER_UINT call_pacp_por(ID porid, RDVPTN acpptn, RDVNO* p_rdvno, void* msg) throw();
        static ER_UINT call_tacp_por(ID porid, RDVPTN acpptn, RDVNO* p_rdvno, void* msg, TMO tmout) throw();
        static ER call_fwd_por(ID porid, RDVPTN acpptn, RDVNO rdvno, const void* msg, UINT cmsgsz) throw();
        static ER call_rpl_rdv(RDVNO rdvno, const void* msg, UINT rmsgsz) throw();
        static ER call_ref_por(ID porid, t_rpor* pk_rpor) throw();
        static ER call_ref_rdv(RDVNO rdvid, t_rrdv* pk_rrdv) throw();
        static ER call_cre_mpl(ID mplid, t_cmpl* pk_cmpl) throw();
        static ER call_cre_mpl(ID mplid, const t_cmpl* pk_cmpl) throw();
        static ER call_del_mpl(ID mplid) throw();
        static ER call_rel_mpl(ID mplid, VP blk) throw();
        static ER call_get_mpl(ID mplid, UINT blksz, VP* p_blk) throw();
        static ER call_pget_mpl(ID mplid, UINT blksz, VP* p_blk) throw();
        static ER call_tget_mpl(ID mplid, UINT blksz, VP* p_blk, TMO tmout) throw();
        static ER call_ref_mpl(ID mplid, t_rmpl* pk_rmpl) throw();
        static ER call_cre_alm(ID almid, t_calm* pk_calm) throw();
        static ER call_cre_alm(ID almid, const t_calm* pk_calm) throw();
        static ER call_del_alm(ID almid) throw();
        static ER call_sta_alm(ID almid, RELTIM almtim) throw();
        static ER call_stp_alm(ID almid) throw();
        static ER call_ref_alm(ID almid, t_ralm* pk_ralm) throw();
        static ER call_def_ovr(t_dovr* pk_dovr) throw();
        static ER call_def_ovr(const t_dovr* pk_dovr) throw();
        static ER call_sta_ovr(ID tskid, OVRTIM ovrtim) throw();
        static ER call_stp_ovr(ID tskid) throw();
        static ER call_ref_ovr(ID tskid, t_rovr* pk_rovr) throw();
        static ER_ID call_acre_tsk(t_ctsk* pk_ctsk) throw();
        static ER_ID call_acre_tsk(const t_ctsk* pk_ctsk) throw();
        static ER_ID call_acre_sem(t_csem* pk_csem) throw();
        static ER_ID call_acre_sem(const t_csem* pk_csem) throw();
        static ER_ID call_acre_flg(t_cflg* pk_cflg) throw();
        static ER_ID call_acre_flg(const t_cflg* pk_cflg) throw();
        static ER_ID call_acre_dtq(t_cdtq* pk_cdtq) throw();
        static ER_ID call_acre_dtq(const t_cdtq* pk_cdtq) throw();
        static ER_ID call_acre_mbx(t_cmbx* pk_cmbx) throw();
        static ER_ID call_acre_mbx(const t_cmbx* pk_cmbx) throw();
        static ER_ID call_acre_mtx(t_cmtx* pk_cmtx) throw();
        static ER_ID call_acre_mtx(const t_cmtx* pk_cmtx) throw();
        static ER_ID call_acre_mbf(t_cmbf* pk_cmbf) throw();
        static ER_ID call_acre_mbf(const t_cmbf* pk_cmbf) throw();
        static ER_ID call_acre_por(t_cpor* pk_cpor) throw();
        static ER_ID call_acre_por(const t_cpor* pk_cpor) throw();
        static ER_ID call_acre_mpf(t_cmpf* pk_cmpf) throw();
        static ER_ID call_acre_mpf(const t_cmpf* pk_cmpf) throw();
        static ER_ID call_acre_mpl(t_cmpl* pk_cmpl) throw();
        static ER_ID call_acre_mpl(const t_cmpl* pk_cmpl) throw();
        static ER_ID call_acre_cyc(t_ccyc* pk_ccyc) throw();
        static ER_ID call_acre_cyc(const t_ccyc* pk_ccyc) throw();
        static ER_ID call_acre_alm(t_calm* pk_calm) throw();
        static ER_ID call_acre_alm(const t_calm* pk_calm) throw();
        static ER_ID call_acre_isr(t_cisr* pk_cisr) throw();
        static ER_ID call_acre_isr(const t_cisr* pk_cisr) throw();
        static bool call_vxsns_ctx(VP_INT exinf) throw();
        static bool call_vxsns_loc(VP_INT exinf) throw();
        static bool call_vxsns_dsp(VP_INT exinf) throw();
        static bool call_vxsns_dpn(VP_INT exinf) throw();
        static bool call_vxsns_tex(VP_INT exinf) throw();
        static bool call_vsns_ini() throw();
        static ER call_vxget_tim(SYSUTIM* p_sysutim) throw();
        static ER call_def_svc(FN fncd, t_dsvc* pk_dsvc) throw();
        static ER call_def_svc(FN fncd, const t_dsvc* pk_dsvc) throw();
        static ER_UINT call_cal_svc(FN fncd) throw();
        static ER_UINT call_cal_svc(FN fncd, VP_INT par1) throw();
        static ER_UINT call_cal_svc(FN fncd, VP_INT par1, VP_INT par2) throw();
        static ER_UINT call_cal_svc(FN fncd, VP_INT par1, VP_INT par2, VP_INT par3) throw();
        static ER_UINT call_cal_svc(FN fncd, VP_INT par1, VP_INT par2, VP_INT par3, VP_INT par4) throw();
        static ER_UINT call_cal_svc(FN fncd, VP_INT par1, VP_INT par2, VP_INT par3, VP_INT par4, VP_INT par5) throw();
    };

    inline ER outline_stub::stub_cre_tsk(ID tskid, t_ctsk* pk_ctsk)
    {
        return call_cre_tsk(tskid, pk_ctsk);
    }
    inline ER outline_stub::stub_cre_tsk(ID tskid, const t_ctsk* pk_ctsk)
    {
        return call_cre_tsk(tskid, pk_ctsk);
    }
    inline ER outline_stub::stub_del_tsk(ID tskid)
    {
        return call_del_tsk(tskid);
    }
    inline ER outline_stub::stub_act_tsk(ID tskid)
    {
        return call_act_tsk(tskid);
    }
    inline ER_UINT outline_stub::stub_can_act(ID tskid)
    {
        return call_can_act(tskid);
    }

    inline ER outline_stub::stub_sta_tsk(ID tskid, VP_INT stacd)
    {
        return call_sta_tsk(tskid, stacd);
    }
    inline void outline_stub::stub_ext_tsk()
    {
        call_ext_tsk();
    }
    inline void outline_stub::stub_exd_tsk()
    {
        call_exd_tsk();
    }
    inline ER outline_stub::stub_ter_tsk(ID tskid)
    {
        return call_ter_tsk(tskid);
    }
    inline ER outline_stub::stub_chg_pri(ID tskid, PRI tskpri)
    {
        return call_chg_pri(tskid, tskpri);
    }
    inline ER outline_stub::stub_get_pri(ID tskid, PRI* p_tskpri)
    {
        return call_get_pri(tskid, p_tskpri);
    }
    inline ER outline_stub::stub_ref_tsk(ID tskid, t_rtsk* pk_rtsk)
    {
        return call_ref_tsk(tskid, pk_rtsk);
    }
    inline ER outline_stub::stub_ref_tst(ID tskid, t_rtst* pk_rtst)
    {
        return call_ref_tst(tskid, pk_rtst);
    }

    inline ER outline_stub::stub_slp_tsk()
    {
        return call_slp_tsk();
    }
    inline ER outline_stub::stub_tslp_tsk(TMO tmout)
    {
        return call_tslp_tsk(tmout);
    }
    inline ER outline_stub::stub_wup_tsk(ID tskid)
    {
        return call_wup_tsk(tskid);
    }
    inline ER_UINT outline_stub::stub_can_wup(ID tskid)
    {
        return call_can_wup(tskid);
    }
    inline ER outline_stub::stub_rel_wai(ID tskid)
    {
        return call_rel_wai(tskid);
    }
    inline ER outline_stub::stub_sus_tsk(ID tskid)
    {
        return call_sus_tsk(tskid);
    }
    inline ER outline_stub::stub_rsm_tsk(ID tskid)
    {
        return call_rsm_tsk(tskid);
    }
    inline ER outline_stub::stub_frsm_tsk(ID tskid)
    {
        return call_frsm_tsk(tskid);
    }
    inline ER outline_stub::stub_dly_tsk(RELTIM dlytim)
    {
        return call_dly_tsk(dlytim);
    }

    inline ER outline_stub::stub_def_tex(ID tskid, t_dtex* pk_dtex)
    {
        return call_def_tex(tskid, pk_dtex);
    }
    inline ER outline_stub::stub_def_tex(ID tskid, const t_dtex* pk_dtex)
    {
        return call_def_tex(tskid, pk_dtex);
    }
    inline ER outline_stub::stub_ras_tex(ID tskid, TEXPTN rasptn)
    {
        return call_ras_tex(tskid, rasptn);
    }
    inline ER outline_stub::stub_dis_tex()
    {
        return call_dis_tex();
    }
    inline ER outline_stub::stub_ena_tex()
    {
        return call_ena_tex();
    }
    inline bool outline_stub::stub_sns_tex()
    {
        return call_sns_tex();
    }
    inline ER outline_stub::stub_ref_tex(ID tskid, t_rtex* pk_rtex)
    {
        return call_ref_tex(tskid, pk_rtex);
    }

    inline ER outline_stub::stub_cre_sem(ID semid, t_csem* pk_csem)
    {
        return call_cre_sem(semid, pk_csem);
    }
    inline ER outline_stub::stub_cre_sem(ID semid, const t_csem* pk_csem)
    {
        return call_cre_sem(semid, pk_csem);
    }
    inline ER outline_stub::stub_del_sem(ID semid)
    {
        return call_del_sem(semid);
    }
    inline ER outline_stub::stub_sig_sem(ID semid)
    {
        return call_sig_sem(semid);
    }
    inline ER outline_stub::stub_wai_sem(ID semid)
    {
        return call_wai_sem(semid);
    }
    inline ER outline_stub::stub_pol_sem(ID semid)
    {
        return call_pol_sem(semid);
    }
    inline ER outline_stub::stub_twai_sem(ID semid, TMO tmout)
    {
        return call_twai_sem(semid, tmout);
    }
    inline ER outline_stub::stub_ref_sem(ID semid, t_rsem* pk_rsem)
    {
        return call_ref_sem(semid, pk_rsem);
    }

    inline ER outline_stub::stub_cre_flg(ID flgid, t_cflg* pk_cflg)
    {
        return call_cre_flg(flgid, pk_cflg);
    }
    inline ER outline_stub::stub_cre_flg(ID flgid, const t_cflg* pk_cflg)
    {
        return call_cre_flg(flgid, pk_cflg);
    }
    inline ER outline_stub::stub_del_flg(ID flgid)
    {
        return call_del_flg(flgid);
    }
    inline ER outline_stub::stub_set_flg(ID flgid, FLGPTN setptn)
    {
        return call_set_flg(flgid, setptn);
    }
    inline ER outline_stub::stub_clr_flg(ID flgid, FLGPTN clrptn)
    {
        return call_clr_flg(flgid, clrptn);
    }
    inline ER outline_stub::stub_wai_flg(ID flgid, FLGPTN waiptn, MODE wfmode, FLGPTN* p_flgptn)
    {
        return call_wai_flg(flgid, waiptn, wfmode, p_flgptn);
    }
    inline ER outline_stub::stub_pol_flg(ID flgid, FLGPTN waiptn, MODE wfmode, FLGPTN* p_flgptn)
    {
        return call_pol_flg(flgid, waiptn, wfmode, p_flgptn);
    }
    inline ER outline_stub::stub_twai_flg(ID flgid, FLGPTN waiptn, MODE wfmode, FLGPTN* p_flgptn, TMO tmout)
    {
        return call_twai_flg(flgid, waiptn, wfmode, p_flgptn, tmout);
    }
    inline ER outline_stub::stub_ref_flg(ID flgid, t_rflg* pk_rflg)
    {
        return call_ref_flg(flgid, pk_rflg);
    }

    inline ER outline_stub::stub_cre_dtq(ID dtqid, t_cdtq* pk_cdtq)
    {
        return call_cre_dtq(dtqid, pk_cdtq);
    }
    inline ER outline_stub::stub_cre_dtq(ID dtqid, const t_cdtq* pk_cdtq)
    {
        return call_cre_dtq(dtqid, pk_cdtq);
    }
    inline ER outline_stub::stub_del_dtq(ID dtqid)
    {
        return call_del_dtq(dtqid);
    }
    inline ER outline_stub::stub_snd_dtq(ID dtqid, VP_INT data)
    {
        return call_snd_dtq(dtqid, data);
    }
    inline ER outline_stub::stub_psnd_dtq(ID dtqid, VP_INT data)
    {
        return call_psnd_dtq(dtqid, data);
    }
    inline ER outline_stub::stub_tsnd_dtq(ID dtqid, VP_INT data, TMO tmout)
    {
        return call_tsnd_dtq(dtqid, data, tmout);
    }
    inline ER outline_stub::stub_fsnd_dtq(ID dtqid, VP_INT data)
    {
        return call_fsnd_dtq(dtqid, data);
    }
    inline ER outline_stub::stub_rcv_dtq(ID dtqid, VP_INT* p_data)
    {
        return call_rcv_dtq(dtqid, p_data);
    }
    inline ER outline_stub::stub_prcv_dtq(ID dtqid, VP_INT* p_data)
    {
        return call_prcv_dtq(dtqid, p_data);
    }
    inline ER outline_stub::stub_trcv_dtq(ID dtqid, VP_INT* p_data, TMO tmout)
    {
        return call_trcv_dtq(dtqid, p_data, tmout);
    }
    inline ER outline_stub::stub_ref_dtq(ID dtqid, t_rdtq* pk_rdtq)
    {
        return call_ref_dtq(dtqid, pk_rdtq);
    }

    inline ER outline_stub::stub_cre_mbx(ID mbxid, t_cmbx* pk_cmbx)
    {
        return call_cre_mbx(mbxid, pk_cmbx);
    }
    inline ER outline_stub::stub_cre_mbx(ID mbxid, const t_cmbx* pk_cmbx)
    {
        return call_cre_mbx(mbxid, pk_cmbx);
    }
    inline ER outline_stub::stub_del_mbx(ID mbxid)
    {
        return call_del_mbx(mbxid);
    }
    inline ER outline_stub::stub_snd_mbx(ID mbxid, T_MSG* pk_msg)
    {
        return call_snd_mbx(mbxid, pk_msg);
    }
    inline ER outline_stub::stub_rcv_mbx(ID mbxid, T_MSG** ppk_msg)
    {
        return call_rcv_mbx(mbxid, ppk_msg);
    }
    inline ER outline_stub::stub_prcv_mbx(ID mbxid, T_MSG** ppk_msg)
    {
        return call_prcv_mbx(mbxid, ppk_msg);
    }
    inline ER outline_stub::stub_trcv_mbx(ID mbxid, T_MSG** ppk_msg, TMO tmout)
    {
        return call_trcv_mbx(mbxid, ppk_msg, tmout);
    }
    inline ER outline_stub::stub_ref_mbx(ID mbxid, t_rmbx* pk_rmbx)
    {
        return call_ref_mbx(mbxid, pk_rmbx);
    }

    inline ER outline_stub::stub_cre_mpf(ID mpfid, t_cmpf* pk_cmpf)
    {
        return call_cre_mpf(mpfid, pk_cmpf);
    }
    inline ER outline_stub::stub_cre_mpf(ID mpfid, const t_cmpf* pk_cmpf)
    {
        return call_cre_mpf(mpfid, pk_cmpf);
    }
    inline ER outline_stub::stub_del_mpf(ID mpfid)
    {
        return call_del_mpf(mpfid);
    }
    inline ER outline_stub::stub_rel_mpf(ID mpfid, VP blk)
    {
        return call_rel_mpf(mpfid, blk);
    }
    inline ER outline_stub::stub_get_mpf(ID mpfid, VP* p_blk)
    {
        return call_get_mpf(mpfid, p_blk);
    }
    inline ER outline_stub::stub_pget_mpf(ID mpfid, VP* p_blk)
    {
        return call_pget_mpf(mpfid, p_blk);
    }
    inline ER outline_stub::stub_tget_mpf(ID mpfid, VP* p_blk, TMO tmout)
    {
        return call_tget_mpf(mpfid, p_blk, tmout);
    }
    inline ER outline_stub::stub_ref_mpf(ID mpfid, t_rmpf* pk_rmpf)
    {
        return call_ref_mpf(mpfid, pk_rmpf);
    }

    inline ER outline_stub::stub_set_tim(SYSTIM* p_systim)
    {
        return call_set_tim(p_systim);
    }
    inline ER outline_stub::stub_set_tim(const SYSTIM* p_systim)
    {
        return call_set_tim(p_systim);
    }
    inline ER outline_stub::stub_get_tim(SYSTIM* p_systim)
    {
        return call_get_tim(p_systim);
    }

    inline ER outline_stub::stub_cre_cyc(ID cycid, t_ccyc* pk_ccyc)
    {
        return call_cre_cyc(cycid, pk_ccyc);
    }
    inline ER outline_stub::stub_cre_cyc(ID cycid, const t_ccyc* pk_ccyc)
    {
        return call_cre_cyc(cycid, pk_ccyc);
    }
    inline ER outline_stub::stub_del_cyc(ID cycid)
    {
        return call_del_cyc(cycid);
    }
    inline ER outline_stub::stub_sta_cyc(ID cycid)
    {
        return call_sta_cyc(cycid);
    }
    inline ER outline_stub::stub_stp_cyc(ID cycid)
    {
        return call_stp_cyc(cycid);
    }
    inline ER outline_stub::stub_ref_cyc(ID cycid, t_rcyc* pk_rcyc)
    {
        return call_ref_cyc(cycid, pk_rcyc);
    }

    inline ER outline_stub::stub_rot_rdq(PRI tskpri)
    {
        return call_rot_rdq(tskpri);
    }
    inline ER outline_stub::stub_get_tid(ID* p_tskid)
    {
        return call_get_tid(p_tskid);
    }
    inline ER outline_stub::stub_loc_cpu()
    {
        return call_loc_cpu();
    }
    inline ER outline_stub::stub_unl_cpu()
    {
        return call_unl_cpu();
    }
    inline ER outline_stub::stub_dis_dsp()
    {
        return call_dis_dsp();
    }
    inline ER outline_stub::stub_ena_dsp()
    {
        return call_ena_dsp();
    }
    inline bool outline_stub::stub_sns_ctx()
    {
        return call_sns_ctx();
    }
    inline bool outline_stub::stub_sns_loc()
    {
        return call_sns_loc();
    }
    inline bool outline_stub::stub_sns_dsp()
    {
        return call_sns_dsp();
    }
    inline bool outline_stub::stub_sns_dpn()
    {
        return call_sns_dpn();
    }
    inline ER outline_stub::stub_ref_sys(t_rsys* pk_rsys)
    {
        return call_ref_sys(pk_rsys);
    }

    inline ER outline_stub::stub_def_inh(INHNO inhno, t_dinh* pk_dinh)
    {
        return call_def_inh(inhno, pk_dinh);
    }
    inline ER outline_stub::stub_def_inh(INHNO inhno, const t_dinh* pk_dinh)
    {
        return call_def_inh(inhno, pk_dinh);
    }
    inline ER outline_stub::stub_cre_isr(ID isrid, t_cisr* pk_cisr)
    {
        return call_cre_isr(isrid, pk_cisr);
    }
    inline ER outline_stub::stub_cre_isr(ID isrid, const t_cisr* pk_cisr)
    {
        return call_cre_isr(isrid, pk_cisr);
    }
    inline ER outline_stub::stub_del_isr(ID isrid)
    {
        return call_del_isr(isrid);
    }
    inline ER outline_stub::stub_ref_isr(ID isrid, t_risr* pk_risr)
    {
        return call_ref_isr(isrid, pk_risr);
    }
    inline ER outline_stub::stub_dis_int(INTNO intno)
    {
        return call_dis_int(intno);
    }
    inline ER outline_stub::stub_ena_int(INTNO intno)
    {
        return call_ena_int(intno);
    }
    inline ER outline_stub::stub_chg_ims(IMS ims)
    {
        return call_chg_ims(ims);
    }
    inline ER outline_stub::stub_get_ims(IMS* p_ims)
    {
        return call_get_ims(p_ims);
    }

    inline ER outline_stub::stub_def_svc(FN fncd, t_dsvc* pk_dsvc)
    {
        return call_def_svc(fncd, pk_dsvc);
    }
    inline ER outline_stub::stub_def_svc(FN fncd, const t_dsvc* pk_dsvc)
    {
        return call_def_svc(fncd, pk_dsvc);
    }
    inline ER outline_stub::stub_def_exc(EXCNO excno, t_dexc* pk_dexc)
    {
        return call_def_exc(excno, pk_dexc);
    }
    inline ER outline_stub::stub_def_exc(EXCNO excno, const t_dexc* pk_dexc)
    {
        return call_def_exc(excno, pk_dexc);
    }
    inline ER outline_stub::stub_ref_cfg(t_rcfg* pk_rcfg)
    {
        return call_ref_cfg(pk_rcfg);
    }
    inline ER outline_stub::stub_ref_ver(t_rver* pk_rver)
    {
        return call_ref_ver(pk_rver);
    }

    inline ER outline_stub::stub_iact_tsk(ID tskid)
    {
        return call_iact_tsk(tskid);
    }
    inline ER outline_stub::stub_iwup_tsk(ID tskid)
    {
        return call_iwup_tsk(tskid);
    }
    inline ER outline_stub::stub_irel_wai(ID tskid)
    {
        return call_irel_wai(tskid);
    }
    inline ER outline_stub::stub_iras_tex(ID tskid, TEXPTN rasptn)
    {
        return call_iras_tex(tskid, rasptn);
    }
    inline ER outline_stub::stub_isig_sem(ID semid)
    {
        return call_isig_sem(semid);
    }
    inline ER outline_stub::stub_iset_flg(ID flgid, FLGPTN setptn)
    {
        return call_iset_flg(flgid, setptn);
    }
    inline ER outline_stub::stub_ipsnd_dtq(ID dtqid, VP_INT data)
    {
        return call_ipsnd_dtq(dtqid, data);
    }
    inline ER outline_stub::stub_ifsnd_dtq(ID dtqid, VP_INT data)
    {
        return call_ifsnd_dtq(dtqid, data);
    }
    inline ER outline_stub::stub_irot_rdq(PRI tskpri)
    {
        return call_irot_rdq(tskpri);
    }
    inline ER outline_stub::stub_iget_tid(ID* p_tskid)
    {
        return call_iget_tid(p_tskid);
    }
    inline ER outline_stub::stub_iloc_cpu()
    {
        return call_iloc_cpu();
    }
    inline ER outline_stub::stub_iunl_cpu()
    {
        return call_iunl_cpu();
    }
    inline ER outline_stub::stub_isig_tim()
    {
        return call_isig_tim();
    }

    inline ER outline_stub::stub_cre_mtx(ID mtxid, t_cmtx* pk_cmtx)
    {
        return call_cre_mtx(mtxid, pk_cmtx);
    }
    inline ER outline_stub::stub_cre_mtx(ID mtxid, const t_cmtx* pk_cmtx)
    {
        return call_cre_mtx(mtxid, pk_cmtx);
    }
    inline ER outline_stub::stub_del_mtx(ID mtxid)
    {
        return call_del_mtx(mtxid);
    }
    inline ER outline_stub::stub_unl_mtx(ID mtxid)
    {
        return call_unl_mtx(mtxid);
    }
    inline ER outline_stub::stub_loc_mtx(ID mtxid)
    {
        return call_loc_mtx(mtxid);
    }
    inline ER outline_stub::stub_ploc_mtx(ID mtxid)
    {
        return call_ploc_mtx(mtxid);
    }
    inline ER outline_stub::stub_tloc_mtx(ID mtxid, TMO tmout)
    {
        return call_tloc_mtx(mtxid, tmout);
    }
    inline ER outline_stub::stub_ref_mtx(ID mtxid, t_rmtx* pk_rmtx)
    {
        return call_ref_mtx(mtxid, pk_rmtx);
    }

    inline ER outline_stub::stub_cre_mbf(ID mbfid, t_cmbf* pk_cmbf)
    {
        return call_cre_mbf(mbfid, pk_cmbf);
    }
    inline ER outline_stub::stub_cre_mbf(ID mbfid, const t_cmbf* pk_cmbf)
    {
        return call_cre_mbf(mbfid, pk_cmbf);
    }
    inline ER outline_stub::stub_del_mbf(ID mbfid)
    {
        return call_del_mbf(mbfid);
    }
    inline ER outline_stub::stub_snd_mbf(ID mbfid, const void* msg, UINT msgsz)
    {
        return call_snd_mbf(mbfid, const_cast<void*>(msg), msgsz);
    }
    inline ER outline_stub::stub_psnd_mbf(ID mbfid, const void* msg, UINT msgsz)
    {
        return call_psnd_mbf(mbfid, const_cast<void*>(msg), msgsz);
    }
    inline ER outline_stub::stub_tsnd_mbf(ID mbfid, const void* msg, UINT msgsz, TMO tmout)
    {
        return call_tsnd_mbf(mbfid, const_cast<void*>(msg), msgsz, tmout);
    }
    inline ER_UINT outline_stub::stub_rcv_mbf(ID mbfid, void* msg)
    {
        return call_rcv_mbf(mbfid, msg);
    }
    inline ER_UINT outline_stub::stub_prcv_mbf(ID mbfid, void* msg)
    {
        return call_prcv_mbf(mbfid, msg);
    }
    inline ER_UINT outline_stub::stub_trcv_mbf(ID mbfid, void* msg, TMO tmout)
    {
        return call_trcv_mbf(mbfid, msg, tmout);
    }
    inline ER outline_stub::stub_ref_mbf(ID mbfid, t_rmbf* pk_rmbf)
    {
        return call_ref_mbf(mbfid, pk_rmbf);
    }

    inline ER outline_stub::stub_cre_por(ID porid, t_cpor* pk_cpor)
    {
        return call_cre_por(porid, pk_cpor);
    }
    inline ER outline_stub::stub_cre_por(ID porid, const t_cpor* pk_cpor)
    {
        return call_cre_por(porid, pk_cpor);
    }
    inline ER outline_stub::stub_del_por(ID porid)
    {
        return call_del_por(porid);
    }
    inline ER_UINT outline_stub::stub_cal_por(ID porid, RDVPTN calptn, void* msg, UINT cmsgsz)
    {
        return call_cal_por(porid, calptn, msg, cmsgsz);
    }
    inline ER_UINT outline_stub::stub_tcal_por(ID porid, RDVPTN calptn, void* msg, UINT cmsgsz, TMO tmout)
    {
        return call_tcal_por(porid, calptn, msg, cmsgsz, tmout);
    }
    inline ER_UINT outline_stub::stub_acp_por(ID porid, RDVPTN acpptn, RDVNO* p_rdvno, void* msg)
    {
        return call_acp_por(porid, acpptn, p_rdvno, msg);
    }
    inline ER_UINT outline_stub::stub_pacp_por(ID porid, RDVPTN acpptn, RDVNO* p_rdvno, void* msg)
    {
        return call_pacp_por(porid, acpptn, p_rdvno, msg);
    }
    inline ER_UINT outline_stub::stub_tacp_por(ID porid, RDVPTN acpptn, RDVNO* p_rdvno, void* msg, TMO tmout)
    {
        return call_tacp_por(porid, acpptn, p_rdvno, msg, tmout);
    }
    inline ER outline_stub::stub_fwd_por(ID porid, RDVPTN acpptn, RDVNO rdvno, const void* msg, UINT cmsgsz)
    {
        return call_fwd_por(porid, acpptn, rdvno, const_cast<void*>(msg), cmsgsz);
    }
    inline ER outline_stub::stub_rpl_rdv(RDVNO rdvno, const void* msg, UINT rmsgsz)
    {
        return call_rpl_rdv(rdvno, const_cast<void*>(msg), rmsgsz);
    }
    inline ER outline_stub::stub_ref_por(ID porid, t_rpor* pk_rpor)
    {
        return call_ref_por(porid, pk_rpor);
    }
    inline ER outline_stub::stub_ref_rdv(RDVNO rdvid, t_rrdv* pk_rrdv)
    {
        return call_ref_rdv(rdvid, pk_rrdv);
    }

    inline ER outline_stub::stub_cre_mpl(ID mplid, t_cmpl* pk_cmpl)
    {
        return call_cre_mpl(mplid, pk_cmpl);
    }
    inline ER outline_stub::stub_cre_mpl(ID mplid, const t_cmpl* pk_cmpl)
    {
        return call_cre_mpl(mplid, pk_cmpl);
    }
    inline ER outline_stub::stub_del_mpl(ID mplid)
    {
        return call_del_mpl(mplid);
    }
    inline ER outline_stub::stub_rel_mpl(ID mplid, VP blk)
    {
        return call_rel_mpl(mplid, blk);
    }
    inline ER outline_stub::stub_get_mpl(ID mplid, UINT blksz, VP* p_blk)
    {
        return call_get_mpl(mplid, blksz, p_blk);
    }
    inline ER outline_stub::stub_pget_mpl(ID mplid, UINT blksz, VP* p_blk)
    {
        return call_pget_mpl(mplid, blksz, p_blk);
    }
    inline ER outline_stub::stub_tget_mpl(ID mplid, UINT blksz, VP* p_blk, TMO tmout)
    {
        return call_tget_mpl(mplid, blksz, p_blk, tmout);
    }
    inline ER outline_stub::stub_ref_mpl(ID mplid, t_rmpl* pk_rmpl)
    {
        return call_ref_mpl(mplid, pk_rmpl);
    }

    inline ER outline_stub::stub_cre_alm(ID almid, t_calm* pk_calm)
    {
        return call_cre_alm(almid, pk_calm);
    }
    inline ER outline_stub::stub_cre_alm(ID almid, const t_calm* pk_calm)
    {
        return call_cre_alm(almid, pk_calm);
    }
    inline ER outline_stub::stub_del_alm(ID almid)
    {
        return call_del_alm(almid);
    }
    inline ER outline_stub::stub_sta_alm(ID almid, RELTIM almtim)
    {
        return call_sta_alm(almid, almtim);
    }
    inline ER outline_stub::stub_stp_alm(ID almid)
    {
        return call_stp_alm(almid);
    }
    inline ER outline_stub::stub_ref_alm(ID almid, t_ralm* pk_ralm)
    {
        return call_ref_alm(almid, pk_ralm);
    }

    inline ER outline_stub::stub_def_ovr(t_dovr* pk_dovr)
    {
        return call_def_ovr(pk_dovr);
    }
    inline ER outline_stub::stub_def_ovr(const t_dovr* pk_dovr)
    {
        return call_def_ovr(pk_dovr);
    }
    inline ER outline_stub::stub_sta_ovr(ID tskid, OVRTIM ovrtim)
    {
        return call_sta_ovr(tskid, ovrtim);
    }
    inline ER outline_stub::stub_stp_ovr(ID tskid)
    {
        return call_stp_ovr(tskid);
    }
    inline ER outline_stub::stub_ref_ovr(ID tskid, t_rovr* pk_rovr)
    {
        return call_ref_ovr(tskid, pk_rovr);
    }

    inline ER_ID outline_stub::stub_acre_tsk(t_ctsk* pk_ctsk)
    {
        return call_acre_tsk(pk_ctsk);
    }
    inline ER_ID outline_stub::stub_acre_tsk(const t_ctsk* pk_ctsk)
    {
        return call_acre_tsk(pk_ctsk);
    }
    inline ER_ID outline_stub::stub_acre_sem(t_csem* pk_csem)
    {
        return call_acre_sem(pk_csem);
    }
    inline ER_ID outline_stub::stub_acre_sem(const t_csem* pk_csem)
    {
        return call_acre_sem(pk_csem);
    }
    inline ER_ID outline_stub::stub_acre_flg(t_cflg* pk_cflg)
    {
        return call_acre_flg(pk_cflg);
    }
    inline ER_ID outline_stub::stub_acre_flg(const t_cflg* pk_cflg)
    {
        return call_acre_flg(pk_cflg);
    }
    inline ER_ID outline_stub::stub_acre_dtq(t_cdtq* pk_cdtq)
    {
        return call_acre_dtq(pk_cdtq);
    }
    inline ER_ID outline_stub::stub_acre_dtq(const t_cdtq* pk_cdtq)
    {
        return call_acre_dtq(pk_cdtq);
    }
    inline ER_ID outline_stub::stub_acre_mbx(t_cmbx* pk_cmbx)
    {
        return call_acre_mbx(pk_cmbx);
    }
    inline ER_ID outline_stub::stub_acre_mbx(const t_cmbx* pk_cmbx)
    {
        return call_acre_mbx(pk_cmbx);
    }
    inline ER_ID outline_stub::stub_acre_mtx(t_cmtx* pk_cmtx)
    {
        return call_acre_mtx(pk_cmtx);
    }
    inline ER_ID outline_stub::stub_acre_mtx(const t_cmtx* pk_cmtx)
    {
        return call_acre_mtx(pk_cmtx);
    }
    inline ER_ID outline_stub::stub_acre_mbf(t_cmbf* pk_cmbf)
    {
        return call_acre_mbf(pk_cmbf);
    }
    inline ER_ID outline_stub::stub_acre_mbf(const t_cmbf* pk_cmbf)
    {
        return call_acre_mbf(pk_cmbf);
    }
    inline ER_ID outline_stub::stub_acre_por(t_cpor* pk_cpor)
    {
        return call_acre_por(pk_cpor);
    }
    inline ER_ID outline_stub::stub_acre_por(const t_cpor* pk_cpor)
    {
        return call_acre_por(pk_cpor);
    }
    inline ER_ID outline_stub::stub_acre_mpf(t_cmpf* pk_cmpf)
    {
        return call_acre_mpf(pk_cmpf);
    }
    inline ER_ID outline_stub::stub_acre_mpf(const t_cmpf* pk_cmpf)
    {
        return call_acre_mpf(pk_cmpf);
    }
    inline ER_ID outline_stub::stub_acre_mpl(t_cmpl* pk_cmpl)
    {
        return call_acre_mpl(pk_cmpl);
    }
    inline ER_ID outline_stub::stub_acre_mpl(const t_cmpl* pk_cmpl)
    {
        return call_acre_mpl(pk_cmpl);
    }
    inline ER_ID outline_stub::stub_acre_cyc(t_ccyc* pk_ccyc)
    {
        return call_acre_cyc(pk_ccyc);
    }
    inline ER_ID outline_stub::stub_acre_cyc(const t_ccyc* pk_ccyc)
    {
        return call_acre_cyc(pk_ccyc);
    }
    inline ER_ID outline_stub::stub_acre_alm(t_calm* pk_calm)
    {
        return call_acre_alm(pk_calm);
    }
    inline ER_ID outline_stub::stub_acre_alm(const t_calm* pk_calm)
    {
        return call_acre_alm(pk_calm);
    }
    inline ER_ID outline_stub::stub_acre_isr(t_cisr* pk_cisr)
    {
        return call_acre_isr(pk_cisr);
    }
    inline ER_ID outline_stub::stub_acre_isr(const t_cisr* pk_cisr)
    {
        return call_acre_isr(pk_cisr);
    }

    inline bool outline_stub::stub_vxsns_ctx(VP_INT exinf)
    {
        return call_vxsns_ctx(exinf);
    }
    inline bool outline_stub::stub_vxsns_loc(VP_INT exinf)
    {
        return call_vxsns_loc(exinf);
    }
    inline bool outline_stub::stub_vxsns_dsp(VP_INT exinf)
    {
        return call_vxsns_dsp(exinf);
    }
    inline bool outline_stub::stub_vxsns_dpn(VP_INT exinf)
    {
        return call_vxsns_dpn(exinf);
    }
    inline bool outline_stub::stub_vxsns_tex(VP_INT exinf)
    {
        return call_vxsns_tex(exinf);
    }
    inline bool outline_stub::stub_vsns_ini()
    {
        return call_vsns_ini();
    }

    inline ER outline_stub::stub_vxget_tim(SYSUTIM* p_sysutim)
    {
        return call_vxget_tim(p_sysutim);
    }

    inline ER_UINT outline_stub::stub_cal_svc(FN fncd)
    {
        return call_cal_svc(fncd, 0, 0, 0, 0, 0);
    }
    inline ER_UINT outline_stub::stub_cal_svc(FN fncd, VP_INT par1)
    {
        return call_cal_svc(fncd, par1, 0, 0, 0, 0);
    }
    inline ER_UINT outline_stub::stub_cal_svc(FN fncd, VP_INT par1, VP_INT par2)
    {
        return call_cal_svc(fncd, par1, par2, 0, 0, 0);
    }
    inline ER_UINT outline_stub::stub_cal_svc(FN fncd, VP_INT par1, VP_INT par2, VP_INT par3)
    {
        return call_cal_svc(fncd, par1, par2, par3, 0, 0);
    }
    inline ER_UINT outline_stub::stub_cal_svc(FN fncd, VP_INT par1, VP_INT par2, VP_INT par3, VP_INT par4)
    {
        return call_cal_svc(fncd, par1, par2, par3, par4, 0);
    }
    inline ER_UINT outline_stub::stub_cal_svc(FN fncd, VP_INT par1, VP_INT par2, VP_INT par3, VP_INT par4, VP_INT par5)
    {
        return call_cal_svc(fncd, par1, par2, par3, par4, par5);
    }

}

#endif  // ! TOPPERS_OUTLINE_STUB_HPP_

---

• Copyright © 2004 by TAKAGI Nobuhisa
• 本ソフトウェアはTOPPERSライセンスに基づいて配布されています。
• TRONは"The Real-time Operating system Nucleus"の略称です。
• ITRONは"Industrial TRON"の略称です。
• μITRONは"Micro Industrial TRON"の略称です。
• TRON、ITRON、およびμITRONは、特定の商品ないしは商品群を指す名称ではありません。
• TOPPERSは"Toyohashi OPen Platform for Embedded Real-time Systems"の略称、JSPは"Just Standard Profile"の略称です。
• 本ページ中の商品名は，各社の商標または登録商標です。